shouldn't be impacting

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

@@ -42,6 +42,11 @@ pub enum FrontendFailureCategory {
   /// exactly what happened. We'll retry their workload in any case.
   #[serde(rename = "retryable_worker_error")]
   RetryableWorkerError,
+
+  /// Model content rules were violated
+  /// Eg. Seedance 2 will report: "your input text violates platform rules. please modify and try again"
+  #[serde(rename = "model_rules_violation")]
+  ModelRulesViolation,
 }
 
 // TODO(bt, 2022-12-21): This desperately needs MySQL integration tests!
@@ -56,6 +61,7 @@ impl FrontendFailureCategory {
       Self::KeepAliveElapsed => "keep_alive_elapsed",
       Self::NotYetImplemented => "not_yet_implemented",
       Self::RetryableWorkerError => "retryable_worker_error",
+      Self::ModelRulesViolation => "model_rules_violation",
     }
   }
 
@@ -65,6 +71,7 @@ impl FrontendFailureCategory {
       "keep_alive_elapsed" => Ok(Self::KeepAliveElapsed),
       "not_yet_implemented" => Ok(Self::NotYetImplemented),
       "retryable_worker_error" => Ok(Self::RetryableWorkerError),
+      "model_rules_violation" => Ok(Self::ModelRulesViolation),
       _ => Err(format!("invalid value: {:?}", value)),
     }
   }
@@ -77,6 +84,7 @@ impl FrontendFailureCategory {
       Self::KeepAliveElapsed,
       Self::NotYetImplemented,
       Self::RetryableWorkerError,
+      Self::ModelRulesViolation,
     ])
   }
 }
@@ -95,6 +103,7 @@ mod tests {
       assert_serialization(FrontendFailureCategory::KeepAliveElapsed, "keep_alive_elapsed");
       assert_serialization(FrontendFailureCategory::NotYetImplemented, "not_yet_implemented");
       assert_serialization(FrontendFailureCategory::RetryableWorkerError, "retryable_worker_error");
+      assert_serialization(FrontendFailureCategory::ModelRulesViolation, "model_rules_violation");
     }
 
     #[test]
@@ -103,6 +112,7 @@ mod tests {
       assert_eq!(FrontendFailureCategory::KeepAliveElapsed.to_str(), "keep_alive_elapsed");
       assert_eq!(FrontendFailureCategory::NotYetImplemented.to_str(), "not_yet_implemented");
       assert_eq!(FrontendFailureCategory::RetryableWorkerError.to_str(), "retryable_worker_error");
+      assert_eq!(FrontendFailureCategory::ModelRulesViolation.to_str(), "model_rules_violation");
     }
 
     #[test]
@@ -111,16 +121,18 @@ mod tests {
       assert_eq!(FrontendFailureCategory::from_str("keep_alive_elapsed").unwrap(), FrontendFailureCategory::KeepAliveElapsed);
       assert_eq!(FrontendFailureCategory::from_str("not_yet_implemented").unwrap(), FrontendFailureCategory::NotYetImplemented);
       assert_eq!(FrontendFailureCategory::from_str("retryable_worker_error").unwrap(), FrontendFailureCategory::RetryableWorkerError);
+      assert_eq!(FrontendFailureCategory::from_str("model_rules_violation").unwrap(), FrontendFailureCategory::ModelRulesViolation);
     }
 
     #[test]
     fn all_variants() {
       let mut variants = FrontendFailureCategory::all_variants();
-      assert_eq!(variants.len(), 4);
+      assert_eq!(variants.len(), 5);
       assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::FaceNotDetected));
       assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::KeepAliveElapsed));
       assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::NotYetImplemented));
       assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::RetryableWorkerError));
+      assert_eq!(variants.pop_first(), Some(FrontendFailureCategory::ModelRulesViolation));
       assert_eq!(variants.pop_first(), None);
     }
   }

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

