From 062b23d3a0c0fb791ff83c7b7e93d2b528abfadc Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Wed, 15 Apr 2026 13:15:20 -0400 Subject: [PATCH] omni seedance 2 (#1372) --- .../config/seedance2-pro-job.development.env | 6 + .../video-thumbnail-job.development.env | 3 + .../config/storyteller-web.development.env | 4 +- .../src/configs/omni_gen/video_models.rs | 1 - .../generate/video/distill_video_request.rs | 45 +- .../generate/video/execute_generation.rs | 305 ++++++++++++ .../endpoints/omni_gen/generate/video/mod.rs | 1 + .../video/omni_gen_video_generate_handler.rs | 164 ++++--- .../generate/video/tests/kinovi/mod.rs | 1 + .../tests/kinovi/test_kinovi_seedance_2p0.rs | 459 ++++++++++++++++++ .../omni_gen/generate/video/tests/mod.rs | 1 + .../video/tests/test_seedance_1p5_pro.rs | 5 +- .../generate/video/tests/test_veo_2.rs | 5 +- .../generate/video/tests/test_veo_3.rs | 5 +- 14 files changed, 917 insertions(+), 88 deletions(-) create mode 100644 crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/execute_generation.rs create mode 100644 crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/mod.rs create mode 100644 crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/test_kinovi_seedance_2p0.rs diff --git a/crates/service/job/seedance2_pro_job/config/seedance2-pro-job.development.env b/crates/service/job/seedance2_pro_job/config/seedance2-pro-job.development.env index 19141cd55a..35443a25b6 100644 --- a/crates/service/job/seedance2_pro_job/config/seedance2-pro-job.development.env +++ b/crates/service/job/seedance2_pro_job/config/seedance2-pro-job.development.env @@ -9,3 +9,9 @@ ENABLE_PAGING=true # Doesn't make sense for jobs: # ENABLE_PAGING_FOR_500S=true +# We don't need to look back that far in development +MAX_JOB_AGE_THRESHOLD_HOURS=5 + +# Don't collide with storyteller-web in development +HTTP_BIND_ADDRESS=0.0.0.0:11223 + diff --git a/crates/service/job/video_thumbnail_job/config/video-thumbnail-job.development.env b/crates/service/job/video_thumbnail_job/config/video-thumbnail-job.development.env index 91b973c216..d57987709d 100644 --- a/crates/service/job/video_thumbnail_job/config/video-thumbnail-job.development.env +++ b/crates/service/job/video_thumbnail_job/config/video-thumbnail-job.development.env @@ -2,3 +2,6 @@ # Development SERVER_ENVIRONMENT='development' + +# Don't collide with storyteller-web in development +HTTP_BIND_ADDRESS=0.0.0.0:13333 diff --git a/crates/service/web/storyteller_web/config/storyteller-web.development.env b/crates/service/web/storyteller_web/config/storyteller-web.development.env index 784a3c34ca..7ac97ccd2f 100644 --- a/crates/service/web/storyteller_web/config/storyteller-web.development.env +++ b/crates/service/web/storyteller_web/config/storyteller-web.development.env @@ -9,8 +9,8 @@ COOKIE_DOMAIN=.jungle.horse WEBSITE_HOMEPAGE_REDIRECT=http://jungle.horse # Paging -ENABLE_PAGING=true -ENABLE_PAGING_FOR_500S=true +ENABLE_PAGING=false +ENABLE_PAGING_FOR_500S=false # Test the rate limiter bypass (obviously these are dummy values) AI_STREAMER_USERNAMES="PewDiePie,xQc" diff --git a/crates/service/web/storyteller_web/src/configs/omni_gen/video_models.rs b/crates/service/web/storyteller_web/src/configs/omni_gen/video_models.rs index d6a9750ebe..14464f10b4 100644 --- a/crates/service/web/storyteller_web/src/configs/omni_gen/video_models.rs +++ b/crates/service/web/storyteller_web/src/configs/omni_gen/video_models.rs @@ -48,7 +48,6 @@ fn build_omni_gen_video_models() -> Vec { }); models.push(OmniGenVideoModelDetails { - is_disabled: Some(true), // TODO: Temporarily disable model: CommonVideoModel::Seedance2p0, full_name: None, text_prompt_supported: Some(true), diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/distill_video_request.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/distill_video_request.rs index 286c7e5d91..932507badf 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/distill_video_request.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/distill_video_request.rs @@ -54,8 +54,11 @@ pub struct DistilledVideoRequest { /// Cost estimate as computed by the Artcraft provider — this is what we bill on. pub cost: VideoGenerationCostEstimate, - /// Execution plan as computed by the Fal provider — what we hand to the router. + /// Execution plan as computed by the execution provider — what we hand to the router. plan: VideoGenerationPlan<'static>, + + /// The provider used for execution (Fal, Seedance2Pro, etc.). + pub execution_provider: Provider, } impl DistilledVideoRequest { @@ -76,6 +79,7 @@ impl DistilledVideoRequest { pub fn distill_video_request( request: &OmniGenVideoCostAndGenerateRequest, media_file_hydration_map: Option<&HashMap>, + execution_provider: Provider, ) -> Result { // 1. Convert the raw API request into a router request. let initial = hydrate_to_router_request(request)?; @@ -109,9 +113,8 @@ pub fn distill_video_request( media_file_hydration_map, )?; - // 3. Build a `GenerateVideoRequest<'static>` whose borrows point into the - // owned boxes. SAFETY: same invariant as the image version — each box - // lives in `Self` for the full lifetime of `DistilledVideoRequest`. + // 3. Build static lifetime references for text fields. + // SAFETY: each box lives in `Self` for the full lifetime of `DistilledVideoRequest`. let prompt_static: Option<&'static str> = owned_prompt.as_deref().map(|s: &String| { let raw: *const str = s.as_str(); unsafe { &*raw } @@ -127,6 +130,23 @@ pub fn distill_video_request( unsafe { &*raw } }); + // 4. Cost estimate (Artcraft provider). + // `initial` already has media fields in token form (from hydrate_to_router_request), + // which is exactly what the Artcraft cost builder needs. Just swap the provider. + let cost: VideoGenerationCostEstimate = { + let cost_request = GenerateVideoRequest { + provider: Provider::Artcraft, + ..initial + }; + let cost_plan = cost_request.build().map_err(|e| { + warn!("Failed to build cost plan during video distillation: {}", e); + AdvancedCommonWebError::from_error(e) + })?; + cost_plan.estimate_costs() + }; + + // 5. Execution plan (execution provider). + // The execution plan uses URL-form media references (resolved from the hydration map). let start_frame_static: Option> = owned_start_frame_url.as_deref().map(|s: &String| { let raw: *const str = s.as_str(); @@ -155,7 +175,7 @@ pub fn distill_video_request( let request_static: GenerateVideoRequest<'static> = GenerateVideoRequest { model: initial.model, - provider: Provider::Fal, + provider: execution_provider, prompt: prompt_static, negative_prompt: negative_prompt_static, start_frame: start_frame_static, @@ -173,20 +193,6 @@ pub fn distill_video_request( idempotency_token: idempotency_static, }; - // 4. Cost estimate (Artcraft provider). - let cost_request = GenerateVideoRequest { - provider: Provider::Artcraft, - ..request_static - }; - let cost_plan = cost_request.build().map_err(|e| { - warn!("Failed to build cost plan during video distillation: {}", e); - AdvancedCommonWebError::from_error(e) - })?; - let cost: VideoGenerationCostEstimate = cost_plan.estimate_costs(); - drop(cost_plan); - drop(cost_request); - - // 5. Execution plan (Fal provider). let plan: VideoGenerationPlan<'static> = { let request_ref: &'static GenerateVideoRequest<'static> = unsafe { let raw: *const GenerateVideoRequest<'static> = &request_static; @@ -210,6 +216,7 @@ pub fn distill_video_request( request: request_static, cost, plan, + execution_provider, }) } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/execute_generation.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/execute_generation.rs new file mode 100644 index 0000000000..6343f5a2de --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/execute_generation.rs @@ -0,0 +1,305 @@ +//! Execution helpers for the omni-gen video generation handler. +//! +//! Routes generation to the appropriate provider (Fal or Seedance2Pro/Kinovi) +//! based on the distilled request's `execution_provider`. + +use std::collections::HashMap; + +use log::{info, warn}; +use url::Url; + +use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest; +use artcraft_router::api::provider::Provider; +use artcraft_router::generate::generate_video::generate_video_response::GenerateVideoResponse; +use enums::common::generation::common_generation_mode::CommonGenerationMode; +use seedance2pro_client::creds::seedance2pro_session::Seedance2ProSession; +use seedance2pro_client::requests::generate_video::generate_video::{ + generate_video, BatchCount, GenerateVideoArgs, ModelType, Resolution, +}; +use seedance2pro_client::requests::prepare_file_upload::prepare_file_upload::{ + prepare_file_upload, PrepareFileUploadArgs, +}; +use seedance2pro_client::requests::upload_file::upload_file::{upload_file, UploadFileArgs}; +use tokens::tokens::media_files::MediaFileToken; +use url_utils::extension::extract_extension_from_url::{ + extract_extension_from_url, ExtractExtensions, +}; + +use crate::http_server::common_responses::advanced_common_web_error::AdvancedCommonWebError; +use crate::state::server_state::ServerState; +use crate::util::http_download_url_to_bytes::http_download_url_to_bytes; + +use super::distill_video_request::DistilledVideoRequest; + +/// Result of a successful generation, regardless of provider. +pub struct GenerationResult { + /// The external job ID used to track the generation (first order_id for Seedance). + pub external_job_id: String, + + /// Whether this is a Seedance2Pro generation (changes DB insertion path). + pub is_seedance2pro: bool, + + /// For Seedance2Pro batch jobs, the list of all order IDs. + pub maybe_seedance_order_ids: Option>, + + /// The generation mode (Text, Keyframe, Reference). + pub generation_mode: CommonGenerationMode, +} + +/// Execute video generation via the appropriate provider. +pub async fn execute_generation( + distilled: &DistilledVideoRequest, + request: &OmniGenVideoCostAndGenerateRequest, + server_state: &ServerState, + media_file_hydration_map: Option<&HashMap>, +) -> Result { + match distilled.execution_provider { + Provider::Seedance2Pro => { + execute_generation_kinovi( + distilled, + request, + server_state, + media_file_hydration_map, + ).await + } + _ => { + execute_generation_fal( + distilled, + request, + server_state, + ).await + } + } +} + +/// Execute generation via Fal (the existing path). +async fn execute_generation_fal( + distilled: &DistilledVideoRequest, + request: &OmniGenVideoCostAndGenerateRequest, + server_state: &ServerState, +) -> Result { + let fal_client = artcraft_router::client::router_fal_client::RouterFalClient::new( + server_state.fal.api_key.clone(), + server_state.fal.webhook_url.clone(), + ); + let router_client = artcraft_router::client::router_client::RouterClient::Fal(fal_client); + + let generation_response = distilled.plan().generate_video(&router_client) + .await + .map_err(|e| { + warn!("Video generation failed (Fal): {:?}", e); + AdvancedCommonWebError::from_error(e) + })?; + + let external_job_id = match &generation_response { + GenerateVideoResponse::Artcraft(p) => p.inference_job_token.as_str().to_string(), + GenerateVideoResponse::Muapi(p) => p.request_id.as_str().to_string(), + GenerateVideoResponse::Seedance2Pro(p) => p.order_id.clone(), + GenerateVideoResponse::Fal(p) => p.request_id.clone().unwrap_or_default(), + }; + + let generation_mode = if request.start_frame_image_media_token.is_some() { + CommonGenerationMode::Keyframe + } else { + CommonGenerationMode::Text + }; + + Ok(GenerationResult { + external_job_id, + is_seedance2pro: false, + maybe_seedance_order_ids: None, + generation_mode, + }) +} + +/// Execute generation via Seedance2Pro/Kinovi. +/// +/// Downloads all referenced media from our CDN, re-uploads to Seedance2Pro's +/// CDN, then calls the Seedance2Pro generate endpoint. +async fn execute_generation_kinovi( + distilled: &DistilledVideoRequest, + request: &OmniGenVideoCostAndGenerateRequest, + server_state: &ServerState, + media_file_hydration_map: Option<&HashMap>, +) -> Result { + let session = Seedance2ProSession::from_cookies_string( + server_state.seedance2pro.cookies.clone() + ); + + let empty_map = HashMap::new(); + let hydration_map = media_file_hydration_map.unwrap_or(&empty_map); + + // Upload each media reference to Seedance2Pro CDN. + let start_frame_url = upload_token_to_seedance2pro( + &session, hydration_map, request.start_frame_image_media_token.as_ref(), + ).await?; + + let end_frame_url = upload_token_to_seedance2pro( + &session, hydration_map, request.end_frame_image_media_token.as_ref(), + ).await?; + + let reference_image_urls = upload_tokens_to_seedance2pro( + &session, hydration_map, request.reference_image_media_tokens.as_deref(), + ).await?; + + let reference_video_urls = upload_tokens_to_seedance2pro( + &session, hydration_map, request.reference_video_media_tokens.as_deref(), + ).await?; + + let reference_audio_urls = upload_tokens_to_seedance2pro( + &session, hydration_map, request.reference_audio_media_tokens.as_deref(), + ).await?; + + // Determine generation mode. + let is_keyframe = request.start_frame_image_media_token.is_some() + || request.end_frame_image_media_token.is_some(); + let is_reference = request.reference_image_media_tokens.as_ref().map_or(false, |t| !t.is_empty()) + || request.reference_video_media_tokens.as_ref().map_or(false, |t| !t.is_empty()) + || request.reference_audio_media_tokens.as_ref().map_or(false, |t| !t.is_empty()); + + let generation_mode = if is_keyframe { + CommonGenerationMode::Keyframe + } else if is_reference { + CommonGenerationMode::Reference + } else { + CommonGenerationMode::Text + }; + + // Map aspect ratio / duration / batch from the request. + let resolution = Resolution::Landscape16x9; // TODO: Map from request.aspect_ratio + let duration_seconds = request.duration_seconds.unwrap_or(5).clamp(4, 15) as u8; + let batch_count = match request.video_batch_count { + Some(2) => BatchCount::Two, + Some(4) => BatchCount::Four, + _ => BatchCount::One, + }; + + let prompt = request.prompt.clone().unwrap_or_default(); + + let video_gen_args = GenerateVideoArgs { + session: &session, + model_type: ModelType::Seedance2Pro, + prompt, + resolution, + duration_seconds, + batch_count, + start_frame_url, + end_frame_url, + reference_image_urls, + reference_video_urls, + reference_audio_urls, + character_ids: None, // TODO: resolve_kinovi_character_ids when character support is added + use_face_blur_hack: None, + host_override: None, + }; + + let gen_response = generate_video(video_gen_args).await + .map_err(|err| { + warn!("Seedance2Pro generate_video failed: {:?}", err); + AdvancedCommonWebError::from_error(err) + })?; + + info!( + "Seedance2Pro generation: task_id={}, order_id={}", + gen_response.task_id, gen_response.order_id + ); + + let order_ids: Vec = match gen_response.order_ids { + Some(ids) if !ids.is_empty() => ids, + _ => vec![gen_response.order_id.clone()], + }; + + Ok(GenerationResult { + external_job_id: gen_response.order_id, + is_seedance2pro: true, + maybe_seedance_order_ids: Some(order_ids), + generation_mode, + }) +} + +// --- Upload helpers --- + +/// Upload a single media token (if present) to Seedance2Pro CDN. +async fn upload_token_to_seedance2pro( + session: &Seedance2ProSession, + hydration_map: &HashMap, + maybe_token: Option<&MediaFileToken>, +) -> Result, AdvancedCommonWebError> { + let token = match maybe_token { + None => return Ok(None), + Some(t) => t, + }; + + let url = hydration_map.get(token).ok_or_else(|| { + AdvancedCommonWebError::BadInputWithSimpleMessage( + format!("Media token not found in hydration map: {:?}", token)) + })?; + + let uploaded = upload_url_to_seedance2pro(session, url).await?; + Ok(Some(uploaded)) +} + +/// Upload a list of media tokens (if present) to Seedance2Pro CDN. +async fn upload_tokens_to_seedance2pro( + session: &Seedance2ProSession, + hydration_map: &HashMap, + maybe_tokens: Option<&[MediaFileToken]>, +) -> Result>, AdvancedCommonWebError> { + let tokens = match maybe_tokens { + None => return Ok(None), + Some(tokens) if tokens.is_empty() => return Ok(None), + Some(tokens) => tokens, + }; + + let mut urls = Vec::with_capacity(tokens.len()); + for token in tokens { + let url = hydration_map.get(token).ok_or_else(|| { + AdvancedCommonWebError::BadInputWithSimpleMessage( + format!("Media token not found in hydration map: {:?}", token)) + })?; + urls.push(upload_url_to_seedance2pro(session, url).await?); + } + Ok(Some(urls)) +} + +/// Download from our CDN and re-upload to Seedance2Pro. +async fn upload_url_to_seedance2pro( + session: &Seedance2ProSession, + our_cdn_url: &Url, +) -> Result { + let extension = extract_extension_from_url(our_cdn_url, &ExtractExtensions::All) + .map(|ext| ext.without_period().to_string()) + .unwrap_or_else(|| "png".to_string()); + + let file_bytes = http_download_url_to_bytes(our_cdn_url.as_str()) + .await + .map_err(|err| { + warn!("Error downloading media from CDN for Seedance2Pro upload: {:?}", err); + AdvancedCommonWebError::from_error(err) + })? + .to_vec(); + + let prepare_result = prepare_file_upload(PrepareFileUploadArgs { + session, + extension, + host_override: None, + }) + .await + .map_err(|err| { + warn!("Error preparing seedance2pro file upload: {:?}", err); + AdvancedCommonWebError::from_error(err) + })?; + + let upload_result = upload_file(UploadFileArgs { + upload_url: prepare_result.upload_url, + file_bytes, + host_override: None, + }) + .await + .map_err(|err| { + warn!("Error uploading file to seedance2pro: {:?}", err); + AdvancedCommonWebError::from_error(err) + })?; + + Ok(upload_result.public_url) +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/mod.rs index d2f1c337d2..5511c5297c 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/mod.rs @@ -1,6 +1,7 @@ pub mod omni_gen_video_generate_handler; pub mod distill_video_request; pub(crate) mod distill_helper; +mod execute_generation; #[cfg(test)] mod tests; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/omni_gen_video_generate_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/omni_gen_video_generate_handler.rs index 11a445e236..f859303072 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/omni_gen_video_generate_handler.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/omni_gen_video_generate_handler.rs @@ -9,9 +9,10 @@ use url::Url; use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest; use artcraft_api_defs::omni_gen::generate_response::omni_gen_video_generate_response::OmniGenVideoGenerateResponse; +use artcraft_router::api::provider::Provider; +use enums::common::generation::common_video_model::CommonVideoModel; use enums::by_table::prompt_context_items::prompt_context_semantic_type::PromptContextSemanticType; use enums::by_table::prompts::prompt_type::PromptType; -use enums::common::generation::common_generation_mode::CommonGenerationMode; use enums::common::generation::common_model_type::CommonModelType; use enums::common::generation_provider::GenerationProvider; use enums::common::visibility::Visibility; @@ -21,6 +22,10 @@ use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job insert_generic_inference_job_for_fal_queue_with_apriori_job_token, InsertGenericInferenceForFalWithAprioriJobTokenArgs, }; +use mysql_queries::queries::generic_inference::seedance2pro::insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token::{ + insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token, + InsertGenericInferenceForSeedance2ProWithAprioriJobTokenArgs, +}; use mysql_queries::queries::idepotency_tokens::insert_idempotency_token::insert_idempotency_token; use mysql_queries::queries::prompt_context_items::insert_batch_prompt_context_items::{ insert_batch_prompt_context_items, InsertBatchArgs, PromptContextItem, @@ -37,6 +42,7 @@ use crate::state::server_state::ServerState; use crate::util::lookup::lookup_image_urls_as_map::lookup_image_urls_as_map; use super::distill_video_request::distill_video_request; +use super::execute_generation::execute_generation; /// Generate a video using the omni-gen unified endpoint. #[utoipa::path( @@ -149,12 +155,20 @@ pub async fn omni_gen_video_generate_handler( } }; + // ==================== DETERMINE PROVIDER ==================== // + + let execution_provider = match request.model { + Some(CommonVideoModel::Seedance2p0) => Provider::Seedance2Pro, + _ => Provider::Fal, + }; + // ==================== DISTILL ==================== // - let distilled = distill_video_request(&request, media_file_hydration_map.as_ref())?; + let distilled = distill_video_request(&request, media_file_hydration_map.as_ref(), execution_provider)?; info!(">>> Distilled cost: {:?}", distilled.cost); info!(">>> Distilled plan: {:?}", distilled.plan()); + info!(">>> Execution provider: {:?}", distilled.execution_provider); // ==================== BILLING ==================== // @@ -175,33 +189,12 @@ pub async fn omni_gen_video_generate_handler( // ==================== EXECUTE GENERATION ==================== // - let fal_client = artcraft_router::client::router_fal_client::RouterFalClient::new( - server_state.fal.api_key.clone(), - server_state.fal.webhook_url.clone(), - ); - let router_client = artcraft_router::client::router_client::RouterClient::Fal(fal_client); - - let generation_response = distilled.plan().generate_video(&router_client) - .await - .map_err(|e| { - warn!("Video generation failed: {:?}", e); - AdvancedCommonWebError::from_error(e) - })?; - - let external_job_id = match &generation_response { - artcraft_router::generate::generate_video::generate_video_response::GenerateVideoResponse::Artcraft(p) => { - p.inference_job_token.as_str().to_string() - } - artcraft_router::generate::generate_video::generate_video_response::GenerateVideoResponse::Muapi(p) => { - p.request_id.as_str().to_string() - } - artcraft_router::generate::generate_video::generate_video_response::GenerateVideoResponse::Seedance2Pro(p) => { - p.order_id.clone() - } - artcraft_router::generate::generate_video::generate_video_response::GenerateVideoResponse::Fal(p) => { - p.request_id.clone().unwrap_or_default() - } - }; + let gen_result = execute_generation( + &distilled, + &request, + &server_state, + media_file_hydration_map.as_ref(), + ).await?; // ==================== DB TRANSACTION ==================== // @@ -217,12 +210,6 @@ pub async fn omni_gen_video_generate_handler( // -- Prompt -- - let generation_mode = if request.start_frame_image_media_token.is_some() { - CommonGenerationMode::Keyframe - } else { - CommonGenerationMode::Text - }; - let prompt_result = insert_prompt(InsertPromptArgs { maybe_apriori_prompt_token: None, prompt_type: PromptType::ArtcraftApp, @@ -232,7 +219,7 @@ pub async fn omni_gen_video_generate_handler( maybe_positive_prompt: request.prompt.as_deref(), maybe_negative_prompt: request.negative_prompt.as_deref(), maybe_other_args: None, - maybe_generation_mode: Some(generation_mode), + maybe_generation_mode: Some(gen_result.generation_mode), maybe_aspect_ratio: None, maybe_resolution: None, maybe_batch_count: request.video_batch_count.map(|c| c as u8), @@ -301,31 +288,88 @@ pub async fn omni_gen_video_generate_handler( // -- Inference job -- - let db_result = insert_generic_inference_job_for_fal_queue_with_apriori_job_token( - InsertGenericInferenceForFalWithAprioriJobTokenArgs { - apriori_job_token: &apriori_job_token, - uuid_idempotency_token: &idempotency_token, - maybe_external_third_party_id: &external_job_id, - fal_category: FalCategory::VideoGeneration, - maybe_inference_args: None, - maybe_prompt_token: prompt_token.as_ref(), - maybe_creator_user_token: Some(user_token), - maybe_avt_token: maybe_avt_token.as_ref(), - creator_ip_address: &ip_address, - creator_set_visibility: Visibility::Public, - mysql_executor: &mut *transaction, - starting_job_status_override: None, - maybe_frontend_failure_category: None, - maybe_failure_reason: None, - phantom: Default::default(), - } - ).await; + let job_token = if gen_result.is_seedance2pro { + // Seedance2Pro path: insert one job per order_id (batch support). + let fallback_ids = vec![gen_result.external_job_id.clone()]; + let order_ids = gen_result.maybe_seedance_order_ids + .as_deref() + .unwrap_or(&fallback_ids); - let job_token = match db_result { - Ok(token) => token, - Err(err) => { - warn!("Error inserting inference job: {:?}", err); - return Err(AdvancedCommonWebError::from_error(err)); + let mut all_job_tokens: Vec = Vec::with_capacity(order_ids.len()); + + for (i, order_id) in order_ids.iter().enumerate() { + let job_token = if i == 0 { + apriori_job_token.clone() + } else { + InferenceJobToken::generate() + }; + + let idempotency_str = if i == 0 { + idempotency_token.clone() + } else { + format!("{}-batch-{}", idempotency_token, i) + }; + + let db_result = insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token( + InsertGenericInferenceForSeedance2ProWithAprioriJobTokenArgs { + apriori_job_token: &job_token, + uuid_idempotency_token: &idempotency_str, + maybe_external_third_party_id: order_id, + maybe_inference_args: None, + maybe_prompt_token: prompt_token.as_ref(), + maybe_wallet_ledger_entry_token: None, + maybe_creator_user_token: Some(user_token), + maybe_avt_token: maybe_avt_token.as_ref(), + creator_ip_address: &ip_address, + creator_set_visibility: Visibility::Public, + mysql_executor: &mut *transaction, + phantom: Default::default(), + } + ).await; + + match db_result { + Ok(token) => all_job_tokens.push(token), + Err(err) => { + warn!("Error inserting seedance2pro inference job (order_id={}): {:?}", order_id, err); + if i == 0 { + return Err(AdvancedCommonWebError::from_error(err)); + } + } + } + } + + all_job_tokens.first().cloned().ok_or_else(|| { + error!("No inference job token was created"); + AdvancedCommonWebError::server_error_with_message("No inference job token was created") + })? + } else { + // Fal / other providers path. + let db_result = insert_generic_inference_job_for_fal_queue_with_apriori_job_token( + InsertGenericInferenceForFalWithAprioriJobTokenArgs { + apriori_job_token: &apriori_job_token, + uuid_idempotency_token: &idempotency_token, + maybe_external_third_party_id: &gen_result.external_job_id, + fal_category: FalCategory::VideoGeneration, + maybe_inference_args: None, + maybe_prompt_token: prompt_token.as_ref(), + maybe_creator_user_token: Some(user_token), + maybe_avt_token: maybe_avt_token.as_ref(), + creator_ip_address: &ip_address, + creator_set_visibility: Visibility::Public, + mysql_executor: &mut *transaction, + starting_job_status_override: None, + maybe_frontend_failure_category: None, + maybe_failure_reason: None, + phantom: Default::default(), + } + ).await; + + match db_result { + Ok(token) => token, + Err(err) => { + warn!("Error inserting inference job: {:?}", err); + return Err(AdvancedCommonWebError::from_error(err)); + } } }; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/mod.rs new file mode 100644 index 0000000000..56c79b849b --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/mod.rs @@ -0,0 +1 @@ +mod test_kinovi_seedance_2p0; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/test_kinovi_seedance_2p0.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/test_kinovi_seedance_2p0.rs new file mode 100644 index 0000000000..840073193d --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/kinovi/test_kinovi_seedance_2p0.rs @@ -0,0 +1,459 @@ +//! Tests for omni-gen video against the Seedance 2.0 model (Kinovi/Seedance2Pro provider). +//! +//! Seedance 2.0 is special: it uses the Seedance2Pro/Kinovi provider for execution +//! instead of Fal. The cost estimation uses Artcraft provider with media-token-form +//! references, while the execution plan uses URL-form references. +//! +//! Pricing: 16¢ per second × batch count. +//! - 4s/batch 1 = 64¢, 5s/batch 1 = 80¢, 15s/batch 1 = 240¢ +//! - Batch 2 = 2×, Batch 4 = 4× + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + + use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest; + use artcraft_router::api::provider::Provider; + use artcraft_router::generate::generate_video::video_generation_plan::VideoGenerationPlan; + use enums::common::generation::common_aspect_ratio::CommonAspectRatio; + use enums::common::generation::common_video_model::CommonVideoModel; + use tokens::tokens::media_files::MediaFileToken; + use url::Url; + + use crate::http_server::endpoints::omni_gen::generate::video::distill_video_request::{ + distill_video_request, DistilledVideoRequest, + }; + + // ── Helpers ──────────────────────────────────────────────────────────────── + + fn make_request( + prompt: Option<&str>, + aspect_ratio: Option, + duration_seconds: Option, + video_batch_count: Option, + start_frame_token: Option, + end_frame_token: Option, + reference_image_tokens: Option>, + reference_video_tokens: Option>, + reference_audio_tokens: Option>, + ) -> OmniGenVideoCostAndGenerateRequest { + OmniGenVideoCostAndGenerateRequest { + idempotency_token: Some("11111111-1111-1111-1111-111111111111".to_string()), + model: Some(CommonVideoModel::Seedance2p0), + prompt: prompt.map(|s| s.to_string()), + negative_prompt: None, + start_frame_image_media_token: start_frame_token, + end_frame_image_media_token: end_frame_token, + reference_image_media_tokens: reference_image_tokens, + reference_video_media_tokens: reference_video_tokens, + reference_audio_media_tokens: reference_audio_tokens, + reference_character_tokens: None, + resolution: None, + aspect_ratio, + quality: None, + duration_seconds, + video_batch_count, + generate_audio: None, + } + } + + fn text_only_request( + duration_seconds: Option, + video_batch_count: Option, + ) -> OmniGenVideoCostAndGenerateRequest { + make_request( + Some("a cat dancing"), + None, + duration_seconds, + video_batch_count, + None, None, None, None, None, + ) + } + + fn fake_token(name: &str) -> MediaFileToken { + MediaFileToken::new_from_str(name) + } + + fn build_hydration_map(tokens: &[&MediaFileToken]) -> HashMap { + tokens.iter().enumerate().map(|(i, t)| { + let url = Url::parse(&format!("https://cdn.example.com/media/{}.png", i)).unwrap(); + ((*t).clone(), url) + }).collect() + } + + fn distill_text(request: &OmniGenVideoCostAndGenerateRequest) -> DistilledVideoRequest { + let empty: HashMap = HashMap::new(); + distill_video_request(request, Some(&empty), Provider::Seedance2Pro) + .expect("distill should succeed for Seedance 2.0 (text)") + } + + fn distill_with_map( + request: &OmniGenVideoCostAndGenerateRequest, + hydration: &HashMap, + ) -> DistilledVideoRequest { + distill_video_request(request, Some(hydration), Provider::Seedance2Pro) + .expect("distill should succeed for Seedance 2.0 (with media)") + } + + // ═══════════════════════════════════════════════════════════════════════════ + // COST TESTS + // ═══════════════════════════════════════════════════════════════════════════ + + mod cost_tests { + use super::*; + + #[test] + fn cost_is_present() { + let d = distill_text(&text_only_request(Some(5), None)); + assert!(d.cost.cost_in_credits.is_some()); + assert!(d.cost.cost_in_usd_cents.is_some()); + } + + #[test] + fn cost_is_not_free() { + let d = distill_text(&text_only_request(Some(5), None)); + assert!(!d.cost.is_free); + } + + // Pricing: 16¢/sec × batch_count + + #[test] + fn cost_4s_batch_1() { + let d = distill_text(&text_only_request(Some(4), Some(1))); + assert_eq!(d.cost.cost_in_usd_cents, Some(64)); + } + + #[test] + fn cost_5s_batch_1() { + let d = distill_text(&text_only_request(Some(5), Some(1))); + assert_eq!(d.cost.cost_in_usd_cents, Some(80)); + } + + #[test] + fn cost_6s_batch_1() { + let d = distill_text(&text_only_request(Some(6), Some(1))); + assert_eq!(d.cost.cost_in_usd_cents, Some(96)); + } + + #[test] + fn cost_10s_batch_1() { + let d = distill_text(&text_only_request(Some(10), Some(1))); + assert_eq!(d.cost.cost_in_usd_cents, Some(160)); + } + + #[test] + fn cost_15s_batch_1() { + let d = distill_text(&text_only_request(Some(15), Some(1))); + assert_eq!(d.cost.cost_in_usd_cents, Some(240)); + } + + #[test] + fn cost_5s_batch_2() { + let d = distill_text(&text_only_request(Some(5), Some(2))); + assert_eq!(d.cost.cost_in_usd_cents, Some(160)); + } + + #[test] + fn cost_5s_batch_4() { + let d = distill_text(&text_only_request(Some(5), Some(4))); + assert_eq!(d.cost.cost_in_usd_cents, Some(320)); + } + + #[test] + fn cost_15s_batch_4() { + let d = distill_text(&text_only_request(Some(15), Some(4))); + assert_eq!(d.cost.cost_in_usd_cents, Some(960)); + } + + #[test] + fn cost_same_with_or_without_start_frame() { + // Cost should not change based on media presence — it's duration × batch. + let text_d = distill_text(&text_only_request(Some(5), Some(1))); + + let start_token = fake_token("start_frame"); + let map = build_hydration_map(&[&start_token]); + let req = make_request( + Some("a cat"), None, Some(5), Some(1), + Some(start_token), None, None, None, None, + ); + let frame_d = distill_with_map(&req, &map); + + assert_eq!(text_d.cost.cost_in_usd_cents, frame_d.cost.cost_in_usd_cents); + } + + #[test] + fn cost_estimation_uses_media_tokens_not_urls() { + // The Artcraft cost plan should use token-form references. + // If it used URLs, the Artcraft plan builder would reject them. + // This test passes if distillation succeeds at all — the Artcraft + // builder would error out on URL-form refs. + let start_token = fake_token("start_frame"); + let ref_img = fake_token("ref_img_1"); + let ref_vid = fake_token("ref_vid_1"); + let ref_aud = fake_token("ref_aud_1"); + + let map = build_hydration_map(&[&start_token, &ref_img, &ref_vid, &ref_aud]); + + let req = make_request( + Some("test"), None, Some(5), Some(1), + Some(start_token), None, + Some(vec![ref_img]), + Some(vec![ref_vid]), + Some(vec![ref_aud]), + ); + + // If this succeeds, the Artcraft cost path handled tokens correctly. + let d = distill_with_map(&req, &map); + assert!(d.cost.cost_in_credits.is_some()); + } + + #[test] + fn default_duration_produces_valid_cost() { + // When duration_seconds is None, the model should use a default. + let d = distill_text(&text_only_request(None, None)); + assert!(d.cost.cost_in_usd_cents.unwrap_or(0) > 0); + } + } + + // ═══════════════════════════════════════════════════════════════════════════ + // GENERATION PLAN TESTS + // ═══════════════════════════════════════════════════════════════════════════ + + mod generation_plan_tests { + use super::*; + + #[test] + fn provider_is_seedance2pro() { + let d = distill_text(&text_only_request(Some(5), None)); + assert!( + matches!(d.execution_provider, Provider::Seedance2Pro), + "expected Seedance2Pro provider, got {:?}", d.execution_provider + ); + } + + #[test] + fn plan_is_seedance2pro_variant() { + let d = distill_text(&text_only_request(Some(5), None)); + assert!( + matches!(d.plan(), VideoGenerationPlan::Seedance2proSeedance2p0(_)), + "expected Seedance2proSeedance2p0 plan variant, got {:?}", d.plan() + ); + } + + #[test] + fn text_only_has_no_media_urls() { + let d = distill_text(&text_only_request(Some(5), None)); + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert!(plan.start_frame_url.is_none()); + assert!(plan.end_frame_url.is_none()); + assert!(plan.reference_image_urls.is_none()); + assert!(plan.reference_video_urls.is_none()); + assert!(plan.reference_audio_urls.is_none()); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn text_only_prompt_is_passed_through() { + let d = distill_text(&text_only_request(Some(5), None)); + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert_eq!(plan.prompt.as_deref(), Some("a cat dancing")); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn start_frame_uses_url_not_token() { + let start_token = fake_token("start_frame"); + let map = build_hydration_map(&[&start_token]); + + let req = make_request( + Some("test"), None, Some(5), None, + Some(start_token), None, None, None, None, + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + let url = plan.start_frame_url.as_ref().expect("start_frame_url should be set"); + assert!(url.starts_with("https://"), "expected URL, got: {}", url); + assert!(!url.contains("m_"), "URL should not look like a media token"); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn end_frame_uses_url_not_token() { + let end_token = fake_token("end_frame"); + let map = build_hydration_map(&[&end_token]); + + let req = make_request( + Some("test"), None, Some(5), None, + None, Some(end_token), None, None, None, + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + let url = plan.end_frame_url.as_ref().expect("end_frame_url should be set"); + assert!(url.starts_with("https://"), "expected URL, got: {}", url); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn start_and_end_frame_both_resolved() { + let start = fake_token("sf"); + let end = fake_token("ef"); + let map = build_hydration_map(&[&start, &end]); + + let req = make_request( + Some("test"), None, Some(5), None, + Some(start), Some(end), None, None, None, + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert!(plan.start_frame_url.is_some()); + assert!(plan.end_frame_url.is_some()); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn reference_images_use_urls() { + let img1 = fake_token("img1"); + let img2 = fake_token("img2"); + let map = build_hydration_map(&[&img1, &img2]); + + let req = make_request( + Some("test"), None, Some(5), None, + None, None, + Some(vec![img1, img2]), + None, None, + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + let urls = plan.reference_image_urls.as_ref().expect("reference_image_urls should be set"); + assert_eq!(urls.len(), 2); + for url in urls { + assert!(url.starts_with("https://"), "expected URL, got: {}", url); + } + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn reference_videos_use_urls() { + let vid1 = fake_token("vid1"); + let map = build_hydration_map(&[&vid1]); + + let req = make_request( + Some("test"), None, Some(5), None, + None, None, None, + Some(vec![vid1]), + None, + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + let urls = plan.reference_video_urls.as_ref().expect("reference_video_urls should be set"); + assert_eq!(urls.len(), 1); + assert!(urls[0].starts_with("https://")); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn reference_audio_use_urls() { + let aud1 = fake_token("aud1"); + let map = build_hydration_map(&[&aud1]); + + let req = make_request( + Some("test"), None, Some(5), None, + None, None, None, None, + Some(vec![aud1]), + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + let urls = plan.reference_audio_urls.as_ref().expect("reference_audio_urls should be set"); + assert_eq!(urls.len(), 1); + assert!(urls[0].starts_with("https://")); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn all_reference_types_together() { + let sf = fake_token("sf"); + let ef = fake_token("ef"); + let img = fake_token("img"); + let vid = fake_token("vid"); + let aud = fake_token("aud"); + let map = build_hydration_map(&[&sf, &ef, &img, &vid, &aud]); + + let req = make_request( + Some("full test"), None, Some(8), Some(2), + Some(sf), Some(ef), + Some(vec![img]), + Some(vec![vid]), + Some(vec![aud]), + ); + let d = distill_with_map(&req, &map); + + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert!(plan.start_frame_url.is_some()); + assert!(plan.end_frame_url.is_some()); + assert_eq!(plan.reference_image_urls.as_ref().map(|v| v.len()), Some(1)); + assert_eq!(plan.reference_video_urls.as_ref().map(|v| v.len()), Some(1)); + assert_eq!(plan.reference_audio_urls.as_ref().map(|v| v.len()), Some(1)); + assert!(plan.prompt.as_deref() == Some("full test")); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn duration_is_clamped_to_valid_range() { + // Duration below 4 should clamp to 4. + let d = distill_text(&text_only_request(Some(1), None)); + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert!(plan.duration_seconds >= 4, "expected >= 4, got {}", plan.duration_seconds); + } else { + panic!("wrong plan variant"); + } + + // Duration above 15 should clamp to 15. + let d = distill_text(&text_only_request(Some(99), None)); + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + assert!(plan.duration_seconds <= 15, "expected <= 15, got {}", plan.duration_seconds); + } else { + panic!("wrong plan variant"); + } + } + + #[test] + fn missing_prompt_defaults_to_empty() { + let req = make_request( + None, None, Some(5), None, + None, None, None, None, None, + ); + let d = distill_text(&req); + if let VideoGenerationPlan::Seedance2proSeedance2p0(plan) = d.plan() { + // Prompt should be None or empty string. + let prompt = plan.prompt.as_deref().unwrap_or(""); + assert!(prompt.is_empty() || plan.prompt.is_none()); + } else { + panic!("wrong plan variant"); + } + } + } +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/mod.rs index a9bf0559a5..baf495bf29 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/mod.rs @@ -1,3 +1,4 @@ mod test_seedance_1p5_pro; mod test_veo_2; mod test_veo_3; +mod kinovi; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_seedance_1p5_pro.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_seedance_1p5_pro.rs index 0c01e121fc..163681c147 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_seedance_1p5_pro.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_seedance_1p5_pro.rs @@ -19,6 +19,7 @@ mod tests { use tokens::tokens::media_files::MediaFileToken; use url::Url; + use artcraft_router::api::provider::Provider; use crate::http_server::endpoints::omni_gen::generate::video::distill_video_request::{ distill_video_request, DistilledVideoRequest, }; @@ -75,7 +76,7 @@ mod tests { fn distill_text(request: &OmniGenVideoCostAndGenerateRequest) -> DistilledVideoRequest { let empty: HashMap = HashMap::new(); - distill_video_request(request, Some(&empty)) + distill_video_request(request, Some(&empty), Provider::Fal) .expect("distill_video_request should succeed for Seedance 1.5 Pro (text)") } @@ -83,7 +84,7 @@ mod tests { request: &OmniGenVideoCostAndGenerateRequest, hydration: &HashMap, ) -> DistilledVideoRequest { - distill_video_request(request, Some(hydration)) + distill_video_request(request, Some(hydration), Provider::Fal) .expect("distill_video_request should succeed for Seedance 1.5 Pro (image)") } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_2.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_2.rs index 17fdbd86e4..9566ed0c06 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_2.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_2.rs @@ -20,6 +20,7 @@ mod tests { use tokens::tokens::media_files::MediaFileToken; use url::Url; + use artcraft_router::api::provider::Provider; use crate::http_server::endpoints::omni_gen::generate::video::distill_video_request::{ distill_video_request, DistilledVideoRequest, }; @@ -62,7 +63,7 @@ mod tests { fn distill_text(request: &OmniGenVideoCostAndGenerateRequest) -> DistilledVideoRequest { let empty: HashMap = HashMap::new(); - distill_video_request(request, Some(&empty)) + distill_video_request(request, Some(&empty), Provider::Fal) .expect("distill_video_request should succeed for Veo 2 (text)") } @@ -70,7 +71,7 @@ mod tests { request: &OmniGenVideoCostAndGenerateRequest, hydration: &HashMap, ) -> DistilledVideoRequest { - distill_video_request(request, Some(hydration)) + distill_video_request(request, Some(hydration), Provider::Fal) .expect("distill_video_request should succeed for Veo 2 (image)") } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_3.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_3.rs index 1f48305250..1ba15b2c8b 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_3.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/tests/test_veo_3.rs @@ -24,6 +24,7 @@ mod tests { use tokens::tokens::media_files::MediaFileToken; use url::Url; + use artcraft_router::api::provider::Provider; use crate::http_server::endpoints::omni_gen::generate::video::distill_video_request::{ distill_video_request, DistilledVideoRequest, }; @@ -68,7 +69,7 @@ mod tests { fn distill_text(request: &OmniGenVideoCostAndGenerateRequest) -> DistilledVideoRequest { let empty: HashMap = HashMap::new(); - distill_video_request(request, Some(&empty)) + distill_video_request(request, Some(&empty), Provider::Fal) .expect("distill should succeed for Veo 3 (text)") } @@ -76,7 +77,7 @@ mod tests { request: &OmniGenVideoCostAndGenerateRequest, hydration: &HashMap, ) -> DistilledVideoRequest { - distill_video_request(request, Some(hydration)) + distill_video_request(request, Some(hydration), Provider::Fal) .expect("distill should succeed for Veo 3 (image)") }