environment var changes

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

@@ -70,4 +70,10 @@ pub enum CommonVideoModel {
 
   #[serde(rename = "veo_3p1_fast")]
   Veo3p1Fast,
+
+  #[serde(rename = "preview_model")]
+  PreviewModel,
+
+  #[serde(rename = "preview_model_fast")]
+  PreviewModelFast,
 }

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

@@ -48,6 +48,8 @@ use crate::generate::generate_video::plan::seedance2pro::plan_generate_video_see
 use crate::generate::generate_video::plan::seedance2pro::plan_generate_video_seedance2pro_seedance2p0_fast::plan_generate_video_seedance2pro_seedance2p0_fast;
 use crate::generate::generate_video::video_generation_plan::VideoGenerationPlan;
 use crate::generate::generate_video_v2::providers::artcraft::happy_horse_1p0::build::build_artcraft_happy_horse_1p0;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model::build::build_artcraft_preview_model;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model_fast::build::build_artcraft_preview_model_fast;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0::build::build_artcraft_seedance_2p0;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0_fast::build::build_artcraft_seedance_2p0_fast;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0_g::build::build_artcraft_seedance_2p0_g;
@@ -153,7 +155,10 @@ impl GenerateVideoRequestBuilder {
       (Provider::Artcraft, CommonVideoModel::Seedance2p0Fast) => true,
       (Provider::Artcraft, CommonVideoModel::Seedance2p0Global) => true,
       (Provider::Artcraft, CommonVideoModel::Seedance2p0FastGlobal) => true,
+      (Provider::Artcraft, CommonVideoModel::PreviewModel) => true,
+      (Provider::Artcraft, CommonVideoModel::PreviewModelFast) => true,
       (Provider::GmiCloud, CommonVideoModel::Seedance2p0Global) => true,
+
       (Provider::GmiCloud, CommonVideoModel::Seedance2p0FastGlobal) => true,
       (Provider::Seedance2Pro, CommonVideoModel::HappyHorse1p0) => true,
       (Provider::Seedance2Pro, CommonVideoModel::Seedance2p0) => true,
@@ -170,6 +175,8 @@ impl GenerateVideoRequestBuilder {
       (Provider::Artcraft, CommonVideoModel::Seedance2p0Fast) => build_artcraft_seedance_2p0_fast(self),
       (Provider::Artcraft, CommonVideoModel::Seedance2p0Global) => build_artcraft_seedance_2p0_g(self),
       (Provider::Artcraft, CommonVideoModel::Seedance2p0FastGlobal) => build_artcraft_seedance_2p0_fast_g(self),
+      (Provider::Artcraft, CommonVideoModel::PreviewModel) => build_artcraft_preview_model(self),
+      (Provider::Artcraft, CommonVideoModel::PreviewModelFast) => build_artcraft_preview_model_fast(self),
       (Provider::GmiCloud, CommonVideoModel::Seedance2p0Global) => build_gmicloud_seedance_2p0_g(self),
       (Provider::GmiCloud, CommonVideoModel::Seedance2p0FastGlobal) => build_gmicloud_seedance_2p0_fast_g(self),
       (Provider::Seedance2Pro, CommonVideoModel::HappyHorse1p0) => build_kinovi_happy_horse_1p0(self),

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

@@ -1,4 +1,6 @@
 pub mod happy_horse_1p0;
+pub mod preview_model;
+pub mod preview_model_fast;
 pub(crate) mod resolve;
 pub mod seedance_2p0;
 pub mod seedance_2p0_fast;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model/build.rs

@@ -0,0 +1,344 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
+use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
+use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::common_resolution::CommonResolution;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+use crate::generate::generate_video_v2::providers::artcraft::resolve::{
+  resolve_audio_list_ref, resolve_character_list_ref, resolve_image_list_ref,
+  resolve_image_ref, resolve_video_list_ref,
+};
+use crate::generate::generate_video_v2::providers::artcraft::preview_model::request::ArtcraftPreviewModelRequestState;
+use crate::generate::generate_video_v2::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+use crate::generate::generate_video_v2::video_generation_request::VideoGenerationRequest;
+
+pub fn build_artcraft_preview_model(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  let aspect_ratio = plan_aspect_ratio(builder.aspect_ratio.take(), strategy)?;
+  let resolution = plan_output_resolution(builder.resolution.take(), strategy)?;
+  let batch_count = plan_batch_count(builder.video_batch_count.take(), strategy)?;
+  let duration_seconds = plan_duration(builder.duration_seconds.take(), strategy)?;
+  let prompt = builder.prompt.take();
+
+  let start_frame = resolve_image_ref(builder.start_frame.take())?;
+  let end_frame = resolve_image_ref(builder.end_frame.take())?;
+  let reference_images = resolve_image_list_ref(builder.reference_images.take())?;
+  let reference_videos = resolve_video_list_ref(builder.reference_videos.take())?;
+  let reference_audio = resolve_audio_list_ref(builder.reference_audio.take())?;
+  let reference_characters = resolve_character_list_ref(builder.reference_character_tokens.take());
+  let idempotency_token = builder.get_or_generate_idempotency_token();
+
+  let request = OmniGenVideoCostAndGenerateRequest {
+    model: Some(CommonVideoModelEnum::PreviewModel),
+    idempotency_token: Some(idempotency_token),
+    prompt,
+    start_frame_image_media_token: start_frame,
+    end_frame_image_media_token: end_frame,
+    reference_image_media_tokens: reference_images,
+    reference_video_media_tokens: reference_videos,
+    reference_audio_media_tokens: reference_audio,
+    reference_character_tokens: reference_characters,
+    resolution,
+    aspect_ratio,
+    duration_seconds: duration_seconds.map(|d| d as u16),
+    video_batch_count: Some(batch_count),
+    negative_prompt: None,
+    generate_audio: None,
+    quality: None,
+  };
+
+  let state = ArtcraftPreviewModelRequestState { request };
+  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftPreviewModel(state)))
+}
+
+// -- Plan helpers --
+
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<CommonAspectRatioEnum>, ArtcraftRouterError> {
+  match aspect_ratio {
+    None
+    | Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(None),
+
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => {
+      Ok(Some(CommonAspectRatioEnum::WideSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => {
+      Ok(Some(CommonAspectRatioEnum::TallNineBySixteen))
+    }
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => {
+      Ok(Some(CommonAspectRatioEnum::Square))
+    }
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(CommonAspectRatioEnum::WideFourByThree)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(CommonAspectRatioEnum::TallThreeByFour)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(CommonAspectRatioEnum::WideTwentyOneByNine)),
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> CommonAspectRatioEnum {
+  match aspect_ratio {
+    CommonAspectRatio::WideFiveByFour => CommonAspectRatioEnum::WideFourByThree,
+    CommonAspectRatio::WideThreeByTwo => CommonAspectRatioEnum::WideFourByThree,
+    CommonAspectRatio::TallFourByFive => CommonAspectRatioEnum::TallThreeByFour,
+    CommonAspectRatio::TallTwoByThree => CommonAspectRatioEnum::TallThreeByFour,
+    CommonAspectRatio::TallNineByTwentyOne => CommonAspectRatioEnum::TallNineBySixteen,
+    _ => CommonAspectRatioEnum::Square,
+  }
+}
+
+// PreviewModel supports output resolutions: 480p, 720p, 1080p.
+fn plan_output_resolution(
+  resolution: Option<CommonResolution>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<CommonResolutionEnum>, ArtcraftRouterError> {
+  match resolution {
+    None => Ok(None),
+
+    Some(CommonResolution::FourEightyP) => Ok(Some(CommonResolutionEnum::FourEightyP)),
+    Some(CommonResolution::SevenTwentyP) => Ok(Some(CommonResolutionEnum::SevenTwentyP)),
+    Some(CommonResolution::TenEightyP) => Ok(Some(CommonResolutionEnum::TenEightyP)),
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => {
+        Ok(Some(match unsupported {
+          CommonResolution::HalfK => CommonResolutionEnum::FourEightyP,
+          _ => CommonResolutionEnum::TenEightyP,
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(match unsupported {
+          CommonResolution::HalfK => CommonResolutionEnum::FourEightyP,
+          _ => CommonResolutionEnum::TenEightyP,
+        }))
+      }
+    },
+  }
+}
+
+// Batch counts: 1, 2, 4.
+fn plan_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<u16, ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 | 2 | 4 => Ok(count),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(4),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(if count < 4 { 2 } else { 4 })
+      }
+    },
+  }
+}
+
+// Duration: 4-15 seconds.
+fn plan_duration(
+  duration_seconds: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<u8>, ArtcraftRouterError> {
+  const MIN: u16 = 4;
+  const MAX: u16 = 15;
+  match duration_seconds {
+    None => Ok(None),
+    Some(d) if d >= MIN && d <= MAX => Ok(Some(d as u8)),
+    Some(d) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "duration_seconds",
+          value: format!("{}", d),
+        }))
+      }
+      _ => Ok(Some(d.clamp(MIN, MAX) as u8)),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+  use tokens::tokens::characters::CharacterToken;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::character_list_ref::CharacterListRef;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::provider::Provider;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video_v2::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+  use crate::generate::generate_video_v2::video_generation_request::VideoGenerationRequest;
+
+  use super::*;
+
+  // ── Field conversions ──
+
+  mod field_conversions {
+    use super::*;
+
+    #[test]
+    fn model_is_preview_model() {
+      let req = unwrap_request(make_builder(|_| {}));
+      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::PreviewModel)));
+    }
+
+    #[test]
+    fn prompt_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.prompt = Some("test".to_string()); }));
+      assert_eq!(req.request.prompt, Some("test".to_string()));
+    }
+
+    #[test]
+    fn duration_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(10); }));
+      assert_eq!(req.request.duration_seconds, Some(10));
+    }
+
+    #[test]
+    fn duration_clamped_to_max() {
+      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(99); }));
+      assert_eq!(req.request.duration_seconds, Some(15));
+    }
+
+    #[test]
+    fn batch_count_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.video_batch_count = Some(4); }));
+      assert_eq!(req.request.video_batch_count, Some(4));
+    }
+  }
+
+  // ── Resolution ──
+
+  mod resolution_tests {
+    use super::*;
+
+    #[test]
+    fn res_480p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::FourEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
+    }
+
+    #[test]
+    fn res_720p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::SevenTwentyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
+    }
+
+    #[test]
+    fn res_1080p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::TenEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::TenEightyP));
+    }
+
+    #[test]
+    fn none_stays_none() {
+      let req = unwrap_request(make_builder(|_| {}));
+      assert!(req.request.resolution.is_none());
+    }
+  }
+
+  // ── Media tokens ──
+
+  mod media_token_tests {
+    use super::*;
+
+    #[test]
+    fn start_frame_token_passed_through() {
+      let token = MediaFileToken::new("mf_start".to_string());
+      let req = unwrap_request(make_builder(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(token.clone()));
+      }));
+      assert_eq!(req.request.start_frame_image_media_token, Some(token));
+    }
+
+    #[test]
+    fn url_start_frame_rejected() {
+      let result = build_artcraft_preview_model(GenerateVideoRequestBuilder {
+        start_frame: Some(ImageRef::Url("https://example.com".to_string())),
+        ..base_builder()
+      });
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn reference_image_tokens_passed_through() {
+      let tokens = vec![MediaFileToken::new("mf_a".to_string()), MediaFileToken::new("mf_b".to_string())];
+      let req = unwrap_request(make_builder(|b| {
+        b.reference_images = Some(ImageListRef::MediaFileTokens(tokens.clone()));
+      }));
+      assert_eq!(req.request.reference_image_media_tokens, Some(tokens));
+    }
+
+    #[test]
+    fn character_tokens_passed_through() {
+      let tokens = vec![CharacterToken::new("char_a".to_string()), CharacterToken::new("char_b".to_string())];
+      let req = unwrap_request(make_builder(|b| {
+        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(tokens.clone()));
+      }));
+      assert_eq!(req.request.reference_character_tokens, Some(tokens));
+    }
+  }
+
+  // ── Helpers ──
+
+  fn base_builder() -> GenerateVideoRequestBuilder {
+    GenerateVideoRequestBuilder {
+      provider: Provider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    }
+  }
+
+  fn make_builder(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
+    let mut builder = base_builder();
+    f(&mut builder);
+    builder
+  }
+
+  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftPreviewModelRequestState {
+    let result = build_artcraft_preview_model(builder).expect("build should succeed");
+    match result {
+      VideoGenerationDraftOrRequest::Request(
+        VideoGenerationRequest::ArtcraftPreviewModel(state)
+      ) => state,
+      _ => panic!("expected ArtcraftPreviewModel request"),
+    }
+  }
+}

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

