seedance2fast artcraft impl

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/cost/artcraft/estimate_video_cost_artcraft_seedance2p0_fast.rs

@@ -0,0 +1,164 @@
+use artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0BatchCount;
+use seedance2pro_client::creds::seedance2pro_session::Seedance2ProSession;
+use seedance2pro_client::requests::generate_video::generate_video::{BatchCount, GenerateVideoArgs, ModelType, Resolution};
+
+use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance2p0::PlanArtcraftSeedance2p0;
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+
+pub(crate) fn estimate_video_cost_artcraft_seedance2p0_fast(
+  plan: &PlanArtcraftSeedance2p0<'_>,
+) -> VideoGenerationCostEstimate {
+  let duration_seconds = plan.duration_seconds.unwrap_or(5).clamp(4, 15);
+
+  let batch_count = match plan.batch_count {
+    Seedance2p0BatchCount::One => BatchCount::One,
+    Seedance2p0BatchCount::Two => BatchCount::Two,
+    Seedance2p0BatchCount::Four => BatchCount::Four,
+  };
+
+  let dummy_session = Seedance2ProSession::from_cookies_string(String::new());
+
+  let args = GenerateVideoArgs {
+    session: &dummy_session,
+    model_type: ModelType::Seedance2Fast, // <-- Fast, not Pro
+    prompt: String::new(),
+    resolution: Resolution::Square1x1,
+    duration_seconds,
+    batch_count,
+    start_frame_url: None,
+    end_frame_url: None,
+    reference_image_urls: None,
+    reference_video_urls: None,
+    reference_audio_urls: None,
+    character_ids: None,
+    use_face_blur_hack: None,
+    host_override: None,
+  };
+
+  let cost_in_usd_cents = args.estimate_cost_in_usd_cents();
+
+  VideoGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_video_model::CommonVideoModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_video::generate_video_request::GenerateVideoRequest;
+
+  fn estimate_usd_cents(duration_seconds: u16, video_batch_count: u16) -> u64 {
+    let request = GenerateVideoRequest {
+      model: CommonVideoModel::Seedance2p0Fast,
+      provider: Provider::Artcraft,
+      prompt: None,
+      negative_prompt: None,
+      start_frame: None,
+      end_frame: None,
+      reference_images: None,
+      reference_videos: None,
+      reference_audio: None,
+      reference_character_tokens: None,
+      resolution: None,
+      aspect_ratio: None,
+      duration_seconds: Some(duration_seconds),
+      video_batch_count: Some(video_batch_count),
+      generate_audio: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  fn estimate_pro_usd_cents(duration_seconds: u16, video_batch_count: u16) -> u64 {
+    let request = GenerateVideoRequest {
+      model: CommonVideoModel::Seedance2p0,
+      provider: Provider::Artcraft,
+      prompt: None,
+      negative_prompt: None,
+      start_frame: None,
+      end_frame: None,
+      reference_images: None,
+      reference_videos: None,
+      reference_audio: None,
+      reference_character_tokens: None,
+      resolution: None,
+      aspect_ratio: None,
+      duration_seconds: Some(duration_seconds),
+      video_batch_count: Some(video_batch_count),
+      generate_audio: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn cost_is_present() {
+    assert!(estimate_usd_cents(5, 1) > 0);
+  }
+
+  #[test]
+  fn cost_batch_1() {
+    assert_eq!(estimate_usd_cents(4, 1), 51);
+    assert_eq!(estimate_usd_cents(5, 1), 64);
+    assert_eq!(estimate_usd_cents(10, 1), 127);
+    assert_eq!(estimate_usd_cents(15, 1), 191);
+  }
+
+  #[test]
+  fn cost_batch_2() {
+    assert_eq!(estimate_usd_cents(5, 2), 127);
+  }
+
+  #[test]
+  fn cost_batch_4() {
+    assert_eq!(estimate_usd_cents(5, 4), 255);
+  }
+
+  #[test]
+  fn fast_is_cheaper_than_pro() {
+    for duration in [4, 5, 10, 15] {
+      let fast = estimate_usd_cents(duration, 1);
+      let pro = estimate_pro_usd_cents(duration, 1);
+      assert!(
+        fast < pro,
+        "Fast ({}) should be cheaper than Pro ({}) at {}s",
+        fast, pro, duration,
+      );
+    }
+  }
+
+  #[test]
+  fn cost_scales_with_duration() {
+    let c4 = estimate_usd_cents(4, 1);
+    let c10 = estimate_usd_cents(10, 1);
+    let c15 = estimate_usd_cents(15, 1);
+    assert!(c4 < c10);
+    assert!(c10 < c15);
+  }
+
+  #[test]
+  fn cost_scales_with_batch() {
+    let b1 = estimate_usd_cents(5, 1);
+    let b2 = estimate_usd_cents(5, 2);
+    let b4 = estimate_usd_cents(5, 4);
+    assert!(b1 < b2);
+    assert!(b2 < b4);
+  }
+}

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

@@ -8,6 +8,7 @@ pub mod estimate_video_cost_artcraft_kling3p0_standard;
 pub mod estimate_video_cost_artcraft_seedance_1_0_lite;
 pub mod estimate_video_cost_artcraft_seedance1p5_pro;
 pub mod estimate_video_cost_artcraft_seedance2p0;
+pub mod estimate_video_cost_artcraft_seedance2p0_fast;
 pub mod estimate_video_cost_artcraft_sora_2;
 pub mod estimate_video_cost_artcraft_sora_2_pro;
 pub mod estimate_video_cost_artcraft_veo_2;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/execute/artcraft/generate_video_artcraft_seedance2p0_fast.rs

@@ -0,0 +1,65 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_video::generate_video_response::{
+  ArtcraftVideoResponsePayload, GenerateVideoResponse,
+};
+use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance2p0::PlanArtcraftSeedance2p0;
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
+use artcraft_client::endpoints::omni_gen::generate::video::omni_gen_video::omni_gen_video_generate;
+use enums::common::generation::common_aspect_ratio::CommonAspectRatio;
+use enums::common::generation::common_video_model::CommonVideoModel;
+
+/// Execute Seedance 2.0 Fast via the Artcraft omni-gen video endpoint.
+///
+/// Unlike Seedance 2.0 Pro (which uses the legacy dedicated endpoint),
+/// Seedance 2.0 Fast routes through the omni-gen unified video endpoint.
+pub async fn execute_artcraft_seedance2p0_fast(
+  plan: &PlanArtcraftSeedance2p0<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+  let aspect_ratio = plan.aspect_ratio.map(|ar| match ar {
+    artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0AspectRatio::Landscape16x9 => CommonAspectRatio::WideSixteenByNine,
+    artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0AspectRatio::Portrait9x16 => CommonAspectRatio::TallNineBySixteen,
+    artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0AspectRatio::Square1x1 => CommonAspectRatio::Square,
+    artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0AspectRatio::Standard4x3 => CommonAspectRatio::WideFourByThree,
+    artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0AspectRatio::Portrait3x4 => CommonAspectRatio::TallThreeByFour,
+  });
+
+  let request = OmniGenVideoCostAndGenerateRequest {
+    idempotency_token: Some(plan.idempotency_token.clone()),
+    model: Some(CommonVideoModel::Seedance2p0Fast),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    negative_prompt: None,
+    start_frame_image_media_token: plan.start_frame.cloned(),
+    end_frame_image_media_token: plan.end_frame.cloned(),
+    reference_image_media_tokens: plan.reference_images.cloned(),
+    reference_video_media_tokens: plan.reference_videos.cloned(),
+    reference_audio_media_tokens: plan.reference_audio.cloned(),
+    reference_character_tokens: None,
+    resolution: None,
+    aspect_ratio,
+    quality: None,
+    duration_seconds: plan.duration_seconds.map(|d| d as u16),
+    video_batch_count: Some(match plan.batch_count {
+      artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0BatchCount::One => 1,
+      artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0BatchCount::Two => 2,
+      artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::Seedance2p0BatchCount::Four => 4,
+    }),
+    generate_audio: None,
+  };
+
+  let response = omni_gen_video_generate(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  let all_tokens = vec![response.inference_job_token.clone()];
+  Ok(GenerateVideoResponse::Artcraft(ArtcraftVideoResponsePayload {
+    inference_job_token: response.inference_job_token,
+    all_inference_job_tokens: all_tokens,
+  }))
+}

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

@@ -8,6 +8,7 @@ pub mod generate_video_artcraft_kling3p0_standard;
 pub mod generate_video_artcraft_seedance_1_0_lite;
 pub mod generate_video_artcraft_seedance1p5_pro;
 pub mod generate_video_artcraft_seedance2p0;
+pub mod generate_video_artcraft_seedance2p0_fast;
 pub mod generate_video_artcraft_sora_2;
 pub mod generate_video_artcraft_sora_2_pro;
 pub mod generate_video_artcraft_veo_2;

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

@@ -19,6 +19,7 @@ use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraf
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance_1_0_lite::plan_generate_video_artcraft_seedance_1_0_lite;
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance1p5_pro::plan_generate_video_artcraft_seedance1p5_pro;
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance2p0::plan_generate_video_artcraft_seedance2p0;
+use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance2p0_fast::plan_generate_video_artcraft_seedance2p0_fast;
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_sora_2::plan_generate_video_artcraft_sora_2;
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_sora_2_pro::plan_generate_video_artcraft_sora_2_pro;
 use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_veo_2::plan_generate_video_artcraft_veo_2;
@@ -132,6 +133,7 @@ impl<'a> GenerateVideoRequest<'a> {
       CommonVideoModel::Seedance10Lite => plan_generate_video_artcraft_seedance_1_0_lite(self),
       CommonVideoModel::Seedance1p5Pro => plan_generate_video_artcraft_seedance1p5_pro(self),
       CommonVideoModel::Seedance2p0 => plan_generate_video_artcraft_seedance2p0(self),
+      CommonVideoModel::Seedance2p0Fast => plan_generate_video_artcraft_seedance2p0_fast(self),
       CommonVideoModel::Sora2 => plan_generate_video_artcraft_sora_2(self),
       CommonVideoModel::Sora2Pro => plan_generate_video_artcraft_sora_2_pro(self),
       CommonVideoModel::Veo2 => plan_generate_video_artcraft_veo_2(self),

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

@@ -8,6 +8,7 @@ pub mod plan_generate_video_artcraft_kling3p0_standard;
 pub mod plan_generate_video_artcraft_seedance_1_0_lite;
 pub mod plan_generate_video_artcraft_seedance1p5_pro;
 pub mod plan_generate_video_artcraft_seedance2p0;
+pub mod plan_generate_video_artcraft_seedance2p0_fast;
 pub mod plan_generate_video_artcraft_sora_2;
 pub mod plan_generate_video_artcraft_sora_2_pro;
 pub mod plan_generate_video_artcraft_veo_2;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video/plan/artcraft/plan_generate_video_artcraft_seedance2p0_fast.rs

@@ -0,0 +1,165 @@
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_video::generate_video_request::GenerateVideoRequest;
+use crate::generate::generate_video::plan::artcraft::plan_generate_video_artcraft_seedance2p0::{
+  PlanArtcraftSeedance2p0, plan_generate_video_artcraft_seedance2p0,
+};
+use crate::generate::generate_video::video_generation_plan::VideoGenerationPlan;
+
+/// Plan for Seedance 2.0 Fast via Artcraft provider.
+///
+/// Uses the same plan structure as Seedance 2.0 Pro (same resolution, duration,
+/// batch count, and media reference handling). The only difference is the
+/// variant used at execution time.
+pub fn plan_generate_video_artcraft_seedance2p0_fast<'a>(
+  request: &'a GenerateVideoRequest<'a>,
+) -> Result<VideoGenerationPlan<'a>, ArtcraftRouterError> {
+  // Reuse the Pro plan builder — it produces a PlanArtcraftSeedance2p0.
+  let pro_plan = plan_generate_video_artcraft_seedance2p0(request)?;
+
+  // Extract the inner plan struct and re-wrap in the Fast variant.
+  match pro_plan {
+    VideoGenerationPlan::ArtcraftSeedance2p0(plan) => {
+      Ok(VideoGenerationPlan::ArtcraftSeedance2p0Fast(plan))
+    }
+    _ => unreachable!("plan_generate_video_artcraft_seedance2p0 always returns ArtcraftSeedance2p0"),
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_video_model::CommonVideoModel;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::provider::Provider;
+  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::GenerateVideoRequest;
+  use crate::generate::generate_video::video_generation_plan::VideoGenerationPlan;
+  use artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::{
+    Seedance2p0AspectRatio, Seedance2p0BatchCount,
+  };
+
+  fn base_request() -> GenerateVideoRequest<'static> {
+    GenerateVideoRequest {
+      model: CommonVideoModel::Seedance2p0Fast,
+      provider: Provider::Artcraft,
+      prompt: Some("a cat in space"),
+      negative_prompt: None,
+      start_frame: None,
+      end_frame: None,
+      reference_images: None,
+      reference_videos: None,
+      reference_audio: None,
+      reference_character_tokens: None,
+      resolution: None,
+      aspect_ratio: None,
+      duration_seconds: None,
+      video_batch_count: None,
+      generate_audio: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      idempotency_token: None,
+    }
+  }
+
+  #[test]
+  fn produces_fast_variant() {
+    let req = base_request();
+    let plan = req.build().unwrap();
+    assert!(matches!(plan, VideoGenerationPlan::ArtcraftSeedance2p0Fast(_)));
+  }
+
+  #[test]
+  fn prompt_is_passed_through() {
+    let req = base_request();
+    let plan = req.build().unwrap();
+    if let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan {
+      assert_eq!(p.prompt, Some("a cat in space"));
+    } else { panic!("wrong variant"); }
+  }
+
+  #[test]
+  fn aspect_ratio_16x9() {
+    let req = GenerateVideoRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      ..base_request()
+    };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.aspect_ratio, Some(Seedance2p0AspectRatio::Landscape16x9)));
+  }
+
+  #[test]
+  fn aspect_ratio_9x16() {
+    let req = GenerateVideoRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallNineBySixteen),
+      ..base_request()
+    };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.aspect_ratio, Some(Seedance2p0AspectRatio::Portrait9x16)));
+  }
+
+  #[test]
+  fn aspect_ratio_square() {
+    let req = GenerateVideoRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      ..base_request()
+    };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.aspect_ratio, Some(Seedance2p0AspectRatio::Square1x1)));
+  }
+
+  #[test]
+  fn batch_count_defaults_to_one() {
+    let req = base_request();
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.batch_count, Seedance2p0BatchCount::One));
+  }
+
+  #[test]
+  fn batch_count_2() {
+    let req = GenerateVideoRequest { video_batch_count: Some(2), ..base_request() };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.batch_count, Seedance2p0BatchCount::Two));
+  }
+
+  #[test]
+  fn batch_count_4() {
+    let req = GenerateVideoRequest { video_batch_count: Some(4), ..base_request() };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert!(matches!(p.batch_count, Seedance2p0BatchCount::Four));
+  }
+
+  #[test]
+  fn duration_in_range() {
+    let req = GenerateVideoRequest { duration_seconds: Some(10), ..base_request() };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert_eq!(p.duration_seconds, Some(10));
+  }
+
+  #[test]
+  fn duration_clamped_to_max() {
+    let req = GenerateVideoRequest { duration_seconds: Some(99), ..base_request() };
+    let plan = req.build().unwrap();
+    let VideoGenerationPlan::ArtcraftSeedance2p0Fast(p) = plan else { panic!("wrong variant") };
+    assert_eq!(p.duration_seconds, Some(15));
+  }
+
+  #[test]
+  fn url_image_ref_returns_error() {
+    let req = GenerateVideoRequest {
+      start_frame: Some(ImageRef::Url("https://example.com/image.jpg")),
+      ..base_request()
+    };
+    assert!(matches!(
+      req.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+}

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

@@ -10,6 +10,7 @@ use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraf
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_seedance_1_0_lite::estimate_video_cost_artcraft_seedance_1_0_lite;
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_seedance1p5_pro::estimate_video_cost_artcraft_seedance1p5_pro;
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_seedance2p0::estimate_video_cost_artcraft_seedance2p0;
+use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_seedance2p0_fast::estimate_video_cost_artcraft_seedance2p0_fast;
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_sora_2::estimate_video_cost_artcraft_sora_2;
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_sora_2_pro::estimate_video_cost_artcraft_sora_2_pro;
 use crate::generate::generate_video::cost::artcraft::estimate_video_cost_artcraft_veo_2::estimate_video_cost_artcraft_veo_2;
@@ -46,6 +47,7 @@ use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_seedance_1_0_lite::execute_artcraft_seedance_1_0_lite;
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_seedance1p5_pro::execute_artcraft_seedance1p5_pro;
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_seedance2p0::execute_artcraft_seedance2p0;
+use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_seedance2p0_fast::execute_artcraft_seedance2p0_fast;
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_sora_2::execute_artcraft_sora_2;
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_sora_2_pro::execute_artcraft_sora_2_pro;
 use crate::generate::generate_video::execute::artcraft::generate_video_artcraft_veo_2::execute_artcraft_veo_2;
@@ -122,6 +124,7 @@ pub enum VideoGenerationPlan<'a> {
   ArtcraftSeedance10Lite(PlanArtcraftSeedance10Lite<'a>),
   ArtcraftSeedance1p5Pro(PlanArtcraftSeedance1p5Pro<'a>),
   ArtcraftSeedance2p0(PlanArtcraftSeedance2p0<'a>),
+  ArtcraftSeedance2p0Fast(PlanArtcraftSeedance2p0<'a>),
   ArtcraftSora2(PlanArtcraftSora2<'a>),
   ArtcraftSora2Pro(PlanArtcraftSora2Pro<'a>),
   ArtcraftVeo2(PlanArtcraftVeo2<'a>),
@@ -196,6 +199,10 @@ impl<'a> VideoGenerationPlan<'a> {
         let artcraft_client = client.get_artcraft_client_ref()?;
         execute_artcraft_seedance2p0(plan, artcraft_client).await
       }
+      VideoGenerationPlan::ArtcraftSeedance2p0Fast(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedance2p0_fast(plan, artcraft_client).await
+      }
       VideoGenerationPlan::ArtcraftSora2(plan) => {
         let artcraft_client = client.get_artcraft_client_ref()?;
         execute_artcraft_sora_2(plan, artcraft_client).await
@@ -325,6 +332,9 @@ impl<'a> VideoGenerationPlan<'a> {
       VideoGenerationPlan::ArtcraftSeedance2p0(plan) => {
         estimate_video_cost_artcraft_seedance2p0(plan)
       }
+      VideoGenerationPlan::ArtcraftSeedance2p0Fast(plan) => {
+        estimate_video_cost_artcraft_seedance2p0_fast(plan)
+      }
       VideoGenerationPlan::ArtcraftSora2(plan) => {
         estimate_video_cost_artcraft_sora_2(plan)
       }