report more

Cargo.lock

@@ -2377,6 +2377,20 @@ dependencies = [
  "tokio-util",
 ]
 
+[[package]]
+name = "comet_api_client"
+version = "0.0.1"
+dependencies = [
+ "log",
+ "reqwest 0.12.23",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "test_data",
+ "tokio",
+ "workspace-build-acceleration",
+]
+
 [[package]]
 name = "compact_str"
 version = "0.7.1"

Cargo.toml

@@ -10,6 +10,7 @@ members = [
   "crates/api_clients/artcraft/artcraft_client",
   "crates/api_clients/artcraft/artcraft_router",
   "crates/api_clients/cloud_storage",
+  "crates/api_clients/comet_api_client",
   "crates/api_clients/datadog_client",
   "crates/api_clients/fal_client",
   "crates/api_clients/google_drive_downloader",

crates/api_clients/comet_api_client/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "comet_api_client"
+edition = "2024"
+version = "0.0.1"
+publish = false
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["workspace-build-acceleration"]
+
+[lib]
+name = "comet_api_client"
+path = "src/lib.rs"
+
+[dependencies]
+# Workspace hack (faster compile times)
+workspace-build-acceleration.workspace = true
+
+# External
+log.workspace = true
+# `multipart` is enabled on top of the workspace feature set because the
+# CometAPI video creation endpoint takes `multipart/form-data` (the
+# `input_reference` image fields are binary parts).
+reqwest = { workspace = true, features = ["multipart"] }
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+
+[dev-dependencies]
+test_data = { path = "../../testing/test_data" }
+tokio = { version = "1", features = ["full"] }

crates/api_clients/comet_api_client/src/creds/comet_api_key.rs

@@ -0,0 +1,17 @@
+/// A CometAPI key used for Bearer token authentication.
+#[derive(Clone)]
+pub struct CometApiKey(pub String);
+
+impl CometApiKey {
+  pub fn new(api_key: String) -> Self {
+    Self(api_key.trim().to_string())
+  }
+
+  pub fn from_str(api_key: &str) -> Self {
+    Self(api_key.trim().to_string())
+  }
+
+  pub fn as_str(&self) -> &str {
+    &self.0
+  }
+}

crates/api_clients/comet_api_client/src/creds/mod.rs

@@ -0,0 +1 @@
+pub mod comet_api_key;

crates/api_clients/comet_api_client/src/error/categorize_comet_error.rs

@@ -0,0 +1,157 @@
+use reqwest::StatusCode;
+
+use crate::error::comet_bad_request_api_error::CometBadRequestApiError;
+use crate::error::comet_error::CometError;
+use crate::error::comet_generic_api_error::CometGenericApiError;
+use crate::error::comet_specific_api_error::CometSpecificApiError;
+
+/// Marker CometAPI returns from `GET /v1/videos/{id}` for unknown task ids.
+const TASK_NOT_EXIST_MARKER: &str = "task_not_exist";
+
+/// Categorize a non-success response from the video creation endpoint
+/// (`POST /v1/videos`).
+///
+/// Per the docs, 400s from this endpoint mean the request itself was invalid
+/// (missing prompt, out-of-range duration, image input on an unsupported
+/// model) — the caller's fault, surfaced as [`CometBadRequestApiError`].
+pub fn categorize_create_video_error(
+  status_code: StatusCode,
+  body: String,
+) -> CometError {
+  if status_code == StatusCode::UNAUTHORIZED {
+    return CometSpecificApiError::UnauthorizedInvalidApiKey { raw_body: body }.into();
+  }
+
+  if status_code == StatusCode::BAD_REQUEST {
+    return CometBadRequestApiError::InvalidRequestParameters { raw_body: body }.into();
+  }
+
+  CometGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+    status_code,
+    body,
+  }.into()
+}
+
+/// Categorize a non-success response from the poll endpoint
+/// (`GET /v1/videos/{id}`).
+///
+/// Unlike the creation endpoint, a 400 here means the task id is unknown
+/// ("task_not_exist") — a specific, well-known cause rather than a
+/// user-facing bad request.
+pub fn categorize_get_video_task_error(
+  status_code: StatusCode,
+  body: String,
+  task_id: &str,
+) -> CometError {
+  if status_code == StatusCode::UNAUTHORIZED {
+    return CometSpecificApiError::UnauthorizedInvalidApiKey { raw_body: body }.into();
+  }
+
+  if status_code == StatusCode::BAD_REQUEST && body.contains(TASK_NOT_EXIST_MARKER) {
+    return CometSpecificApiError::TaskNotFound {
+      task_id: task_id.to_string(),
+      raw_body: body,
+    }.into();
+  }
+
+  CometGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+    status_code,
+    body,
+  }.into()
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  mod create_video_tests {
+    use super::*;
+
+    #[test]
+    fn bad_request_is_caller_fault() {
+      let body = r#"{"error":{"message":"seconds must be between 4 and 15","type":"invalid_request_error"}}"#.to_string();
+
+      let error = categorize_create_video_error(StatusCode::BAD_REQUEST, body.clone());
+
+      match error {
+        CometError::ApiBadRequest(CometBadRequestApiError::InvalidRequestParameters { raw_body }) => {
+          assert_eq!(raw_body, body);
+        }
+        other => panic!("Expected InvalidRequestParameters, got: {:?}", other),
+      }
+    }
+
+    #[test]
+    fn unauthorized_is_specific() {
+      let body = r#"{"error":{"message":"invalid token","type":"cometapi_error"}}"#.to_string();
+
+      let error = categorize_create_video_error(StatusCode::UNAUTHORIZED, body);
+
+      match error {
+        CometError::ApiSpecific(CometSpecificApiError::UnauthorizedInvalidApiKey { raw_body }) => {
+          assert!(raw_body.contains("invalid token"));
+        }
+        other => panic!("Expected UnauthorizedInvalidApiKey, got: {:?}", other),
+      }
+    }
+
+    #[test]
+    fn server_errors_fall_back_to_uncategorized() {
+      let error = categorize_create_video_error(
+        StatusCode::BAD_GATEWAY,
+        "upstream timeout".to_string(),
+      );
+
+      match &error {
+        CometError::ApiGeneric(CometGenericApiError::UncategorizedBadResponseWithStatusAndBody { status_code, .. }) => {
+          assert_eq!(*status_code, StatusCode::BAD_GATEWAY);
+        }
+        other => panic!("Expected UncategorizedBadResponseWithStatusAndBody, got: {:?}", other),
+      }
+      assert!(error.is_having_downtime_issues());
+    }
+  }
+
+  mod get_video_task_tests {
+    use super::*;
+
+    #[test]
+    fn task_not_exist_is_task_not_found() {
+      let body = r#"{"error":{"message":"task_not_exist","type":"cometapi_error"}}"#.to_string();
+
+      let error = categorize_get_video_task_error(StatusCode::BAD_REQUEST, body, "task_abc123");
+
+      match error {
+        CometError::ApiSpecific(CometSpecificApiError::TaskNotFound { task_id, raw_body }) => {
+          assert_eq!(task_id, "task_abc123");
+          assert!(raw_body.contains("task_not_exist"));
+        }
+        other => panic!("Expected TaskNotFound, got: {:?}", other),
+      }
+    }
+
+    #[test]
+    fn other_bad_requests_fall_back_to_uncategorized() {
+      let body = r#"{"error":{"message":"something else"}}"#.to_string();
+
+      let error = categorize_get_video_task_error(StatusCode::BAD_REQUEST, body, "task_abc123");
+
+      match error {
+        CometError::ApiGeneric(CometGenericApiError::UncategorizedBadResponseWithStatusAndBody { .. }) => {}
+        other => panic!("Expected UncategorizedBadResponseWithStatusAndBody, got: {:?}", other),
+      }
+    }
+
+    #[test]
+    fn unauthorized_is_specific() {
+      let body = r#"{"error":{"message":"invalid token"}}"#.to_string();
+
+      let error = categorize_get_video_task_error(StatusCode::UNAUTHORIZED, body, "task_abc123");
+
+      match error {
+        CometError::ApiSpecific(CometSpecificApiError::UnauthorizedInvalidApiKey { .. }) => {}
+        other => panic!("Expected UnauthorizedInvalidApiKey, got: {:?}", other),
+      }
+    }
+  }
+}

crates/api_clients/comet_api_client/src/error/comet_bad_request_api_error.rs

@@ -0,0 +1,22 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+/// These represent known "400s" that are the fault of the client sending a
+/// bad request. They should surface to the end user as 400s.
+#[derive(Debug)]
+pub enum CometBadRequestApiError {
+  /// The video creation request was rejected for invalid parameters (eg.
+  /// missing prompt, out-of-range duration, an `input_reference` image on a
+  /// model that doesn't support image input).
+  InvalidRequestParameters { raw_body: String },
+}
+
+impl Error for CometBadRequestApiError {}
+
+impl Display for CometBadRequestApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::InvalidRequestParameters { raw_body } => write!(f, "Invalid request parameters: {}", raw_body),
+    }
+  }
+}

crates/api_clients/comet_api_client/src/error/comet_client_error.rs

@@ -0,0 +1,26 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug)]
+pub enum CometClientError {
+  /// An error was encountered building the reqwest client or the request.
+  ReqwestClientError(reqwest::Error),
+
+  /// A request field couldn't be validated or converted to the value
+  /// expected on the wire. Carries the field name and the raw input the
+  /// caller supplied.
+  InvalidRequestField { field: &'static str, raw_value: String, reason: String },
+}
+
+impl Error for CometClientError {}
+
+impl Display for CometClientError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::ReqwestClientError(err) => write!(f, "Reqwest client error: {}", err),
+      Self::InvalidRequestField { field, raw_value, reason } => {
+        write!(f, "Invalid value for request field `{}`: {:?} ({})", field, raw_value, reason)
+      }
+    }
+  }
+}

crates/api_clients/comet_api_client/src/error/comet_error.rs

@@ -0,0 +1,71 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+use crate::error::comet_bad_request_api_error::CometBadRequestApiError;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_generic_api_error::CometGenericApiError;
+use crate::error::comet_specific_api_error::CometSpecificApiError;
+
+#[derive(Debug)]
+pub enum CometError {
+  /// An error that happened client-side (before or while making the request).
+  Client(CometClientError),
+
+  /// Known "400s" that are the fault of the client sending a bad request.
+  /// These should surface to the end user as 400s.
+  ApiBadRequest(CometBadRequestApiError),
+
+  /// Server-side errors with specific, well-known causes.
+  ApiSpecific(CometSpecificApiError),
+
+  /// Server-side errors with unknown / grab-bag causes.
+  ApiGeneric(CometGenericApiError),
+}
+
+impl CometError {
+  pub fn is_having_downtime_issues(&self) -> bool {
+    match self {
+      Self::ApiGeneric(CometGenericApiError::UncategorizedBadResponseWithStatusAndBody { status_code, body: _ }) => {
+        matches!(status_code.as_u16(), 502 | 503 | 504 | 524)
+      },
+      _ => false,
+    }
+  }
+}
+
+impl Error for CometError {}
+
+impl Display for CometError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::Client(e) => write!(f, "CometClientError: {:?}", e),
+      Self::ApiBadRequest(e) => write!(f, "CometBadRequestApiError: {:?}", e),
+      Self::ApiSpecific(e) => write!(f, "CometSpecificApiError: {:?}", e),
+      Self::ApiGeneric(e) => write!(f, "CometGenericApiError: {:?}", e),
+    }
+  }
+}
+
+impl From<CometClientError> for CometError {
+  fn from(error: CometClientError) -> Self {
+    Self::Client(error)
+  }
+}
+
+impl From<CometBadRequestApiError> for CometError {
+  fn from(error: CometBadRequestApiError) -> Self {
+    Self::ApiBadRequest(error)
+  }
+}
+
+impl From<CometSpecificApiError> for CometError {
+  fn from(error: CometSpecificApiError) -> Self {
+    Self::ApiSpecific(error)
+  }
+}
+
+impl From<CometGenericApiError> for CometError {
+  fn from(error: CometGenericApiError) -> Self {
+    Self::ApiGeneric(error)
+  }
+}

crates/api_clients/comet_api_client/src/error/comet_generic_api_error.rs

@@ -0,0 +1,33 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+use reqwest::StatusCode;
+
+/// Server-side errors with unknown / grab-bag causes.
+#[derive(Debug)]
+pub enum CometGenericApiError {
+  /// serde_json::Error, likely from a JSON deserialization schema mismatch.
+  /// Includes the original body.
+  SerdeResponseParseErrorWithBody(serde_json::Error, String),
+
+  /// An uncategorized bad HTTP response with status code and body.
+  UncategorizedBadResponseWithStatusAndBody {
+    status_code: StatusCode,
+    body: String,
+  },
+
+  /// An uncaught error from the HTTP client (network failures, timeouts, etc.)
+  ReqwestError(reqwest::Error),
+}
+
+impl Error for CometGenericApiError {}
+
+impl Display for CometGenericApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::SerdeResponseParseErrorWithBody(err, body) => write!(f, "Failed to parse response body: {:?}. Body: {}", err, body),
+      Self::UncategorizedBadResponseWithStatusAndBody { status_code, body } => write!(f, "Uncategorized bad response: status code {}, body: {}", status_code, body),
+      Self::ReqwestError(err) => write!(f, "Reqwest error: {}", err),
+    }
+  }
+}

