no implicit 720p anymore - make this explicit

## Fixes
- Slow paste in prompt box: `execCommand("insertText")` is quadratic per
line in Chromium - now inserts the clipboard as a single text node
(linear)
- Model selector submenu not scrolling in focus mode: the modal's scroll
lock swallows wheel/touch on body-portaled panels - flyout now stops
propagation (same pattern as mention dropdown)

.claude/rules/testing.md

@@ -1,5 +1,25 @@
 # Testing
 
+## Database Fixture Tests
+
+- Live in-crate (e.g. `storyteller-web`'s omni_gen video pricing tests) and
+  use the `mysql_testing` crate (`crates/schema/database/mysql_testing`) for
+  guarded pools, schema setup, and account/session/wallet fixtures
+- They RUN BY DEFAULT with `cargo test -p storyteller-web` and from the IDE
+  (requires a local MySQL with an `artcraft_test` database). Machines/CI
+  without MySQL skip them via the off switch:
+  `SQLX_OFFLINE=true cargo test -p storyteller-web --features skip_database_tests`
+- They connect ONLY via `ARTCRAFT_TEST_DATABASE_URL` (default
+  `mysql://root:@localhost:3306/artcraft_test`); the guard panics on any
+  database whose name lacks "test", on `storyteller`/`artcraft`, and on
+  cloud hosts — see `mysql_testing/README.md`
+- Database tests run in PARALLEL: each test creates its own users, wallets,
+  and rows; schema setup single-flights via a MySQL named lock. Only tests
+  mutating shared/global state take
+  `mysql_testing::serial::acquire_serial_test_lock().await`
+- External providers must never be called: the harness stubs Kinovi with an
+  in-process HTTP server via `KINOVI_CUSTOM_API_HOST`/`KINOVI_CUSTOM_CDN_HOST`
+
 ## Running Tests
 
 - Most crates: `cargo test -p {crate_name}`

.sqlx/query-03919ba8286d18980ecaa0038df76f43f5388db0d3838181fa8f15f4cbb932af.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nUPDATE generic_inference_jobs\nSET\n  status = ?,\n  on_success_result_entity_type = ?,\n  on_success_result_entity_token = ?,\n  failure_reason = NULL,\n  internal_debugging_failure_reason = NULL,\n  success_execution_millis = ?,\n  success_inference_execution_millis = ?,\n  retry_at = NULL,\n  successfully_completed_at = NOW()\nWHERE token = ?\nAND status NOT IN ('complete_success', 'complete_failure')\n    ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": []
+  },
+  "hash": "03919ba8286d18980ecaa0038df76f43f5388db0d3838181fa8f15f4cbb932af"
+}

.sqlx/query-258ac40d3fab39f110e1e82d50e73542423bfe9a21f8127e6cd83214c1726e25.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nUPDATE generic_inference_jobs\nSET\n  status = ?,\n  assigned_worker = ?,\n  last_assigned_worker = ?,\n  assigned_cluster = ?,\n  first_started_at = NOW()\nWHERE token = ?\n    ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "258ac40d3fab39f110e1e82d50e73542423bfe9a21f8127e6cd83214c1726e25"
+}

.sqlx/query-62b3e2e058331a6819acd98c634b3bf2d10aa38d43b49ab69fb8637497beec2f.json

@@ -110,4 +110,4 @@
     ]
   },
   "hash": "62b3e2e058331a6819acd98c634b3bf2d10aa38d43b49ab69fb8637497beec2f"
-}
+}

.sqlx/query-6ca0fcdf495624cf347f612586868f6dea93f52d9f942a92dcd2b3e6aba7c63c.json

@@ -0,0 +1,36 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n  token as `job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken`,\n  maybe_prompt_token as `maybe_prompt_token: tokens::tokens::prompts::PromptToken`\nFROM generic_inference_jobs\nWHERE job_type = ?\nAND status = 'pending'\nORDER BY id ASC\nLIMIT 1\nFOR UPDATE SKIP LOCKED\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "maybe_prompt_token: tokens::tokens::prompts::PromptToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true
+    ]
+  },
+  "hash": "6ca0fcdf495624cf347f612586868f6dea93f52d9f942a92dcd2b3e6aba7c63c"
+}

.sqlx/query-96599b4854248d84188b092db84edb50dc5402bb7771fd8ea96a96ad43e732c0.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "MySQL",
+  "query": "\nUPDATE generic_inference_jobs\nSET\n  status = ?,\n  frontend_failure_category = ?,\n  failure_reason = ?,\n  internal_debugging_failure_reason = ?,\n  success_execution_millis = ?,\n  success_inference_execution_millis = ?\nWHERE token = ?\nAND status NOT IN ('complete_success', 'complete_failure')\n    ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "96599b4854248d84188b092db84edb50dc5402bb7771fd8ea96a96ad43e732c0"
+}

.sqlx/query-cd04f4f7b48ae9da53b6a210111f8e3edff94dee30263e22b45d5e29dbe9245a.json

@@ -176,4 +176,4 @@
     ]
   },
   "hash": "cd04f4f7b48ae9da53b6a210111f8e3edff94dee30263e22b45d5e29dbe9245a"
-}
+}

.sqlx/query-cf2794c87868e77dfaa45bdbe630ae276dbb8c2d041442ba465af0b7a6d61af6.json

@@ -99,4 +99,4 @@
     ]
   },
   "hash": "cf2794c87868e77dfaa45bdbe630ae276dbb8c2d041442ba465af0b7a6d61af6"
-}
+}

.sqlx/query-d88098343686ded52a71fc45a1b96d28ea3003975d6e7d20eee2022aa31d8189.json

@@ -9,4 +9,4 @@
     "nullable": []
   },
   "hash": "d88098343686ded52a71fc45a1b96d28ea3003975d6e7d20eee2022aa31d8189"
-}
+}

.sqlx/query-f1d41ad17cb01f5aef0ce2eea042ccb3e5e649365a0befaf0f46492b75523442.json

@@ -0,0 +1,124 @@
+{
+  "db_name": "MySQL",
+  "query": "\nSELECT\n  token as `job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken`,\n  status as `status: enums::common::job_status_plus::JobStatusPlus`,\n  job_type as `job_type: enums::by_table::generic_inference_jobs::inference_job_type::InferenceJobType`,\n  maybe_creator_user_token as `maybe_creator_user_token: tokens::tokens::users::UserToken`,\n  maybe_creator_anonymous_visitor_token as `maybe_creator_anonymous_visitor_token: tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken`,\n  creator_ip_address,\n  maybe_prompt_token as `maybe_prompt_token: tokens::tokens::prompts::PromptToken`,\n  maybe_debug_log_event_token as `maybe_debug_log_event_token: tokens::tokens::non_unique::debug_logs_event_token::DebugLogEventToken`,\n  platform_type as `maybe_platform_type: enums::common::platform_type::PlatformType`,\n  on_success_result_entity_token as `maybe_result_media_file_token: tokens::tokens::media_files::MediaFileToken`\nFROM generic_inference_jobs\nWHERE token = ?\nAND job_type IN ('artcraft_minimax_h3_turbo', 'artcraft_minimax_h3_ultra')\n    ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "job_token: tokens::tokens::generic_inference_jobs::InferenceJobToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | UNIQUE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 1,
+        "name": "status: enums::common::job_status_plus::JobStatusPlus",
+        "type_info": {
+          "type": "String",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | ENUM",
+          "char_set": 224,
+          "max_size": 76
+        }
+      },
+      {
+        "ordinal": 2,
+        "name": "job_type: enums::by_table::generic_inference_jobs::inference_job_type::InferenceJobType",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 3,
+        "name": "maybe_creator_user_token: tokens::tokens::users::UserToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 4,
+        "name": "maybe_creator_anonymous_visitor_token: tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 5,
+        "name": "creator_ip_address",
+        "type_info": {
+          "type": "VarString",
+          "flags": "NOT_NULL | MULTIPLE_KEY | BINARY | NO_DEFAULT_VALUE",
+          "char_set": 224,
+          "max_size": 160
+        }
+      },
+      {
+        "ordinal": 6,
+        "name": "maybe_prompt_token: tokens::tokens::prompts::PromptToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 7,
+        "name": "maybe_debug_log_event_token: tokens::tokens::non_unique::debug_logs_event_token::DebugLogEventToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      },
+      {
+        "ordinal": 8,
+        "name": "maybe_platform_type: enums::common::platform_type::PlatformType",
+        "type_info": {
+          "type": "VarString",
+          "flags": "BINARY",
+          "char_set": 224,
+          "max_size": 64
+        }
+      },
+      {
+        "ordinal": 9,
+        "name": "maybe_result_media_file_token: tokens::tokens::media_files::MediaFileToken",
+        "type_info": {
+          "type": "VarString",
+          "flags": "MULTIPLE_KEY | BINARY",
+          "char_set": 224,
+          "max_size": 128
+        }
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true,
+      true,
+      false,
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  "hash": "f1d41ad17cb01f5aef0ce2eea042ccb3e5e649365a0befaf0f46492b75523442"
+}

Cargo.lock

@@ -7363,6 +7363,22 @@ dependencies = [
  "workspace-build-acceleration",
 ]
 
+[[package]]
+name = "mysql_testing"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bcrypt",
+ "bucket_paths",
+ "chrono",
+ "enums",
+ "log",
+ "mysql_queries",
+ "sqlx",
+ "tokens",
+ "tokio",
+]
+
 [[package]]
 name = "mysqlclient-sys"
 version = "0.2.5"
@@ -11646,6 +11662,7 @@ dependencies = [
  "migration",
  "mimetypes",
  "mysql_queries",
+ "mysql_testing",
  "once_cell",
  "opaque_cursors",
  "pager",

Cargo.toml

@@ -120,6 +120,7 @@ members = [
   "crates/schema/database/elasticsearch_schema",
   "crates/schema/database/migration",
   "crates/schema/database/mysql_queries",
+  "crates/schema/database/mysql_testing",
   "crates/schema/database/redis_common",
   "crates/schema/database/redis_schema",
   "crates/schema/database/sqlite_tasks",
@@ -282,6 +283,7 @@ mimetypes = { path = "crates/lib/files/mimetypes" }
 muapi_client = { path = "crates/api_clients/muapi_client" }
 metrics = { path = "crates/lib/metrics" }
 mysql_queries = { path = "crates/schema/database/mysql_queries" }
+mysql_testing = { path = "crates/schema/database/mysql_testing" }
 pager = { path = "crates/lib/pager" }
 openai_sora_client = { path = "crates/api_clients/openai_sora_client" }
 primitives = { path = "crates/lib/data/primitives" }

_docs/pagescene_animations_handoff.md

@@ -0,0 +1,227 @@
+# PageScene Animations — Branch Handoff
+
+Branch: `frontend/pagescene-animations` (forked from `main` @ `6329045350`, 2026-08-04).
+Everything below is TypeScript-typechecked per-lib (`tsc -p <lib>/tsconfig.lib.json`); runtime
+verification status is tracked in the checklist at the bottom. Drag-and-drop has had one manual
+pass (confirmed working); most other surfaces have not been launched.
+
+## What this branch does
+
+Makes skeletal animations a first-class asset in the 3D editor (pagescene): browse them in the
+asset drawer, drag them onto characters or the timeline with live rig-compatibility feedback,
+play clips baked into uploaded models, preview animations everywhere models are previewed, and
+upload Mixamo FBX files (with or without mesh) end to end.
+
+## Commit map
+
+| Commit       | What                                                                    |
+|--------------|-------------------------------------------------------------------------|
+| `7af3fb9856` | Animations tab in AssetModal; AnimationsDrawer retired                   |
+| `1fcbc55780` | Pointer drag-and-drop with live rig-compatibility badge                  |
+| `79d7ade8bc` | Baked-in clips on the timeline (+ clip-row eligibility widened)          |
+| `142279414e` | Animation dropdown in Viewer3D + upload preview                          |
+| `913905308e` | Clip fixes: vanishing character, 1 s strips, select-to-delete, undo      |
+| `60251104e3` | FBX accepted at the picker, converted to GLB in-browser                  |
+| `0942ec4804` | Nx tsconfig references for the new ui-select dependency                  |
+| `d0c7b65a6e` | FBX conversion moved into a Web Worker (main-thread fallback)            |
+| `8e51b6c524` | Explicit "Upload as Animation" toggle + required duration_millis         |
+| `00ebeae10c` | User's uploaded animations merged into the Animations tab                |
+| `e1c7a0c7b0` | Persistent skeleton-helper toggle in the outliner                        |
+| `30f40c0ddb` | Previewer bone toggles + mesh-less framing/mixer-binding fixes           |
+| `5f7ba7bbc5` | AnimationsModal (All/Presets/Uploaded) + timeline quality-of-life        |
+| `d55735620a` | Timeline ruler tick marks + strip button spacing                         |
+| `79875d8c76` | Upload animations from the AnimationsModal (initialCategory)             |
+| *(this)*     | NodeHierarchyHelper: bone toggle works for converted mesh-less GLBs      |
+
+## Features
+
+### 1. Animations tab in the asset drawer (`AssetModal`)
+
+- New left-rail section fed by `GET /v1/media_files/list_featured?filter_engine_categories=animation`
+  (GLB/GLTF only — the clip loader is GLTF-based). Featured results REPLACE the 37 hardcoded
+  `demoAnimationItems`; demos are only the empty-API fallback.
+- The session user's own uploaded animations (`list/user`, same filter) render AHEAD of the
+  featured set. Fetched on every modal open and after each upload; fails silently for anonymous
+  users (`suppressErrorToast` on the user-media fetch path).
+- Card click appends the clip to the selected character's row at the earliest free slot (toast
+  when no character is selected or the row is full). The old right-docked `AnimationsDrawer` is
+  deleted; the old HTML5-DnD path (`ANIMATION_CLIP_MIME`) is gone with it.
+
+### 2. Drag-and-drop with rig-compatibility badge (`DndAsset`)
+
+- Animation cards ride the same pointer-drag pipeline as every other asset. On drag start the
+  clip's track node names are preloaded (`loadRawGlb`, cached per media id); hovering a
+  character (or any skinned object) checks those names against its nodes — the exact direct-bind
+  rule `CharacterAnimationManager` plays by. No retargeting (explicitly out of scope).
+- The shared `DragGhost` shows the verdict: green check (binds) / red slash (no target or rig
+  mismatch); nothing while the clip is still loading. Incompatible or slot-less drops are
+  rejected with a toast.
+- Drop targets: a character in the 3D scene (earliest free slot) or a timeline row
+  (`data-clip-drop-uuid`; pointer-x → time via the `data-timeline-ruler` rect).
+
+### 3. Timeline clips: behavior + UX
+
+- **Strips default to 1 s** and the strip width is the authoritative play window
+  (`LaneRuntime.stripDuration`): trimming genuinely cuts playback; loop repeats inside the
+  strip; a non-loop strip wider than its clip freezes on the last frame. On load a strip only
+  shrinks (clip shorter than default) — never grows.
+- **Rest-pose in gaps**: `Skeleton.pose()` was replaced with a rest-pose snapshot captured at
+  mixer creation (all nodes BELOW the object root; root excluded so gizmo/keyframes never snap
+  back). `pose()` rebuilds bone locals from inverse bind matrices and mis-scales cm-rigs — that
+  was the "character vanishes when moving a strip" bug.
+- **Selection UX**: strips are click-to-select; × renders only on the selected strip;
+  Del/Backspace deletes; removal is individually undoable (`RemoveClipLaneAction` — the one
+  exception to clip edits riding the timeline Save/Cancel session).
+- **Full rows reject adds**: `resolveFreeStart` returns null instead of accepting an
+  overlapping clamp.
+
+### 4. Baked-in clips
+
+- `ClipStrip.bakedClipIndex` marks a strip sourced from the object's own `animations[]`
+  (resolved synchronously — no media fetch). Objects with baked clips get a timeline clip row
+  with a "+" picker listing them.
+- Clip-row eligibility is wider than characters: any skinned object (creatures, rigged uploads)
+  accepts animation drags (bind check gates); baked-only objects get a row for the picker.
+- INVARIANT: baked clips are never removed from the THREE model. Removing a baked strip only
+  unschedules it; the clip stays on `object.animations` and in the picker. Library strips stay
+  fully removable.
+- Outliner metadata (`hasSkeleton`, `bakedClips`) is computed in `convert_object` and refreshed
+  after every GLB load (`SceneDeps.onGlbLoaded` → `refreshOutliner`).
+
+### 5. Previewers (Viewer3D + upload preview)
+
+- Both play baked clips: autoplay the first, dropdown with every clip + "T-pose (none)", hidden
+  entirely for animation-less models.
+- Both have a bone icon toggling a skeleton overlay — default ON when the model has no mesh
+  (Mixamo "without skin" exports), so animation-only files are visible. The upload thumbnail
+  snapshot then captures the skeleton render.
+- The overlay adapts to the rig kind: real `THREE.Bone` joints get `THREE.SkeletonHelper`;
+  mesh-less models whose joints re-imported as plain nodes get `NodeHierarchyHelper`
+  (exported from `viewer-3d`) — GLTF only round-trips bone-ness through a *skin*, and a
+  mesh-less export has no skin, so converted FBX animations lose `Bone`-ness entirely. The
+  toggle shows for `hasBones || !hasMesh`.
+- Latent bugs fixed: upload preview discarded `gltf.animations`; its child re-parenting loop
+  skipped every other child (`scene.add` mutates the array mid-forEach); its mixer bound before
+  the model entered the scene (silently played nothing); camera framing NaN'd on empty
+  bounding boxes (now falls back to bone world positions); camera now fits once, not per-child.
+
+### 6. FBX upload support
+
+- The 3D uploader accepts `.fbx` and normalizes it at the door: `FBXLoader` → `GLTFExporter`
+  → binary GLB with clips preserved. Runs in a dedicated Web Worker (transferred buffers, jobs
+  naturally serialized); a broken worker environment falls back to the main thread. The raw FBX
+  can never reach the backend — retry of a failed conversion re-converts.
+- Caveats: embedded textures may not survive; units are exported as parsed (cm-scaled Mixamo
+  rigs are not rescaled).
+
+### 7. Upload as Animation
+
+- Mutually exclusive checkbox next to "Upload as Character" → `engine_category=animation`.
+  Mesh-less files preselect it (preview loader reports `hasMesh:false`); a user click always
+  wins. Rig-type dropdown defaults to Mixamo (characters keep Mixamo ArKit first).
+- The backend-required `maybe_duration_millis` is read from the longest clip at submit time;
+  clip-less files are flagged and excluded client-side.
+
+### 8. Outliner skeleton toggle (`SkeletonHelperController`)
+
+- Bone icon on skinned rows toggles a persistent `SkeletonHelper` on LAYER 1 (editor-only —
+  the render camera renders layer 0, so skeletons never appear in captures/recordings).
+- Persists as `userData.skeletonVisible` through scene save/load (explicit restore in the proxy
+  load path). Reconciliation rides `OutlinerRefreshedEvent` — add/delete/load/new-scene and the
+  post-GLB-load refresh all funnel there.
+- FK/pose-mode compatible: `PoseModeChangedEvent("pose")` suppresses the persistent helper for
+  the posed character (FKHelper draws its own rig); exit restores it. The toggle state itself
+  is never touched.
+
+## Manual test checklist (outstanding)
+
+- [ ] Prod data: does `list_featured?filter_engine_categories=animation` return rows? If yes
+      they replace the demo clips in the tab; if empty, the 37 demos show.
+- [ ] Clip→rig bind smoke test on shipped characters (runtime-unverified `mixamorig:*`
+      assumption; a "bound 0 tracks" console warning means retargeting becomes the real task).
+- [ ] Creature experiment: drag a clip onto a creature — badge should reflect bind result.
+- [ ] Baked clips: "+" picker on an animated object's row; add/remove/re-add; save/reload
+      persistence (the `object.animations` stash on load is gated on `auto_add` — statically
+      unconfirmed for every load path).
+- [ ] Clip UX round: strips at 1 s; trim semantics; select → ×/Del; undo/redo of removal;
+      character stays visible when a strip moves off the playhead.
+- [ ] FBX round trip: pick `.fbx` → converts (worker; check console for worker load failures —
+      falls back to main thread) → skeleton visible + clip dropdown → Upload as Animation
+      preselected → appears at front of Animations tab → drag onto character → plays.
+- [ ] Converted-FBX scale: if placed objects come in ~100× too big, the converter needs a
+      normalize-scale step.
+- [ ] Outliner bone toggle: on/off, FK-mode enter/exit restore, save/reload persistence, and
+      absence from Capture/Record output.
+- [ ] Previewer dropdown + bone toggle across lightbox, media page, lightbox-modal,
+      ImageTo3DExperience, upload modal.
+
+## Debug pass + hardening round (post-review)
+
+A four-agent review of the combined branch produced 30 findings (5 high / 12 medium / 13 low);
+ALL have been fixed or explicitly closed, one commit per finding (range `72cb218e..b21732d1`).
+Highlights, roughly in commit order:
+
+- Highs: baked clips cloned per lane (shared-AnimationAction playback/removal corruption);
+  runtime revalidation for objects recreated under the same uuid (delete→undo, reloads) — later
+  hardened into LOOP-FREE terminal lane states (bound / missing / unbindable, reassessed only on
+  root-instance change; the pre-fetch rig gate is sound because every load path stamps the target
+  uuid only post-load); skeleton-helper sync self-heals across in-session reloads; upload modal
+  can no longer report success for empty/partial submissions; ref-guarded double-submit.
+- Mediums: strip removal mirrored into the Save/Cancel `saved` snapshot (Cancel can't resurrect,
+  no phantom undo); stale strip/keyframe selections pruned in the bridge + live-checked before
+  swallowing Del/Backspace; one winning lane per character at flush boundaries (blend-glitch
+  frame was being ENCODED into recordings); orphaned tracks/lanes filtered from scene JSON at
+  save; per-clip queued-drop tokens; animation raycasts gated to the canvas element + honest
+  front-most-surface occlusion; virtualized-grid thumbnail state keyed by item; one shared
+  lazily-fetched animation-library store (was double-fetch + double-toast + divergent lists);
+  previewer rest-pose snapshots replace `Skeleton.pose()` everywhere; all-node camera-framing
+  fallback for plain-node rigs; upload-preview races (superseded-load cancellation, snapshot
+  after helper creation, File-identity row statuses, retry re-entry).
+- Lows: duration-shrink re-fits strips; baked-clip picker portals out of the scrolling row list;
+  timeline resets on scene switch/new scene instead of leaking across; click-to-add accepts every
+  drag-eligible target; queued drops bail on a torn-down editor (`Editor.isLive`); top-level root
+  lookups unified; flick-click race killed via `wasDragGesture`; converting-overlay control reset;
+  conversion completions reload only the previewed entry; worker `onmessageerror` recovery +
+  corrupt-vs-clip-less error messages + explicit `initialCategory` wins over mesh-less
+  auto-detect; Uploaded tab pages past the 100-item cap.
+- Closed without code: the "compat cache stales on streaming characters" finding (invalidated —
+  uuid-resolvable roots are always fully loaded) and the Tauri `promptSignup` gap (desktop is
+  always signed in by adapter contract).
+
+## Landed since the original handoff
+
+- **AnimationsModal** (was deferred — now built, `5f7ba7bbc5`/`79875d8c76`): standalone modal
+  with All / Presets / Uploaded tabs, opened from an "Add Animation" button next to Enter Pose
+  Mode and from the "+" add-asset menu. Adding a clip expands the timeline and scrolls to the
+  character (`timelineRevealObjectUuid`); the modal closes after an add unless "Reopen after
+  adding" is on. Its "Upload animation" button opens `UploadModal3D` with
+  `initialCategory="animation"` (anonymous users get the signup prompt), landing on the
+  Uploaded tab afterwards. `AssetModal`'s animations tab was folded into this.
+- **Timeline QoL**: ruler tick marks (major/second/sub-tick), selected-object-only track
+  filter, directional expand/collapse chevrons, thumbnail-less animation cards get an icon
+  placeholder.
+
+## Deferred (explicitly out of scope for this branch)
+
+- **Split-screen preview window** (based on the `?output=` `DemoOutputOverlay`) — parked until
+  explicit approval.
+- **Retargeting** (`SkeletonUtils.retargetClip`) — too complex for now; mismatched rigs are
+  simply rejected by the bind check.
+- **Clip blending/layering** — one non-overlapping row per object, by design.
+
+## Key files
+
+| Area                | Files                                                                                     |
+|---------------------|-------------------------------------------------------------------------------------------|
+| Drawer tab          | `pagescene/src/lib/comps/AssetMenu/AssetModal.tsx`, `shared/ItemElement.tsx`               |
+| Drag-and-drop       | `pagescene/src/lib/DragAndDrop/DndAsset.ts`, `gallery-modal/src/lib/DragGhost.tsx`         |
+| Timeline data/engine| `pagescene/src/lib/engine/timeline/types.ts`, `engine/editor/TimelineController.ts`,       |
+|                     | `engine/animation/CharacterAnimationManager.ts`, `engine/editor/actions/RemoveClipLaneAction.ts` |
+| Timeline UI         | `pagescene/src/lib/comps/Timeline/TimelineEditor.tsx`, `TimelineClipRow.tsx`               |
+| Skeleton toggle     | `pagescene/src/lib/engine/editor/SkeletonHelperController.ts`, `comps/Outliner/Outliner.tsx` |
+| Previewers          | `viewer-3d/src/lib/viewer-3d.tsx`, `upload-modal/.../utilities/loadPreviewOnCanvas.ts`     |
+| FBX + upload        | `upload-modal/.../utilities/convertFbxToGlb.ts` (+ `.worker.ts`), `UploadModal3D.tsx`,     |
+|                     | `UploadFiles3D.tsx`, `utilities/readGlbAnimationDuration.ts`                               |
+
+The pagescene `CLAUDE.md` "Mixamo animation clips" section has been kept current with these
+changes and carries the same invariants in engine-doc form.

crates/api_clients/artcraft/artcraft_api_defs/src/internal/minimax_jobs/mark_minimax_job_failure.rs

@@ -0,0 +1,29 @@
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use enums::by_table::generic_inference_jobs::frontend_failure_category::FrontendFailureCategory;
+
+/// Request body for `POST /v1/internal/minimax_jobs/job/{job_token}/failure`.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct MarkMinimaxJobFailureRequest {
+  /// Optional failure class the frontend can localize and present.
+  pub maybe_frontend_failure_category: Option<FrontendFailureCategory>,
+
+  /// Optional failure reason we can show the user (512 characters max).
+  pub maybe_user_failure_reason: Option<String>,
+
+  /// Optional internal-only stack trace or error (512 characters max).
+  pub maybe_internal_debugging_failure_reason: Option<String>,
+
+  /// Optional total wall-clock runtime of the failed attempt, in milliseconds.
+  pub execution_duration_millis: Option<u64>,
+
+  /// Optional inference-only runtime of the failed attempt, in milliseconds.
+  pub inference_duration_millis: Option<u64>,
+}
+
+/// Response body for `POST /v1/internal/minimax_jobs/job/{job_token}/failure`.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct MarkMinimaxJobFailureResponse {
+  pub success: bool,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/internal/minimax_jobs/mark_minimax_job_success.rs

@@ -0,0 +1,29 @@
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use tokens::tokens::media_files::MediaFileToken;
+
+// NB: The success request is form-multipart (video bytes + optional
+// `duration_millis` / `width` / `height` metadata fields), so its form struct
+// lives with the actix handler; only the response shape is declared here.
+
+/// Response body for `POST /v1/internal/minimax_jobs/job/{job_token}/success`.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct MarkMinimaxJobSuccessResponse {
+  pub success: bool,
+
+  /// The media file created from the uploaded video.
+  pub media_file_token: MediaFileToken,
+
+  /// Video duration stored on the media file record, in milliseconds
+  /// (worker-supplied, or probed from the file when not supplied).
+  pub maybe_duration_millis: Option<u64>,
+
+  /// Frame width stored on the media file record, in pixels
+  /// (worker-supplied, or probed from the file when not supplied).
+  pub maybe_width: Option<u32>,
+
+  /// Frame height stored on the media file record, in pixels
+  /// (worker-supplied, or probed from the file when not supplied).
+  pub maybe_height: Option<u32>,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/internal/minimax_jobs/minimax_worker_model.rs

@@ -0,0 +1,33 @@
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+/// The first-party Minimax models a worker can request jobs for.
+///
+/// This is deliberately its own enum (not `CommonVideoModel`) so the internal
+/// worker API surface stays small and stable.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize, ToSchema)]
+pub enum MinimaxWorkerModel {
+  #[serde(rename = "minimax_h3_turbo")]
+  MinimaxH3Turbo,
+
+  #[serde(rename = "minimax_h3_ultra")]
+  MinimaxH3Ultra,
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn serde_round_trip() {
+    let cases = [
+      (MinimaxWorkerModel::MinimaxH3Turbo, "\"minimax_h3_turbo\""),
+      (MinimaxWorkerModel::MinimaxH3Ultra, "\"minimax_h3_ultra\""),
+    ];
+    for (variant, json) in cases {
+      assert_eq!(serde_json::to_string(&variant).unwrap(), json);
+      let parsed: MinimaxWorkerModel = serde_json::from_str(json).unwrap();
+      assert_eq!(parsed, variant);
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_api_defs/src/internal/minimax_jobs/mod.rs

@@ -0,0 +1,4 @@
+pub mod mark_minimax_job_failure;
+pub mod mark_minimax_job_success;
+pub mod minimax_worker_model;
+pub mod obtain_minimax_job;

crates/api_clients/artcraft/artcraft_api_defs/src/internal/minimax_jobs/obtain_minimax_job.rs

@@ -0,0 +1,85 @@
+use serde_derive::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use enums::by_table::prompt_context_items::prompt_context_semantic_type::PromptContextSemanticType;
+use enums::common::generation::common_aspect_ratio::CommonAspectRatio;
+use enums::common::generation::common_bitrate::CommonBitrate;
+use enums::common::generation::common_generation_mode::CommonGenerationMode;
+use enums::common::generation::common_resolution::CommonResolution;
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use tokens::tokens::prompts::PromptToken;
+
+use crate::common::responses::media_links::MediaLinks;
+use crate::internal::minimax_jobs::minimax_worker_model::MinimaxWorkerModel;
+
+/// Request body for `POST /v1/internal/minimax_jobs/obtain_job`.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct ObtainMinimaxJobRequest {
+  /// Which model the worker wants a job for.
+  pub model: MinimaxWorkerModel,
+
+  /// The worker's hostname (linux hostname, k8s pod name), if reported.
+  pub worker_hostname: Option<String>,
+
+  /// The cluster the worker runs in (e.g. "runpod", "lambdalabs"), if reported.
+  pub cluster_name: Option<String>,
+}
+
+/// Response body for `POST /v1/internal/minimax_jobs/obtain_job`.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct ObtainMinimaxJobResponse {
+  pub success: bool,
+
+  /// The obtained job, or `None` when no pending job is available.
+  pub maybe_job: Option<ObtainedMinimaxJob>,
+}
+
+/// A job the worker now holds a lock on (status was moved to `started`).
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct ObtainedMinimaxJob {
+  pub job_token: InferenceJobToken,
+
+  /// Echo of the requested model.
+  pub model: MinimaxWorkerModel,
+
+  /// The prompt and inputs the worker needs to run inference. Only `None`
+  /// when the job was somehow enqueued without a prompt record (or the
+  /// prompt lookup failed) — workers should fail such jobs via the failure
+  /// endpoint.
+  pub maybe_prompt: Option<MinimaxJobPromptDetails>,
+}
+
+/// The prompt (text + generation settings) and its attached media references.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct MinimaxJobPromptDetails {
+  pub prompt_token: PromptToken,
+
+  pub maybe_positive_prompt: Option<String>,
+  pub maybe_negative_prompt: Option<String>,
+
+  pub maybe_generation_mode: Option<CommonGenerationMode>,
+  pub maybe_aspect_ratio: Option<CommonAspectRatio>,
+  pub maybe_resolution: Option<CommonResolution>,
+  pub maybe_bitrate: Option<CommonBitrate>,
+  pub maybe_generate_audio: Option<bool>,
+  pub maybe_duration_seconds: Option<u32>,
+
+  /// Image / video / audio references attached to the prompt, with full CDN
+  /// links, in their original order.
+  pub media_references: Vec<MinimaxJobMediaReference>,
+}
+
+/// One media input attached to the prompt (start frame, end frame, or an
+/// image / video / audio reference), with full CDN links.
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct MinimaxJobMediaReference {
+  pub media_file_token: MediaFileToken,
+
+  /// The role the media plays (start frame, end frame, image / video / audio
+  /// reference, etc.).
+  pub semantic_type: PromptContextSemanticType,
+
+  /// Full CDN links to the media file.
+  pub media_links: MediaLinks,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/internal/mod.rs

@@ -0,0 +1,4 @@
+//! Internal-facing API surfaces (worker fleets, etc.). These are
+//! authenticated with internal API keys, never consumer credentials.
+
+pub mod minimax_jobs;

crates/api_clients/artcraft/artcraft_api_defs/src/lib.rs

@@ -5,6 +5,7 @@ pub mod common;
 pub mod credits;
 pub mod folders;
 pub mod generate;
+pub mod internal;
 pub mod jobs;
 pub mod media_file;
 pub mod moderation;

crates/api_clients/artcraft/artcraft_api_defs/src/omni_gen/cost_and_generate_requests/omni_gen_video_cost_and_generate_request.rs

@@ -69,4 +69,23 @@ pub struct OmniGenVideoCostAndGenerateRequest {
   /// Some models will default this to true, others will default it to false,
   /// so it's best to be explicit.
   pub generate_audio: Option<bool>,
+
+  /// Frontend-supplied hints for cost estimation only. IGNORED by
+  /// generation — the generate endpoints measure inputs themselves (e.g.
+  /// ffprobing reference videos) and bill from those measurements.
+  pub estimate_only: Option<EstimateFields>,
+}
+
+/// These fields are ignored by generation. They're only used by the frontend
+/// to aid in cost estimation (e.g. Seedance 2.5 bills reference-video input
+/// seconds, so the cost quote needs the combined input duration without the
+/// server downloading and probing the files on every poll).
+#[derive(Clone, Copy, Serialize, Deserialize, ToSchema, Debug, Default)]
+pub struct EstimateFields {
+  /// Combined duration of all reference video inputs, in milliseconds.
+  pub total_input_video_duration_millis: Option<u32>,
+
+  /// Combined duration of all reference audio inputs, in milliseconds.
+  /// (No model bills audio input seconds yet; accepted for future models.)
+  pub total_input_audio_duration_millis: Option<u32>,
 }

crates/api_clients/artcraft/artcraft_client/src/datatypes/common_enums/generation/api_client_video_model.rs

@@ -25,8 +25,6 @@ pub enum ApiClientVideoModel {
   Seedance2p0Fast,
   Seedance2p0BytePlus,
   Seedance2p0BytePlusFast,
-  Seedance2p0Ultra,
-  Seedance2p0UltraFast,
   Seedance2p0BytePlusUltra,
   Seedance2p0BytePlusUltraFast,
   Seedance2p0Mini,
@@ -65,8 +63,6 @@ impl From<String> for ApiClientVideoModel {
       "seedance_2p0_fast" => Self::Seedance2p0Fast,
       "seedance_2p0_bp" => Self::Seedance2p0BytePlus,
       "seedance_2p0_bp_fast" => Self::Seedance2p0BytePlusFast,
-      "seedance_2p0_u" => Self::Seedance2p0Ultra,
-      "seedance_2p0_u_fast" => Self::Seedance2p0UltraFast,
       "seedance_2p0_bpu" => Self::Seedance2p0BytePlusUltra,
       "seedance_2p0_bpu_fast" => Self::Seedance2p0BytePlusUltraFast,
       "seedance_2p0_mini" => Self::Seedance2p0Mini,
@@ -106,8 +102,6 @@ impl From<ApiClientVideoModel> for String {
       ApiClientVideoModel::Seedance2p0Fast => "seedance_2p0_fast".to_string(),
       ApiClientVideoModel::Seedance2p0BytePlus => "seedance_2p0_bp".to_string(),
       ApiClientVideoModel::Seedance2p0BytePlusFast => "seedance_2p0_bp_fast".to_string(),
-      ApiClientVideoModel::Seedance2p0Ultra => "seedance_2p0_u".to_string(),
-      ApiClientVideoModel::Seedance2p0UltraFast => "seedance_2p0_u_fast".to_string(),
       ApiClientVideoModel::Seedance2p0BytePlusUltra => "seedance_2p0_bpu".to_string(),
       ApiClientVideoModel::Seedance2p0BytePlusUltraFast => "seedance_2p0_bpu_fast".to_string(),
       ApiClientVideoModel::Seedance2p0Mini => "seedance_2p0_mini".to_string(),
@@ -165,8 +159,6 @@ mod tests {
       (ApiClientVideoModel::Seedance2p0Fast, "seedance_2p0_fast"),
       (ApiClientVideoModel::Seedance2p0BytePlus, "seedance_2p0_bp"),
       (ApiClientVideoModel::Seedance2p0BytePlusFast, "seedance_2p0_bp_fast"),
-      (ApiClientVideoModel::Seedance2p0Ultra, "seedance_2p0_u"),
-      (ApiClientVideoModel::Seedance2p0UltraFast, "seedance_2p0_u_fast"),
       (ApiClientVideoModel::Seedance2p0BytePlusUltra, "seedance_2p0_bpu"),
       (ApiClientVideoModel::Seedance2p0BytePlusUltraFast, "seedance_2p0_bpu_fast"),
       (ApiClientVideoModel::Seedance2p0Mini, "seedance_2p0_mini"),

crates/api_clients/artcraft/artcraft_router/src/api/router_video_model.rs

@@ -68,11 +68,7 @@ pub enum RouterVideoModel {
   #[serde(rename = "seedance_2p0_bp_fast")]
   Seedance2p0BytePlusFast,
 
-  #[serde(rename = "seedance_2p0_u")]
-  Seedance2p0Ultra,
 
-  #[serde(rename = "seedance_2p0_u_fast")]
-  Seedance2p0UltraFast,
 
   #[serde(rename = "seedance_2p0_bpu")]
   Seedance2p0BytePlusUltra,
@@ -92,6 +88,12 @@ pub enum RouterVideoModel {
   #[serde(rename = "seedance_2p5_preview")]
   Seedance2p5Preview,
 
+  #[serde(rename = "seedance_2p5")]
+  Seedance2p5,
+
+  #[serde(rename = "seedance_2p5_u")]
+  Seedance2p5Ultra,
+
   #[serde(rename = "happy_horse_1p0")]
   HappyHorse1p0,
 
@@ -156,6 +158,20 @@ mod tests {
     assert_serde_round_trip(RouterVideoModel::Seedance2p5Preview, "seedance_2p5_preview");
   }
 
+  #[test]
+  fn seedance_2p5_serializes() {
+    // NB: This string must match `CommonVideoModel` — the two enums convert
+    // via serde string round-trip in the omni handlers.
+    assert_serde_round_trip(RouterVideoModel::Seedance2p5, "seedance_2p5");
+  }
+
+  #[test]
+  fn seedance_2p5_ultra_serializes() {
+    // NB: This string must match `CommonVideoModel` — the two enums convert
+    // via serde string round-trip in the omni handlers.
+    assert_serde_round_trip(RouterVideoModel::Seedance2p5Ultra, "seedance_2p5_u");
+  }
+
   #[test]
   fn veo_3p1_lite_and_vidu_variants_serialize() {
     // NB: These strings must match `CommonVideoModel` — the two enums convert

crates/api_clients/artcraft/artcraft_router/src/generate/generate_audio/providers/kinovi/resolve.rs

@@ -71,7 +71,7 @@ pub(crate) async fn resolve_and_upload_audio_ref(
       })?
     }
   };
-  upload_to_kinovi_web(session, &source_url).await
+  upload_to_kinovi_web(session, &source_url, None).await
 }
 
 #[cfg(test)]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/build_common.rs

@@ -22,14 +22,15 @@ use crate::generate::generate_image::generate_image_request_builder::GenerateIma
 /// Per-model build functions are expected to validate model-specific
 /// constraints (e.g. unsupported aspect ratios) BEFORE calling this helper.
 /// Validation that's identical across every Artcraft image model — batch count
-/// (1..=4) and image_inputs shape — lives here.
+/// (1..=[`max_batch_count`]) and image_inputs shape — lives here.
 pub fn build_artcraft_omni_image_request(
   builder: GenerateImageRequestBuilder,
   model: CommonImageModelEnum,
 ) -> Result<OmniGenImageCostAndGenerateRequest, ArtcraftRouterError> {
   let strategy = builder.request_mismatch_mitigation_strategy;
 
-  let image_batch_count = plan_batch_count(builder.image_batch_count, strategy)?;
+  let image_batch_count =
+    plan_batch_count_with_max(builder.image_batch_count, strategy, max_batch_count(model))?;
   let image_media_tokens = resolve_image_list_ref(builder.image_inputs.clone())?;
 
   let aspect_ratio = builder.aspect_ratio.map(to_aspect_ratio_enum);
@@ -52,26 +53,47 @@ pub fn build_artcraft_omni_image_request(
   })
 }
 
+/// The largest batch each Artcraft image model accepts. Seedream 5.0 Pro and
+/// Ultra accept batches of up to 8; every other model caps at 4.
+pub fn max_batch_count(model: CommonImageModelEnum) -> u16 {
+  match model {
+    CommonImageModelEnum::Seedream5p0Pro | CommonImageModelEnum::Seedream5p0ProUltra => 8,
+    _ => 4,
+  }
+}
+
 /// Validate batch count (1..=4). Mirrors the v1 plan-level validation that
 /// every Artcraft image model performs.
 pub fn plan_batch_count(
   image_batch_count: Option<u16>,
   strategy: RequestMismatchMitigationStrategy,
+) -> Result<u16, ArtcraftRouterError> {
+  plan_batch_count_with_max(image_batch_count, strategy, 4)
+}
+
+/// Validate batch count (1..=`max`), clamping or erroring per the mitigation
+/// strategy when the request exceeds the model's cap.
+pub fn plan_batch_count_with_max(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+  max: u16,
 ) -> Result<u16, ArtcraftRouterError> {
   let count = image_batch_count.unwrap_or(1);
-  match count {
-    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
-    1..=4 => Ok(count),
-    _ => match strategy {
-      RequestMismatchMitigationStrategy::ErrorOut => {
-        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-          field: "image_batch_count",
-          value: format!("{}", count),
-        }))
-      }
-      RequestMismatchMitigationStrategy::PayMoreUpgrade
-      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(4),
-    },
+  if count == 0 {
+    return Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations));
+  }
+  if count <= max {
+    return Ok(count);
+  }
+  match strategy {
+    RequestMismatchMitigationStrategy::ErrorOut => {
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_batch_count",
+        value: format!("{}", count),
+      }))
+    }
+    RequestMismatchMitigationStrategy::PayMoreUpgrade
+    | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(max),
   }
 }
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/generate_video_request_builder.rs

@@ -26,8 +26,6 @@ use crate::generate::generate_video::providers::artcraft::seedance_1p0_lite::bui
 use crate::generate::generate_video::providers::artcraft::seedance_1p5_pro::build::build_artcraft_seedance_1p5_pro;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0::build::build_artcraft_seedance_2p0;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_fast::build::build_artcraft_seedance_2p0_fast;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u::build::build_artcraft_seedance_2p0_u;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u_fast::build::build_artcraft_seedance_2p0_u_fast;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp::build::build_artcraft_seedance_2p0_bp;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp_fast::build::build_artcraft_seedance_2p0_bp_fast;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu::build::build_artcraft_seedance_2p0_bpu;
@@ -50,8 +48,6 @@ use crate::generate::generate_video::providers::artcraft::vidu_q3::build::build_
 use crate::generate::generate_video::providers::artcraft::vidu_q3_turbo::build::build_artcraft_vidu_q3_turbo;
 use crate::generate::generate_video::providers::kinovi::happy_horse_1p0::build::build_kinovi_happy_horse_1p0;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0::build::build_kinovi_seedance_2p0;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_g::build::build_gmicloud_seedance_2p0_u;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_fast_g::build::build_gmicloud_seedance_2p0_u_fast;
 use crate::generate::generate_video::providers::grok_api::grok_imagine_video::build::build_grok_api_grok_imagine_video;
 use crate::generate::generate_video::providers::grok_api::grok_imagine_video_1p5::build::build_grok_api_grok_imagine_video_1p5;
 use crate::generate::generate_video::providers::fal::kling_1_6_pro::build::build_fal_kling_1_6_pro;
@@ -78,7 +74,10 @@ use crate::generate::generate_video::providers::fal::vidu_q3::build::build_fal_v
 use crate::generate::generate_video::providers::fal::vidu_q3_turbo::build::build_fal_vidu_q3_turbo;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_fast::build::build_kinovi_seedance_2p0_fast;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_mini::build::build_kinovi_seedance_2p0_mini;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5::build::build_artcraft_seedance_2p5;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5_u::build::build_artcraft_seedance_2p5_u;
 use crate::generate::generate_video::providers::artcraft::seedance_2p5_preview::build::build_artcraft_seedance_2p5_preview;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::build::build_kinovi_seedance_2p5;
 use crate::generate::generate_video::providers::kinovi::seedance_2p5_preview::build::build_kinovi_seedance_2p5_preview;
 use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
 
@@ -138,6 +137,12 @@ pub struct GenerateVideoRequestBuilder {
   /// so it's best to be explicit.
   pub generate_audio: Option<bool>,
 
+  /// CALCULATION-ONLY (never sent to any provider): the total seconds of
+  /// reference video input, summed across all reference videos and rounded
+  /// up to whole seconds per file. Models that bill reference-video input
+  /// seconds (e.g. Seedance 2.5) add this to the billed duration.
+  pub total_reference_video_input_seconds: Option<u16>,
+
   /// If the request is a mismatch with the (model/provider), how to mitigate it.
   pub request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy,
 
@@ -166,6 +171,7 @@ impl Default for GenerateVideoRequestBuilder {
       duration_seconds: None,
       video_batch_count: None,
       generate_audio: None,
+      total_reference_video_input_seconds: None,
       idempotency_token: None,
     }
   }
@@ -191,8 +197,6 @@ impl GenerateVideoRequestBuilder {
       (RouterProvider::Artcraft, RouterVideoModel::MinimaxH3) => build_artcraft_minimax_h3(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0) => build_artcraft_seedance_2p0(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0Fast) => build_artcraft_seedance_2p0_fast(self),
-      (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0Ultra) => build_artcraft_seedance_2p0_u(self),
-      (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0UltraFast) => build_artcraft_seedance_2p0_u_fast(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0BytePlus) => build_artcraft_seedance_2p0_bp(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0BytePlusFast) => build_artcraft_seedance_2p0_bp_fast(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0BytePlusUltra) => build_artcraft_seedance_2p0_bpu(self),
@@ -201,6 +205,8 @@ impl GenerateVideoRequestBuilder {
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0BytePlusMini) => build_artcraft_seedance_2p0_bp_mini(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p0BytePlusUltraMini) => build_artcraft_seedance_2p0_bpu_mini(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance2p5Preview) => build_artcraft_seedance_2p5_preview(self),
+      (RouterProvider::Artcraft, RouterVideoModel::Seedance2p5) => build_artcraft_seedance_2p5(self),
+      (RouterProvider::Artcraft, RouterVideoModel::Seedance2p5Ultra) => build_artcraft_seedance_2p5_u(self),
       (RouterProvider::Artcraft, RouterVideoModel::PreviewModel) => build_artcraft_preview_model(self),
       (RouterProvider::Artcraft, RouterVideoModel::PreviewModelFast) => build_artcraft_preview_model_fast(self),
       (RouterProvider::Artcraft, RouterVideoModel::Seedance10Lite) => build_artcraft_seedance_1p0_lite(self),
@@ -238,9 +244,6 @@ impl GenerateVideoRequestBuilder {
       (RouterProvider::Fal, RouterVideoModel::Veo3p1Lite) => build_fal_veo_3p1_lite(self),
       (RouterProvider::Fal, RouterVideoModel::ViduQ3) => build_fal_vidu_q3(self),
       (RouterProvider::Fal, RouterVideoModel::ViduQ3Turbo) => build_fal_vidu_q3_turbo(self),
-      // GmiCloud
-      (RouterProvider::GmiCloud, RouterVideoModel::Seedance2p0Ultra) => build_gmicloud_seedance_2p0_u(self),
-      (RouterProvider::GmiCloud, RouterVideoModel::Seedance2p0UltraFast) => build_gmicloud_seedance_2p0_u_fast(self),
       // Grok
       (RouterProvider::GrokApi, RouterVideoModel::GrokImagineVideo) => build_grok_api_grok_imagine_video(self),
       (RouterProvider::GrokApi, RouterVideoModel::GrokImagineVideo1p5) => build_grok_api_grok_imagine_video_1p5(self),
@@ -252,6 +255,7 @@ impl GenerateVideoRequestBuilder {
       (RouterProvider::KinoviWeb, RouterVideoModel::Seedance2p0BytePlusMini) => build_kinovi_seedance_2p0_mini(self),
       (RouterProvider::KinoviWeb, RouterVideoModel::Seedance2p0BytePlusUltraMini) => build_kinovi_seedance_2p0_mini(self),
       (RouterProvider::KinoviWeb, RouterVideoModel::Seedance2p5Preview) => build_kinovi_seedance_2p5_preview(self),
+      (RouterProvider::KinoviWeb, RouterVideoModel::Seedance2p5) => build_kinovi_seedance_2p5(self),
       _ => self.unsupported_provider_and_model(),
     }
   }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/build_common.rs

@@ -82,6 +82,7 @@ pub fn build_artcraft_omni_video_request(
     negative_prompt: None,
     generate_audio: None,
     quality: None,
+    estimate_only: None,
   })
 }
 
@@ -230,7 +231,7 @@ fn plan_output_resolution(
   }
 }
 
-/// Batch counts: 1, 2, 4.
+/// Batch counts: 1 through 4.
 pub fn plan_batch_count(
   video_batch_count: Option<u16>,
   strategy: RequestMismatchMitigationStrategy,
@@ -238,7 +239,8 @@ pub fn plan_batch_count(
   let count = video_batch_count.unwrap_or(1);
   match count {
     0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
-    1 | 2 | 4 => Ok(count),
+    1..=4 => Ok(count),
+    // 5 and above:
     _ => match strategy {
       RequestMismatchMitigationStrategy::ErrorOut => {
         Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
@@ -247,9 +249,31 @@ pub fn plan_batch_count(
         }))
       }
       RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(4),
-      RequestMismatchMitigationStrategy::PayLessDowngrade => {
-        Ok(if count < 4 { 2 } else { 4 })
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(4),
+    },
+  }
+}
+
+/// Batch counts for the Seedance 2.0 Mini family: 1-8 are all valid
+/// (wider than the shared 1/2/4 planning); higher counts clamp to 8 per the
+/// mitigation strategy.
+pub fn plan_mini_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<u16, ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1..=8 => Ok(count),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
       }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(8),
     },
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/grok_imagine_video_1p5/request.rs

@@ -63,6 +63,7 @@ mod tests {
         duration_seconds: Some(5),
         video_batch_count: Some(1),
         generate_audio: None,
+        estimate_only: None,
       },
     };
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/mod.rs

@@ -23,8 +23,6 @@ pub mod seedance_1p0_lite;
 pub mod seedance_1p5_pro;
 pub mod seedance_2p0;
 pub mod seedance_2p0_fast;
-pub mod seedance_2p0_u_fast;
-pub mod seedance_2p0_u;
 pub mod seedance_2p0_bp;
 pub mod seedance_2p0_bp_fast;
 pub mod seedance_2p0_bpu;
@@ -32,7 +30,9 @@ pub mod seedance_2p0_bpu_fast;
 pub mod seedance_2p0_mini;
 pub mod seedance_2p0_bp_mini;
 pub mod seedance_2p0_bpu_mini;
+pub mod seedance_2p5;
 pub mod seedance_2p5_preview;
+pub mod seedance_2p5_u;
 pub mod sora_2;
 pub mod sora_2_pro;
 pub mod veo_2;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/preview_model/cost.rs

@@ -79,6 +79,12 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 2), 750);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 375);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 3), 1125);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 500);
@@ -109,6 +115,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 100);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 150);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 200);
@@ -133,6 +144,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 2), 500);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 3), 750);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 4), 1000);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/preview_model_fast/cost.rs

@@ -76,6 +76,12 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 2), 600);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 300);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 3), 900);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 400);
@@ -106,6 +112,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 90);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 135);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 180);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0/cost.rs

@@ -65,7 +65,6 @@ impl ArtcraftSeedance2p0CostState {
       let usd_cents = seedance_2p0_four_k_usd_cents(
         self.duration_seconds,
         self.batch_count,
-        self.has_video_reference,
       );
       return VideoGenerationCostEstimate {
         cost_in_credits: Some(usd_cents),
@@ -146,6 +145,13 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 2), 480);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 4, 3), 192);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 240);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 3), 720);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 4, 4), 256);
@@ -177,6 +183,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 78);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 117);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 155);
@@ -201,6 +212,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 2), 466);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 3), 699);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 4), 933);
@@ -226,10 +242,10 @@ mod tests {
 
     #[test]
     fn explicit_4k_without_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, false), 347);
-      assert_eq!(artcraft_4k_cents(5, 1, false), 433);
-      assert_eq!(artcraft_4k_cents(10, 1, false), 866);
-      assert_eq!(artcraft_4k_cents(15, 1, false), 1299);
+      assert_eq!(artcraft_4k_cents(4, 1, false), 358);
+      assert_eq!(artcraft_4k_cents(5, 1, false), 447);
+      assert_eq!(artcraft_4k_cents(10, 1, false), 893);
+      assert_eq!(artcraft_4k_cents(15, 1, false), 1340);
     }
 
     #[test]
@@ -464,4 +480,74 @@ mod tests {
       .cost_in_usd_cents
       .unwrap()
   }
+
+  // ── Video reference deltas ──
+  //
+  // References price on the with-reference rate card; the delta must be positive at every resolution and duration.
+
+  mod video_reference_deltas {
+    use enums::common::generation::common_resolution::CommonResolution;
+
+    use super::super::ArtcraftSeedance2p0CostState;
+
+    #[test]
+    fn refs_cost_more_at_480p() {
+      assert_ref_delta(CommonResolution::FourEightyP, 5, 39, 45, 6);
+      assert_ref_delta(CommonResolution::FourEightyP, 10, 78, 89, 11);
+      assert_ref_delta(CommonResolution::FourEightyP, 15, 117, 133, 16);
+    }
+
+    #[test]
+    fn refs_cost_more_at_720p() {
+      assert_ref_delta(CommonResolution::SevenTwentyP, 5, 80, 111, 31);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 10, 160, 221, 61);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 15, 240, 331, 91);
+    }
+
+    #[test]
+    fn refs_cost_more_at_1080p() {
+      assert_ref_delta(CommonResolution::TenEightyP, 5, 233, 256, 23);
+      assert_ref_delta(CommonResolution::TenEightyP, 10, 466, 511, 45);
+      assert_ref_delta(CommonResolution::TenEightyP, 15, 699, 767, 68);
+    }
+
+    #[test]
+    fn refs_cost_more_at_4k() {
+      assert_ref_delta(CommonResolution::FourK, 5, 447, 569, 122);
+      assert_ref_delta(CommonResolution::FourK, 10, 893, 1138, 245);
+      assert_ref_delta(CommonResolution::FourK, 15, 1340, 1707, 367);
+    }
+
+    /// Price the same generation with and without a reference video; pin
+    /// both prices and the delta, in USD cents AND credits (credits equal
+    /// cents, and both must show references costing more).
+    fn assert_ref_delta(
+      resolution: CommonResolution,
+      duration_seconds: u16,
+      expected_no_ref: u64,
+      expected_with_ref: u64,
+      expected_delta: u64,
+    ) {
+      let no_ref = ArtcraftSeedance2p0CostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: false,
+      }.estimate_cost();
+      let with_ref = ArtcraftSeedance2p0CostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: true,
+      }.estimate_cost();
+
+      let no_ref_cents = no_ref.cost_in_usd_cents.unwrap();
+      let with_ref_cents = with_ref.cost_in_usd_cents.unwrap();
+      assert_eq!(no_ref_cents, expected_no_ref);
+      assert_eq!(with_ref_cents, expected_with_ref);
+      assert_eq!(with_ref_cents - no_ref_cents, expected_delta);
+      assert!(with_ref_cents > no_ref_cents, "references must cost more");
+
+      let no_ref_credits = no_ref.cost_in_credits.unwrap();
+      let with_ref_credits = with_ref.cost_in_credits.unwrap();
+      assert_eq!(no_ref_credits, expected_no_ref);
+      assert_eq!(with_ref_credits, expected_with_ref);
+      assert_eq!(with_ref_credits - no_ref_credits, expected_delta);
+    }
+  }
+
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bp/cost.rs

@@ -1,6 +1,5 @@
 use enums::common::generation::common_resolution::CommonResolution;
 
-use crate::generate::generate_video::providers::artcraft::seedance_common::seedance_2p0_four_k_usd_cents;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp::request::ArtcraftSeedance2p0BytePlusRequestState;
 use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
 
@@ -12,6 +11,24 @@ const CENTS_PER_SECOND_480P: f64 = 10.0;
 const CENTS_PER_SECOND_720P: f64 = 25.0;
 const CENTS_PER_SECOND_1080P: f64 = 50.0;
 
+/// USD cents per second, in hundredths of a cent, when one or more
+/// reference videos are attached. Held as integer hundredths so the math is
+/// exact; rounded up to whole cents once, after multiplying by
+/// duration × batch.
+///   480p:  10.20 ¢/s
+///   720p:  25.70 ¢/s
+///   1080p: 57.80 ¢/s
+///   4K:   119.00 ¢/s
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P: u64 = 1_020;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P: u64 = 2_570;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_1080P: u64 = 5_780;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_4K: u64 = 11_900;
+
+/// 4K output price with no reference videos, in hundredths of a USD cent
+/// per second (95.00 ¢/s), rounded up to whole cents after multiplying by
+/// duration × batch.
+const CENTI_CENTS_PER_SECOND_4K: u64 = 9_500;
+
 pub struct ArtcraftSeedance2p0BytePlusCostState {
   pub resolution: CommonResolution,
   pub duration_seconds: u16,
@@ -32,12 +49,24 @@ impl ArtcraftSeedance2p0BytePlusCostState {
   }
 
   pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    if self.has_video_reference {
+      let usd_cents = self.with_video_reference_usd_cents();
+      return VideoGenerationCostEstimate {
+        cost_in_credits: Some(usd_cents),
+        cost_in_usd_cents: Some(usd_cents),
+        is_free: false,
+        is_unlimited: false,
+        is_rate_limited: false,
+        has_watermark: false,
+        failures_are_refunded: None,
+      };
+    }
+
     if self.resolution == CommonResolution::FourK {
-      let usd_cents = seedance_2p0_four_k_usd_cents(
-        self.duration_seconds,
-        self.batch_count,
-        self.has_video_reference,
-      );
+      let total_centi_cents = CENTI_CENTS_PER_SECOND_4K
+        * self.duration_seconds as u64
+        * self.batch_count as u64;
+      let usd_cents = total_centi_cents.div_ceil(100);
       return VideoGenerationCostEstimate {
         cost_in_credits: Some(usd_cents),
         cost_in_usd_cents: Some(usd_cents),
@@ -67,6 +96,22 @@ impl ArtcraftSeedance2p0BytePlusCostState {
       failures_are_refunded: None,
     }
   }
+
+  /// Price when one or more reference videos are attached.
+  fn with_video_reference_usd_cents(&self) -> u64 {
+    let centi_cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P,
+      CommonResolution::TenEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_1080P,
+      CommonResolution::FourK => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_4K,
+      // Everything else (including 720p) prices at 720p.
+      _ => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P,
+    };
+
+    let seconds = self.duration_seconds as u64 * self.batch_count as u64;
+
+    // Round up to whole cents.
+    (centi_cents_per_second * seconds).div_ceil(100)
+  }
 }
 
 #[cfg(test)]
@@ -92,6 +137,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 2), 250);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 375);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 500);
@@ -119,6 +169,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 100);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 150);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 200);
@@ -141,6 +196,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 2), 500);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 3), 750);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 4), 1000);
@@ -164,18 +224,20 @@ mod tests {
 
     #[test]
     fn explicit_4k_without_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, false), 347);
-      assert_eq!(artcraft_4k_cents(5, 1, false), 433);
-      assert_eq!(artcraft_4k_cents(10, 1, false), 866);
-      assert_eq!(artcraft_4k_cents(15, 1, false), 1299);
+      // 95.00 ¢/s card, rounded up to whole cents.
+      assert_eq!(artcraft_4k_cents(4, 1, false), 380);
+      assert_eq!(artcraft_4k_cents(5, 1, false), 475);
+      assert_eq!(artcraft_4k_cents(10, 1, false), 950);
+      assert_eq!(artcraft_4k_cents(15, 1, false), 1425);
     }
 
     #[test]
     fn explicit_4k_with_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, true), 416);
-      assert_eq!(artcraft_4k_cents(5, 1, true), 519);
-      assert_eq!(artcraft_4k_cents(10, 1, true), 1038);
-      assert_eq!(artcraft_4k_cents(15, 1, true), 1557);
+      // 119.00 ¢/s with-reference card, rounded up to whole cents.
+      assert_eq!(artcraft_4k_cents(4, 1, true), 476);
+      assert_eq!(artcraft_4k_cents(5, 1, true), 595);
+      assert_eq!(artcraft_4k_cents(10, 1, true), 1190);
+      assert_eq!(artcraft_4k_cents(15, 1, true), 1785);
     }
   }
 
@@ -228,4 +290,74 @@ mod tests {
   fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16, video_batch_count: u16) -> u64 {
     build_cost(resolution, duration_seconds, video_batch_count).cost_in_usd_cents.unwrap()
   }
+
+  // ── Video reference deltas ──
+  //
+  // References price on the with-reference rate card (10.20/25.70/57.80/113.80 ¢/s); the delta must be positive at every resolution and duration.
+
+  mod video_reference_deltas {
+    use enums::common::generation::common_resolution::CommonResolution;
+
+    use super::super::ArtcraftSeedance2p0BytePlusCostState;
+
+    #[test]
+    fn refs_cost_more_at_480p() {
+      assert_ref_delta(CommonResolution::FourEightyP, 5, 50, 51, 1);
+      assert_ref_delta(CommonResolution::FourEightyP, 10, 100, 102, 2);
+      assert_ref_delta(CommonResolution::FourEightyP, 15, 150, 153, 3);
+    }
+
+    #[test]
+    fn refs_cost_more_at_720p() {
+      assert_ref_delta(CommonResolution::SevenTwentyP, 5, 125, 129, 4);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 10, 250, 257, 7);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 15, 375, 386, 11);
+    }
+
+    #[test]
+    fn refs_cost_more_at_1080p() {
+      assert_ref_delta(CommonResolution::TenEightyP, 5, 250, 289, 39);
+      assert_ref_delta(CommonResolution::TenEightyP, 10, 500, 578, 78);
+      assert_ref_delta(CommonResolution::TenEightyP, 15, 750, 867, 117);
+    }
+
+    #[test]
+    fn refs_cost_more_at_4k() {
+      assert_ref_delta(CommonResolution::FourK, 5, 475, 595, 120);
+      assert_ref_delta(CommonResolution::FourK, 10, 950, 1190, 240);
+      assert_ref_delta(CommonResolution::FourK, 15, 1425, 1785, 360);
+    }
+
+    /// Price the same generation with and without a reference video; pin
+    /// both prices and the delta, in USD cents AND credits (credits equal
+    /// cents, and both must show references costing more).
+    fn assert_ref_delta(
+      resolution: CommonResolution,
+      duration_seconds: u16,
+      expected_no_ref: u64,
+      expected_with_ref: u64,
+      expected_delta: u64,
+    ) {
+      let no_ref = ArtcraftSeedance2p0BytePlusCostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: false,
+      }.estimate_cost();
+      let with_ref = ArtcraftSeedance2p0BytePlusCostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: true,
+      }.estimate_cost();
+
+      let no_ref_cents = no_ref.cost_in_usd_cents.unwrap();
+      let with_ref_cents = with_ref.cost_in_usd_cents.unwrap();
+      assert_eq!(no_ref_cents, expected_no_ref);
+      assert_eq!(with_ref_cents, expected_with_ref);
+      assert_eq!(with_ref_cents - no_ref_cents, expected_delta);
+      assert!(with_ref_cents > no_ref_cents, "references must cost more");
+
+      let no_ref_credits = no_ref.cost_in_credits.unwrap();
+      let with_ref_credits = with_ref.cost_in_credits.unwrap();
+      assert_eq!(no_ref_credits, expected_no_ref);
+      assert_eq!(with_ref_credits, expected_with_ref);
+      assert_eq!(with_ref_credits - no_ref_credits, expected_delta);
+    }
+  }
+
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bp_fast/cost.rs

@@ -9,10 +9,20 @@ use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp_fast::
 const CENTS_PER_SECOND_480P: f64 = 9.0;
 const CENTS_PER_SECOND_720P: f64 = 20.0;
 
+/// USD cents per second, in hundredths of a cent, when one or more
+/// reference videos are attached. Held as integer hundredths so the math is
+/// exact; rounded up to whole cents once, after multiplying by
+/// duration × batch.
+///   480p:  9.65 ¢/s
+///   720p: 20.50 ¢/s
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P: u64 = 965;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P: u64 = 2_050;
+
 pub struct ArtcraftSeedance2p0BytePlusFastCostState {
   pub resolution: CommonResolution,
   pub duration_seconds: u16,
   pub batch_count: u16,
+  pub has_video_reference: bool,
 }
 
 impl ArtcraftSeedance2p0BytePlusFastCostState {
@@ -21,10 +31,26 @@ impl ArtcraftSeedance2p0BytePlusFastCostState {
       .unwrap_or(CommonResolution::SevenTwentyP);
     let duration_seconds = request.request.duration_seconds.unwrap_or(5);
     let batch_count = request.request.video_batch_count.unwrap_or(1);
-    Self { resolution, duration_seconds, batch_count }
+    let has_video_reference = request.request.reference_video_media_tokens
+      .as_ref()
+      .is_some_and(|tokens| !tokens.is_empty());
+    Self { resolution, duration_seconds, batch_count, has_video_reference }
   }
 
   pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    if self.has_video_reference {
+      let usd_cents = self.with_video_reference_usd_cents();
+      return VideoGenerationCostEstimate {
+        cost_in_credits: Some(usd_cents),
+        cost_in_usd_cents: Some(usd_cents),
+        is_free: false,
+        is_unlimited: false,
+        is_rate_limited: false,
+        has_watermark: false,
+        failures_are_refunded: None,
+      };
+    }
+
     let cents_per_second = match self.resolution {
       CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
       _ => CENTS_PER_SECOND_720P,
@@ -42,6 +68,20 @@ impl ArtcraftSeedance2p0BytePlusFastCostState {
       failures_are_refunded: None,
     }
   }
+
+  /// Price when one or more reference videos are attached.
+  fn with_video_reference_usd_cents(&self) -> u64 {
+    let centi_cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P,
+      // Everything else (including 720p) prices at 720p.
+      _ => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P,
+    };
+
+    let seconds = self.duration_seconds as u64 * self.batch_count as u64;
+
+    // Round up to whole cents.
+    (centi_cents_per_second * seconds).div_ceil(100)
+  }
 }
 
 #[cfg(test)]
@@ -67,6 +107,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 2), 200);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 300);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 400);
@@ -94,6 +139,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 90);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 135);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 180);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bp_mini/build.rs

@@ -3,21 +3,28 @@ use enums::common::generation::common_video_model::CommonVideoModel as CommonVid
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
 use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
 use crate::generate::generate_video::providers::artcraft::build_common::{
-  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
+  build_artcraft_omni_video_request, plan_mini_batch_count, SupportedResolutions, UltraWideSupport,
 };
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp_mini::request::ArtcraftSeedance2p0BytePlusMiniRequestState;
 use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
 use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
 
-pub fn build_artcraft_seedance_2p0_bp_mini(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+pub fn build_artcraft_seedance_2p0_bp_mini(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
   // Seedance 2.0 Mini supports 480p and 720p only (higher resolutions downgrade
   // to 720p), and all six aspect ratios including 21:9.
-  let request = build_artcraft_omni_video_request(
+  // Mini supports batches of 1-8, wider than the shared 1/2/4 planning.
+  // Take the batch out before the shared build and set it after.
+  let strategy = builder.request_mismatch_mitigation_strategy;
+  let batch_count = plan_mini_batch_count(builder.video_batch_count.take(), strategy)?;
+
+  let mut request = build_artcraft_omni_video_request(
     builder,
     CommonVideoModelEnum::Seedance2p0BytePlusMini,
     SupportedResolutions::Fast,
     UltraWideSupport::Supported,
   )?;
+  request.video_batch_count = Some(batch_count);
+
   let state = ArtcraftSeedance2p0BytePlusMiniRequestState { request };
   Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p0BytePlusMini(state)))
 }
@@ -80,10 +87,18 @@ mod tests {
     }
 
     #[test]
-    fn batch_count_clamped_to_platform_max() {
-      // The ArtCraft platform caps batch at 4 and downgrades higher requests.
-      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(8); }));
-      assert_eq!(req.request.video_batch_count, Some(4));
+    fn batch_count_up_to_eight_passed_through() {
+      // Mini supports batches of 1-8; execution and billing must agree.
+      for batch in 1..=8u16 {
+        let req = unwrap_request(builder_with(move |b| { b.video_batch_count = Some(batch); }));
+        assert_eq!(req.request.video_batch_count, Some(batch));
+      }
+    }
+
+    #[test]
+    fn batch_count_above_eight_clamps_to_eight() {
+      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(9); }));
+      assert_eq!(req.request.video_batch_count, Some(8));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bp_mini/cost.rs

@@ -65,18 +65,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 14);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 33);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 50);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 15);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 36);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 54);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 21);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 42);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 63);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 23);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 45);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 68);
     }
   }
 
@@ -85,18 +85,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 35);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 44);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 88);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 131);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 37);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 46);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 91);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 137);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 42);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 53);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 105);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 158);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 44);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 55);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 110);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 165);
     }
 
     #[test]
@@ -105,6 +105,49 @@ mod tests {
     }
   }
 
+  mod batch_pricing {
+    use super::*;
+
+    /// Mini bills batches of 1-8 in full (the platform's 1/2/4 cap does not
+    /// apply). Once, batch 8 executed in full but billed as batch 4.
+    #[test]
+    fn every_batch_size_720p_5s() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 46);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 2, false), 91);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 3, false), 137);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 4, false), 182);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 5, false), 228);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 6, false), 273);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 7, false), 319);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, false), 364);
+    }
+
+    #[test]
+    fn every_batch_size_480p_5s() {
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 2, false), 36);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 3, false), 54);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 4, false), 71);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 5, false), 89);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 6, false), 107);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 7, false), 125);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 8, false), 142);
+    }
+
+    #[test]
+    fn batch_eight_with_video_reference() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, true), 438);
+    }
+
+    #[test]
+    fn batch_above_eight_clamps_to_eight() {
+      assert_eq!(
+        cents(RouterResolution::SevenTwentyP, 5, 9, false),
+        cents(RouterResolution::SevenTwentyP, 5, 8, false),
+      );
+    }
+  }
+
   mod credits_tests {
     use super::*;
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bpu/cost.rs

@@ -1,6 +1,5 @@
 use enums::common::generation::common_resolution::CommonResolution;
 
-use crate::generate::generate_video::providers::artcraft::seedance_common::seedance_2p0_four_k_usd_cents;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu::request::ArtcraftSeedance2p0BytePlusUltraRequestState;
 use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
 
@@ -12,6 +11,24 @@ const CENTS_PER_SECOND_480P: f64 = 10.0;
 const CENTS_PER_SECOND_720P: f64 = 25.0;
 const CENTS_PER_SECOND_1080P: f64 = 50.0;
 
+/// USD cents per second, in hundredths of a cent, when one or more
+/// reference videos are attached. Held as integer hundredths so the math is
+/// exact; rounded up to whole cents once, after multiplying by
+/// duration × batch.
+///   480p:  10.20 ¢/s
+///   720p:  25.70 ¢/s
+///   1080p: 57.80 ¢/s
+///   4K:   119.00 ¢/s
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P: u64 = 1_020;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P: u64 = 2_570;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_1080P: u64 = 5_780;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_4K: u64 = 11_900;
+
+/// 4K output price with no reference videos, in hundredths of a USD cent
+/// per second (95.00 ¢/s), rounded up to whole cents after multiplying by
+/// duration × batch.
+const CENTI_CENTS_PER_SECOND_4K: u64 = 9_500;
+
 pub struct ArtcraftSeedance2p0BytePlusUltraCostState {
   pub resolution: CommonResolution,
   pub duration_seconds: u16,
@@ -32,12 +49,24 @@ impl ArtcraftSeedance2p0BytePlusUltraCostState {
   }
 
   pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    if self.has_video_reference {
+      let usd_cents = self.with_video_reference_usd_cents();
+      return VideoGenerationCostEstimate {
+        cost_in_credits: Some(usd_cents),
+        cost_in_usd_cents: Some(usd_cents),
+        is_free: false,
+        is_unlimited: false,
+        is_rate_limited: false,
+        has_watermark: false,
+        failures_are_refunded: None,
+      };
+    }
+
     if self.resolution == CommonResolution::FourK {
-      let usd_cents = seedance_2p0_four_k_usd_cents(
-        self.duration_seconds,
-        self.batch_count,
-        self.has_video_reference,
-      );
+      let total_centi_cents = CENTI_CENTS_PER_SECOND_4K
+        * self.duration_seconds as u64
+        * self.batch_count as u64;
+      let usd_cents = total_centi_cents.div_ceil(100);
       return VideoGenerationCostEstimate {
         cost_in_credits: Some(usd_cents),
         cost_in_usd_cents: Some(usd_cents),
@@ -67,6 +96,22 @@ impl ArtcraftSeedance2p0BytePlusUltraCostState {
       failures_are_refunded: None,
     }
   }
+
+  /// Price when one or more reference videos are attached.
+  fn with_video_reference_usd_cents(&self) -> u64 {
+    let centi_cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P,
+      CommonResolution::TenEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_1080P,
+      CommonResolution::FourK => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_4K,
+      // Everything else (including 720p) prices at 720p.
+      _ => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P,
+    };
+
+    let seconds = self.duration_seconds as u64 * self.batch_count as u64;
+
+    // Round up to whole cents.
+    (centi_cents_per_second * seconds).div_ceil(100)
+  }
 }
 
 #[cfg(test)]
@@ -92,6 +137,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 2), 250);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 375);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 500);
@@ -119,6 +169,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 100);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 150);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 200);
@@ -141,6 +196,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 2), 500);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 3), 750);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 4), 1000);
@@ -164,18 +224,20 @@ mod tests {
 
     #[test]
     fn explicit_4k_without_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, false), 347);
-      assert_eq!(artcraft_4k_cents(5, 1, false), 433);
-      assert_eq!(artcraft_4k_cents(10, 1, false), 866);
-      assert_eq!(artcraft_4k_cents(15, 1, false), 1299);
+      // 95.00 ¢/s card, rounded up to whole cents.
+      assert_eq!(artcraft_4k_cents(4, 1, false), 380);
+      assert_eq!(artcraft_4k_cents(5, 1, false), 475);
+      assert_eq!(artcraft_4k_cents(10, 1, false), 950);
+      assert_eq!(artcraft_4k_cents(15, 1, false), 1425);
     }
 
     #[test]
     fn explicit_4k_with_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, true), 416);
-      assert_eq!(artcraft_4k_cents(5, 1, true), 519);
-      assert_eq!(artcraft_4k_cents(10, 1, true), 1038);
-      assert_eq!(artcraft_4k_cents(15, 1, true), 1557);
+      // 119.00 ¢/s with-reference card, rounded up to whole cents.
+      assert_eq!(artcraft_4k_cents(4, 1, true), 476);
+      assert_eq!(artcraft_4k_cents(5, 1, true), 595);
+      assert_eq!(artcraft_4k_cents(10, 1, true), 1190);
+      assert_eq!(artcraft_4k_cents(15, 1, true), 1785);
     }
   }
 
@@ -228,4 +290,74 @@ mod tests {
   fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16, video_batch_count: u16) -> u64 {
     build_cost(resolution, duration_seconds, video_batch_count).cost_in_usd_cents.unwrap()
   }
+
+  // ── Video reference deltas ──
+  //
+  // References price on the with-reference rate card (10.20/25.70/57.80/113.80 ¢/s); the delta must be positive at every resolution and duration.
+
+  mod video_reference_deltas {
+    use enums::common::generation::common_resolution::CommonResolution;
+
+    use super::super::ArtcraftSeedance2p0BytePlusUltraCostState;
+
+    #[test]
+    fn refs_cost_more_at_480p() {
+      assert_ref_delta(CommonResolution::FourEightyP, 5, 50, 51, 1);
+      assert_ref_delta(CommonResolution::FourEightyP, 10, 100, 102, 2);
+      assert_ref_delta(CommonResolution::FourEightyP, 15, 150, 153, 3);
+    }
+
+    #[test]
+    fn refs_cost_more_at_720p() {
+      assert_ref_delta(CommonResolution::SevenTwentyP, 5, 125, 129, 4);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 10, 250, 257, 7);
+      assert_ref_delta(CommonResolution::SevenTwentyP, 15, 375, 386, 11);
+    }
+
+    #[test]
+    fn refs_cost_more_at_1080p() {
+      assert_ref_delta(CommonResolution::TenEightyP, 5, 250, 289, 39);
+      assert_ref_delta(CommonResolution::TenEightyP, 10, 500, 578, 78);
+      assert_ref_delta(CommonResolution::TenEightyP, 15, 750, 867, 117);
+    }
+
+    #[test]
+    fn refs_cost_more_at_4k() {
+      assert_ref_delta(CommonResolution::FourK, 5, 475, 595, 120);
+      assert_ref_delta(CommonResolution::FourK, 10, 950, 1190, 240);
+      assert_ref_delta(CommonResolution::FourK, 15, 1425, 1785, 360);
+    }
+
+    /// Price the same generation with and without a reference video; pin
+    /// both prices and the delta, in USD cents AND credits (credits equal
+    /// cents, and both must show references costing more).
+    fn assert_ref_delta(
+      resolution: CommonResolution,
+      duration_seconds: u16,
+      expected_no_ref: u64,
+      expected_with_ref: u64,
+      expected_delta: u64,
+    ) {
+      let no_ref = ArtcraftSeedance2p0BytePlusUltraCostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: false,
+      }.estimate_cost();
+      let with_ref = ArtcraftSeedance2p0BytePlusUltraCostState {
+        resolution, duration_seconds, batch_count: 1, has_video_reference: true,
+      }.estimate_cost();
+
+      let no_ref_cents = no_ref.cost_in_usd_cents.unwrap();
+      let with_ref_cents = with_ref.cost_in_usd_cents.unwrap();
+      assert_eq!(no_ref_cents, expected_no_ref);
+      assert_eq!(with_ref_cents, expected_with_ref);
+      assert_eq!(with_ref_cents - no_ref_cents, expected_delta);
+      assert!(with_ref_cents > no_ref_cents, "references must cost more");
+
+      let no_ref_credits = no_ref.cost_in_credits.unwrap();
+      let with_ref_credits = with_ref.cost_in_credits.unwrap();
+      assert_eq!(no_ref_credits, expected_no_ref);
+      assert_eq!(with_ref_credits, expected_with_ref);
+      assert_eq!(with_ref_credits - no_ref_credits, expected_delta);
+    }
+  }
+
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bpu_fast/cost.rs

@@ -9,10 +9,20 @@ use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu_fast:
 const CENTS_PER_SECOND_480P: f64 = 9.0;
 const CENTS_PER_SECOND_720P: f64 = 20.0;
 
+/// USD cents per second, in hundredths of a cent, when one or more
+/// reference videos are attached. Held as integer hundredths so the math is
+/// exact; rounded up to whole cents once, after multiplying by
+/// duration × batch.
+///   480p:  9.65 ¢/s
+///   720p: 20.50 ¢/s
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P: u64 = 965;
+const WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P: u64 = 2_050;
+
 pub struct ArtcraftSeedance2p0BytePlusUltraFastCostState {
   pub resolution: CommonResolution,
   pub duration_seconds: u16,
   pub batch_count: u16,
+  pub has_video_reference: bool,
 }
 
 impl ArtcraftSeedance2p0BytePlusUltraFastCostState {
@@ -21,10 +31,26 @@ impl ArtcraftSeedance2p0BytePlusUltraFastCostState {
       .unwrap_or(CommonResolution::SevenTwentyP);
     let duration_seconds = request.request.duration_seconds.unwrap_or(5);
     let batch_count = request.request.video_batch_count.unwrap_or(1);
-    Self { resolution, duration_seconds, batch_count }
+    let has_video_reference = request.request.reference_video_media_tokens
+      .as_ref()
+      .is_some_and(|tokens| !tokens.is_empty());
+    Self { resolution, duration_seconds, batch_count, has_video_reference }
   }
 
   pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    if self.has_video_reference {
+      let usd_cents = self.with_video_reference_usd_cents();
+      return VideoGenerationCostEstimate {
+        cost_in_credits: Some(usd_cents),
+        cost_in_usd_cents: Some(usd_cents),
+        is_free: false,
+        is_unlimited: false,
+        is_rate_limited: false,
+        has_watermark: false,
+        failures_are_refunded: None,
+      };
+    }
+
     let cents_per_second = match self.resolution {
       CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
       _ => CENTS_PER_SECOND_720P,
@@ -42,6 +68,20 @@ impl ArtcraftSeedance2p0BytePlusUltraFastCostState {
       failures_are_refunded: None,
     }
   }
+
+  /// Price when one or more reference videos are attached.
+  fn with_video_reference_usd_cents(&self) -> u64 {
+    let centi_cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_480P,
+      // Everything else (including 720p) prices at 720p.
+      _ => WITH_VIDEO_REFERENCE_CENTI_CENTS_PER_SECOND_720P,
+    };
+
+    let seconds = self.duration_seconds as u64 * self.batch_count as u64;
+
+    // Round up to whole cents.
+    (centi_cents_per_second * seconds).div_ceil(100)
+  }
 }
 
 #[cfg(test)]
@@ -67,6 +107,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 2), 200);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 300);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 400);
@@ -94,6 +139,11 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 90);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 135);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 180);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bpu_mini/build.rs

@@ -3,21 +3,28 @@ use enums::common::generation::common_video_model::CommonVideoModel as CommonVid
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
 use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
 use crate::generate::generate_video::providers::artcraft::build_common::{
-  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
+  build_artcraft_omni_video_request, plan_mini_batch_count, SupportedResolutions, UltraWideSupport,
 };
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu_mini::request::ArtcraftSeedance2p0BytePlusUltraMiniRequestState;
 use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
 use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
 
-pub fn build_artcraft_seedance_2p0_bpu_mini(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+pub fn build_artcraft_seedance_2p0_bpu_mini(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
   // Seedance 2.0 Mini supports 480p and 720p only (higher resolutions downgrade
   // to 720p), and all six aspect ratios including 21:9.
-  let request = build_artcraft_omni_video_request(
+  // Mini supports batches of 1-8, wider than the shared 1/2/4 planning.
+  // Take the batch out before the shared build and set it after.
+  let strategy = builder.request_mismatch_mitigation_strategy;
+  let batch_count = plan_mini_batch_count(builder.video_batch_count.take(), strategy)?;
+
+  let mut request = build_artcraft_omni_video_request(
     builder,
     CommonVideoModelEnum::Seedance2p0BytePlusUltraMini,
     SupportedResolutions::Fast,
     UltraWideSupport::Supported,
   )?;
+  request.video_batch_count = Some(batch_count);
+
   let state = ArtcraftSeedance2p0BytePlusUltraMiniRequestState { request };
   Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p0BytePlusUltraMini(state)))
 }
@@ -80,10 +87,18 @@ mod tests {
     }
 
     #[test]
-    fn batch_count_clamped_to_platform_max() {
-      // The ArtCraft platform caps batch at 4 and downgrades higher requests.
-      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(8); }));
-      assert_eq!(req.request.video_batch_count, Some(4));
+    fn batch_count_up_to_eight_passed_through() {
+      // Mini supports batches of 1-8; execution and billing must agree.
+      for batch in 1..=8u16 {
+        let req = unwrap_request(builder_with(move |b| { b.video_batch_count = Some(batch); }));
+        assert_eq!(req.request.video_batch_count, Some(batch));
+      }
+    }
+
+    #[test]
+    fn batch_count_above_eight_clamps_to_eight() {
+      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(9); }));
+      assert_eq!(req.request.video_batch_count, Some(8));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_bpu_mini/cost.rs

@@ -65,18 +65,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 14);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 33);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 50);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 15);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 36);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 54);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 21);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 42);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 63);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 23);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 45);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 68);
     }
   }
 
@@ -85,18 +85,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 35);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 44);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 88);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 131);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 37);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 46);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 91);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 137);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 42);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 53);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 105);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 158);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 44);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 55);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 110);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 165);
     }
 
     #[test]
@@ -105,6 +105,49 @@ mod tests {
     }
   }
 
+  mod batch_pricing {
+    use super::*;
+
+    /// Mini bills batches of 1-8 in full (the platform's 1/2/4 cap does not
+    /// apply). Once, batch 8 executed in full but billed as batch 4.
+    #[test]
+    fn every_batch_size_720p_5s() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 46);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 2, false), 91);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 3, false), 137);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 4, false), 182);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 5, false), 228);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 6, false), 273);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 7, false), 319);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, false), 364);
+    }
+
+    #[test]
+    fn every_batch_size_480p_5s() {
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 2, false), 36);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 3, false), 54);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 4, false), 71);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 5, false), 89);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 6, false), 107);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 7, false), 125);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 8, false), 142);
+    }
+
+    #[test]
+    fn batch_eight_with_video_reference() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, true), 438);
+    }
+
+    #[test]
+    fn batch_above_eight_clamps_to_eight() {
+      assert_eq!(
+        cents(RouterResolution::SevenTwentyP, 5, 9, false),
+        cents(RouterResolution::SevenTwentyP, 5, 8, false),
+      );
+    }
+  }
+
   mod credits_tests {
     use super::*;
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_fast/cost.rs

@@ -13,7 +13,7 @@ use crate::generate::generate_video::providers::artcraft::seedance_2p0_fast::req
 ///
 /// Kept as f64 because per-second rates are fractional; rounding happens
 /// once at the end after multiplying by duration * batch.
-const CENTS_PER_SECOND_480P: f64 = 5.181;
+const CENTS_PER_SECOND_480P: f64 = 6.40;
 const CENTS_PER_SECOND_720P: f64 = 12.727;
 
 /// USD cents per second, in hundredths of a cent, when one or more
@@ -122,6 +122,13 @@ mod tests {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 2), 382);
     }
 
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 4, 3), 153);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 3), 191);
+      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 3), 573);
+    }
+
     #[test]
     fn batch_4() {
       assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 4, 4), 204);
@@ -142,20 +149,25 @@ mod tests {
 
     #[test]
     fn batch_1() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 4, 1), 21);
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 1), 26);
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 1), 52);
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15, 1), 78);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 4, 1), 26);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 1), 32);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 1), 64);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15, 1), 96);
     }
 
     #[test]
     fn batch_2() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 52);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 2), 64);
+    }
+
+        #[test]
+    fn batch_3() {
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 3), 96);
     }
 
     #[test]
     fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 104);
+      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 4), 128);
     }
   }
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_mini/build.rs

@@ -3,21 +3,28 @@ use enums::common::generation::common_video_model::CommonVideoModel as CommonVid
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
 use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
 use crate::generate::generate_video::providers::artcraft::build_common::{
-  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
+  build_artcraft_omni_video_request, plan_mini_batch_count, SupportedResolutions, UltraWideSupport,
 };
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_mini::request::ArtcraftSeedance2p0MiniRequestState;
 use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
 use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
 
-pub fn build_artcraft_seedance_2p0_mini(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+pub fn build_artcraft_seedance_2p0_mini(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
   // Seedance 2.0 Mini supports 480p and 720p only (higher resolutions downgrade
   // to 720p), and all six aspect ratios including 21:9.
-  let request = build_artcraft_omni_video_request(
+  // Mini supports batches of 1-8, wider than the shared 1/2/4 planning.
+  // Take the batch out before the shared build and set it after.
+  let strategy = builder.request_mismatch_mitigation_strategy;
+  let batch_count = plan_mini_batch_count(builder.video_batch_count.take(), strategy)?;
+
+  let mut request = build_artcraft_omni_video_request(
     builder,
     CommonVideoModelEnum::Seedance2p0Mini,
     SupportedResolutions::Fast,
     UltraWideSupport::Supported,
   )?;
+  request.video_batch_count = Some(batch_count);
+
   let state = ArtcraftSeedance2p0MiniRequestState { request };
   Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p0Mini(state)))
 }
@@ -80,10 +87,18 @@ mod tests {
     }
 
     #[test]
-    fn batch_count_clamped_to_platform_max() {
-      // The ArtCraft platform caps batch at 4 and downgrades higher requests.
-      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(8); }));
-      assert_eq!(req.request.video_batch_count, Some(4));
+    fn batch_count_up_to_eight_passed_through() {
+      // Mini supports batches of 1-8; execution and billing must agree.
+      for batch in 1..=8u16 {
+        let req = unwrap_request(builder_with(move |b| { b.video_batch_count = Some(batch); }));
+        assert_eq!(req.request.video_batch_count, Some(batch));
+      }
+    }
+
+    #[test]
+    fn batch_count_above_eight_clamps_to_eight() {
+      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(9); }));
+      assert_eq!(req.request.video_batch_count, Some(8));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_mini/cost.rs

@@ -65,18 +65,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 13);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 33);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 49);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, false), 14);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, false), 35);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, false), 52);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 17);
-      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 21);
-      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 42);
-      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 62);
+      assert_eq!(cents(RouterResolution::FourEightyP, 4, 1, true), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, true), 22);
+      assert_eq!(cents(RouterResolution::FourEightyP, 10, 1, true), 44);
+      assert_eq!(cents(RouterResolution::FourEightyP, 15, 1, true), 66);
     }
   }
 
@@ -85,18 +85,18 @@ mod tests {
 
     #[test]
     fn without_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 35);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 44);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 87);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 130);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, false), 36);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 45);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, false), 89);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, false), 134);
     }
 
     #[test]
     fn with_video_reference() {
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 42);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 52);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 104);
-      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 156);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 4, 1, true), 43);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, true), 54);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 10, 1, true), 108);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 15, 1, true), 161);
     }
 
     #[test]
@@ -105,6 +105,49 @@ mod tests {
     }
   }
 
+  mod batch_pricing {
+    use super::*;
+
+    /// Mini bills batches of 1-8 in full (the platform's 1/2/4 cap does not
+    /// apply). Once, batch 8 executed in full but billed as batch 4.
+    #[test]
+    fn every_batch_size_720p_5s() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 1, false), 45);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 2, false), 89);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 3, false), 134);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 4, false), 178);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 5, false), 223);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 6, false), 267);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 7, false), 312);
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, false), 356);
+    }
+
+    #[test]
+    fn every_batch_size_480p_5s() {
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 1, false), 18);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 2, false), 35);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 3, false), 52);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 4, false), 69);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 5, false), 87);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 6, false), 104);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 7, false), 121);
+      assert_eq!(cents(RouterResolution::FourEightyP, 5, 8, false), 138);
+    }
+
+    #[test]
+    fn batch_eight_with_video_reference() {
+      assert_eq!(cents(RouterResolution::SevenTwentyP, 5, 8, true), 429);
+    }
+
+    #[test]
+    fn batch_above_eight_clamps_to_eight() {
+      assert_eq!(
+        cents(RouterResolution::SevenTwentyP, 5, 9, false),
+        cents(RouterResolution::SevenTwentyP, 5, 8, false),
+      );
+    }
+  }
+
   mod credits_tests {
     use super::*;
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u/build.rs

@@ -1,189 +0,0 @@
-use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
-
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-use crate::generate::generate_video::providers::artcraft::build_common::{
-  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
-};
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u::request::ArtcraftSeedance2p0UltraRequestState;
-use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-pub fn build_artcraft_seedance_2p0_u(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
-  let request = build_artcraft_omni_video_request(
-    builder,
-    CommonVideoModelEnum::Seedance2p0Ultra,
-    SupportedResolutions::FullWith4k,
-    UltraWideSupport::Supported,
-  )?;
-  let state = ArtcraftSeedance2p0UltraRequestState { request };
-  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p0Ultra(state)))
-}
-
-#[cfg(test)]
-mod tests {
-  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
-  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
-  use enums::common::generation::common_bitrate::CommonBitrate as CommonBitrateEnum;
-  use crate::api::router_bitrate::RouterBitrate;
-  use tokens::tokens::characters::CharacterToken;
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::character_list_ref::CharacterListRef;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-  use super::*;
-
-  // ── Field conversions ──
-
-  mod field_conversions {
-    use super::*;
-
-    #[test]
-    fn model_is_seedance_2p0() {
-      let req = unwrap_request(make_builder(|_| {}));
-      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::Seedance2p0Ultra)));
-    }
-
-    #[test]
-    fn prompt_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.prompt = Some("test".to_string()); }));
-      assert_eq!(req.request.prompt, Some("test".to_string()));
-    }
-
-    #[test]
-    fn duration_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(10); }));
-      assert_eq!(req.request.duration_seconds, Some(10));
-    }
-
-    #[test]
-    fn duration_clamped_to_max() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(99); }));
-      assert_eq!(req.request.duration_seconds, Some(15));
-    }
-
-    #[test]
-    fn batch_count_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.video_batch_count = Some(4); }));
-      assert_eq!(req.request.video_batch_count, Some(4));
-    }
-
-    #[test]
-    fn bitrate_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.bitrate = Some(RouterBitrate::High); }));
-      assert_eq!(req.request.bitrate, Some(CommonBitrateEnum::High));
-    }
-  }
-
-  // ── Resolution ──
-
-  mod resolution_tests {
-    use super::*;
-
-    #[test]
-    fn res_480p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::FourEightyP); }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
-    }
-
-    #[test]
-    fn res_720p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::SevenTwentyP); }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
-    }
-
-    #[test]
-    fn res_1080p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::TenEightyP); }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::TenEightyP));
-    }
-
-    #[test]
-    fn res_4k() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::FourK); }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourK));
-    }
-
-    #[test]
-    fn none_stays_none() {
-      let req = unwrap_request(make_builder(|_| {}));
-      assert!(req.request.resolution.is_none());
-    }
-  }
-
-  // ── Media tokens ──
-
-  mod media_token_tests {
-    use super::*;
-
-    #[test]
-    fn start_frame_token_passed_through() {
-      let token = MediaFileToken::new("mf_start".to_string());
-      let req = unwrap_request(make_builder(|b| {
-        b.start_frame = Some(ImageRef::MediaFileToken(token.clone()));
-      }));
-      assert_eq!(req.request.start_frame_image_media_token, Some(token));
-    }
-
-    #[test]
-    fn url_start_frame_rejected() {
-      let result = build_artcraft_seedance_2p0_u(GenerateVideoRequestBuilder {
-        start_frame: Some(ImageRef::Url("https://example.com".to_string())),
-        ..base_builder()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn reference_image_tokens_passed_through() {
-      let tokens = vec![MediaFileToken::new("mf_a".to_string()), MediaFileToken::new("mf_b".to_string())];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_images = Some(ImageListRef::MediaFileTokens(tokens.clone()));
-      }));
-      assert_eq!(req.request.reference_image_media_tokens, Some(tokens));
-    }
-
-    #[test]
-    fn character_tokens_passed_through() {
-      let tokens = vec![CharacterToken::new("char_a".to_string()), CharacterToken::new("char_b".to_string())];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(tokens.clone()));
-      }));
-      assert_eq!(req.request.reference_character_tokens, Some(tokens));
-    }
-  }
-
-  // ── Helpers ──
-
-  fn base_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      provider: RouterProvider::Artcraft,
-      duration_seconds: Some(5),
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn make_builder(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
-    let mut builder = base_builder();
-    f(&mut builder);
-    builder
-  }
-
-  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftSeedance2p0UltraRequestState {
-    let result = build_artcraft_seedance_2p0_u(builder).expect("build should succeed");
-    match result {
-      VideoGenerationDraftOrRequest::Request(
-        VideoGenerationRequest::ArtcraftSeedance2p0Ultra(state)
-      ) => state,
-      _ => panic!("expected ArtcraftSeedance2p0 request"),
-    }
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u/cost.rs

@@ -1,237 +0,0 @@
-use enums::common::generation::common_resolution::CommonResolution;
-
-use crate::generate::generate_video::providers::artcraft::seedance_common::seedance_2p0_four_k_usd_cents;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u::request::ArtcraftSeedance2p0UltraRequestState;
-use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
-
-// ── Pricing constants ──
-
-const CENTS_PER_SECOND_480P: f64 = 5.4404;
-const CENTS_PER_SECOND_720P: f64 = 11.2;
-const CENTS_PER_SECOND_1080P: f64 = 32.6424;
-
-pub struct ArtcraftSeedance2p0UltraCostState {
-  pub resolution: CommonResolution,
-  pub duration_seconds: u16,
-  pub batch_count: u16,
-  pub has_video_reference: bool,
-}
-
-impl ArtcraftSeedance2p0UltraCostState {
-  pub fn from_request(request: &ArtcraftSeedance2p0UltraRequestState) -> Self {
-    let resolution = request.request.resolution
-      .unwrap_or(CommonResolution::SevenTwentyP);
-    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
-    let batch_count = request.request.video_batch_count.unwrap_or(1);
-    let has_video_reference = request.request.reference_video_media_tokens
-      .as_ref()
-      .is_some_and(|tokens| !tokens.is_empty());
-
-    Self { resolution, duration_seconds, batch_count, has_video_reference }
-  }
-
-  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
-    if self.resolution == CommonResolution::FourK {
-      let usd_cents = seedance_2p0_four_k_usd_cents(
-        self.duration_seconds,
-        self.batch_count,
-        self.has_video_reference,
-      );
-      return VideoGenerationCostEstimate {
-        cost_in_credits: Some(usd_cents),
-        cost_in_usd_cents: Some(usd_cents),
-        is_free: false,
-        is_unlimited: false,
-        is_rate_limited: false,
-        has_watermark: false,
-        failures_are_refunded: None,
-      };
-    }
-
-    let cents_per_second = match self.resolution {
-      CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
-      CommonResolution::TenEightyP => CENTS_PER_SECOND_1080P,
-      _ => CENTS_PER_SECOND_720P,
-    };
-
-    let cents_per_video = (cents_per_second * self.duration_seconds as f64).ceil() as u64;
-    let usd_cents = cents_per_video * self.batch_count as u64;
-
-    VideoGenerationCostEstimate {
-      cost_in_credits: Some(usd_cents),
-      cost_in_usd_cents: Some(usd_cents),
-      is_free: false,
-      is_unlimited: false,
-      is_rate_limited: false,
-      has_watermark: false,
-      failures_are_refunded: None,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_provider::RouterProvider;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-
-  mod pricing_720p {
-    use super::*;
-
-    #[test]
-    fn batch_1() {
-      // 11.2 * 5 = 56¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 1), 56);
-      // 11.2 * 10 = 112¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1), 112);
-      // 11.2 * 15 = 168¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 1), 168);
-    }
-
-    #[test]
-    fn batch_2() {
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 2), 112);
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 10, 2), 224);
-    }
-
-    #[test]
-    fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 4), 224);
-    }
-
-    #[test]
-    fn none_defaults_to_720p() {
-      assert_eq!(cost_cents(None, 10, 1), cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1));
-    }
-  }
-
-  mod pricing_480p {
-    use super::*;
-
-    #[test]
-    fn batch_1() {
-      // 5.4404 * 5 = 27.202 → ceil = 28¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 1), 28);
-      // 5.4404 * 10 = 54.404 → ceil = 55¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 1), 55);
-      // 5.4404 * 15 = 81.606 → ceil = 82¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15, 1), 82);
-    }
-
-    #[test]
-    fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 4), 220);
-    }
-  }
-
-  mod pricing_1080p {
-    use super::*;
-
-    #[test]
-    fn batch_1() {
-      // 32.6424 * 5 = 163.212 → ceil = 164¢
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5, 1), 164);
-      // 32.6424 * 10 = 326.424 → ceil = 327¢
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 10, 1), 327);
-      // 32.6424 * 15 = 489.636 → ceil = 490¢
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 15, 1), 490);
-    }
-
-    #[test]
-    fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 10, 4), 1308);
-    }
-  }
-
-  mod four_k_pricing {
-    use enums::common::generation::common_resolution::CommonResolution;
-
-    fn artcraft_4k_cents(duration_seconds: u16, batch_count: u16, has_video_reference: bool) -> u64 {
-      super::super::ArtcraftSeedance2p0UltraCostState {
-        resolution: CommonResolution::FourK,
-        duration_seconds,
-        batch_count,
-        has_video_reference,
-      }
-      .estimate_cost()
-      .cost_in_usd_cents
-      .unwrap()
-    }
-
-    #[test]
-    fn explicit_4k_without_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, false), 347);
-      assert_eq!(artcraft_4k_cents(5, 1, false), 433);
-      assert_eq!(artcraft_4k_cents(10, 1, false), 866);
-      assert_eq!(artcraft_4k_cents(15, 1, false), 1299);
-    }
-
-    #[test]
-    fn explicit_4k_with_video_reference() {
-      assert_eq!(artcraft_4k_cents(4, 1, true), 416);
-      assert_eq!(artcraft_4k_cents(5, 1, true), 519);
-      assert_eq!(artcraft_4k_cents(10, 1, true), 1038);
-      assert_eq!(artcraft_4k_cents(15, 1, true), 1557);
-    }
-  }
-
-  mod relative_pricing {
-    use super::*;
-
-    #[test]
-    fn cost_480p_cheaper_than_720p_cheaper_than_1080p() {
-      let c480 = cost_cents(Some(RouterResolution::FourEightyP), 10, 1);
-      let c720 = cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1);
-      let c1080 = cost_cents(Some(RouterResolution::TenEightyP), 10, 1);
-      assert!(c480 < c720);
-      assert!(c720 < c1080);
-    }
-
-    #[test]
-    fn cost_scales_with_duration() {
-      let c5 = cost_cents(None, 5, 1);
-      let c10 = cost_cents(None, 10, 1);
-      let c15 = cost_cents(None, 15, 1);
-      assert!(c5 < c10);
-      assert!(c10 < c15);
-    }
-
-    #[test]
-    fn cost_scales_with_batch() {
-      let b1 = cost_cents(None, 10, 1);
-      let b2 = cost_cents(None, 10, 2);
-      let b4 = cost_cents(None, 10, 4);
-      assert!(b1 < b2);
-      assert!(b2 < b4);
-    }
-
-    #[test]
-    fn credits_equal_usd_cents() {
-      let cost = build_cost(None, 10, 1);
-      assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
-    }
-  }
-
-  // -- Helpers --
-
-  fn build_cost(
-    resolution: Option<RouterResolution>,
-    duration_seconds: u16,
-    video_batch_count: u16,
-  ) -> crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate {
-    let builder = GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0Ultra,
-      provider: RouterProvider::Artcraft,
-      resolution,
-      duration_seconds: Some(duration_seconds),
-      video_batch_count: Some(video_batch_count),
-      ..Default::default()
-    };
-    builder.build2().expect("build2").estimate_cost().expect("estimate_cost")
-  }
-
-  fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16, batch: u16) -> u64 {
-    build_cost(resolution, duration_seconds, batch).cost_in_usd_cents.unwrap()
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u/request.rs

@@ -1,237 +0,0 @@
-use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
-
-use crate::client::router_artcraft_client::RouterArtcraftClient;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-use crate::generate::generate_video::providers::artcraft::request_common::send_artcraft_omni_video_request;
-
-#[derive(Clone, Debug)]
-pub struct ArtcraftSeedance2p0UltraRequestState {
-  pub request: OmniGenVideoCostAndGenerateRequest,
-}
-
-impl ArtcraftSeedance2p0UltraRequestState {
-  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
-    send_artcraft_omni_video_request(&self.request, client).await
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use tokens::tokens::characters::CharacterToken;
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::character_list_ref::CharacterListRef;
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::client::router_artcraft_client::RouterArtcraftClient;
-  use crate::client::router_client::RouterClient;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
-  use artcraft_client::utils::api_host::ApiHost;
-
-  use test_data::web::character_tokens::{JIM, KNIGHT};
-  use test_data::web::image_media_tokens::{
-    FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN,
-    JUNO_AT_LAKE_PRODUCTION_MEDIA_TOKEN,
-    WHITE_HOUSE_SUNSET_PRODUCTION_MEDIA_TOKEN,
-  };
-
-  // -- Aspect ratio tests --
-
-  mod aspect_ratio_tests {
-    use super::*;
-
-    #[tokio::test]
-    #[ignore]
-    async fn landscape() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A corgi running through a field of wildflowers at sunset.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn portrait() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A cat sitting on a windowsill watching rain.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::TallNineBySixteen),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn square() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A hummingbird hovering near a flower.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::Square),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Resolution tests --
-
-  mod resolution_tests {
-    use super::*;
-
-    #[tokio::test]
-    #[ignore]
-    async fn res_480p() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A shiba inu playing in autumn leaves.".to_string()),
-        resolution: Some(RouterResolution::FourEightyP),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn res_720p() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A golden retriever catching a frisbee on the beach.".to_string()),
-        resolution: Some(RouterResolution::SevenTwentyP),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn res_1080p() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A fox walking through a snowy forest.".to_string()),
-        resolution: Some(RouterResolution::TenEightyP),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Modality tests --
-
-  mod modality_tests {
-    use super::*;
-    use test_data::web::image_media_tokens::TALL_MOCHI_WITH_GLASSES_PRODUCTION_MEDIA_TOKEN;
-
-    #[tokio::test]
-    #[ignore]
-    async fn text_to_video() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A whale breaching in the open ocean at dawn, cinematic.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn keyframe_start_and_end_frame() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("The dog walks from the lake to the forest.".to_string()),
-        start_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new(JUNO_AT_LAKE_PRODUCTION_MEDIA_TOKEN.to_string()))),
-        end_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new(FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN.to_string()))),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn image_references() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("The dog in @2 runs through the scenery in @1 towards the building in @3.".to_string()),
-        reference_images: Some(ImageListRef::MediaFileTokens(vec![
-          MediaFileToken::new(FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN.to_string()),
-          MediaFileToken::new(TALL_MOCHI_WITH_GLASSES_PRODUCTION_MEDIA_TOKEN.to_string()),
-          MediaFileToken::new(WHITE_HOUSE_SUNSET_PRODUCTION_MEDIA_TOKEN.to_string()),
-        ])),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn character_references() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("@Jim and @Knight are sparring in a medieval arena.".to_string()),
-        reference_character_tokens: Some(CharacterListRef::CharacterTokens(vec![
-          CharacterToken::new(JIM.token.to_string()),
-          CharacterToken::new(KNIGHT.token.to_string()),
-        ])),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Helpers --
-
-  fn artcraft_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      provider: RouterProvider::Artcraft,
-      duration_seconds: Some(4),
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn get_artcraft_client() -> RouterClient {
-    let cookies = std::fs::read_to_string("/Users/bt/Artcraft/credentials/artcraft_cookies.txt")
-      .expect("Failed to read artcraft cookies");
-    let cookies = cookies.trim().to_string();
-    let credentials = StorytellerCredentialSet::parse_multi_cookie_header(&cookies)
-      .expect("Failed to parse cookies")
-      .expect("No credentials found");
-    RouterClient::Artcraft(RouterArtcraftClient::new(ApiHost::Storyteller, credentials))
-  }
-
-  async fn run_pipeline(builder: GenerateVideoRequestBuilder) -> GenerateVideoResponse {
-    let client = get_artcraft_client();
-
-    let draft_or_request = builder.build2().expect("build2 should succeed");
-    let request = match draft_or_request {
-      VideoGenerationDraftOrRequest::Request(r) => r,
-      _ => panic!("expected Request variant (Artcraft skips draft)"),
-    };
-
-    let response = request.send_request(&client).await.expect("send_request should succeed");
-
-    match &response {
-      GenerateVideoResponse::Artcraft(p) => {
-        println!("inference_job_token={:?}", p.inference_job_token);
-        println!("all_inference_job_tokens={:?}", p.all_inference_job_tokens);
-      }
-      other => println!("response: {:?}", other),
-    }
-
-    response
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u_fast/build.rs

@@ -1,253 +0,0 @@
-use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
-
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-use crate::generate::generate_video::providers::artcraft::build_common::{
-  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
-};
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u_fast::request::ArtcraftSeedance2p0UltraFastRequestState;
-use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-pub fn build_artcraft_seedance_2p0_u_fast(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
-  let request = build_artcraft_omni_video_request(
-    builder,
-    CommonVideoModelEnum::Seedance2p0UltraFast,
-    SupportedResolutions::Fast,
-    UltraWideSupport::Supported,
-  )?;
-  let state = ArtcraftSeedance2p0UltraFastRequestState { request };
-  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p0UltraFast(state)))
-}
-
-#[cfg(test)]
-mod tests {
-  use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
-  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
-  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
-  use enums::common::generation::common_bitrate::CommonBitrate as CommonBitrateEnum;
-  use crate::api::router_bitrate::RouterBitrate;
-  use tokens::tokens::characters::CharacterToken;
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::character_list_ref::CharacterListRef;
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::api::video_list_ref::VideoListRef;
-  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-  use super::*;
-
-  // ── Field conversions ──
-
-  mod field_conversions {
-    use super::*;
-
-    #[test]
-    fn prompt_is_passed_through() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| { b.prompt = Some("test".to_string()); }));
-      assert_eq!(req.request.prompt, Some("test".to_string()));
-    }
-
-    #[test]
-    fn prompt_none_stays_none() {
-      let req = unwrap_request(artcraft_fast_builder_with(|_| {}));
-      assert!(req.request.prompt.is_none());
-    }
-
-    #[test]
-    fn model_is_seedance_2p0_fast() {
-      let req = unwrap_request(artcraft_fast_builder_with(|_| {}));
-      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::Seedance2p0UltraFast)));
-    }
-
-    #[test]
-    fn duration_passed_through() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| { b.duration_seconds = Some(10); }));
-      assert_eq!(req.request.duration_seconds, Some(10));
-    }
-
-    #[test]
-    fn duration_clamped_to_max() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| { b.duration_seconds = Some(99); }));
-      assert_eq!(req.request.duration_seconds, Some(15));
-    }
-
-    #[test]
-    fn batch_count_passed_through() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| { b.video_batch_count = Some(4); }));
-      assert_eq!(req.request.video_batch_count, Some(4));
-    }
-
-    #[test]
-    fn bitrate_passed_through() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| { b.bitrate = Some(RouterBitrate::High); }));
-      assert_eq!(req.request.bitrate, Some(CommonBitrateEnum::High));
-    }
-  }
-
-  // ── Aspect ratio ──
-
-  mod aspect_ratio_tests {
-    use super::*;
-
-    #[test]
-    fn wide() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.aspect_ratio = Some(RouterAspectRatio::WideSixteenByNine);
-      }));
-      assert_eq!(req.request.aspect_ratio, Some(CommonAspectRatioEnum::WideSixteenByNine));
-    }
-
-    #[test]
-    fn tall() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.aspect_ratio = Some(RouterAspectRatio::TallNineBySixteen);
-      }));
-      assert_eq!(req.request.aspect_ratio, Some(CommonAspectRatioEnum::TallNineBySixteen));
-    }
-
-    #[test]
-    fn square() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.aspect_ratio = Some(RouterAspectRatio::Square);
-      }));
-      assert_eq!(req.request.aspect_ratio, Some(CommonAspectRatioEnum::Square));
-    }
-
-    #[test]
-    fn none_stays_none() {
-      let req = unwrap_request(artcraft_fast_builder_with(|_| {}));
-      assert!(req.request.aspect_ratio.is_none());
-    }
-  }
-
-  // ── Resolution ──
-
-  mod resolution_tests {
-    use super::*;
-
-    #[test]
-    fn res_480p() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.resolution = Some(RouterResolution::FourEightyP);
-      }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
-    }
-
-    #[test]
-    fn res_720p() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.resolution = Some(RouterResolution::SevenTwentyP);
-      }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
-    }
-
-    #[test]
-    fn res_1080p_downgrades_to_720p() {
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.resolution = Some(RouterResolution::TenEightyP);
-      }));
-      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
-    }
-
-    #[test]
-    fn res_1080p_error_out() {
-      let result = build_artcraft_seedance_2p0_u_fast(GenerateVideoRequestBuilder {
-        model: RouterVideoModel::Seedance2p0UltraFast,
-        provider: RouterProvider::Artcraft,
-        resolution: Some(RouterResolution::TenEightyP),
-        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
-        ..Default::default()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn none_stays_none() {
-      let req = unwrap_request(artcraft_fast_builder_with(|_| {}));
-      assert!(req.request.resolution.is_none());
-    }
-  }
-
-  // ── Media tokens ──
-
-  mod media_token_tests {
-    use super::*;
-
-    #[test]
-    fn start_frame_token_passed_through() {
-      let token = MediaFileToken::new("mf_start".to_string());
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.start_frame = Some(ImageRef::MediaFileToken(token.clone()));
-      }));
-      assert_eq!(req.request.start_frame_image_media_token, Some(token));
-    }
-
-    #[test]
-    fn url_start_frame_rejected() {
-      let result = build_artcraft_seedance_2p0_u_fast(GenerateVideoRequestBuilder {
-        model: RouterVideoModel::Seedance2p0UltraFast,
-        provider: RouterProvider::Artcraft,
-        start_frame: Some(ImageRef::Url("https://example.com".to_string())),
-        ..Default::default()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn reference_image_tokens_passed_through() {
-      let tokens = vec![
-        MediaFileToken::new("mf_a".to_string()),
-        MediaFileToken::new("mf_b".to_string()),
-      ];
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.reference_images = Some(ImageListRef::MediaFileTokens(tokens.clone()));
-      }));
-      assert_eq!(req.request.reference_image_media_tokens, Some(tokens));
-    }
-
-    #[test]
-    fn character_tokens_passed_through() {
-      let tokens = vec![
-        CharacterToken::new("char_a".to_string()),
-        CharacterToken::new("char_b".to_string()),
-      ];
-      let req = unwrap_request(artcraft_fast_builder_with(|b| {
-        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(tokens.clone()));
-      }));
-      assert_eq!(req.request.reference_character_tokens, Some(tokens));
-    }
-  }
-
-  // ── Helpers ──
-
-  fn artcraft_fast_builder_with(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
-    let mut builder = GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::Artcraft,
-      duration_seconds: Some(5),
-      video_batch_count: Some(1),
-      ..Default::default()
-    };
-    f(&mut builder);
-    builder
-  }
-
-  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftSeedance2p0UltraFastRequestState {
-    let result = build_artcraft_seedance_2p0_u_fast(builder).expect("build should succeed");
-    match result {
-      VideoGenerationDraftOrRequest::Request(
-        VideoGenerationRequest::ArtcraftSeedance2p0UltraFast(state)
-      ) => state,
-      _ => panic!("expected ArtcraftSeedance2p0Fast request"),
-    }
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u_fast/cost.rs

@@ -1,168 +0,0 @@
-use enums::common::generation::common_resolution::CommonResolution;
-
-use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u_fast::request::ArtcraftSeedance2p0UltraFastRequestState;
-
-// ── Pricing constants ──
-
-const CENTS_PER_SECOND_480P: f64 = 3.6267;
-const CENTS_PER_SECOND_720P: f64 = 8.9089;
-
-pub struct ArtcraftSeedance2p0UltraFastCostState {
-  pub resolution: CommonResolution,
-  pub duration_seconds: u16,
-  pub batch_count: u16,
-}
-
-impl ArtcraftSeedance2p0UltraFastCostState {
-  pub fn from_request(request: &ArtcraftSeedance2p0UltraFastRequestState) -> Self {
-    let resolution = request.request.resolution
-      .unwrap_or(CommonResolution::SevenTwentyP);
-    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
-    let batch_count = request.request.video_batch_count.unwrap_or(1);
-
-    Self { resolution, duration_seconds, batch_count }
-  }
-
-  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
-    let cents_per_second = match self.resolution {
-      CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
-      // Fast model doesn't support 1080p; all non-480p resolves to 720p pricing
-      _ => CENTS_PER_SECOND_720P,
-    };
-
-    let cents_per_video = (cents_per_second * self.duration_seconds as f64).ceil() as u64;
-    let usd_cents = cents_per_video * self.batch_count as u64;
-
-    VideoGenerationCostEstimate {
-      cost_in_credits: Some(usd_cents),
-      cost_in_usd_cents: Some(usd_cents),
-      is_free: false,
-      is_unlimited: false,
-      is_rate_limited: false,
-      has_watermark: false,
-      failures_are_refunded: None,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::router_provider::RouterProvider;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-
-  mod pricing_720p {
-    use super::*;
-
-    #[test]
-    fn batch_1() {
-      // 8.9089 * 5 = 44.5445 → ceil = 45¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5, 1), 45);
-      // 8.9089 * 10 = 89.089 → ceil = 90¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1), 90);
-      // 8.9089 * 15 = 133.6335 → ceil = 134¢
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 15, 1), 134);
-    }
-
-    #[test]
-    fn batch_2() {
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 10, 2), 180);
-    }
-
-    #[test]
-    fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 10, 4), 360);
-    }
-
-    #[test]
-    fn none_defaults_to_720p() {
-      assert_eq!(cost_cents(None, 10, 1), cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1));
-    }
-  }
-
-  mod pricing_480p {
-    use super::*;
-
-    #[test]
-    fn batch_1() {
-      // 3.6267 * 5 = 18.1335 → ceil = 19¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5, 1), 19);
-      // 3.6267 * 10 = 36.267 → ceil = 37¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 1), 37);
-      // 3.6267 * 15 = 54.4005 → ceil = 55¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15, 1), 55);
-    }
-
-    #[test]
-    fn batch_4() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10, 4), 148);
-    }
-  }
-
-  mod relative_pricing {
-    use super::*;
-
-    #[test]
-    fn cost_480p_cheaper_than_720p() {
-      let c480 = cost_cents(Some(RouterResolution::FourEightyP), 10, 1);
-      let c720 = cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1);
-      assert!(c480 < c720, "480p ({c480}) should be < 720p ({c720})");
-    }
-
-    #[test]
-    fn cost_scales_with_duration() {
-      let c5 = cost_cents(None, 5, 1);
-      let c10 = cost_cents(None, 10, 1);
-      let c15 = cost_cents(None, 15, 1);
-      assert!(c5 < c10);
-      assert!(c10 < c15);
-    }
-
-    #[test]
-    fn fast_g_cheaper_than_standard_g() {
-      let fast = cost_cents(Some(RouterResolution::SevenTwentyP), 10, 1);
-      let standard = {
-        let builder = GenerateVideoRequestBuilder {
-          model: RouterVideoModel::Seedance2p0Ultra,
-          provider: RouterProvider::Artcraft,
-          resolution: Some(RouterResolution::SevenTwentyP),
-          duration_seconds: Some(10),
-          video_batch_count: Some(1),
-          ..Default::default()
-        };
-        builder.build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
-      };
-      assert!(fast < standard, "Fast ({fast}¢) should be < Standard ({standard}¢)");
-    }
-
-    #[test]
-    fn credits_equal_usd_cents() {
-      let cost = build_cost(None, 10, 1);
-      assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
-    }
-  }
-
-  // -- Helpers --
-
-  fn build_cost(
-    resolution: Option<RouterResolution>,
-    duration_seconds: u16,
-    video_batch_count: u16,
-  ) -> crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate {
-    let builder = GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::Artcraft,
-      resolution,
-      duration_seconds: Some(duration_seconds),
-      video_batch_count: Some(video_batch_count),
-      ..Default::default()
-    };
-    builder.build2().expect("build2").estimate_cost().expect("estimate_cost")
-  }
-
-  fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16, batch: u16) -> u64 {
-    build_cost(resolution, duration_seconds, batch).cost_in_usd_cents.unwrap()
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p0_u_fast/request.rs

@@ -1,227 +0,0 @@
-use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
-
-use crate::client::router_artcraft_client::RouterArtcraftClient;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-use crate::generate::generate_video::providers::artcraft::request_common::send_artcraft_omni_video_request;
-
-#[derive(Clone, Debug)]
-pub struct ArtcraftSeedance2p0UltraFastRequestState {
-  pub request: OmniGenVideoCostAndGenerateRequest,
-}
-
-impl ArtcraftSeedance2p0UltraFastRequestState {
-  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
-    send_artcraft_omni_video_request(&self.request, client).await
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use tokens::tokens::characters::CharacterToken;
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::character_list_ref::CharacterListRef;
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::client::router_artcraft_client::RouterArtcraftClient;
-  use crate::client::router_client::RouterClient;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use artcraft_client::credentials::storyteller_credential_set::StorytellerCredentialSet;
-  use artcraft_client::utils::api_host::ApiHost;
-
-  use test_data::web::character_tokens::{JIM, KNIGHT};
-  use test_data::web::image_media_tokens::{
-    FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN,
-    JUNO_AT_LAKE_PRODUCTION_MEDIA_TOKEN,
-    WHITE_HOUSE_SUNSET_PRODUCTION_MEDIA_TOKEN,
-  };
-
-  // -- Aspect ratio tests --
-
-  mod aspect_ratio_tests {
-    use super::*;
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn landscape() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A corgi running through a field of wildflowers at sunset.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn portrait() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A cat sitting on a windowsill watching rain.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::TallNineBySixteen),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn square() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A hummingbird hovering near a flower.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::Square),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Resolution tests --
-
-  mod resolution_tests {
-    use super::*;
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn res_480p() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A shiba inu playing in autumn leaves.".to_string()),
-        resolution: Some(RouterResolution::FourEightyP),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn res_720p() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A golden retriever catching a frisbee on the beach.".to_string()),
-        resolution: Some(RouterResolution::SevenTwentyP),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Modality tests --
-
-  mod modality_tests {
-    use super::*;
-    use test_data::web::image_media_tokens::TALL_MOCHI_WITH_GLASSES_PRODUCTION_MEDIA_TOKEN;
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn text_to_video() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("A sky whale breaching in the open sky, pink clouds at dawn, cinematic.".to_string()),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn keyframe_start_and_end_frame() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("The dog walks from the lake to the forest.".to_string()),
-        start_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new(JUNO_AT_LAKE_PRODUCTION_MEDIA_TOKEN.to_string()))),
-        end_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new(FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN.to_string()))),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn image_references() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("The dog in @2 runs through the scenery in @1 towards the building in @3.".to_string()),
-        reference_images: Some(ImageListRef::MediaFileTokens(vec![
-          MediaFileToken::new(FOREST_BACKDROP_PRODUCTION_MEDIA_TOKEN.to_string()),
-          MediaFileToken::new(TALL_MOCHI_WITH_GLASSES_PRODUCTION_MEDIA_TOKEN.to_string()),
-          MediaFileToken::new(WHITE_HOUSE_SUNSET_PRODUCTION_MEDIA_TOKEN.to_string()),
-        ])),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-
-    #[tokio::test]
-    #[ignore] // manually run — fires a real API request and incurs cost
-    async fn character_references() {
-      let response = run_pipeline(GenerateVideoRequestBuilder {
-        prompt: Some("@Jim and @Knight are sparring in a medieval arena.".to_string()),
-        reference_character_tokens: Some(CharacterListRef::CharacterTokens(vec![
-          CharacterToken::new(JIM.token.to_string()),
-          CharacterToken::new(KNIGHT.token.to_string()),
-        ])),
-        aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-        ..artcraft_fast_builder()
-      }).await;
-      assert!(matches!(response, GenerateVideoResponse::Artcraft(_)));
-      assert_eq!(1, 2, "Inspect output above");
-    }
-  }
-
-  // -- Helpers --
-
-  fn artcraft_fast_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::Artcraft,
-      duration_seconds: Some(4),
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn get_artcraft_client() -> RouterClient {
-    let cookies = std::fs::read_to_string("/Users/bt/Artcraft/credentials/artcraft_cookies.txt")
-      .expect("Failed to read artcraft cookies");
-    let cookies = cookies.trim().to_string();
-    let credentials = StorytellerCredentialSet::parse_multi_cookie_header(&cookies)
-      .expect("Failed to parse cookies")
-      .expect("No credentials found");
-    RouterClient::Artcraft(RouterArtcraftClient::new(ApiHost::Storyteller, credentials))
-  }
-
-  async fn run_pipeline(builder: GenerateVideoRequestBuilder) -> GenerateVideoResponse {
-    let client = get_artcraft_client();
-
-    let draft_or_request = builder.build2().expect("build2 should succeed");
-    let request = match draft_or_request {
-      VideoGenerationDraftOrRequest::Request(r) => r,
-      _ => panic!("expected Request variant (Artcraft skips draft)"),
-    };
-
-    let response = request.send_request(&client).await.expect("send_request should succeed");
-
-    match &response {
-      GenerateVideoResponse::Artcraft(p) => {
-        println!("inference_job_token={:?}", p.inference_job_token);
-        println!("all_inference_job_tokens={:?}", p.all_inference_job_tokens);
-      }
-      other => println!("response: {:?}", other),
-    }
-
-    response
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5/build.rs

@@ -0,0 +1,244 @@
+use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+use crate::generate::generate_video::providers::artcraft::build_common::{
+  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
+};
+use crate::generate::generate_video::providers::artcraft::seedance_2p5::request::ArtcraftSeedance2p5RequestState;
+use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
+
+pub fn build_artcraft_seedance_2p5(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  // Parity with the Kinovi build: keyframes and reference media are mutually
+  // exclusive, an end frame requires a start frame, and there is no
+  // character support. Erroring here keeps the billing estimate consistent
+  // with the execution build.
+  let has_keyframes = builder.start_frame.is_some() || builder.end_frame.is_some();
+  let has_references = builder.reference_images.is_some()
+    || builder.reference_videos.is_some()
+    || builder.reference_audio.is_some();
+
+  if has_keyframes && has_references {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_images",
+      value: "Seedance 2.5 cannot combine keyframes with reference media; send one or the other".to_string(),
+    }));
+  }
+  if builder.end_frame.is_some() && builder.start_frame.is_none() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "end_frame",
+      value: "Seedance 2.5 requires a start frame when an end frame is set".to_string(),
+    }));
+  }
+  if builder.reference_character_tokens.is_some() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_character_tokens",
+      value: "Seedance 2.5 does not support character references".to_string(),
+    }));
+  }
+
+  // 2.5 allows 4-30 second durations (longer than the shared 4-15 range in
+  // build_common) and generates a single video per request. Plan both here,
+  // leaving None for the shared builder, then set them after.
+  let duration_seconds = plan_duration(builder.duration_seconds.take(), strategy)?;
+  plan_batch_count(builder.video_batch_count.take(), strategy)?;
+
+  let total_input_seconds = builder.total_reference_video_input_seconds.take();
+
+  let mut request = build_artcraft_omni_video_request(
+    builder,
+    CommonVideoModelEnum::Seedance2p5,
+    SupportedResolutions::Fast,
+    UltraWideSupport::Supported,
+  )?;
+  request.duration_seconds = duration_seconds;
+  request.video_batch_count = Some(1);
+
+  let state = ArtcraftSeedance2p5RequestState { request, total_input_seconds };
+  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p5(state)))
+}
+
+// Seedance 2.5 supports durations of 4-30 seconds.
+fn plan_duration(
+  duration_seconds: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<u16>, ArtcraftRouterError> {
+  const MIN: u16 = 4;
+  const MAX: u16 = 30;
+  match duration_seconds {
+    None => Ok(None),
+    Some(d) if d >= MIN && d <= MAX => Ok(Some(d)),
+    Some(d) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "duration_seconds",
+          value: format!("{}", d),
+        }))
+      }
+      _ => Ok(Some(d.clamp(MIN, MAX))),
+    },
+  }
+}
+
+// Seedance 2.5 generates a single video per request (no batching).
+fn plan_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<(), ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(()),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(()),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+  use tokens::tokens::characters::CharacterToken;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::character_list_ref::CharacterListRef;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::api::router_video_model::RouterVideoModel;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
+
+  use super::*;
+
+  mod field_conversions {
+    use super::*;
+
+    #[test]
+    fn model_is_correct() {
+      let req = unwrap_request(builder_with(|_| {}));
+      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::Seedance2p5)));
+    }
+
+    #[test]
+    fn duration_30_is_passed_through() {
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(30); }));
+      assert_eq!(req.request.duration_seconds, Some(30));
+    }
+
+    #[test]
+    fn duration_clamped_to_range() {
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(99); }));
+      assert_eq!(req.request.duration_seconds, Some(30));
+
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(2); }));
+      assert_eq!(req.request.duration_seconds, Some(4));
+    }
+
+    #[test]
+    fn batch_count_is_always_one() {
+      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(4); }));
+      assert_eq!(req.request.video_batch_count, Some(1));
+    }
+
+    #[test]
+    fn total_input_seconds_is_carried_through() {
+      let req = unwrap_request(builder_with(|b| { b.total_reference_video_input_seconds = Some(14); }));
+      assert_eq!(req.total_input_seconds, Some(14));
+    }
+  }
+
+  mod modality_rules {
+    use super::*;
+
+    #[test]
+    fn keyframes_are_accepted() {
+      let req = unwrap_request(builder_with(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_start".to_string())));
+        b.end_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_end".to_string())));
+      }));
+      assert!(req.request.start_frame_image_media_token.is_some());
+      assert!(req.request.end_frame_image_media_token.is_some());
+    }
+
+    #[test]
+    fn end_frame_without_start_frame_errors() {
+      let result = build_artcraft_seedance_2p5(builder_with(|b| {
+        b.end_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_end".to_string())));
+      }));
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn keyframes_plus_references_error() {
+      let result = build_artcraft_seedance_2p5(builder_with(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_start".to_string())));
+        b.reference_images = Some(ImageListRef::MediaFileTokens(vec![
+          MediaFileToken::new("mf_ref".to_string()),
+        ]));
+      }));
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn character_references_error() {
+      let result = build_artcraft_seedance_2p5(builder_with(|b| {
+        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(vec![
+          CharacterToken::new("char_abc".to_string()),
+        ]));
+      }));
+      assert!(result.is_err());
+    }
+  }
+
+  mod resolution_tests {
+    use super::*;
+
+    #[test]
+    fn res_480p() {
+      let req = unwrap_request(builder_with(|b| { b.resolution = Some(RouterResolution::FourEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
+    }
+
+    #[test]
+    fn res_1080p_downgrades_to_720p() {
+      let req = unwrap_request(builder_with(|b| { b.resolution = Some(RouterResolution::TenEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
+    }
+  }
+
+  fn builder_with(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
+    let mut builder = GenerateVideoRequestBuilder {
+      model: RouterVideoModel::Seedance2p5,
+      provider: RouterProvider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    };
+    f(&mut builder);
+    builder
+  }
+
+  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftSeedance2p5RequestState {
+    let result = build_artcraft_seedance_2p5(builder).expect("build should succeed");
+    match result {
+      VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p5(state)) => state,
+      _ => panic!("expected ArtcraftSeedance2p5 request"),
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5/cost.rs

@@ -0,0 +1,200 @@
+use enums::common::generation::common_resolution::CommonResolution;
+
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+use crate::generate::generate_video::providers::artcraft::seedance_common::seedance_2p5_usd_cents;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5::request::ArtcraftSeedance2p5RequestState;
+
+/// Seedance 2.5 pricing depends on the resolution, the output duration, and
+/// — when reference videos are attached — the total seconds of reference
+/// video input, which are billed on top of the output duration (at a lower
+/// per-second rate). The TOTAL input duration clamps to the 4..=30 second
+/// billing range. No batching.
+pub struct ArtcraftSeedance2p5CostState {
+  pub resolution: CommonResolution,
+  pub duration_seconds: u16,
+  pub has_video_references: bool,
+  pub maybe_total_input_seconds: Option<u16>,
+}
+
+impl ArtcraftSeedance2p5CostState {
+  pub fn from_request(request: &ArtcraftSeedance2p5RequestState) -> Self {
+    let resolution = request.request.resolution
+      .unwrap_or(CommonResolution::SevenTwentyP);
+    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
+
+    let has_video_references = request.request.reference_video_media_tokens
+      .as_ref()
+      .is_some_and(|tokens| !tokens.is_empty());
+
+    Self {
+      resolution,
+      duration_seconds,
+      has_video_references,
+      maybe_total_input_seconds: request.total_input_seconds,
+    }
+  }
+
+  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    // Input-second clamping (the 4..=30 billing range) and the
+    // unknown-or-zero-input failsafe happen inside the shared pricing
+    // function.
+    let maybe_total_input_seconds = self.maybe_total_input_seconds;
+
+    let usd_cents = seedance_2p5_usd_cents(
+      self.resolution,
+      self.duration_seconds,
+      self.has_video_references,
+      maybe_total_input_seconds,
+    );
+
+    // ArtCraft credits: 100 credits = $1.00, so credits = cents.
+    VideoGenerationCostEstimate {
+      cost_in_credits: Some(usd_cents),
+      cost_in_usd_cents: Some(usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::api::router_video_model::RouterVideoModel;
+  use crate::api::video_list_ref::VideoListRef;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+
+  use tokens::tokens::media_files::MediaFileToken;
+
+  mod pricing_without_video_references {
+    use super::*;
+
+    #[test]
+    fn table_480p() {
+      // 11.76954733 ¢/s, rounded up.
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 4), 48);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 5), 59);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 10), 118);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 30), 354);
+    }
+
+    #[test]
+    fn table_720p() {
+      // 26.70781893 ¢/s, rounded up.
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 4), 107);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 5), 134);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 10), 268);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 30), 802);
+    }
+
+    #[test]
+    fn none_defaults_to_720p() {
+      assert_eq!(cents(None, 10), cents(Some(RouterResolution::SevenTwentyP), 10));
+    }
+  }
+
+  mod pricing_with_video_references {
+    use super::*;
+
+    #[test]
+    fn thirty_second_output_with_ten_input_seconds_bills_forty() {
+      // 7.24279835 ¢/s × 40 = 289.71 → 290¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(10)), 290);
+      // 15.84362140 ¢/s × 40 = 633.74 → 634¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::SevenTwentyP), 30, Some(10)), 634);
+    }
+
+    #[test]
+    fn fourteen_input_seconds_bill_forty_four() {
+      // 7.24279835 ¢/s × 44 = 318.68 → 319¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(14)), 319);
+    }
+
+    #[test]
+    fn missing_or_zero_input_seconds_bill_the_thirty_second_maximum() {
+      // FAILSAFE: an unmeasured (or zero) input bills the 30-second MAXIMUM,
+      // matching the provider client's fallback:
+      // 7.24279835 ¢/s × (10+30) = 289.71 → 290¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, None), 290);
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(0)), 290);
+    }
+
+    #[test]
+    fn input_totals_under_four_seconds_clamp_to_four() {
+      // 1s, 3s, and 4s totals price identically; 5s bills more.
+      let at_minimum = cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(4));
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(1)), at_minimum);
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(3)), at_minimum);
+      assert!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(5)) > at_minimum);
+    }
+
+    #[test]
+    fn input_seconds_clamp_to_max_billed_input_seconds() {
+      // 200 input seconds clamp to 30: 7.24279835 ¢/s × (30+30) = 434.57 → 435¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(200)), 435);
+      assert_eq!(
+        cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(200)),
+        cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(30)),
+      );
+    }
+  }
+
+  mod credits_tests {
+    use super::*;
+
+    #[test]
+    fn credits_equal_usd_cents() {
+      for dur in [4u16, 10, 30] {
+        let estimate = estimate_with(|b| {
+          b.resolution = Some(RouterResolution::FourEightyP);
+          b.duration_seconds = Some(dur);
+        });
+        assert_eq!(estimate.cost_in_credits, estimate.cost_in_usd_cents);
+      }
+    }
+  }
+
+  // ── Helpers ──
+
+  fn estimate_with(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> VideoGenerationCostEstimate {
+    let mut builder = GenerateVideoRequestBuilder {
+      model: RouterVideoModel::Seedance2p5,
+      provider: RouterProvider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    };
+    f(&mut builder);
+    builder.build2()
+      .expect("build should succeed")
+      .estimate_cost()
+      .expect("estimate should succeed")
+  }
+
+  fn cents(resolution: Option<RouterResolution>, duration_seconds: u16) -> u64 {
+    estimate_with(|b| {
+      b.resolution = resolution;
+      b.duration_seconds = Some(duration_seconds);
+    }).cost_in_usd_cents.unwrap()
+  }
+
+  fn cents_with_video_refs(
+    resolution: Option<RouterResolution>,
+    duration_seconds: u16,
+    total_input_seconds: Option<u16>,
+  ) -> u64 {
+    estimate_with(|b| {
+      b.resolution = resolution;
+      b.duration_seconds = Some(duration_seconds);
+      b.reference_videos = Some(VideoListRef::MediaFileTokens(vec![
+        MediaFileToken::new("mf_ref".to_string()),
+      ]));
+      b.total_reference_video_input_seconds = total_input_seconds;
+    }).cost_in_usd_cents.unwrap()
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5/request.rs

@@ -0,0 +1,22 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
+
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
+use crate::generate::generate_video::providers::artcraft::request_common::send_artcraft_omni_video_request;
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftSeedance2p5RequestState {
+  pub request: OmniGenVideoCostAndGenerateRequest,
+
+  /// Calculation-only: total seconds of reference video input, billed on top
+  /// of the output duration when reference videos are attached. Not part of
+  /// the omni request wire shape.
+  pub total_input_seconds: Option<u16>,
+}
+
+impl ArtcraftSeedance2p5RequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+    send_artcraft_omni_video_request(&self.request, client).await
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5_u/build.rs

@@ -0,0 +1,244 @@
+use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+use crate::generate::generate_video::providers::artcraft::build_common::{
+  build_artcraft_omni_video_request, SupportedResolutions, UltraWideSupport,
+};
+use crate::generate::generate_video::providers::artcraft::seedance_2p5_u::request::ArtcraftSeedance2p5UltraRequestState;
+use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
+
+pub fn build_artcraft_seedance_2p5_u(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  // Parity with the Kinovi build: keyframes and reference media are mutually
+  // exclusive, an end frame requires a start frame, and there is no
+  // character support. Erroring here keeps the billing estimate consistent
+  // with the execution build.
+  let has_keyframes = builder.start_frame.is_some() || builder.end_frame.is_some();
+  let has_references = builder.reference_images.is_some()
+    || builder.reference_videos.is_some()
+    || builder.reference_audio.is_some();
+
+  if has_keyframes && has_references {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_images",
+      value: "Seedance 2.5 Ultra cannot combine keyframes with reference media; send one or the other".to_string(),
+    }));
+  }
+  if builder.end_frame.is_some() && builder.start_frame.is_none() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "end_frame",
+      value: "Seedance 2.5 Ultra requires a start frame when an end frame is set".to_string(),
+    }));
+  }
+  if builder.reference_character_tokens.is_some() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_character_tokens",
+      value: "Seedance 2.5 Ultra does not support character references".to_string(),
+    }));
+  }
+
+  // 2.5 allows 4-30 second durations (longer than the shared 4-15 range in
+  // build_common) and generates a single video per request. Plan both here,
+  // leaving None for the shared builder, then set them after.
+  let duration_seconds = plan_duration(builder.duration_seconds.take(), strategy)?;
+  plan_batch_count(builder.video_batch_count.take(), strategy)?;
+
+  let total_input_seconds = builder.total_reference_video_input_seconds.take();
+
+  let mut request = build_artcraft_omni_video_request(
+    builder,
+    CommonVideoModelEnum::Seedance2p5Ultra,
+    SupportedResolutions::Fast,
+    UltraWideSupport::Supported,
+  )?;
+  request.duration_seconds = duration_seconds;
+  request.video_batch_count = Some(1);
+
+  let state = ArtcraftSeedance2p5UltraRequestState { request, total_input_seconds };
+  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p5Ultra(state)))
+}
+
+// Seedance 2.5 supports durations of 4-30 seconds.
+fn plan_duration(
+  duration_seconds: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<u16>, ArtcraftRouterError> {
+  const MIN: u16 = 4;
+  const MAX: u16 = 30;
+  match duration_seconds {
+    None => Ok(None),
+    Some(d) if d >= MIN && d <= MAX => Ok(Some(d)),
+    Some(d) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "duration_seconds",
+          value: format!("{}", d),
+        }))
+      }
+      _ => Ok(Some(d.clamp(MIN, MAX))),
+    },
+  }
+}
+
+// Seedance 2.5 generates a single video per request (no batching).
+fn plan_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<(), ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(()),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(()),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+  use tokens::tokens::characters::CharacterToken;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::character_list_ref::CharacterListRef;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::api::router_video_model::RouterVideoModel;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
+
+  use super::*;
+
+  mod field_conversions {
+    use super::*;
+
+    #[test]
+    fn model_is_correct() {
+      let req = unwrap_request(builder_with(|_| {}));
+      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::Seedance2p5Ultra)));
+    }
+
+    #[test]
+    fn duration_30_is_passed_through() {
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(30); }));
+      assert_eq!(req.request.duration_seconds, Some(30));
+    }
+
+    #[test]
+    fn duration_clamped_to_range() {
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(99); }));
+      assert_eq!(req.request.duration_seconds, Some(30));
+
+      let req = unwrap_request(builder_with(|b| { b.duration_seconds = Some(2); }));
+      assert_eq!(req.request.duration_seconds, Some(4));
+    }
+
+    #[test]
+    fn batch_count_is_always_one() {
+      let req = unwrap_request(builder_with(|b| { b.video_batch_count = Some(4); }));
+      assert_eq!(req.request.video_batch_count, Some(1));
+    }
+
+    #[test]
+    fn total_input_seconds_is_carried_through() {
+      let req = unwrap_request(builder_with(|b| { b.total_reference_video_input_seconds = Some(14); }));
+      assert_eq!(req.total_input_seconds, Some(14));
+    }
+  }
+
+  mod modality_rules {
+    use super::*;
+
+    #[test]
+    fn keyframes_are_accepted() {
+      let req = unwrap_request(builder_with(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_start".to_string())));
+        b.end_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_end".to_string())));
+      }));
+      assert!(req.request.start_frame_image_media_token.is_some());
+      assert!(req.request.end_frame_image_media_token.is_some());
+    }
+
+    #[test]
+    fn end_frame_without_start_frame_errors() {
+      let result = build_artcraft_seedance_2p5_u(builder_with(|b| {
+        b.end_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_end".to_string())));
+      }));
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn keyframes_plus_references_error() {
+      let result = build_artcraft_seedance_2p5_u(builder_with(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_start".to_string())));
+        b.reference_images = Some(ImageListRef::MediaFileTokens(vec![
+          MediaFileToken::new("mf_ref".to_string()),
+        ]));
+      }));
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn character_references_error() {
+      let result = build_artcraft_seedance_2p5_u(builder_with(|b| {
+        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(vec![
+          CharacterToken::new("char_abc".to_string()),
+        ]));
+      }));
+      assert!(result.is_err());
+    }
+  }
+
+  mod resolution_tests {
+    use super::*;
+
+    #[test]
+    fn res_480p() {
+      let req = unwrap_request(builder_with(|b| { b.resolution = Some(RouterResolution::FourEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
+    }
+
+    #[test]
+    fn res_1080p_downgrades_to_720p() {
+      let req = unwrap_request(builder_with(|b| { b.resolution = Some(RouterResolution::TenEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
+    }
+  }
+
+  fn builder_with(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
+    let mut builder = GenerateVideoRequestBuilder {
+      model: RouterVideoModel::Seedance2p5Ultra,
+      provider: RouterProvider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    };
+    f(&mut builder);
+    builder
+  }
+
+  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftSeedance2p5UltraRequestState {
+    let result = build_artcraft_seedance_2p5_u(builder).expect("build should succeed");
+    match result {
+      VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftSeedance2p5Ultra(state)) => state,
+      _ => panic!("expected ArtcraftSeedance2p5Ultra request"),
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5_u/cost.rs

@@ -0,0 +1,224 @@
+use enums::common::generation::common_resolution::CommonResolution;
+
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+use crate::generate::generate_video::providers::artcraft::seedance_common::seedance_2p5_ultra_usd_cents;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5_u::request::ArtcraftSeedance2p5UltraRequestState;
+
+/// Seedance 2.5 Ultra pricing depends on the resolution, the output
+/// duration, and — when reference videos are attached — the total seconds of
+/// reference video input, which are billed on top of the output duration (at
+/// a lower per-second rate). Input seconds are clamped to
+/// [`MAX_BILLED_INPUT_SECONDS`] — the model accepts at most 30 seconds of
+/// video. No batching.
+pub struct ArtcraftSeedance2p5UltraCostState {
+  pub resolution: CommonResolution,
+  pub duration_seconds: u16,
+  pub has_video_references: bool,
+  pub maybe_total_input_seconds: Option<u16>,
+}
+
+impl ArtcraftSeedance2p5UltraCostState {
+  pub fn from_request(request: &ArtcraftSeedance2p5UltraRequestState) -> Self {
+    let resolution = request.request.resolution
+      .unwrap_or(CommonResolution::SevenTwentyP);
+    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
+
+    let has_video_references = request.request.reference_video_media_tokens
+      .as_ref()
+      .is_some_and(|tokens| !tokens.is_empty());
+
+    Self {
+      resolution,
+      duration_seconds,
+      has_video_references,
+      maybe_total_input_seconds: request.total_input_seconds,
+    }
+  }
+
+  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    // Input-second clamping (the 4..=30 billing range) and the
+    // unknown-or-zero-input failsafe happen inside the shared pricing
+    // function.
+    let maybe_total_input_seconds = self.maybe_total_input_seconds;
+
+    let usd_cents = seedance_2p5_ultra_usd_cents(
+      self.resolution,
+      self.duration_seconds,
+      self.has_video_references,
+      maybe_total_input_seconds,
+    );
+
+    // ArtCraft credits: 100 credits = $1.00, so credits = cents.
+    VideoGenerationCostEstimate {
+      cost_in_credits: Some(usd_cents),
+      cost_in_usd_cents: Some(usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::api::router_video_model::RouterVideoModel;
+  use crate::api::video_list_ref::VideoListRef;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+
+  use tokens::tokens::media_files::MediaFileToken;
+
+  mod pricing_without_video_references {
+    use super::*;
+
+    #[test]
+    fn table_480p() {
+      // 13.90946502 ¢/s, rounded up.
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 4), 56);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 5), 70);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 10), 140);
+      assert_eq!(cents(Some(RouterResolution::FourEightyP), 30), 418);
+    }
+
+    #[test]
+    fn table_720p() {
+      // 31.56378601 ¢/s, rounded up.
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 4), 127);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 5), 158);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 10), 316);
+      assert_eq!(cents(Some(RouterResolution::SevenTwentyP), 30), 947);
+    }
+
+    #[test]
+    fn none_defaults_to_720p() {
+      assert_eq!(cents(None, 10), cents(Some(RouterResolution::SevenTwentyP), 10));
+    }
+
+    #[test]
+    fn ultra_prices_above_regular_seedance_2p5() {
+      for (resolution, duration) in [
+        (RouterResolution::FourEightyP, 5u16),
+        (RouterResolution::FourEightyP, 30),
+        (RouterResolution::SevenTwentyP, 5),
+        (RouterResolution::SevenTwentyP, 30),
+      ] {
+        let ultra = cents(Some(resolution), duration);
+        let regular = estimate_for_model(RouterVideoModel::Seedance2p5, |b| {
+          b.resolution = Some(resolution);
+          b.duration_seconds = Some(duration);
+        }).cost_in_usd_cents.unwrap();
+        assert!(ultra > regular, "{resolution:?} {duration}s: ultra {ultra} <= regular {regular}");
+      }
+    }
+  }
+
+  mod pricing_with_video_references {
+    use super::*;
+
+    #[test]
+    fn thirty_second_output_with_ten_input_seconds_bills_forty() {
+      // 8.55967078 ¢/s × 40 = 342.39 → 343¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(10)), 343);
+      // 18.72427984 ¢/s × 40 = 748.97 → 749¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::SevenTwentyP), 30, Some(10)), 749);
+    }
+
+    #[test]
+    fn fourteen_input_seconds_bill_forty_four() {
+      // 8.55967078 ¢/s × 44 = 376.63 → 377¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(14)), 377);
+    }
+
+    #[test]
+    fn missing_or_zero_input_seconds_bill_the_thirty_second_maximum() {
+      // FAILSAFE: an unmeasured (or zero) input bills the 30-second MAXIMUM,
+      // matching the provider client's fallback:
+      // 8.55967078 ¢/s × (10+30) = 342.39 → 343¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, None), 343);
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(0)), 343);
+    }
+
+    #[test]
+    fn input_totals_under_four_seconds_clamp_to_four() {
+      let at_minimum = cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(4));
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(1)), at_minimum);
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(3)), at_minimum);
+      assert!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 10, Some(5)) > at_minimum);
+    }
+
+    #[test]
+    fn input_seconds_clamp_to_max_billed_input_seconds() {
+      // 200 input seconds clamp to 30: 8.55967078 ¢/s × (30+30) = 513.58 → 514¢.
+      assert_eq!(cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(200)), 514);
+      assert_eq!(
+        cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(200)),
+        cents_with_video_refs(Some(RouterResolution::FourEightyP), 30, Some(30)),
+      );
+    }
+  }
+
+  mod credits_tests {
+    use super::*;
+
+    #[test]
+    fn credits_equal_usd_cents() {
+      for dur in [4u16, 10, 30] {
+        let estimate = estimate_with(|b| {
+          b.resolution = Some(RouterResolution::FourEightyP);
+          b.duration_seconds = Some(dur);
+        });
+        assert_eq!(estimate.cost_in_credits, estimate.cost_in_usd_cents);
+      }
+    }
+  }
+
+  // ── Helpers ──
+
+  fn estimate_with(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> VideoGenerationCostEstimate {
+    estimate_for_model(RouterVideoModel::Seedance2p5Ultra, f)
+  }
+
+  fn estimate_for_model(
+    model: RouterVideoModel,
+    f: impl FnOnce(&mut GenerateVideoRequestBuilder),
+  ) -> VideoGenerationCostEstimate {
+    let mut builder = GenerateVideoRequestBuilder {
+      model,
+      provider: RouterProvider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    };
+    f(&mut builder);
+    builder.build2()
+      .expect("build should succeed")
+      .estimate_cost()
+      .expect("estimate should succeed")
+  }
+
+  fn cents(resolution: Option<RouterResolution>, duration_seconds: u16) -> u64 {
+    estimate_with(|b| {
+      b.resolution = resolution;
+      b.duration_seconds = Some(duration_seconds);
+    }).cost_in_usd_cents.unwrap()
+  }
+
+  fn cents_with_video_refs(
+    resolution: Option<RouterResolution>,
+    duration_seconds: u16,
+    total_input_seconds: Option<u16>,
+  ) -> u64 {
+    estimate_with(|b| {
+      b.resolution = resolution;
+      b.duration_seconds = Some(duration_seconds);
+      b.reference_videos = Some(VideoListRef::MediaFileTokens(vec![
+        MediaFileToken::new("mf_ref".to_string()),
+      ]));
+      b.total_reference_video_input_seconds = total_input_seconds;
+    }).cost_in_usd_cents.unwrap()
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_2p5_u/request.rs

@@ -0,0 +1,22 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
+
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
+use crate::generate::generate_video::providers::artcraft::request_common::send_artcraft_omni_video_request;
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftSeedance2p5UltraRequestState {
+  pub request: OmniGenVideoCostAndGenerateRequest,
+
+  /// Calculation-only: total seconds of reference video input, billed on top
+  /// of the output duration when reference videos are attached. Not part of
+  /// the omni request wire shape.
+  pub total_input_seconds: Option<u16>,
+}
+
+impl ArtcraftSeedance2p5UltraRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+    send_artcraft_omni_video_request(&self.request, client).await
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/seedance_common.rs

@@ -3,35 +3,27 @@
 //! ArtCraft credits equal USD cents (100 credits = $1.00).
 
 use enums::common::generation::common_resolution::CommonResolution;
+use kinovi_web_client::generate::video::generate_seedance_2p5::{
+  MAX_BILLED_INPUT_SECONDS, MIN_BILLED_INPUT_SECONDS,
+};
 
 // 4K is priced uniformly across the non-Fast Seedance 2.0 models. Rates are held
 // in hundredths of a USD cent per second so the math is exact integer arithmetic
 // (no floating point), then rounded up to whole cents.
 
-/// 4K output price, in hundredths of a USD cent per second (86.60 ¢/s).
-const FOUR_K_CENTI_CENTS_PER_SECOND: u64 = 8660;
+/// 4K output price, in hundredths of a USD cent per second (89.30 ¢/s).
+const FOUR_K_CENTI_CENTS_PER_SECOND: u64 = 8930;
 
-/// Extra hundredths of a USD cent per second when a reference video is attached
-/// at 4K (17.20 ¢/s surcharge).
-const FOUR_K_VIDEO_REFERENCE_SURCHARGE_CENTI_CENTS_PER_SECOND: u64 = 1720;
-
-/// ArtCraft's price (USD cents) for Seedance 2.0 at 4K.
-///
-/// A reference video adds a per-second surcharge (4K with and without a video
-/// reference are priced differently). The cost scales with duration and batch
-/// count, rounded up to whole cents.
+/// ArtCraft's price (USD cents) for Seedance 2.0 at 4K with no reference
+/// videos attached. Each model prices reference videos through its own
+/// with-reference rate card. The cost scales with duration and batch count,
+/// rounded up to whole cents.
 pub fn seedance_2p0_four_k_usd_cents(
   duration_seconds: u16,
   batch_count: u16,
-  has_video_reference: bool,
 ) -> u64 {
-  let mut centi_cents_per_second = FOUR_K_CENTI_CENTS_PER_SECOND;
-  if has_video_reference {
-    centi_cents_per_second += FOUR_K_VIDEO_REFERENCE_SURCHARGE_CENTI_CENTS_PER_SECOND;
-  }
-
   let total_centi_cents =
-    centi_cents_per_second * duration_seconds as u64 * batch_count as u64;
+    FOUR_K_CENTI_CENTS_PER_SECOND * duration_seconds as u64 * batch_count as u64;
 
   // Round up to whole cents.
   total_centi_cents.div_ceil(100)
@@ -48,22 +40,22 @@ pub fn seedance_2p0_four_k_usd_cents(
 // rate sets and helpers below.
 
 /// Regular Mini — 480p price, USD cents per second.
-const MINI_CENTS_PER_SECOND_480P: f64 = 3.24074074;
+const MINI_CENTS_PER_SECOND_480P: f64 = 3.45;
 /// Regular Mini — 480p reference-video surcharge, USD cents per second.
-const MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_480P: f64 = 0.86419753;
+const MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_480P: f64 = 0.90;
 /// Regular Mini — 720p price, USD cents per second.
-const MINI_CENTS_PER_SECOND_720P: f64 = 8.64197531;
+const MINI_CENTS_PER_SECOND_720P: f64 = 8.90;
 /// Regular Mini — 720p reference-video surcharge, USD cents per second.
-const MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_720P: f64 = 1.72839506;
+const MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_720P: f64 = 1.80;
 
 /// BytePlus / BytePlus Ultra Mini — 480p price, USD cents per second.
-const BYTEPLUS_MINI_CENTS_PER_SECOND_480P: f64 = 3.27160494;
+const BYTEPLUS_MINI_CENTS_PER_SECOND_480P: f64 = 3.55;
 /// BytePlus / BytePlus Ultra Mini — 480p reference-video surcharge, USD cents per second.
-const BYTEPLUS_MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_480P: f64 = 0.87242798;
+const BYTEPLUS_MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_480P: f64 = 0.95;
 /// BytePlus / BytePlus Ultra Mini — 720p price, USD cents per second.
-const BYTEPLUS_MINI_CENTS_PER_SECOND_720P: f64 = 8.72427984;
+const BYTEPLUS_MINI_CENTS_PER_SECOND_720P: f64 = 9.10;
 /// BytePlus / BytePlus Ultra Mini — 720p reference-video surcharge, USD cents per second.
-const BYTEPLUS_MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_720P: f64 = 1.74485597;
+const BYTEPLUS_MINI_VIDEO_REFERENCE_SURCHARGE_CENTS_PER_SECOND_720P: f64 = 1.85;
 
 /// ArtCraft's price (USD cents) for the regular Seedance 2.0 Mini.
 ///
@@ -141,6 +133,115 @@ pub fn seedance_2p5_preview_usd_cents(
   (cents_per_second * duration_seconds as f64).ceil() as u64
 }
 
+/// Seedance 2.5 — 480p price, USD cents per second.
+const SEEDANCE_2P5_CENTS_PER_SECOND_480P: f64 = 11.76954733;
+/// Seedance 2.5 — 720p price, USD cents per second.
+const SEEDANCE_2P5_CENTS_PER_SECOND_720P: f64 = 26.70781893;
+/// Seedance 2.5 — 480p price with video references, USD cents per second.
+const SEEDANCE_2P5_VIDEO_REFERENCE_CENTS_PER_SECOND_480P: f64 = 7.24279835;
+/// Seedance 2.5 — 720p price with video references, USD cents per second.
+const SEEDANCE_2P5_VIDEO_REFERENCE_CENTS_PER_SECOND_720P: f64 = 15.84362140;
+
+/// ArtCraft's price (USD cents) for Seedance 2.5.
+///
+/// Only 480p and 720p are offered; any other resolution prices at 720p.
+/// Without video references, billed seconds = output duration. With video
+/// references, the per-second rate drops but the billed seconds are the
+/// output duration PLUS the total seconds of reference video input (clamped
+/// to the 4..=30 second billing range). The fractional total is rounded UP
+/// to a whole cent. No batching.
+pub fn seedance_2p5_usd_cents(
+  resolution: CommonResolution,
+  duration_seconds: u16,
+  has_video_references: bool,
+  maybe_total_input_seconds: Option<u16>,
+) -> u64 {
+  let (cents_per_second, billed_seconds) = if has_video_references {
+    let rate = match resolution {
+      CommonResolution::FourEightyP => SEEDANCE_2P5_VIDEO_REFERENCE_CENTS_PER_SECOND_480P,
+      // Everything else (including 720p and unsupported resolutions) prices at 720p.
+      _ => SEEDANCE_2P5_VIDEO_REFERENCE_CENTS_PER_SECOND_720P,
+    };
+    // The TOTAL input duration clamps to the 4..=30 second billing range
+    // (three 1s videos sum to 3 and bill 4; three 3s videos bill 9).
+    //
+    // FAILSAFE: an unknown (never probed) or zero input duration bills the
+    // 30-second MAXIMUM, matching the provider client's own fallback. It
+    // must never default toward the minimum — billing 4 input seconds for
+    // an unmeasured input while the provider assumes 30 sells input seconds
+    // far below cost.
+    let billed_input_seconds = match maybe_total_input_seconds {
+      None | Some(0) => u16::from(MAX_BILLED_INPUT_SECONDS),
+      Some(seconds) => {
+        seconds.clamp(u16::from(MIN_BILLED_INPUT_SECONDS), u16::from(MAX_BILLED_INPUT_SECONDS))
+      }
+    };
+    (rate, u64::from(duration_seconds) + u64::from(billed_input_seconds))
+  } else {
+    let rate = match resolution {
+      CommonResolution::FourEightyP => SEEDANCE_2P5_CENTS_PER_SECOND_480P,
+      _ => SEEDANCE_2P5_CENTS_PER_SECOND_720P,
+    };
+    (rate, u64::from(duration_seconds))
+  };
+
+  (cents_per_second * billed_seconds as f64).ceil() as u64
+}
+
+/// Seedance 2.5 Ultra — 480p price, USD cents per second.
+const SEEDANCE_2P5_ULTRA_CENTS_PER_SECOND_480P: f64 = 13.90946502;
+/// Seedance 2.5 Ultra — 720p price, USD cents per second.
+const SEEDANCE_2P5_ULTRA_CENTS_PER_SECOND_720P: f64 = 31.56378601;
+/// Seedance 2.5 Ultra — 480p price with video references, USD cents per second.
+const SEEDANCE_2P5_ULTRA_VIDEO_REFERENCE_CENTS_PER_SECOND_480P: f64 = 8.55967078;
+/// Seedance 2.5 Ultra — 720p price with video references, USD cents per second.
+const SEEDANCE_2P5_ULTRA_VIDEO_REFERENCE_CENTS_PER_SECOND_720P: f64 = 18.72427984;
+
+/// ArtCraft's price (USD cents) for Seedance 2.5 Ultra.
+///
+/// Only 480p and 720p are offered; any other resolution prices at 720p.
+/// Without video references, billed seconds = output duration. With video
+/// references, the per-second rate drops but the billed seconds are the
+/// output duration PLUS the total seconds of reference video input. The
+/// fractional total is rounded UP to a whole cent. No batching.
+pub fn seedance_2p5_ultra_usd_cents(
+  resolution: CommonResolution,
+  duration_seconds: u16,
+  has_video_references: bool,
+  maybe_total_input_seconds: Option<u16>,
+) -> u64 {
+  let (cents_per_second, billed_seconds) = if has_video_references {
+    let rate = match resolution {
+      CommonResolution::FourEightyP => SEEDANCE_2P5_ULTRA_VIDEO_REFERENCE_CENTS_PER_SECOND_480P,
+      // Everything else (including 720p and unsupported resolutions) prices at 720p.
+      _ => SEEDANCE_2P5_ULTRA_VIDEO_REFERENCE_CENTS_PER_SECOND_720P,
+    };
+    // The TOTAL input duration clamps to the 4..=30 second billing range
+    // (three 1s videos sum to 3 and bill 4; three 3s videos bill 9).
+    //
+    // FAILSAFE: an unknown (never probed) or zero input duration bills the
+    // 30-second MAXIMUM, matching the provider client's own fallback. It
+    // must never default toward the minimum — billing 4 input seconds for
+    // an unmeasured input while the provider assumes 30 sells input seconds
+    // far below cost.
+    let billed_input_seconds = match maybe_total_input_seconds {
+      None | Some(0) => u16::from(MAX_BILLED_INPUT_SECONDS),
+      Some(seconds) => {
+        seconds.clamp(u16::from(MIN_BILLED_INPUT_SECONDS), u16::from(MAX_BILLED_INPUT_SECONDS))
+      }
+    };
+    (rate, u64::from(duration_seconds) + u64::from(billed_input_seconds))
+  } else {
+    let rate = match resolution {
+      CommonResolution::FourEightyP => SEEDANCE_2P5_ULTRA_CENTS_PER_SECOND_480P,
+      _ => SEEDANCE_2P5_ULTRA_CENTS_PER_SECOND_720P,
+    };
+    (rate, u64::from(duration_seconds))
+  };
+
+  (cents_per_second * billed_seconds as f64).ceil() as u64
+}
+
 #[allow(clippy::too_many_arguments)]
 fn mini_usd_cents(
   resolution: CommonResolution,
@@ -171,37 +272,17 @@ mod tests {
   use super::*;
 
   #[test]
-  fn four_k_without_video_reference() {
-    assert_eq!(seedance_2p0_four_k_usd_cents(4, 1, false), 347);
-    assert_eq!(seedance_2p0_four_k_usd_cents(5, 1, false), 433);
-    assert_eq!(seedance_2p0_four_k_usd_cents(10, 1, false), 866);
-    assert_eq!(seedance_2p0_four_k_usd_cents(15, 1, false), 1299);
-  }
-
-  #[test]
-  fn four_k_with_video_reference() {
-    assert_eq!(seedance_2p0_four_k_usd_cents(4, 1, true), 416);
-    assert_eq!(seedance_2p0_four_k_usd_cents(5, 1, true), 519);
-    assert_eq!(seedance_2p0_four_k_usd_cents(10, 1, true), 1038);
-    assert_eq!(seedance_2p0_four_k_usd_cents(15, 1, true), 1557);
-  }
-
-  #[test]
-  fn video_reference_always_costs_more() {
-    for &duration in &[4u16, 5, 10, 15] {
-      assert!(
-        seedance_2p0_four_k_usd_cents(duration, 1, true)
-          > seedance_2p0_four_k_usd_cents(duration, 1, false),
-        "video reference should cost more at {duration}s",
-      );
-    }
+  fn four_k_base_prices() {
+    assert_eq!(seedance_2p0_four_k_usd_cents(4, 1), 358);
+    assert_eq!(seedance_2p0_four_k_usd_cents(5, 1), 447);
+    assert_eq!(seedance_2p0_four_k_usd_cents(10, 1), 893);
+    assert_eq!(seedance_2p0_four_k_usd_cents(15, 1), 1340);
   }
 
   #[test]
   fn batch_count_multiplies() {
-    assert_eq!(seedance_2p0_four_k_usd_cents(5, 2, false), 866);
-    assert_eq!(seedance_2p0_four_k_usd_cents(5, 4, false), 1732);
-    assert_eq!(seedance_2p0_four_k_usd_cents(5, 2, true), 1038);
+    assert_eq!(seedance_2p0_four_k_usd_cents(5, 2), 893);
+    assert_eq!(seedance_2p0_four_k_usd_cents(5, 4), 1786);
   }
 
   // ── Seedance 2.0 Mini ──
@@ -218,34 +299,34 @@ mod tests {
 
     #[test]
     fn four_eighty_p_without_video_reference() {
-      assert_eq!(cents(CommonResolution::FourEightyP, 4, false), 13);
-      assert_eq!(cents(CommonResolution::FourEightyP, 5, false), 17);
-      assert_eq!(cents(CommonResolution::FourEightyP, 10, false), 33);
-      assert_eq!(cents(CommonResolution::FourEightyP, 15, false), 49);
+      assert_eq!(cents(CommonResolution::FourEightyP, 4, false), 14);
+      assert_eq!(cents(CommonResolution::FourEightyP, 5, false), 18);
+      assert_eq!(cents(CommonResolution::FourEightyP, 10, false), 35);
+      assert_eq!(cents(CommonResolution::FourEightyP, 15, false), 52);
     }
 
     #[test]
     fn four_eighty_p_with_video_reference() {
-      assert_eq!(cents(CommonResolution::FourEightyP, 4, true), 17);
-      assert_eq!(cents(CommonResolution::FourEightyP, 5, true), 21);
-      assert_eq!(cents(CommonResolution::FourEightyP, 10, true), 42);
-      assert_eq!(cents(CommonResolution::FourEightyP, 15, true), 62);
+      assert_eq!(cents(CommonResolution::FourEightyP, 4, true), 18);
+      assert_eq!(cents(CommonResolution::FourEightyP, 5, true), 22);
+      assert_eq!(cents(CommonResolution::FourEightyP, 10, true), 44);
+      assert_eq!(cents(CommonResolution::FourEightyP, 15, true), 66);
     }
 
     #[test]
     fn seven_twenty_p_without_video_reference() {
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, false), 35);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, false), 44);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, false), 87);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, false), 130);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, false), 36);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, false), 45);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, false), 89);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, false), 134);
     }
 
     #[test]
     fn seven_twenty_p_with_video_reference() {
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, true), 42);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, true), 52);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, true), 104);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, true), 156);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, true), 43);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, true), 54);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, true), 108);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, true), 161);
     }
 
     #[test]
@@ -272,9 +353,9 @@ mod tests {
     fn batch_count_scales_the_total() {
       // Batch is baked in before the single round-up, so batched totals can be
       // a cent under N× the single price.
-      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 2, false), 87);
-      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 4, false), 173);
-      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::FourEightyP, 5, 2, false), 33);
+      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 2, false), 89);
+      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 4, false), 178);
+      assert_eq!(seedance_2p0_mini_usd_cents(CommonResolution::FourEightyP, 5, 2, false), 35);
     }
   }
 
@@ -292,34 +373,34 @@ mod tests {
 
     #[test]
     fn four_eighty_p_without_video_reference() {
-      assert_eq!(cents(CommonResolution::FourEightyP, 4, false), 14);
-      assert_eq!(cents(CommonResolution::FourEightyP, 5, false), 17);
-      assert_eq!(cents(CommonResolution::FourEightyP, 10, false), 33);
-      assert_eq!(cents(CommonResolution::FourEightyP, 15, false), 50);
+      assert_eq!(cents(CommonResolution::FourEightyP, 4, false), 15);
+      assert_eq!(cents(CommonResolution::FourEightyP, 5, false), 18);
+      assert_eq!(cents(CommonResolution::FourEightyP, 10, false), 36);
+      assert_eq!(cents(CommonResolution::FourEightyP, 15, false), 54);
     }
 
     #[test]
     fn four_eighty_p_with_video_reference() {
-      assert_eq!(cents(CommonResolution::FourEightyP, 4, true), 17);
-      assert_eq!(cents(CommonResolution::FourEightyP, 5, true), 21);
-      assert_eq!(cents(CommonResolution::FourEightyP, 10, true), 42);
-      assert_eq!(cents(CommonResolution::FourEightyP, 15, true), 63);
+      assert_eq!(cents(CommonResolution::FourEightyP, 4, true), 18);
+      assert_eq!(cents(CommonResolution::FourEightyP, 5, true), 23);
+      assert_eq!(cents(CommonResolution::FourEightyP, 10, true), 45);
+      assert_eq!(cents(CommonResolution::FourEightyP, 15, true), 68);
     }
 
     #[test]
     fn seven_twenty_p_without_video_reference() {
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, false), 35);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, false), 44);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, false), 88);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, false), 131);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, false), 37);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, false), 46);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, false), 91);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, false), 137);
     }
 
     #[test]
     fn seven_twenty_p_with_video_reference() {
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, true), 42);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, true), 53);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, true), 105);
-      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, true), 158);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 4, true), 44);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 5, true), 55);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 10, true), 110);
+      assert_eq!(cents(CommonResolution::SevenTwentyP, 15, true), 165);
     }
 
     #[test]
@@ -347,9 +428,9 @@ mod tests {
 
     #[test]
     fn batch_count_scales_the_total() {
-      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 2, false), 88);
-      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 4, false), 175);
-      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::FourEightyP, 5, 2, false), 33);
+      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 2, false), 91);
+      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::SevenTwentyP, 5, 4, false), 182);
+      assert_eq!(seedance_2p0_byteplus_mini_usd_cents(CommonResolution::FourEightyP, 5, 2, false), 36);
     }
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/veo_3/cost.rs

@@ -11,8 +11,8 @@ impl ArtcraftVeo3CostState {
   pub fn from_request(request: &ArtcraftVeo3RequestState) -> Self {
     Self {
       duration_seconds: duration_seconds_for_cost(request.request.duration_seconds),
-      // v1 legacy Veo 3 handler defaults generate_audio to false.
-      generate_audio: request.request.generate_audio.unwrap_or(false),
+      // Unset defaults to audio on.
+      generate_audio: request.request.generate_audio.unwrap_or(true),
     }
   }
 
@@ -81,8 +81,7 @@ mod tests {
   }
 
   #[test]
-  fn audio_default_is_off() {
-    // None → audio defaults to false.
-    assert_eq!(cost_cents(Some(8), None), cost_cents(Some(8), Some(false)));
+  fn audio_default_is_on() {
+    assert_eq!(cost_cents(Some(8), None), cost_cents(Some(8), Some(true)));
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/artcraft/veo_3_fast/cost.rs

@@ -1,22 +1,32 @@
 use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
 use crate::generate::generate_video::providers::artcraft::veo_3_fast::request::ArtcraftVeo3FastRequestState;
 
+/// Per-second rates in hundredths of a US cent.
+const CENTI_CENTS_PER_SECOND_AUDIO_OFF: u64 = 1_150;
+const CENTI_CENTS_PER_SECOND_AUDIO_ON: u64 = 1_725;
+
 #[derive(Clone, Debug)]
 pub struct ArtcraftVeo3FastCostState {
+  pub duration_seconds: u64,
   pub generate_audio: bool,
 }
 
 impl ArtcraftVeo3FastCostState {
   pub fn from_request(request: &ArtcraftVeo3FastRequestState) -> Self {
     Self {
-      // v1 legacy Veo 3 Fast handler defaults generate_audio to false.
-      generate_audio: request.request.generate_audio.unwrap_or(false),
+      duration_seconds: duration_seconds_for_cost(request.request.duration_seconds),
+      // Unset defaults to audio on.
+      generate_audio: request.request.generate_audio.unwrap_or(true),
     }
   }
 
   pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
-    // Flat per-video price: 88¢ audio off, 132¢ audio on.
-    let cost_in_usd_cents: u64 = if self.generate_audio { 132 } else { 88 };
+    let rate = if self.generate_audio {
+      CENTI_CENTS_PER_SECOND_AUDIO_ON
+    } else {
+      CENTI_CENTS_PER_SECOND_AUDIO_OFF
+    };
+    let cost_in_usd_cents = (rate * self.duration_seconds).div_ceil(100);
 
     VideoGenerationCostEstimate {
       cost_in_credits: Some(cost_in_usd_cents),
@@ -30,6 +40,16 @@ impl ArtcraftVeo3FastCostState {
   }
 }
 
+/// Mirrors Veo 3's `duration_seconds_for_cost`: s≤4 → 4, s≤6 → 6, else → 8
+/// (incl. None and 7+).
+fn duration_seconds_for_cost(d: Option<u16>) -> u64 {
+  match d {
+    Some(s) if s <= 4 => 4,
+    Some(s) if s <= 6 => 6,
+    _ => 8,
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use crate::api::router_video_model::RouterVideoModel;
@@ -49,22 +69,34 @@ mod tests {
   }
 
   #[test]
-  fn audio_off_is_88() { assert_eq!(cost_cents(Some(8), Some(false)), 88); }
+  fn audio_off_4s_is_46() { assert_eq!(cost_cents(Some(4), Some(false)), 46); }
 
   #[test]
-  fn audio_on_is_132() { assert_eq!(cost_cents(Some(8), Some(true)), 132); }
+  fn audio_off_6s_is_69() { assert_eq!(cost_cents(Some(6), Some(false)), 69); }
 
   #[test]
-  fn audio_default_is_off() {
-    assert_eq!(cost_cents(Some(8), None), 88);
+  fn audio_off_8s_is_92() { assert_eq!(cost_cents(Some(8), Some(false)), 92); }
+
+  #[test]
+  fn audio_on_4s_is_69() { assert_eq!(cost_cents(Some(4), Some(true)), 69); }
+
+  #[test]
+  fn audio_on_6s_is_104() {
+    // 1725 × 6 = 10350 hundredth-cents → 104 cents (rounded up).
+    assert_eq!(cost_cents(Some(6), Some(true)), 104);
   }
 
   #[test]
-  fn duration_does_not_affect_cost() {
-    // v1 always bills 8s regardless of duration_seconds.
-    assert_eq!(cost_cents(Some(4), Some(false)), 88);
-    assert_eq!(cost_cents(Some(6), Some(false)), 88);
-    assert_eq!(cost_cents(Some(8), Some(false)), 88);
-    assert_eq!(cost_cents(None, Some(false)), 88);
+  fn audio_on_8s_is_138() { assert_eq!(cost_cents(Some(8), Some(true)), 138); }
+
+  #[test]
+  fn default_duration_is_8s() {
+    assert_eq!(cost_cents(None, Some(false)), cost_cents(Some(8), Some(false)));
   }
+
+  #[test]
+  fn audio_default_is_on() {
+    assert_eq!(cost_cents(Some(8), None), cost_cents(Some(8), Some(true)));
+  }
+
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/first_party/minimax_h3_ultra_cost.rs

@@ -3,7 +3,6 @@
 //! TODO(2026-08-06): Placeholder rates copied from the existing Minimax H3
 //! pricing. Finalize once first-party GPU inference costs are known.
 
-use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
 use enums::common::generation::common_resolution::CommonResolution;
 
 /// Per-second rates in hundredths of a US cent.
@@ -15,12 +14,15 @@ const DEFAULT_DURATION_SECONDS: u64 = 5;
 
 /// Estimate the user-facing Minimax H3 Ultra cost in USD cents.
 /// System credits = cents (same convention as the v2 pipeline).
-pub fn estimate_minimax_h3_ultra_cost_usd_cents(request: &OmniGenVideoCostAndGenerateRequest) -> u64 {
-  let duration_seconds = request.duration_seconds
+pub fn estimate_minimax_h3_ultra_cost_usd_cents(
+  maybe_duration_seconds: Option<u16>,
+  maybe_resolution: Option<CommonResolution>,
+) -> u64 {
+  let duration_seconds = maybe_duration_seconds
     .map(u64::from)
     .unwrap_or(DEFAULT_DURATION_SECONDS);
 
-  let rate = if is_2k(request.resolution) {
+  let rate = if is_2k(maybe_resolution) {
     HIGH_RES_RATE_HUNDREDTH_CENTS_PER_SEC
   } else {
     LOW_RES_RATE_HUNDREDTH_CENTS_PER_SEC
@@ -52,45 +54,28 @@ mod tests {
 
   #[test]
   fn default_resolution_5s_is_150() {
-    assert_eq!(cost_cents(None, None), 150);
+    assert_eq!(estimate_minimax_h3_ultra_cost_usd_cents(None, None), 150);
   }
 
   #[test]
   fn low_res_5s_is_92() {
-    assert_eq!(cost_cents(Some(5), Some(CommonResolution::SevenTwentyP)), 92);
+    assert_eq!(
+      estimate_minimax_h3_ultra_cost_usd_cents(Some(5), Some(CommonResolution::SevenTwentyP)),
+      92,
+    );
   }
 
   #[test]
   fn high_res_10s_is_299() {
-    assert_eq!(cost_cents(Some(10), Some(CommonResolution::TenEightyP)), 299);
+    assert_eq!(
+      estimate_minimax_h3_ultra_cost_usd_cents(Some(10), Some(CommonResolution::TenEightyP)),
+      299,
+    );
   }
 
   #[test]
   fn odd_duration_rounds_up_to_whole_cents() {
     // 7s high res: 2990 × 7 = 20930 hundredth-cents → 210 cents.
-    assert_eq!(cost_cents(Some(7), None), 210);
-  }
-
-  fn cost_cents(duration_seconds: Option<u16>, resolution: Option<CommonResolution>) -> u64 {
-    let request = OmniGenVideoCostAndGenerateRequest {
-      idempotency_token: None,
-      model: None,
-      prompt: None,
-      negative_prompt: None,
-      start_frame_image_media_token: None,
-      end_frame_image_media_token: None,
-      reference_image_media_tokens: None,
-      reference_video_media_tokens: None,
-      reference_audio_media_tokens: None,
-      reference_character_tokens: None,
-      resolution,
-      aspect_ratio: None,
-      bitrate: None,
-      quality: None,
-      duration_seconds,
-      video_batch_count: None,
-      generate_audio: None,
-    };
-    estimate_minimax_h3_ultra_cost_usd_cents(&request)
+    assert_eq!(estimate_minimax_h3_ultra_cost_usd_cents(Some(7), None), 210);
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/first_party/mod.rs

@@ -0,0 +1,4 @@
+//! Models fulfilled on first-party infrastructure; enqueued directly by
+//! storyteller-web rather than routed.
+
+pub mod minimax_h3_ultra_cost;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/mod.rs

@@ -1,2 +0,0 @@
-pub mod seedance_2p0_g;
-pub mod seedance_2p0_fast_g;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_fast_g/build.rs

@@ -1,323 +0,0 @@
-use gmicloud_client::requests::api::video::seedance_2_0_fast_260128::api::{
-  Seedance20FastRatio, Seedance20FastRequest, Seedance20FastResolution,
-};
-
-use crate::api::audio_list_ref::AudioListRef;
-use crate::api::router_aspect_ratio::RouterAspectRatio;
-use crate::api::router_resolution::RouterResolution;
-use crate::api::image_list_ref::ImageListRef;
-use crate::api::image_ref::ImageRef;
-use crate::api::video_list_ref::VideoListRef;
-use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::errors::client_error::ClientError;
-use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_fast_g::request::GmiCloudSeedance2p0UltraFastRequestState;
-use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-pub fn build_gmicloud_seedance_2p0_u_fast(
-  mut builder: GenerateVideoRequestBuilder,
-) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
-  let strategy = builder.request_mismatch_mitigation_strategy;
-
-  let ratio = plan_ratio(builder.aspect_ratio.take(), strategy)?;
-  let resolution = plan_resolution(builder.resolution.take(), strategy)?;
-  let duration = builder.duration_seconds.take().map(|d| (d as u8).clamp(4, 15));
-  let prompt = builder.prompt.take().unwrap_or_default();
-
-  let first_frame = resolve_url(builder.start_frame.take())?;
-  let last_frame = resolve_url(builder.end_frame.take())?;
-  let reference_images = resolve_url_list_from_images(builder.reference_images.take())?;
-  let reference_videos = resolve_url_list_from_videos(builder.reference_videos.take())?;
-  let reference_audios = resolve_url_list_from_audios(builder.reference_audio.take())?;
-
-  let request = Seedance20FastRequest {
-    prompt,
-    duration,
-    resolution,
-    ratio,
-    seed: None,
-    watermark: Some(false),
-    generate_audio: Some(true),
-    web_search: None,
-    first_frame,
-    last_frame,
-    reference_images,
-    reference_videos,
-    reference_audios,
-    reference_asset_ids: None,
-  };
-
-  let state = GmiCloudSeedance2p0UltraFastRequestState { request };
-  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::GmiCloudSeedance2p0UltraFast(state)))
-}
-
-fn plan_ratio(
-  aspect_ratio: Option<RouterAspectRatio>,
-  _strategy: RequestMismatchMitigationStrategy,
-) -> Result<Option<Seedance20FastRatio>, ArtcraftRouterError> {
-  match aspect_ratio {
-    None | Some(RouterAspectRatio::Auto) | Some(RouterAspectRatio::Auto2k)
-    | Some(RouterAspectRatio::Auto3k) | Some(RouterAspectRatio::Auto4k) => Ok(None),
-    Some(RouterAspectRatio::WideSixteenByNine) | Some(RouterAspectRatio::Wide) => Ok(Some(Seedance20FastRatio::Landscape16x9)),
-    Some(RouterAspectRatio::TallNineBySixteen) | Some(RouterAspectRatio::Tall) => Ok(Some(Seedance20FastRatio::Portrait9x16)),
-    Some(RouterAspectRatio::Square) | Some(RouterAspectRatio::SquareHd) => Ok(Some(Seedance20FastRatio::Square)),
-    Some(RouterAspectRatio::WideFourByThree) => Ok(Some(Seedance20FastRatio::Standard4x3)),
-    Some(RouterAspectRatio::TallThreeByFour) => Ok(Some(Seedance20FastRatio::Portrait3x4)),
-    Some(RouterAspectRatio::WideTwentyOneByNine) | Some(RouterAspectRatio::TallNineByTwentyOne) => {
-      Ok(Some(Seedance20FastRatio::UltraWide21x9))
-    }
-    Some(RouterAspectRatio::WideThreeByTwo) | Some(RouterAspectRatio::WideFiveByFour)
-    | Some(RouterAspectRatio::TallFourByFive) | Some(RouterAspectRatio::TallTwoByThree) => {
-      Ok(Some(Seedance20FastRatio::Adaptive))
-    }
-  }
-}
-
-fn plan_resolution(
-  resolution: Option<RouterResolution>,
-  _strategy: RequestMismatchMitigationStrategy,
-) -> Result<Option<Seedance20FastResolution>, ArtcraftRouterError> {
-  match resolution {
-    None => Ok(None),
-    Some(RouterResolution::FourEightyP) => Ok(Some(Seedance20FastResolution::FourEightyP)),
-    Some(RouterResolution::SevenTwentyP) => Ok(Some(Seedance20FastResolution::SevenTwentyP)),
-    // Fast model doesn't support 1080p — fall back to 720p
-    Some(RouterResolution::TenEightyP) => Ok(Some(Seedance20FastResolution::SevenTwentyP)),
-    Some(RouterResolution::HalfK) | Some(RouterResolution::OneK) => Ok(Some(Seedance20FastResolution::FourEightyP)),
-    Some(RouterResolution::TwoK) | Some(RouterResolution::ThreeK) | Some(RouterResolution::FourK) => {
-      Ok(Some(Seedance20FastResolution::SevenTwentyP))
-    }
-  }
-}
-
-fn resolve_url(image_ref: Option<ImageRef>) -> Result<Option<String>, ArtcraftRouterError> {
-  match image_ref {
-    None => Ok(None),
-    Some(ImageRef::Url(url)) => Ok(Some(url)),
-    Some(ImageRef::MediaFileToken(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "start_frame/end_frame",
-        value: "GmiCloud only supports image URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-fn resolve_url_list_from_images(
-  list_ref: Option<ImageListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(ImageListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(ImageListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_images",
-        value: "GmiCloud only supports image URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-fn resolve_url_list_from_videos(
-  list_ref: Option<VideoListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(VideoListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(VideoListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_videos",
-        value: "GmiCloud only supports video URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use gmicloud_client::requests::api::video::seedance_2_0_fast_260128::api::{
-    Seedance20FastRatio, Seedance20FastResolution,
-  };
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::api::video_list_ref::VideoListRef;
-  use crate::api::audio_list_ref::AudioListRef;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-  use super::*;
-
-  mod field_conversions {
-    use super::*;
-
-    #[test]
-    fn prompt_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.prompt = Some("fast test".to_string()); }));
-      assert_eq!(req.request.prompt, "fast test");
-    }
-
-    #[test]
-    fn duration_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(8); }));
-      assert_eq!(req.request.duration, Some(8));
-    }
-
-    #[test]
-    fn duration_clamped_to_min() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(2); }));
-      assert_eq!(req.request.duration, Some(4));
-    }
-
-    #[test]
-    fn duration_clamped_to_max() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(30); }));
-      assert_eq!(req.request.duration, Some(15));
-    }
-  }
-
-  mod resolution_tests {
-    use super::*;
-
-    #[test]
-    fn res_480p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::FourEightyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20FastResolution::FourEightyP));
-    }
-
-    #[test]
-    fn res_720p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::SevenTwentyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20FastResolution::SevenTwentyP));
-    }
-
-    #[test]
-    fn res_1080p_falls_back_to_720p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::TenEightyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20FastResolution::SevenTwentyP));
-    }
-
-    #[test]
-    fn none_stays_none() {
-      let req = unwrap_request(make_builder(|_| {}));
-      assert!(req.request.resolution.is_none());
-    }
-  }
-
-  mod aspect_ratio_tests {
-    use super::*;
-
-    #[test]
-    fn landscape_16x9() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::WideSixteenByNine); }));
-      assert_eq!(req.request.ratio, Some(Seedance20FastRatio::Landscape16x9));
-    }
-
-    #[test]
-    fn square() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::Square); }));
-      assert_eq!(req.request.ratio, Some(Seedance20FastRatio::Square));
-    }
-
-    #[test]
-    fn auto_maps_to_none() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::Auto); }));
-      assert_eq!(req.request.ratio, None);
-    }
-  }
-
-  mod media_url_tests {
-    use super::*;
-
-    #[test]
-    fn start_frame_url_passed_through() {
-      let req = unwrap_request(make_builder(|b| {
-        b.start_frame = Some(ImageRef::Url("https://example.com/img.png".to_string()));
-      }));
-      assert_eq!(req.request.first_frame, Some("https://example.com/img.png".to_string()));
-    }
-
-    #[test]
-    fn media_file_token_rejected() {
-      let result = build_gmicloud_seedance_2p0_u_fast(GenerateVideoRequestBuilder {
-        start_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_x".to_string()))),
-        ..base_builder()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn reference_image_urls_passed_through() {
-      let urls = vec!["https://example.com/ref.png".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_images = Some(ImageListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_images, Some(urls));
-    }
-
-    #[test]
-    fn reference_video_urls_passed_through() {
-      let urls = vec!["https://example.com/ref.mp4".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_videos = Some(VideoListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_videos, Some(urls));
-    }
-
-    #[test]
-    fn reference_audio_urls_passed_through() {
-      let urls = vec!["https://example.com/ref.wav".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_audio = Some(AudioListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_audios, Some(urls));
-    }
-  }
-
-  fn base_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::GmiCloud,
-      duration_seconds: Some(5),
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn make_builder(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
-    let mut builder = base_builder();
-    f(&mut builder);
-    builder
-  }
-
-  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> GmiCloudSeedance2p0UltraFastRequestState {
-    let result = build_gmicloud_seedance_2p0_u_fast(builder).expect("build should succeed");
-    match result {
-      VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::GmiCloudSeedance2p0UltraFast(state)) => state,
-      _ => panic!("expected GmiCloudSeedance2p0FastG request"),
-    }
-  }
-}
-
-fn resolve_url_list_from_audios(
-  list_ref: Option<AudioListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(AudioListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(AudioListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_audios",
-        value: "GmiCloud only supports audio URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_fast_g/cost.rs

@@ -1,125 +0,0 @@
-use gmicloud_client::traits::gmicloud_request_cost_calculator_trait::GmiCloudRequestCostCalculator;
-
-use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_fast_g::request::GmiCloudSeedance2p0UltraFastRequestState;
-
-pub struct GmiCloudSeedance2p0UltraFastCostState {
-  request: GmiCloudSeedance2p0UltraFastRequestState,
-}
-
-impl GmiCloudSeedance2p0UltraFastCostState {
-  pub fn from_request(request: &GmiCloudSeedance2p0UltraFastRequestState) -> Self {
-    Self { request: request.clone() }
-  }
-
-  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
-    let cost_in_usd_cents = self.request.request.calculate_cost_in_cents();
-
-    VideoGenerationCostEstimate {
-      cost_in_credits: None,
-      cost_in_usd_cents: Some(cost_in_usd_cents),
-      is_free: false,
-      is_unlimited: false,
-      is_rate_limited: false,
-      has_watermark: false,
-      failures_are_refunded: None,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::router_provider::RouterProvider;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-
-  mod pricing_720p {
-    use super::*;
-
-    #[test]
-    fn default_5s() {
-      // 720p: 3.1 ¢/s * 5 = 15.5 → ceil = 16¢
-      assert_eq!(cost_cents(None, 5), 16);
-    }
-
-    #[test]
-    fn default_10s() {
-      // 3.1 * 10 = 31¢
-      assert_eq!(cost_cents(None, 10), 31);
-    }
-
-    #[test]
-    fn default_15s() {
-      // 3.1 * 15 = 46.5 → ceil = 47¢
-      assert_eq!(cost_cents(None, 15), 47);
-    }
-  }
-
-  mod pricing_480p {
-    use super::*;
-
-    #[test]
-    fn p480_5s() {
-      // 1.0 * 5 = 5¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5), 5);
-    }
-
-    #[test]
-    fn p480_10s() {
-      // 1.0 * 10 = 10¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10), 10);
-    }
-
-    #[test]
-    fn p480_15s() {
-      // 1.0 * 15 = 15¢
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15), 15);
-    }
-  }
-
-  mod relative_pricing {
-    use super::*;
-
-    #[test]
-    fn higher_resolution_costs_more() {
-      let c480 = cost_cents(Some(RouterResolution::FourEightyP), 10);
-      let c720 = cost_cents(Some(RouterResolution::SevenTwentyP), 10);
-      assert!(c480 < c720, "480p ({c480}) should be < 720p ({c720})");
-    }
-
-    #[test]
-    fn fast_cheaper_than_standard() {
-      let fast = cost_cents(Some(RouterResolution::SevenTwentyP), 10);
-      let standard = {
-        let builder = GenerateVideoRequestBuilder {
-          model: RouterVideoModel::Seedance2p0Ultra,
-          provider: RouterProvider::GmiCloud,
-          resolution: Some(RouterResolution::SevenTwentyP),
-          duration_seconds: Some(10),
-          video_batch_count: Some(1),
-          ..Default::default()
-        };
-        builder.build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
-      };
-      assert!(fast < standard, "Fast ({fast}¢) should be < Standard ({standard}¢)");
-    }
-  }
-
-  fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16) -> u64 {
-    let builder = GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::GmiCloud,
-      resolution,
-      duration_seconds: Some(duration_seconds),
-      video_batch_count: Some(1),
-      ..Default::default()
-    };
-    builder.build2()
-      .expect("build2 should succeed")
-      .estimate_cost()
-      .expect("estimate_cost should succeed")
-      .cost_in_usd_cents
-      .unwrap()
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_fast_g/request.rs

@@ -1,100 +0,0 @@
-use gmicloud_client::requests::api::video::seedance_2_0_fast_260128::api::Seedance20FastRequest;
-
-use crate::client::router_gmicloud_client::RouterGmiCloudClient;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::errors::provider_error::ProviderError;
-use crate::generate::generate_video::generate_video_response::{
-  GenerateVideoResponse, GmiCloudVideoResponsePayload,
-};
-
-#[derive(Clone, Debug)]
-pub struct GmiCloudSeedance2p0UltraFastRequestState {
-  pub request: Seedance20FastRequest,
-}
-
-impl GmiCloudSeedance2p0UltraFastRequestState {
-  pub async fn send(&self, client: &RouterGmiCloudClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
-    let response = self.request.send_request(&client.api_key)
-      .await
-      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::GmiCloud(err)))?;
-
-    Ok(GenerateVideoResponse::GmiCloud(GmiCloudVideoResponsePayload {
-      request_id: response.request_id,
-    }))
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::client::router_client::RouterClient;
-  use crate::client::router_gmicloud_client::RouterGmiCloudClient;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use gmicloud_client::creds::gmicloud_api_key::GmiCloudApiKey;
-  use test_data::web::image_urls::JUNO_AT_LAKE_IMAGE_URL;
-
-  #[tokio::test]
-  #[ignore] // requires real API key, incurs costs
-  async fn test_text_to_video_720p() {
-    let response = run_pipeline(GenerateVideoRequestBuilder {
-      prompt: Some("A shiba inu playing in autumn leaves.".to_string()),
-      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-      resolution: Some(RouterResolution::SevenTwentyP),
-      duration_seconds: Some(5),
-      ..gmicloud_fast_builder()
-    }).await;
-    println!("response: {:?}", response);
-    assert!(matches!(response, GenerateVideoResponse::GmiCloud(_)));
-  }
-
-  #[tokio::test]
-  #[ignore] // requires real API key, incurs costs
-  async fn test_image_to_video_480p() {
-    let response = run_pipeline(GenerateVideoRequestBuilder {
-      prompt: Some("The dog starts running and splashing in the lake.".to_string()),
-      start_frame: Some(ImageRef::Url(JUNO_AT_LAKE_IMAGE_URL.to_string())),
-      resolution: Some(RouterResolution::FourEightyP),
-      duration_seconds: Some(5),
-      ..gmicloud_fast_builder()
-    }).await;
-    println!("response: {:?}", response);
-    assert!(matches!(response, GenerateVideoResponse::GmiCloud(_)));
-  }
-
-  fn gmicloud_fast_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0UltraFast,
-      provider: RouterProvider::GmiCloud,
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn get_gmicloud_client() -> RouterClient {
-    let secret = std::fs::read_to_string("/Users/bt/Artcraft/credentials/gmicloud_api_key.txt")
-      .expect("Failed to read GmiCloud API key");
-    let api_key = GmiCloudApiKey::from_str(&secret);
-    RouterClient::GmiCloud(RouterGmiCloudClient::new(api_key))
-  }
-
-  async fn run_pipeline(builder: GenerateVideoRequestBuilder) -> GenerateVideoResponse {
-    let client = get_gmicloud_client();
-    let draft_or_request = builder.build2().expect("build2 should succeed");
-    let request = match draft_or_request {
-      VideoGenerationDraftOrRequest::Request(r) => r,
-      _ => panic!("expected Request variant (GmiCloud skips draft)"),
-    };
-    let response = request.send_request(&client).await.expect("send_request should succeed");
-    match &response {
-      GenerateVideoResponse::GmiCloud(p) => println!("request_id={}", p.request_id),
-      other => println!("response: {:?}", other),
-    }
-    response
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_g/build.rs

@@ -1,355 +0,0 @@
-use gmicloud_client::requests::api::video::seedance_2_0_260128::api::{
-  Seedance20Ratio, Seedance20Request, Seedance20Resolution,
-};
-
-use crate::api::audio_list_ref::AudioListRef;
-use crate::api::router_aspect_ratio::RouterAspectRatio;
-use crate::api::router_resolution::RouterResolution;
-use crate::api::image_list_ref::ImageListRef;
-use crate::api::image_ref::ImageRef;
-use crate::api::video_list_ref::VideoListRef;
-use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::errors::client_error::ClientError;
-use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_g::request::GmiCloudSeedance2p0UltraRequestState;
-use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-pub fn build_gmicloud_seedance_2p0_u(
-  mut builder: GenerateVideoRequestBuilder,
-) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
-  let strategy = builder.request_mismatch_mitigation_strategy;
-
-  let ratio = plan_ratio(builder.aspect_ratio.take(), strategy)?;
-  let resolution = plan_resolution(builder.resolution.take(), strategy)?;
-  let duration = builder.duration_seconds.take().map(|d| (d as u8).clamp(4, 15));
-  let prompt = builder.prompt.take().unwrap_or_default();
-
-  let first_frame = resolve_url(builder.start_frame.take())?;
-  let last_frame = resolve_url(builder.end_frame.take())?;
-  let reference_images = resolve_url_list_from_images(builder.reference_images.take())?;
-  let reference_videos = resolve_url_list_from_videos(builder.reference_videos.take())?;
-  let reference_audios = resolve_url_list_from_audios(builder.reference_audio.take())?;
-
-  let request = Seedance20Request {
-    prompt,
-    duration,
-    resolution,
-    ratio,
-    seed: None,
-    watermark: Some(false),
-    generate_audio: Some(true),
-    web_search: None,
-    first_frame,
-    last_frame,
-    reference_images,
-    reference_videos,
-    reference_audios,
-    reference_asset_ids: None,
-  };
-
-  let state = GmiCloudSeedance2p0UltraRequestState { request };
-  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::GmiCloudSeedance2p0Ultra(state)))
-}
-
-fn plan_ratio(
-  aspect_ratio: Option<RouterAspectRatio>,
-  _strategy: RequestMismatchMitigationStrategy,
-) -> Result<Option<Seedance20Ratio>, ArtcraftRouterError> {
-  match aspect_ratio {
-    None | Some(RouterAspectRatio::Auto) | Some(RouterAspectRatio::Auto2k)
-    | Some(RouterAspectRatio::Auto3k) | Some(RouterAspectRatio::Auto4k) => Ok(None),
-    Some(RouterAspectRatio::WideSixteenByNine) | Some(RouterAspectRatio::Wide) => Ok(Some(Seedance20Ratio::Landscape16x9)),
-    Some(RouterAspectRatio::TallNineBySixteen) | Some(RouterAspectRatio::Tall) => Ok(Some(Seedance20Ratio::Portrait9x16)),
-    Some(RouterAspectRatio::Square) | Some(RouterAspectRatio::SquareHd) => Ok(Some(Seedance20Ratio::Square)),
-    Some(RouterAspectRatio::WideFourByThree) => Ok(Some(Seedance20Ratio::Standard4x3)),
-    Some(RouterAspectRatio::TallThreeByFour) => Ok(Some(Seedance20Ratio::Portrait3x4)),
-    Some(RouterAspectRatio::WideTwentyOneByNine) | Some(RouterAspectRatio::TallNineByTwentyOne) => {
-      Ok(Some(Seedance20Ratio::UltraWide21x9))
-    }
-    Some(RouterAspectRatio::WideThreeByTwo) | Some(RouterAspectRatio::WideFiveByFour)
-    | Some(RouterAspectRatio::TallFourByFive) | Some(RouterAspectRatio::TallTwoByThree) => {
-      Ok(Some(Seedance20Ratio::Adaptive))
-    }
-  }
-}
-
-fn plan_resolution(
-  resolution: Option<RouterResolution>,
-  _strategy: RequestMismatchMitigationStrategy,
-) -> Result<Option<Seedance20Resolution>, ArtcraftRouterError> {
-  match resolution {
-    None => Ok(None),
-    Some(RouterResolution::FourEightyP) => Ok(Some(Seedance20Resolution::FourEightyP)),
-    Some(RouterResolution::SevenTwentyP) => Ok(Some(Seedance20Resolution::SevenTwentyP)),
-    Some(RouterResolution::TenEightyP) => Ok(Some(Seedance20Resolution::TenEightyP)),
-    Some(RouterResolution::HalfK) | Some(RouterResolution::OneK) => Ok(Some(Seedance20Resolution::FourEightyP)),
-    Some(RouterResolution::TwoK) | Some(RouterResolution::ThreeK) | Some(RouterResolution::FourK) => {
-      Ok(Some(Seedance20Resolution::TenEightyP))
-    }
-  }
-}
-
-fn resolve_url(image_ref: Option<ImageRef>) -> Result<Option<String>, ArtcraftRouterError> {
-  match image_ref {
-    None => Ok(None),
-    Some(ImageRef::Url(url)) => Ok(Some(url)),
-    Some(ImageRef::MediaFileToken(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "start_frame/end_frame",
-        value: "GmiCloud only supports image URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-fn resolve_url_list_from_images(
-  list_ref: Option<ImageListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(ImageListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(ImageListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_images",
-        value: "GmiCloud only supports image URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-fn resolve_url_list_from_videos(
-  list_ref: Option<VideoListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(VideoListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(VideoListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_videos",
-        value: "GmiCloud only supports video URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use gmicloud_client::requests::api::video::seedance_2_0_260128::api::{
-    Seedance20Ratio, Seedance20Resolution,
-  };
-  use tokens::tokens::media_files::MediaFileToken;
-
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_list_ref::ImageListRef;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::api::video_list_ref::VideoListRef;
-  use crate::api::audio_list_ref::AudioListRef;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use crate::generate::generate_video::video_generation_request::VideoGenerationRequest;
-
-  use super::*;
-
-  mod field_conversions {
-    use super::*;
-
-    #[test]
-    fn prompt_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.prompt = Some("test prompt".to_string()); }));
-      assert_eq!(req.request.prompt, "test prompt");
-    }
-
-    #[test]
-    fn duration_passed_through() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(10); }));
-      assert_eq!(req.request.duration, Some(10));
-    }
-
-    #[test]
-    fn duration_clamped_to_min() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(1); }));
-      assert_eq!(req.request.duration, Some(4));
-    }
-
-    #[test]
-    fn duration_clamped_to_max() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(99); }));
-      assert_eq!(req.request.duration, Some(15));
-    }
-
-    #[test]
-    fn duration_none_stays_none() {
-      let req = unwrap_request(make_builder(|b| { b.duration_seconds = None; }));
-      assert_eq!(req.request.duration, None);
-    }
-  }
-
-  mod aspect_ratio_tests {
-    use super::*;
-
-    #[test]
-    fn landscape_16x9() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::WideSixteenByNine); }));
-      assert_eq!(req.request.ratio, Some(Seedance20Ratio::Landscape16x9));
-    }
-
-    #[test]
-    fn portrait_9x16() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::TallNineBySixteen); }));
-      assert_eq!(req.request.ratio, Some(Seedance20Ratio::Portrait9x16));
-    }
-
-    #[test]
-    fn square() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::Square); }));
-      assert_eq!(req.request.ratio, Some(Seedance20Ratio::Square));
-    }
-
-    #[test]
-    fn four_by_three() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::WideFourByThree); }));
-      assert_eq!(req.request.ratio, Some(Seedance20Ratio::Standard4x3));
-    }
-
-    #[test]
-    fn unsupported_maps_to_adaptive() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::WideThreeByTwo); }));
-      assert_eq!(req.request.ratio, Some(Seedance20Ratio::Adaptive));
-    }
-
-    #[test]
-    fn auto_maps_to_none() {
-      let req = unwrap_request(make_builder(|b| { b.aspect_ratio = Some(RouterAspectRatio::Auto); }));
-      assert_eq!(req.request.ratio, None);
-    }
-  }
-
-  mod resolution_tests {
-    use super::*;
-
-    #[test]
-    fn res_480p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::FourEightyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20Resolution::FourEightyP));
-    }
-
-    #[test]
-    fn res_720p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::SevenTwentyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20Resolution::SevenTwentyP));
-    }
-
-    #[test]
-    fn res_1080p() {
-      let req = unwrap_request(make_builder(|b| { b.resolution = Some(RouterResolution::TenEightyP); }));
-      assert_eq!(req.request.resolution, Some(Seedance20Resolution::TenEightyP));
-    }
-
-    #[test]
-    fn none_stays_none() {
-      let req = unwrap_request(make_builder(|_| {}));
-      assert!(req.request.resolution.is_none());
-    }
-  }
-
-  mod media_url_tests {
-    use super::*;
-
-    #[test]
-    fn start_frame_url_passed_through() {
-      let req = unwrap_request(make_builder(|b| {
-        b.start_frame = Some(ImageRef::Url("https://example.com/start.png".to_string()));
-      }));
-      assert_eq!(req.request.first_frame, Some("https://example.com/start.png".to_string()));
-    }
-
-    #[test]
-    fn media_file_token_rejected_for_start_frame() {
-      let result = build_gmicloud_seedance_2p0_u(GenerateVideoRequestBuilder {
-        start_frame: Some(ImageRef::MediaFileToken(MediaFileToken::new("mf_test".to_string()))),
-        ..base_builder()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn reference_image_urls_passed_through() {
-      let urls = vec!["https://example.com/a.png".to_string(), "https://example.com/b.png".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_images = Some(ImageListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_images, Some(urls));
-    }
-
-    #[test]
-    fn reference_image_tokens_rejected() {
-      let result = build_gmicloud_seedance_2p0_u(GenerateVideoRequestBuilder {
-        reference_images: Some(ImageListRef::MediaFileTokens(vec![MediaFileToken::new("mf_a".to_string())])),
-        ..base_builder()
-      });
-      assert!(result.is_err());
-    }
-
-    #[test]
-    fn reference_video_urls_passed_through() {
-      let urls = vec!["https://example.com/v.mp4".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_videos = Some(VideoListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_videos, Some(urls));
-    }
-
-    #[test]
-    fn reference_audio_urls_passed_through() {
-      let urls = vec!["https://example.com/a.wav".to_string()];
-      let req = unwrap_request(make_builder(|b| {
-        b.reference_audio = Some(AudioListRef::Urls(urls.clone()));
-      }));
-      assert_eq!(req.request.reference_audios, Some(urls));
-    }
-  }
-
-  fn base_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0Ultra,
-      provider: RouterProvider::GmiCloud,
-      duration_seconds: Some(5),
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn make_builder(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
-    let mut builder = base_builder();
-    f(&mut builder);
-    builder
-  }
-
-  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> GmiCloudSeedance2p0UltraRequestState {
-    let result = build_gmicloud_seedance_2p0_u(builder).expect("build should succeed");
-    match result {
-      VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::GmiCloudSeedance2p0Ultra(state)) => state,
-      _ => panic!("expected GmiCloudSeedance2p0G request"),
-    }
-  }
-}
-
-fn resolve_url_list_from_audios(
-  list_ref: Option<AudioListRef>,
-) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
-  match list_ref {
-    None => Ok(None),
-    Some(AudioListRef::Urls(urls)) => Ok(Some(urls)),
-    Some(AudioListRef::MediaFileTokens(_)) => {
-      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
-        field: "reference_audios",
-        value: "GmiCloud only supports audio URLs, not media file tokens".to_string(),
-      }))
-    }
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_g/cost.rs

@@ -1,133 +0,0 @@
-use gmicloud_client::traits::gmicloud_request_cost_calculator_trait::GmiCloudRequestCostCalculator;
-
-use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_g::request::GmiCloudSeedance2p0UltraRequestState;
-
-pub struct GmiCloudSeedance2p0UltraCostState {
-  request: GmiCloudSeedance2p0UltraRequestState,
-}
-
-impl GmiCloudSeedance2p0UltraCostState {
-  pub fn from_request(request: &GmiCloudSeedance2p0UltraRequestState) -> Self {
-    Self { request: request.clone() }
-  }
-
-  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
-    let cost_in_usd_cents = self.request.request.calculate_cost_in_cents();
-
-    VideoGenerationCostEstimate {
-      cost_in_credits: None,
-      cost_in_usd_cents: Some(cost_in_usd_cents),
-      is_free: false,
-      is_unlimited: false,
-      is_rate_limited: false,
-      has_watermark: false,
-      failures_are_refunded: None,
-    }
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::router_provider::RouterProvider;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-
-  mod pricing_720p {
-    use super::*;
-
-    #[test]
-    fn default_5s() {
-      // 720p: 5.2 ¢/s * 5 = 26¢
-      assert_eq!(cost_cents(None, 5), 26);
-    }
-
-    #[test]
-    fn default_10s() {
-      assert_eq!(cost_cents(None, 10), 52);
-    }
-
-    #[test]
-    fn explicit_720p_5s() {
-      assert_eq!(cost_cents(Some(RouterResolution::SevenTwentyP), 5), 26);
-    }
-  }
-
-  mod pricing_480p {
-    use super::*;
-
-    #[test]
-    fn p480_5s() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 5), 12);
-    }
-
-    #[test]
-    fn p480_10s() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 10), 24);
-    }
-
-    #[test]
-    fn p480_15s() {
-      assert_eq!(cost_cents(Some(RouterResolution::FourEightyP), 15), 36);
-    }
-  }
-
-  mod pricing_1080p {
-    use super::*;
-
-    #[test]
-    fn p1080_5s() {
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 5), 58);
-    }
-
-    #[test]
-    fn p1080_10s() {
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 10), 116);
-    }
-
-    #[test]
-    fn p1080_15s() {
-      assert_eq!(cost_cents(Some(RouterResolution::TenEightyP), 15), 174);
-    }
-  }
-
-  mod relative_pricing {
-    use super::*;
-
-    #[test]
-    fn higher_resolution_costs_more() {
-      let c480 = cost_cents(Some(RouterResolution::FourEightyP), 10);
-      let c720 = cost_cents(Some(RouterResolution::SevenTwentyP), 10);
-      let c1080 = cost_cents(Some(RouterResolution::TenEightyP), 10);
-      assert!(c480 < c720, "480p ({c480}) should be < 720p ({c720})");
-      assert!(c720 < c1080, "720p ({c720}) should be < 1080p ({c1080})");
-    }
-
-    #[test]
-    fn longer_duration_costs_more() {
-      let c5 = cost_cents(None, 5);
-      let c10 = cost_cents(None, 10);
-      let c15 = cost_cents(None, 15);
-      assert!(c5 < c10);
-      assert!(c10 < c15);
-    }
-  }
-
-  fn cost_cents(resolution: Option<RouterResolution>, duration_seconds: u16) -> u64 {
-    let builder = GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0Ultra,
-      provider: RouterProvider::GmiCloud,
-      resolution,
-      duration_seconds: Some(duration_seconds),
-      video_batch_count: Some(1),
-      ..Default::default()
-    };
-    builder.build2()
-      .expect("build2 should succeed")
-      .estimate_cost()
-      .expect("estimate_cost should succeed")
-      .cost_in_usd_cents
-      .unwrap()
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_g/mod.rs

@@ -1,3 +0,0 @@
-pub mod build;
-pub mod cost;
-pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/gmicloud/seedance_2p0_g/request.rs

@@ -1,98 +0,0 @@
-use gmicloud_client::requests::api::video::seedance_2_0_260128::api::Seedance20Request;
-
-use crate::client::router_gmicloud_client::RouterGmiCloudClient;
-use crate::errors::artcraft_router_error::ArtcraftRouterError;
-use crate::errors::provider_error::ProviderError;
-use crate::generate::generate_video::generate_video_response::{
-  GenerateVideoResponse, GmiCloudVideoResponsePayload,
-};
-
-#[derive(Clone, Debug)]
-pub struct GmiCloudSeedance2p0UltraRequestState {
-  pub request: Seedance20Request,
-}
-
-impl GmiCloudSeedance2p0UltraRequestState {
-  pub async fn send(&self, client: &RouterGmiCloudClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
-    let response = self.request.send_request(&client.api_key)
-      .await
-      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::GmiCloud(err)))?;
-
-    Ok(GenerateVideoResponse::GmiCloud(GmiCloudVideoResponsePayload {
-      request_id: response.request_id,
-    }))
-  }
-}
-
-#[cfg(test)]
-mod tests {
-  use crate::api::router_aspect_ratio::RouterAspectRatio;
-  use crate::api::router_resolution::RouterResolution;
-  use crate::api::router_video_model::RouterVideoModel;
-  use crate::api::image_ref::ImageRef;
-  use crate::api::router_provider::RouterProvider;
-  use crate::client::router_client::RouterClient;
-  use crate::client::router_gmicloud_client::RouterGmiCloudClient;
-  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
-  use crate::generate::generate_video::generate_video_response::GenerateVideoResponse;
-  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
-  use gmicloud_client::creds::gmicloud_api_key::GmiCloudApiKey;
-  use test_data::web::image_urls::JUNO_AT_LAKE_IMAGE_URL;
-
-  #[tokio::test]
-  #[ignore] // requires real API key, incurs costs
-  async fn test_text_to_video_720p() {
-    let response = run_pipeline(GenerateVideoRequestBuilder {
-      prompt: Some("A corgi running through a field of wildflowers at sunset.".to_string()),
-      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
-      resolution: Some(RouterResolution::SevenTwentyP),
-      duration_seconds: Some(5),
-      ..gmicloud_builder()
-    }).await;
-    assert!(matches!(response, GenerateVideoResponse::GmiCloud(_)));
-  }
-
-  #[tokio::test]
-  #[ignore] // requires real API key, incurs costs
-  async fn test_image_to_video_480p() {
-    let response = run_pipeline(GenerateVideoRequestBuilder {
-      prompt: Some("The dog starts running and splashing in the lake.".to_string()),
-      start_frame: Some(ImageRef::Url(JUNO_AT_LAKE_IMAGE_URL.to_string())),
-      resolution: Some(RouterResolution::FourEightyP),
-      duration_seconds: Some(5),
-      ..gmicloud_builder()
-    }).await;
-    assert!(matches!(response, GenerateVideoResponse::GmiCloud(_)));
-  }
-
-  fn gmicloud_builder() -> GenerateVideoRequestBuilder {
-    GenerateVideoRequestBuilder {
-      model: RouterVideoModel::Seedance2p0Ultra,
-      provider: RouterProvider::GmiCloud,
-      video_batch_count: Some(1),
-      ..Default::default()
-    }
-  }
-
-  fn get_gmicloud_client() -> RouterClient {
-    let secret = std::fs::read_to_string("/Users/bt/Artcraft/credentials/gmicloud_api_key.txt")
-      .expect("Failed to read GmiCloud API key");
-    let api_key = GmiCloudApiKey::from_str(&secret);
-    RouterClient::GmiCloud(RouterGmiCloudClient::new(api_key))
-  }
-
-  async fn run_pipeline(builder: GenerateVideoRequestBuilder) -> GenerateVideoResponse {
-    let client = get_gmicloud_client();
-    let draft_or_request = builder.build2().expect("build2 should succeed");
-    let request = match draft_or_request {
-      VideoGenerationDraftOrRequest::Request(r) => r,
-      _ => panic!("expected Request variant (GmiCloud skips draft)"),
-    };
-    let response = request.send_request(&client).await.expect("send_request should succeed");
-    match &response {
-      GenerateVideoResponse::GmiCloud(p) => println!("request_id={}", p.request_id),
-      other => println!("response: {:?}", other),
-    }
-    response
-  }
-}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/happy_horse_1p0/build.rs

@@ -100,7 +100,10 @@ fn plan_output_resolution(
   strategy: RequestMismatchMitigationStrategy,
 ) -> Result<Option<KinoviHappyHorse1p0OutputResolution>, ArtcraftRouterError> {
   match resolution {
-    None => Ok(None),
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviHappyHorse1p0OutputResolution::SevenTwentyP)),
 
     Some(RouterResolution::SevenTwentyP) => Ok(Some(KinoviHappyHorse1p0OutputResolution::SevenTwentyP)),
     Some(RouterResolution::TenEightyP) => Ok(Some(KinoviHappyHorse1p0OutputResolution::TenEightyP)),
@@ -332,10 +335,10 @@ mod tests {
     }
 
     #[test]
-    fn resolution_none() {
+    fn resolution_none_defaults_to_720p() {
       let builder = GenerateVideoRequestBuilder { resolution: None, ..happy_horse_builder() };
       let draft = unwrap_draft(build_kinovi_happy_horse_1p0(builder));
-      assert!(draft.resolution.is_none());
+      assert!(matches!(draft.resolution, Some(KinoviHappyHorse1p0OutputResolution::SevenTwentyP)));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/happy_horse_1p0/draft.rs

@@ -37,7 +37,8 @@ impl KinoviHappyHorse1p0DraftState {
 
     if let Some(remaining) = self.unhandled_request_state.take() {
       let map = draft_context.media_file_to_artcraft_url_map;
-      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map).await?;
+      let predownloaded = draft_context.predownloaded_media_paths;
+      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map, predownloaded).await?;
     }
 
     let request = GenerateHappyHorse1p0Request {

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/mod.rs

@@ -2,6 +2,7 @@ pub mod happy_horse_1p0;
 pub mod seedance_2p0;
 pub mod seedance_2p0_fast;
 pub mod seedance_2p0_mini;
+pub mod seedance_2p5;
 pub mod seedance_2p5_preview;
 pub(crate) mod resolve;
 pub(crate) mod upload;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/resolve.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::path::{Path, PathBuf};
 
 use kinovi_web_client::creds::kinovi_web_session::KinoviWebSession;
 use tokens::tokens::media_files::MediaFileToken;
@@ -45,13 +46,15 @@ pub(crate) async fn resolve_and_upload_single(
   session: &KinoviWebSession,
   image_ref: Option<ImageRef>,
   maybe_map: Option<&HashMap<MediaFileToken, String>>,
+  maybe_predownloaded: Option<&HashMap<String, PathBuf>>,
 ) -> Result<Option<String>, ArtcraftRouterError> {
   let source_url = match image_ref {
     None => return Ok(None),
     Some(ImageRef::Url(url)) => url,
     Some(ImageRef::MediaFileToken(token)) => resolve_token(maybe_map, &token)?,
   };
-  Ok(Some(upload_to_kinovi_web(session, &source_url).await?))
+  let local_path = predownloaded_path(maybe_predownloaded, &source_url);
+  Ok(Some(upload_to_kinovi_web(session, &source_url, local_path).await?))
 }
 
 /// Resolve a list of refs to URLs and upload each to KinoviWeb CDN.
@@ -60,6 +63,7 @@ pub(crate) async fn resolve_and_upload_list(
   session: &KinoviWebSession,
   urls_or_tokens: Option<UrlsOrTokens>,
   maybe_map: Option<&HashMap<MediaFileToken, String>>,
+  maybe_predownloaded: Option<&HashMap<String, PathBuf>>,
 ) -> Result<Option<Vec<String>>, ArtcraftRouterError> {
   let source_urls = match urls_or_tokens {
     None => return Ok(None),
@@ -71,11 +75,23 @@ pub(crate) async fn resolve_and_upload_list(
 
   let mut uploaded = Vec::with_capacity(source_urls.len());
   for url in &source_urls {
-    uploaded.push(upload_to_kinovi_web(session, url).await?);
+    let local_path = predownloaded_path(maybe_predownloaded, url);
+    uploaded.push(upload_to_kinovi_web(session, url, local_path).await?);
   }
   Ok(Some(uploaded))
 }
 
+/// Look up a caller-predownloaded local copy of the source file (see
+/// `VideoGenerationDraftContext::predownloaded_media_paths`).
+fn predownloaded_path<'a>(
+  maybe_predownloaded: Option<&'a HashMap<String, PathBuf>>,
+  source_url: &str,
+) -> Option<&'a Path> {
+  maybe_predownloaded
+    .and_then(|paths| paths.get(source_url))
+    .map(PathBuf::as_path)
+}
+
 /// Map character tokens to their Kinovi character IDs, preserving order.
 pub(crate) fn resolve_character_tokens(
   character_list_ref: Option<&CharacterListRef>,

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0/build.rs

@@ -117,7 +117,10 @@ fn plan_output_resolution(
   strategy: RequestMismatchMitigationStrategy,
 ) -> Result<Option<KinoviOutputResolution>, ArtcraftRouterError> {
   match resolution {
-    None => Ok(None),
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
 
     // Direct mappings
     Some(RouterResolution::FourEightyP) => Ok(Some(KinoviOutputResolution::FourEightyP)),
@@ -149,7 +152,7 @@ fn plan_output_resolution(
   }
 }
 
-// Seedance2p0 supports batch counts of 1, 2, and 4 only.
+// Seedance2p0 supports batch counts of 1 through 4.
 fn plan_batch_count(
   video_batch_count: Option<u16>,
   strategy: RequestMismatchMitigationStrategy,
@@ -159,7 +162,9 @@ fn plan_batch_count(
     0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
     1 => Ok(KinoviBatchCount::One),
     2 => Ok(KinoviBatchCount::Two),
+    3 => Ok(KinoviBatchCount::Three),
     4 => Ok(KinoviBatchCount::Four),
+    // 5 and above:
     _ => match strategy {
       RequestMismatchMitigationStrategy::ErrorOut => {
         Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
@@ -167,12 +172,8 @@ fn plan_batch_count(
           value: format!("{}", count),
         }))
       }
-      RequestMismatchMitigationStrategy::PayMoreUpgrade => {
-        Ok(if count < 4 { KinoviBatchCount::Four } else { KinoviBatchCount::Four })
-      }
-      RequestMismatchMitigationStrategy::PayLessDowngrade => {
-        Ok(if count < 4 { KinoviBatchCount::Two } else { KinoviBatchCount::Four })
-      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(KinoviBatchCount::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(KinoviBatchCount::Four),
     },
   }
 }
@@ -291,6 +292,13 @@ mod tests {
       assert!(matches!(draft.batch_count, KinoviBatchCount::Two));
     }
 
+    #[test]
+    fn batch_count_three() {
+      let builder = GenerateVideoRequestBuilder { video_batch_count: Some(3), ..kinovi_web_builder() };
+      let draft = unwrap_draft(build_kinovi_seedance_2p0(builder));
+      assert!(matches!(draft.batch_count, KinoviBatchCount::Three));
+    }
+
     #[test]
     fn batch_count_four() {
       let builder = GenerateVideoRequestBuilder { video_batch_count: Some(4), ..kinovi_web_builder() };
@@ -388,10 +396,10 @@ mod tests {
     }
 
     #[test]
-    fn resolution_none() {
+    fn resolution_none_defaults_to_720p() {
       let builder = GenerateVideoRequestBuilder { resolution: None, ..kinovi_web_builder() };
       let draft = unwrap_draft(build_kinovi_seedance_2p0(builder));
-      assert!(draft.resolution.is_none());
+      assert!(matches!(draft.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0/cost.rs

@@ -119,6 +119,13 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::Two), 494);
     }
 
+        #[test]
+    fn cost_720p_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::Three), 198);
+      assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Three), 247);
+      assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 15, KinoviBatchCount::Three), 741);
+    }
+
     #[test]
     fn cost_720p_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 4, KinoviBatchCount::Four), 264);
@@ -145,6 +152,11 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Two), 62);
     }
 
+        #[test]
+    fn cost_480p_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Three), 93);
+    }
+
     #[test]
     fn cost_480p_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Four), 124);
@@ -169,6 +181,11 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Two), 371);
     }
 
+        #[test]
+    fn cost_1080p_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Three), 556);
+    }
+
     #[test]
     fn cost_1080p_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::TenEightyP, 5, KinoviBatchCount::Four), 741);
@@ -196,6 +213,11 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::FourK, 5, KinoviBatchCount::Two), 824);
     }
 
+        #[test]
+    fn cost_4k_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::FourK, 5, KinoviBatchCount::Three), 1235);
+    }
+
     #[test]
     fn cost_4k_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::FourK, 5, KinoviBatchCount::Four), 1647);
@@ -413,7 +435,8 @@ mod tests {
     fn from_draft_720p_default() {
       let draft = make_draft(5, 1, None, false);
       let cost = KinoviSeedance2p0CostState::from_draft(&draft);
-      assert!(cost.resolution.is_none()); // None defaults to 720p pricing
+      // Unset resolution is pinned to explicit 720p at build time.
+      assert!(matches!(cost.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
       assert_eq!(cost.duration_seconds, 5);
       assert!(matches!(cost.batch_count, Some(KinoviBatchCount::One)));
       assert!(!cost.has_video_reference);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0/draft.rs

@@ -59,20 +59,21 @@ impl KinoviSeedance2p0DraftState {
 
     if let Some(remaining) = self.unhandled_request_state.take() {
       let map = draft_context.media_file_to_artcraft_url_map;
+      let predownloaded = draft_context.predownloaded_media_paths;
 
-      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map).await?;
-      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map).await?;
+      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map, predownloaded).await?;
+      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map, predownloaded).await?;
 
       reference_image_urls = resolve_and_upload_list(
-        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_video_urls = resolve_and_upload_list(
-        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_audio_urls = resolve_and_upload_list(
-        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       character_ids = resolve_character_tokens(

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0_fast/build.rs

@@ -118,7 +118,10 @@ fn plan_output_resolution(
   strategy: RequestMismatchMitigationStrategy,
 ) -> Result<Option<KinoviOutputResolution>, ArtcraftRouterError> {
   match resolution {
-    None => Ok(None),
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
 
     // Direct mappings
     Some(RouterResolution::FourEightyP) => Ok(Some(KinoviOutputResolution::FourEightyP)),
@@ -163,7 +166,7 @@ fn plan_output_resolution(
   }
 }
 
-// Seedance2p0Fast supports batch counts of 1, 2, and 4 only.
+// Seedance2p0Fast supports batch counts of 1 through 4.
 fn plan_batch_count(
   video_batch_count: Option<u16>,
   strategy: RequestMismatchMitigationStrategy,
@@ -173,7 +176,9 @@ fn plan_batch_count(
     0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
     1 => Ok(KinoviBatchCount::One),
     2 => Ok(KinoviBatchCount::Two),
+    3 => Ok(KinoviBatchCount::Three),
     4 => Ok(KinoviBatchCount::Four),
+    // 5 and above:
     _ => match strategy {
       RequestMismatchMitigationStrategy::ErrorOut => {
         Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
@@ -181,12 +186,8 @@ fn plan_batch_count(
           value: format!("{}", count),
         }))
       }
-      RequestMismatchMitigationStrategy::PayMoreUpgrade => {
-        Ok(if count < 4 { KinoviBatchCount::Four } else { KinoviBatchCount::Four })
-      }
-      RequestMismatchMitigationStrategy::PayLessDowngrade => {
-        Ok(if count < 4 { KinoviBatchCount::Two } else { KinoviBatchCount::Four })
-      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(KinoviBatchCount::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(KinoviBatchCount::Four),
     },
   }
 }
@@ -307,6 +308,13 @@ mod tests {
       assert!(matches!(draft.batch_count, KinoviBatchCount::Two));
     }
 
+    #[test]
+    fn batch_count_three() {
+      let builder = GenerateVideoRequestBuilder { video_batch_count: Some(3), ..kinovi_web_fast_builder() };
+      let draft = unwrap_draft(build_kinovi_seedance_2p0_fast(builder));
+      assert!(matches!(draft.batch_count, KinoviBatchCount::Three));
+    }
+
     #[test]
     fn batch_count_four() {
       let builder = GenerateVideoRequestBuilder { video_batch_count: Some(4), ..kinovi_web_fast_builder() };
@@ -416,10 +424,10 @@ mod tests {
     }
 
     #[test]
-    fn resolution_none() {
+    fn resolution_none_defaults_to_720p() {
       let builder = GenerateVideoRequestBuilder { resolution: None, ..kinovi_web_fast_builder() };
       let draft = unwrap_draft(build_kinovi_seedance_2p0_fast(builder));
-      assert!(draft.resolution.is_none());
+      assert!(matches!(draft.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
     }
 
     #[test]

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0_fast/cost.rs

@@ -119,6 +119,11 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Two), 116);
     }
 
+        #[test]
+    fn cost_720p_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Three), 173);
+    }
+
     #[test]
     fn cost_720p_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::SevenTwentyP, 5, KinoviBatchCount::Four), 231);
@@ -143,6 +148,11 @@ mod tests {
       assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Two), 58);
     }
 
+        #[test]
+    fn cost_480p_batch_3() {
+      assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Three), 87);
+    }
+
     #[test]
     fn cost_480p_batch_4() {
       assert_eq!(usd_cents(KinoviOutputResolution::FourEightyP, 5, KinoviBatchCount::Four), 116);
@@ -256,7 +266,8 @@ mod tests {
     fn from_draft_720p_default() {
       let draft = make_draft(5, 1, None, false);
       let cost = KinoviSeedance2p0FastCostState::from_draft(&draft);
-      assert!(cost.resolution.is_none());
+      // Unset resolution is pinned to explicit 720p at build time.
+      assert!(matches!(cost.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
       assert_eq!(cost.duration_seconds, 5);
       assert!(matches!(cost.batch_count, Some(KinoviBatchCount::One)));
       assert!(!cost.has_video_reference);

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0_fast/draft.rs

@@ -56,20 +56,21 @@ impl KinoviSeedance2p0FastDraftState {
 
     if let Some(remaining) = self.unhandled_request_state.take() {
       let map = draft_context.media_file_to_artcraft_url_map;
+      let predownloaded = draft_context.predownloaded_media_paths;
 
-      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map).await?;
-      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map).await?;
+      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map, predownloaded).await?;
+      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map, predownloaded).await?;
 
       reference_image_urls = resolve_and_upload_list(
-        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_video_urls = resolve_and_upload_list(
-        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_audio_urls = resolve_and_upload_list(
-        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       character_ids = resolve_character_tokens(

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0_mini/build.rs

@@ -116,7 +116,10 @@ fn plan_output_resolution(
   strategy: RequestMismatchMitigationStrategy,
 ) -> Result<Option<KinoviOutputResolution>, ArtcraftRouterError> {
   match resolution {
-    None => Ok(None),
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
 
     // Direct mappings
     Some(RouterResolution::FourEightyP) => Ok(Some(KinoviOutputResolution::FourEightyP)),
@@ -429,10 +432,10 @@ mod tests {
     }
 
     #[test]
-    fn resolution_none() {
+    fn resolution_none_defaults_to_720p() {
       let builder = GenerateVideoRequestBuilder { resolution: None, ..mini_builder() };
       let draft = unwrap_draft(build_kinovi_seedance_2p0_mini(builder));
-      assert!(draft.resolution.is_none());
+      assert!(matches!(draft.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
     }
   }
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p0_mini/draft.rs

@@ -56,20 +56,21 @@ impl KinoviSeedance2p0MiniDraftState {
 
     if let Some(remaining) = self.unhandled_request_state.take() {
       let map = draft_context.media_file_to_artcraft_url_map;
+      let predownloaded = draft_context.predownloaded_media_paths;
 
-      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map).await?;
-      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map).await?;
+      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map, predownloaded).await?;
+      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map, predownloaded).await?;
 
       reference_image_urls = resolve_and_upload_list(
-        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_video_urls = resolve_and_upload_list(
-        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_audio_urls = resolve_and_upload_list(
-        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       character_ids = resolve_character_tokens(

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5/build.rs

@@ -0,0 +1,456 @@
+use kinovi_web_client::generate::video::generate_seedance_2p5::{
+  KinoviSeedance2p5AspectRatio as KinoviAspectRatio,
+  KinoviSeedance2p5OutputResolution as KinoviOutputResolution,
+};
+
+use crate::api::router_aspect_ratio::RouterAspectRatio;
+use crate::api::router_resolution::RouterResolution;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::draft::{KinoviSeedance2p5DraftState, KinoviSeedance2p5RemainingItems};
+use crate::generate::generate_video::video_generation_draft::VideoGenerationDraftRequest;
+use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+
+pub fn build_kinovi_seedance_2p5(builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+  let draft = do_build_kinovi_seedance_2p5(builder)?;
+  Ok(VideoGenerationDraftOrRequest::Draft(VideoGenerationDraftRequest::KinoviSeedance2p5(draft)))
+}
+
+fn do_build_kinovi_seedance_2p5(mut builder: GenerateVideoRequestBuilder) -> Result<KinoviSeedance2p5DraftState, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  let has_keyframes = builder.start_frame.is_some() || builder.end_frame.is_some();
+  let has_references = builder.reference_images.is_some()
+    || builder.reference_videos.is_some()
+    || builder.reference_audio.is_some();
+
+  // Keyframe (image-to-video) and reference modes are mutually exclusive on
+  // the Seedance 2.5 API. Dropping either set would change the meaning of
+  // the request, so this errors regardless of strategy.
+  if has_keyframes && has_references {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_images",
+      value: "Seedance 2.5 cannot combine keyframes with reference media; send one or the other".to_string(),
+    }));
+  }
+
+  // An end frame requires a start frame.
+  if builder.end_frame.is_some() && builder.start_frame.is_none() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "end_frame",
+      value: "Seedance 2.5 requires a start frame when an end frame is set".to_string(),
+    }));
+  }
+
+  // Kinovi character references are not supported by the 2.5 API.
+  if builder.reference_character_tokens.is_some() {
+    return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+      field: "reference_character_tokens",
+      value: "Seedance 2.5 does not support character references".to_string(),
+    }));
+  }
+
+  // Keyframe mode only supports "Adaptive" (the aspect ratio follows the
+  // input frames), so any explicit aspect ratio preference is ignored there.
+  // The planned value below only applies to reference mode.
+  let aspect_ratio = plan_aspect_ratio(builder.aspect_ratio.take(), strategy)?;
+  let resolution = plan_output_resolution(builder.resolution.take(), strategy)?;
+  plan_batch_count(builder.video_batch_count.take(), strategy)?;
+  let duration_seconds = plan_duration(builder.duration_seconds.take(), strategy)?;
+  let prompt = builder.prompt.take().unwrap_or_default();
+
+  let total_input_seconds = builder.total_reference_video_input_seconds
+    .map(|seconds| u8::try_from(seconds).unwrap_or(u8::MAX));
+
+  // NB: `builder.bitrate` is intentionally ignored — 2.5 has no bitrate
+  // option (and bitrate never affects cost).
+
+  let unhandled_request_state = KinoviSeedance2p5RemainingItems {
+    start_frame: builder.start_frame.take(),
+    end_frame: builder.end_frame.take(),
+    reference_images: builder.reference_images.take(),
+    reference_videos: builder.reference_videos.take(),
+    reference_audio: builder.reference_audio.take(),
+  };
+
+  Ok(KinoviSeedance2p5DraftState {
+    aspect_ratio,
+    resolution,
+    duration_seconds,
+    prompt,
+    total_input_seconds,
+    unhandled_request_state: Some(unhandled_request_state),
+  })
+}
+
+// ── Plan helpers ──
+
+// Seedance 2.5 reference mode supports all six aspect ratios:
+//   16:9, 21:9, 9:16, 1:1, 4:3, 3:4. All supported ratios cost the same, so
+//   both upgrade and downgrade pick the nearest match. (Keyframe mode is
+//   always Adaptive and ignores this entirely.)
+fn plan_aspect_ratio(
+  aspect_ratio: Option<RouterAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<KinoviAspectRatio, ArtcraftRouterError> {
+  match aspect_ratio {
+    // No preference or auto — default to landscape
+    None
+    | Some(RouterAspectRatio::Auto)
+    | Some(RouterAspectRatio::Auto2k)
+    | Some(RouterAspectRatio::Auto4k) => Ok(KinoviAspectRatio::Landscape16x9),
+
+    // Direct mappings
+    Some(RouterAspectRatio::WideSixteenByNine) | Some(RouterAspectRatio::Wide) => {
+      Ok(KinoviAspectRatio::Landscape16x9)
+    }
+    Some(RouterAspectRatio::TallNineBySixteen) | Some(RouterAspectRatio::Tall) => {
+      Ok(KinoviAspectRatio::Portrait9x16)
+    }
+    Some(RouterAspectRatio::Square) | Some(RouterAspectRatio::SquareHd) => {
+      Ok(KinoviAspectRatio::Square1x1)
+    }
+    Some(RouterAspectRatio::WideFourByThree) => Ok(KinoviAspectRatio::Standard4x3),
+    Some(RouterAspectRatio::TallThreeByFour) => Ok(KinoviAspectRatio::Portrait3x4),
+    Some(RouterAspectRatio::WideTwentyOneByNine) => Ok(KinoviAspectRatio::UltraWide21x9),
+
+    // Mismatches — apply strategy
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(nearest_aspect_ratio(unsupported))
+      }
+    },
+  }
+}
+
+/// Pick the nearest supported aspect ratio by AR value (width / height).
+fn nearest_aspect_ratio(aspect_ratio: RouterAspectRatio) -> KinoviAspectRatio {
+  match aspect_ratio {
+    RouterAspectRatio::WideFiveByFour => KinoviAspectRatio::Standard4x3,         // 1.25, nearest 1.33
+    RouterAspectRatio::WideThreeByTwo => KinoviAspectRatio::Standard4x3,         // 1.50, nearest 1.33
+    RouterAspectRatio::TallFourByFive => KinoviAspectRatio::Portrait3x4,         // 0.80, nearest 0.75
+    RouterAspectRatio::TallTwoByThree => KinoviAspectRatio::Portrait3x4,         // 0.67, nearest 0.75
+    RouterAspectRatio::TallNineByTwentyOne => KinoviAspectRatio::Portrait9x16,   // 0.43, nearest 0.56
+    _ => KinoviAspectRatio::Square1x1,
+  }
+}
+
+// Seedance 2.5 supports output resolutions: 480p and 720p only.
+// 1080p (and higher) is NOT supported — downgrade to 720p or error based on strategy.
+fn plan_output_resolution(
+  resolution: Option<RouterResolution>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<KinoviOutputResolution>, ArtcraftRouterError> {
+  match resolution {
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
+
+    // Direct mappings
+    Some(RouterResolution::FourEightyP) => Ok(Some(KinoviOutputResolution::FourEightyP)),
+    Some(RouterResolution::SevenTwentyP) => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
+
+    // 1080p is not supported — handle via strategy
+    Some(RouterResolution::TenEightyP) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", RouterResolution::TenEightyP),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        // 1080p not available — downgrade to 720p (highest supported)
+        Ok(Some(KinoviOutputResolution::SevenTwentyP))
+      }
+    },
+
+    // Other unsupported resolutions
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(match unsupported {
+          RouterResolution::HalfK => KinoviOutputResolution::FourEightyP,
+          _ => KinoviOutputResolution::SevenTwentyP,
+        }))
+      }
+    },
+  }
+}
+
+// Seedance 2.5 generates a single video per request (no batching).
+fn plan_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<(), ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(()),
+    // Over the maximum of 1.
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(()),
+    },
+  }
+}
+
+// Seedance 2.5 supports durations of 4–30 seconds.
+fn plan_duration(
+  duration_seconds: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<u8, ArtcraftRouterError> {
+  const MIN: u16 = 4;
+  const MAX: u16 = 30;
+  const DEFAULT: u8 = 5;
+  match duration_seconds {
+    None => Ok(DEFAULT),
+    Some(d) if d >= MIN && d <= MAX => Ok(d as u8),
+    Some(d) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "duration_seconds",
+          value: format!("{}", d),
+        }))
+      }
+      _ => Ok(d.clamp(MIN, MAX) as u8),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use kinovi_web_client::generate::video::generate_seedance_2p5::{
+    KinoviSeedance2p5AspectRatio as KinoviAspectRatio,
+    KinoviSeedance2p5OutputResolution as KinoviOutputResolution,
+  };
+  use tokens::tokens::characters::CharacterToken;
+
+  use crate::api::character_list_ref::CharacterListRef;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::api::router_video_model::RouterVideoModel;
+  use crate::api::video_list_ref::VideoListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video::providers::kinovi::seedance_2p5::draft::KinoviSeedance2p5DraftState;
+  use crate::generate::generate_video::video_generation_draft::VideoGenerationDraftRequest;
+  use crate::generate::generate_video::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+
+  use super::*;
+
+  mod materialized_field_conversions {
+    use super::*;
+
+    #[test]
+    fn prompt_is_passed_through() {
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(base_builder()));
+      assert_eq!(draft.prompt, "a cat dancing");
+    }
+
+    #[test]
+    fn duration_defaults_to_5() {
+      let builder = GenerateVideoRequestBuilder { duration_seconds: None, ..base_builder() };
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+      assert_eq!(draft.duration_seconds, 5);
+    }
+
+    #[test]
+    fn duration_clamped_to_range() {
+      let over = GenerateVideoRequestBuilder { duration_seconds: Some(99), ..base_builder() };
+      assert_eq!(unwrap_draft(build_kinovi_seedance_2p5(over)).duration_seconds, 30);
+
+      let under = GenerateVideoRequestBuilder { duration_seconds: Some(2), ..base_builder() };
+      assert_eq!(unwrap_draft(build_kinovi_seedance_2p5(under)).duration_seconds, 4);
+    }
+
+    #[test]
+    fn total_input_seconds_is_carried_through() {
+      let builder = GenerateVideoRequestBuilder {
+        total_reference_video_input_seconds: Some(14),
+        ..base_builder()
+      };
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+      assert_eq!(draft.total_input_seconds, Some(14));
+    }
+
+    #[test]
+    fn total_input_seconds_saturates_at_u8_max() {
+      let builder = GenerateVideoRequestBuilder {
+        total_reference_video_input_seconds: Some(9_999),
+        ..base_builder()
+      };
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+      assert_eq!(draft.total_input_seconds, Some(u8::MAX));
+    }
+  }
+
+  mod modality_rules {
+    use super::*;
+
+    #[test]
+    fn keyframes_are_accepted() {
+      let builder = GenerateVideoRequestBuilder {
+        start_frame: Some(ImageRef::Url("https://example.com/start.jpg".to_string())),
+        end_frame: Some(ImageRef::Url("https://example.com/end.jpg".to_string())),
+        ..base_builder()
+      };
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+      let remaining = draft.unhandled_request_state.unwrap();
+      assert!(remaining.start_frame.is_some());
+      assert!(remaining.end_frame.is_some());
+    }
+
+    #[test]
+    fn start_frame_alone_is_accepted() {
+      let builder = GenerateVideoRequestBuilder {
+        start_frame: Some(ImageRef::Url("https://example.com/start.jpg".to_string())),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedance_2p5(builder).is_ok());
+    }
+
+    #[test]
+    fn end_frame_without_start_frame_errors() {
+      let builder = GenerateVideoRequestBuilder {
+        end_frame: Some(ImageRef::Url("https://example.com/end.jpg".to_string())),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedance_2p5(builder).is_err());
+    }
+
+    #[test]
+    fn keyframes_plus_references_error() {
+      let builder = GenerateVideoRequestBuilder {
+        start_frame: Some(ImageRef::Url("https://example.com/start.jpg".to_string())),
+        reference_images: Some(ImageListRef::Urls(vec!["https://example.com/ref.jpg".to_string()])),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedance_2p5(builder).is_err());
+    }
+
+    #[test]
+    fn character_references_error() {
+      let builder = GenerateVideoRequestBuilder {
+        reference_character_tokens: Some(CharacterListRef::CharacterTokens(vec![
+          CharacterToken::new("char_abc".to_string()),
+        ])),
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedance_2p5(builder).is_err());
+    }
+
+    #[test]
+    fn reference_media_lands_in_unhandled() {
+      let builder = GenerateVideoRequestBuilder {
+        reference_images: Some(ImageListRef::Urls(vec!["https://example.com/ref.jpg".to_string()])),
+        reference_videos: Some(VideoListRef::Urls(vec!["https://example.com/vid.mp4".to_string()])),
+        ..base_builder()
+      };
+      let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+      let remaining = draft.unhandled_request_state.unwrap();
+      assert!(remaining.reference_images.is_some());
+      assert!(remaining.reference_videos.is_some());
+    }
+  }
+
+  mod aspect_ratio_and_resolution {
+    use super::*;
+
+    #[test]
+    fn direct_aspect_ratio_mappings() {
+      let expected = [
+        (RouterAspectRatio::WideSixteenByNine, KinoviAspectRatio::Landscape16x9),
+        (RouterAspectRatio::WideTwentyOneByNine, KinoviAspectRatio::UltraWide21x9),
+        (RouterAspectRatio::TallNineBySixteen, KinoviAspectRatio::Portrait9x16),
+        (RouterAspectRatio::Square, KinoviAspectRatio::Square1x1),
+        (RouterAspectRatio::WideFourByThree, KinoviAspectRatio::Standard4x3),
+        (RouterAspectRatio::TallThreeByFour, KinoviAspectRatio::Portrait3x4),
+      ];
+      for (input, output) in expected {
+        let builder = GenerateVideoRequestBuilder { aspect_ratio: Some(input), ..base_builder() };
+        let draft = unwrap_draft(build_kinovi_seedance_2p5(builder));
+        assert!(
+          std::mem::discriminant(&draft.aspect_ratio) == std::mem::discriminant(&output),
+          "aspect ratio {input:?} mapped wrong",
+        );
+      }
+    }
+
+    #[test]
+    fn resolution_480p_and_720p() {
+      let builder = GenerateVideoRequestBuilder { resolution: Some(RouterResolution::FourEightyP), ..base_builder() };
+      assert!(matches!(unwrap_draft(build_kinovi_seedance_2p5(builder)).resolution, Some(KinoviOutputResolution::FourEightyP)));
+
+      let builder = GenerateVideoRequestBuilder { resolution: Some(RouterResolution::SevenTwentyP), ..base_builder() };
+      assert!(matches!(unwrap_draft(build_kinovi_seedance_2p5(builder)).resolution, Some(KinoviOutputResolution::SevenTwentyP)));
+    }
+
+    #[test]
+    fn resolution_1080p_downgrades_to_720p() {
+      let builder = GenerateVideoRequestBuilder {
+        resolution: Some(RouterResolution::TenEightyP),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayLessDowngrade,
+        ..base_builder()
+      };
+      assert!(matches!(unwrap_draft(build_kinovi_seedance_2p5(builder)).resolution, Some(KinoviOutputResolution::SevenTwentyP)));
+    }
+
+    #[test]
+    fn resolution_1080p_error_out() {
+      let builder = GenerateVideoRequestBuilder {
+        resolution: Some(RouterResolution::TenEightyP),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..base_builder()
+      };
+      assert!(build_kinovi_seedance_2p5(builder).is_err());
+    }
+  }
+
+  // ── Helpers ──
+
+  fn base_builder() -> GenerateVideoRequestBuilder {
+    GenerateVideoRequestBuilder {
+      model: RouterVideoModel::Seedance2p5,
+      provider: RouterProvider::KinoviWeb,
+      prompt: Some("a cat dancing".to_string()),
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    }
+  }
+
+  fn unwrap_draft(result: Result<VideoGenerationDraftOrRequest, ArtcraftRouterError>) -> KinoviSeedance2p5DraftState {
+    match result.expect("build should succeed") {
+      VideoGenerationDraftOrRequest::Draft(
+        VideoGenerationDraftRequest::KinoviSeedance2p5(draft)
+      ) => draft,
+      _ => panic!("expected KinoviSeedance2p5 draft"),
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5/cost.rs

@@ -0,0 +1,227 @@
+use kinovi_web_client::generate::video::generate_seedance_2p5::{
+  GenerateSeedance2p5Request, KinoviSeedance2p5Modality, KinoviSeedance2p5OutputResolution,
+  MAX_BILLED_INPUT_SECONDS, MIN_BILLED_INPUT_SECONDS,
+};
+
+use crate::api::video_list_ref::VideoListRef;
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::draft::KinoviSeedance2p5DraftState;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::request::KinoviSeedance2p5RequestState;
+
+/// Seedance 2.5 pricing depends on the resolution, the output duration, and
+/// — when reference videos are attached — the total seconds of reference
+/// video input, which are billed on top of the output duration (at a lower
+/// per-second rate). Input seconds are clamped to
+/// [`MAX_BILLED_INPUT_SECONDS`] — the model accepts at most 30 seconds of
+/// video.
+pub struct KinoviSeedance2p5CostState {
+  pub resolution: Option<KinoviSeedance2p5OutputResolution>,
+  pub duration_seconds: u8,
+  pub has_video_references: bool,
+  pub total_input_seconds: Option<u8>,
+}
+
+impl KinoviSeedance2p5CostState {
+  pub fn from_request(request: &KinoviSeedance2p5RequestState) -> Self {
+    let has_video_references = matches!(
+      &request.request.modality,
+      KinoviSeedance2p5Modality::Reference { reference_video_urls: Some(urls), .. } if !urls.is_empty()
+    );
+
+    Self {
+      resolution: request.request.output_resolution,
+      duration_seconds: request.request.duration_seconds,
+      has_video_references,
+      total_input_seconds: request.request.total_input_seconds,
+    }
+  }
+
+  pub fn from_draft(draft: &KinoviSeedance2p5DraftState) -> Self {
+    let has_video_references = draft.unhandled_request_state
+      .as_ref()
+      .and_then(|remaining| remaining.reference_videos.as_ref())
+      .is_some_and(|videos| match videos {
+        VideoListRef::MediaFileTokens(tokens) => !tokens.is_empty(),
+        VideoListRef::Urls(urls) => !urls.is_empty(),
+      });
+
+    Self {
+      resolution: draft.resolution,
+      duration_seconds: draft.duration_seconds,
+      has_video_references,
+      total_input_seconds: draft.total_input_seconds,
+    }
+  }
+
+  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    // Delegate to the kinovi_web_client calculator via a pricing-only
+    // request. Only the modality's video references, the resolution, the
+    // duration, and the input seconds affect the price.
+    let modality = if self.has_video_references {
+      KinoviSeedance2p5Modality::Reference {
+        aspect_ratio: None,
+        reference_image_urls: None,
+        reference_video_urls: Some(vec!["https://pricing-only.invalid/ref.mp4".to_string()]),
+        reference_audio_urls: None,
+      }
+    } else {
+      KinoviSeedance2p5Modality::Reference {
+        aspect_ratio: None,
+        reference_image_urls: None,
+        reference_video_urls: None,
+        reference_audio_urls: None,
+      }
+    };
+
+    // NB: The kinovi calculator clamps measured values and bills the
+    // worst-case maximum for unknown (None) or zero inputs. Zero passes
+    // through unclamped so that worst-case fallback applies — clamping it up
+    // to the minimum here would understate the cost.
+    let total_input_seconds = self.total_input_seconds
+      .map(|seconds| match seconds {
+        0 => 0,
+        measured => measured.clamp(MIN_BILLED_INPUT_SECONDS, MAX_BILLED_INPUT_SECONDS),
+      });
+
+    let pricing_request = GenerateSeedance2p5Request {
+      prompt: String::new(),
+      modality,
+      output_resolution: self.resolution,
+      duration_seconds: self.duration_seconds,
+      total_input_seconds,
+      use_face_blur_hack: None,
+    };
+
+    let costs = pricing_request.calculate_costs();
+    // 2.5 bills whole credits, so the rounding below is exact; the USD cents
+    // (the authoritative charge) are rounded up.
+    let cost_in_credits = costs.kinovi_credits.round() as u64;
+    let cost_in_usd_cents = costs.usd_cents_rounded_up;
+
+    VideoGenerationCostEstimate {
+      cost_in_credits: Some(cost_in_credits),
+      cost_in_usd_cents: Some(cost_in_usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use kinovi_web_client::generate::video::generate_seedance_2p5::KinoviSeedance2p5OutputResolution as KinoviOutputResolution;
+
+  use super::*;
+
+  // ── Credits without video references (26/sec at 480p, 59/sec at 720p) ──
+
+  mod credits_without_video_references {
+    use super::*;
+
+    #[test]
+    fn credits_480p() {
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 5, false, None), 130);
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 10, false, None), 260);
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 30, false, None), 780);
+    }
+
+    #[test]
+    fn credits_720p() {
+      assert_eq!(credits(Some(KinoviOutputResolution::SevenTwentyP), 5, false, None), 295);
+      assert_eq!(credits(Some(KinoviOutputResolution::SevenTwentyP), 30, false, None), 1770);
+    }
+
+    #[test]
+    fn default_resolution_is_720p() {
+      assert_eq!(credits(None, 10, false, None), credits(Some(KinoviOutputResolution::SevenTwentyP), 10, false, None));
+    }
+
+    #[test]
+    fn input_seconds_ignored_without_video_references() {
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 10, false, Some(60)), 260);
+    }
+  }
+
+  // ── Credits with video references (16/sec at 480p, 35/sec at 720p,
+  //    over output duration + input seconds) ──
+
+  mod credits_with_video_references {
+    use super::*;
+
+    #[test]
+    fn thirty_second_output_with_ten_input_seconds_bills_forty() {
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 30, true, Some(10)), 16 * 40);
+      assert_eq!(credits(Some(KinoviOutputResolution::SevenTwentyP), 30, true, Some(10)), 35 * 40);
+    }
+
+    #[test]
+    fn fourteen_input_seconds_bill_forty_four() {
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 30, true, Some(14)), 16 * 44);
+    }
+
+    #[test]
+    fn missing_input_seconds_bill_the_worst_case_maximum() {
+      // Unknown input duration with video references attached: the kinovi
+      // estimator assumes the 30-second maximum so the provider-cost
+      // estimate never undershoots the actual charge.
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 10, true, None), 16 * 40);
+    }
+
+    #[test]
+    fn input_seconds_clamp_to_max_billed_input_seconds() {
+      // 200 input seconds clamp to 30: 30s output + 30 = 60 billed seconds.
+      assert_eq!(credits(Some(KinoviOutputResolution::FourEightyP), 30, true, Some(200)), 16 * 60);
+      assert_eq!(
+        credits(Some(KinoviOutputResolution::FourEightyP), 30, true, Some(200)),
+        credits(Some(KinoviOutputResolution::FourEightyP), 30, true, Some(30)),
+      );
+    }
+  }
+
+  // ── USD cents (rounded up) ──
+
+  #[test]
+  fn usd_cents_are_rounded_up() {
+    // 130 credits → 13000/243 = 53.4979 → 54¢.
+    let estimate = cost_state(Some(KinoviOutputResolution::FourEightyP), 5, false, None).estimate_cost();
+    assert_eq!(estimate.cost_in_usd_cents, Some(54));
+  }
+
+  // ── Estimate flags ──
+
+  #[test]
+  fn estimate_flags() {
+    let estimate = cost_state(Some(KinoviOutputResolution::FourEightyP), 5, false, None).estimate_cost();
+    assert!(!estimate.is_free);
+    assert!(!estimate.is_unlimited);
+    assert!(!estimate.is_rate_limited);
+    assert!(!estimate.has_watermark);
+    assert!(estimate.failures_are_refunded.is_none());
+  }
+
+  // ── Helpers ──
+
+  fn cost_state(
+    resolution: Option<KinoviOutputResolution>,
+    duration_seconds: u8,
+    has_video_references: bool,
+    total_input_seconds: Option<u8>,
+  ) -> KinoviSeedance2p5CostState {
+    KinoviSeedance2p5CostState { resolution, duration_seconds, has_video_references, total_input_seconds }
+  }
+
+  fn credits(
+    resolution: Option<KinoviOutputResolution>,
+    duration_seconds: u8,
+    has_video_references: bool,
+    total_input_seconds: Option<u8>,
+  ) -> u64 {
+    cost_state(resolution, duration_seconds, has_video_references, total_input_seconds)
+      .estimate_cost()
+      .cost_in_credits
+      .unwrap()
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5/draft.rs

@@ -0,0 +1,118 @@
+use kinovi_web_client::generate::video::generate_seedance_2p5::{
+  GenerateSeedance2p5Request, KinoviSeedance2p5AspectRatio, KinoviSeedance2p5Modality,
+  KinoviSeedance2p5OutputResolution,
+};
+
+use crate::api::audio_list_ref::AudioListRef;
+use crate::api::image_list_ref::ImageListRef;
+use crate::api::image_ref::ImageRef;
+use crate::api::video_list_ref::VideoListRef;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::providers::kinovi::resolve::{
+  audio_list_ref_into_urls_or_tokens, image_list_ref_into_urls_or_tokens,
+  resolve_and_upload_list, resolve_and_upload_single, video_list_ref_into_urls_or_tokens,
+};
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::request::KinoviSeedance2p5RequestState;
+use crate::generate::generate_video::video_generation_draft_context::VideoGenerationDraftContext;
+
+#[derive(Debug, Clone)]
+pub struct KinoviSeedance2p5DraftState {
+  pub prompt: String,
+
+  /// Aspect ratio for the reference (text/reference-to-video) modality.
+  /// Keyframe mode is always "Adaptive" and ignores this.
+  pub aspect_ratio: KinoviSeedance2p5AspectRatio,
+
+  pub resolution: Option<KinoviSeedance2p5OutputResolution>,
+
+  pub duration_seconds: u8,
+
+  /// Calculation-only: total seconds of reference video input, summed across
+  /// all reference videos (each rounded up to a whole second).
+  pub total_input_seconds: Option<u8>,
+
+  pub unhandled_request_state: Option<KinoviSeedance2p5RemainingItems>,
+}
+
+/// Media inputs not yet resolved/uploaded. The build step guarantees that
+/// keyframes and reference media are mutually exclusive.
+#[derive(Debug, Clone)]
+pub struct KinoviSeedance2p5RemainingItems {
+  pub start_frame: Option<ImageRef>,
+  pub end_frame: Option<ImageRef>,
+  pub reference_images: Option<ImageListRef>,
+  pub reference_videos: Option<VideoListRef>,
+  pub reference_audio: Option<AudioListRef>,
+}
+
+impl KinoviSeedance2p5DraftState {
+  pub async fn to_request(
+    &mut self,
+    draft_context: &VideoGenerationDraftContext<'_>,
+  ) -> Result<KinoviSeedance2p5RequestState, ArtcraftRouterError> {
+    let client = draft_context.get_kinovi_web_client_ref()?;
+    let session = &client.session;
+
+    let mut start_frame_url = None;
+    let mut end_frame_url = None;
+    let mut reference_image_urls = None;
+    let mut reference_video_urls = None;
+    let mut reference_audio_urls = None;
+
+    if let Some(remaining) = self.unhandled_request_state.take() {
+      let map = draft_context.media_file_to_artcraft_url_map;
+      let predownloaded = draft_context.predownloaded_media_paths;
+
+      start_frame_url = resolve_and_upload_single(session, remaining.start_frame, map, predownloaded).await?;
+      end_frame_url = resolve_and_upload_single(session, remaining.end_frame, map, predownloaded).await?;
+
+      reference_image_urls = resolve_and_upload_list(
+        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map, predownloaded,
+      ).await?;
+
+      reference_video_urls = resolve_and_upload_list(
+        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map, predownloaded,
+      ).await?;
+
+      reference_audio_urls = resolve_and_upload_list(
+        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map, predownloaded,
+      ).await?;
+    }
+
+    let modality = match start_frame_url {
+      Some(start_frame_url) => KinoviSeedance2p5Modality::Keyframe {
+        start_frame_url,
+        end_frame_url,
+      },
+      None => {
+        // The build step rejects an end frame without a start frame, but a
+        // failed resolution could recreate the situation — never send an
+        // orphaned end frame as a reference request.
+        if end_frame_url.is_some() {
+          return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+            field: "end_frame",
+            value: "Seedance 2.5 requires a start frame when an end frame is set".to_string(),
+          }));
+        }
+        KinoviSeedance2p5Modality::Reference {
+          aspect_ratio: Some(self.aspect_ratio),
+          reference_image_urls,
+          reference_video_urls,
+          reference_audio_urls,
+        }
+      }
+    };
+
+    let request = GenerateSeedance2p5Request {
+      prompt: self.prompt.clone(),
+      modality,
+      output_resolution: self.resolution,
+      duration_seconds: self.duration_seconds,
+      total_input_seconds: self.total_input_seconds,
+      use_face_blur_hack: None,
+    };
+
+    Ok(KinoviSeedance2p5RequestState { request })
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5/mod.rs

@@ -1,3 +1,4 @@
 pub mod build;
-pub mod cost;
+pub mod draft;
 pub mod request;
+pub mod cost;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5/request.rs

@@ -0,0 +1,37 @@
+use kinovi_web_client::generate::video::generate_seedance_2p5::{
+  generate_seedance_2p5, GenerateSeedance2p5Args, GenerateSeedance2p5Request,
+};
+
+use crate::client::router_kinovi_web_client::RouterKinoviWebClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_video::generate_video_response::{GenerateVideoResponse, KinoviWebVideoResponsePayload};
+
+#[derive(Debug, Clone)]
+pub struct KinoviSeedance2p5RequestState {
+  /// Final materialized request; ready to fire.
+  pub request: GenerateSeedance2p5Request,
+}
+
+impl KinoviSeedance2p5RequestState {
+  pub async fn send(&self, client: &RouterKinoviWebClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+    let session = &client.session;
+
+    let args = GenerateSeedance2p5Args {
+      session,
+      host_override: None,
+      request: self.request.clone(),
+    };
+
+    let response = generate_seedance_2p5(args)
+      .await
+      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::KinoviWeb(err)))?;
+
+    Ok(GenerateVideoResponse::KinoviWeb(KinoviWebVideoResponsePayload {
+      order_id: response.order_id,
+      task_id: response.task_id,
+      maybe_order_ids: response.order_ids,
+      maybe_task_ids: response.task_ids,
+    }))
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5_preview/build.rs

@@ -134,7 +134,10 @@ fn plan_output_resolution(
   strategy: RequestMismatchMitigationStrategy,
 ) -> Result<Option<KinoviOutputResolution>, ArtcraftRouterError> {
   match resolution {
-    None => Ok(None),
+    // Unset defaults to explicit 720p. Cost estimation prices unset as 720p,
+    // so the request must pin 720p too — never leave the resolution up to the
+    // provider's server-side default, or billing and supplier cost can diverge.
+    None => Ok(Some(KinoviOutputResolution::SevenTwentyP)),
 
     // Direct mappings
     Some(RouterResolution::FourEightyP) => Ok(Some(KinoviOutputResolution::FourEightyP)),
@@ -439,10 +442,10 @@ mod tests {
     }
 
     #[test]
-    fn resolution_none() {
+    fn resolution_none_defaults_to_720p() {
       let builder = GenerateVideoRequestBuilder { resolution: None, ..preview_builder() };
       let draft = unwrap_draft(build_kinovi_seedance_2p5_preview(builder));
-      assert!(draft.resolution.is_none());
+      assert!(matches!(draft.resolution, Some(KinoviOutputResolution::SevenTwentyP)));
     }
   }
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/seedance_2p5_preview/draft.rs

@@ -47,17 +47,18 @@ impl KinoviSeedance2p5PreviewDraftState {
 
     if let Some(remaining) = self.unhandled_request_state.take() {
       let map = draft_context.media_file_to_artcraft_url_map;
+      let predownloaded = draft_context.predownloaded_media_paths;
 
       reference_image_urls = resolve_and_upload_list(
-        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_images.map(image_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_video_urls = resolve_and_upload_list(
-        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_videos.map(video_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
 
       reference_audio_urls = resolve_and_upload_list(
-        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map,
+        session, remaining.reference_audio.map(audio_list_ref_into_urls_or_tokens), map, predownloaded,
       ).await?;
     }
 

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/kinovi/upload.rs

@@ -1,3 +1,7 @@
+use std::path::Path;
+
+use log::{info, warn};
+
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
 use crate::errors::provider_error::ProviderError;
 use crate::utils::download_file::download_file;
@@ -6,16 +10,34 @@ use kinovi_web_client::requests::prepare_file_upload::prepare_file_upload::{prep
 use kinovi_web_client::requests::upload_file::upload_file::{upload_file, UploadFileArgs};
 use url_utils::extension::extract_extension_from_url::{extract_extension_from_url_str, ExtractExtensions};
 
-/// Downloads a file from a source URL and re-uploads it to kinovi_web CDN.
+/// Re-uploads a file to the kinovi_web CDN, reading it from
+/// `maybe_local_path` when the caller already downloaded it (e.g. reference
+/// videos probed for billing), or downloading it from the source URL
+/// otherwise.
 pub(crate) async fn upload_to_kinovi_web(
   session: &KinoviWebSession,
   source_url: &str,
+  maybe_local_path: Option<&Path>,
 ) -> Result<String, ArtcraftRouterError> {
   let extension = extract_extension_from_url_str(source_url, &ExtractExtensions::All)
       .map(|ext| ext.without_period().to_string())
       .unwrap_or_else(|| "jpg".to_string());
 
-  let file_bytes = download_file(source_url).await?;
+  let file_bytes = match maybe_local_path {
+    Some(local_path) => match std::fs::read(local_path) {
+      Ok(bytes) => {
+        info!("Reusing predownloaded file for kinovi upload: {}", source_url);
+        bytes
+      }
+      Err(err) => {
+        // The file should exist; fall back to downloading rather than fail.
+        warn!("Failed to read predownloaded file {:?} ({:?}); re-downloading {}",
+          local_path, err, source_url);
+        download_file(source_url).await?
+      }
+    },
+    None => download_file(source_url).await?,
+  };
 
   let prepare_response = prepare_file_upload(PrepareFileUploadArgs {
     session,

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/providers/mod.rs

@@ -1,5 +1,5 @@
 pub mod artcraft;
 pub mod fal;
-pub mod gmicloud;
+pub mod first_party;
 pub mod grok_api;
-pub mod kinovi;
+pub mod kinovi;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/video_generation_draft.rs

@@ -9,6 +9,8 @@ use crate::generate::generate_video::providers::kinovi::seedance_2p0_fast::cost:
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_fast::draft::KinoviSeedance2p0FastDraftState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_mini::cost::KinoviSeedance2p0MiniCostState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_mini::draft::KinoviSeedance2p0MiniDraftState;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::cost::KinoviSeedance2p5CostState;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::draft::KinoviSeedance2p5DraftState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p5_preview::cost::KinoviSeedance2p5PreviewCostState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p5_preview::draft::KinoviSeedance2p5PreviewDraftState;
 use crate::generate::generate_video::video_generation_draft_context::VideoGenerationDraftContext;
@@ -24,6 +26,7 @@ pub enum VideoGenerationDraftRequest {
   KinoviSeedance2p0Fast(KinoviSeedance2p0FastDraftState),
   KinoviSeedance2p0Mini(KinoviSeedance2p0MiniDraftState),
   KinoviSeedance2p5Preview(KinoviSeedance2p5PreviewDraftState),
+  KinoviSeedance2p5(KinoviSeedance2p5DraftState),
 }
 
 impl VideoGenerationDraftRequest {
@@ -35,6 +38,7 @@ impl VideoGenerationDraftRequest {
       Self::KinoviSeedance2p0Fast(_) => RouterProvider::KinoviWeb,
       Self::KinoviSeedance2p0Mini(_) => RouterProvider::KinoviWeb,
       Self::KinoviSeedance2p5Preview(_) => RouterProvider::KinoviWeb,
+      Self::KinoviSeedance2p5(_) => RouterProvider::KinoviWeb,
     }
   }
 
@@ -46,6 +50,7 @@ impl VideoGenerationDraftRequest {
       VideoGenerationDraftRequest::KinoviSeedance2p0Fast(draft) => Ok(KinoviSeedance2p0FastCostState::from_draft(draft).estimate_cost()),
       VideoGenerationDraftRequest::KinoviSeedance2p0Mini(draft) => Ok(KinoviSeedance2p0MiniCostState::from_draft(draft).estimate_cost()),
       VideoGenerationDraftRequest::KinoviSeedance2p5Preview(draft) => Ok(KinoviSeedance2p5PreviewCostState::from_draft(draft).estimate_cost()),
+      VideoGenerationDraftRequest::KinoviSeedance2p5(draft) => Ok(KinoviSeedance2p5CostState::from_draft(draft).estimate_cost()),
     }
   }
 
@@ -73,6 +78,10 @@ impl VideoGenerationDraftRequest {
         let result = draft.to_request(&draft_context).await?;
         Ok(VideoGenerationRequest::KinoviSeedance2p5Preview(result))
       },
+      VideoGenerationDraftRequest::KinoviSeedance2p5(mut draft) => {
+        let result = draft.to_request(&draft_context).await?;
+        Ok(VideoGenerationRequest::KinoviSeedance2p5(result))
+      },
     }
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/video_generation_draft_context.rs

@@ -4,6 +4,7 @@ use crate::errors::artcraft_router_error::ArtcraftRouterError;
 use crate::errors::client_error::ClientError;
 use std::collections::HashMap;
 use std::fmt::Debug;
+use std::path::PathBuf;
 use tokens::tokens::characters::CharacterToken;
 use tokens::tokens::media_files::MediaFileToken;
 
@@ -19,6 +20,12 @@ pub struct VideoGenerationDraftContext<'a> {
   /// Optional context: a map of Character Tokens to their respective Kinovi IDs
   /// Only necessary if using Kinovi characters
   pub character_token_to_kinovi_id_map: Option<&'a HashMap<CharacterToken, String>>,
+
+  /// Optional context: source URL → local file path for media the caller has
+  /// already downloaded (e.g. reference videos probed for billing). Uploads
+  /// read these files instead of downloading the same bytes again. The
+  /// caller must keep the files alive until the upload completes.
+  pub predownloaded_media_paths: Option<&'a HashMap<String, PathBuf>>,
 }
 
 impl <'a> VideoGenerationDraftContext<'a> {
@@ -45,6 +52,7 @@ impl Debug for VideoGenerationDraftContext<'_> {
       .field("client", &self.client.is_some())
       .field("media_file_to_artcraft_url_map", &self.media_file_to_artcraft_url_map)
       .field("character_token_to_kinovi_id_map", &self.character_token_to_kinovi_id_map)
+      .field("predownloaded_media_paths", &self.predownloaded_media_paths)
       .finish()
   }
 }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/video_generation_request.rs

@@ -41,10 +41,6 @@ use crate::generate::generate_video::providers::artcraft::seedance_2p0::cost::Ar
 use crate::generate::generate_video::providers::artcraft::seedance_2p0::request::ArtcraftSeedance2p0RequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_fast::cost::ArtcraftSeedance2p0FastCostState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_fast::request::ArtcraftSeedance2p0FastRequestState;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u::cost::ArtcraftSeedance2p0UltraCostState;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u::request::ArtcraftSeedance2p0UltraRequestState;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u_fast::cost::ArtcraftSeedance2p0UltraFastCostState;
-use crate::generate::generate_video::providers::artcraft::seedance_2p0_u_fast::request::ArtcraftSeedance2p0UltraFastRequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp::cost::ArtcraftSeedance2p0BytePlusCostState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp::request::ArtcraftSeedance2p0BytePlusRequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp_fast::cost::ArtcraftSeedance2p0BytePlusFastCostState;
@@ -55,6 +51,10 @@ use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu_fast:
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bpu_fast::request::ArtcraftSeedance2p0BytePlusUltraFastRequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_mini::cost::ArtcraftSeedance2p0MiniCostState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_mini::request::ArtcraftSeedance2p0MiniRequestState;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5::cost::ArtcraftSeedance2p5CostState;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5::request::ArtcraftSeedance2p5RequestState;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5_u::cost::ArtcraftSeedance2p5UltraCostState;
+use crate::generate::generate_video::providers::artcraft::seedance_2p5_u::request::ArtcraftSeedance2p5UltraRequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p5_preview::cost::ArtcraftSeedance2p5PreviewCostState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p5_preview::request::ArtcraftSeedance2p5PreviewRequestState;
 use crate::generate::generate_video::providers::artcraft::seedance_2p0_bp_mini::cost::ArtcraftSeedance2p0BytePlusMiniCostState;
@@ -125,10 +125,6 @@ use crate::generate::generate_video::providers::fal::vidu_q3::cost::FalViduQ3Cos
 use crate::generate::generate_video::providers::fal::vidu_q3::request::FalViduQ3RequestState;
 use crate::generate::generate_video::providers::fal::vidu_q3_turbo::cost::FalViduQ3TurboCostState;
 use crate::generate::generate_video::providers::fal::vidu_q3_turbo::request::FalViduQ3TurboRequestState;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_g::cost::GmiCloudSeedance2p0UltraCostState;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_g::request::GmiCloudSeedance2p0UltraRequestState;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_fast_g::cost::GmiCloudSeedance2p0UltraFastCostState;
-use crate::generate::generate_video::providers::gmicloud::seedance_2p0_fast_g::request::GmiCloudSeedance2p0UltraFastRequestState;
 use crate::generate::generate_video::providers::grok_api::grok_imagine_video::cost::GrokApiGrokImagineVideoCostState;
 use crate::generate::generate_video::providers::grok_api::grok_imagine_video::request::GrokApiGrokImagineVideoRequestState;
 use crate::generate::generate_video::providers::grok_api::grok_imagine_video_1p5::cost::GrokApiGrokImagineVideo1p5CostState;
@@ -141,6 +137,8 @@ use crate::generate::generate_video::providers::kinovi::seedance_2p0_fast::cost:
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_fast::request::KinoviSeedance2p0FastRequestState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_mini::cost::KinoviSeedance2p0MiniCostState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p0_mini::request::KinoviSeedance2p0MiniRequestState;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::cost::KinoviSeedance2p5CostState;
+use crate::generate::generate_video::providers::kinovi::seedance_2p5::request::KinoviSeedance2p5RequestState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p5_preview::cost::KinoviSeedance2p5PreviewCostState;
 use crate::generate::generate_video::providers::kinovi::seedance_2p5_preview::request::KinoviSeedance2p5PreviewRequestState;
 
@@ -165,14 +163,14 @@ pub enum VideoGenerationRequest {
   ArtcraftSeedance1p5Pro(ArtcraftSeedance1p5ProRequestState),
   ArtcraftSeedance2p0(ArtcraftSeedance2p0RequestState),
   ArtcraftSeedance2p0Fast(ArtcraftSeedance2p0FastRequestState),
-  ArtcraftSeedance2p0Ultra(ArtcraftSeedance2p0UltraRequestState),
-  ArtcraftSeedance2p0UltraFast(ArtcraftSeedance2p0UltraFastRequestState),
   ArtcraftSeedance2p0BytePlus(ArtcraftSeedance2p0BytePlusRequestState),
   ArtcraftSeedance2p0BytePlusFast(ArtcraftSeedance2p0BytePlusFastRequestState),
   ArtcraftSeedance2p0BytePlusUltra(ArtcraftSeedance2p0BytePlusUltraRequestState),
   ArtcraftSeedance2p0BytePlusUltraFast(ArtcraftSeedance2p0BytePlusUltraFastRequestState),
   ArtcraftSeedance2p0Mini(ArtcraftSeedance2p0MiniRequestState),
   ArtcraftSeedance2p5Preview(ArtcraftSeedance2p5PreviewRequestState),
+  ArtcraftSeedance2p5(ArtcraftSeedance2p5RequestState),
+  ArtcraftSeedance2p5Ultra(ArtcraftSeedance2p5UltraRequestState),
   ArtcraftSeedance2p0BytePlusMini(ArtcraftSeedance2p0BytePlusMiniRequestState),
   ArtcraftSeedance2p0BytePlusUltraMini(ArtcraftSeedance2p0BytePlusUltraMiniRequestState),
   ArtcraftSora2(ArtcraftSora2RequestState),
@@ -207,8 +205,6 @@ pub enum VideoGenerationRequest {
   FalVeo3p1Lite(FalVeo3p1LiteRequestState),
   FalViduQ3(FalViduQ3RequestState),
   FalViduQ3Turbo(FalViduQ3TurboRequestState),
-  GmiCloudSeedance2p0Ultra(GmiCloudSeedance2p0UltraRequestState),
-  GmiCloudSeedance2p0UltraFast(GmiCloudSeedance2p0UltraFastRequestState),
   GrokApiGrokImagineVideo(GrokApiGrokImagineVideoRequestState),
   GrokApiGrokImagineVideo1p5(GrokApiGrokImagineVideo1p5RequestState),
   KinoviHappyHorse1p0(KinoviHappyHorse1p0RequestState),
@@ -216,6 +212,7 @@ pub enum VideoGenerationRequest {
   KinoviSeedance2p0Fast(KinoviSeedance2p0FastRequestState),
   KinoviSeedance2p0Mini(KinoviSeedance2p0MiniRequestState),
   KinoviSeedance2p5Preview(KinoviSeedance2p5PreviewRequestState),
+  KinoviSeedance2p5(KinoviSeedance2p5RequestState),
 }
 
 impl VideoGenerationRequest {
@@ -241,14 +238,14 @@ impl VideoGenerationRequest {
       Self::ArtcraftSeedance1p5Pro(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0Fast(_) => RouterProvider::Artcraft,
-      Self::ArtcraftSeedance2p0Ultra(_) => RouterProvider::Artcraft,
-      Self::ArtcraftSeedance2p0UltraFast(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlus(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlusFast(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlusUltra(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlusUltraFast(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0Mini(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p5Preview(_) => RouterProvider::Artcraft,
+      Self::ArtcraftSeedance2p5(_) => RouterProvider::Artcraft,
+      Self::ArtcraftSeedance2p5Ultra(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlusMini(_) => RouterProvider::Artcraft,
       Self::ArtcraftSeedance2p0BytePlusUltraMini(_) => RouterProvider::Artcraft,
       Self::ArtcraftSora2(_) => RouterProvider::Artcraft,
@@ -283,8 +280,6 @@ impl VideoGenerationRequest {
       Self::FalVeo3p1Lite(_) => RouterProvider::Fal,
       Self::FalViduQ3(_) => RouterProvider::Fal,
       Self::FalViduQ3Turbo(_) => RouterProvider::Fal,
-      Self::GmiCloudSeedance2p0Ultra(_) => RouterProvider::GmiCloud,
-      Self::GmiCloudSeedance2p0UltraFast(_) => RouterProvider::GmiCloud,
       Self::GrokApiGrokImagineVideo(_) => RouterProvider::GrokApi,
       Self::GrokApiGrokImagineVideo1p5(_) => RouterProvider::GrokApi,
       Self::KinoviHappyHorse1p0(_) => RouterProvider::KinoviWeb,
@@ -292,6 +287,7 @@ impl VideoGenerationRequest {
       Self::KinoviSeedance2p0Fast(_) => RouterProvider::KinoviWeb,
       Self::KinoviSeedance2p0Mini(_) => RouterProvider::KinoviWeb,
       Self::KinoviSeedance2p5Preview(_) => RouterProvider::KinoviWeb,
+      Self::KinoviSeedance2p5(_) => RouterProvider::KinoviWeb,
     }
   }
 
@@ -317,14 +313,14 @@ impl VideoGenerationRequest {
       VideoGenerationRequest::ArtcraftSeedance1p5Pro(request) => Ok(ArtcraftSeedance1p5ProCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0(request) => Ok(ArtcraftSeedance2p0CostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0Fast(request) => Ok(ArtcraftSeedance2p0FastCostState::from_request(request).estimate_cost()),
-      VideoGenerationRequest::ArtcraftSeedance2p0Ultra(request) => Ok(ArtcraftSeedance2p0UltraCostState::from_request(request).estimate_cost()),
-      VideoGenerationRequest::ArtcraftSeedance2p0UltraFast(request) => Ok(ArtcraftSeedance2p0UltraFastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlus(request) => Ok(ArtcraftSeedance2p0BytePlusCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusFast(request) => Ok(ArtcraftSeedance2p0BytePlusFastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusUltra(request) => Ok(ArtcraftSeedance2p0BytePlusUltraCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusUltraFast(request) => Ok(ArtcraftSeedance2p0BytePlusUltraFastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0Mini(request) => Ok(ArtcraftSeedance2p0MiniCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p5Preview(request) => Ok(ArtcraftSeedance2p5PreviewCostState::from_request(request).estimate_cost()),
+      VideoGenerationRequest::ArtcraftSeedance2p5(request) => Ok(ArtcraftSeedance2p5CostState::from_request(request).estimate_cost()),
+      VideoGenerationRequest::ArtcraftSeedance2p5Ultra(request) => Ok(ArtcraftSeedance2p5UltraCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusMini(request) => Ok(ArtcraftSeedance2p0BytePlusMiniCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusUltraMini(request) => Ok(ArtcraftSeedance2p0BytePlusUltraMiniCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSora2(request) => Ok(ArtcraftSora2CostState::from_request(request).estimate_cost()),
@@ -359,8 +355,6 @@ impl VideoGenerationRequest {
       VideoGenerationRequest::FalVeo3p1Lite(request) => Ok(FalVeo3p1LiteCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::FalViduQ3(request) => Ok(FalViduQ3CostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::FalViduQ3Turbo(request) => Ok(FalViduQ3TurboCostState::from_request(request).estimate_cost()),
-      VideoGenerationRequest::GmiCloudSeedance2p0Ultra(request) => Ok(GmiCloudSeedance2p0UltraCostState::from_request(request).estimate_cost()),
-      VideoGenerationRequest::GmiCloudSeedance2p0UltraFast(request) => Ok(GmiCloudSeedance2p0UltraFastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::GrokApiGrokImagineVideo(request) => Ok(GrokApiGrokImagineVideoCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::GrokApiGrokImagineVideo1p5(request) => GrokApiGrokImagineVideo1p5CostState::from_request(request).estimate_cost(),
       VideoGenerationRequest::KinoviHappyHorse1p0(request) => Ok(KinoviHappyHorse1p0CostState::from_request(request).estimate_cost()),
@@ -368,6 +362,7 @@ impl VideoGenerationRequest {
       VideoGenerationRequest::KinoviSeedance2p0Fast(request) => Ok(KinoviSeedance2p0FastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::KinoviSeedance2p0Mini(request) => Ok(KinoviSeedance2p0MiniCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::KinoviSeedance2p5Preview(request) => Ok(KinoviSeedance2p5PreviewCostState::from_request(request).estimate_cost()),
+      VideoGenerationRequest::KinoviSeedance2p5(request) => Ok(KinoviSeedance2p5CostState::from_request(request).estimate_cost()),
     }
   }
 
@@ -451,14 +446,6 @@ impl VideoGenerationRequest {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await
       },
-      VideoGenerationRequest::ArtcraftSeedance2p0Ultra(request) => {
-        let client_ref = client.get_artcraft_client_ref()?;
-        request.send(client_ref).await
-      },
-      VideoGenerationRequest::ArtcraftSeedance2p0UltraFast(request) => {
-        let client_ref = client.get_artcraft_client_ref()?;
-        request.send(client_ref).await
-      },
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlus(request) => {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await
@@ -483,6 +470,14 @@ impl VideoGenerationRequest {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await
       },
+      VideoGenerationRequest::ArtcraftSeedance2p5(request) => {
+        let client_ref = client.get_artcraft_client_ref()?;
+        request.send(client_ref).await
+      },
+      VideoGenerationRequest::ArtcraftSeedance2p5Ultra(request) => {
+        let client_ref = client.get_artcraft_client_ref()?;
+        request.send(client_ref).await
+      },
       VideoGenerationRequest::ArtcraftSeedance2p0BytePlusMini(request) => {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await
@@ -619,14 +614,6 @@ impl VideoGenerationRequest {
         let client_ref = client.get_fal_client_ref()?;
         request.send(client_ref).await
       },
-      VideoGenerationRequest::GmiCloudSeedance2p0Ultra(request) => {
-        let client_ref = client.get_gmicloud_client_ref()?;
-        request.send(client_ref).await
-      },
-      VideoGenerationRequest::GmiCloudSeedance2p0UltraFast(request) => {
-        let client_ref = client.get_gmicloud_client_ref()?;
-        request.send(client_ref).await
-      },
       VideoGenerationRequest::GrokApiGrokImagineVideo(request) => {
         let client_ref = client.get_grok_api_client_ref()?;
         request.send(client_ref).await
@@ -655,6 +642,10 @@ impl VideoGenerationRequest {
         let client_ref = client.get_kinovi_web_client_ref()?;
         request.send(client_ref).await
       },
+      VideoGenerationRequest::KinoviSeedance2p5(request) => {
+        let client_ref = client.get_kinovi_web_client_ref()?;
+        request.send(client_ref).await
+      },
     }
   }
 }

crates/api_clients/artcraft/artcraft_router/src/test_helpers.rs

@@ -355,6 +355,7 @@ pub fn base_video_request() -> GenerateVideoRequestBuilder {
     duration_seconds: None,
     video_batch_count: None,
     generate_audio: None,
+    total_reference_video_input_seconds: None,
     request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
     idempotency_token: None,
   }

crates/api_clients/kinovi_web_client/src/generate/video/generate_happy_horse_1p0.rs

@@ -119,7 +119,7 @@ pub async fn generate_happy_horse_1p0(
     model_type: KinoviModelTypeRaw::HappyHorse1p0,
     prompt: req.prompt,
     aspect_ratio: map_aspect_ratio(req.aspect_ratio),
-    output_resolution: req.output_resolution.map(map_output_resolution),
+    output_resolution: Some(map_output_resolution(req.output_resolution)),
     batch_count: map_batch_count(req.batch_count),
     duration_seconds: req.duration_seconds,
     start_frame_url: req.start_frame_url,
@@ -159,10 +159,12 @@ fn map_aspect_ratio(ar: Option<KinoviHappyHorse1p0AspectRatio>) -> KinoviAspectR
   }
 }
 
-fn map_output_resolution(res: KinoviHappyHorse1p0OutputResolution) -> KinoviOutputResolutionRaw {
+fn map_output_resolution(res: Option<KinoviHappyHorse1p0OutputResolution>) -> KinoviOutputResolutionRaw {
   match res {
-    KinoviHappyHorse1p0OutputResolution::SevenTwentyP => KinoviOutputResolutionRaw::SevenTwentyP,
-    KinoviHappyHorse1p0OutputResolution::TenEightyP => KinoviOutputResolutionRaw::TenEightyP,
+    // Unset resolves to 720p — MUST stay in lockstep with calculate_costs(),
+    // which prices None as 720p.
+    Some(KinoviHappyHorse1p0OutputResolution::SevenTwentyP) | None => KinoviOutputResolutionRaw::SevenTwentyP,
+    Some(KinoviHappyHorse1p0OutputResolution::TenEightyP) => KinoviOutputResolutionRaw::TenEightyP,
   }
 }
 

crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p0.rs

@@ -61,6 +61,7 @@ pub enum KinoviSeedance2p0OutputResolution {
 pub enum KinoviSeedance2p0BatchCount {
   One,
   Two,
+  Three,
   Four,
 }
 
@@ -124,6 +125,7 @@ impl GenerateSeedance2p0Request {
     let batch_multiplier: u64 = match self.batch_count {
       None | Some(KinoviSeedance2p0BatchCount::One) => 1,
       Some(KinoviSeedance2p0BatchCount::Two) => 2,
+      Some(KinoviSeedance2p0BatchCount::Three) => 3,
       Some(KinoviSeedance2p0BatchCount::Four) => 4,
     };
 
@@ -181,7 +183,7 @@ pub async fn generate_seedance_2p0(
     model_type: KinoviModelTypeRaw::Seedance2Pro,
     prompt: req.prompt,
     aspect_ratio: map_aspect_ratio(req.aspect_ratio),
-    output_resolution: req.output_resolution.map(map_output_resolution),
+    output_resolution: Some(map_output_resolution(req.output_resolution)),
     batch_count: map_batch_count(req.batch_count),
     duration_seconds: req.duration_seconds,
     start_frame_url: req.start_frame_url,
@@ -222,12 +224,16 @@ fn map_aspect_ratio(ar: Option<KinoviSeedance2p0AspectRatio>) -> KinoviAspectRat
   }
 }
 
-fn map_output_resolution(res: KinoviSeedance2p0OutputResolution) -> KinoviOutputResolutionRaw {
+fn map_output_resolution(res: Option<KinoviSeedance2p0OutputResolution>) -> KinoviOutputResolutionRaw {
   match res {
-    KinoviSeedance2p0OutputResolution::FourEightyP => KinoviOutputResolutionRaw::FourEightyP,
-    KinoviSeedance2p0OutputResolution::SevenTwentyP => KinoviOutputResolutionRaw::SevenTwentyP,
-    KinoviSeedance2p0OutputResolution::TenEightyP => KinoviOutputResolutionRaw::TenEightyP,
-    KinoviSeedance2p0OutputResolution::FourK => KinoviOutputResolutionRaw::FourK,
+    Some(KinoviSeedance2p0OutputResolution::FourEightyP) => KinoviOutputResolutionRaw::FourEightyP,
+    // Unset resolves to 720p — MUST stay in lockstep with calculate_costs(),
+    // which prices None as 720p. Never leave the resolution to the Kinovi
+    // server-side default; a silent upstream change would make supplier cost
+    // diverge from what we billed.
+    Some(KinoviSeedance2p0OutputResolution::SevenTwentyP) | None => KinoviOutputResolutionRaw::SevenTwentyP,
+    Some(KinoviSeedance2p0OutputResolution::TenEightyP) => KinoviOutputResolutionRaw::TenEightyP,
+    Some(KinoviSeedance2p0OutputResolution::FourK) => KinoviOutputResolutionRaw::FourK,
   }
 }
 
@@ -235,6 +241,7 @@ fn map_batch_count(bc: Option<KinoviSeedance2p0BatchCount>) -> KinoviBatchCountR
   match bc {
     Some(KinoviSeedance2p0BatchCount::One) | None => KinoviBatchCountRaw::One,
     Some(KinoviSeedance2p0BatchCount::Two) => KinoviBatchCountRaw::Two,
+    Some(KinoviSeedance2p0BatchCount::Three) => KinoviBatchCountRaw::Three,
     Some(KinoviSeedance2p0BatchCount::Four) => KinoviBatchCountRaw::Four,
   }
 }
@@ -689,6 +696,13 @@ mod tests {
         assert_eq!(batch2, base * 2);
       }
 
+      #[test]
+      fn batch_3_triples() {
+        let base = r720(5).calculate_costs().total_cost.kinovi_credits;
+        let batch3 = build_request(5, None, Some(KinoviSeedance2p0BatchCount::Three)).calculate_costs().total_cost.kinovi_credits;
+        assert_eq!(batch3, base * 3);
+      }
+
       #[test]
       fn batch_4_quadruples() {
         let base = r720(5).calculate_costs().total_cost.kinovi_credits;

crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p0_fast.rs

@@ -59,6 +59,7 @@ pub enum KinoviSeedance2p0FastOutputResolution {
 pub enum KinoviSeedance2p0FastBatchCount {
   One,
   Two,
+  Three,
   Four,
 }
 
@@ -114,6 +115,7 @@ impl GenerateSeedance2p0FastRequest {
     let batch_multiplier: u64 = match self.batch_count {
       None | Some(KinoviSeedance2p0FastBatchCount::One) => 1,
       Some(KinoviSeedance2p0FastBatchCount::Two) => 2,
+      Some(KinoviSeedance2p0FastBatchCount::Three) => 3,
       Some(KinoviSeedance2p0FastBatchCount::Four) => 4,
     };
 
@@ -171,7 +173,7 @@ pub async fn generate_seedance_2p0_fast(
     model_type: KinoviModelTypeRaw::Seedance2Fast,
     prompt: req.prompt,
     aspect_ratio: map_aspect_ratio(req.aspect_ratio),
-    output_resolution: req.output_resolution.map(map_output_resolution),
+    output_resolution: Some(map_output_resolution(req.output_resolution)),
     batch_count: map_batch_count(req.batch_count),
     duration_seconds: req.duration_seconds,
     start_frame_url: req.start_frame_url,
@@ -212,10 +214,12 @@ fn map_aspect_ratio(ar: Option<KinoviSeedance2p0FastAspectRatio>) -> KinoviAspec
   }
 }
 
-fn map_output_resolution(res: KinoviSeedance2p0FastOutputResolution) -> KinoviOutputResolutionRaw {
+fn map_output_resolution(res: Option<KinoviSeedance2p0FastOutputResolution>) -> KinoviOutputResolutionRaw {
   match res {
-    KinoviSeedance2p0FastOutputResolution::FourEightyP => KinoviOutputResolutionRaw::FourEightyP,
-    KinoviSeedance2p0FastOutputResolution::SevenTwentyP => KinoviOutputResolutionRaw::SevenTwentyP,
+    Some(KinoviSeedance2p0FastOutputResolution::FourEightyP) => KinoviOutputResolutionRaw::FourEightyP,
+    // Unset resolves to 720p — MUST stay in lockstep with calculate_costs(),
+    // which prices None as 720p.
+    Some(KinoviSeedance2p0FastOutputResolution::SevenTwentyP) | None => KinoviOutputResolutionRaw::SevenTwentyP,
   }
 }
 
@@ -223,6 +227,7 @@ fn map_batch_count(bc: Option<KinoviSeedance2p0FastBatchCount>) -> KinoviBatchCo
   match bc {
     Some(KinoviSeedance2p0FastBatchCount::One) | None => KinoviBatchCountRaw::One,
     Some(KinoviSeedance2p0FastBatchCount::Two) => KinoviBatchCountRaw::Two,
+    Some(KinoviSeedance2p0FastBatchCount::Three) => KinoviBatchCountRaw::Three,
     Some(KinoviSeedance2p0FastBatchCount::Four) => KinoviBatchCountRaw::Four,
   }
 }
@@ -465,6 +470,13 @@ mod tests {
         assert_eq!(batch2, base * 2);
       }
 
+      #[test]
+      fn batch_3_triples() {
+        let base = r720(5).calculate_costs().total_cost.kinovi_credits;
+        let batch3 = build_request(5, None, Some(KinoviSeedance2p0FastBatchCount::Three)).calculate_costs().total_cost.kinovi_credits;
+        assert_eq!(batch3, base * 3);
+      }
+
       #[test]
       fn batch_4_quadruples() {
         let base = r720(5).calculate_costs().total_cost.kinovi_credits;

crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p0_mini.rs

@@ -179,7 +179,7 @@ fn to_raw_request(req: GenerateSeedance2p0MiniRequest) -> WorkflowRunTaskRequest
     model_type: KinoviModelTypeRaw::Seedance2Mini,
     prompt: req.prompt,
     aspect_ratio: map_aspect_ratio(req.aspect_ratio),
-    output_resolution: req.output_resolution.map(map_output_resolution),
+    output_resolution: Some(map_output_resolution(req.output_resolution)),
     batch_count: map_batch_count(req.batch_count),
     duration_seconds: req.duration_seconds,
     start_frame_url: req.start_frame_url,
@@ -205,10 +205,12 @@ fn map_aspect_ratio(ar: Option<KinoviSeedance2p0MiniAspectRatio>) -> KinoviAspec
   }
 }
 
-fn map_output_resolution(res: KinoviSeedance2p0MiniOutputResolution) -> KinoviOutputResolutionRaw {
+fn map_output_resolution(res: Option<KinoviSeedance2p0MiniOutputResolution>) -> KinoviOutputResolutionRaw {
   match res {
-    KinoviSeedance2p0MiniOutputResolution::FourEightyP => KinoviOutputResolutionRaw::FourEightyP,
-    KinoviSeedance2p0MiniOutputResolution::SevenTwentyP => KinoviOutputResolutionRaw::SevenTwentyP,
+    Some(KinoviSeedance2p0MiniOutputResolution::FourEightyP) => KinoviOutputResolutionRaw::FourEightyP,
+    // Unset resolves to 720p — MUST stay in lockstep with calculate_costs(),
+    // which prices None as 720p.
+    Some(KinoviSeedance2p0MiniOutputResolution::SevenTwentyP) | None => KinoviOutputResolutionRaw::SevenTwentyP,
   }
 }
 
@@ -566,11 +568,11 @@ mod tests {
     }
 
     #[test]
-    fn default_resolution_maps_to_none() {
+    fn default_resolution_maps_to_720p() {
       let mut req = sample();
       req.output_resolution = None;
       let raw = to_raw_request(req);
-      assert!(raw.output_resolution.is_none());
+      assert!(matches!(raw.output_resolution, Some(KinoviOutputResolutionRaw::SevenTwentyP)));
     }
 
     #[test]

crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p5.rs

@@ -0,0 +1,783 @@
+use crate::creds::kinovi_web_session::KinoviWebSession;
+use crate::error::kinovi_web_error::KinoviWebError;
+use crate::cost::kinovi_fractional_generation_cost::KinoviFractionalGenerationCost;
+use crate::requests::kinovi_host::KinoviHost;
+use crate::requests::workflow_run_task::workflow_run_task::{
+  workflow_run_task, KinoviAspectRatioRaw, KinoviBatchCountRaw, KinoviModelTypeRaw,
+  KinoviOutputResolutionRaw, WorkflowRunTaskArgs, WorkflowRunTaskRequest,
+};
+
+// ── Constants ──
+
+/// Seedance 2.5 supports at most 30 seconds of video: reference-video input
+/// seconds beyond this are clamped for billing.
+pub const MAX_BILLED_INPUT_SECONDS: u8 = 30;
+
+/// The minimum TOTAL billed input seconds when video references are
+/// attached: however short the input videos are, the total bills at least 4
+/// seconds. (Three 1-second videos sum to 3 and clamp to 4; three 3-second
+/// videos sum to 9 and bill 9.)
+pub const MIN_BILLED_INPUT_SECONDS: u8 = 4;
+
+// ── Args ──
+
+pub struct GenerateSeedance2p5Args<'a> {
+  pub request: GenerateSeedance2p5Request,
+  pub session: &'a KinoviWebSession,
+  pub host_override: Option<KinoviHost>,
+}
+
+// ── Request ──
+
+/// Seedance 2.5 supports keyframe (image-to-video) and reference
+/// (text-to-video / reference-to-video) modalities, and 480p/720p output.
+///
+/// On the wire it reuses the 2.5 *Preview* business type
+/// (`seedance25-preview-video-generation`) with model `seedance2-5`;
+/// text-to-video is sent as mode "reference".
+#[derive(Clone, Debug)]
+pub struct GenerateSeedance2p5Request {
+  pub prompt: String,
+
+  pub modality: KinoviSeedance2p5Modality,
+
+  pub output_resolution: Option<KinoviSeedance2p5OutputResolution>,
+
+  pub duration_seconds: u8,
+
+  /// CALCULATION-ONLY (never sent on the wire): the total seconds of
+  /// reference video input, summed across all reference videos. When video
+  /// references are attached, Kinovi bills the input seconds on top of the
+  /// output duration — see the pricing notes on [`calculate_costs`].
+  ///
+  /// [`calculate_costs`]: GenerateSeedance2p5Request::calculate_costs
+  pub total_input_seconds: Option<u8>,
+
+  /// Controls `faceBlurMode`: true sends "on"; false or None sends "off"
+  /// (the model always sends the field, like 2.5 Preview).
+  pub use_face_blur_hack: Option<bool>,
+}
+
+// ── Modality ──
+
+/// The generation modality. The aspect ratio choice lives here because the
+/// two modalities support disjoint aspect ratio sets.
+#[derive(Clone, Debug)]
+pub enum KinoviSeedance2p5Modality {
+  /// Image-to-video (start frame + optional end frame).
+  ///
+  /// The aspect ratio is always "Adaptive" — the only choice the API allows
+  /// in this modality, expressed on the wire by omitting the `aspectRatio`
+  /// field entirely — so there is nothing to configure.
+  Keyframe {
+    start_frame_url: String,
+    end_frame_url: Option<String>,
+  },
+
+  /// Text-to-video / reference-to-video. "Adaptive" is NOT supported here;
+  /// `None` defaults to 16:9.
+  Reference {
+    aspect_ratio: Option<KinoviSeedance2p5AspectRatio>,
+    /// Reference images, referenced in prompts as @image1, @image2, etc.
+    reference_image_urls: Option<Vec<String>>,
+    /// Reference videos, referenced in prompts as @video1, @video2, etc.
+    reference_video_urls: Option<Vec<String>>,
+    /// Reference audio, referenced in prompts as @audio1, @audio2, etc.
+    reference_audio_urls: Option<Vec<String>>,
+  },
+}
+
+// ── Enums ──
+
+/// Aspect ratios for the reference (text/reference-to-video) modality.
+/// There is deliberately no "Adaptive" variant: Adaptive is keyframe-only
+/// (and there it is the only choice).
+#[derive(Debug, Clone, Copy)]
+pub enum KinoviSeedance2p5AspectRatio {
+  Landscape16x9,
+  UltraWide21x9,
+  Portrait9x16,
+  Square1x1,
+  Standard4x3,
+  Portrait3x4,
+}
+
+/// Output resolution. Seedance 2.5 supports only 480p and 720p for now.
+#[derive(Debug, Clone, Copy)]
+pub enum KinoviSeedance2p5OutputResolution {
+  FourEightyP,
+  SevenTwentyP,
+}
+
+// ── Pricing ──
+//
+// Seedance 2.5 credit pricing (whole credits per billed second):
+//
+// | Resolution | No video refs | With video refs |
+// |------------|---------------|-----------------|
+// | 480p       |            26 |              16 |
+// | 720p       |            59 |              35 |
+//
+// Without video references (text-to-video, keyframe, and reference mode with
+// only image/audio references), billed seconds = output duration.
+//
+// With video references, the rate drops but the billed seconds are the
+// output duration PLUS the total seconds of reference video input
+// (`total_input_seconds`, summed across all reference videos and clamped to
+// the [`MIN_BILLED_INPUT_SECONDS`]..=[`MAX_BILLED_INPUT_SECONDS`] range). E.g. a 30s output with a 10s video
+// reference bills as 40 seconds; a 30s output with two 7s references (14s
+// total input) bills as 44 seconds.
+//
+// Default resolution (None) is 720p.
+// Credit package: 525,000 credits for $2,159.0909 (~243 credits/$1).
+
+impl GenerateSeedance2p5Request {
+  /// Calculate the cost of this generation request, in Kinovi credits and
+  /// USD cents.
+  pub fn calculate_costs(&self) -> KinoviFractionalGenerationCost {
+    let has_video_references = matches!(
+      &self.modality,
+      KinoviSeedance2p5Modality::Reference { reference_video_urls: Some(urls), .. } if !urls.is_empty()
+    );
+
+    let (credits_per_second, billed_seconds) = if has_video_references {
+      let rate = match self.output_resolution {
+        Some(KinoviSeedance2p5OutputResolution::FourEightyP) => 16u64,
+        Some(KinoviSeedance2p5OutputResolution::SevenTwentyP) | None => 35u64,
+      };
+      // An unknown (None) or zero input duration bills the worst-case
+      // maximum — never default toward the minimum.
+      let input_seconds = match self.total_input_seconds {
+        None | Some(0) => MAX_BILLED_INPUT_SECONDS,
+        Some(seconds) => seconds.clamp(MIN_BILLED_INPUT_SECONDS, MAX_BILLED_INPUT_SECONDS),
+      };
+      let seconds = u64::from(self.duration_seconds) + u64::from(input_seconds);
+      (rate, seconds)
+    } else {
+      let rate = match self.output_resolution {
+        Some(KinoviSeedance2p5OutputResolution::FourEightyP) => 26u64,
+        Some(KinoviSeedance2p5OutputResolution::SevenTwentyP) | None => 59u64,
+      };
+      (rate, u64::from(self.duration_seconds))
+    };
+
+    let total_credits = credits_per_second * billed_seconds;
+    KinoviFractionalGenerationCost::from_kinovi_credits(total_credits as f64)
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateSeedance2p5Response {
+  pub task_id: String,
+  pub order_id: String,
+  pub task_ids: Option<Vec<String>>,
+  pub order_ids: Option<Vec<String>>,
+}
+
+// ── Entry point ──
+
+pub async fn generate_seedance_2p5(
+  args: GenerateSeedance2p5Args<'_>,
+) -> Result<GenerateSeedance2p5Response, KinoviWebError> {
+  let raw_response = workflow_run_task(WorkflowRunTaskArgs {
+    request: to_raw_request(args.request),
+    session: args.session,
+    host_override: args.host_override,
+  }).await?;
+
+  Ok(GenerateSeedance2p5Response {
+    task_id: raw_response.task_id,
+    order_id: raw_response.order_id,
+    task_ids: raw_response.task_ids,
+    order_ids: raw_response.order_ids,
+  })
+}
+
+// ── Mapping helpers ──
+
+fn to_raw_request(req: GenerateSeedance2p5Request) -> WorkflowRunTaskRequest {
+  let (
+    aspect_ratio,
+    start_frame_url,
+    end_frame_url,
+    reference_image_urls,
+    reference_video_urls,
+    reference_audio_urls,
+  ) = match req.modality {
+    KinoviSeedance2p5Modality::Keyframe { start_frame_url, end_frame_url } => (
+      // Keyframe is always "Adaptive"; the raw layer omits the aspect ratio
+      // for 2.5 keyframe requests, so this placeholder never hits the wire.
+      KinoviAspectRatioRaw::Landscape16x9,
+      Some(start_frame_url),
+      end_frame_url,
+      None,
+      None,
+      None,
+    ),
+    KinoviSeedance2p5Modality::Reference {
+      aspect_ratio,
+      reference_image_urls,
+      reference_video_urls,
+      reference_audio_urls,
+    } => (
+      map_aspect_ratio(aspect_ratio),
+      None,
+      None,
+      reference_image_urls,
+      reference_video_urls,
+      reference_audio_urls,
+    ),
+  };
+
+  WorkflowRunTaskRequest {
+    model_type: KinoviModelTypeRaw::Seedance2p5,
+    prompt: req.prompt,
+    aspect_ratio,
+    output_resolution: Some(map_output_resolution(req.output_resolution)),
+    duration_seconds: req.duration_seconds,
+    batch_count: KinoviBatchCountRaw::One,
+    start_frame_url,
+    end_frame_url,
+    reference_image_urls,
+    reference_video_urls,
+    reference_audio_urls,
+    character_ids: None,
+    use_face_blur_hack: req.use_face_blur_hack,
+    bitrate: None,
+  }
+}
+
+fn map_aspect_ratio(ar: Option<KinoviSeedance2p5AspectRatio>) -> KinoviAspectRatioRaw {
+  match ar {
+    Some(KinoviSeedance2p5AspectRatio::Landscape16x9) => KinoviAspectRatioRaw::Landscape16x9,
+    Some(KinoviSeedance2p5AspectRatio::UltraWide21x9) => KinoviAspectRatioRaw::UltraWide21x9,
+    Some(KinoviSeedance2p5AspectRatio::Portrait9x16) => KinoviAspectRatioRaw::Portrait9x16,
+    Some(KinoviSeedance2p5AspectRatio::Square1x1) => KinoviAspectRatioRaw::Square1x1,
+    Some(KinoviSeedance2p5AspectRatio::Standard4x3) => KinoviAspectRatioRaw::Landscape4x3,
+    Some(KinoviSeedance2p5AspectRatio::Portrait3x4) => KinoviAspectRatioRaw::Portrait3x4,
+    None => KinoviAspectRatioRaw::Landscape16x9,
+  }
+}
+
+fn map_output_resolution(res: Option<KinoviSeedance2p5OutputResolution>) -> KinoviOutputResolutionRaw {
+  match res {
+    Some(KinoviSeedance2p5OutputResolution::FourEightyP) => KinoviOutputResolutionRaw::FourEightyP,
+    // Unset resolves to 720p — MUST stay in lockstep with calculate_costs(),
+    // which prices None as 720p.
+    Some(KinoviSeedance2p5OutputResolution::SevenTwentyP) | None => KinoviOutputResolutionRaw::SevenTwentyP,
+  }
+}
+
+// ── Tests ──
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::creds::kinovi_web_session::KinoviWebSession;
+  use crate::test_utils::get_test_cookies::get_test_cookies;
+  use crate::test_utils::setup_test_logging::setup_test_logging;
+  use errors::AnyhowResult;
+  use log::LevelFilter;
+
+  mod pricing_tests {
+    use super::*;
+
+    const FLOAT_TOLERANCE: f64 = 1e-9;
+
+    // ── No video references: output-duration billing ──
+    //
+    // 480p = 26 credits/sec, 720p = 59 credits/sec.
+
+    mod without_video_references {
+      use super::*;
+
+      #[test]
+      fn table_480p() {
+        assert_eq!(t2v_480(1).calculate_costs().kinovi_credits, 26.0);
+        assert_eq!(t2v_480(5).calculate_costs().kinovi_credits, 130.0);
+        assert_eq!(t2v_480(10).calculate_costs().kinovi_credits, 260.0);
+        assert_eq!(t2v_480(15).calculate_costs().kinovi_credits, 390.0);
+        assert_eq!(t2v_480(30).calculate_costs().kinovi_credits, 780.0);
+      }
+
+      #[test]
+      fn table_720p() {
+        assert_eq!(t2v_720(1).calculate_costs().kinovi_credits, 59.0);
+        assert_eq!(t2v_720(5).calculate_costs().kinovi_credits, 295.0);
+        assert_eq!(t2v_720(10).calculate_costs().kinovi_credits, 590.0);
+        assert_eq!(t2v_720(15).calculate_costs().kinovi_credits, 885.0);
+        assert_eq!(t2v_720(30).calculate_costs().kinovi_credits, 1770.0);
+      }
+
+      #[test]
+      fn default_resolution_is_720p() {
+        let default = t2v_720(10).calculate_costs();
+        let mut explicit = t2v_720(10);
+        explicit.output_resolution = Some(KinoviSeedance2p5OutputResolution::SevenTwentyP);
+        assert_eq!(default, explicit.calculate_costs());
+      }
+
+      #[test]
+      fn keyframe_modality_uses_no_reference_rates() {
+        let mut request = keyframe_request(10);
+        request.output_resolution = Some(KinoviSeedance2p5OutputResolution::FourEightyP);
+        assert_eq!(request.calculate_costs().kinovi_credits, 260.0);
+
+        let request_720 = keyframe_request(10);
+        assert_eq!(request_720.calculate_costs().kinovi_credits, 590.0);
+      }
+
+      #[test]
+      fn image_and_audio_references_do_not_change_the_rate() {
+        let mut request = t2v_480(10);
+        set_reference_urls(
+          &mut request,
+          Some(vec!["https://example.com/a.png".to_string(), "https://example.com/b.jpg".to_string()]),
+          None,
+          Some(vec!["https://example.com/ref.wav".to_string()]),
+        );
+        assert_eq!(request.calculate_costs().kinovi_credits, 260.0);
+      }
+
+      #[test]
+      fn empty_video_reference_list_counts_as_no_references() {
+        let mut request = t2v_480(10);
+        set_reference_urls(&mut request, None, Some(Vec::new()), None);
+        assert_eq!(request.calculate_costs().kinovi_credits, 260.0);
+      }
+
+      #[test]
+      fn total_input_seconds_is_ignored_without_video_references() {
+        let mut request = t2v_480(10);
+        request.total_input_seconds = Some(60);
+        assert_eq!(request.calculate_costs().kinovi_credits, 260.0);
+      }
+    }
+
+    // ── With video references: input seconds are billed too ──
+    //
+    // 480p = 16 credits/sec, 720p = 35 credits/sec, over
+    // (output duration + total_input_seconds) billed seconds.
+
+    mod with_video_references {
+      use super::*;
+
+      #[test]
+      fn thirty_second_output_with_ten_second_reference_bills_forty_seconds() {
+        // The canonical example: 30s output + 10s of input video = 40 billed seconds.
+        let request = video_ref_480(30, Some(10));
+        assert_eq!(request.calculate_costs().kinovi_credits, (16 * 40) as f64);
+
+        let request = video_ref_720(30, Some(10));
+        assert_eq!(request.calculate_costs().kinovi_credits, (35 * 40) as f64);
+      }
+
+      #[test]
+      fn two_seven_second_references_bill_forty_four_seconds() {
+        // Two 7s references (14s total input) + 30s output = 44 billed seconds.
+        let mut request = video_ref_480(30, Some(14));
+        set_reference_urls(
+          &mut request,
+          None,
+          Some(vec![
+            "https://example.com/ref1.mp4".to_string(),
+            "https://example.com/ref2.mp4".to_string(),
+          ]),
+          None,
+        );
+        assert_eq!(request.calculate_costs().kinovi_credits, (16 * 44) as f64);
+      }
+
+      #[test]
+      fn table_480p_with_ten_input_seconds() {
+        assert_eq!(video_ref_480(5, Some(10)).calculate_costs().kinovi_credits, (16 * 15) as f64);
+        assert_eq!(video_ref_480(10, Some(10)).calculate_costs().kinovi_credits, (16 * 20) as f64);
+        assert_eq!(video_ref_480(30, Some(10)).calculate_costs().kinovi_credits, (16 * 40) as f64);
+      }
+
+      #[test]
+      fn table_720p_with_ten_input_seconds() {
+        assert_eq!(video_ref_720(5, Some(10)).calculate_costs().kinovi_credits, (35 * 15) as f64);
+        assert_eq!(video_ref_720(10, Some(10)).calculate_costs().kinovi_credits, (35 * 20) as f64);
+        assert_eq!(video_ref_720(30, Some(10)).calculate_costs().kinovi_credits, (35 * 40) as f64);
+      }
+
+      #[test]
+      fn input_totals_under_four_seconds_clamp_to_four() {
+        // Total input clamps to a 4-second minimum: 1s, 3s, and 4s totals
+        // all bill 4; 5s bills 5.
+        assert_eq!(video_ref_480(30, Some(1)).calculate_costs().kinovi_credits, (16 * 34) as f64);
+        assert_eq!(video_ref_480(30, Some(3)).calculate_costs().kinovi_credits, (16 * 34) as f64);
+        assert_eq!(video_ref_480(30, Some(4)).calculate_costs().kinovi_credits, (16 * 34) as f64);
+        assert_eq!(video_ref_480(30, Some(5)).calculate_costs().kinovi_credits, (16 * 35) as f64);
+      }
+
+      #[test]
+      fn missing_total_input_seconds_bills_the_worst_case_maximum() {
+        // Unknown input duration with video references attached: assume the
+        // 30-second maximum so the estimate never undershoots the charge.
+        assert_eq!(video_ref_480(10, None).calculate_costs().kinovi_credits, (16 * 40) as f64);
+        assert_eq!(video_ref_720(10, None).calculate_costs().kinovi_credits, (35 * 40) as f64);
+      }
+
+      #[test]
+      fn input_seconds_clamp_to_max_billed_input_seconds() {
+        // 200 input seconds clamp to 30: 30s output + 30 = 60 billed seconds.
+        assert_eq!(video_ref_480(30, Some(200)).calculate_costs().kinovi_credits, (16 * 60) as f64);
+        assert_eq!(
+          video_ref_480(30, Some(200)).calculate_costs(),
+          video_ref_480(30, Some(MAX_BILLED_INPUT_SECONDS)).calculate_costs(),
+        );
+      }
+
+      #[test]
+      fn mixed_references_still_use_video_reference_rates() {
+        let mut request = video_ref_480(10, Some(5));
+        set_reference_urls(
+          &mut request,
+          Some(vec!["https://example.com/a.png".to_string()]),
+          Some(vec!["https://example.com/ref.mp4".to_string()]),
+          Some(vec!["https://example.com/ref.wav".to_string()]),
+        );
+        assert_eq!(request.calculate_costs().kinovi_credits, (16 * 15) as f64);
+      }
+    }
+
+    // ── USD cents conversion ──
+    //
+    // usd_cents = credits × 100 / 243, computed on integer hundredths.
+
+    mod usd_cents {
+      use super::*;
+
+      #[test]
+      fn cents_480p_5s() {
+        // 130 credits; 13000/243 = 53.4979 cents.
+        let cost = t2v_480(5).calculate_costs();
+        assert_eq!(cost.usd_cents_rounded_up, 54);
+        assert_eq!(cost.usd_cents_rounded_down, 53);
+        assert!((cost.usd_cents_fractional - (13000.0 / 243.0)).abs() < FLOAT_TOLERANCE);
+      }
+
+      #[test]
+      fn cents_720p_30s() {
+        // 1770 credits; 177000/243 = 728.3951 cents.
+        let cost = t2v_720(30).calculate_costs();
+        assert_eq!(cost.usd_cents_rounded_up, 729);
+        assert_eq!(cost.usd_cents_rounded_down, 728);
+        assert!((cost.usd_cents_fractional - (177000.0 / 243.0)).abs() < FLOAT_TOLERANCE);
+      }
+
+      #[test]
+      fn cents_720p_video_ref_40_billed_seconds() {
+        // 35 × 40 = 1400 credits; 140000/243 = 576.1317 cents.
+        let cost = video_ref_720(30, Some(10)).calculate_costs();
+        assert_eq!(cost.usd_cents_rounded_up, 577);
+        assert_eq!(cost.usd_cents_rounded_down, 576);
+        assert!((cost.usd_cents_fractional - (140000.0 / 243.0)).abs() < FLOAT_TOLERANCE);
+      }
+    }
+
+    // ── Relative pricing ──
+
+    mod relative_tests {
+      use super::*;
+
+      #[test]
+      fn video_reference_rate_is_cheaper_per_second() {
+        // 16 < 26 and 35 < 59: the with-references rate is lower per billed
+        // second (the input seconds are where the money goes). Compare at
+        // the minimum billed input (1s clamps to 4) — unknown or zero input
+        // assumes the 30-second maximum, which would swamp the rate
+        // comparison.
+        assert!(video_ref_480(10, Some(1)).calculate_costs().kinovi_credits
+          < t2v_480(10).calculate_costs().kinovi_credits);
+        assert!(video_ref_720(10, Some(1)).calculate_costs().kinovi_credits
+          < t2v_720(10).calculate_costs().kinovi_credits);
+      }
+
+      #[test]
+      fn cost_scales_linearly_with_duration() {
+        for duration in [1u8, 5, 10, 30] {
+          assert_eq!(
+            t2v_480(duration).calculate_costs().kinovi_credits,
+            (26 * u64::from(duration)) as f64,
+          );
+        }
+      }
+    }
+
+    // ── Aspect ratio doesn't affect cost ──
+
+    #[test]
+    fn aspect_ratio_does_not_affect_credits() {
+      let baseline = t2v_720(10).calculate_costs().kinovi_credits;
+
+      let ratios = [
+        KinoviSeedance2p5AspectRatio::Landscape16x9,
+        KinoviSeedance2p5AspectRatio::UltraWide21x9,
+        KinoviSeedance2p5AspectRatio::Portrait9x16,
+        KinoviSeedance2p5AspectRatio::Square1x1,
+        KinoviSeedance2p5AspectRatio::Standard4x3,
+        KinoviSeedance2p5AspectRatio::Portrait3x4,
+      ];
+
+      for ar in &ratios {
+        let mut request = t2v_720(10);
+        request.modality = KinoviSeedance2p5Modality::Reference {
+          aspect_ratio: Some(*ar),
+          reference_image_urls: None,
+          reference_video_urls: None,
+          reference_audio_urls: None,
+        };
+        assert_eq!(
+          request.calculate_costs().kinovi_credits, baseline,
+          "Aspect ratio {:?} should not change credits from baseline {}", ar, baseline,
+        );
+      }
+    }
+
+    // ── Helpers ──
+
+    fn text_to_video_request(
+      duration_seconds: u8,
+      output_resolution: Option<KinoviSeedance2p5OutputResolution>,
+    ) -> GenerateSeedance2p5Request {
+      GenerateSeedance2p5Request {
+        prompt: String::new(),
+        modality: KinoviSeedance2p5Modality::Reference {
+          aspect_ratio: None,
+          reference_image_urls: None,
+          reference_video_urls: None,
+          reference_audio_urls: None,
+        },
+        output_resolution,
+        duration_seconds,
+        total_input_seconds: None,
+        use_face_blur_hack: None,
+      }
+    }
+
+    fn t2v_480(duration: u8) -> GenerateSeedance2p5Request {
+      text_to_video_request(duration, Some(KinoviSeedance2p5OutputResolution::FourEightyP))
+    }
+
+    fn t2v_720(duration: u8) -> GenerateSeedance2p5Request {
+      text_to_video_request(duration, None)
+    }
+
+    fn keyframe_request(duration: u8) -> GenerateSeedance2p5Request {
+      GenerateSeedance2p5Request {
+        prompt: String::new(),
+        modality: KinoviSeedance2p5Modality::Keyframe {
+          start_frame_url: "https://example.com/start.png".to_string(),
+          end_frame_url: Some("https://example.com/end.png".to_string()),
+        },
+        output_resolution: None,
+        duration_seconds: duration,
+        total_input_seconds: None,
+        use_face_blur_hack: None,
+      }
+    }
+
+    fn video_ref_480(duration: u8, total_input_seconds: Option<u8>) -> GenerateSeedance2p5Request {
+      let mut request = t2v_480(duration);
+      set_reference_urls(&mut request, None, Some(vec!["https://example.com/ref.mp4".to_string()]), None);
+      request.total_input_seconds = total_input_seconds;
+      request
+    }
+
+    fn video_ref_720(duration: u8, total_input_seconds: Option<u8>) -> GenerateSeedance2p5Request {
+      let mut request = t2v_720(duration);
+      set_reference_urls(&mut request, None, Some(vec!["https://example.com/ref.mp4".to_string()]), None);
+      request.total_input_seconds = total_input_seconds;
+      request
+    }
+
+    fn set_reference_urls(
+      request: &mut GenerateSeedance2p5Request,
+      images: Option<Vec<String>>,
+      videos: Option<Vec<String>>,
+      audio: Option<Vec<String>>,
+    ) {
+      let KinoviSeedance2p5Modality::Reference {
+        reference_image_urls,
+        reference_video_urls,
+        reference_audio_urls,
+        ..
+      } = &mut request.modality else {
+        panic!("set_reference_urls requires the Reference modality");
+      };
+      *reference_image_urls = images;
+      *reference_video_urls = videos;
+      *reference_audio_urls = audio;
+    }
+  }
+
+  mod raw_mapping_tests {
+    use super::*;
+
+    #[test]
+    fn keyframe_maps_frames_and_no_references() {
+      let raw = to_raw_request(GenerateSeedance2p5Request {
+        prompt: "Car drives into the sunset".to_string(),
+        modality: KinoviSeedance2p5Modality::Keyframe {
+          start_frame_url: "https://example.com/start.png".to_string(),
+          end_frame_url: Some("https://example.com/end.png".to_string()),
+        },
+        output_resolution: Some(KinoviSeedance2p5OutputResolution::FourEightyP),
+        duration_seconds: 8,
+        total_input_seconds: None,
+        use_face_blur_hack: None,
+      });
+
+      assert!(matches!(raw.model_type, KinoviModelTypeRaw::Seedance2p5));
+      assert_eq!(raw.start_frame_url.as_deref(), Some("https://example.com/start.png"));
+      assert_eq!(raw.end_frame_url.as_deref(), Some("https://example.com/end.png"));
+      assert!(raw.reference_image_urls.is_none());
+      assert!(raw.reference_video_urls.is_none());
+      assert!(raw.reference_audio_urls.is_none());
+    }
+
+    #[test]
+    fn reference_maps_references_and_no_frames() {
+      let raw = to_raw_request(GenerateSeedance2p5Request {
+        prompt: "The t-rex @image1 eats the banana".to_string(),
+        modality: KinoviSeedance2p5Modality::Reference {
+          aspect_ratio: Some(KinoviSeedance2p5AspectRatio::UltraWide21x9),
+          reference_image_urls: Some(vec!["https://example.com/a.png".to_string()]),
+          reference_video_urls: Some(vec!["https://example.com/ref.mp4".to_string()]),
+          reference_audio_urls: Some(vec!["https://example.com/ref.wav".to_string()]),
+        },
+        output_resolution: None,
+        duration_seconds: 8,
+        total_input_seconds: Some(7),
+        use_face_blur_hack: None,
+      });
+
+      assert!(matches!(raw.aspect_ratio, KinoviAspectRatioRaw::UltraWide21x9));
+      assert!(raw.start_frame_url.is_none());
+      assert!(raw.end_frame_url.is_none());
+      assert_eq!(raw.reference_image_urls.as_deref().map(|urls| urls.len()), Some(1));
+      assert_eq!(raw.reference_video_urls.as_deref().map(|urls| urls.len()), Some(1));
+      assert_eq!(raw.reference_audio_urls.as_deref().map(|urls| urls.len()), Some(1));
+    }
+
+    #[test]
+    fn reference_aspect_ratio_defaults_to_16x9() {
+      let raw = to_raw_request(GenerateSeedance2p5Request {
+        prompt: "Lightning hits a building".to_string(),
+        modality: KinoviSeedance2p5Modality::Reference {
+          aspect_ratio: None,
+          reference_image_urls: None,
+          reference_video_urls: None,
+          reference_audio_urls: None,
+        },
+        output_resolution: None,
+        duration_seconds: 5,
+        total_input_seconds: None,
+        use_face_blur_hack: None,
+      });
+
+      assert!(matches!(raw.aspect_ratio, KinoviAspectRatioRaw::Landscape16x9));
+    }
+  }
+
+  mod real_requests {
+    use super::*;
+
+    #[tokio::test]
+    #[ignore]
+    async fn test_text_to_video_480p() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedance_2p5(GenerateSeedance2p5Args {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedance2p5Request {
+          prompt: "Lightning hits a building".to_string(),
+          modality: KinoviSeedance2p5Modality::Reference {
+            aspect_ratio: Some(KinoviSeedance2p5AspectRatio::Landscape16x9),
+            reference_image_urls: None,
+            reference_video_urls: None,
+            reference_audio_urls: None,
+          },
+          output_resolution: Some(KinoviSeedance2p5OutputResolution::FourEightyP),
+          duration_seconds: 5,
+          total_input_seconds: None,
+          use_face_blur_hack: None,
+        },
+      }).await?;
+      println!("t2v 480p — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert!(!result.task_id.is_empty());
+      assert!(!result.order_id.is_empty());
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    #[tokio::test]
+    #[ignore]
+    async fn test_keyframe_to_video_adaptive_480p() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedance_2p5(GenerateSeedance2p5Args {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedance2p5Request {
+          prompt: "Car drives into the sunset".to_string(),
+          modality: KinoviSeedance2p5Modality::Keyframe {
+            start_frame_url: "https://static.seedance2-pro.com/materials/20260807/1786128486168-a2bf6132.png".to_string(),
+            end_frame_url: Some("https://static.seedance2-pro.com/materials/20260807/1786128493608-d708413a.png".to_string()),
+          },
+          output_resolution: Some(KinoviSeedance2p5OutputResolution::FourEightyP),
+          duration_seconds: 8,
+          total_input_seconds: None,
+          use_face_blur_hack: None,
+        },
+      }).await?;
+      println!("keyframe 480p — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert!(!result.task_id.is_empty());
+      assert!(!result.order_id.is_empty());
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    #[tokio::test]
+    #[ignore]
+    async fn test_reference_to_video_480p() -> AnyhowResult<()> {
+      setup_test_logging(LevelFilter::Trace);
+      let session = test_session()?;
+      let result = generate_seedance_2p5(GenerateSeedance2p5Args {
+        session: &session,
+        host_override: None,
+        request: GenerateSeedance2p5Request {
+          prompt: "The t-rex @image1 eats the banana @image2".to_string(),
+          modality: KinoviSeedance2p5Modality::Reference {
+            aspect_ratio: Some(KinoviSeedance2p5AspectRatio::UltraWide21x9),
+            reference_image_urls: Some(vec![
+              "https://static.seedance2-pro.com/materials/20260807/1786128628611-d6ca7afd.png".to_string(),
+              "https://static.seedance2-pro.com/materials/20260807/1786128638331-5395ff1c.jpg".to_string(),
+            ]),
+            reference_video_urls: None,
+            reference_audio_urls: None,
+          },
+          output_resolution: Some(KinoviSeedance2p5OutputResolution::FourEightyP),
+          duration_seconds: 8,
+          total_input_seconds: None,
+          use_face_blur_hack: None,
+        },
+      }).await?;
+      println!("reference 480p — task_id={}, order_id={}", result.task_id, result.order_id);
+      assert!(!result.task_id.is_empty());
+      assert!(!result.order_id.is_empty());
+      assert_eq!(1, 2, "Inspect output above");
+      Ok(())
+    }
+
+    fn test_session() -> AnyhowResult<KinoviWebSession> {
+      let cookies = get_test_cookies()?;
+      Ok(KinoviWebSession::from_cookies_string(cookies))
+    }
+  }
+}