@@ -40,6 +40,7 @@ pub enum InferenceCategory {
   ImageGeneration,
 
   /// FAL-powered video generation
+  /// (Also Seedance2-Pro.com)
   #[serde(rename = "video_generation")]
   VideoGeneration,
   

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

@@ -16,6 +16,10 @@ pub enum InferenceJobExternalThirdParty {
   #[serde(rename = "fal")]
   #[default]
   Fal,
+
+  /// Seedance 2 Pro jobs
+  #[serde(rename = "seedance2pro")]
+  Seedance2Pro,
 }
 
 // TODO(bt, 2022-12-21): This desperately needs MySQL integration tests!
@@ -27,12 +31,14 @@ impl InferenceJobExternalThirdParty {
   pub fn to_str(&self) -> &'static str {
     match self {
       Self::Fal => "fal",
+      Self::Seedance2Pro => "seedance2pro",
     }
   }
 
   pub fn from_str(value: &str) -> Result<Self, String> {
     match value {
       "fal" => Ok(Self::Fal),
+      "seedance2pro" => Ok(Self::Seedance2Pro),
       _ => Err(format!("invalid value: {:?}", value)),
     }
   }
@@ -42,6 +48,7 @@ impl InferenceJobExternalThirdParty {
     // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc.
     BTreeSet::from([
       Self::Fal,
+      Self::Seedance2Pro,
     ])
   }
 }