crates/api_clients/comet_api_client/src/error/comet_specific_api_error.rs

@@ -0,0 +1,23 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+/// Server-side errors with specific, well-known causes.
+#[derive(Debug)]
+pub enum CometSpecificApiError {
+  /// 401: the API key is missing or invalid.
+  UnauthorizedInvalidApiKey { raw_body: String },
+
+  /// The poll endpoint responded "task_not_exist" for the given task id.
+  TaskNotFound { task_id: String, raw_body: String },
+}
+
+impl Error for CometSpecificApiError {}
+
+impl Display for CometSpecificApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::UnauthorizedInvalidApiKey { raw_body } => write!(f, "Unauthorized: invalid or missing API key: {}", raw_body),
+      Self::TaskNotFound { task_id, raw_body } => write!(f, "Task not found: {} ({})", task_id, raw_body),
+    }
+  }
+}

crates/api_clients/comet_api_client/src/error/mod.rs

@@ -0,0 +1,6 @@
+pub mod categorize_comet_error;
+pub mod comet_bad_request_api_error;
+pub mod comet_client_error;
+pub mod comet_error;
+pub mod comet_generic_api_error;
+pub mod comet_specific_api_error;

crates/api_clients/comet_api_client/src/generate/mod.rs

@@ -0,0 +1 @@
+pub mod video;

crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p0_pro.rs

