From 84d683056cff338c9b0308251eed6cacafb46041 Mon Sep 17 00:00:00 2001 From: Hanashi Date: Fri, 31 Jul 2026 16:25:35 -0400 Subject: [PATCH] new model - seedance 2.5 --- .../video/generate_seedance_2p5_preview.rs | 438 ++++++++++++++++++ .../src/generate/video/mod.rs | 1 + .../workflow_run_task/request_types.rs | 11 + .../workflow_run_task/workflow_run_task.rs | 206 +++++++- 4 files changed, 647 insertions(+), 9 deletions(-) create mode 100644 crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p5_preview.rs diff --git a/crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p5_preview.rs b/crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p5_preview.rs new file mode 100644 index 0000000000..1d99cf5afa --- /dev/null +++ b/crates/api_clients/kinovi_web_client/src/generate/video/generate_seedance_2p5_preview.rs @@ -0,0 +1,438 @@ +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, +}; + +// ── Args ── + +pub struct GenerateSeedance2p5PreviewArgs<'a> { + pub request: GenerateSeedance2p5PreviewRequest, + pub session: &'a KinoviWebSession, + pub host_override: Option, +} + +// ── Request ── + +/// Seedance 2.5 Preview only supports reference mode (there is no keyframe +/// start/end frame mode), 480p/720p output, and durations of 4–30 seconds. +#[derive(Clone, Debug)] +pub struct GenerateSeedance2p5PreviewRequest { + pub prompt: String, + pub aspect_ratio: Option, + pub output_resolution: Option, + pub duration_seconds: u8, + /// Reference images, referenced in prompts as @image1, @image2, etc. + pub reference_image_urls: Option>, + /// Reference videos, referenced in prompts as @video1, @video2, etc. + pub reference_video_urls: Option>, + /// Reference audio, referenced in prompts as @audio1, @audio2, etc. + pub reference_audio_urls: Option>, + /// Controls `faceBlurMode`: true sends "on"; false or None sends "off" + /// (the model always sends the field, unlike older Seedance models). + pub use_face_blur_hack: Option, +} + +// ── Enums ── + +#[derive(Debug, Clone, Copy)] +pub enum KinoviSeedance2p5PreviewAspectRatio { + Landscape16x9, + UltraWide21x9, + Portrait9x16, + Square1x1, + Standard4x3, + Portrait3x4, +} + +/// Output resolution. 2.5 Preview supports only 480p and 720p. +#[derive(Debug, Clone, Copy)] +pub enum KinoviSeedance2p5PreviewOutputResolution { + FourEightyP, + SevenTwentyP, +} + +// ── Pricing ── +// +// Seedance 2.5 Preview credit pricing (per second of output duration): +// +// | Resolution | Credits/sec | +// |------------|-------------| +// | 480p | 46.81 | +// | 720p | 93.62 | +// +// References (images, videos, and audio) do NOT affect the cost — unlike the +// Seedance 2.0 models, there is no video-reference surcharge. Default +// resolution (None) is 720p. +// Credit package: 525,000 credits for $2,159.0909 (~243 credits/$1). + +impl GenerateSeedance2p5PreviewRequest { + /// Calculate the cost of this generation request, in Kinovi credits + /// (fractional) and USD cents. + /// + /// The math is done in integer hundredths of a credit so the totals land + /// exactly on the observed values (e.g. 480p × 15s = 702.15, not the + /// 702.150000000001 float artifact Kinovi's own UI shows). + pub fn calculate_costs(&self) -> KinoviFractionalGenerationCost { + let credits_per_second_hundredths: u64 = match self.output_resolution { + Some(KinoviSeedance2p5PreviewOutputResolution::FourEightyP) => 4_681, + Some(KinoviSeedance2p5PreviewOutputResolution::SevenTwentyP) | None => 9_362, + }; + + let total_hundredths = credits_per_second_hundredths * u64::from(self.duration_seconds); + KinoviFractionalGenerationCost::from_kinovi_credits(total_hundredths as f64 / 100.0) + } +} + +// ── Response ── + +pub struct GenerateSeedance2p5PreviewResponse { + pub task_id: String, + pub order_id: String, + pub task_ids: Option>, + pub order_ids: Option>, +} + +// ── Entry point ── + +pub async fn generate_seedance_2p5_preview( + args: GenerateSeedance2p5PreviewArgs<'_>, +) -> Result { + let raw_response = workflow_run_task(WorkflowRunTaskArgs { + request: to_raw_request(args.request), + session: args.session, + host_override: args.host_override, + }).await?; + + Ok(GenerateSeedance2p5PreviewResponse { + 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: GenerateSeedance2p5PreviewRequest) -> WorkflowRunTaskRequest { + WorkflowRunTaskRequest { + model_type: KinoviModelTypeRaw::Seedance2p5Preview, + prompt: req.prompt, + aspect_ratio: map_aspect_ratio(req.aspect_ratio), + output_resolution: req.output_resolution.map(map_output_resolution), + duration_seconds: req.duration_seconds, + batch_count: KinoviBatchCountRaw::One, + start_frame_url: None, + end_frame_url: None, + reference_image_urls: req.reference_image_urls, + reference_video_urls: req.reference_video_urls, + reference_audio_urls: req.reference_audio_urls, + character_ids: None, + use_face_blur_hack: req.use_face_blur_hack, + bitrate: None, + } +} + +fn map_aspect_ratio(ar: Option) -> KinoviAspectRatioRaw { + match ar { + Some(KinoviSeedance2p5PreviewAspectRatio::Landscape16x9) => KinoviAspectRatioRaw::Landscape16x9, + Some(KinoviSeedance2p5PreviewAspectRatio::UltraWide21x9) => KinoviAspectRatioRaw::UltraWide21x9, + Some(KinoviSeedance2p5PreviewAspectRatio::Portrait9x16) => KinoviAspectRatioRaw::Portrait9x16, + Some(KinoviSeedance2p5PreviewAspectRatio::Square1x1) => KinoviAspectRatioRaw::Square1x1, + Some(KinoviSeedance2p5PreviewAspectRatio::Standard4x3) => KinoviAspectRatioRaw::Landscape4x3, + Some(KinoviSeedance2p5PreviewAspectRatio::Portrait3x4) => KinoviAspectRatioRaw::Portrait3x4, + None => KinoviAspectRatioRaw::Landscape16x9, + } +} + +fn map_output_resolution(res: KinoviSeedance2p5PreviewOutputResolution) -> KinoviOutputResolutionRaw { + match res { + KinoviSeedance2p5PreviewOutputResolution::FourEightyP => KinoviOutputResolutionRaw::FourEightyP, + KinoviSeedance2p5PreviewOutputResolution::SevenTwentyP => 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; + + fn build_request( + duration_seconds: u8, + output_resolution: Option, + ) -> GenerateSeedance2p5PreviewRequest { + GenerateSeedance2p5PreviewRequest { + prompt: String::new(), + aspect_ratio: None, + output_resolution, + duration_seconds, + reference_image_urls: None, + reference_video_urls: None, + reference_audio_urls: None, + use_face_blur_hack: None, + } + } + + fn r480(dur: u8) -> GenerateSeedance2p5PreviewRequest { + build_request(dur, Some(KinoviSeedance2p5PreviewOutputResolution::FourEightyP)) + } + + fn r720(dur: u8) -> GenerateSeedance2p5PreviewRequest { + build_request(dur, None) + } + + fn with_all_reference_types(mut request: GenerateSeedance2p5PreviewRequest) -> GenerateSeedance2p5PreviewRequest { + request.reference_image_urls = Some(vec![ + "https://example.com/a.jpg".to_string(), + "https://example.com/b.png".to_string(), + ]); + request.reference_video_urls = Some(vec!["https://example.com/ref.mp4".to_string()]); + request.reference_audio_urls = Some(vec!["https://example.com/ref.wav".to_string()]); + request + } + + // ── Full pricing table (credits) ── + // + // The exact per-duration table observed from Kinovi for Seedance 2.5 + // Preview: 480p = 46.81 credits/sec, 720p = 93.62 credits/sec. + + mod kinovi_pricing_table { + use super::*; + + #[test] + fn table_480p() { + assert_eq!(r480(4).calculate_costs().kinovi_credits, 187.24); + assert_eq!(r480(10).calculate_costs().kinovi_credits, 468.1); + assert_eq!(r480(15).calculate_costs().kinovi_credits, 702.15); + assert_eq!(r480(20).calculate_costs().kinovi_credits, 936.2); + assert_eq!(r480(25).calculate_costs().kinovi_credits, 1170.25); + assert_eq!(r480(30).calculate_costs().kinovi_credits, 1404.3); + } + + #[test] + fn table_720p() { + assert_eq!(r720(4).calculate_costs().kinovi_credits, 374.48); + assert_eq!(r720(10).calculate_costs().kinovi_credits, 936.2); + assert_eq!(r720(15).calculate_costs().kinovi_credits, 1404.3); + assert_eq!(r720(20).calculate_costs().kinovi_credits, 1872.4); + assert_eq!(r720(25).calculate_costs().kinovi_credits, 2340.5); + assert_eq!(r720(30).calculate_costs().kinovi_credits, 2808.6); + } + + #[test] + fn explicit_720p_same_as_default() { + let default = r720(10).calculate_costs(); + let explicit = build_request(10, Some(KinoviSeedance2p5PreviewOutputResolution::SevenTwentyP)).calculate_costs(); + assert_eq!(default, explicit); + } + } + + // ── References don't affect cost ── + // + // Unlike the Seedance 2.0 models, 2.5 Preview has no video-reference + // surcharge: adding or removing references of any type leaves the cost + // unchanged. + + mod references_do_not_affect_cost { + use super::*; + + #[test] + fn table_480p_with_references_is_identical() { + for duration in [4u8, 10, 15, 20, 25, 30] { + assert_eq!( + with_all_reference_types(r480(duration)).calculate_costs(), + r480(duration).calculate_costs(), + "480p at {duration}s", + ); + } + } + + #[test] + fn table_720p_with_references_is_identical() { + for duration in [4u8, 10, 15, 20, 25, 30] { + assert_eq!( + with_all_reference_types(r720(duration)).calculate_costs(), + r720(duration).calculate_costs(), + "720p at {duration}s", + ); + } + } + + #[test] + fn video_reference_alone_adds_no_surcharge() { + let mut request = r720(10); + request.reference_video_urls = Some(vec!["https://example.com/ref.mp4".to_string()]); + assert_eq!(request.calculate_costs().kinovi_credits, 936.2); + } + } + + // ── USD cents conversion ── + // + // usd_cents = credits × 100 / 243, computed on integer hundredths. + + mod usd_cents { + use super::*; + + #[test] + fn cents_480p_4s() { + // 187.24 credits; 18724/243 = 77.0535 cents. + let cost = r480(4).calculate_costs(); + assert_eq!(cost.usd_cents_rounded_up, 78); + assert_eq!(cost.usd_cents_rounded_down, 77); + assert!((cost.usd_cents_fractional - (18724.0 / 243.0)).abs() < FLOAT_TOLERANCE); + } + + #[test] + fn cents_480p_15s() { + // 702.15 credits; 70215/243 = 288.9506 cents. + let cost = r480(15).calculate_costs(); + assert_eq!(cost.usd_cents_rounded_up, 289); + assert_eq!(cost.usd_cents_rounded_down, 288); + assert!((cost.usd_cents_fractional - (70215.0 / 243.0)).abs() < FLOAT_TOLERANCE); + } + + #[test] + fn cents_720p_4s() { + // 374.48 credits; 37448/243 = 154.1070 cents. + let cost = r720(4).calculate_costs(); + assert_eq!(cost.usd_cents_rounded_up, 155); + assert_eq!(cost.usd_cents_rounded_down, 154); + assert!((cost.usd_cents_fractional - (37448.0 / 243.0)).abs() < FLOAT_TOLERANCE); + } + + #[test] + fn cents_720p_30s() { + // 2808.6 credits; 280860/243 = 1155.8025 cents. + let cost = r720(30).calculate_costs(); + assert_eq!(cost.usd_cents_rounded_up, 1156); + assert_eq!(cost.usd_cents_rounded_down, 1155); + assert!((cost.usd_cents_fractional - (280860.0 / 243.0)).abs() < FLOAT_TOLERANCE); + } + } + + // ── Relative pricing ── + + mod relative_tests { + use super::*; + + #[test] + fn seven_twenty_is_exactly_double_480p() { + for duration in [4u8, 10, 15, 20, 25, 30] { + let c480 = r480(duration).calculate_costs().kinovi_credits; + let c720 = r720(duration).calculate_costs().kinovi_credits; + assert_eq!(c720, c480 * 2.0, "720p should be 2× 480p at {duration}s"); + } + } + + #[test] + fn cost_scales_linearly_with_duration() { + let per_second = r480(1).calculate_costs().kinovi_credits; + assert_eq!(per_second, 46.81); + for duration in [4u8, 10, 15, 20, 25, 30] { + let expected = (4_681 * u64::from(duration)) as f64 / 100.0; + assert_eq!(r480(duration).calculate_costs().kinovi_credits, expected); + } + } + } + + // ── Aspect ratio doesn't affect cost ── + + #[test] + fn aspect_ratio_does_not_affect_credits() { + let baseline = r720(10).calculate_costs().kinovi_credits; + + let ratios = [ + KinoviSeedance2p5PreviewAspectRatio::Landscape16x9, + KinoviSeedance2p5PreviewAspectRatio::UltraWide21x9, + KinoviSeedance2p5PreviewAspectRatio::Portrait9x16, + KinoviSeedance2p5PreviewAspectRatio::Square1x1, + KinoviSeedance2p5PreviewAspectRatio::Standard4x3, + KinoviSeedance2p5PreviewAspectRatio::Portrait3x4, + ]; + + for ar in &ratios { + let mut request = r720(10); + request.aspect_ratio = Some(*ar); + assert_eq!( + request.calculate_costs().kinovi_credits, baseline, + "Aspect ratio {:?} should not change credits from baseline {}", ar, baseline, + ); + } + } + } + + 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_preview(GenerateSeedance2p5PreviewArgs { + session: &session, + host_override: None, + request: GenerateSeedance2p5PreviewRequest { + prompt: "A man is running from a t-rex".to_string(), + aspect_ratio: Some(KinoviSeedance2p5PreviewAspectRatio::Landscape16x9), + output_resolution: Some(KinoviSeedance2p5PreviewOutputResolution::FourEightyP), + duration_seconds: 4, + reference_image_urls: None, + reference_video_urls: None, + reference_audio_urls: 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_text_to_video_720p_default() -> AnyhowResult<()> { + setup_test_logging(LevelFilter::Trace); + let session = test_session()?; + let result = generate_seedance_2p5_preview(GenerateSeedance2p5PreviewArgs { + session: &session, + host_override: None, + request: GenerateSeedance2p5PreviewRequest { + prompt: "A corgi and a shiba are playing chess against one another".to_string(), + aspect_ratio: None, + output_resolution: None, + duration_seconds: 4, + reference_image_urls: None, + reference_video_urls: None, + reference_audio_urls: None, + use_face_blur_hack: None, + }, + }).await?; + println!("t2v 720p — 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 { + let cookies = get_test_cookies()?; + Ok(KinoviWebSession::from_cookies_string(cookies)) + } + } +} diff --git a/crates/api_clients/kinovi_web_client/src/generate/video/mod.rs b/crates/api_clients/kinovi_web_client/src/generate/video/mod.rs index e4995a4fc4..8e8cce0ca1 100644 --- a/crates/api_clients/kinovi_web_client/src/generate/video/mod.rs +++ b/crates/api_clients/kinovi_web_client/src/generate/video/mod.rs @@ -2,3 +2,4 @@ pub mod generate_happy_horse_1p0; pub mod generate_seedance_2p0; pub mod generate_seedance_2p0_fast; pub mod generate_seedance_2p0_mini; +pub mod generate_seedance_2p5_preview; diff --git a/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/request_types.rs b/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/request_types.rs index 81c5777083..d75ec3f16e 100644 --- a/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/request_types.rs +++ b/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/request_types.rs @@ -49,6 +49,17 @@ pub (super) struct ApiParams { pub face_blur_mode: Option<&'static str>, #[serde(rename = "characterIds", skip_serializing_if = "Option::is_none")] pub character_ids: Option>, + /// Reference image URLs, for models that send references in split + /// `imageUrls` / `videoUrls` fields (Seedance 2.5 Preview). Those models + /// also mirror the image URLs into `uploadedUrls`. None for models that + /// send a single combined `uploadedUrls` list. + #[serde(rename = "imageUrls", skip_serializing_if = "Option::is_none")] + pub image_urls: Option>, + /// Reference video URLs, for models that send references in split + /// `imageUrls` / `videoUrls` fields (Seedance 2.5 Preview). None for + /// models that send videos in the combined `uploadedUrls` list. + #[serde(rename = "videoUrls", skip_serializing_if = "Option::is_none")] + pub video_urls: Option>, #[serde(rename = "uploadedUrls", skip_serializing_if = "Option::is_none")] pub uploaded_urls: Option>, #[serde(rename = "audioUrls", skip_serializing_if = "Option::is_none")] diff --git a/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/workflow_run_task.rs b/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/workflow_run_task.rs index 3d21ac3d3f..3b63540acb 100644 --- a/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/workflow_run_task.rs +++ b/crates/api_clients/kinovi_web_client/src/requests/workflow_run_task/workflow_run_task.rs @@ -164,6 +164,17 @@ impl KinoviOutputResolutionRaw { Self::FourK => Some("4k"), } } + + /// The API string including the "720p" default, for models that always + /// send `outputResolution` explicitly (Seedance 2.5 Preview). + pub fn as_explicit_api_str(&self) -> &'static str { + match self { + Self::FourEightyP => "480p", + Self::SevenTwentyP => "720p", + Self::TenEightyP => "1080p", + Self::FourK => "4k", + } + } } /// Number of videos to generate in a single request. @@ -203,6 +214,8 @@ pub enum KinoviModelTypeRaw { Seedance2Fast, /// Seedance 2.0 Mini (cheapest; 480p/720p only). Seedance2Mini, + /// Seedance 2.5 Preview (480p/720p only). + Seedance2p5Preview, /// Happy Horse 1.0. HappyHorse1p0, } @@ -213,24 +226,28 @@ impl KinoviModelTypeRaw { Self::Seedance2Pro => "seedance-20", Self::Seedance2Fast => "seedance2-fast", Self::Seedance2Mini => "seedance2.0-mini", + Self::Seedance2p5Preview => "seedance2-5-preview", Self::HappyHorse1p0 => "happyhorse1.0", } } - /// The tRPC `businessType` for this model. Seedance 2.0 Mini uses its - /// own business type; every other model uses the shared one. + /// The tRPC `businessType` for this model. Seedance 2.0 Mini and 2.5 + /// Preview use their own business types; every other model uses the + /// shared one. fn business_type(&self) -> &'static str { match self { Self::Seedance2Mini => "seedance20-mini-video-generation", + Self::Seedance2p5Preview => "seedance25-preview-video-generation", Self::HappyHorse1p0 => "happyhorse-video-generation", Self::Seedance2Pro | Self::Seedance2Fast => "wan22-video-generation", } } /// Whether the aspect ratio is sent in an `aspectRatio` field (true) - /// rather than the `resolution` field. Mini and Happy Horse use `aspectRatio`. + /// rather than the `resolution` field. Mini, 2.5 Preview, and Happy Horse + /// use `aspectRatio`. fn uses_aspect_ratio_field(&self) -> bool { - matches!(self, Self::Seedance2Mini | Self::HappyHorse1p0) + matches!(self, Self::Seedance2Mini | Self::Seedance2p5Preview | Self::HappyHorse1p0) } /// Whether this model uses Happy Horse's `happyhorseMode` (t2v/i2v) @@ -238,6 +255,27 @@ impl KinoviModelTypeRaw { fn uses_happyhorse_mode(&self) -> bool { matches!(self, Self::HappyHorse1p0) } + + /// Whether reference URLs are sent in split `imageUrls` / `videoUrls` + /// fields — with `uploadedUrls` mirroring just the images — rather than + /// one combined `uploadedUrls` list. Seedance 2.5 Preview uses the split + /// shape. + fn uses_split_reference_url_fields(&self) -> bool { + matches!(self, Self::Seedance2p5Preview) + } + + /// Whether `mode` is always "reference", even with no references attached. + /// Seedance 2.5 Preview has no keyframe mode. + fn always_uses_reference_mode(&self) -> bool { + matches!(self, Self::Seedance2p5Preview) + } + + /// Whether the default field values (`outputResolution: "720p"`, + /// `faceBlurMode: "off"`) are always sent explicitly rather than omitted. + /// Seedance 2.5 Preview always sends both. + fn always_sends_default_fields(&self) -> bool { + matches!(self, Self::Seedance2p5Preview) + } } /// Output video bitrate. When omitted, defaults to "standard". @@ -408,9 +446,21 @@ fn build_batch_request(req: WorkflowRunTaskRequest) -> BatchRequest { let is_reference_mode = has_reference_images || has_reference_videos || has_reference_audio || has_characters; - let video_input_mode = if is_reference_mode { "reference" } else { "keyframe" }; + let video_input_mode = if is_reference_mode || req.model_type.always_uses_reference_mode() { + "reference" + } else { + "keyframe" + }; - let uploaded_urls: Option> = if is_reference_mode { + // Reference URLs. Seedance 2.5 Preview sends split `imageUrls` / + // `videoUrls` fields with `uploadedUrls` mirroring just the images; other + // models combine videos + images into `uploadedUrls` in reference mode, or + // send the start/end frames there in keyframe mode. + let (image_urls, video_urls, uploaded_urls): (Option>, Option>, Option>) = if req.model_type.uses_split_reference_url_fields() { + let image_urls = req.reference_image_urls.filter(|urls| !urls.is_empty()); + let video_urls = req.reference_video_urls.filter(|urls| !urls.is_empty()); + (image_urls.clone(), video_urls, image_urls) + } else if is_reference_mode { let mut urls = Vec::new(); if let Some(video_urls) = req.reference_video_urls { urls.extend(video_urls); @@ -418,7 +468,7 @@ fn build_batch_request(req: WorkflowRunTaskRequest) -> BatchRequest { if let Some(image_urls) = req.reference_image_urls { urls.extend(image_urls); } - if urls.is_empty() { None } else { Some(urls) } + (None, None, if urls.is_empty() { None } else { Some(urls) }) } else { let mut urls = Vec::new(); if let Some(url) = req.start_frame_url { @@ -427,7 +477,7 @@ fn build_batch_request(req: WorkflowRunTaskRequest) -> BatchRequest { if let Some(url) = req.end_frame_url { urls.push(url); } - if urls.is_empty() { None } else { Some(urls) } + (None, None, if urls.is_empty() { None } else { Some(urls) }) }; let audio_urls: Option> = if has_reference_audio { @@ -439,9 +489,17 @@ fn build_batch_request(req: WorkflowRunTaskRequest) -> BatchRequest { let face_blur_mode = match req.use_face_blur_hack { Some(true) => Some("on"), Some(false) => Some("off"), + None if req.model_type.always_sends_default_fields() => Some("off"), None => None, }; + let output_resolution = if req.model_type.always_sends_default_fields() { + let resolution = req.output_resolution.unwrap_or(KinoviOutputResolutionRaw::SevenTwentyP); + Some(resolution.as_explicit_api_str()) + } else { + req.output_resolution.and_then(|r| r.as_api_str()) + }; + let batch_count_value = req.batch_count.as_u8(); let batch_count = if batch_count_value > 1 { Some(batch_count_value) } else { None }; @@ -483,9 +541,11 @@ fn build_batch_request(req: WorkflowRunTaskRequest) -> BatchRequest { duration, mode, happyhorse_mode, - output_resolution: req.output_resolution.and_then(|r| r.as_api_str()), + output_resolution, face_blur_mode, character_ids: req.character_ids, + image_urls, + video_urls, uploaded_urls, audio_urls, batch_count, @@ -545,6 +605,8 @@ mod tests { output_resolution: None, face_blur_mode: None, character_ids: None, + image_urls: None, + video_urls: None, uploaded_urls: None, audio_urls: None, batch_count: None, @@ -594,6 +656,8 @@ mod tests { output_resolution, face_blur_mode: None, character_ids: None, + image_urls: None, + video_urls: None, uploaded_urls: None, audio_urls: None, batch_count: None, @@ -705,6 +769,130 @@ mod tests { } } + // ── Seedance 2.5 Preview request shape ── + // + // 2.5 Preview differs from the other models on the wire: a + // `seedance25-preview-video-generation` businessType, a + // `seedance2-5-preview` model, an `aspectRatio` ratio string, `mode` always + // "reference" (even with no references), `outputResolution` and + // `faceBlurMode` always sent (including their "720p" / "off" defaults), and + // references split into `imageUrls` / `videoUrls` with `uploadedUrls` + // mirroring just the images. + + mod seedance_2p5_preview_shape_tests { + use super::*; + + fn preview_request( + output_resolution: Option, + reference_image_urls: Option>, + reference_video_urls: Option>, + reference_audio_urls: Option>, + ) -> WorkflowRunTaskRequest { + WorkflowRunTaskRequest { + model_type: KinoviModelTypeRaw::Seedance2p5Preview, + prompt: "A man is running from a t-rex".to_string(), + aspect_ratio: KinoviAspectRatioRaw::Landscape16x9, + output_resolution, + duration_seconds: 4, + batch_count: KinoviBatchCountRaw::One, + start_frame_url: None, + end_frame_url: None, + reference_image_urls, + reference_video_urls, + reference_audio_urls, + character_ids: None, + use_face_blur_hack: None, + bitrate: None, + } + } + + #[test] + fn text_to_video_matches_observed_request() { + // Mirrors external/requests/sites/kinovi.ai/2026-07-31-seedance2p5/1_seedance2p5.txt. + let body = build_batch_request(preview_request( + Some(KinoviOutputResolutionRaw::FourEightyP), None, None, None)); + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains(r#""businessType":"seedance25-preview-video-generation""#), "{json}"); + assert!(json.contains(r#""model":"seedance2-5-preview""#), "{json}"); + assert!(json.contains(r#""aspectRatio":"16:9""#), "{json}"); + assert!(json.contains(r#""duration":"4s""#), "{json}"); + assert!(json.contains(r#""outputResolution":"480p""#), "{json}"); + assert!(json.contains(r#""contentMode":"normal""#), "{json}"); + // 2.5 Preview does NOT send the ratio-string `resolution` field. + assert!(!json.contains(r#""resolution":"#), "{json}"); + // No references attached: no URL fields at all. + assert!(!json.contains("imageUrls"), "{json}"); + assert!(!json.contains("videoUrls"), "{json}"); + assert!(!json.contains("uploadedUrls"), "{json}"); + assert!(!json.contains("audioUrls"), "{json}"); + } + + #[test] + fn mode_is_reference_even_without_references() { + let body = build_batch_request(preview_request(None, None, None, None)); + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains(r#""mode":"reference""#), "{json}"); + assert!(!json.contains("keyframe"), "{json}"); + } + + #[test] + fn default_720p_and_face_blur_off_are_sent_explicitly() { + let body = build_batch_request(preview_request(None, None, None, None)); + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains(r#""outputResolution":"720p""#), "{json}"); + assert!(json.contains(r#""faceBlurMode":"off""#), "{json}"); + } + + #[test] + fn image_references_fill_image_urls_and_uploaded_urls() { + let images = vec![ + "https://static.seedance2-pro.com/materials/a.jpg".to_string(), + "https://static.seedance2-pro.com/materials/b.png".to_string(), + ]; + let body = build_batch_request(preview_request( + Some(KinoviOutputResolutionRaw::SevenTwentyP), Some(images), None, None)); + let json = serde_json::to_string(&body).unwrap(); + let expected_urls = r#"["https://static.seedance2-pro.com/materials/a.jpg","https://static.seedance2-pro.com/materials/b.png"]"#; + assert!(json.contains(&format!(r#""imageUrls":{expected_urls}"#)), "{json}"); + // `uploadedUrls` mirrors the images. + assert!(json.contains(&format!(r#""uploadedUrls":{expected_urls}"#)), "{json}"); + assert!(!json.contains("videoUrls"), "{json}"); + } + + #[test] + fn video_and_audio_references_use_their_own_fields() { + // Mirrors 3_seedance2p5_third.txt: images + video + audio. The video + // and audio URLs are NOT mirrored into `uploadedUrls`. + let body = build_batch_request(preview_request( + Some(KinoviOutputResolutionRaw::FourEightyP), + Some(vec!["https://static.seedance2-pro.com/materials/img.jpg".to_string()]), + Some(vec!["https://static.seedance2-pro.com/materials/dog.mp4".to_string()]), + Some(vec!["https://static.seedance2-pro.com/materials/bark.wav".to_string()]), + )); + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains(r#""imageUrls":["https://static.seedance2-pro.com/materials/img.jpg"]"#), "{json}"); + assert!(json.contains(r#""videoUrls":["https://static.seedance2-pro.com/materials/dog.mp4"]"#), "{json}"); + assert!(json.contains(r#""audioUrls":["https://static.seedance2-pro.com/materials/bark.wav"]"#), "{json}"); + assert!(json.contains(r#""uploadedUrls":["https://static.seedance2-pro.com/materials/img.jpg"]"#), "{json}"); + } + + #[test] + fn empty_reference_lists_send_no_url_fields() { + let body = build_batch_request(preview_request( + None, Some(vec![]), Some(vec![]), None)); + let json = serde_json::to_string(&body).unwrap(); + assert!(!json.contains("imageUrls"), "{json}"); + assert!(!json.contains("videoUrls"), "{json}"); + assert!(!json.contains("uploadedUrls"), "{json}"); + } + + #[test] + fn model_string_and_business_type() { + assert_eq!(KinoviModelTypeRaw::Seedance2p5Preview.as_api_str(), "seedance2-5-preview"); + assert_eq!(KinoviModelTypeRaw::Seedance2p5Preview.business_type(), "seedance25-preview-video-generation"); + } + } + // ── 2026-06-24 request-shape change ── // // The aspect ratio is now a ratio string ("16:9"). Seedance Pro/Fast keep it