@@ -0,0 +1,233 @@
+use enums::common::generation::common_resolution::CommonResolution;
+
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model::request::ArtcraftPreviewModelRequestState;
+
+// ── Pricing constants ──
+//
+// ArtCraft credits: 100 credits = $1.00. Credits always equal USD cents.
+
+/// USD cents per second by resolution:
+///   480p:  $0.10/s = 10.0 ¢/s
+///   720p:  $0.25/s = 25.0 ¢/s
+///   1080p: $0.50/s = 50.0 ¢/s
+const CENTS_PER_SECOND_480P: f64 = 10.0;
+const CENTS_PER_SECOND_720P: f64 = 25.0;
+const CENTS_PER_SECOND_1080P: f64 = 50.0;
+
+pub struct ArtcraftPreviewModelCostState {
+  pub resolution: CommonResolution,
+  pub duration_seconds: u16,
+  pub batch_count: u16,
+}
+
+impl ArtcraftPreviewModelCostState {
+  pub fn from_request(request: &ArtcraftPreviewModelRequestState) -> Self {
+    let resolution = request.request.resolution
+      .unwrap_or(CommonResolution::SevenTwentyP);
+    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
+    let batch_count = request.request.video_batch_count.unwrap_or(1);
+
+    Self { resolution, duration_seconds, batch_count }
+  }
+
+  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    let cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
+      CommonResolution::TenEightyP => CENTS_PER_SECOND_1080P,
+      // Everything else (including 720p) prices at 720p.
+      _ => CENTS_PER_SECOND_720P,
+    };
+
+    let usd_cents = (self.duration_seconds as f64 * cents_per_second * self.batch_count as f64).round() as u64;
+
+    VideoGenerationCostEstimate {
+      cost_in_credits: Some(usd_cents),
+      cost_in_usd_cents: Some(usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::common_video_model::CommonVideoModel;
+  use crate::api::provider::Provider;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+
+  // -- 720p pricing --
+
+  mod pricing_720p {
+    use super::*;
+
+    #[test]
+    fn batch_1() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 4, 1), 100);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1), 125);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 10, 1), 250);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 1), 375);
+    }
+
+    #[test]
+    fn batch_2() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 2), 250);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 2), 750);
+    }
+
+    #[test]
+    fn batch_4() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 4), 500);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 4), 1500);
+    }
+
+    #[test]
+    fn none_defaults_to_720p() {
+      assert_eq!(cost_cents(None, 5, 1), cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1));
+    }
+  }
+
+  // -- 480p pricing --
+
+  mod pricing_480p {
+    use super::*;
+
+    #[test]
+    fn batch_1() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 4, 1), 40);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 1), 50);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 10, 1), 100);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 15, 1), 150);
+    }
+
+    #[test]
+    fn batch_2() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 2), 100);
+    }
+
+    #[test]
+    fn batch_4() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 4), 200);
+    }
+  }
+
+  // -- 1080p pricing --
+
+  mod pricing_1080p {
+    use super::*;
+
+    #[test]
+    fn batch_1() {
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 4, 1), 200);
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 5, 1), 250);
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 10, 1), 500);
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 15, 1), 750);
+    }
+
+    #[test]
+    fn batch_2() {
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 5, 2), 500);
+    }
+
+    #[test]
+    fn batch_4() {
+      assert_eq!(cost_cents(Some(CommonResolution::TenEightyP), 5, 4), 1000);
+    }
+  }
+
+  // -- Relative pricing --
+
+  mod relative_pricing_tests {
+    use super::*;
+
+    #[test]
+    fn cost_480p_cheaper_than_720p_cheaper_than_1080p() {
+      let c480 = cost_cents(Some(CommonResolution::FourEightyP), 5, 1);
+      let c720 = cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1);
+      let c1080 = cost_cents(Some(CommonResolution::TenEightyP), 5, 1);
+      assert!(c480 < c720);
+      assert!(c720 < c1080);
+    }
+
+    #[test]
+    fn cost_scales_with_duration() {
+      let c4 = cost_cents(Some(CommonResolution::SevenTwentyP), 4, 1);
+      let c10 = cost_cents(Some(CommonResolution::SevenTwentyP), 10, 1);
+      let c15 = cost_cents(Some(CommonResolution::SevenTwentyP), 15, 1);
+      assert!(c4 < c10);
+      assert!(c10 < c15);
+    }
+
+    #[test]
+    fn cost_scales_with_batch() {
+      let b1 = cost_cents(Some(CommonResolution::TenEightyP), 5, 1);
+      let b2 = cost_cents(Some(CommonResolution::TenEightyP), 5, 2);
+      let b4 = cost_cents(Some(CommonResolution::TenEightyP), 5, 4);
+      assert!(b1 < b2);
+      assert!(b2 < b4);
+    }
+  }
+
+  // -- Credits equal cents --
+
+  mod credits_tests {
+    use super::*;
+
+    #[test]
+    fn credits_equal_usd_cents_all_combos() {
+      let resolutions = [
+        Some(CommonResolution::FourEightyP),
+        Some(CommonResolution::SevenTwentyP),
+        Some(CommonResolution::TenEightyP),
+        None,
+      ];
+      for res in resolutions {
+        for dur in [4, 5, 10, 15] {
+          for batch in [1, 2, 4] {
+            let cost = build_cost(res, dur, batch);
+            assert_eq!(
+              cost.cost_in_credits, cost.cost_in_usd_cents,
+              "credits should equal cents for res={:?} dur={}s batch={}",
+              res, dur, batch,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // -- Helpers --
+
+  fn build_cost(
+    resolution: Option<CommonResolution>,
+    duration_seconds: u16,
+    video_batch_count: u16,
+  ) -> crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate {
+    let builder = GenerateVideoRequestBuilder {
+      model: CommonVideoModel::PreviewModel,
+      provider: Provider::Artcraft,
+      resolution,
+      duration_seconds: Some(duration_seconds),
+      video_batch_count: Some(video_batch_count),
+      ..Default::default()
+    };
+    builder.build2()
+      .expect("build2 should succeed")
+      .estimate_cost()
+      .expect("estimate_cost should succeed")
+  }
+
+  fn cost_cents(
+    resolution: Option<CommonResolution>,
+    duration_seconds: u16,
+    video_batch_count: u16,
+  ) -> u64 {
+    build_cost(resolution, duration_seconds, video_batch_count)
+      .cost_in_usd_cents
+      .unwrap()
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model/mod.rs

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

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model/request.rs

@@ -0,0 +1,32 @@
+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 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,
+};
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftPreviewModelRequestState {
+  /// Final materialized request; ready to fire via the omni-gen video endpoint.
+  pub request: OmniGenVideoCostAndGenerateRequest,
+}
+
+impl ArtcraftPreviewModelRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+    let response = omni_gen_video_generate(
+      &client.api_host,
+      Some(&client.credentials),
+      self.request.clone(),
+    )
+      .await
+      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+    Ok(GenerateVideoResponse::Artcraft(ArtcraftVideoResponsePayload {
+      inference_job_token: response.inference_job_token.clone(),
+      all_inference_job_tokens: vec![response.inference_job_token],
+    }))
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model_fast/build.rs

@@ -0,0 +1,367 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest;
+use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
+use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::common_resolution::CommonResolution;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+use crate::generate::generate_video_v2::providers::artcraft::resolve::{
+  resolve_audio_list_ref, resolve_character_list_ref, resolve_image_list_ref,
+  resolve_image_ref, resolve_video_list_ref,
+};
+use crate::generate::generate_video_v2::providers::artcraft::preview_model_fast::request::ArtcraftPreviewModelFastRequestState;
+use crate::generate::generate_video_v2::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+use crate::generate::generate_video_v2::video_generation_request::VideoGenerationRequest;
+
+pub fn build_artcraft_preview_model_fast(mut builder: GenerateVideoRequestBuilder) -> Result<VideoGenerationDraftOrRequest, ArtcraftRouterError> {
+  let strategy = builder.request_mismatch_mitigation_strategy;
+
+  let aspect_ratio = plan_aspect_ratio(builder.aspect_ratio.take(), strategy)?;
+  let resolution = plan_output_resolution(builder.resolution.take(), strategy)?;
+  let batch_count = plan_batch_count(builder.video_batch_count.take(), strategy)?;
+  let duration_seconds = plan_duration(builder.duration_seconds.take(), strategy)?;
+  let prompt = builder.prompt.take();
+
+  let start_frame = resolve_image_ref(builder.start_frame.take())?;
+  let end_frame = resolve_image_ref(builder.end_frame.take())?;
+  let reference_images = resolve_image_list_ref(builder.reference_images.take())?;
+  let reference_videos = resolve_video_list_ref(builder.reference_videos.take())?;
+  let reference_audio = resolve_audio_list_ref(builder.reference_audio.take())?;
+  let reference_characters = resolve_character_list_ref(builder.reference_character_tokens.take());
+  let idempotency_token = builder.get_or_generate_idempotency_token();
+
+  let request = OmniGenVideoCostAndGenerateRequest {
+    model: Some(CommonVideoModelEnum::PreviewModelFast),
+    idempotency_token: Some(idempotency_token),
+    prompt,
+    start_frame_image_media_token: start_frame,
+    end_frame_image_media_token: end_frame,
+    reference_image_media_tokens: reference_images,
+    reference_video_media_tokens: reference_videos,
+    reference_audio_media_tokens: reference_audio,
+    reference_character_tokens: reference_characters,
+    resolution,
+    aspect_ratio,
+    duration_seconds: duration_seconds.map(|d| d as u16),
+    video_batch_count: Some(batch_count),
+    negative_prompt: None,
+    generate_audio: None,
+    quality: None,
+  };
+
+  let state = ArtcraftPreviewModelFastRequestState { request };
+  Ok(VideoGenerationDraftOrRequest::Request(VideoGenerationRequest::ArtcraftPreviewModelFast(state)))
+}
+
+// -- Plan helpers --
+
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<CommonAspectRatioEnum>, ArtcraftRouterError> {
+  match aspect_ratio {
+    None
+    | Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(None),
+
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => {
+      Ok(Some(CommonAspectRatioEnum::WideSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => {
+      Ok(Some(CommonAspectRatioEnum::TallNineBySixteen))
+    }
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => {
+      Ok(Some(CommonAspectRatioEnum::Square))
+    }
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(CommonAspectRatioEnum::WideFourByThree)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(CommonAspectRatioEnum::TallThreeByFour)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(CommonAspectRatioEnum::WideTwentyOneByNine)),
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> CommonAspectRatioEnum {
+  match aspect_ratio {
+    CommonAspectRatio::WideFiveByFour => CommonAspectRatioEnum::WideFourByThree,
+    CommonAspectRatio::WideThreeByTwo => CommonAspectRatioEnum::WideFourByThree,
+    CommonAspectRatio::TallFourByFive => CommonAspectRatioEnum::TallThreeByFour,
+    CommonAspectRatio::TallTwoByThree => CommonAspectRatioEnum::TallThreeByFour,
+    CommonAspectRatio::TallNineByTwentyOne => CommonAspectRatioEnum::TallNineBySixteen,
+    _ => CommonAspectRatioEnum::Square,
+  }
+}
+
+// PreviewModelFast supports output resolutions: 480p and 720p only.
+fn plan_output_resolution(
+  resolution: Option<CommonResolution>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<CommonResolutionEnum>, ArtcraftRouterError> {
+  match resolution {
+    None => Ok(None),
+
+    Some(CommonResolution::FourEightyP) => Ok(Some(CommonResolutionEnum::FourEightyP)),
+    Some(CommonResolution::SevenTwentyP) => Ok(Some(CommonResolutionEnum::SevenTwentyP)),
+
+    // 1080p not supported for Fast
+    Some(CommonResolution::TenEightyP) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", CommonResolution::TenEightyP),
+        }))
+      }
+      _ => Ok(Some(CommonResolutionEnum::SevenTwentyP)),
+    },
+
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "resolution",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => {
+        Ok(Some(match unsupported {
+          CommonResolution::HalfK => CommonResolutionEnum::FourEightyP,
+          _ => CommonResolutionEnum::SevenTwentyP,
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(match unsupported {
+          CommonResolution::HalfK => CommonResolutionEnum::FourEightyP,
+          _ => CommonResolutionEnum::SevenTwentyP,
+        }))
+      }
+    },
+  }
+}
+
+// Batch counts: 1, 2, 4.
+fn plan_batch_count(
+  video_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<u16, ArtcraftRouterError> {
+  let count = video_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 | 2 | 4 => Ok(count),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "video_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(4),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(if count < 4 { 2 } else { 4 })
+      }
+    },
+  }
+}
+
+// Duration: 4-15 seconds.
+fn plan_duration(
+  duration_seconds: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<u8>, ArtcraftRouterError> {
+  const MIN: u16 = 4;
+  const MAX: u16 = 15;
+  match duration_seconds {
+    None => Ok(None),
+    Some(d) if d >= MIN && d <= MAX => Ok(Some(d as u8)),
+    Some(d) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "duration_seconds",
+          value: format!("{}", d),
+        }))
+      }
+      _ => Ok(Some(d.clamp(MIN, MAX) as u8)),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use enums::common::generation::common_video_model::CommonVideoModel as CommonVideoModelEnum;
+  use tokens::tokens::characters::CharacterToken;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::character_list_ref::CharacterListRef;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::common_video_model::CommonVideoModel;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::image_ref::ImageRef;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+  use crate::generate::generate_video_v2::video_generation_draft_or_request::VideoGenerationDraftOrRequest;
+  use crate::generate::generate_video_v2::video_generation_request::VideoGenerationRequest;
+
+  use super::*;
+
+  // ── Field conversions ──
+
+  mod field_conversions {
+    use super::*;
+
+    #[test]
+    fn model_is_preview_model_fast() {
+      let req = unwrap_request(make_builder(|_| {}));
+      assert!(matches!(req.request.model, Some(CommonVideoModelEnum::PreviewModelFast)));
+    }
+
+    #[test]
+    fn prompt_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.prompt = Some("test".to_string()); }));
+      assert_eq!(req.request.prompt, Some("test".to_string()));
+    }
+
+    #[test]
+    fn duration_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(10); }));
+      assert_eq!(req.request.duration_seconds, Some(10));
+    }
+
+    #[test]
+    fn duration_clamped_to_max() {
+      let req = unwrap_request(make_builder(|b| { b.duration_seconds = Some(99); }));
+      assert_eq!(req.request.duration_seconds, Some(15));
+    }
+
+    #[test]
+    fn batch_count_passed_through() {
+      let req = unwrap_request(make_builder(|b| { b.video_batch_count = Some(4); }));
+      assert_eq!(req.request.video_batch_count, Some(4));
+    }
+  }
+
+  // ── Resolution ──
+
+  mod resolution_tests {
+    use super::*;
+
+    #[test]
+    fn res_480p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::FourEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::FourEightyP));
+    }
+
+    #[test]
+    fn res_720p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::SevenTwentyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
+    }
+
+    #[test]
+    fn res_1080p_downgrades_to_720p() {
+      let req = unwrap_request(make_builder(|b| { b.resolution = Some(CommonResolution::TenEightyP); }));
+      assert_eq!(req.request.resolution, Some(CommonResolutionEnum::SevenTwentyP));
+    }
+
+    #[test]
+    fn res_1080p_error_out() {
+      let result = build_artcraft_preview_model_fast(GenerateVideoRequestBuilder {
+        model: CommonVideoModel::PreviewModelFast,
+        provider: Provider::Artcraft,
+        resolution: Some(CommonResolution::TenEightyP),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..Default::default()
+      });
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn none_stays_none() {
+      let req = unwrap_request(make_builder(|_| {}));
+      assert!(req.request.resolution.is_none());
+    }
+  }
+
+  // ── Media tokens ──
+
+  mod media_token_tests {
+    use super::*;
+
+    #[test]
+    fn start_frame_token_passed_through() {
+      let token = MediaFileToken::new("mf_start".to_string());
+      let req = unwrap_request(make_builder(|b| {
+        b.start_frame = Some(ImageRef::MediaFileToken(token.clone()));
+      }));
+      assert_eq!(req.request.start_frame_image_media_token, Some(token));
+    }
+
+    #[test]
+    fn url_start_frame_rejected() {
+      let result = build_artcraft_preview_model_fast(GenerateVideoRequestBuilder {
+        model: CommonVideoModel::PreviewModelFast,
+        provider: Provider::Artcraft,
+        start_frame: Some(ImageRef::Url("https://example.com".to_string())),
+        ..Default::default()
+      });
+      assert!(result.is_err());
+    }
+
+    #[test]
+    fn reference_image_tokens_passed_through() {
+      let tokens = vec![MediaFileToken::new("mf_a".to_string()), MediaFileToken::new("mf_b".to_string())];
+      let req = unwrap_request(make_builder(|b| {
+        b.reference_images = Some(ImageListRef::MediaFileTokens(tokens.clone()));
+      }));
+      assert_eq!(req.request.reference_image_media_tokens, Some(tokens));
+    }
+
+    #[test]
+    fn character_tokens_passed_through() {
+      let tokens = vec![CharacterToken::new("char_a".to_string()), CharacterToken::new("char_b".to_string())];
+      let req = unwrap_request(make_builder(|b| {
+        b.reference_character_tokens = Some(CharacterListRef::CharacterTokens(tokens.clone()));
+      }));
+      assert_eq!(req.request.reference_character_tokens, Some(tokens));
+    }
+  }
+
+  // ── Helpers ──
+
+  fn make_builder(f: impl FnOnce(&mut GenerateVideoRequestBuilder)) -> GenerateVideoRequestBuilder {
+    let mut builder = GenerateVideoRequestBuilder {
+      model: CommonVideoModel::PreviewModelFast,
+      provider: Provider::Artcraft,
+      duration_seconds: Some(5),
+      video_batch_count: Some(1),
+      ..Default::default()
+    };
+    f(&mut builder);
+    builder
+  }
+
+  fn unwrap_request(builder: GenerateVideoRequestBuilder) -> ArtcraftPreviewModelFastRequestState {
+    let result = build_artcraft_preview_model_fast(builder).expect("build should succeed");
+    match result {
+      VideoGenerationDraftOrRequest::Request(
+        VideoGenerationRequest::ArtcraftPreviewModelFast(state)
+      ) => state,
+      _ => panic!("expected ArtcraftPreviewModelFast request"),
+    }
+  }
+}

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

