diff --git a/Cargo.lock b/Cargo.lock index f8a6682dec..7b07766bc9 100644 --- a/Cargo.lock +++ b/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" diff --git a/Cargo.toml b/Cargo.toml index 43222a92b2..f53286d3d7 100644 --- a/Cargo.toml +++ b/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", diff --git a/crates/api_clients/comet_api_client/Cargo.toml b/crates/api_clients/comet_api_client/Cargo.toml new file mode 100644 index 0000000000..0dfbb8649b --- /dev/null +++ b/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"] } diff --git a/crates/api_clients/comet_api_client/src/creds/comet_api_key.rs b/crates/api_clients/comet_api_client/src/creds/comet_api_key.rs new file mode 100644 index 0000000000..19379503c8 --- /dev/null +++ b/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 + } +} diff --git a/crates/api_clients/comet_api_client/src/creds/mod.rs b/crates/api_clients/comet_api_client/src/creds/mod.rs new file mode 100644 index 0000000000..f9509f584b --- /dev/null +++ b/crates/api_clients/comet_api_client/src/creds/mod.rs @@ -0,0 +1 @@ +pub mod comet_api_key; diff --git a/crates/api_clients/comet_api_client/src/error/categorize_comet_error.rs b/crates/api_clients/comet_api_client/src/error/categorize_comet_error.rs new file mode 100644 index 0000000000..886309bd3c --- /dev/null +++ b/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), + } + } + } +} diff --git a/crates/api_clients/comet_api_client/src/error/comet_bad_request_api_error.rs b/crates/api_clients/comet_api_client/src/error/comet_bad_request_api_error.rs new file mode 100644 index 0000000000..46113d90c9 --- /dev/null +++ b/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), + } + } +} diff --git a/crates/api_clients/comet_api_client/src/error/comet_client_error.rs b/crates/api_clients/comet_api_client/src/error/comet_client_error.rs new file mode 100644 index 0000000000..831b2cbd56 --- /dev/null +++ b/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) + } + } + } +} diff --git a/crates/api_clients/comet_api_client/src/error/comet_error.rs b/crates/api_clients/comet_api_client/src/error/comet_error.rs new file mode 100644 index 0000000000..959d747a11 --- /dev/null +++ b/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 for CometError { + fn from(error: CometClientError) -> Self { + Self::Client(error) + } +} + +impl From for CometError { + fn from(error: CometBadRequestApiError) -> Self { + Self::ApiBadRequest(error) + } +} + +impl From for CometError { + fn from(error: CometSpecificApiError) -> Self { + Self::ApiSpecific(error) + } +} + +impl From for CometError { + fn from(error: CometGenericApiError) -> Self { + Self::ApiGeneric(error) + } +} diff --git a/crates/api_clients/comet_api_client/src/error/comet_generic_api_error.rs b/crates/api_clients/comet_api_client/src/error/comet_generic_api_error.rs new file mode 100644 index 0000000000..540e6848d2 --- /dev/null +++ b/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), + } + } +} diff --git a/crates/api_clients/comet_api_client/src/error/comet_specific_api_error.rs b/crates/api_clients/comet_api_client/src/error/comet_specific_api_error.rs new file mode 100644 index 0000000000..b5ebf2e4c3 --- /dev/null +++ b/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), + } + } +} diff --git a/crates/api_clients/comet_api_client/src/error/mod.rs b/crates/api_clients/comet_api_client/src/error/mod.rs new file mode 100644 index 0000000000..6f82605ccb --- /dev/null +++ b/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; diff --git a/crates/api_clients/comet_api_client/src/generate/mod.rs b/crates/api_clients/comet_api_client/src/generate/mod.rs new file mode 100644 index 0000000000..b04b953edb --- /dev/null +++ b/crates/api_clients/comet_api_client/src/generate/mod.rs @@ -0,0 +1 @@ +pub mod video; diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p0_pro.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p0_pro.rs new file mode 100644 index 0000000000..878b500cd2 --- /dev/null +++ b/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, + + pub size: Option, +} + +// ── 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 { + 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 { + 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) -> GenerateDoubaoSeedance1p0ProRequest { + GenerateDoubaoSeedance1p0ProRequest { + prompt: "ok".to_string(), + duration_seconds, + size: None, + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p5_pro.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_1p5_pro.rs new file mode 100644 index 0000000000..216d2c06a9 --- /dev/null +++ b/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, + + pub size: Option, +} + +// ── 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 { + 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 { + 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) -> GenerateDoubaoSeedance1p5ProRequest { + GenerateDoubaoSeedance1p5ProRequest { + prompt: "ok".to_string(), + duration_seconds, + size: None, + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0.rs new file mode 100644 index 0000000000..35b391bbad --- /dev/null +++ b/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, + + /// `None` defaults to 16:9 (when a resolution is set). + pub aspect_ratio: Option, + + /// `None` defaults to 720p (when an aspect ratio is set). + pub resolution: Option, + + /// Reference images (JPEG, PNG, WebP) for image-to-video. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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 { + 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, + resolution: Option, + ) -> 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 { + 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); + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0_fast.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_doubao_seedance_2p0_fast.rs new file mode 100644 index 0000000000..f1b4f17c5a --- /dev/null +++ b/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, + + /// `None` defaults to 16:9 (when a resolution is set). + pub aspect_ratio: Option, + + /// `None` defaults to 720p (when an aspect ratio is set). + pub resolution: Option, + + /// Reference images (JPEG, PNG, WebP) for image-to-video. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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 { + 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, + resolution: Option, + ) -> GenerateDoubaoSeedance2p0FastRequest { + GenerateDoubaoSeedance2p0FastRequest { + prompt: "ok".to_string(), + duration_seconds: None, + aspect_ratio, + resolution, + input_reference_images: vec![], + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3.rs new file mode 100644 index 0000000000..80e9baa618 --- /dev/null +++ b/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, + + pub size: Option, + + /// Reference images for image-to-video / start-end-to-video workflows. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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) -> GenerateViduQ3Request { + GenerateViduQ3Request { + prompt: "ok".to_string(), + duration_seconds, + size: None, + input_reference_images: vec![], + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3_turbo.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_vidu_q3_turbo.rs new file mode 100644 index 0000000000..325d3bc92d --- /dev/null +++ b/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, + + pub size: Option, + + /// Reference images for image-to-video / start-end-to-video workflows. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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) -> GenerateViduQ3TurboRequest { + GenerateViduQ3TurboRequest { + prompt: "ok".to_string(), + duration_seconds, + size: None, + input_reference_images: vec![], + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p6.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p6.rs new file mode 100644 index 0000000000..942c77dcbf --- /dev/null +++ b/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, + + /// `None` uses the API default (720p). + pub size: Option, + + /// Reference images for image-to-video and reference-to-video workflows. + /// Wan 2.6 accepts up to 5 references. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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) -> GenerateWan2p6Request { + GenerateWan2p6Request { + prompt: "ok".to_string(), + duration_seconds, + size: None, + input_reference_images: vec![], + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p7.rs b/crates/api_clients/comet_api_client/src/generate/video/generate_wan_2p7.rs new file mode 100644 index 0000000000..b944c41993 --- /dev/null +++ b/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, + + /// `None` uses the API default (720p). + pub size: Option, + + /// Reference images for image-to-video and first/last-frame workflows. + pub input_reference_images: Vec, +} + +// ── 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 { + 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 { + 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) -> GenerateWan2p7Request { + GenerateWan2p7Request { + prompt: "ok".to_string(), + duration_seconds, + size: None, + input_reference_images: vec![], + } + } +} diff --git a/crates/api_clients/comet_api_client/src/generate/video/mod.rs b/crates/api_clients/comet_api_client/src/generate/video/mod.rs new file mode 100644 index 0000000000..edc28e6d88 --- /dev/null +++ b/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; diff --git a/crates/api_clients/comet_api_client/src/lib.rs b/crates/api_clients/comet_api_client/src/lib.rs new file mode 100644 index 0000000000..964cb8a029 --- /dev/null +++ b/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; diff --git a/crates/api_clients/comet_api_client/src/requests/comet_host.rs b/crates/api_clients/comet_api_client/src/requests/comet_host.rs new file mode 100644 index 0000000000..c8049b0568 --- /dev/null +++ b/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"; diff --git a/crates/api_clients/comet_api_client/src/requests/create_video/create_video.rs b/crates/api_clients/comet_api_client/src/requests/create_video/create_video.rs new file mode 100644 index 0000000000..06c5cc572a --- /dev/null +++ b/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, + + /// Output size: an aspect-ratio preset or exact dimensions. + pub maybe_size: Option, + + /// 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, +} + +/// 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, + + /// 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, +} + +// ── 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, + + /// 0-100 completion percentage. + pub maybe_progress: Option, + + /// Unix timestamp (seconds). + pub maybe_created_at: Option, +} + +/// 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 { + 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 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) -> 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); + } + } +} diff --git a/crates/api_clients/comet_api_client/src/requests/create_video/mod.rs b/crates/api_clients/comet_api_client/src/requests/create_video/mod.rs new file mode 100644 index 0000000000..272583fe9c --- /dev/null +++ b/crates/api_clients/comet_api_client/src/requests/create_video/mod.rs @@ -0,0 +1,2 @@ +pub mod create_video; +pub mod request_types; diff --git a/crates/api_clients/comet_api_client/src/requests/create_video/request_types.rs b/crates/api_clients/comet_api_client/src/requests/create_video/request_types.rs new file mode 100644 index 0000000000..8676db32fe --- /dev/null +++ b/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, + + /// Always "video". + pub object: Option, + + /// The model that will fulfil the task, eg. "doubao-seedance-2-0". + pub model: Option, + + /// Initial lifecycle status, typically "queued". + pub status: CometVideoTaskStatus, + + /// 0-100 completion percentage. + pub progress: Option, + + /// Unix timestamp (seconds). + pub created_at: Option, +} + +#[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); + } +} diff --git a/crates/api_clients/comet_api_client/src/requests/get_video_task/get_video_task.rs b/crates/api_clients/comet_api_client/src/requests/get_video_task/get_video_task.rs new file mode 100644 index 0000000000..8aa4a2cafe --- /dev/null +++ b/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, + + /// 0-100 completion percentage. + pub maybe_progress: Option, + + /// 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, + + /// Unix timestamp (seconds). + pub maybe_created_at: Option, + + /// Unix timestamp (seconds) when the task finished. + pub maybe_completed_at: Option, +} + +/// Fetch the current state of a video task (`GET /v1/videos/{id}`). +pub async fn get_video_task(args: GetVideoTaskArgs<'_>) -> Result { + 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!(); + } + } +} diff --git a/crates/api_clients/comet_api_client/src/requests/get_video_task/mod.rs b/crates/api_clients/comet_api_client/src/requests/get_video_task/mod.rs new file mode 100644 index 0000000000..2ab7ec621e --- /dev/null +++ b/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; diff --git a/crates/api_clients/comet_api_client/src/requests/get_video_task/request_types.rs b/crates/api_clients/comet_api_client/src/requests/get_video_task/request_types.rs new file mode 100644 index 0000000000..bc9bc28bfc --- /dev/null +++ b/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, + + /// The Seedance model used, eg. "doubao-seedance-2-0". + pub model: Option, + + /// Lifecycle status. + pub status: CometVideoTaskStatus, + + /// 0-100 completion percentage. + pub progress: Option, + + /// 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, + + /// Unix timestamp (seconds). + pub created_at: Option, + + /// Unix timestamp (seconds) when the task finished. + pub completed_at: Option, +} + +#[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()); + } +} diff --git a/crates/api_clients/comet_api_client/src/requests/mod.rs b/crates/api_clients/comet_api_client/src/requests/mod.rs new file mode 100644 index 0000000000..bebda1551b --- /dev/null +++ b/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; diff --git a/crates/api_clients/comet_api_client/src/requests/video_task_status.rs b/crates/api_clients/comet_api_client/src/requests/video_task_status.rs new file mode 100644 index 0000000000..d293f581b1 --- /dev/null +++ b/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>(deserializer: D) -> Result { + let value = String::deserialize(deserializer)?; + Ok(Self::from_str(&value)) + } +} + +impl Serialize for CometVideoTaskStatus { + fn serialize(&self, serializer: S) -> Result { + 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()); + } +} diff --git a/crates/api_clients/comet_api_client/src/test_utils/mod.rs b/crates/api_clients/comet_api_client/src/test_utils/mod.rs new file mode 100644 index 0000000000..e16f3ce4f2 --- /dev/null +++ b/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) +}