@@ -57,22 +64,25 @@ mod tests {
     #[test]
     fn test_serialization() {
       assert_serialization(InferenceJobExternalThirdParty::Fal, "fal");
+      assert_serialization(InferenceJobExternalThirdParty::Seedance2Pro, "seedance2pro");
     }
 
     #[test]
     fn to_str() {
       assert_eq!(InferenceJobExternalThirdParty::Fal.to_str(), "fal");
+      assert_eq!(InferenceJobExternalThirdParty::Seedance2Pro.to_str(), "seedance2pro");
     }
 
     #[test]
     fn from_str() {
       assert_eq!(InferenceJobExternalThirdParty::from_str("fal").unwrap(), InferenceJobExternalThirdParty::Fal);
+      assert_eq!(InferenceJobExternalThirdParty::from_str("seedance2pro").unwrap(), InferenceJobExternalThirdParty::Seedance2Pro);
     }
 
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 1;
+      const EXPECTED_COUNT : usize = 2;
       
       assert_eq!(InferenceJobExternalThirdParty::all_variants().len(), EXPECTED_COUNT);
       assert_eq!(InferenceJobExternalThirdParty::iter().len(), EXPECTED_COUNT);
@@ -103,7 +113,7 @@ mod tests {
 
     #[test]
     fn serialized_length_ok_for_database() {
-      const MAX_LENGTH : usize = 32;
+      const MAX_LENGTH : usize = 16;
       for variant in InferenceJobExternalThirdParty::all_variants() {
         let serialized = variant.to_str();
         assert!(serialized.len() > 0, "variant {:?} is too short", variant);

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

@@ -30,6 +30,11 @@ pub enum InferenceJobProductCategory {
   FalObject,
   FalBgRemoval,
 
+  // =============== SEEDANCE 2 PRO ===============
+
+  #[serde(rename = "seedance2pro_video")]
+  Seedance2ProVideo,
+
   // =============== TEXT TO SPEECH ===============
 
   /// TTS: GptSoVits
@@ -125,6 +130,7 @@ impl InferenceJobProductCategory {
       Self::FalVideo => "fal_video",
       Self::FalObject => "fal_object",
       Self::FalBgRemoval => "fal_bg_removal",
+      Self::Seedance2ProVideo => "seedance2pro_video",
       Self::TtsGptSoVits => "tts_gpt_so_vits",
       Self::TtsStyleTts2 => "tts_style_tts2",
       Self::TtsTacotron2 => "tts_tacotron2",
@@ -157,6 +163,7 @@ impl InferenceJobProductCategory {
       "fal_video" => Ok(Self::FalVideo),
       "fal_object" => Ok(Self::FalObject),
       "fal_bg_removal" => Ok(Self::FalBgRemoval),
+      "seedance2pro_video" => Ok(Self::Seedance2ProVideo),
       "tts_gpt_so_vits" => Ok(Self::TtsGptSoVits),
       "tts_style_tts2" => Ok(Self::TtsStyleTts2),
       "tts_tacotron2" => Ok(Self::TtsTacotron2),
@@ -192,6 +199,7 @@ impl InferenceJobProductCategory {
       Self::FalVideo,
       Self::FalObject,
       Self::FalBgRemoval,
+      Self::Seedance2ProVideo,
       Self::TtsGptSoVits,
       Self::TtsStyleTts2,
       Self::TtsTacotron2,
@@ -233,6 +241,7 @@ mod tests {
       assert_serialization(InferenceJobProductCategory::FalVideo, "fal_video");
       assert_serialization(InferenceJobProductCategory::FalObject, "fal_object");
       assert_serialization(InferenceJobProductCategory::FalBgRemoval, "fal_bg_removal");
+      assert_serialization(InferenceJobProductCategory::Seedance2ProVideo, "seedance2pro_video");
       assert_serialization(InferenceJobProductCategory::TtsGptSoVits, "tts_gpt_so_vits");
       assert_serialization(InferenceJobProductCategory::TtsStyleTts2, "tts_style_tts2");
       assert_serialization(InferenceJobProductCategory::TtsTacotron2, "tts_tacotron2");
@@ -264,6 +273,7 @@ mod tests {
       assert_eq!(InferenceJobProductCategory::FalVideo.to_str(), "fal_video");
       assert_eq!(InferenceJobProductCategory::FalObject.to_str(), "fal_object");
       assert_eq!(InferenceJobProductCategory::FalBgRemoval.to_str(), "fal_bg_removal");
+      assert_eq!(InferenceJobProductCategory::Seedance2ProVideo.to_str(), "seedance2pro_video");
       assert_eq!(InferenceJobProductCategory::TtsGptSoVits.to_str(), "tts_gpt_so_vits");
       assert_eq!(InferenceJobProductCategory::TtsStyleTts2.to_str(), "tts_style_tts2");
       assert_eq!(InferenceJobProductCategory::TtsTacotron2.to_str(), "tts_tacotron2");
@@ -294,6 +304,7 @@ mod tests {
       assert_eq!(InferenceJobProductCategory::from_str("fal_video").unwrap(), InferenceJobProductCategory::FalVideo);
       assert_eq!(InferenceJobProductCategory::from_str("fal_object").unwrap(), InferenceJobProductCategory::FalObject);
       assert_eq!(InferenceJobProductCategory::from_str("fal_bg_removal").unwrap(), InferenceJobProductCategory::FalBgRemoval);
+      assert_eq!(InferenceJobProductCategory::from_str("seedance2pro_video").unwrap(), InferenceJobProductCategory::Seedance2ProVideo);
       assert_eq!(InferenceJobProductCategory::from_str("tts_gpt_so_vits").unwrap(), InferenceJobProductCategory::TtsGptSoVits);
       assert_eq!(InferenceJobProductCategory::from_str("tts_style_tts2").unwrap(), InferenceJobProductCategory::TtsStyleTts2);
       assert_eq!(InferenceJobProductCategory::from_str("tts_tacotron2").unwrap(), InferenceJobProductCategory::TtsTacotron2);
@@ -320,7 +331,7 @@ mod tests {
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 27;
+      const EXPECTED_COUNT : usize = 28;
 
       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

@@ -18,7 +18,11 @@ pub enum InferenceJobType {
   /// Fal jobs do not run on our job runners.
   /// Instead, we receive web hook updates from Fal.
   FalQueue,
-  
+
+  /// Seedance 2 Pro jobs. We poll for results.
+  #[serde(rename = "seedance2pro_queue")]
+  Seedance2ProQueue,
+
   /// Storyteller Studio and Video Style Transfer Jobs (which we may want to split).
   /// These run in Comfy.
   /// TODO(bt,2024-07-15): We may segregate these two job types in the future
@@ -110,6 +114,7 @@ impl InferenceJobType {
   pub fn to_str(&self) -> &'static str {
     match self {
       Self::FalQueue => "fal_queue",
+      Self::Seedance2ProQueue => "seedance2pro_queue",
       Self::VideoRender => "video_render",
       Self::LivePortrait => "live_portrait",
       Self::FaceFusion => "face_fusion",
@@ -136,6 +141,7 @@ impl InferenceJobType {
   pub fn from_str(value: &str) -> Result<Self, String> {
     match value {
       "fal_queue" => Ok(Self::FalQueue),
+      "seedance2pro_queue" => Ok(Self::Seedance2ProQueue),
       "video_render" => Ok(Self::VideoRender),
       "live_portrait" => Ok(Self::LivePortrait),
       "face_fusion" => Ok(Self::FaceFusion),
@@ -165,6 +171,7 @@ impl InferenceJobType {
     // NB: BTreeSet::from() isn't const, but not worth using LazyStatic, etc.
     BTreeSet::from([
       Self::FalQueue,
+      Self::Seedance2ProQueue,
       Self::VideoRender,
       Self::LivePortrait,
       Self::FaceFusion,
@@ -205,6 +212,7 @@ mod tests {
     #[test]
     fn test_serialization() {
       assert_serialization(InferenceJobType::FalQueue, "fal_queue");
+      assert_serialization(InferenceJobType::Seedance2ProQueue, "seedance2pro_queue");
       assert_serialization(InferenceJobType::VideoRender, "video_render");
       assert_serialization(InferenceJobType::LivePortrait, "live_portrait");
       assert_serialization(InferenceJobType::FaceFusion, "face_fusion");
@@ -230,6 +238,7 @@ mod tests {
     #[test]
     fn to_str() {
       assert_eq!(InferenceJobType::FalQueue.to_str(), "fal_queue");
+      assert_eq!(InferenceJobType::Seedance2ProQueue.to_str(), "seedance2pro_queue");
       assert_eq!(InferenceJobType::VideoRender.to_str(), "video_render");
       assert_eq!(InferenceJobType::LivePortrait.to_str(), "live_portrait");
       assert_eq!(InferenceJobType::FaceFusion.to_str(), "face_fusion");
@@ -255,6 +264,7 @@ mod tests {
     #[test]
     fn from_str() {
       assert_eq!(InferenceJobType::from_str("fal_queue").unwrap(), InferenceJobType::FalQueue);
+      assert_eq!(InferenceJobType::from_str("seedance2pro_queue").unwrap(), InferenceJobType::Seedance2ProQueue);
       assert_eq!(InferenceJobType::from_str("video_render").unwrap(), InferenceJobType::VideoRender);
       assert_eq!(InferenceJobType::from_str("live_portrait").unwrap(), InferenceJobType::LivePortrait);
       assert_eq!(InferenceJobType::from_str("face_fusion").unwrap(), InferenceJobType::FaceFusion);
@@ -280,7 +290,7 @@ mod tests {
     #[test]
     fn all_variants() {
       // Static check
-      const EXPECTED_COUNT : usize = 21;
+      const EXPECTED_COUNT : usize = 22;
       
       assert_eq!(InferenceJobType::all_variants().len(), EXPECTED_COUNT);
       assert_eq!(InferenceJobType::iter().len(), EXPECTED_COUNT);

crates/schema/public/enums/src/by_table/media_files/media_file_origin_model_type.rs

@@ -216,7 +216,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = MediaFileOriginModelType::all_variants();
-      assert_eq!(variants.len(), 15);
+      assert_eq!(variants.len(), 18);
       assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::FaceFusion));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::F5TTS));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginModelType::LivePortrait));

crates/schema/public/enums/src/by_table/media_files/media_file_origin_product_category.rs

@@ -66,6 +66,9 @@ pub enum MediaFileOriginProductCategory {
   #[serde(rename = "image_gen")]
   ImageGeneration,
 
+  #[serde(rename = "video_gen")]
+  VideoGeneration,
+
   // Media files for video filters
   #[deprecated(note = "This isn't relevant product surface area anymore")]
   #[serde(rename = "video_filter")]
@@ -98,6 +101,7 @@ impl MediaFileOriginProductCategory {
       Self::ZeroShotVoice => "zs_voice",
       Self::Mocap => "mocap",
       Self::ImageGeneration => "image_gen",
+      Self::VideoGeneration => "video_gen",
       Self::VideoFilter => "video_filter",
       Self::Workflow => "workflow",
     }
@@ -117,6 +121,7 @@ impl MediaFileOriginProductCategory {
       "zs_voice" => Ok(Self::ZeroShotVoice),
       "mocap" => Ok(Self::Mocap),
       "image_gen" => Ok(Self::ImageGeneration),
+      "video_gen" => Ok(Self::VideoGeneration),
       "video_filter" => Ok(Self::VideoFilter),
       "workflow" => Ok(Self::Workflow),
       _ => Err(format!("invalid value: {:?}", value)),
@@ -139,6 +144,7 @@ impl MediaFileOriginProductCategory {
       Self::ZeroShotVoice,
       Self::Mocap,
       Self::ImageGeneration,
+      Self::VideoGeneration,
       Self::VideoFilter,
       Self::Workflow,
     ])
@@ -167,6 +173,7 @@ mod tests {
       assert_serialization(MediaFileOriginProductCategory::ZeroShotVoice, "zs_voice");
       assert_serialization(MediaFileOriginProductCategory::Mocap, "mocap");
       assert_serialization(MediaFileOriginProductCategory::ImageGeneration, "image_gen");
+      assert_serialization(MediaFileOriginProductCategory::VideoGeneration, "video_gen");
       assert_serialization(MediaFileOriginProductCategory::VideoFilter, "video_filter");
       assert_serialization(MediaFileOriginProductCategory::Workflow, "workflow");
     }
@@ -185,6 +192,7 @@ mod tests {
       assert_eq!(MediaFileOriginProductCategory::ZeroShotVoice.to_str(), "zs_voice");
       assert_eq!(MediaFileOriginProductCategory::Mocap.to_str(), "mocap");
       assert_eq!(MediaFileOriginProductCategory::ImageGeneration.to_str(), "image_gen");
+      assert_eq!(MediaFileOriginProductCategory::VideoGeneration.to_str(), "video_gen");
       assert_eq!(MediaFileOriginProductCategory::VideoFilter.to_str(), "video_filter");
       assert_eq!(MediaFileOriginProductCategory::Workflow.to_str(), "workflow");
     }
@@ -203,6 +211,7 @@ mod tests {
       assert_eq!(MediaFileOriginProductCategory::from_str("zs_voice").unwrap(), MediaFileOriginProductCategory::ZeroShotVoice);
       assert_eq!(MediaFileOriginProductCategory::from_str("mocap").unwrap(), MediaFileOriginProductCategory::Mocap);
       assert_eq!(MediaFileOriginProductCategory::from_str("image_gen").unwrap(),MediaFileOriginProductCategory::ImageGeneration);
+      assert_eq!(MediaFileOriginProductCategory::from_str("video_gen").unwrap(), MediaFileOriginProductCategory::VideoGeneration);
       assert_eq!(MediaFileOriginProductCategory::from_str("video_filter").unwrap(), MediaFileOriginProductCategory::VideoFilter);
       assert_eq!(MediaFileOriginProductCategory::from_str("workflow").unwrap(), MediaFileOriginProductCategory::Workflow);
     }
@@ -210,7 +219,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = MediaFileOriginProductCategory::all_variants();
-      assert_eq!(variants.len(), 14);
+      assert_eq!(variants.len(), 15);
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Unknown));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::FaceAnimator));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::FaceFusion));
@@ -223,6 +232,7 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::ZeroShotVoice));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Mocap));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::ImageGeneration));
+      assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::VideoGeneration));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::VideoFilter));
       assert_eq!(variants.pop_first(), Some(MediaFileOriginProductCategory::Workflow));
       assert_eq!(variants.pop_first(), None);

crates/schema/public/enums/src/common/job_status_plus.rs

@@ -43,7 +43,7 @@ impl Default for JobStatusPlus {
 }
 
 impl JobStatusPlus {
-  pub fn to_str(&self) -> &'static str {
+  pub const fn to_str(&self) -> &'static str {
     match self {
       Self::Pending => "pending",
       Self::Started => "started",

crates/schema/public/enums/src/common/model_type.rs

@@ -93,6 +93,8 @@ pub enum ModelType {
   Seedance10Lite,
   #[serde(rename = "seedance_1p0_pro")]
   Seedance10Pro,
+  #[serde(rename = "seedance_2p0")]
+  Seedance2p0,
   #[serde(rename = "sora_2")]
   Sora2,
   #[serde(rename = "sora_2_pro")]
@@ -163,6 +165,7 @@ impl ModelType {
       Self::Kling2p6Pro => "kling_2p6_pro",
       Self::Seedance10Lite => "seedance_1p0_lite",
       Self::Seedance10Pro => "seedance_1p0_pro",
+      Self::Seedance2p0 => "seedance_2p0",
       Self::Sora2 => "sora_2",
       Self::Sora2Pro => "sora_2_pro",
       Self::Veo2 => "veo_2",
@@ -217,6 +220,7 @@ impl ModelType {
       "kling_2p6_pro" => Ok(Self::Kling2p6Pro),
       "seedance_1p0_lite" => Ok(Self::Seedance10Lite),
       "seedance_1p0_pro" => Ok(Self::Seedance10Pro),
+      "seedance_2p0" => Ok(Self::Seedance2p0),
       "sora_2" => Ok(Self::Sora2),
       "sora_2_pro" => Ok(Self::Sora2Pro),
       "veo_2" => Ok(Self::Veo2),
@@ -275,6 +279,7 @@ impl ModelType {
       Self::Kling2p6Pro,
       Self::Seedance10Lite,
       Self::Seedance10Pro,
+      Self::Seedance2p0,
       Self::Sora2,
       Self::Sora2Pro,
       Self::Veo2,
@@ -337,6 +342,7 @@ mod tests {
       assert_serialization(ModelType::Kling2p6Pro, "kling_2p6_pro");
       assert_serialization(ModelType::Seedance10Lite, "seedance_1p0_lite");
       assert_serialization(ModelType::Seedance10Pro, "seedance_1p0_pro");
+      assert_serialization(ModelType::Seedance2p0, "seedance_2p0");
       assert_serialization(ModelType::Sora2, "sora_2");
       assert_serialization(ModelType::Sora2Pro, "sora_2_pro");
       assert_serialization(ModelType::Veo2, "veo_2");
@@ -389,6 +395,7 @@ mod tests {
       assert_eq!(ModelType::Kling2p6Pro.to_str(), "kling_2p6_pro");
       assert_eq!(ModelType::Seedance10Lite.to_str(), "seedance_1p0_lite");
       assert_eq!(ModelType::Seedance10Pro.to_str(), "seedance_1p0_pro");
+      assert_eq!(ModelType::Seedance2p0.to_str(), "seedance_2p0");
       assert_eq!(ModelType::Sora2.to_str(), "sora_2");
       assert_eq!(ModelType::Sora2Pro.to_str(), "sora_2_pro");
       assert_eq!(ModelType::Veo2.to_str(), "veo_2");
@@ -441,6 +448,7 @@ mod tests {
       assert_eq!(ModelType::from_str("kling_2p6_pro").unwrap(), ModelType::Kling2p6Pro);
       assert_eq!(ModelType::from_str("seedance_1p0_lite").unwrap(), ModelType::Seedance10Lite);
       assert_eq!(ModelType::from_str("seedance_1p0_pro").unwrap(), ModelType::Seedance10Pro);
+      assert_eq!(ModelType::from_str("seedance_2p0").unwrap(), ModelType::Seedance2p0);
       assert_eq!(ModelType::from_str("sora_2").unwrap(), ModelType::Sora2);
       assert_eq!(ModelType::from_str("sora_2_pro").unwrap(), ModelType::Sora2Pro);
       assert_eq!(ModelType::from_str("veo_2").unwrap(), ModelType::Veo2);
@@ -458,7 +466,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = ModelType::all_variants();
-      assert_eq!(variants.len(), 44);
+      assert_eq!(variants.len(), 45);
       // Image models
       assert_eq!(variants.pop_first(), Some(ModelType::Flux1Dev));
       assert_eq!(variants.pop_first(), Some(ModelType::Flux1Schnell));
@@ -495,6 +503,7 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(ModelType::Kling2p6Pro));
       assert_eq!(variants.pop_first(), Some(ModelType::Seedance10Lite));
       assert_eq!(variants.pop_first(), Some(ModelType::Seedance10Pro));
+      assert_eq!(variants.pop_first(), Some(ModelType::Seedance2p0));
       assert_eq!(variants.pop_first(), Some(ModelType::Sora2));
       assert_eq!(variants.pop_first(), Some(ModelType::Sora2Pro));
       assert_eq!(variants.pop_first(), Some(ModelType::Veo2));

crates/schema/public/enums/src/tauri/tasks/task_model_type.rs

@@ -65,6 +65,8 @@ pub enum TaskModelType {
   Kling2p6Pro,
   #[serde(rename = "seedance_1.0_lite")]
   Seedance10Lite,
+  #[serde(rename = "seedance_2p0")]
+  Seedance2p0,
   #[serde(rename = "sora_2")]
   Sora2,
   #[serde(rename = "sora_2_pro")]
@@ -126,6 +128,7 @@ impl TaskModelType {
       Self::Kling2p5TurboPro => "kling_2p5_turbo_pro",
       Self::Kling2p6Pro => "kling_2p6_pro",
       Self::Seedance10Lite => "seedance_1.0_lite",
+      Self::Seedance2p0 => "seedance_2p0",
       Self::Sora2 => "sora_2",
       Self::Sora2Pro => "sora_2_pro",
       Self::Veo2 => "veo_2",
@@ -169,6 +172,7 @@ impl TaskModelType {
       "kling_2p5_turbo_pro" => Ok(Self::Kling2p5TurboPro),
       "kling_2p6_pro" => Ok(Self::Kling2p6Pro),
       "seedance_1.0_lite" => Ok(Self::Seedance10Lite),
+      "seedance_2p0" => Ok(Self::Seedance2p0),
       "sora_2" => Ok(Self::Sora2),
       "sora_2_pro" => Ok(Self::Sora2Pro),
       "veo_2" => Ok(Self::Veo2),
@@ -215,6 +219,7 @@ impl TaskModelType {
       Self::Kling2p5TurboPro,
       Self::Kling2p6Pro,
       Self::Seedance10Lite,
+      Self::Seedance2p0,
       Self::Sora2,
       Self::Sora2Pro,
       Self::Veo2,
@@ -268,6 +273,7 @@ mod tests {
       assert_serialization(TaskModelType::Kling2p5TurboPro, "kling_2p5_turbo_pro");
       assert_serialization(TaskModelType::Kling2p6Pro, "kling_2p6_pro");
       assert_serialization(TaskModelType::Seedance10Lite, "seedance_1.0_lite");
+      assert_serialization(TaskModelType::Seedance2p0, "seedance_2p0");
       assert_serialization(TaskModelType::Sora2, "sora_2");
       assert_serialization(TaskModelType::Sora2Pro, "sora_2_pro");
       assert_serialization(TaskModelType::Veo2, "veo_2");
@@ -310,6 +316,7 @@ mod tests {
       assert_eq!(TaskModelType::Kling2p5TurboPro.to_str(), "kling_2p5_turbo_pro");
       assert_eq!(TaskModelType::Kling2p6Pro.to_str(), "kling_2p6_pro");
       assert_eq!(TaskModelType::Seedance10Lite.to_str(), "seedance_1.0_lite");
+      assert_eq!(TaskModelType::Seedance2p0.to_str(), "seedance_2p0");
       assert_eq!(TaskModelType::Sora2.to_str(), "sora_2");
       assert_eq!(TaskModelType::Sora2Pro.to_str(), "sora_2_pro");
       assert_eq!(TaskModelType::Veo2.to_str(), "veo_2");
@@ -352,6 +359,7 @@ mod tests {
       assert_eq!(TaskModelType::from_str("kling_2p5_turbo_pro").unwrap(), TaskModelType::Kling2p5TurboPro);
       assert_eq!(TaskModelType::from_str("kling_2p6_pro").unwrap(), TaskModelType::Kling2p6Pro);
       assert_eq!(TaskModelType::from_str("seedance_1.0_lite").unwrap(), TaskModelType::Seedance10Lite);
+      assert_eq!(TaskModelType::from_str("seedance_2p0").unwrap(), TaskModelType::Seedance2p0);
       assert_eq!(TaskModelType::from_str("sora_2").unwrap(), TaskModelType::Sora2);
       assert_eq!(TaskModelType::from_str("sora_2_pro").unwrap(), TaskModelType::Sora2Pro);
       assert_eq!(TaskModelType::from_str("veo_2").unwrap(), TaskModelType::Veo2);
@@ -380,7 +388,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = TaskModelType::all_variants();
-      assert_eq!(variants.len(), 35);
+      assert_eq!(variants.len(), 36);
       // Image models
       assert_eq!(variants.pop_first(), Some(TaskModelType::Flux1Dev));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Flux1Schnell));
@@ -407,6 +415,7 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(TaskModelType::Kling2p5TurboPro));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Kling2p6Pro));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Seedance10Lite));
+      assert_eq!(variants.pop_first(), Some(TaskModelType::Seedance2p0));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Sora2));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Sora2Pro));
       assert_eq!(variants.pop_first(), Some(TaskModelType::Veo2));