@@ -0,0 +1,146 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometVideoModelRaw, CometVideoSize, CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Seedance 1.0 Pro supports 2-10 second durations.
+const MIN_DURATION_SECONDS: u8 = 2;
+const MAX_DURATION_SECONDS: u8 = 10;
+
+// ── Args ──
+
+pub struct GenerateDoubaoSeedance1p0ProArgs<'a> {
+  pub request: GenerateDoubaoSeedance1p0ProRequest,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+/// NB: Seedance 1.0 Pro is text-only — `input_reference` images are not
+/// supported, so this request deliberately has no image field.
+#[derive(Clone, Debug)]
+pub struct GenerateDoubaoSeedance1p0ProRequest {
+  pub prompt: String,
+
+  /// 2-10 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  pub size: Option<DoubaoSeedance1p0ProSize>,
+}
+
+// ── Enums ──
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance1p0ProSize {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  UltraWide21x9,
+  Exact { width: u32, height: u32 },
+}
+
+// ── Response ──
+
+pub struct GenerateDoubaoSeedance1p0ProResponse {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_doubao_seedance_1p0_pro(
+  args: GenerateDoubaoSeedance1p0ProArgs<'_>,
+) -> Result<GenerateDoubaoSeedance1p0ProResponse, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateDoubaoSeedance1p0ProResponse {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateDoubaoSeedance1p0ProRequest {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Seedance 1.0 Pro supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::DoubaoSeedance1p0Pro,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: vec![],
+    })
+  }
+}
+
+fn map_size(size: DoubaoSeedance1p0ProSize) -> CometVideoSize {
+  match size {
+    DoubaoSeedance1p0ProSize::Landscape16x9 => CometVideoSize::Landscape16x9,
+    DoubaoSeedance1p0ProSize::Standard4x3 => CometVideoSize::Standard4x3,
+    DoubaoSeedance1p0ProSize::Square1x1 => CometVideoSize::Square,
+    DoubaoSeedance1p0ProSize::Portrait3x4 => CometVideoSize::Portrait3x4,
+    DoubaoSeedance1p0ProSize::Portrait9x16 => CometVideoSize::Portrait9x16,
+    DoubaoSeedance1p0ProSize::UltraWide21x9 => CometVideoSize::UltraWide21x9,
+    DoubaoSeedance1p0ProSize::Exact { width, height } => CometVideoSize::Exact { width, height },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateDoubaoSeedance1p0ProRequest {
+      prompt: "time lapse of a city at dusk".to_string(),
+      duration_seconds: Some(2),
+      size: Some(DoubaoSeedance1p0ProSize::Square1x1),
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "doubao-seedance-1-0-pro".to_string()),
+      ("prompt", "time lapse of a city at dusk".to_string()),
+      ("seconds", "2".to_string()),
+      ("size", "1:1".to_string()),
+    ]);
+    assert!(raw.input_reference_images.is_empty());
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(1)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(2)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(10)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(11)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateDoubaoSeedance1p0ProRequest {
+    GenerateDoubaoSeedance1p0ProRequest {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p5_pro.rs

@@ -0,0 +1,146 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometVideoModelRaw, CometVideoSize, CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Seedance 1.5 Pro supports 4-12 second durations.
+const MIN_DURATION_SECONDS: u8 = 4;
+const MAX_DURATION_SECONDS: u8 = 12;
+
+// ── Args ──
+
+pub struct GenerateDoubaoSeedance1p5ProArgs<'a> {
+  pub request: GenerateDoubaoSeedance1p5ProRequest,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+/// NB: Seedance 1.5 Pro is text-only — `input_reference` images are not
+/// supported, so this request deliberately has no image field.
+#[derive(Clone, Debug)]
+pub struct GenerateDoubaoSeedance1p5ProRequest {
+  pub prompt: String,
+
+  /// 4-12 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  pub size: Option<DoubaoSeedance1p5ProSize>,
+}
+
+// ── Enums ──
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance1p5ProSize {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  UltraWide21x9,
+  Exact { width: u32, height: u32 },
+}
+
+// ── Response ──
+
+pub struct GenerateDoubaoSeedance1p5ProResponse {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_doubao_seedance_1p5_pro(
+  args: GenerateDoubaoSeedance1p5ProArgs<'_>,
+) -> Result<GenerateDoubaoSeedance1p5ProResponse, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateDoubaoSeedance1p5ProResponse {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateDoubaoSeedance1p5ProRequest {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Seedance 1.5 Pro supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::DoubaoSeedance1p5Pro,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: vec![],
+    })
+  }
+}
+
+fn map_size(size: DoubaoSeedance1p5ProSize) -> CometVideoSize {
+  match size {
+    DoubaoSeedance1p5ProSize::Landscape16x9 => CometVideoSize::Landscape16x9,
+    DoubaoSeedance1p5ProSize::Standard4x3 => CometVideoSize::Standard4x3,
+    DoubaoSeedance1p5ProSize::Square1x1 => CometVideoSize::Square,
+    DoubaoSeedance1p5ProSize::Portrait3x4 => CometVideoSize::Portrait3x4,
+    DoubaoSeedance1p5ProSize::Portrait9x16 => CometVideoSize::Portrait9x16,
+    DoubaoSeedance1p5ProSize::UltraWide21x9 => CometVideoSize::UltraWide21x9,
+    DoubaoSeedance1p5ProSize::Exact { width, height } => CometVideoSize::Exact { width, height },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateDoubaoSeedance1p5ProRequest {
+      prompt: "a paper boat in a storm drain".to_string(),
+      duration_seconds: Some(12),
+      size: Some(DoubaoSeedance1p5ProSize::Portrait9x16),
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "doubao-seedance-1-5-pro".to_string()),
+      ("prompt", "a paper boat in a storm drain".to_string()),
+      ("seconds", "12".to_string()),
+      ("size", "9:16".to_string()),
+    ]);
+    assert!(raw.input_reference_images.is_empty());
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(3)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(4)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(12)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(13)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateDoubaoSeedance1p5ProRequest {
+    GenerateDoubaoSeedance1p5ProRequest {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0.rs

@@ -0,0 +1,471 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Seedance 2.0 supports 4-15 second durations.
+const MIN_DURATION_SECONDS: u8 = 4;
+const MAX_DURATION_SECONDS: u8 = 15;
+
+/// The API default duration when `seconds` is omitted.
+const DEFAULT_DURATION_SECONDS: u8 = 5;
+
+// ── Args ──
+
+pub struct GenerateDoubaoSeedance2p0Args<'a> {
+  pub request: GenerateDoubaoSeedance2p0Request,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateDoubaoSeedance2p0Request {
+  /// Reference attached images in the prompt as `[Image 1]`, `[Image 2]`, etc.
+  pub prompt: String,
+
+  /// 4-15 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  /// `None` defaults to 16:9 (when a resolution is set).
+  pub aspect_ratio: Option<DoubaoSeedance2p0AspectRatio>,
+
+  /// `None` defaults to 720p (when an aspect ratio is set).
+  pub resolution: Option<DoubaoSeedance2p0Resolution>,
+
+  /// Reference images (JPEG, PNG, WebP) for image-to-video.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance2p0AspectRatio {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  UltraWide21x9,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance2p0Resolution {
+  FourEightyP,
+  SevenTwentyP,
+  TenEightyP,
+}
+
+// ── Pricing ──
+//
+// Seedance 2.0 per-second USD pricing (via CometAPI):
+//
+// | Resolution | $/sec  |
+// |------------|--------|
+// | 480p       | 0.063  |
+// | 720p       | 0.1368 |
+// | 1080p      | 0.3366 |
+//
+// Total cost = price per second × video duration (seconds).
+
+impl GenerateDoubaoSeedance2p0Request {
+  /// Estimate the USD cost in cents for this generation request.
+  pub fn estimate_cost_in_usd_cents(&self) -> u64 {
+    let dollars_per_second: f64 = match self.resolution {
+      Some(DoubaoSeedance2p0Resolution::FourEightyP) => 0.063,
+      // Default resolution (None) is 720p.
+      Some(DoubaoSeedance2p0Resolution::SevenTwentyP) | None => 0.1368,
+      Some(DoubaoSeedance2p0Resolution::TenEightyP) => 0.3366,
+    };
+    let seconds = self.duration_seconds.unwrap_or(DEFAULT_DURATION_SECONDS);
+    (f64::from(seconds) * dollars_per_second * 100.0).round() as u64
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateDoubaoSeedance2p0Response {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_doubao_seedance_2p0(
+  args: GenerateDoubaoSeedance2p0Args<'_>,
+) -> Result<GenerateDoubaoSeedance2p0Response, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateDoubaoSeedance2p0Response {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateDoubaoSeedance2p0Request {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Seedance 2.0 supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::DoubaoSeedance2p0,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.resolve_size(),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+
+  /// The wire `size` is a single exact-dimensions field determined by the
+  /// (aspect ratio, resolution) pair. Dimensions mirror CometAPI's own
+  /// playground options for `doubao-seedance-2-0`. When neither knob is
+  /// set, `size` is omitted and the API picks its default.
+  fn resolve_size(&self) -> Option<CometVideoSize> {
+    if self.aspect_ratio.is_none() && self.resolution.is_none() {
+      return None;
+    }
+
+    let aspect_ratio = self.aspect_ratio.unwrap_or(DoubaoSeedance2p0AspectRatio::Landscape16x9);
+    let resolution = self.resolution.unwrap_or(DoubaoSeedance2p0Resolution::SevenTwentyP);
+
+    use DoubaoSeedance2p0AspectRatio as Ratio;
+    use DoubaoSeedance2p0Resolution as Res;
+
+    let (width, height) = match (resolution, aspect_ratio) {
+      (Res::FourEightyP, Ratio::Landscape16x9) => (864, 496),
+      (Res::FourEightyP, Ratio::Standard4x3) => (752, 560),
+      (Res::FourEightyP, Ratio::Square1x1) => (640, 640),
+      (Res::FourEightyP, Ratio::Portrait3x4) => (560, 752),
+      (Res::FourEightyP, Ratio::Portrait9x16) => (496, 864),
+      (Res::FourEightyP, Ratio::UltraWide21x9) => (992, 432),
+
+      (Res::SevenTwentyP, Ratio::Landscape16x9) => (1280, 720),
+      (Res::SevenTwentyP, Ratio::Standard4x3) => (1112, 834),
+      (Res::SevenTwentyP, Ratio::Square1x1) => (960, 960),
+      (Res::SevenTwentyP, Ratio::Portrait3x4) => (834, 1112),
+      (Res::SevenTwentyP, Ratio::Portrait9x16) => (720, 1280),
+      (Res::SevenTwentyP, Ratio::UltraWide21x9) => (1470, 630),
+
+      (Res::TenEightyP, Ratio::Landscape16x9) => (1920, 1080),
+      (Res::TenEightyP, Ratio::Standard4x3) => (1664, 1248),
+      (Res::TenEightyP, Ratio::Square1x1) => (1440, 1440),
+      (Res::TenEightyP, Ratio::Portrait3x4) => (1248, 1664),
+      (Res::TenEightyP, Ratio::Portrait9x16) => (1080, 1920),
+      (Res::TenEightyP, Ratio::UltraWide21x9) => (2206, 946),
+    };
+
+    Some(CometVideoSize::Exact { width, height })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  use DoubaoSeedance2p0AspectRatio as Ratio;
+  use DoubaoSeedance2p0Resolution as Res;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateDoubaoSeedance2p0Request {
+      prompt: "animate [Image 1]".to_string(),
+      duration_seconds: Some(8),
+      aspect_ratio: Some(Ratio::UltraWide21x9),
+      resolution: Some(Res::TenEightyP),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "doubao-seedance-2-0".to_string()),
+      ("prompt", "animate [Image 1]".to_string()),
+      ("seconds", "8".to_string()),
+      ("size", "2206x946".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn size_matrix_matches_cometapi_playground() {
+    // (resolution, ratio) -> exact size, as offered by CometAPI's own
+    // playground dropdown for doubao-seedance-2-0.
+    let cases = [
+      (Res::FourEightyP, Ratio::Landscape16x9, "864x496"),
+      (Res::FourEightyP, Ratio::Standard4x3, "752x560"),
+      (Res::FourEightyP, Ratio::Square1x1, "640x640"),
+      (Res::FourEightyP, Ratio::Portrait3x4, "560x752"),
+      (Res::FourEightyP, Ratio::Portrait9x16, "496x864"),
+      (Res::FourEightyP, Ratio::UltraWide21x9, "992x432"),
+      (Res::SevenTwentyP, Ratio::Landscape16x9, "1280x720"),
+      (Res::SevenTwentyP, Ratio::Standard4x3, "1112x834"),
+      (Res::SevenTwentyP, Ratio::Square1x1, "960x960"),
+      (Res::SevenTwentyP, Ratio::Portrait3x4, "834x1112"),
+      (Res::SevenTwentyP, Ratio::Portrait9x16, "720x1280"),
+      (Res::SevenTwentyP, Ratio::UltraWide21x9, "1470x630"),
+      (Res::TenEightyP, Ratio::Landscape16x9, "1920x1080"),
+      (Res::TenEightyP, Ratio::Standard4x3, "1664x1248"),
+      (Res::TenEightyP, Ratio::Square1x1, "1440x1440"),
+      (Res::TenEightyP, Ratio::Portrait3x4, "1248x1664"),
+      (Res::TenEightyP, Ratio::Portrait9x16, "1080x1920"),
+      (Res::TenEightyP, Ratio::UltraWide21x9, "2206x946"),
+    ];
+
+    for (resolution, aspect_ratio, expected) in cases {
+      let request = base_request(Some(aspect_ratio), Some(resolution));
+      let size = request.resolve_size().expect("should resolve");
+      assert_eq!(size.as_api_string(), expected,
+        "({resolution:?}, {aspect_ratio:?}) should map to {expected}");
+    }
+  }
+
+  #[test]
+  fn size_defaults() {
+    // Neither knob set: omit size, let the API default.
+    assert!(base_request(None, None).resolve_size().is_none());
+
+    // Only ratio set: resolution defaults to 720p.
+    let size = base_request(Some(Ratio::Portrait9x16), None).resolve_size().expect("should resolve");
+    assert_eq!(size.as_api_string(), "720x1280");
+
+    // Only resolution set: ratio defaults to 16:9.
+    let size = base_request(None, Some(Res::TenEightyP)).resolve_size().expect("should resolve");
+    assert_eq!(size.as_api_string(), "1920x1080");
+  }
+
+  #[test]
+  fn duration_bounds() {
+    let mut request = base_request(None, None);
+    for (seconds, ok) in [(Some(3), false), (Some(4), true), (Some(15), true), (Some(16), false), (None, true)] {
+      request.duration_seconds = seconds;
+      assert_eq!(request.to_create_video_request().is_ok(), ok, "seconds: {seconds:?}");
+    }
+  }
+
+  #[test]
+  fn cost_estimates() {
+    // 5 seconds at 480p: 5 × $0.063 = $0.315 -> 32¢
+    let mut request = base_request(None, Some(Res::FourEightyP));
+    request.duration_seconds = Some(5);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 32);
+
+    // 10 seconds at 1080p: 10 × $0.3366 = $3.366 -> 337¢
+    request.resolution = Some(Res::TenEightyP);
+    request.duration_seconds = Some(10);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 337);
+
+    // Defaults (5 seconds, 720p): 5 × $0.1368 = $0.684 -> 68¢
+    request.resolution = None;
+    request.duration_seconds = None;
+    assert_eq!(request.estimate_cost_in_usd_cents(), 68);
+  }
+
+  fn base_request(
+    aspect_ratio: Option<DoubaoSeedance2p0AspectRatio>,
+    resolution: Option<DoubaoSeedance2p0Resolution>,
+  ) -> GenerateDoubaoSeedance2p0Request {
+    GenerateDoubaoSeedance2p0Request {
+      prompt: "ok".to_string(),
+      duration_seconds: None,
+      aspect_ratio,
+      resolution,
+      input_reference_images: vec![],
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────────────
+  // ⚠️  EXPENSIVE LIVE TESTS  ⚠️
+  //
+  // Each test below enqueues a REAL 10-second Seedance 2.0 generation with
+  // four reference images and polls it to completion. These INCUR REAL
+  // COSTS (per CometAPI's per-second pricing):
+  //
+  //   480p:  10s × $0.063  ≈ $0.63
+  //   720p:  10s × $0.1368 ≈ $1.37
+  //   1080p: 10s × $0.3366 ≈ $3.37
+  //
+  // They also take a while — generations have been observed to run well
+  // past 10 minutes. Run one at a time, manually:
+  //
+  //   cargo test -p comet_api_client live_generate_480p -- --ignored --nocapture
+  // ─────────────────────────────────────────────────────────────────────
+  mod live_tests {
+    use std::time::Duration;
+
+    use test_data::web::image_urls::{
+      ERNEST_GHOST_TREX_IMAGE_URL,
+      FOREST_BACKDROP_IMAGE_URL,
+      GHOST_IMAGE_URL,
+      GRASSY_HILL_TRANSPARENT_IMAGE_URL,
+      JUNO_AT_LAKE_IMAGE_URL,
+      MOUNTAIN_TREE_IMAGE_URL,
+      SUPER_WIDE_FALL_MOUNTAINS_IMAGE_URL,
+      TALL_CORGI_SHIBA_TREASURE_OCEAN_URL,
+      TALL_MOCHI_WITH_GLASSES_IMAGE_URL,
+      TREX_SKELETON_IMAGE_URL,
+      WHITE_HOUSE_SUNSET_IMAGE_URL,
+      WIDE_CORGI_SHIBA_TREASURE_OCEAN_URL,
+    };
+
+    use super::*;
+    use crate::requests::get_video_task::get_video_task::{get_video_task, GetVideoTaskArgs};
+    use crate::test_utils::load_api_key;
+
+    /// ⚠️ EXPENSIVE: real 10s 480p generation (~$0.63) + a long poll.
+    #[ignore]
+    #[tokio::test]
+    async fn live_generate_480p_with_references() {
+      let input_reference_images = download_reference_images(&[
+        ERNEST_GHOST_TREX_IMAGE_URL,
+        GHOST_IMAGE_URL,
+        TREX_SKELETON_IMAGE_URL,
+        FOREST_BACKDROP_IMAGE_URL,
+      ]).await;
+
+      run_generation_to_completion(GenerateDoubaoSeedance2p0Request {
+        prompt: "The frightened man from [Image 1] runs through the dark forest \
+          from [Image 4], chased by the glowing ghost from [Image 2]. The t-rex \
+          skeleton from [Image 3] rises out of the leaves behind them. Spooky, \
+          comedic 90s horror movie tone."
+          .to_string(),
+        duration_seconds: Some(10),
+        aspect_ratio: Some(DoubaoSeedance2p0AspectRatio::Landscape16x9),
+        resolution: Some(DoubaoSeedance2p0Resolution::FourEightyP),
+        input_reference_images,
+      }).await;
+    }
+
+    /// ⚠️ EXPENSIVE: real 10s 720p generation (~$1.37) + a long poll.
+    #[ignore]
+    #[tokio::test]
+    async fn live_generate_720p_with_references() {
+      let input_reference_images = download_reference_images(&[
+        JUNO_AT_LAKE_IMAGE_URL,
+        TALL_MOCHI_WITH_GLASSES_IMAGE_URL,
+        TALL_CORGI_SHIBA_TREASURE_OCEAN_URL,
+        WIDE_CORGI_SHIBA_TREASURE_OCEAN_URL,
+      ]).await;
+
+      run_generation_to_completion(GenerateDoubaoSeedance2p0Request {
+        prompt: "The dog from [Image 1] and the bespectacled dog from [Image 2] \
+          join the corgi and shiba from [Image 3] on the beach, digging up the \
+          treasure chest from [Image 4] as waves roll in. Joyful, sunny \
+          adventure-film tone."
+          .to_string(),
+        duration_seconds: Some(10),
+        aspect_ratio: Some(DoubaoSeedance2p0AspectRatio::Landscape16x9),
+        resolution: Some(DoubaoSeedance2p0Resolution::SevenTwentyP),
+        input_reference_images,
+      }).await;
+    }
+
+    /// ⚠️ EXPENSIVE: real 10s 1080p generation (~$3.37) + a long poll.
+    #[ignore]
+    #[tokio::test]
+    async fn live_generate_1080p_with_references() {
+      let input_reference_images = download_reference_images(&[
+        GRASSY_HILL_TRANSPARENT_IMAGE_URL,
+        MOUNTAIN_TREE_IMAGE_URL,
+        SUPER_WIDE_FALL_MOUNTAINS_IMAGE_URL,
+        WHITE_HOUSE_SUNSET_IMAGE_URL,
+      ]).await;
+
+      run_generation_to_completion(GenerateDoubaoSeedance2p0Request {
+        prompt: "A cinematic drone shot glides over the grassy hill from \
+          [Image 1], past the lone tree on the mountainside from [Image 2], \
+          across the sweeping autumn mountain range from [Image 3], and settles \
+          on the white house at sunset from [Image 4]. Golden hour, slow and \
+          steady camera movement."
+          .to_string(),
+        duration_seconds: Some(10),
+        aspect_ratio: Some(DoubaoSeedance2p0AspectRatio::Landscape16x9),
+        resolution: Some(DoubaoSeedance2p0Resolution::TenEightyP),
+        input_reference_images,
+      }).await;
+    }
+
+    // ── Helpers ──
+
+    async fn download_reference_images(urls: &[&str]) -> Vec<CometInputReferenceImage> {
+      let mut images = Vec::with_capacity(urls.len());
+      for url in urls {
+        images.push(download_reference_image(url).await);
+      }
+      images
+    }
+
+    async fn download_reference_image(url: &str) -> CometInputReferenceImage {
+      let response = reqwest::get(url).await.expect("image download should succeed");
+      assert!(response.status().is_success(), "image download failed: {} ({})", url, response.status());
+
+      let filename = url.rsplit('/').next().expect("url should have a path").to_string();
+      let maybe_content_type = if filename.ends_with(".png") {
+        Some("image/png".to_string())
+      } else {
+        Some("image/jpeg".to_string())
+      };
+      let file_bytes = response.bytes().await.expect("image body should download").to_vec();
+
+      println!("Downloaded reference: {} ({} bytes)", filename, file_bytes.len());
+
+      CometInputReferenceImage {
+        file_bytes,
+        filename,
+        maybe_content_type,
+      }
+    }
+
+    /// Enqueue the generation, poll until terminal, and assert success.
+    async fn run_generation_to_completion(request: GenerateDoubaoSeedance2p0Request) {
+      // NB: Generations have been observed to run well past 10 minutes.
+      const POLL_INTERVAL: Duration = Duration::from_secs(15);
+      const MAX_POLLS: u32 = 120; // ~30 minutes
+
+      let api_key = load_api_key();
+      println!("Estimated cost: {}¢", request.estimate_cost_in_usd_cents());
+
+      let created = generate_doubao_seedance_2p0(GenerateDoubaoSeedance2p0Args {
+        request,
+        api_key: &api_key,
+      }).await.expect("generate_doubao_seedance_2p0 should succeed");
+
+      println!("Enqueued task: {} (status: {})", created.task_id, created.status);
+
+      for poll in 1..=MAX_POLLS {
+        tokio::time::sleep(POLL_INTERVAL).await;
+
+        let task = get_video_task(GetVideoTaskArgs {
+          api_key: &api_key,
+          task_id: &created.task_id,
+        }).await.expect("get_video_task should succeed");
+
+        println!("Poll {}: status {} (progress: {:?})", poll, task.status, task.maybe_progress);
+
+        if task.status.is_terminal() {
+          assert!(task.status.is_success(), "task should complete successfully: {:?}", task);
+          let video_url = task.maybe_video_url.expect("completed task should have a video url");
+          println!("Video URL: {}", video_url);
+          return;
+        }
+      }
+
+      panic!("Task {} did not reach a terminal state in time", created.task_id);
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0_fast.rs

@@ -0,0 +1,278 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Seedance 2.0 Fast supports 4-15 second durations.
+const MIN_DURATION_SECONDS: u8 = 4;
+const MAX_DURATION_SECONDS: u8 = 15;
+
+/// The API default duration when `seconds` is omitted.
+const DEFAULT_DURATION_SECONDS: u8 = 5;
+
+// ── Args ──
+
+pub struct GenerateDoubaoSeedance2p0FastArgs<'a> {
+  pub request: GenerateDoubaoSeedance2p0FastRequest,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateDoubaoSeedance2p0FastRequest {
+  /// Reference attached images in the prompt as `[Image 1]`, `[Image 2]`, etc.
+  pub prompt: String,
+
+  /// 4-15 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  /// `None` defaults to 16:9 (when a resolution is set).
+  pub aspect_ratio: Option<DoubaoSeedance2p0FastAspectRatio>,
+
+  /// `None` defaults to 720p (when an aspect ratio is set).
+  pub resolution: Option<DoubaoSeedance2p0FastResolution>,
+
+  /// Reference images (JPEG, PNG, WebP) for image-to-video.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance2p0FastAspectRatio {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  UltraWide21x9,
+}
+
+/// NB: 1080p is available for all Seedance models EXCEPT 2.0 Fast, so this
+/// enum deliberately has no 1080p variant.
+#[derive(Debug, Clone, Copy)]
+pub enum DoubaoSeedance2p0FastResolution {
+  FourEightyP,
+  SevenTwentyP,
+}
+
+// ── Pricing ──
+//
+// Seedance 2.0 Fast per-second USD pricing (via CometAPI):
+//
+// | Resolution | $/sec  |
+// |------------|--------|
+// | 480p       | 0.0504 |
+// | 720p       | 0.108  |
+//
+// Total cost = price per second × video duration (seconds).
+
+impl GenerateDoubaoSeedance2p0FastRequest {
+  /// Estimate the USD cost in cents for this generation request.
+  pub fn estimate_cost_in_usd_cents(&self) -> u64 {
+    let dollars_per_second: f64 = match self.resolution {
+      Some(DoubaoSeedance2p0FastResolution::FourEightyP) => 0.0504,
+      // Default resolution (None) is 720p.
+      Some(DoubaoSeedance2p0FastResolution::SevenTwentyP) | None => 0.108,
+    };
+    let seconds = self.duration_seconds.unwrap_or(DEFAULT_DURATION_SECONDS);
+    (f64::from(seconds) * dollars_per_second * 100.0).round() as u64
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateDoubaoSeedance2p0FastResponse {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_doubao_seedance_2p0_fast(
+  args: GenerateDoubaoSeedance2p0FastArgs<'_>,
+) -> Result<GenerateDoubaoSeedance2p0FastResponse, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateDoubaoSeedance2p0FastResponse {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateDoubaoSeedance2p0FastRequest {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Seedance 2.0 Fast supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::DoubaoSeedance2p0Fast,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.resolve_size(),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+
+  /// The wire `size` is a single exact-dimensions field determined by the
+  /// (aspect ratio, resolution) pair. Dimensions mirror CometAPI's own
+  /// playground options for the Seedance 2.0 family. When neither knob is
+  /// set, `size` is omitted and the API picks its default.
+  fn resolve_size(&self) -> Option<CometVideoSize> {
+    if self.aspect_ratio.is_none() && self.resolution.is_none() {
+      return None;
+    }
+
+    let aspect_ratio = self.aspect_ratio.unwrap_or(DoubaoSeedance2p0FastAspectRatio::Landscape16x9);
+    let resolution = self.resolution.unwrap_or(DoubaoSeedance2p0FastResolution::SevenTwentyP);
+
+    use DoubaoSeedance2p0FastAspectRatio as Ratio;
+    use DoubaoSeedance2p0FastResolution as Res;
+
+    let (width, height) = match (resolution, aspect_ratio) {
+      (Res::FourEightyP, Ratio::Landscape16x9) => (864, 496),
+      (Res::FourEightyP, Ratio::Standard4x3) => (752, 560),
+      (Res::FourEightyP, Ratio::Square1x1) => (640, 640),
+      (Res::FourEightyP, Ratio::Portrait3x4) => (560, 752),
+      (Res::FourEightyP, Ratio::Portrait9x16) => (496, 864),
+      (Res::FourEightyP, Ratio::UltraWide21x9) => (992, 432),
+
+      (Res::SevenTwentyP, Ratio::Landscape16x9) => (1280, 720),
+      (Res::SevenTwentyP, Ratio::Standard4x3) => (1112, 834),
+      (Res::SevenTwentyP, Ratio::Square1x1) => (960, 960),
+      (Res::SevenTwentyP, Ratio::Portrait3x4) => (834, 1112),
+      (Res::SevenTwentyP, Ratio::Portrait9x16) => (720, 1280),
+      (Res::SevenTwentyP, Ratio::UltraWide21x9) => (1470, 630),
+    };
+
+    Some(CometVideoSize::Exact { width, height })
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  use DoubaoSeedance2p0FastAspectRatio as Ratio;
+  use DoubaoSeedance2p0FastResolution as Res;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateDoubaoSeedance2p0FastRequest {
+      prompt: "a corgi surfing".to_string(),
+      duration_seconds: Some(4),
+      aspect_ratio: Some(Ratio::Landscape16x9),
+      resolution: Some(Res::FourEightyP),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "doubao-seedance-2-0-fast".to_string()),
+      ("prompt", "a corgi surfing".to_string()),
+      ("seconds", "4".to_string()),
+      ("size", "864x496".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn size_matrix_matches_cometapi_playground() {
+    // (resolution, ratio) -> exact size, as offered by CometAPI's own
+    // playground dropdown for the Seedance 2.0 family. No 1080p row: Fast
+    // doesn't support it (enforced by the resolution enum).
+    let cases = [
+      (Res::FourEightyP, Ratio::Landscape16x9, "864x496"),
+      (Res::FourEightyP, Ratio::Standard4x3, "752x560"),
+      (Res::FourEightyP, Ratio::Square1x1, "640x640"),
+      (Res::FourEightyP, Ratio::Portrait3x4, "560x752"),
+      (Res::FourEightyP, Ratio::Portrait9x16, "496x864"),
+      (Res::FourEightyP, Ratio::UltraWide21x9, "992x432"),
+      (Res::SevenTwentyP, Ratio::Landscape16x9, "1280x720"),
+      (Res::SevenTwentyP, Ratio::Standard4x3, "1112x834"),
+      (Res::SevenTwentyP, Ratio::Square1x1, "960x960"),
+      (Res::SevenTwentyP, Ratio::Portrait3x4, "834x1112"),
+      (Res::SevenTwentyP, Ratio::Portrait9x16, "720x1280"),
+      (Res::SevenTwentyP, Ratio::UltraWide21x9, "1470x630"),
+    ];
+
+    for (resolution, aspect_ratio, expected) in cases {
+      let request = base_request(Some(aspect_ratio), Some(resolution));
+      let size = request.resolve_size().expect("should resolve");
+      assert_eq!(size.as_api_string(), expected,
+        "({resolution:?}, {aspect_ratio:?}) should map to {expected}");
+    }
+  }
+
+  #[test]
+  fn size_defaults() {
+    // Neither knob set: omit size, let the API default.
+    assert!(base_request(None, None).resolve_size().is_none());
+
+    // Only ratio set: resolution defaults to 720p.
+    let size = base_request(Some(Ratio::Square1x1), None).resolve_size().expect("should resolve");
+    assert_eq!(size.as_api_string(), "960x960");
+
+    // Only resolution set: ratio defaults to 16:9.
+    let size = base_request(None, Some(Res::FourEightyP)).resolve_size().expect("should resolve");
+    assert_eq!(size.as_api_string(), "864x496");
+  }
+
+  #[test]
+  fn duration_bounds() {
+    let mut request = base_request(None, None);
+    for (seconds, ok) in [(Some(3), false), (Some(4), true), (Some(15), true), (Some(16), false), (None, true)] {
+      request.duration_seconds = seconds;
+      assert_eq!(request.to_create_video_request().is_ok(), ok, "seconds: {seconds:?}");
+    }
+  }
+
+  #[test]
+  fn cost_estimates() {
+    // 5 seconds at 480p: 5 × $0.0504 = $0.252 -> 25¢
+    let mut request = base_request(None, Some(Res::FourEightyP));
+    request.duration_seconds = Some(5);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 25);
+
+    // 15 seconds at 720p: 15 × $0.108 = $1.62 -> 162¢
+    request.resolution = Some(Res::SevenTwentyP);
+    request.duration_seconds = Some(15);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 162);
+
+    // Defaults (5 seconds, 720p): 5 × $0.108 = $0.54 -> 54¢
+    request.resolution = None;
+    request.duration_seconds = None;
+    assert_eq!(request.estimate_cost_in_usd_cents(), 54);
+  }
+
+  fn base_request(
+    aspect_ratio: Option<DoubaoSeedance2p0FastAspectRatio>,
+    resolution: Option<DoubaoSeedance2p0FastResolution>,
+  ) -> GenerateDoubaoSeedance2p0FastRequest {
+    GenerateDoubaoSeedance2p0FastRequest {
+      prompt: "ok".to_string(),
+      duration_seconds: None,
+      aspect_ratio,
+      resolution,
+      input_reference_images: vec![],
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3.rs

@@ -0,0 +1,162 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Vidu Q3 supports 1-16 second durations.
+const MIN_DURATION_SECONDS: u8 = 1;
+const MAX_DURATION_SECONDS: u8 = 16;
+
+// ── Args ──
+
+pub struct GenerateViduQ3Args<'a> {
+  pub request: GenerateViduQ3Request,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateViduQ3Request {
+  pub prompt: String,
+
+  /// 1-16 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  pub size: Option<ViduQ3Size>,
+
+  /// Reference images for image-to-video / start-end-to-video workflows.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+/// Vidu Q3 renders at 540p/720p/1080p (24 FPS). The API's `size` field takes
+/// an aspect ratio preset or exact dimensions (eg. 960x528).
+#[derive(Debug, Clone, Copy)]
+pub enum ViduQ3Size {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  Exact { width: u32, height: u32 },
+}
+
+// ── Pricing ──
+//
+// Vidu Q3 per-second USD pricing (via CometAPI):
+//
+// | Resolution  | $/sec   |
+// |-------------|---------|
+// | 360p/540p   | 0.056   |
+// | 720p/1080p  | 0.1232  |
+//
+// Total cost = price per second × video duration (seconds).
+// NB: Not modeled as an estimator because the `size` field is an aspect
+// ratio in the common case, which doesn't determine the billed resolution.
+
+// ── Response ──
+
+pub struct GenerateViduQ3Response {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_vidu_q3(
+  args: GenerateViduQ3Args<'_>,
+) -> Result<GenerateViduQ3Response, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateViduQ3Response {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateViduQ3Request {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Vidu Q3 supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::ViduQ3,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+}
+
+fn map_size(size: ViduQ3Size) -> CometVideoSize {
+  match size {
+    ViduQ3Size::Landscape16x9 => CometVideoSize::Landscape16x9,
+    ViduQ3Size::Standard4x3 => CometVideoSize::Standard4x3,
+    ViduQ3Size::Square1x1 => CometVideoSize::Square,
+    ViduQ3Size::Portrait3x4 => CometVideoSize::Portrait3x4,
+    ViduQ3Size::Portrait9x16 => CometVideoSize::Portrait9x16,
+    ViduQ3Size::Exact { width, height } => CometVideoSize::Exact { width, height },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateViduQ3Request {
+      prompt: "a lighthouse in fog".to_string(),
+      duration_seconds: Some(16),
+      size: Some(ViduQ3Size::Exact { width: 960, height: 528 }),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "viduq3".to_string()),
+      ("prompt", "a lighthouse in fog".to_string()),
+      ("seconds", "16".to_string()),
+      ("size", "960x528".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(0)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(1)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(16)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(17)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateViduQ3Request {
+    GenerateViduQ3Request {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+      input_reference_images: vec![],
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3_turbo.rs

@@ -0,0 +1,162 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Vidu Q3 Turbo supports 1-16 second durations.
+const MIN_DURATION_SECONDS: u8 = 1;
+const MAX_DURATION_SECONDS: u8 = 16;
+
+// ── Args ──
+
+pub struct GenerateViduQ3TurboArgs<'a> {
+  pub request: GenerateViduQ3TurboRequest,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateViduQ3TurboRequest {
+  pub prompt: String,
+
+  /// 1-16 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  pub size: Option<ViduQ3TurboSize>,
+
+  /// Reference images for image-to-video / start-end-to-video workflows.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+/// Vidu Q3 Turbo renders at 540p/720p/1080p (24 FPS). The API's `size` field
+/// takes an aspect ratio preset or exact dimensions (eg. 960x528).
+#[derive(Debug, Clone, Copy)]
+pub enum ViduQ3TurboSize {
+  Landscape16x9,
+  Standard4x3,
+  Square1x1,
+  Portrait3x4,
+  Portrait9x16,
+  Exact { width: u32, height: u32 },
+}
+
+// ── Pricing ──
+//
+// Vidu Q3 Turbo per-second USD pricing (via CometAPI):
+//
+// | Resolution  | $/sec   |
+// |-------------|---------|
+// | 360p/540p   | 0.028   |
+// | 720p/1080p  | 0.0616  |
+//
+// Total cost = price per second × video duration (seconds).
+// NB: Not modeled as an estimator because the `size` field is an aspect
+// ratio in the common case, which doesn't determine the billed resolution.
+
+// ── Response ──
+
+pub struct GenerateViduQ3TurboResponse {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_vidu_q3_turbo(
+  args: GenerateViduQ3TurboArgs<'_>,
+) -> Result<GenerateViduQ3TurboResponse, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateViduQ3TurboResponse {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateViduQ3TurboRequest {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Vidu Q3 Turbo supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::ViduQ3Turbo,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+}
+
+fn map_size(size: ViduQ3TurboSize) -> CometVideoSize {
+  match size {
+    ViduQ3TurboSize::Landscape16x9 => CometVideoSize::Landscape16x9,
+    ViduQ3TurboSize::Standard4x3 => CometVideoSize::Standard4x3,
+    ViduQ3TurboSize::Square1x1 => CometVideoSize::Square,
+    ViduQ3TurboSize::Portrait3x4 => CometVideoSize::Portrait3x4,
+    ViduQ3TurboSize::Portrait9x16 => CometVideoSize::Portrait9x16,
+    ViduQ3TurboSize::Exact { width, height } => CometVideoSize::Exact { width, height },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateViduQ3TurboRequest {
+      prompt: "raindrops on a window".to_string(),
+      duration_seconds: Some(1),
+      size: Some(ViduQ3TurboSize::Portrait9x16),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "viduq3-turbo".to_string()),
+      ("prompt", "raindrops on a window".to_string()),
+      ("seconds", "1".to_string()),
+      ("size", "9:16".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(0)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(1)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(16)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(17)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateViduQ3TurboRequest {
+    GenerateViduQ3TurboRequest {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+      input_reference_images: vec![],
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p6.rs

@@ -0,0 +1,216 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Wan 2.6 supports 2-15 second durations.
+const MIN_DURATION_SECONDS: u8 = 2;
+const MAX_DURATION_SECONDS: u8 = 15;
+
+/// The API default duration when `seconds` is omitted.
+const DEFAULT_DURATION_SECONDS: u8 = 5;
+
+/// Wan 2.6 accepts up to 5 references.
+const MAX_REFERENCE_IMAGES: usize = 5;
+
+// ── Args ──
+
+pub struct GenerateWan2p6Args<'a> {
+  pub request: GenerateWan2p6Request,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateWan2p6Request {
+  pub prompt: String,
+
+  /// 2-15 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  /// `None` uses the API default (720p).
+  pub size: Option<Wan2p6Size>,
+
+  /// Reference images for image-to-video and reference-to-video workflows.
+  /// Wan 2.6 accepts up to 5 references.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+/// Wan 2.6 renders at 720p or 1080p.
+#[derive(Debug, Clone, Copy)]
+pub enum Wan2p6Size {
+  SevenTwentyP,
+  TenEightyP,
+}
+
+// ── Pricing ──
+//
+// Wan 2.6 per-second USD pricing (via CometAPI):
+//
+// | Resolution | $/sec |
+// |------------|-------|
+// | 720p       | 0.08  |
+// | 1080p      | 0.12  |
+//
+// Total cost = price per second × video duration (seconds).
+
+impl GenerateWan2p6Request {
+  /// Estimate the USD cost in cents for this generation request.
+  pub fn estimate_cost_in_usd_cents(&self) -> u64 {
+    let cents_per_second: u64 = match self.size {
+      Some(Wan2p6Size::TenEightyP) => 12,
+      // Default resolution (None) is 720p.
+      Some(Wan2p6Size::SevenTwentyP) | None => 8,
+    };
+    let seconds = self.duration_seconds.unwrap_or(DEFAULT_DURATION_SECONDS);
+    u64::from(seconds) * cents_per_second
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateWan2p6Response {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_wan_2p6(
+  args: GenerateWan2p6Args<'_>,
+) -> Result<GenerateWan2p6Response, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateWan2p6Response {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateWan2p6Request {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Wan 2.6 supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    if self.input_reference_images.len() > MAX_REFERENCE_IMAGES {
+      return Err(CometClientError::InvalidRequestField {
+        field: "input_reference_images",
+        raw_value: self.input_reference_images.len().to_string(),
+        reason: format!("Wan 2.6 accepts at most {MAX_REFERENCE_IMAGES} references"),
+      });
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::Wan2p6,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+}
+
+fn map_size(size: Wan2p6Size) -> CometVideoSize {
+  match size {
+    Wan2p6Size::SevenTwentyP => CometVideoSize::Exact { width: 1280, height: 720 },
+    Wan2p6Size::TenEightyP => CometVideoSize::Exact { width: 1920, height: 1080 },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateWan2p6Request {
+      prompt: "a steam train crossing a viaduct".to_string(),
+      duration_seconds: Some(15),
+      size: Some(Wan2p6Size::TenEightyP),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "wan2.6".to_string()),
+      ("prompt", "a steam train crossing a viaduct".to_string()),
+      ("seconds", "15".to_string()),
+      ("size", "1920x1080".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(1)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(2)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(15)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(16)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  #[test]
+  fn too_many_references_rejected() {
+    let mut request = request_with_seconds(Some(5));
+    request.input_reference_images = (0..6)
+      .map(|i| CometInputReferenceImage {
+        file_bytes: vec![0u8],
+        filename: format!("ref_{i}.png"),
+        maybe_content_type: Some("image/png".to_string()),
+      })
+      .collect();
+
+    let error = request.to_create_video_request().expect_err("should reject 6 references");
+    assert!(matches!(error, CometClientError::InvalidRequestField { field: "input_reference_images", .. }));
+
+    request.input_reference_images.truncate(5);
+    assert!(request.to_create_video_request().is_ok());
+  }
+
+  #[test]
+  fn cost_estimates() {
+    // 5 seconds at 720p: 5 × 8¢ = 40¢
+    let mut request = request_with_seconds(Some(5));
+    request.size = Some(Wan2p6Size::SevenTwentyP);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 40);
+
+    // 10 seconds at 1080p: 10 × 12¢ = 120¢
+    request.duration_seconds = Some(10);
+    request.size = Some(Wan2p6Size::TenEightyP);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 120);
+
+    // Defaults (5 seconds, 720p): 40¢
+    request.duration_seconds = None;
+    request.size = None;
+    assert_eq!(request.estimate_cost_in_usd_cents(), 40);
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateWan2p6Request {
+    GenerateWan2p6Request {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+      input_reference_images: vec![],
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p7.rs

@@ -0,0 +1,186 @@
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::requests::create_video::create_video::{
+  create_video, CometInputReferenceImage, CometVideoModelRaw, CometVideoSize,
+  CreateVideoArgs, CreateVideoRequest,
+};
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Wan 2.7 supports 2-15 second durations.
+const MIN_DURATION_SECONDS: u8 = 2;
+const MAX_DURATION_SECONDS: u8 = 15;
+
+/// The API default duration when `seconds` is omitted.
+const DEFAULT_DURATION_SECONDS: u8 = 5;
+
+// ── Args ──
+
+pub struct GenerateWan2p7Args<'a> {
+  pub request: GenerateWan2p7Request,
+  pub api_key: &'a CometApiKey,
+}
+
+// ── Request ──
+
+#[derive(Clone, Debug)]
+pub struct GenerateWan2p7Request {
+  pub prompt: String,
+
+  /// 2-15 seconds. `None` uses the API default (5).
+  pub duration_seconds: Option<u8>,
+
+  /// `None` uses the API default (720p).
+  pub size: Option<Wan2p7Size>,
+
+  /// Reference images for image-to-video and first/last-frame workflows.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+// ── Enums ──
+
+/// Wan 2.7 renders at 720p or 1080p.
+#[derive(Debug, Clone, Copy)]
+pub enum Wan2p7Size {
+  SevenTwentyP,
+  TenEightyP,
+}
+
+// ── Pricing ──
+//
+// Wan 2.7 per-second USD pricing (via CometAPI):
+//
+// | Resolution | $/sec |
+// |------------|-------|
+// | 720p       | 0.08  |
+// | 1080p      | 0.12  |
+//
+// Total cost = price per second × video duration (seconds).
+
+impl GenerateWan2p7Request {
+  /// Estimate the USD cost in cents for this generation request.
+  pub fn estimate_cost_in_usd_cents(&self) -> u64 {
+    let cents_per_second: u64 = match self.size {
+      Some(Wan2p7Size::TenEightyP) => 12,
+      // Default resolution (None) is 720p.
+      Some(Wan2p7Size::SevenTwentyP) | None => 8,
+    };
+    let seconds = self.duration_seconds.unwrap_or(DEFAULT_DURATION_SECONDS);
+    u64::from(seconds) * cents_per_second
+  }
+}
+
+// ── Response ──
+
+pub struct GenerateWan2p7Response {
+  /// Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+  pub status: CometVideoTaskStatus,
+}
+
+// ── Entry point ──
+
+pub async fn generate_wan_2p7(
+  args: GenerateWan2p7Args<'_>,
+) -> Result<GenerateWan2p7Response, CometError> {
+  let raw_request = args.request.to_create_video_request()?;
+
+  let result = create_video(CreateVideoArgs {
+    api_key: args.api_key,
+    request: raw_request,
+  }).await?;
+
+  Ok(GenerateWan2p7Response {
+    task_id: result.task_id,
+    status: result.status,
+  })
+}
+
+impl GenerateWan2p7Request {
+  /// Validate and lower to the generic wire request.
+  pub fn to_create_video_request(&self) -> Result<CreateVideoRequest, CometClientError> {
+    if let Some(seconds) = self.duration_seconds {
+      if !(MIN_DURATION_SECONDS..=MAX_DURATION_SECONDS).contains(&seconds) {
+        return Err(CometClientError::InvalidRequestField {
+          field: "duration_seconds",
+          raw_value: seconds.to_string(),
+          reason: format!("Wan 2.7 supports {MIN_DURATION_SECONDS}-{MAX_DURATION_SECONDS} second durations"),
+        });
+      }
+    }
+
+    Ok(CreateVideoRequest {
+      model: CometVideoModelRaw::Wan2p7,
+      prompt: self.prompt.clone(),
+      maybe_seconds: self.duration_seconds,
+      maybe_size: self.size.map(map_size),
+      input_reference_images: self.input_reference_images.clone(),
+    })
+  }
+}
+
+fn map_size(size: Wan2p7Size) -> CometVideoSize {
+  match size {
+    Wan2p7Size::SevenTwentyP => CometVideoSize::Exact { width: 1280, height: 720 },
+    Wan2p7Size::TenEightyP => CometVideoSize::Exact { width: 1920, height: 1080 },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn maps_to_wire_request() {
+    let request = GenerateWan2p7Request {
+      prompt: "a koi pond at golden hour".to_string(),
+      duration_seconds: Some(5),
+      size: Some(Wan2p7Size::SevenTwentyP),
+      input_reference_images: vec![],
+    };
+
+    let raw = request.to_create_video_request().expect("should validate");
+    assert_eq!(raw.text_form_fields(), vec![
+      ("model", "wan2.7".to_string()),
+      ("prompt", "a koi pond at golden hour".to_string()),
+      ("seconds", "5".to_string()),
+      ("size", "1280x720".to_string()),
+    ]);
+  }
+
+  #[test]
+  fn duration_bounds() {
+    assert!(request_with_seconds(Some(1)).to_create_video_request().is_err());
+    assert!(request_with_seconds(Some(2)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(15)).to_create_video_request().is_ok());
+    assert!(request_with_seconds(Some(16)).to_create_video_request().is_err());
+    assert!(request_with_seconds(None).to_create_video_request().is_ok());
+  }
+
+  #[test]
+  fn cost_estimates() {
+    // 5 seconds at 720p: 5 × 8¢ = 40¢
+    let mut request = request_with_seconds(Some(5));
+    request.size = Some(Wan2p7Size::SevenTwentyP);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 40);
+
+    // 10 seconds at 1080p: 10 × 12¢ = 120¢
+    request.duration_seconds = Some(10);
+    request.size = Some(Wan2p7Size::TenEightyP);
+    assert_eq!(request.estimate_cost_in_usd_cents(), 120);
+
+    // Defaults (5 seconds, 720p): 40¢
+    request.duration_seconds = None;
+    request.size = None;
+    assert_eq!(request.estimate_cost_in_usd_cents(), 40);
+  }
+
+  fn request_with_seconds(duration_seconds: Option<u8>) -> GenerateWan2p7Request {
+    GenerateWan2p7Request {
+      prompt: "ok".to_string(),
+      duration_seconds,
+      size: None,
+      input_reference_images: vec![],
+    }
+  }
+}

crates/api_clients/comet_api_client/src/generate/video/mod.rs

@@ -0,0 +1,13 @@
+//! Concrete, strongly-typed per-model bindings over the generic
+//! [`crate::requests::create_video`] call. Each module encodes one model's
+//! constraints (duration range, size options, image-input support) in the
+//! type system and validates before hitting the wire.
+
+pub mod generate_doubao_seedance_1p0_pro;
+pub mod generate_doubao_seedance_1p5_pro;
+pub mod generate_doubao_seedance_2p0;
+pub mod generate_doubao_seedance_2p0_fast;
+pub mod generate_vidu_q3;
+pub mod generate_vidu_q3_turbo;
+pub mod generate_wan_2p6;
+pub mod generate_wan_2p7;

crates/api_clients/comet_api_client/src/lib.rs

@@ -0,0 +1,21 @@
+//! comet_api_client
+//!
+//! HTTP client for CometAPI (https://www.cometapi.com/), which proxies a
+//! variety of third-party generative models. We use it for Doubao Seedance 2.0
+//! video generation ("Seedance 2.0" and "Seedance 2.0 Fast").
+//!
+//! Flow: enqueue with [`requests::create_video`], then poll with
+//! [`requests::get_video_task`] until the task reaches a terminal status.
+//!
+//! NB: There is deliberately no webhook module. CometAPI documents callbacks
+//! as provider-specific pass-through events with no standardized payload, and
+//! the Seedance video endpoint has no documented callback parameter. Comet's
+//! own guidance is to "keep polling as the source of truth".
+
+pub mod creds;
+pub mod error;
+pub mod generate;
+pub mod requests;
+
+#[cfg(test)]
+mod test_utils;

crates/api_clients/comet_api_client/src/requests/comet_host.rs

@@ -0,0 +1,2 @@
+/// Base URL for the CometAPI HTTP API.
+pub const COMET_API_BASE_URL: &str = "https://api.cometapi.com";

crates/api_clients/comet_api_client/src/requests/create_video/create_video.rs

@@ -0,0 +1,439 @@
+use std::fmt;
+
+use log::info;
+use reqwest::multipart::{Form, Part};
+
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::categorize_comet_error::categorize_create_video_error;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::error::comet_generic_api_error::CometGenericApiError;
+use crate::requests::comet_host::COMET_API_BASE_URL;
+use crate::requests::create_video::request_types::CreateVideoRawResponse;
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+// ── Public args ──
+
+/// Top-level argument to [`create_video`]. Borrows the API key separately
+/// from the request body so callers can log/save [`CreateVideoRequest`]
+/// without leaking the credential.
+pub struct CreateVideoArgs<'a> {
+  pub api_key: &'a CometApiKey,
+  pub request: CreateVideoRequest,
+}
+
+/// The material part of a video creation request (`POST /v1/videos`).
+///
+/// This is the generic, model-agnostic wire shape. Per-model duration and
+/// size constraints are NOT enforced here — use the strongly-typed bindings
+/// in [`crate::generate::video`] which validate before delegating to this.
+#[derive(Clone)]
+pub struct CreateVideoRequest {
+  /// Which video model fulfils the request.
+  pub model: CometVideoModelRaw,
+
+  /// Text description of the desired video. Reference attached images in
+  /// the prompt as `[Image 1]`, `[Image 2]`, etc.
+  pub prompt: String,
+
+  /// Video duration in seconds. Valid ranges are model-specific. Default: 5.
+  pub maybe_seconds: Option<u8>,
+
+  /// Output size: an aspect-ratio preset or exact dimensions.
+  pub maybe_size: Option<CometVideoSize>,
+
+  /// Optional reference images (JPEG, PNG, WebP) for image-to-video.
+  /// Each is sent as a repeated `input_reference` multipart field.
+  /// Not all models support image input.
+  pub input_reference_images: Vec<CometInputReferenceImage>,
+}
+
+/// The video models CometAPI fronts on `POST /v1/videos`.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum CometVideoModelRaw {
+  /// Seedance 2.0
+  DoubaoSeedance2p0,
+  /// Seedance 2.0 Fast
+  DoubaoSeedance2p0Fast,
+  /// Seedance 1.5 Pro (text-only)
+  DoubaoSeedance1p5Pro,
+  /// Seedance 1.0 Pro (text-only)
+  DoubaoSeedance1p0Pro,
+  /// Vidu Q3
+  ViduQ3,
+  /// Vidu Q3 Turbo
+  ViduQ3Turbo,
+  /// Alibaba Wan 2.7
+  Wan2p7,
+  /// Alibaba Wan 2.6
+  Wan2p6,
+}
+
+/// Output video size: a ratio preset or exact pixel dimensions.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum CometVideoSize {
+  /// 16:9 (landscape)
+  Landscape16x9,
+  /// 4:3
+  Standard4x3,
+  /// 1:1 (square)
+  Square,
+  /// 3:4
+  Portrait3x4,
+  /// 9:16 (portrait)
+  Portrait9x16,
+  /// 21:9 (ultra-wide)
+  UltraWide21x9,
+  /// Exact dimensions, eg. 1280x720.
+  Exact { width: u32, height: u32 },
+}
+
+/// A reference image attached to the request as a binary multipart part.
+#[derive(Clone)]
+pub struct CometInputReferenceImage {
+  /// Raw bytes of the image (JPEG, PNG, or WebP). Excluded from `Debug`
+  /// output — a megabyte-scale blob shouldn't end up in a log line.
+  pub file_bytes: Vec<u8>,
+
+  /// Filename for the multipart `Content-Disposition` header.
+  pub filename: String,
+
+  /// Optional MIME type, eg. "image/png". If `None`, reqwest uses
+  /// `application/octet-stream`.
+  pub maybe_content_type: Option<String>,
+}
+
+// ── Public response ──
+
+#[derive(Clone, Debug)]
+pub struct CreateVideoSuccess {
+  /// Task identifier. Poll `GET /v1/videos/{task_id}` until terminal.
+  pub task_id: String,
+
+  /// Initial lifecycle status, typically queued.
+  pub status: CometVideoTaskStatus,
+
+  /// The model that will fulfil the task, as echoed by the API.
+  pub maybe_model: Option<String>,
+
+  /// 0-100 completion percentage.
+  pub maybe_progress: Option<u8>,
+
+  /// Unix timestamp (seconds).
+  pub maybe_created_at: Option<i64>,
+}
+
+/// Enqueue a Doubao Seedance 2.0 video generation task.
+///
+/// CometAPI's video creation endpoint takes `multipart/form-data`. The task
+/// id in the response is then polled with
+/// [`crate::requests::get_video_task::get_video_task::get_video_task`].
+pub async fn create_video(args: CreateVideoArgs<'_>) -> Result<CreateVideoSuccess, CometError> {
+  let request = &args.request;
+  request.validate()?;
+
+  let url = format!("{COMET_API_BASE_URL}/v1/videos");
+
+  let mut form = Form::new();
+  for (field, value) in request.text_form_fields() {
+    form = form.text(field, value);
+  }
+  for image in &request.input_reference_images {
+    let mut part = Part::bytes(image.file_bytes.clone())
+      .file_name(image.filename.clone());
+    if let Some(content_type) = &image.maybe_content_type {
+      part = part.mime_str(content_type)
+        .map_err(|err| CometClientError::InvalidRequestField {
+          field: "input_reference_images.maybe_content_type",
+          raw_value: content_type.clone(),
+          reason: format!("invalid mime type: {err}"),
+        })?;
+    }
+    form = form.part("input_reference", part);
+  }
+
+  let client = reqwest::Client::builder()
+    .build()
+    .map_err(CometClientError::ReqwestClientError)?;
+
+  let response = client.post(&url)
+    .bearer_auth(args.api_key.as_str())
+    .multipart(form)
+    .send()
+    .await
+    .map_err(CometGenericApiError::ReqwestError)?;
+
+  let status_code = response.status();
+  let body = response.text()
+    .await
+    .map_err(CometGenericApiError::ReqwestError)?;
+
+  if !status_code.is_success() {
+    return Err(categorize_create_video_error(status_code, body));
+  }
+
+  let raw: CreateVideoRawResponse = serde_json::from_str(&body)
+    .map_err(|err| CometGenericApiError::SerdeResponseParseErrorWithBody(err, body.clone()))?;
+
+  info!("Comet video task enqueued: {} (status: {})", raw.id, raw.status);
+
+  Ok(CreateVideoSuccess {
+    task_id: raw.id,
+    status: raw.status,
+    maybe_model: raw.model,
+    maybe_progress: raw.progress,
+    maybe_created_at: raw.created_at,
+  })
+}
+
+impl CreateVideoRequest {
+  /// The text fields of the multipart form, in wire order. Split out from
+  /// [`create_video`] so the form shape is testable without HTTP.
+  pub fn text_form_fields(&self) -> Vec<(&'static str, String)> {
+    let mut fields = vec![
+      ("model", self.model.as_api_str().to_string()),
+      ("prompt", self.prompt.clone()),
+    ];
+    if let Some(seconds) = self.maybe_seconds {
+      fields.push(("seconds", seconds.to_string()));
+    }
+    if let Some(size) = self.maybe_size {
+      fields.push(("size", size.as_api_string()));
+    }
+    fields
+  }
+
+  fn validate(&self) -> Result<(), CometClientError> {
+    if self.prompt.trim().is_empty() {
+      return Err(CometClientError::InvalidRequestField {
+        field: "prompt",
+        raw_value: self.prompt.clone(),
+        reason: "prompt must not be empty".to_string(),
+      });
+    }
+
+    Ok(())
+  }
+}
+
+impl CometVideoModelRaw {
+  pub fn as_api_str(&self) -> &'static str {
+    match self {
+      Self::DoubaoSeedance2p0 => "doubao-seedance-2-0",
+      Self::DoubaoSeedance2p0Fast => "doubao-seedance-2-0-fast",
+      Self::DoubaoSeedance1p5Pro => "doubao-seedance-1-5-pro",
+      Self::DoubaoSeedance1p0Pro => "doubao-seedance-1-0-pro",
+      Self::ViduQ3 => "viduq3",
+      Self::ViduQ3Turbo => "viduq3-turbo",
+      Self::Wan2p7 => "wan2.7",
+      Self::Wan2p6 => "wan2.6",
+    }
+  }
+}
+
+impl CometVideoSize {
+  pub fn as_api_string(&self) -> String {
+    match self {
+      Self::Landscape16x9 => "16:9".to_string(),
+      Self::Standard4x3 => "4:3".to_string(),
+      Self::Square => "1:1".to_string(),
+      Self::Portrait3x4 => "3:4".to_string(),
+      Self::Portrait9x16 => "9:16".to_string(),
+      Self::UltraWide21x9 => "21:9".to_string(),
+      Self::Exact { width, height } => format!("{width}x{height}"),
+    }
+  }
+}
+
+impl fmt::Debug for CreateVideoRequest {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.debug_struct("CreateVideoRequest")
+      .field("model", &self.model)
+      .field("prompt", &self.prompt)
+      .field("maybe_seconds", &self.maybe_seconds)
+      .field("maybe_size", &self.maybe_size)
+      .field("input_reference_images", &self.input_reference_images)
+      .finish()
+  }
+}
+
+impl fmt::Debug for CometInputReferenceImage {
+  // Print byte-length, not raw bytes — derived Debug on Vec<u8> would dump
+  // the entire image into the log line.
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.debug_struct("CometInputReferenceImage")
+      .field("file_bytes_len", &self.file_bytes.len())
+      .field("filename", &self.filename)
+      .field("maybe_content_type", &self.maybe_content_type)
+      .finish()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  mod shape_tests {
+    use super::*;
+
+    #[test]
+    fn model_api_strings() {
+      assert_eq!(CometVideoModelRaw::DoubaoSeedance2p0.as_api_str(), "doubao-seedance-2-0");
+      assert_eq!(CometVideoModelRaw::DoubaoSeedance2p0Fast.as_api_str(), "doubao-seedance-2-0-fast");
+      assert_eq!(CometVideoModelRaw::DoubaoSeedance1p5Pro.as_api_str(), "doubao-seedance-1-5-pro");
+      assert_eq!(CometVideoModelRaw::DoubaoSeedance1p0Pro.as_api_str(), "doubao-seedance-1-0-pro");
+      assert_eq!(CometVideoModelRaw::ViduQ3.as_api_str(), "viduq3");
+      assert_eq!(CometVideoModelRaw::ViduQ3Turbo.as_api_str(), "viduq3-turbo");
+      assert_eq!(CometVideoModelRaw::Wan2p7.as_api_str(), "wan2.7");
+      assert_eq!(CometVideoModelRaw::Wan2p6.as_api_str(), "wan2.6");
+    }
+
+    #[test]
+    fn size_api_strings() {
+      assert_eq!(CometVideoSize::Landscape16x9.as_api_string(), "16:9");
+      assert_eq!(CometVideoSize::Standard4x3.as_api_string(), "4:3");
+      assert_eq!(CometVideoSize::Square.as_api_string(), "1:1");
+      assert_eq!(CometVideoSize::Portrait3x4.as_api_string(), "3:4");
+      assert_eq!(CometVideoSize::Portrait9x16.as_api_string(), "9:16");
+      assert_eq!(CometVideoSize::UltraWide21x9.as_api_string(), "21:9");
+      assert_eq!(CometVideoSize::Exact { width: 1280, height: 720 }.as_api_string(), "1280x720");
+    }
+
+    #[test]
+    fn minimal_form_fields() {
+      let request = CreateVideoRequest {
+        model: CometVideoModelRaw::DoubaoSeedance2p0Fast,
+        prompt: "a corgi running through a field".to_string(),
+        maybe_seconds: None,
+        maybe_size: None,
+        input_reference_images: vec![],
+      };
+
+      assert_eq!(request.text_form_fields(), vec![
+        ("model", "doubao-seedance-2-0-fast".to_string()),
+        ("prompt", "a corgi running through a field".to_string()),
+      ]);
+    }
+
+    #[test]
+    fn full_form_fields() {
+      let request = CreateVideoRequest {
+        model: CometVideoModelRaw::DoubaoSeedance2p0,
+        prompt: "make [Image 1] come alive".to_string(),
+        maybe_seconds: Some(10),
+        maybe_size: Some(CometVideoSize::Portrait9x16),
+        input_reference_images: vec![],
+      };
+
+      assert_eq!(request.text_form_fields(), vec![
+        ("model", "doubao-seedance-2-0".to_string()),
+        ("prompt", "make [Image 1] come alive".to_string()),
+        ("seconds", "10".to_string()),
+        ("size", "9:16".to_string()),
+      ]);
+    }
+  }
+
+  mod validation_tests {
+    use super::*;
+
+    #[test]
+    fn empty_prompt_is_rejected() {
+      let request = request_with_prompt_and_seconds("  ", None);
+      let error = request.validate().expect_err("should reject empty prompt");
+      assert!(matches!(error, CometClientError::InvalidRequestField { field: "prompt", .. }));
+    }
+
+    // NB: Duration ranges are model-specific and validated by the concrete
+    // bindings in `generate::video`; the generic layer accepts any value.
+
+    fn request_with_prompt_and_seconds(prompt: &str, maybe_seconds: Option<u8>) -> CreateVideoRequest {
+      CreateVideoRequest {
+        model: CometVideoModelRaw::DoubaoSeedance2p0,
+        prompt: prompt.to_string(),
+        maybe_seconds,
+        maybe_size: None,
+        input_reference_images: vec![],
+      }
+    }
+  }
+
+  mod live_tests {
+    use super::*;
+    use crate::test_utils::load_api_key;
+
+    /// Live test: enqueues a REAL generation and INCURS COSTS.
+    /// Run manually with:
+    ///   cargo test -p comet_api_client live_create_video -- --ignored --nocapture
+    #[ignore]
+    #[tokio::test]
+    async fn live_create_video() {
+      let api_key = load_api_key();
+
+      let result = create_video(CreateVideoArgs {
+        api_key: &api_key,
+        request: CreateVideoRequest {
+          model: CometVideoModelRaw::DoubaoSeedance2p0Fast,
+          prompt: "a corgi running through a sunny meadow, cinematic".to_string(),
+          maybe_seconds: Some(4),
+          maybe_size: Some(CometVideoSize::Landscape16x9),
+          input_reference_images: vec![],
+        },
+      }).await.expect("create_video should succeed");
+
+      println!("Enqueued task: {} (status: {})", result.task_id, result.status);
+      assert!(!result.task_id.is_empty());
+    }
+
+    /// Live test: enqueues a REAL generation and polls it to completion.
+    /// INCURS COSTS and takes a few minutes. Run manually with:
+    ///   cargo test -p comet_api_client live_create_and_poll_video -- --ignored --nocapture
+    #[ignore]
+    #[tokio::test]
+    async fn live_create_and_poll_video() {
+      use std::time::Duration;
+
+      use crate::requests::get_video_task::get_video_task::{get_video_task, GetVideoTaskArgs};
+
+      // NB: Comet's docs claim most tasks finish in 1-3 minutes, but tasks
+      // have been observed to sit at `in_progress` well past 10 minutes.
+      const POLL_INTERVAL: Duration = Duration::from_secs(15);
+      const MAX_POLLS: u32 = 120; // ~30 minutes
+
+      let api_key = load_api_key();
+
+      let created = create_video(CreateVideoArgs {
+        api_key: &api_key,
+        request: CreateVideoRequest {
+          model: CometVideoModelRaw::DoubaoSeedance2p0Fast,
+          prompt: "a corgi running through a sunny meadow, cinematic".to_string(),
+          maybe_seconds: Some(4),
+          maybe_size: Some(CometVideoSize::Landscape16x9),
+          input_reference_images: vec![],
+        },
+      }).await.expect("create_video should succeed");
+
+      println!("Enqueued task: {} (status: {})", created.task_id, created.status);
+
+      for poll in 1..=MAX_POLLS {
+        tokio::time::sleep(POLL_INTERVAL).await;
+
+        let task = get_video_task(GetVideoTaskArgs {
+          api_key: &api_key,
+          task_id: &created.task_id,
+        }).await.expect("get_video_task should succeed");
+
+        println!("Poll {}: status {} (progress: {:?})", poll, task.status, task.maybe_progress);
+
+        if task.status.is_terminal() {
+          assert!(task.status.is_success(), "task should complete successfully: {:?}", task);
+          let video_url = task.maybe_video_url.expect("completed task should have a video url");
+          println!("Video URL: {}", video_url);
+          return;
+        }
+      }
+
+      panic!("Task {} did not reach a terminal state in time", created.task_id);
+    }
+  }
+}

crates/api_clients/comet_api_client/src/requests/create_video/mod.rs

@@ -0,0 +1,2 @@
+pub mod create_video;
+pub mod request_types;

crates/api_clients/comet_api_client/src/requests/create_video/request_types.rs

@@ -0,0 +1,77 @@
+use serde_derive::Deserialize;
+
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Over-the-wire response from `POST /v1/videos`.
+///
+/// The docs show both `id` and `task_id` carrying the same task identifier;
+/// `task_id` is treated as an optional mirror of `id`.
+#[derive(Clone, Debug, Deserialize)]
+pub struct CreateVideoRawResponse {
+  /// Task identifier, eg. "task_abc123". Use this with the poll endpoint.
+  pub id: String,
+
+  /// Mirror of `id`.
+  pub task_id: Option<String>,
+
+  /// Always "video".
+  pub object: Option<String>,
+
+  /// The model that will fulfil the task, eg. "doubao-seedance-2-0".
+  pub model: Option<String>,
+
+  /// Initial lifecycle status, typically "queued".
+  pub status: CometVideoTaskStatus,
+
+  /// 0-100 completion percentage.
+  pub progress: Option<u8>,
+
+  /// Unix timestamp (seconds).
+  pub created_at: Option<i64>,
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  /// Documented response shape from
+  /// https://apidoc.cometapi.com/api/video/seedance/create.md
+  const REAL_CREATE_RESPONSE: &str = r#"
+{
+  "id": "task_abc123",
+  "task_id": "task_abc123",
+  "object": "video",
+  "model": "doubao-seedance-2-0",
+  "status": "queued",
+  "progress": 0,
+  "created_at": 1776681149
+}
+    "#;
+
+  #[test]
+  fn parse_real_create_response() {
+    let response: CreateVideoRawResponse = serde_json::from_str(REAL_CREATE_RESPONSE)
+      .expect("should parse");
+
+    assert_eq!(response.id, "task_abc123");
+    assert_eq!(response.task_id.as_deref(), Some("task_abc123"));
+    assert_eq!(response.object.as_deref(), Some("video"));
+    assert_eq!(response.model.as_deref(), Some("doubao-seedance-2-0"));
+    assert_eq!(response.status, CometVideoTaskStatus::Queued);
+    assert_eq!(response.progress, Some(0));
+    assert_eq!(response.created_at, Some(1776681149));
+  }
+
+  #[test]
+  fn parse_minimal_response() {
+    // Only `id` and `status` are load-bearing; everything else is optional
+    // so schema drift doesn't break enqueuing.
+    let response: CreateVideoRawResponse = serde_json::from_str(
+      r#"{"id":"task_xyz","status":"queued"}"#,
+    ).expect("should parse");
+
+    assert_eq!(response.id, "task_xyz");
+    assert_eq!(response.status, CometVideoTaskStatus::Queued);
+    assert_eq!(response.task_id, None);
+  }
+}

crates/api_clients/comet_api_client/src/requests/get_video_task/get_video_task.rs

@@ -0,0 +1,184 @@
+use log::info;
+
+use crate::creds::comet_api_key::CometApiKey;
+use crate::error::categorize_comet_error::categorize_get_video_task_error;
+use crate::error::comet_client_error::CometClientError;
+use crate::error::comet_error::CometError;
+use crate::error::comet_generic_api_error::CometGenericApiError;
+use crate::requests::comet_host::COMET_API_BASE_URL;
+use crate::requests::get_video_task::request_types::VideoTaskRawResponse;
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+// ── Public args ──
+
+pub struct GetVideoTaskArgs<'a> {
+  pub api_key: &'a CometApiKey,
+
+  /// The task id returned by the creation endpoint, eg. "task_abc123".
+  pub task_id: &'a str,
+}
+
+// ── Public response ──
+
+/// Snapshot of a video task's state.
+///
+/// Poll every 10-20 seconds until [`CometVideoTaskStatus::is_terminal`];
+/// most tasks finish within 1-3 minutes.
+#[derive(Clone, Debug)]
+pub struct CometVideoTask {
+  pub task_id: String,
+
+  pub status: CometVideoTaskStatus,
+
+  /// The Seedance model used, as echoed by the API.
+  pub maybe_model: Option<String>,
+
+  /// 0-100 completion percentage.
+  pub maybe_progress: Option<u8>,
+
+  /// Signed download URL, present only when the task completed. The
+  /// signature is time-limited — download or re-host the file promptly.
+  pub maybe_video_url: Option<String>,
+
+  /// Unix timestamp (seconds).
+  pub maybe_created_at: Option<i64>,
+
+  /// Unix timestamp (seconds) when the task finished.
+  pub maybe_completed_at: Option<i64>,
+}
+
+/// Fetch the current state of a video task (`GET /v1/videos/{id}`).
+pub async fn get_video_task(args: GetVideoTaskArgs<'_>) -> Result<CometVideoTask, CometError> {
+  let url = format!("{COMET_API_BASE_URL}/v1/videos/{}", args.task_id);
+
+  let client = reqwest::Client::builder()
+    .build()
+    .map_err(CometClientError::ReqwestClientError)?;
+
+  let response = client.get(&url)
+    .bearer_auth(args.api_key.as_str())
+    .send()
+    .await
+    .map_err(CometGenericApiError::ReqwestError)?;
+
+  let status_code = response.status();
+  let body = response.text()
+    .await
+    .map_err(CometGenericApiError::ReqwestError)?;
+
+  if !status_code.is_success() {
+    return Err(categorize_get_video_task_error(status_code, body, args.task_id));
+  }
+
+  let raw: VideoTaskRawResponse = serde_json::from_str(&body)
+    .map_err(|err| CometGenericApiError::SerdeResponseParseErrorWithBody(err, body.clone()))?;
+
+  info!("Comet video task {}: status {} (progress: {:?})", raw.id, raw.status, raw.progress);
+
+  Ok(CometVideoTask {
+    task_id: raw.id,
+    status: raw.status,
+    maybe_model: raw.model,
+    maybe_progress: raw.progress,
+    maybe_video_url: raw.video_url,
+    maybe_created_at: raw.created_at,
+    maybe_completed_at: raw.completed_at,
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::error::comet_specific_api_error::CometSpecificApiError;
+  use crate::requests::get_video_content::get_video_content::{
+    probe_video_failure_reason, ProbeVideoFailureReasonArgs,
+  };
+  use crate::test_utils::load_api_key;
+
+  /// Historical task ids from real generations, kept for diagnosing how
+  /// CometAPI reports terminal states. Several of these failed content
+  /// moderation ("VIOLATION").
+  const KNOWN_TASK_IDS: &[&str] = &[
+    "task_ZISEWaXgmyqXWiesd287qTyAZLapbwz8",
+    "task_ZvwV2nhp08ng4krT16CPxtHZ2SgABElj",
+    "task_GZPVhcnIZKLJBqsCGTBvMiUFN9uDnwJv",
+    "task_iGnAQ5lwqhMltxhN5k9yATAjs7AgjV39",
+    "task_hGhShys2Wi2gPf2qUkuQ38VKIytWAw1d",
+    "task_t84NmrcT3k8s6Il4xJeKtfxXipA3n8RQ",
+    "task_6OhdGVFZjHNtOKKx8Ewz37mENaVIhC3X",
+  ];
+
+  /// Live test: makes a REAL network request (no generation cost — the task
+  /// id is bogus, so this exercises auth + the TaskNotFound error path).
+  /// Run manually with:
+  ///   cargo test -p comet_api_client live_get_video_task -- --ignored --nocapture
+  #[ignore]
+  #[tokio::test]
+  async fn live_get_video_task_unknown_id() {
+    let api_key = load_api_key();
+
+    let result = get_video_task(GetVideoTaskArgs {
+      api_key: &api_key,
+      task_id: "task_does_not_exist_artcraft_test",
+    }).await;
+
+    match result {
+      Err(CometError::ApiSpecific(CometSpecificApiError::TaskNotFound { task_id, .. })) => {
+        assert_eq!(task_id, "task_does_not_exist_artcraft_test");
+      }
+      other => panic!("Expected TaskNotFound, got: {:?}", other),
+    }
+  }
+
+  /// Live diagnostic: polls the known historical tasks and prints their full
+  /// state, including the failure reason recovered from the content
+  /// endpoint for failed tasks. Free (read-only GETs, no generation cost),
+  /// but hits the real API. Run manually with:
+  ///   cargo test -p comet_api_client live_poll_known_task_ids -- --ignored --nocapture
+  ///
+  /// NB: The poll endpoint reports failures as a bare `status: "failed"`.
+  /// The ONLY way to learn WHY is `GET /v1/videos/{id}/content`, whose error
+  /// message leaks the underlying provider status (eg. "VIOLATION" for
+  /// content-moderation rejections — these run to progress 100 and then
+  /// fail when the finished output is moderated).
+  #[ignore]
+  #[tokio::test]
+  async fn live_poll_known_task_ids() {
+    let api_key = load_api_key();
+
+    for task_id in KNOWN_TASK_IDS {
+      println!("===== {task_id}");
+
+      let task = match get_video_task(GetVideoTaskArgs { api_key: &api_key, task_id }).await {
+        Ok(task) => task,
+        Err(err) => {
+          println!("  poll error: {err}");
+          continue;
+        }
+      };
+
+      println!("  status:       {}", task.status);
+      println!("  model:        {}", task.maybe_model.as_deref().unwrap_or("?"));
+      println!("  progress:     {:?}", task.maybe_progress);
+      println!("  created_at:   {:?}", task.maybe_created_at);
+      println!("  completed_at: {:?}", task.maybe_completed_at);
+      println!("  video_url:    {}", task.maybe_video_url.as_deref().unwrap_or("(none)"));
+
+      if task.status.is_failure() {
+        match probe_video_failure_reason(ProbeVideoFailureReasonArgs { api_key: &api_key, task_id }).await {
+          Ok(Some(reason)) => {
+            println!("  failure reason (via /content):");
+            println!("    raw message:       {}", reason.raw_message);
+            println!("    underlying status: {}", reason.maybe_underlying_status.as_deref().unwrap_or("(unparsed)"));
+            println!("    content violation: {}", reason.is_content_violation());
+            println!("    error type:        {}", reason.maybe_error_type.as_deref().unwrap_or("(none)"));
+            println!("    request id:        {}", reason.maybe_request_id.as_deref().unwrap_or("(none)"));
+          }
+          Ok(None) => println!("  failure probe: content unexpectedly downloadable"),
+          Err(err) => println!("  failure probe error: {err}"),
+        }
+      }
+      println!();
+    }
+  }
+}

crates/api_clients/comet_api_client/src/requests/get_video_task/mod.rs

@@ -0,0 +1,2 @@
+pub mod get_video_task;
+pub mod request_types;

crates/api_clients/comet_api_client/src/requests/get_video_task/request_types.rs

@@ -0,0 +1,113 @@
+use serde_derive::Deserialize;
+
+use crate::requests::video_task_status::CometVideoTaskStatus;
+
+/// Over-the-wire response from `GET /v1/videos/{id}`.
+#[derive(Clone, Debug, Deserialize)]
+pub struct VideoTaskRawResponse {
+  /// Task identifier.
+  pub id: String,
+
+  /// Always "video".
+  pub object: Option<String>,
+
+  /// The Seedance model used, eg. "doubao-seedance-2-0".
+  pub model: Option<String>,
+
+  /// Lifecycle status.
+  pub status: CometVideoTaskStatus,
+
+  /// 0-100 completion percentage.
+  pub progress: Option<u8>,
+
+  /// Signed download URL. Present only when `status` is "completed".
+  /// NB: the signature is time-limited — download or re-host the file
+  /// before it expires.
+  pub video_url: Option<String>,
+
+  /// Unix timestamp (seconds).
+  pub created_at: Option<i64>,
+
+  /// Unix timestamp (seconds) when the task finished.
+  pub completed_at: Option<i64>,
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  // Documented response shapes from
+  // https://apidoc.cometapi.com/api/video/seedance/query.md
+
+  const REAL_IN_PROGRESS_RESPONSE: &str = r#"
+{
+  "id": "task_abc123",
+  "object": "video",
+  "model": "doubao-seedance-2-0",
+  "status": "in_progress",
+  "progress": 30,
+  "created_at": 1777385418,
+  "completed_at": 1777385485
+}
+    "#;
+
+  const REAL_COMPLETED_RESPONSE: &str = r#"
+{
+  "id": "task_abc123",
+  "object": "video",
+  "model": "doubao-seedance-2-0",
+  "status": "completed",
+  "progress": 100,
+  "created_at": 1777385418,
+  "completed_at": 1777385526,
+  "video_url": "https://example.com/seedance-output.mp4"
+}
+    "#;
+
+  const REAL_FAILED_RESPONSE: &str = r#"
+{
+  "id": "task_abc123",
+  "object": "video",
+  "model": "doubao-seedance-2-0",
+  "status": "failed",
+  "progress": 0,
+  "created_at": 1777385418,
+  "completed_at": 1777385526
+}
+    "#;
+
+  #[test]
+  fn parse_real_in_progress_response() {
+    let response: VideoTaskRawResponse = serde_json::from_str(REAL_IN_PROGRESS_RESPONSE)
+      .expect("should parse");
+
+    assert_eq!(response.id, "task_abc123");
+    assert_eq!(response.status, CometVideoTaskStatus::InProgress);
+    assert_eq!(response.progress, Some(30));
+    assert_eq!(response.video_url, None);
+    assert!(!response.status.is_terminal());
+  }
+
+  #[test]
+  fn parse_real_completed_response() {
+    let response: VideoTaskRawResponse = serde_json::from_str(REAL_COMPLETED_RESPONSE)
+      .expect("should parse");
+
+    assert_eq!(response.status, CometVideoTaskStatus::Completed);
+    assert_eq!(response.progress, Some(100));
+    assert_eq!(response.video_url.as_deref(), Some("https://example.com/seedance-output.mp4"));
+    assert_eq!(response.completed_at, Some(1777385526));
+    assert!(response.status.is_success());
+  }
+
+  #[test]
+  fn parse_real_failed_response() {
+    let response: VideoTaskRawResponse = serde_json::from_str(REAL_FAILED_RESPONSE)
+      .expect("should parse");
+
+    assert_eq!(response.status, CometVideoTaskStatus::Failed);
+    assert_eq!(response.video_url, None);
+    assert!(response.status.is_terminal());
+    assert!(response.status.is_failure());
+  }
+}

crates/api_clients/comet_api_client/src/requests/mod.rs

@@ -0,0 +1,5 @@
+pub mod comet_host;
+pub mod create_video;
+pub mod get_video_content;
+pub mod get_video_task;
+pub mod video_task_status;

crates/api_clients/comet_api_client/src/requests/video_task_status.rs

@@ -0,0 +1,132 @@
+use std::fmt;
+
+use serde::de::{Deserialize, Deserializer};
+use serde::ser::{Serialize, Serializer};
+
+/// Lifecycle status of a CometAPI video task.
+///
+/// The `Unknown(String)` catch-all future-proofs against CometAPI adding new
+/// states — callers should treat unknown states as still-running unless
+/// proven otherwise.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum CometVideoTaskStatus {
+  Queued,
+  InProgress,
+  Completed,
+  Failed,
+  Error,
+  Unknown(String),
+}
+
+impl CometVideoTaskStatus {
+  pub fn to_str(&self) -> &str {
+    match self {
+      Self::Queued => "queued",
+      Self::InProgress => "in_progress",
+      Self::Completed => "completed",
+      Self::Failed => "failed",
+      Self::Error => "error",
+      Self::Unknown(value) => value,
+    }
+  }
+
+  pub fn from_str(value: &str) -> Self {
+    match value {
+      "queued" => Self::Queued,
+      "in_progress" => Self::InProgress,
+      "completed" => Self::Completed,
+      "failed" => Self::Failed,
+      "error" => Self::Error,
+      other => Self::Unknown(other.to_string()),
+    }
+  }
+
+  /// Whether the task has reached a terminal state (stop polling).
+  pub fn is_terminal(&self) -> bool {
+    matches!(self, Self::Completed | Self::Failed | Self::Error)
+  }
+
+  pub fn is_success(&self) -> bool {
+    matches!(self, Self::Completed)
+  }
+
+  pub fn is_failure(&self) -> bool {
+    matches!(self, Self::Failed | Self::Error)
+  }
+}
+
+impl fmt::Display for CometVideoTaskStatus {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "{}", self.to_str())
+  }
+}
+
+impl<'de> Deserialize<'de> for CometVideoTaskStatus {
+  fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+    let value = String::deserialize(deserializer)?;
+    Ok(Self::from_str(&value))
+  }
+}
+
+impl Serialize for CometVideoTaskStatus {
+  fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+    serializer.serialize_str(self.to_str())
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn deserialize_known_states() {
+    let cases = [
+      ("\"queued\"", CometVideoTaskStatus::Queued),
+      ("\"in_progress\"", CometVideoTaskStatus::InProgress),
+      ("\"completed\"", CometVideoTaskStatus::Completed),
+      ("\"failed\"", CometVideoTaskStatus::Failed),
+      ("\"error\"", CometVideoTaskStatus::Error),
+    ];
+    for (json, expected) in cases {
+      let status: CometVideoTaskStatus = serde_json::from_str(json).expect("should parse");
+      assert_eq!(status, expected);
+    }
+  }
+
+  #[test]
+  fn deserialize_unknown_state_is_future_proof() {
+    let status: CometVideoTaskStatus = serde_json::from_str("\"hyper_queued\"").expect("should parse");
+    assert_eq!(status, CometVideoTaskStatus::Unknown("hyper_queued".to_string()));
+    assert!(!status.is_terminal());
+  }
+
+  #[test]
+  fn round_trip() {
+    for status in [
+      CometVideoTaskStatus::Queued,
+      CometVideoTaskStatus::InProgress,
+      CometVideoTaskStatus::Completed,
+      CometVideoTaskStatus::Failed,
+      CometVideoTaskStatus::Error,
+      CometVideoTaskStatus::Unknown("new_state".to_string()),
+    ] {
+      let json = serde_json::to_string(&status).expect("should serialize");
+      let parsed: CometVideoTaskStatus = serde_json::from_str(&json).expect("should parse");
+      assert_eq!(parsed, status);
+    }
+  }
+
+  #[test]
+  fn terminal_states() {
+    assert!(!CometVideoTaskStatus::Queued.is_terminal());
+    assert!(!CometVideoTaskStatus::InProgress.is_terminal());
+    assert!(CometVideoTaskStatus::Completed.is_terminal());
+    assert!(CometVideoTaskStatus::Failed.is_terminal());
+    assert!(CometVideoTaskStatus::Error.is_terminal());
+
+    assert!(CometVideoTaskStatus::Completed.is_success());
+    assert!(!CometVideoTaskStatus::Completed.is_failure());
+    assert!(CometVideoTaskStatus::Failed.is_failure());
+    assert!(CometVideoTaskStatus::Error.is_failure());
+  }
+}

crates/api_clients/comet_api_client/src/test_utils/mod.rs

@@ -0,0 +1,11 @@
+use std::fs::read_to_string;
+
+use crate::creds::comet_api_key::CometApiKey;
+
+const API_KEY_PATH: &str = "/Users/bt/Artcraft/credentials/comet_api_key.txt";
+
+pub fn load_api_key() -> CometApiKey {
+  let secret = read_to_string(API_KEY_PATH)
+    .expect("Failed to read Comet API key file");
+  CometApiKey::from_str(&secret)
+}