@@ -0,0 +1,203 @@
+use enums::common::generation::common_resolution::CommonResolution;
+
+use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model_fast::request::ArtcraftPreviewModelFastRequestState;
+
+// ── Pricing constants ──
+//
+// ArtCraft credits: 100 credits = $1.00. Credits always equal USD cents.
+
+/// USD cents per second by resolution:
+///   480p:  $0.09/s = 9.0 ¢/s
+///   720p:  $0.20/s = 20.0 ¢/s
+const CENTS_PER_SECOND_480P: f64 = 9.0;
+const CENTS_PER_SECOND_720P: f64 = 20.0;
+
+pub struct ArtcraftPreviewModelFastCostState {
+  pub resolution: CommonResolution,
+  pub duration_seconds: u16,
+  pub batch_count: u16,
+}
+
+impl ArtcraftPreviewModelFastCostState {
+  pub fn from_request(request: &ArtcraftPreviewModelFastRequestState) -> Self {
+    let resolution = request.request.resolution
+      .unwrap_or(CommonResolution::SevenTwentyP);
+    let duration_seconds = request.request.duration_seconds.unwrap_or(5);
+    let batch_count = request.request.video_batch_count.unwrap_or(1);
+
+    Self { resolution, duration_seconds, batch_count }
+  }
+
+  pub fn estimate_cost(&self) -> VideoGenerationCostEstimate {
+    let cents_per_second = match self.resolution {
+      CommonResolution::FourEightyP => CENTS_PER_SECOND_480P,
+      // Everything else (including 720p and unsupported resolutions) prices at 720p.
+      _ => CENTS_PER_SECOND_720P,
+    };
+
+    let usd_cents = (self.duration_seconds as f64 * cents_per_second * self.batch_count as f64).round() as u64;
+
+    VideoGenerationCostEstimate {
+      cost_in_credits: Some(usd_cents),
+      cost_in_usd_cents: Some(usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::common_video_model::CommonVideoModel;
+  use crate::api::provider::Provider;
+  use crate::generate::generate_video::generate_video_request_builder::GenerateVideoRequestBuilder;
+
+  // -- 720p pricing --
+
+  mod pricing_720p {
+    use super::*;
+
+    #[test]
+    fn batch_1() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 4, 1), 80);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1), 100);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 10, 1), 200);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 1), 300);
+    }
+
+    #[test]
+    fn batch_2() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 2), 200);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 2), 600);
+    }
+
+    #[test]
+    fn batch_4() {
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 5, 4), 400);
+      assert_eq!(cost_cents(Some(CommonResolution::SevenTwentyP), 15, 4), 1200);
+    }
+
+    #[test]
+    fn none_defaults_to_720p() {
+      assert_eq!(cost_cents(None, 5, 1), cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1));
+    }
+  }
+
+  // -- 480p pricing --
+
+  mod pricing_480p {
+    use super::*;
+
+    #[test]
+    fn batch_1() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 4, 1), 36);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 1), 45);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 10, 1), 90);
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 15, 1), 135);
+    }
+
+    #[test]
+    fn batch_2() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 2), 90);
+    }
+
+    #[test]
+    fn batch_4() {
+      assert_eq!(cost_cents(Some(CommonResolution::FourEightyP), 5, 4), 180);
+    }
+  }
+
+  // -- Relative pricing --
+
+  mod relative_pricing_tests {
+    use super::*;
+
+    #[test]
+    fn cost_480p_cheaper_than_720p() {
+      let c480 = cost_cents(Some(CommonResolution::FourEightyP), 5, 1);
+      let c720 = cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1);
+      assert!(c480 < c720);
+    }
+
+    #[test]
+    fn cost_scales_with_duration() {
+      let c4 = cost_cents(Some(CommonResolution::SevenTwentyP), 4, 1);
+      let c10 = cost_cents(Some(CommonResolution::SevenTwentyP), 10, 1);
+      let c15 = cost_cents(Some(CommonResolution::SevenTwentyP), 15, 1);
+      assert!(c4 < c10);
+      assert!(c10 < c15);
+    }
+
+    #[test]
+    fn cost_scales_with_batch() {
+      let b1 = cost_cents(Some(CommonResolution::SevenTwentyP), 5, 1);
+      let b2 = cost_cents(Some(CommonResolution::SevenTwentyP), 5, 2);
+      let b4 = cost_cents(Some(CommonResolution::SevenTwentyP), 5, 4);
+      assert!(b1 < b2);
+      assert!(b2 < b4);
+    }
+  }
+
+  // -- Credits equal cents --
+
+  mod credits_tests {
+    use super::*;
+
+    #[test]
+    fn credits_equal_usd_cents_all_combos() {
+      let resolutions = [
+        Some(CommonResolution::FourEightyP),
+        Some(CommonResolution::SevenTwentyP),
+        None,
+      ];
+      for res in resolutions {
+        for dur in [4, 5, 10, 15] {
+          for batch in [1, 2, 4] {
+            let cost = build_cost(res, dur, batch);
+            assert_eq!(
+              cost.cost_in_credits, cost.cost_in_usd_cents,
+              "credits should equal cents for res={:?} dur={}s batch={}",
+              res, dur, batch,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  // -- Helpers --
+
+  fn build_cost(
+    resolution: Option<CommonResolution>,
+    duration_seconds: u16,
+    video_batch_count: u16,
+  ) -> crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate {
+    let builder = GenerateVideoRequestBuilder {
+      model: CommonVideoModel::PreviewModelFast,
+      provider: Provider::Artcraft,
+      resolution,
+      duration_seconds: Some(duration_seconds),
+      video_batch_count: Some(video_batch_count),
+      ..Default::default()
+    };
+    builder.build2()
+      .expect("build2 should succeed")
+      .estimate_cost()
+      .expect("estimate_cost should succeed")
+  }
+
+  fn cost_cents(
+    resolution: Option<CommonResolution>,
+    duration_seconds: u16,
+    video_batch_count: u16,
+  ) -> u64 {
+    build_cost(resolution, duration_seconds, video_batch_count)
+      .cost_in_usd_cents
+      .unwrap()
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model_fast/mod.rs

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

crates/api_clients/artcraft/artcraft_router/src/generate/generate_video_v2/providers/artcraft/preview_model_fast/request.rs

@@ -0,0 +1,32 @@
+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 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,
+};
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftPreviewModelFastRequestState {
+  /// Final materialized request; ready to fire via the omni-gen video endpoint.
+  pub request: OmniGenVideoCostAndGenerateRequest,
+}
+
+impl ArtcraftPreviewModelFastRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateVideoResponse, ArtcraftRouterError> {
+    let response = omni_gen_video_generate(
+      &client.api_host,
+      Some(&client.credentials),
+      self.request.clone(),
+    )
+      .await
+      .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+    Ok(GenerateVideoResponse::Artcraft(ArtcraftVideoResponsePayload {
+      inference_job_token: response.inference_job_token.clone(),
+      all_inference_job_tokens: vec![response.inference_job_token],
+    }))
+  }
+}

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

@@ -5,6 +5,10 @@ use crate::generate::generate_video::generate_video_response::GenerateVideoRespo
 use crate::generate::generate_video::video_generation_cost_estimate::VideoGenerationCostEstimate;
 use crate::generate::generate_video_v2::providers::artcraft::happy_horse_1p0::cost::ArtcraftHappyHorse1p0CostState;
 use crate::generate::generate_video_v2::providers::artcraft::happy_horse_1p0::request::ArtcraftHappyHorse1p0RequestState;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model::cost::ArtcraftPreviewModelCostState;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model::request::ArtcraftPreviewModelRequestState;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model_fast::cost::ArtcraftPreviewModelFastCostState;
+use crate::generate::generate_video_v2::providers::artcraft::preview_model_fast::request::ArtcraftPreviewModelFastRequestState;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0::cost::ArtcraftSeedance2p0CostState;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0::request::ArtcraftSeedance2p0RequestState;
 use crate::generate::generate_video_v2::providers::artcraft::seedance_2p0_fast::cost::ArtcraftSeedance2p0FastCostState;
@@ -27,6 +31,8 @@ use crate::generate::generate_video_v2::providers::kinovi::seedance_2p0_fast::re
 #[derive(Clone, Debug)]
 pub enum VideoGenerationRequest {
   ArtcraftHappyHorse1p0(ArtcraftHappyHorse1p0RequestState),
+  ArtcraftPreviewModel(ArtcraftPreviewModelRequestState),
+  ArtcraftPreviewModelFast(ArtcraftPreviewModelFastRequestState),
   ArtcraftSeedance2p0(ArtcraftSeedance2p0RequestState),
   ArtcraftSeedance2p0Fast(ArtcraftSeedance2p0FastRequestState),
   ArtcraftSeedance2p0G(ArtcraftSeedance2p0GRequestState),
@@ -43,6 +49,8 @@ impl VideoGenerationRequest {
   pub fn get_provider(&self) -> Provider {
     match self {
       Self::ArtcraftHappyHorse1p0(_) => Provider::Artcraft,
+      Self::ArtcraftPreviewModel(_) => Provider::Artcraft,
+      Self::ArtcraftPreviewModelFast(_) => Provider::Artcraft,
       Self::ArtcraftSeedance2p0(_) => Provider::Artcraft,
       Self::ArtcraftSeedance2p0Fast(_) => Provider::Artcraft,
       Self::ArtcraftSeedance2p0G(_) => Provider::Artcraft,
@@ -59,6 +67,8 @@ impl VideoGenerationRequest {
   pub fn estimate_cost(&self) -> Result<VideoGenerationCostEstimate, ArtcraftRouterError> {
     match self {
       VideoGenerationRequest::ArtcraftHappyHorse1p0(request) => Ok(ArtcraftHappyHorse1p0CostState::from_request(request).estimate_cost()),
+      VideoGenerationRequest::ArtcraftPreviewModel(request) => Ok(ArtcraftPreviewModelCostState::from_request(request).estimate_cost()),
+      VideoGenerationRequest::ArtcraftPreviewModelFast(request) => Ok(ArtcraftPreviewModelFastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0(request) => Ok(ArtcraftSeedance2p0CostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0Fast(request) => Ok(ArtcraftSeedance2p0FastCostState::from_request(request).estimate_cost()),
       VideoGenerationRequest::ArtcraftSeedance2p0G(request) => Ok(ArtcraftSeedance2p0GCostState::from_request(request).estimate_cost()),
@@ -79,6 +89,14 @@ impl VideoGenerationRequest {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await
       },
+      VideoGenerationRequest::ArtcraftPreviewModel(request) => {
+        let client_ref = client.get_artcraft_client_ref()?;
+        request.send(client_ref).await
+      },
+      VideoGenerationRequest::ArtcraftPreviewModelFast(request) => {
+        let client_ref = client.get_artcraft_client_ref()?;
+        request.send(client_ref).await
+      },
       VideoGenerationRequest::ArtcraftSeedance2p0(request) => {
         let client_ref = client.get_artcraft_client_ref()?;
         request.send(client_ref).await

crates/schema/database/mysql_queries/src/queries/generic_inference/seedance2pro/insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token.rs

@@ -22,6 +22,9 @@ use crate::payloads::generic_inference_args::generic_inference_args::GenericInfe
 pub struct InsertGenericInferenceForSeedance2ProWithAprioriJobTokenArgs<'e, 'c, E>
   where E: 'e + Executor<'c, Database = MySql>
 {
+  /// Which kinovi queue to use: standard or alternate
+  pub use_alternate_kinovi: bool,
+
   pub uuid_idempotency_token: &'e str,
 
   // NOTE: We'll generate this ahead of time so we can save it with billing info!
@@ -56,12 +59,23 @@ pub async fn insert_generic_inference_job_for_seedance2pro_queue_with_apriori_jo
   let serialized_args_payload = serde_json::ser::to_string(&args.maybe_inference_args)
       .map_err(|_e| anyhow!("could not encode inference args"))?;
 
-  const JOB_TYPE: InferenceJobType = InferenceJobType::Seedance2ProQueue;
   const INFERENCE_CATEGORY: InferenceCategory = InferenceCategory::VideoGeneration;
-  const PRODUCT_CATEGORY: InferenceJobProductCategory = InferenceJobProductCategory::Seedance2ProVideo;
-  const EXTERNAL_THIRD_PARTY: InferenceJobExternalThirdParty = InferenceJobExternalThirdParty::Seedance2Pro;
   const STATUS: JobStatusPlus = JobStatusPlus::Pending;
 
+  let job_type;
+  let external_third_party;
+  let product_category;
+
+  if args.use_alternate_kinovi {
+    job_type = InferenceJobType::Seedance2ProAltQueue;
+    external_third_party = InferenceJobExternalThirdParty::Seedance2ProAlt;
+    product_category = InferenceJobProductCategory::Seedance2ProVideoAlt;
+  } else {
+    job_type = InferenceJobType::Seedance2ProQueue;
+    external_third_party = InferenceJobExternalThirdParty::Seedance2Pro;
+    product_category = InferenceJobProductCategory::Seedance2ProVideo;
+  }
+
   let query = sqlx::query!(
         r#"
 INSERT INTO generic_inference_jobs
@@ -113,12 +127,12 @@ SET
         args.apriori_job_token.as_str(),
         args.uuid_idempotency_token,
 
-        JOB_TYPE.to_str(),
+        job_type.to_str(),
 
-        EXTERNAL_THIRD_PARTY.to_str(),
+        external_third_party.to_str(),
         args.maybe_external_third_party_id,
 
-        PRODUCT_CATEGORY.to_str(),
+        product_category.to_str(),
         INFERENCE_CATEGORY.to_str(),
 
         args.maybe_prompt_token.map(|t| t.to_string()),

crates/schema/database/mysql_queries/src/queries/generic_inference/seedance2pro/list_pending_seedance2pro_video_jobs.rs

@@ -41,7 +41,11 @@ struct RawRecord {
 }
 
 /// Returns all non-terminal Seedance2Pro video jobs that have an associated order_id.
-pub async fn list_pending_seedance2pro_video_jobs(pool: &MySqlPool) -> Result<Vec<PendingSeedance2ProJob>, sqlx::Error> {
+pub async fn list_pending_seedance2pro_video_jobs(
+  pool: &MySqlPool,
+  external_third_party: InferenceJobExternalThirdParty,
+  job_type: InferenceJobType,
+) -> Result<Vec<PendingSeedance2ProJob>, sqlx::Error> {
   let records = sqlx::query_as!(
     RawRecord,
     r#"
@@ -64,8 +68,8 @@ WHERE jobs.maybe_external_third_party = ?
 
 LIMIT 25000
     "#,
-    InferenceJobExternalThirdParty::Seedance2Pro.to_str(),
-    InferenceJobType::Seedance2ProQueue.to_str(),
+    external_third_party.to_str(),
+    job_type.to_str(),
   )
     .fetch_all(pool)
     .await?;

crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_external_third_party.rs

@@ -29,6 +29,10 @@ pub enum InferenceJobExternalThirdParty {
   #[serde(rename = "seedance2pro")]
   Seedance2Pro,
 
+  /// Seedance 2 Pro Alt jobs
+  #[serde(rename = "seedance2pro_alt")]
+  Seedance2ProAlt,
+
   /// World Labs jobs
   #[serde(rename = "worldlabs")]
   Worldlabs,
@@ -46,6 +50,7 @@ impl InferenceJobExternalThirdParty {
       Self::Fal => "fal",
       Self::GmiCloud => "gmicloud",
       Self::Seedance2Pro => "seedance2pro",
+      Self::Seedance2ProAlt => "seedance2pro_alt",
       Self::Worldlabs => "worldlabs",
     }
   }
@@ -56,6 +61,7 @@ impl InferenceJobExternalThirdParty {
       "fal" => Ok(Self::Fal),
       "gmicloud" => Ok(Self::GmiCloud),
       "seedance2pro" => Ok(Self::Seedance2Pro),
+      "seedance2pro_alt" => Ok(Self::Seedance2ProAlt),
       "worldlabs" => Ok(Self::Worldlabs),
       _ => Err(format!("invalid value: {:?}", value)),
     }
@@ -69,6 +75,7 @@ impl InferenceJobExternalThirdParty {
       Self::Fal,
       Self::GmiCloud,
       Self::Seedance2Pro,
+      Self::Seedance2ProAlt,
       Self::Worldlabs,
     ])
   }
@@ -88,6 +95,7 @@ mod tests {
       assert_serialization(InferenceJobExternalThirdParty::Fal, "fal");
       assert_serialization(InferenceJobExternalThirdParty::GmiCloud, "gmicloud");
       assert_serialization(InferenceJobExternalThirdParty::Seedance2Pro, "seedance2pro");
+      assert_serialization(InferenceJobExternalThirdParty::Seedance2ProAlt, "seedance2pro_alt");
       assert_serialization(InferenceJobExternalThirdParty::Worldlabs, "worldlabs");
     }
 
@@ -97,6 +105,7 @@ mod tests {
       assert_eq!(InferenceJobExternalThirdParty::Fal.to_str(), "fal");
       assert_eq!(InferenceJobExternalThirdParty::GmiCloud.to_str(), "gmicloud");
       assert_eq!(InferenceJobExternalThirdParty::Seedance2Pro.to_str(), "seedance2pro");
+      assert_eq!(InferenceJobExternalThirdParty::Seedance2ProAlt.to_str(), "seedance2pro_alt");
       assert_eq!(InferenceJobExternalThirdParty::Worldlabs.to_str(), "worldlabs");
     }
 
@@ -106,13 +115,14 @@ mod tests {
       assert_eq!(InferenceJobExternalThirdParty::from_str("fal").unwrap(), InferenceJobExternalThirdParty::Fal);
       assert_eq!(InferenceJobExternalThirdParty::from_str("gmicloud").unwrap(), InferenceJobExternalThirdParty::GmiCloud);
       assert_eq!(InferenceJobExternalThirdParty::from_str("seedance2pro").unwrap(), InferenceJobExternalThirdParty::Seedance2Pro);
+      assert_eq!(InferenceJobExternalThirdParty::from_str("seedance2pro_alt").unwrap(), InferenceJobExternalThirdParty::Seedance2ProAlt);
       assert_eq!(InferenceJobExternalThirdParty::from_str("worldlabs").unwrap(), InferenceJobExternalThirdParty::Worldlabs);
     }
 
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 5;
+      const EXPECTED_COUNT : usize = 6;
       
       assert_eq!(InferenceJobExternalThirdParty::all_variants().len(), EXPECTED_COUNT);
       assert_eq!(InferenceJobExternalThirdParty::iter().len(), EXPECTED_COUNT);

crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_product_category.rs

@@ -48,6 +48,11 @@ pub enum InferenceJobProductCategory {
   #[serde(rename = "seedance2pro_character")]
   Seedance2ProCharacter,
 
+  // =============== SEEDANCE 2 PRO ALT ===============
+
+  #[serde(rename = "seedance2pro_video_alt")]
+  Seedance2ProVideoAlt,
+
   // =============== WORLD LABS ===============
 
   /// World Labs: Gaussian Splat Generation
@@ -153,6 +158,7 @@ impl InferenceJobProductCategory {
       Self::BeebleVideo => "beeble_video",
       Self::Seedance2ProVideo => "seedance2pro_video",
       Self::Seedance2ProCharacter => "seedance2pro_character",
+      Self::Seedance2ProVideoAlt => "seedance2pro_video_alt",
       Self::WorldlabsSplat => "worldlabs_splat",
       Self::TtsGptSoVits => "tts_gpt_so_vits",
       Self::TtsStyleTts2 => "tts_style_tts2",
@@ -190,6 +196,7 @@ impl InferenceJobProductCategory {
       "beeble_video" => Ok(Self::BeebleVideo),
       "seedance2pro_video" => Ok(Self::Seedance2ProVideo),
       "seedance2pro_character" => Ok(Self::Seedance2ProCharacter),
+      "seedance2pro_video_alt" => Ok(Self::Seedance2ProVideoAlt),
       "worldlabs_splat" => Ok(Self::WorldlabsSplat),
       "tts_gpt_so_vits" => Ok(Self::TtsGptSoVits),
       "tts_style_tts2" => Ok(Self::TtsStyleTts2),
@@ -230,6 +237,7 @@ impl InferenceJobProductCategory {
       Self::BeebleVideo,
       Self::Seedance2ProVideo,
       Self::Seedance2ProCharacter,
+      Self::Seedance2ProVideoAlt,
       Self::WorldlabsSplat,
       Self::TtsGptSoVits,
       Self::TtsStyleTts2,
@@ -276,6 +284,7 @@ mod tests {
       assert_serialization(InferenceJobProductCategory::BeebleVideo, "beeble_video");
       assert_serialization(InferenceJobProductCategory::Seedance2ProVideo, "seedance2pro_video");
       assert_serialization(InferenceJobProductCategory::Seedance2ProCharacter, "seedance2pro_character");
+      assert_serialization(InferenceJobProductCategory::Seedance2ProVideoAlt, "seedance2pro_video_alt");
       assert_serialization(InferenceJobProductCategory::WorldlabsSplat, "worldlabs_splat");
       assert_serialization(InferenceJobProductCategory::TtsGptSoVits, "tts_gpt_so_vits");
       assert_serialization(InferenceJobProductCategory::TtsStyleTts2, "tts_style_tts2");
@@ -312,6 +321,7 @@ mod tests {
       assert_eq!(InferenceJobProductCategory::BeebleVideo.to_str(), "beeble_video");
       assert_eq!(InferenceJobProductCategory::Seedance2ProVideo.to_str(), "seedance2pro_video");
       assert_eq!(InferenceJobProductCategory::Seedance2ProCharacter.to_str(), "seedance2pro_character");
+      assert_eq!(InferenceJobProductCategory::Seedance2ProVideoAlt.to_str(), "seedance2pro_video_alt");
       assert_eq!(InferenceJobProductCategory::WorldlabsSplat.to_str(), "worldlabs_splat");
       assert_eq!(InferenceJobProductCategory::TtsGptSoVits.to_str(), "tts_gpt_so_vits");
       assert_eq!(InferenceJobProductCategory::TtsStyleTts2.to_str(), "tts_style_tts2");
@@ -347,6 +357,7 @@ mod tests {
       assert_eq!(InferenceJobProductCategory::from_str("beeble_video").unwrap(), InferenceJobProductCategory::BeebleVideo);
       assert_eq!(InferenceJobProductCategory::from_str("seedance2pro_video").unwrap(), InferenceJobProductCategory::Seedance2ProVideo);
       assert_eq!(InferenceJobProductCategory::from_str("seedance2pro_character").unwrap(), InferenceJobProductCategory::Seedance2ProCharacter);
+      assert_eq!(InferenceJobProductCategory::from_str("seedance2pro_video_alt").unwrap(), InferenceJobProductCategory::Seedance2ProVideoAlt);
       assert_eq!(InferenceJobProductCategory::from_str("worldlabs_splat").unwrap(), InferenceJobProductCategory::WorldlabsSplat);
       assert_eq!(InferenceJobProductCategory::from_str("tts_gpt_so_vits").unwrap(), InferenceJobProductCategory::TtsGptSoVits);
       assert_eq!(InferenceJobProductCategory::from_str("tts_style_tts2").unwrap(), InferenceJobProductCategory::TtsStyleTts2);
@@ -374,7 +385,7 @@ mod tests {
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 32;
+      const EXPECTED_COUNT : usize = 33;
 
       assert_eq!(InferenceJobProductCategory::all_variants().len(), EXPECTED_COUNT);
       assert_eq!(InferenceJobProductCategory::iter().len(), EXPECTED_COUNT);

crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_job_type.rs

@@ -31,6 +31,10 @@ pub enum InferenceJobType {
   #[serde(rename = "seedance2pro_character")]
   Seedance2ProCharacter,
 
+  /// Seedance 2 Pro Alt jobs. We poll for results.
+  #[serde(rename = "seedance2pro_alt_queue")]
+  Seedance2ProAltQueue,
+
   /// Beeble jobs. We poll for results.
   #[serde(rename = "beeble_queue")]
   BeebleQueue,
@@ -133,6 +137,7 @@ impl InferenceJobType {
       Self::GmiCloudQueue => "gmicloud_queue",
       Self::BeebleQueue => "beeble_queue",
       Self::Seedance2ProQueue => "seedance2pro_queue",
+      Self::Seedance2ProAltQueue => "seedance2pro_alt_queue",
       Self::Seedance2ProCharacter => "seedance2pro_character",
       Self::WorldlabsQueue => "worldlabs_queue",
       Self::VideoRender => "video_render",
@@ -165,6 +170,7 @@ impl InferenceJobType {
       "beeble_queue" => Ok(Self::BeebleQueue),
       "seedance2pro_queue" => Ok(Self::Seedance2ProQueue),
       "seedance2pro_character" => Ok(Self::Seedance2ProCharacter),
+      "seedance2pro_alt_queue" => Ok(Self::Seedance2ProAltQueue),
       "worldlabs_queue" => Ok(Self::WorldlabsQueue),
       "video_render" => Ok(Self::VideoRender),
       "live_portrait" => Ok(Self::LivePortrait),
@@ -199,6 +205,7 @@ impl InferenceJobType {
       Self::BeebleQueue,
       Self::Seedance2ProQueue,
       Self::Seedance2ProCharacter,
+      Self::Seedance2ProAltQueue,
       Self::WorldlabsQueue,
       Self::VideoRender,
       Self::LivePortrait,
@@ -244,6 +251,7 @@ mod tests {
       assert_serialization(InferenceJobType::BeebleQueue, "beeble_queue");
       assert_serialization(InferenceJobType::Seedance2ProQueue, "seedance2pro_queue");
       assert_serialization(InferenceJobType::Seedance2ProCharacter, "seedance2pro_character");
+      assert_serialization(InferenceJobType::Seedance2ProAltQueue, "seedance2pro_alt_queue");
       assert_serialization(InferenceJobType::WorldlabsQueue, "worldlabs_queue");
       assert_serialization(InferenceJobType::VideoRender, "video_render");
       assert_serialization(InferenceJobType::LivePortrait, "live_portrait");
@@ -274,6 +282,7 @@ mod tests {
       assert_eq!(InferenceJobType::BeebleQueue.to_str(), "beeble_queue");
       assert_eq!(InferenceJobType::Seedance2ProQueue.to_str(), "seedance2pro_queue");
       assert_eq!(InferenceJobType::Seedance2ProCharacter.to_str(), "seedance2pro_character");
+      assert_eq!(InferenceJobType::Seedance2ProAltQueue.to_str(), "seedance2pro_alt_queue");
       assert_eq!(InferenceJobType::WorldlabsQueue.to_str(), "worldlabs_queue");
       assert_eq!(InferenceJobType::VideoRender.to_str(), "video_render");
       assert_eq!(InferenceJobType::LivePortrait.to_str(), "live_portrait");
@@ -304,6 +313,7 @@ mod tests {
       assert_eq!(InferenceJobType::from_str("beeble_queue").unwrap(), InferenceJobType::BeebleQueue);
       assert_eq!(InferenceJobType::from_str("seedance2pro_queue").unwrap(), InferenceJobType::Seedance2ProQueue);
       assert_eq!(InferenceJobType::from_str("seedance2pro_character").unwrap(), InferenceJobType::Seedance2ProCharacter);
+      assert_eq!(InferenceJobType::from_str("seedance2pro_alt_queue").unwrap(), InferenceJobType::Seedance2ProAltQueue);
       assert_eq!(InferenceJobType::from_str("worldlabs_queue").unwrap(), InferenceJobType::WorldlabsQueue);
       assert_eq!(InferenceJobType::from_str("video_render").unwrap(), InferenceJobType::VideoRender);
       assert_eq!(InferenceJobType::from_str("live_portrait").unwrap(), InferenceJobType::LivePortrait);
@@ -330,7 +340,7 @@ mod tests {
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 26;
+      const EXPECTED_COUNT : usize = 27;
       
       assert_eq!(InferenceJobType::all_variants().len(), EXPECTED_COUNT);
       assert_eq!(InferenceJobType::iter().len(), EXPECTED_COUNT);

crates/schema/public/enums/src/common/generation/common_model_type.rs

@@ -148,6 +148,10 @@ pub enum CommonModelType {
   Veo3p1,
   #[serde(rename = "veo_3p1_fast")]
   Veo3p1Fast,
+  #[serde(rename = "preview_model")]
+  PreviewModel,
+  #[serde(rename = "preview_model_fast")]
+  PreviewModelFast,
   #[serde(rename = "switch_x")]
   SwitchX,
 
@@ -232,6 +236,8 @@ impl CommonModelType {
       Self::Veo3Fast => "veo_3_fast",
       Self::Veo3p1 => "veo_3p1",
       Self::Veo3p1Fast => "veo_3p1_fast",
+      Self::PreviewModel => "preview_model",
+      Self::PreviewModelFast => "preview_model_fast",
       Self::SwitchX => "switch_x",
 
       // 3D Object generation models
@@ -304,6 +310,8 @@ impl CommonModelType {
       "veo_3_fast" => Ok(Self::Veo3Fast),
       "veo_3p1" => Ok(Self::Veo3p1),
       "veo_3p1_fast" => Ok(Self::Veo3p1Fast),
+      "preview_model" => Ok(Self::PreviewModel),
+      "preview_model_fast" => Ok(Self::PreviewModelFast),
       "switch_x" => Ok(Self::SwitchX),
 
       // 3D Object generation models
@@ -380,6 +388,8 @@ impl CommonModelType {
       Self::Veo3Fast,
       Self::Veo3p1,
       Self::Veo3p1Fast,
+      Self::PreviewModel,
+      Self::PreviewModelFast,
       Self::SwitchX,
 
       // 3D Object generation models
@@ -453,6 +463,8 @@ impl CommonModelType {
       Self::Veo3Fast => CommonModelClass::Video,
       Self::Veo3p1 => CommonModelClass::Video,
       Self::Veo3p1Fast => CommonModelClass::Video,
+      Self::PreviewModel => CommonModelClass::Video,
+      Self::PreviewModelFast => CommonModelClass::Video,
       Self::SwitchX => CommonModelClass::Video,
 
       // 3D Object generation models (mesh)
@@ -535,6 +547,8 @@ mod tests {
       assert_serialization(CommonModelType::Veo3Fast, "veo_3_fast");
       assert_serialization(CommonModelType::Veo3p1, "veo_3p1");
       assert_serialization(CommonModelType::Veo3p1Fast, "veo_3p1_fast");
+      assert_serialization(CommonModelType::PreviewModel, "preview_model");
+      assert_serialization(CommonModelType::PreviewModelFast, "preview_model_fast");
       assert_serialization(CommonModelType::SwitchX, "switch_x");
       // 3D Object generation models
       assert_serialization(CommonModelType::Hunyuan3d2_0, "hunyuan_3d_2p0");
@@ -604,6 +618,8 @@ mod tests {
       assert_eq!(CommonModelType::Veo3Fast.to_str(), "veo_3_fast");
       assert_eq!(CommonModelType::Veo3p1.to_str(), "veo_3p1");
       assert_eq!(CommonModelType::Veo3p1Fast.to_str(), "veo_3p1_fast");
+      assert_eq!(CommonModelType::PreviewModel.to_str(), "preview_model");
+      assert_eq!(CommonModelType::PreviewModelFast.to_str(), "preview_model_fast");
       assert_eq!(CommonModelType::SwitchX.to_str(), "switch_x");
 
       // 3D Object generation models
@@ -673,6 +689,8 @@ mod tests {
       assert_eq!(CommonModelType::from_str("veo_3_fast").unwrap(), CommonModelType::Veo3Fast);
       assert_eq!(CommonModelType::from_str("veo_3p1").unwrap(), CommonModelType::Veo3p1);
       assert_eq!(CommonModelType::from_str("veo_3p1_fast").unwrap(), CommonModelType::Veo3p1Fast);
+      assert_eq!(CommonModelType::from_str("preview_model").unwrap(), CommonModelType::PreviewModel);
+      assert_eq!(CommonModelType::from_str("preview_model_fast").unwrap(), CommonModelType::PreviewModelFast);
       assert_eq!(CommonModelType::from_str("switch_x").unwrap(), CommonModelType::SwitchX);
 
       // 3D Object generation models
@@ -687,7 +705,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = CommonModelType::all_variants();
-      assert_eq!(variants.len(), 60);
+      assert_eq!(variants.len(), 62);
       // Image models
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Dev));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Schnell));
@@ -744,6 +762,8 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(CommonModelType::Veo3Fast));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Veo3p1));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Veo3p1Fast));
+      assert_eq!(variants.pop_first(), Some(CommonModelType::PreviewModel));
+      assert_eq!(variants.pop_first(), Some(CommonModelType::PreviewModelFast));
       assert_eq!(variants.pop_first(), Some(CommonModelType::SwitchX));
       // 3D Object generation models
       assert_eq!(variants.pop_first(), Some(CommonModelType::Hunyuan3d2_0));

crates/schema/public/enums/src/common/generation/common_video_model.rs

@@ -70,6 +70,12 @@ pub enum CommonVideoModel {
 
   #[serde(rename = "veo_3p1_fast")]
   Veo3p1Fast,
+
+  #[serde(rename = "preview_model")]
+  PreviewModel,
+
+  #[serde(rename = "preview_model_fast")]
+  PreviewModelFast,
 }
 
 impl CommonVideoModel {
@@ -98,6 +104,8 @@ impl CommonVideoModel {
       Self::Veo3Fast => CommonModelType::Veo3Fast,
       Self::Veo3p1 => CommonModelType::Veo3p1,
       Self::Veo3p1Fast => CommonModelType::Veo3p1Fast,
+      Self::PreviewModel => CommonModelType::PreviewModel,
+      Self::PreviewModelFast => CommonModelType::PreviewModelFast,
     }
   }
 }
@@ -132,6 +140,8 @@ mod tests {
     assert_serialization(CommonVideoModel::Veo3Fast, "veo_3_fast");
     assert_serialization(CommonVideoModel::Veo3p1, "veo_3p1");
     assert_serialization(CommonVideoModel::Veo3p1Fast, "veo_3p1_fast");
+    assert_serialization(CommonVideoModel::PreviewModel, "preview_model");
+    assert_serialization(CommonVideoModel::PreviewModelFast, "preview_model_fast");
   }
 
   #[test]
@@ -159,6 +169,8 @@ mod tests {
       ("veo_3_fast", CommonVideoModel::Veo3Fast),
       ("veo_3p1", CommonVideoModel::Veo3p1),
       ("veo_3p1_fast", CommonVideoModel::Veo3p1Fast),
+      ("preview_model", CommonVideoModel::PreviewModel),
+      ("preview_model_fast", CommonVideoModel::PreviewModelFast),
     ];
     for (json_str, expected) in cases {
       let json = format!("\"{}\"", json_str);
@@ -193,6 +205,8 @@ mod tests {
       CommonVideoModel::Veo3Fast,
       CommonVideoModel::Veo3p1,
       CommonVideoModel::Veo3p1Fast,
+      CommonVideoModel::PreviewModel,
+      CommonVideoModel::PreviewModelFast,
     ];
     for variant in all {
       let json = serde_json::to_string(&variant).unwrap();
@@ -226,6 +240,8 @@ mod tests {
       (CommonVideoModel::Veo3Fast, CommonModelType::Veo3Fast),
       (CommonVideoModel::Veo3p1, CommonModelType::Veo3p1),
       (CommonVideoModel::Veo3p1Fast, CommonModelType::Veo3p1Fast),
+      (CommonVideoModel::PreviewModel, CommonModelType::PreviewModel),
+      (CommonVideoModel::PreviewModelFast, CommonModelType::PreviewModelFast),
     ];
     for (video_model, expected) in models {
       assert_eq!(video_model.to_common_model_type(), expected);

crates/service/job/seedance2_pro_job/src/http_server/run_http_server.rs

@@ -13,7 +13,7 @@ use pager::client::pager::Pager;
 use crate::http_server::endpoints::health_check_handler::get_health_check_handler;
 use crate::http_server::http_server_shared_state::HttpServerSharedState;
 
-const DEFAULT_BIND_ADDRESS: &str = "0.0.0.0:12345";
+const DEFAULT_BIND_ADDRESS: &str = "0.0.0.0:11223";
 const DEFAULT_NUM_WORKERS: usize = 2;
 
 pub struct CreateServerArgs {

crates/service/job/seedance2_pro_job/src/job_dependencies.rs

@@ -20,6 +20,10 @@ pub struct JobDependencies {
   /// Session credentials for polling seedance2-pro.com.
   pub seedance2pro_session: Seedance2ProSession,
 
+  /// When true, this instance polls for alternate-account jobs
+  /// (Seedance2ProAltQueue / Seedance2ProAlt) instead of the primary ones.
+  pub is_alternate_mode: bool,
+
   pub server_environment: ServerEnvironment,
 
   pub job_stats: JobStats,

crates/service/job/seedance2_pro_job/src/jobs/video_polling_job/video_polling_main_loop.rs

@@ -2,6 +2,8 @@ use std::collections::HashMap;
 use std::time::{Duration, Instant};
 
 use chrono::Utc;
+use enums::by_table::generic_inference_jobs::inference_job_external_third_party::InferenceJobExternalThirdParty;
+use enums::by_table::generic_inference_jobs::inference_job_type::InferenceJobType;
 use log::{error, info, warn};
 use pager::notification::notification_details_builder::NotificationDetailsBuilder;
 use pager::notification::notification_urgency::NotificationUrgency;
@@ -61,7 +63,13 @@ pub async fn video_polling_main_loop(job_dependencies: JobDependencies) {
 async fn run_poll_iteration(deps: &JobDependencies) -> anyhow::Result<()> {
   // 1. Query all (limit 25,000) non-terminal Seedance2Pro jobs from DB.
   //    This is all non-(complete_success, complete_failure) jobs.
-  let pending_jobs = match list_pending_seedance2pro_video_jobs(&deps.mysql_pool).await {
+  let (third_party, job_type) = if deps.is_alternate_mode {
+    (InferenceJobExternalThirdParty::Seedance2ProAlt, InferenceJobType::Seedance2ProAltQueue)
+  } else {
+    (InferenceJobExternalThirdParty::Seedance2Pro, InferenceJobType::Seedance2ProQueue)
+  };
+
+  let pending_jobs = match list_pending_seedance2pro_video_jobs(&deps.mysql_pool, third_party, job_type).await {
     Ok(jobs) => jobs,
     Err(err) => {
       error!("Failed to list pending database jobs: {:?}", err);

crates/service/job/seedance2_pro_job/src/main.rs

@@ -45,7 +45,11 @@ const ENV_SECRET_KEY: &str = "SECRET_KEY";
 const ENV_REGION_NAME: &str = "REGION_NAME";
 const ENV_PUBLIC_BUCKET_NAME: &str = "PUBLIC_BUCKET_NAME";
 const ENV_S3_ENDPOINT: &str = "S3_COMPATIBLE_ENDPOINT_URL";
-const ENV_SEEDANCE2PRO_COOKIES : &str = "SEEDANCE2PRO_COOKIES";
+
+const ENV_SEEDANCE2PRO_ALTERNATE: &str = "SEEDANCE2PRO_ALTERNATE";
+const ENV_SEEDANCE2PRO_COOKIES: &str = "SEEDANCE2PRO_COOKIES";
+const ENV_SEEDANCE2PRO_ALT_COOKIES: &str = "SEEDANCE2PRO_ALT_COOKIES";
+
 const ENV_MAX_JOB_AGE_THRESHOLD_HOURS: &str = "MAX_JOB_AGE_THRESHOLD_HOURS";
 
 #[tokio::main]
@@ -101,8 +105,20 @@ async fn main() -> AnyhowResult<()> {
     Some(bucket_timeout),
   )?;
 
+  // Alternate mode: uses a different Kinovi account, different job types, skips character polling.
+  let is_alternate_mode = easyenv::get_env_string_optional(ENV_SEEDANCE2PRO_ALTERNATE)
+    .map(|v| v.trim().to_lowercase())
+    .map(|v| v == "true" || v == "1")
+    .unwrap_or(false);
+
+  if is_alternate_mode {
+    info!("Running in ALTERNATE mode (SEEDANCE2PRO_ALTERNATE=true).");
+  }
+
   // Seedance2Pro session from cookie string
-  let seedance2pro_cookies = easyenv::get_env_string_required(ENV_SEEDANCE2PRO_COOKIES)?;
+  let cookie_env_var = if is_alternate_mode { ENV_SEEDANCE2PRO_ALT_COOKIES } else { ENV_SEEDANCE2PRO_COOKIES };
+  info!("Reading Seedance2Pro cookies from environment variable: {}", cookie_env_var);
+  let seedance2pro_cookies = easyenv::get_env_string_required(cookie_env_var)?;
   let seedance2pro_session = Seedance2ProSession::from_cookies_string(seedance2pro_cookies);
 
   // How often to poll for results (default: 15 seconds)
@@ -171,6 +187,7 @@ async fn main() -> AnyhowResult<()> {
     mysql_pool,
     public_bucket_client,
     seedance2pro_session,
+    is_alternate_mode,
     server_environment,
     job_stats,
     poll_interval_millis,
@@ -214,23 +231,27 @@ async fn main() -> AnyhowResult<()> {
 
   // Spawn all polling loops as concurrent tasks.
   let video_deps = job_dependencies.clone();
-  let character_deps = job_dependencies.clone();
-  let credits_deps = job_dependencies;
+  let credits_deps = job_dependencies.clone();
 
   let video_handle = tokio::spawn(async move {
     video_polling_main_loop(video_deps).await;
   });
 
-  let character_handle = tokio::spawn(async move {
-    character_polling_main_loop(character_deps).await;
-  });
-
   let credits_handle = tokio::spawn(async move {
     credits_checking_main_loop(credits_deps).await;
   });
 
-  // Wait for all to finish (they exit when application_shutdown is set).
-  let _ = tokio::join!(video_handle, character_handle, credits_handle);
+  if is_alternate_mode {
+    // Alternate mode: skip character polling entirely.
+    info!("Alternate mode: character polling is disabled.");
+    let _ = tokio::join!(video_handle, credits_handle);
+  } else {
+    let character_deps = job_dependencies;
+    let character_handle = tokio::spawn(async move {
+      character_polling_main_loop(character_deps).await;
+    });
+    let _ = tokio::join!(video_handle, character_handle, credits_handle);
+  }
 
   info!("Shutting down pager worker...");
   pager_for_shutdown.shutdown_worker();

crates/service/job/video_thumbnail_job/config/video-thumbnail-job.development.env

@@ -4,4 +4,4 @@
 SERVER_ENVIRONMENT='development'
 
 # Don't collide with storyteller-web in development
-HTTP_BIND_ADDRESS=0.0.0.0:13333
+HTTP_BIND_ADDRESS=0.0.0.0:13339

crates/service/job/video_thumbnail_job/src/http_server/run_http_server.rs

@@ -13,7 +13,7 @@ use pager::client::pager::Pager;
 use crate::http_server::endpoints::health_check_handler::get_health_check_handler;
 use crate::http_server::http_server_shared_state::HttpServerSharedState;
 
-const DEFAULT_BIND_ADDRESS: &str = "0.0.0.0:12345";
+const DEFAULT_BIND_ADDRESS: &str = "0.0.0.0:13339";
 const DEFAULT_NUM_WORKERS: usize = 2;
 
 pub struct CreateServerArgs {

crates/service/web/storyteller_web/src/configs/omni_gen/video_models.rs

@@ -155,10 +155,89 @@ fn build_omni_gen_video_models() -> Vec<OmniGenVideoModelDetails> {
     ..Default::default()
   });
 
+//  models.push(OmniGenVideoModelDetails {
+//    model: CommonVideoModel::Seedance2p0Global,
+//    model_creator: Some(ModelCreator::Bytedance),
+//    full_name: Some("Seedance 2.0 (Global)".to_string()),
+//    text_prompt_supported: Some(true),
+//    starting_keyframe_supported: Some(true),
+//    ending_keyframe_supported: Some(true),
+//    image_references_supported: Some(true),
+//    image_references_max: Some(9),
+//    audio_references_supported: Some(true),
+//    audio_references_max: Some(3),
+//    audio_references_max_total_duration_seconds: Some(15),
+//    video_references_supported: Some(true),
+//    video_references_max: Some(3),
+//    video_references_max_total_duration_seconds: Some(15),
+//    character_references_supported: Some(true),
+//    character_references_max: Some(9),
+//    aspect_ratio_options: Some(vec![
+//      CommonAspectRatio::WideTwentyOneByNine,
+//      CommonAspectRatio::WideSixteenByNine,
+//      CommonAspectRatio::WideFourByThree,
+//      CommonAspectRatio::Square,
+//      CommonAspectRatio::TallThreeByFour,
+//      CommonAspectRatio::TallNineBySixteen,
+//    ]),
+//    aspect_ratio_default: Some(CommonAspectRatio::WideSixteenByNine),
+//    resolution_options: Some(vec![
+//      CommonResolution::FourEightyP,
+//      CommonResolution::SevenTwentyP,
+//      CommonResolution::TenEightyP,
+//    ]),
+//    resolution_default: Some(CommonResolution::SevenTwentyP),
+//    batch_size_options: Some(vec![1, 2, 4]),
+//    batch_size_default: Some(1),
+//    duration_seconds_min: Some(4),
+//    duration_seconds_max: Some(15),
+//    duration_seconds_default: Some(5),
+//    ..Default::default()
+//  });
+//
+//  models.push(OmniGenVideoModelDetails {
+//    model: CommonVideoModel::Seedance2p0FastGlobal,
+//    model_creator: Some(ModelCreator::Bytedance),
+//    full_name: Some("Seedance 2.0 Fast (Global)".to_string()),
+//    text_prompt_supported: Some(true),
+//    starting_keyframe_supported: Some(true),
+//    ending_keyframe_supported: Some(true),
+//    image_references_supported: Some(true),
+//    image_references_max: Some(9),
+//    audio_references_supported: Some(true),
+//    audio_references_max: Some(3),
+//    audio_references_max_total_duration_seconds: Some(15),
+//    video_references_supported: Some(true),
+//    video_references_max: Some(3),
+//    video_references_max_total_duration_seconds: Some(15),
+//    character_references_supported: Some(true),
+//    character_references_max: Some(9),
+//    aspect_ratio_options: Some(vec![
+//      CommonAspectRatio::WideTwentyOneByNine,
+//      CommonAspectRatio::WideSixteenByNine,
+//      CommonAspectRatio::WideFourByThree,
+//      CommonAspectRatio::Square,
+//      CommonAspectRatio::TallThreeByFour,
+//      CommonAspectRatio::TallNineBySixteen,
+//    ]),
+//    aspect_ratio_default: Some(CommonAspectRatio::WideSixteenByNine),
+//    resolution_options: Some(vec![
+//      CommonResolution::FourEightyP,
+//      CommonResolution::SevenTwentyP,
+//    ]),
+//    resolution_default: Some(CommonResolution::SevenTwentyP),
+//    batch_size_options: Some(vec![1, 2, 4]),
+//    batch_size_default: Some(1),
+//    duration_seconds_min: Some(4),
+//    duration_seconds_max: Some(15),
+//    duration_seconds_default: Some(5),
+//    ..Default::default()
+//  });
+
   models.push(OmniGenVideoModelDetails {
-    model: CommonVideoModel::Seedance2p0Global,
-    model_creator: Some(ModelCreator::Bytedance),
-    full_name: Some("Seedance 2.0 (Global)".to_string()),
+    model: CommonVideoModel::PreviewModel,
+    model_creator: None,
+    full_name: Some("Research Preview".to_string()),
     text_prompt_supported: Some(true),
     starting_keyframe_supported: Some(true),
     ending_keyframe_supported: Some(true),
@@ -196,9 +275,9 @@ fn build_omni_gen_video_models() -> Vec<OmniGenVideoModelDetails> {
   });
 
   models.push(OmniGenVideoModelDetails {
-    model: CommonVideoModel::Seedance2p0FastGlobal,
-    model_creator: Some(ModelCreator::Bytedance),
-    full_name: Some("Seedance 2.0 Fast (Global)".to_string()),
+    model: CommonVideoModel::PreviewModelFast,
+    model_creator: None,
+    full_name: Some("Research Preview (Fast)".to_string()),
     text_prompt_supported: Some(true),
     starting_keyframe_supported: Some(true),
     ending_keyframe_supported: Some(true),

crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/video/estimate_video_cost_handler.rs

@@ -151,6 +151,8 @@ fn map_video_model(model: CommonVideoModel) -> Result<RouterVideoModel, HandlerE
     CommonVideoModel::Veo3Fast => RouterVideoModel::Veo3Fast,
     CommonVideoModel::Veo3p1 => RouterVideoModel::Veo3p1,
     CommonVideoModel::Veo3p1Fast => RouterVideoModel::Veo3p1Fast,
+    CommonVideoModel::PreviewModel => RouterVideoModel::PreviewModel,
+    CommonVideoModel::PreviewModelFast => RouterVideoModel::PreviewModelFast,
   };
   Ok(router_model)
 }

crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/multi_function/seedance_2p0_multi_function_video_gen_handler.rs

@@ -192,7 +192,7 @@ pub async fn seedance_2p0_multi_function_video_gen_handler(
     info!("User {:?} is seedance-whitelisted, trying whitelist session first", user_token);
 
     let whitelist_session = Seedance2ProSession::from_cookies_string(
-      server_state.seedance2pro.cookies_whitelist.clone()
+      server_state.seedance2pro.cookies_byteplus.clone()
     );
 
     let result = upload_and_generate(
@@ -412,6 +412,7 @@ pub async fn seedance_2p0_multi_function_video_gen_handler(
 
     let db_result = insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token(
       InsertGenericInferenceForSeedance2ProWithAprioriJobTokenArgs {
+        use_alternate_kinovi: false,
         apriori_job_token: &job_token,
         uuid_idempotency_token: &idempotency_str,
         maybe_external_third_party_id: order_id,

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/helpers/build_router_client.rs

@@ -13,13 +13,11 @@ use crate::state::server_state::ServerState;
 pub fn build_router_client(
   provider: Provider,
   server_state: &ServerState,
+  use_alternate_kinovi: bool,
 ) -> Result<RouterClient, AdvancedCommonWebError> {
   match provider {
     Provider::Seedance2Pro => {
-      let session = Seedance2ProSession::from_cookies_string(
-        server_state.seedance2pro.cookies.clone()
-      );
-      Ok(RouterClient::Seedance2Pro(RouterSeedance2ProClient::new(session)))
+      kinovi_provider(server_state, use_alternate_kinovi)
     }
     Provider::Fal => {
       let fal_client = RouterFalClient::new(
@@ -40,3 +38,19 @@ pub fn build_router_client(
     }
   }
 }
+
+fn kinovi_provider(server_state: &ServerState, use_alternate_kinovi: bool) -> Result<RouterClient, AdvancedCommonWebError> {
+  let session = if use_alternate_kinovi {
+    // Alternate Kinovi
+    Seedance2ProSession::from_cookies_string(
+      server_state.seedance2pro.cookies_byteplus.clone()
+    )
+  } else {
+    // Standard Kinovi
+    Seedance2ProSession::from_cookies_string(
+      server_state.seedance2pro.cookies.clone()
+    )
+  };
+  
+  Ok(RouterClient::Seedance2Pro(RouterSeedance2ProClient::new(session)))
+}

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/insert_db_job/insert_seedance2pro_jobs.rs

@@ -16,6 +16,7 @@ pub struct InsertSeedance2proJobsArgs<'a, 'tx> {
   pub primary_order_id: &'a str,
   pub maybe_additional_order_ids: Option<&'a [String]>,
   pub maybe_wallet_ledger_entry_token: Option<&'a WalletLedgerEntryToken>,
+  pub use_alternate_kinovi: bool,
   pub shared: SharedJobArgs<'a, 'tx>,
 }
 
@@ -29,6 +30,7 @@ pub async fn insert_seedance2pro_jobs(args: InsertSeedance2proJobsArgs<'_, '_>)
     primary_order_id,
     maybe_additional_order_ids,
     maybe_wallet_ledger_entry_token,
+    use_alternate_kinovi,
     mut shared,
   } = args;
 
@@ -55,6 +57,7 @@ pub async fn insert_seedance2pro_jobs(args: InsertSeedance2proJobsArgs<'_, '_>)
 
     let db_result = insert_generic_inference_job_for_seedance2pro_queue_with_apriori_job_token(
       InsertGenericInferenceForSeedance2ProWithAprioriJobTokenArgs {
+        use_alternate_kinovi,
         apriori_job_token: &job_token,
         uuid_idempotency_token: &idempotency_str,
         maybe_external_third_party_id: order_id,

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/omni_gen_video_generate_handler.rs

@@ -189,6 +189,14 @@ pub async fn omni_gen_video_generate_handler(
     Some(CommonVideoModel::Seedance2p0Fast) => true,
     Some(CommonVideoModel::Seedance2p0Global) => true,
     Some(CommonVideoModel::Seedance2p0FastGlobal) => true,
+    Some(CommonVideoModel::PreviewModel) => true,
+    Some(CommonVideoModel::PreviewModelFast) => true,
+    _ => false,
+  };
+
+  let use_alternate_kinovi = match request.model {
+    Some(CommonVideoModel::PreviewModel) => true,
+    Some(CommonVideoModel::PreviewModelFast) => true,
     _ => false,
   };
 
@@ -201,6 +209,7 @@ pub async fn omni_gen_video_generate_handler(
       user_token,
       media_file_to_url_map: &media_file_to_url_map,
       kinovi_character_id_map: &kinovi_character_id_map,
+      use_alternate_kinovi,
     }).await?
   } else {
     info!("Using pipeline v1");
@@ -336,6 +345,7 @@ pub async fn omni_gen_video_generate_handler(
         primary_order_id: &payload.order_id,
         maybe_additional_order_ids: payload.maybe_order_ids.as_deref(),
         maybe_wallet_ledger_entry_token: pipeline_result.billing.maybe_wallet_ledger_entry_token.as_ref(),
+        use_alternate_kinovi,
         shared: SharedJobArgs {
           apriori_job_token: &pipeline_result.billing.apriori_job_token,
           idempotency_token: &idempotency_token,

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/pipeline_v1/execute/execute_fal.rs

@@ -15,7 +15,9 @@ pub(crate) async fn execute_generation_fal(
   plan: &VideoGenerationPlan,
   server_state: &ServerState,
 ) -> Result<GenerateVideoResponse, AdvancedCommonWebError> {
-  let router_client = build_router_client(Provider::Fal, server_state)?;
+  const USE_ALTERNATE_KINOVI: bool = false;
+
+  let router_client = build_router_client(Provider::Fal, server_state, USE_ALTERNATE_KINOVI)?;
 
   let response = plan.generate_video(&router_client)
     .await

crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/generate/video/pipeline_v2/run_pipeline_v2.rs

@@ -27,6 +27,7 @@ pub struct RunPipelineV2Args<'a> {
   pub user_token: &'a UserToken,
   pub media_file_to_url_map: &'a Option<HashMap<MediaFileToken, String>>,
   pub kinovi_character_id_map: &'a Option<HashMap<CharacterToken, String>>,
+  pub use_alternate_kinovi: bool,
 }
 
 pub async fn run_pipeline_v2(args: RunPipelineV2Args<'_>) -> Result<PipelineResult, AdvancedCommonWebError> {
@@ -37,8 +38,21 @@ pub async fn run_pipeline_v2(args: RunPipelineV2Args<'_>) -> Result<PipelineResu
     user_token,
     media_file_to_url_map,
     kinovi_character_id_map,
+    use_alternate_kinovi,
   } = args;
 
+  let mut router_builder = router_builder.clone();
+
+  match router_builder.model {
+    CommonVideoModel::PreviewModel => {
+      router_builder.model = CommonVideoModel::Seedance2p0;
+    },
+    CommonVideoModel::PreviewModelFast => {
+      router_builder.model = CommonVideoModel::Seedance2p0Fast;
+    },
+    _ => {}, // Fall-through
+  }
+
   let provider = match router_builder.model {
     CommonVideoModel::HappyHorse1p0 => Provider::Seedance2Pro,
     CommonVideoModel::Seedance2p0 => Provider::Seedance2Pro,
@@ -97,6 +111,7 @@ pub async fn run_pipeline_v2(args: RunPipelineV2Args<'_>) -> Result<PipelineResu
     server_state,
     media_file_to_url_map.as_ref(),
     kinovi_character_id_map.as_ref(),
+    use_alternate_kinovi,
   ).await;
 
   // 5. On failure, refund wallet for Kinovi requests.
@@ -129,10 +144,11 @@ async fn upload_and_generate(
   server_state: &ServerState,
   media_file_urls_by_token: Option<&HashMap<MediaFileToken, String>>,
   kinovi_character_ids: Option<&HashMap<CharacterToken, String>>,
+  use_alternate_kinovi: bool,
 ) -> Result<GenerateVideoResponse, AdvancedCommonWebError> {
 
   let provider = draft_or_request.get_provider();
-  let client = build_router_client(provider, server_state)?;
+  let client = build_router_client(provider, server_state, use_alternate_kinovi)?;
 
   let video_request = match draft_or_request {
     VideoGenerationDraftOrRequest::Request(request) => request,

crates/service/web/storyteller_web/src/main.rs

@@ -492,7 +492,7 @@ async fn main() -> AnyhowResult<()> {
     },
     seedance2pro: Seedance2ProData {
       cookies: easyenv::get_env_string_required("SEEDANCE2PRO_COOKIES")?,
-      cookies_whitelist: easyenv::get_env_string_required("SEEDANCE2PRO_WHITELIST_COOKIES")?,
+      cookies_byteplus: easyenv::get_env_string_required("SEEDANCE2PRO_WHITELIST_COOKIES")?,
     },
     openai: OpenAiData {
       api_key: openai_api_key,

crates/service/web/storyteller_web/src/state/server_state.rs

@@ -346,7 +346,7 @@ pub struct Seedance2ProData {
   pub cookies: String,
 
   /// Cookie string for seedance2-pro.com (Whitelisted account)
-  pub cookies_whitelist: String,
+  pub cookies_byteplus: String,
 }
 
 /// OpenAI integration