cleanup

.gitignore

@@ -36,7 +36,7 @@ script/socat_dev_database_connect.sh
 venv/
 
 # Testing
-requests/
+/requests/
 
 # Scratch data
 scratch/

Cargo.lock

@@ -10334,6 +10334,28 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "seedance2pro"
+version = "0.0.1"
+dependencies = [
+ "chrono",
+ "cloudflare_errors",
+ "env",
+ "env_logger 0.11.8",
+ "errors",
+ "log",
+ "rand 0.9.2",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "testing",
+ "tokio",
+ "url",
+ "workspace-build-acceleration",
+ "wreq",
+ "wreq-util",
+]
+
 [[package]]
 name = "selectors"
 version = "0.24.0"

Cargo.toml

@@ -16,6 +16,7 @@ members = [
   "crates/api_clients/midjourney_client",
   "crates/api_clients/openai_sora_client",
   "crates/api_clients/openart_client",
+  "crates/api_clients/seedance2pro",
   "crates/api_clients/runwayml_client",
   "crates/api_clients/thumbnail_generator",
   "crates/api_clients/world_labs_client",
@@ -232,6 +233,7 @@ memory_store = { path = "crates/lib/caching/memory_store" }
 midjourney_client = { path = "crates/api_clients/midjourney_client" }
 mimetypes = { path = "crates/lib/files/mimetypes" }
 openai_sora_client = { path = "crates/api_clients/openai_sora_client" }
+seedance2pro = { path = "crates/api_clients/seedance2pro" }
 primitives = { path = "crates/lib/data/primitives" }
 shared_service_components = { path = "crates/lib/shared_service_components" }
 sqlite_tasks = { path = "crates/schema/database/sqlite_tasks" }

crates/api_clients/seedance2pro/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "seedance2pro"
+edition = "2024"
+version = "0.0.1"
+publish = false
+
+[package.metadata.cargo-udeps.ignore]
+normal = ["workspace-build-acceleration"]
+
+[lib]
+name = "seedance2pro"
+path = "src/lib.rs"
+
+[dependencies]
+# Workspace hack (faster compile times)
+workspace-build-acceleration.workspace = true
+
+# Internal
+errors.workspace = true
+
+# External
+chrono.workspace = true
+cloudflare_errors.workspace = true
+log.workspace = true
+rand.workspace = true
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+wreq.workspace = true
+wreq-util.workspace = true
+url.workspace = true
+
+[dev-dependencies]
+chrono.workspace = true
+env.workspace = true
+env_logger.workspace = true
+testing = { path = "../../lib/testing" }
+tokio = { version = "1", features = ["full"] }

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

@@ -0,0 +1,2 @@
+pub mod seedance2pro_cookies;
+pub mod seedance2pro_session;

crates/api_clients/seedance2pro/src/creds/seedance2pro_cookies.rs

@@ -0,0 +1,24 @@
+/// Cookies are the credential required to interact with the Seedance2 Pro API.
+
+#[derive(Clone)]
+pub struct Seedance2ProCookies {
+  cookies: String,
+}
+
+impl Seedance2ProCookies {
+  pub fn new(cookies: String) -> Self {
+    Seedance2ProCookies { cookies }
+  }
+
+  pub fn as_str(&self) -> &str {
+    &self.cookies
+  }
+
+  pub fn as_bytes(&self) -> &[u8] {
+    self.cookies.as_bytes()
+  }
+
+  pub fn to_string(&self) -> String {
+    self.cookies.clone()
+  }
+}

crates/api_clients/seedance2pro/src/creds/seedance2pro_session.rs

@@ -0,0 +1,19 @@
+use crate::creds::seedance2pro_cookies::Seedance2ProCookies;
+
+/// Holds the full session data needed to make authenticated requests to Seedance2 Pro.
+#[derive(Clone)]
+pub struct Seedance2ProSession {
+  pub cookies: Seedance2ProCookies,
+}
+
+impl Seedance2ProSession {
+  pub fn new(cookies: Seedance2ProCookies) -> Self {
+    Seedance2ProSession { cookies }
+  }
+
+  pub fn from_cookies_string(cookies: String) -> Self {
+    Seedance2ProSession {
+      cookies: Seedance2ProCookies::new(cookies),
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+pub mod seedance2pro_client_error;
+pub mod seedance2pro_error;
+pub mod seedance2pro_generic_api_error;
+pub mod seedance2pro_specific_api_error;

crates/api_clients/seedance2pro/src/error/seedance2pro_client_error.rs

@@ -0,0 +1,26 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug)]
+pub enum Seedance2ProClientError {
+  /// No cookies are present in the session.
+  NoCookiesPresent,
+
+  /// Error parsing a URL.
+  UrlParseError(url::ParseError),
+
+  /// An error was encountered in building the Wreq client.
+  WreqClientError(wreq::Error),
+}
+
+impl Error for Seedance2ProClientError {}
+
+impl Display for Seedance2ProClientError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::NoCookiesPresent => write!(f, "No cookies present in the session."),
+      Self::UrlParseError(err) => write!(f, "URL parse error: {}", err),
+      Self::WreqClientError(err) => write!(f, "Wreq client error (during client creation): {}", err),
+    }
+  }
+}

crates/api_clients/seedance2pro/src/error/seedance2pro_error.rs

@@ -0,0 +1,54 @@
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_generic_api_error::Seedance2ProGenericApiError;
+use crate::error::seedance2pro_specific_api_error::Seedance2ProSpecificApiError;
+use cloudflare_errors::cloudflare_error::CloudflareError;
+use std::error::Error;
+
+#[derive(Debug)]
+pub enum Seedance2ProError {
+  Client(Seedance2ProClientError),
+  ApiSpecific(Seedance2ProSpecificApiError),
+  ApiGeneric(Seedance2ProGenericApiError),
+}
+
+impl Seedance2ProError {
+  pub fn is_having_downtime_issues(&self) -> bool {
+    match self {
+      Self::ApiGeneric(Seedance2ProGenericApiError::Http502ErrorBadGateway(_)) => true,
+      Self::ApiGeneric(Seedance2ProGenericApiError::CloudflareError(CloudflareError::BadGateway502)) => true,
+      Self::ApiGeneric(Seedance2ProGenericApiError::CloudflareError(CloudflareError::GatewayTimeout504)) => true,
+      Self::ApiGeneric(Seedance2ProGenericApiError::CloudflareError(CloudflareError::TimeoutOccurred524)) => true,
+      _ => false,
+    }
+  }
+}
+
+impl Error for Seedance2ProError {}
+
+impl std::fmt::Display for Seedance2ProError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::Client(e) => write!(f, "Seedance2ProClientError: {:?}", e),
+      Self::ApiSpecific(e) => write!(f, "Seedance2ProSpecificApiError: {:?}", e),
+      Self::ApiGeneric(e) => write!(f, "Seedance2ProGenericApiError: {:?}", e),
+    }
+  }
+}
+
+impl From<Seedance2ProClientError> for Seedance2ProError {
+  fn from(error: Seedance2ProClientError) -> Self {
+    Self::Client(error)
+  }
+}
+
+impl From<Seedance2ProSpecificApiError> for Seedance2ProError {
+  fn from(error: Seedance2ProSpecificApiError) -> Self {
+    Self::ApiSpecific(error)
+  }
+}
+
+impl From<Seedance2ProGenericApiError> for Seedance2ProError {
+  fn from(error: Seedance2ProGenericApiError) -> Self {
+    Self::ApiGeneric(error)
+  }
+}

crates/api_clients/seedance2pro/src/error/seedance2pro_generic_api_error.rs

@@ -0,0 +1,50 @@
+use cloudflare_errors::cloudflare_error::CloudflareError;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+use wreq::StatusCode;
+
+#[derive(Debug)]
+pub enum Seedance2ProGenericApiError {
+  /// Specific Cloudflare errors.
+  CloudflareError(CloudflareError),
+
+  /// HTTP 502 Bad Gateway.
+  /// We preserve the message for debugging.
+  Http502ErrorBadGateway(String),
+
+  /// serde_json::Error, likely from JSON deserialization schema mismatch.
+  /// Includes the original body.
+  SerdeResponseParseErrorWithBody(serde_json::Error, String),
+
+  /// serde_json::Error on a non-200 (error) response.
+  /// Includes the original body.
+  SerdeParseErrorWithBodyOnNon200(serde_json::Error, String),
+
+  /// An uncategorized bad HTTP response.
+  UncategorizedBadResponse(String),
+
+  /// An uncategorized bad HTTP response with status code and body.
+  UncategorizedBadResponseWithStatusAndBody {
+    status_code: StatusCode,
+    body: String,
+  },
+
+  /// An uncaught error from the HTTP client.
+  WreqError(wreq::Error),
+}
+
+impl Error for Seedance2ProGenericApiError {}
+
+impl Display for Seedance2ProGenericApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::CloudflareError(err) => write!(f, "Cloudflare error: {}", err),
+      Self::Http502ErrorBadGateway(msg) => write!(f, "HTTP 502 Bad Gateway: {}", msg),
+      Self::SerdeResponseParseErrorWithBody(err, body) => write!(f, "Failed to parse response body: {:?}. Body: {}", err, body),
+      Self::SerdeParseErrorWithBodyOnNon200(err, body) => write!(f, "Failed to parse non-200 response body: {:?}. Body: {}", err, body),
+      Self::UncategorizedBadResponse(msg) => write!(f, "Uncategorized bad response: {}", msg),
+      Self::UncategorizedBadResponseWithStatusAndBody { status_code, body } => write!(f, "Uncategorized bad response: status code {}, body: {}", status_code, body),
+      Self::WreqError(err) => write!(f, "Wreq client error: {}", err),
+    }
+  }
+}

crates/api_clients/seedance2pro/src/error/seedance2pro_specific_api_error.rs

@@ -0,0 +1,22 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug)]
+pub enum Seedance2ProSpecificApiError {
+  /// The session cookies are expired or invalid.
+  UnauthorizedSessionExpired,
+
+  /// The video generation request was flagged as a content violation.
+  VideoGenerationViolation(String),
+}
+
+impl Error for Seedance2ProSpecificApiError {}
+
+impl Display for Seedance2ProSpecificApiError {
+  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::UnauthorizedSessionExpired => write!(f, "Unauthorized: session cookies expired or invalid."),
+      Self::VideoGenerationViolation(body) => write!(f, "Video generation violation: {}", body),
+    }
+  }
+}

crates/api_clients/seedance2pro/src/lib.rs

@@ -0,0 +1,8 @@
+#[cfg(test)]
+pub (crate) mod test_utils;
+
+// User API
+pub mod creds;
+pub mod error;
+pub mod requests;
+pub mod utils;

crates/api_clients/seedance2pro/src/requests/generate_video/generate_video.rs

@@ -0,0 +1,300 @@
+use crate::creds::seedance2pro_session::Seedance2ProSession;
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_error::Seedance2ProError;
+use crate::error::seedance2pro_generic_api_error::Seedance2ProGenericApiError;
+use crate::error::seedance2pro_specific_api_error::Seedance2ProSpecificApiError;
+use crate::requests::generate_video::request_types::*;
+use crate::utils::common_headers::FIREFOX_USER_AGENT;
+use log::info;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const RUN_TASK_URL: &str = "https://seedance2-pro.com/api/trpc/workflow.runTask?batch=1";
+
+// --- Request args ---
+
+pub struct GenerateVideoArgs<'a> {
+  pub session: &'a Seedance2ProSession,
+
+  pub prompt: String,
+
+  pub resolution: Resolution,
+
+  /// Duration in seconds (4–15).
+  pub duration_seconds: u8,
+
+  pub batch_count: BatchCount,
+
+  /// Optional start frame image URL (keyframe mode).
+  pub start_frame_url: Option<String>,
+
+  /// Optional end frame image URL (keyframe mode).
+  pub end_frame_url: Option<String>,
+
+  /// Optional reference image URLs (reference mode). When present, takes priority over start/end frames.
+  pub reference_image_urls: Option<Vec<String>>,
+}
+
+// --- Public enums ---
+
+/// Video resolution / aspect ratio.
+#[derive(Debug, Clone, Copy)]
+pub enum Resolution {
+  /// 16:9 landscape (1280x720)
+  Landscape16x9,
+  /// 9:16 portrait (720x1280)
+  Portrait9x16,
+  /// 1:1 square (720x720)
+  Square1x1,
+  /// 4:3 standard (960x720)
+  Standard4x3,
+  /// 3:4 portrait (720x960)
+  Portrait3x4,
+}
+
+impl Resolution {
+  fn as_str(&self) -> &'static str {
+    match self {
+      Self::Landscape16x9 => "1280x720",
+      Self::Portrait9x16 => "720x1280",
+      Self::Square1x1 => "720x720",
+      Self::Standard4x3 => "960x720",
+      Self::Portrait3x4 => "720x960",
+    }
+  }
+}
+
+/// Number of videos to generate in a single request.
+#[derive(Debug, Clone, Copy)]
+pub enum BatchCount {
+  One,
+  Two,
+  Four,
+}
+
+impl BatchCount {
+  fn as_u8(&self) -> u8 {
+    match self {
+      Self::One => 1,
+      Self::Two => 2,
+      Self::Four => 4,
+    }
+  }
+}
+
+// --- Response ---
+
+pub struct GenerateVideoResponse {
+  pub task_id: String,
+
+  pub order_id: String,
+
+  /// Present when batch_count > 1.
+  pub task_ids: Option<Vec<String>>,
+
+  /// Present when batch_count > 1.
+  pub order_ids: Option<Vec<String>>,
+}
+
+// --- Implementation ---
+
+pub async fn generate_video(args: GenerateVideoArgs<'_>) -> Result<GenerateVideoResponse, Seedance2ProError> {
+  let is_reference_mode = args.reference_image_urls.as_ref().is_some_and(|urls| !urls.is_empty());
+
+  let video_input_mode = if is_reference_mode { "reference" } else { "keyframe" };
+
+  let uploaded_urls: Option<Vec<String>> = if is_reference_mode {
+    args.reference_image_urls
+  } else {
+    let mut urls = Vec::new();
+    if let Some(url) = args.start_frame_url {
+      urls.push(url);
+    }
+    if let Some(url) = args.end_frame_url {
+      urls.push(url);
+    }
+    if urls.is_empty() { None } else { Some(urls) }
+  };
+
+  let batch_count_value = args.batch_count.as_u8();
+  let batch_count = if batch_count_value > 1 { Some(batch_count_value) } else { None };
+
+  let duration = format!("{}s", args.duration_seconds);
+
+  info!(
+    "Generating video: mode={}, resolution={}, duration={}, batch={}",
+    video_input_mode, args.resolution.as_str(), duration, batch_count_value
+  );
+
+  let request_body = BatchRequest {
+    zero: BatchRequestInner {
+      json: BatchRequestJson {
+        business_type: "wan22-video-generation",
+        api_params: ApiParams {
+          prompt: args.prompt,
+          resolution: args.resolution.as_str().to_string(),
+          mode: "normal",
+          model: "seedance-20",
+          duration,
+          video_input_mode,
+          uploaded_urls,
+          batch_count,
+        },
+      },
+    },
+  };
+
+  let cookie = args.session.cookies.as_str();
+
+  let client = Client::builder()
+    .emulation(Emulation::Firefox143)
+    .build()
+    .map_err(|err| Seedance2ProClientError::WreqClientError(err))?;
+
+  let response = client.post(RUN_TASK_URL)
+    .header("User-Agent", FIREFOX_USER_AGENT)
+    .header("Accept", "*/*")
+    .header("Accept-Language", "en-US,en;q=0.9")
+    .header("Accept-Encoding", "gzip, deflate, br, zstd")
+    .header("Referer", "https://seedance2-pro.com/")
+    .header("Content-Type", "application/json")
+    .header("x-trpc-source", "client")
+    .header("Origin", "https://seedance2-pro.com")
+    .header("Connection", "keep-alive")
+    .header("Cookie", cookie)
+    .header("Sec-Fetch-Dest", "empty")
+    .header("Sec-Fetch-Mode", "cors")
+    .header("Sec-Fetch-Site", "same-origin")
+    .header("Priority", "u=4")
+    .header("TE", "trailers")
+    .json(&request_body)
+    .send()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  let status = response.status();
+  let response_body = response.text()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  info!("Response status: {}, body: {}", status, response_body);
+
+  if !status.is_success() {
+    return Err(Seedance2ProGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+      status_code: status,
+      body: response_body,
+    }.into());
+  }
+
+  let batch_response: Vec<BatchResponseItem> = serde_json::from_str(&response_body)
+    .map_err(|err| Seedance2ProGenericApiError::SerdeResponseParseErrorWithBody(err, response_body.clone()))?;
+
+  let task_data = batch_response
+    .into_iter()
+    .next()
+    .ok_or_else(|| Seedance2ProGenericApiError::UncategorizedBadResponse(
+      "Empty batch response array".to_string()
+    ))?
+    .result
+    .data
+    .json;
+
+  if task_data.violation_warning {
+    return Err(Seedance2ProSpecificApiError::VideoGenerationViolation(response_body).into());
+  }
+
+  Ok(GenerateVideoResponse {
+    task_id: task_data.task_id,
+    order_id: task_data.order_id,
+    task_ids: task_data.task_ids,
+    order_ids: task_data.order_ids,
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::creds::seedance2pro_session::Seedance2ProSession;
+  use crate::test_utils::get_test_cookies::get_test_cookies;
+  use crate::test_utils::setup_test_logging::setup_test_logging;
+  use errors::AnyhowResult;
+  use log::LevelFilter;
+
+  fn test_session() -> AnyhowResult<Seedance2ProSession> {
+    let cookies = get_test_cookies()?;
+    Ok(Seedance2ProSession::from_cookies_string(cookies))
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies
+  async fn test_generate_text_to_video() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+    let args = GenerateVideoArgs {
+      session: &session,
+      prompt: "A corgi eating a cake in a fancy kitchen.".to_string(),
+      resolution: Resolution::Square1x1,
+      duration_seconds: 5,
+      batch_count: BatchCount::One,
+      start_frame_url: None,
+      end_frame_url: None,
+      reference_image_urls: None,
+    };
+    let result = generate_video(args).await?;
+    println!("Task ID: {}", result.task_id);
+    println!("Order ID: {}", result.order_id);
+    assert!(!result.task_id.is_empty());
+    assert!(!result.order_id.is_empty());
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies
+  async fn test_generate_keyframe_video() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+    let args = GenerateVideoArgs {
+      session: &session,
+      prompt: "A dog shakes the glasses off its head. The camera pans out as the shiba shakes. The shiba barks.".to_string(),
+      resolution: Resolution::Landscape16x9,
+      duration_seconds: 15,
+      batch_count: BatchCount::One,
+      start_frame_url: Some("https://static.seedance2-pro.com/materials/20260219/1771496300184-fb32e08c.jpg".to_string()),
+      end_frame_url: None,
+      reference_image_urls: None,
+    };
+    let result = generate_video(args).await?;
+    println!("Task ID: {}", result.task_id);
+    println!("Order ID: {}", result.order_id);
+    assert!(!result.task_id.is_empty());
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies
+  async fn test_generate_reference_video() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+    let args = GenerateVideoArgs {
+      session: &session,
+      prompt: "The dog in @2 is in the office at @1 without the man. The office is dark and moonlight streams in through the windows. Particles of dust gleam in the moon beams. Suddenly, the dog jumps on the desk and barks.".to_string(),
+      resolution: Resolution::Standard4x3,
+      duration_seconds: 10,
+      batch_count: BatchCount::One,
+      start_frame_url: None,
+      end_frame_url: None,
+      reference_image_urls: Some(vec![
+        "https://static.seedance2-pro.com/materials/20260219/1771463564512-b14bfe90.png".to_string(),
+        "https://static.seedance2-pro.com/materials/20260219/1771496300184-fb32e08c.jpg".to_string(),
+      ]),
+    };
+    let result = generate_video(args).await?;
+    println!("Task ID: {}", result.task_id);
+    println!("Order ID: {}", result.order_id);
+    assert!(!result.task_id.is_empty());
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+}

crates/api_clients/seedance2pro/src/requests/generate_video/mod.rs

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

crates/api_clients/seedance2pro/src/requests/generate_video/request_types.rs

@@ -0,0 +1,60 @@
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+pub (super) struct BatchRequest {
+  #[serde(rename = "0")]
+  pub zero: BatchRequestInner,
+}
+
+#[derive(Serialize)]
+pub (super) struct BatchRequestInner {
+  pub json: BatchRequestJson,
+}
+
+#[derive(Serialize)]
+pub (super) struct BatchRequestJson {
+  #[serde(rename = "businessType")]
+  pub business_type: &'static str,
+  #[serde(rename = "apiParams")]
+  pub api_params: ApiParams,
+}
+
+#[derive(Serialize)]
+pub (super) struct ApiParams {
+  pub prompt: String,
+  pub resolution: String,
+  pub mode: &'static str,
+  pub model: &'static str,
+  pub duration: String,
+  #[serde(rename = "videoInputMode")]
+  pub video_input_mode: &'static str,
+  #[serde(rename = "uploadedUrls", skip_serializing_if = "Option::is_none")]
+  pub uploaded_urls: Option<Vec<String>>,
+  #[serde(rename = "batchCount", skip_serializing_if = "Option::is_none")]
+  pub batch_count: Option<u8>,
+}
+
+#[derive(Deserialize, Debug)]
+pub (super) struct BatchResponseItem {
+  pub result: BatchResponseResult,
+}
+
+#[derive(Deserialize, Debug)]
+pub (super) struct BatchResponseResult {
+  pub data: BatchResponseData,
+}
+
+#[derive(Deserialize, Debug)]
+pub (super) struct BatchResponseData {
+  pub json: TaskResponseJson,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub (super) struct TaskResponseJson {
+  pub task_id: String,
+  pub order_id: String,
+  pub task_ids: Option<Vec<String>>,
+  pub order_ids: Option<Vec<String>>,
+  pub violation_warning: bool,
+}

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

@@ -0,0 +1,4 @@
+pub mod generate_video;
+pub mod poll_orders;
+pub mod prepare_image_upload;
+pub mod upload_image;

crates/api_clients/seedance2pro/src/requests/poll_orders/mod.rs

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

crates/api_clients/seedance2pro/src/requests/poll_orders/poll_orders.rs

@@ -0,0 +1,270 @@
+use crate::creds::seedance2pro_session::Seedance2ProSession;
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_error::Seedance2ProError;
+use crate::error::seedance2pro_generic_api_error::Seedance2ProGenericApiError;
+use crate::requests::poll_orders::request_types::*;
+use crate::utils::common_headers::FIREFOX_USER_AGENT;
+use log::info;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const GET_ORDERS_BASE_URL: &str = "https://seedance2-pro.com/api/trpc/userOrder.getOrders";
+
+/// Builds the tRPC `input` JSON for the getOrders endpoint.
+/// When `cursor` is `Some`, it is included in the JSON payload.
+fn build_input_json(cursor: Option<u64>) -> String {
+  match cursor {
+    None => r#"{"0":{"json":{"limit":30,"format":null,"direction":"forward"},"meta":{"values":{"format":["undefined"]},"v":1}}}"#.to_string(),
+    Some(c) => format!(
+      r#"{{"0":{{"json":{{"limit":30,"format":null,"cursor":{cursor},"direction":"forward"}},"meta":{{"values":{{"format":["undefined"]}},"v":1}}}}}}"#,
+      cursor = c
+    ),
+  }
+}
+
+// --- Args & response ---
+
+pub struct PollOrdersArgs<'a> {
+  pub session: &'a Seedance2ProSession,
+
+  /// Optional cursor from a previous `PollOrdersResponse::next_cursor`.
+  /// When `None`, the most recent orders are returned.
+  pub cursor: Option<u64>,
+}
+
+pub struct PollOrdersResponse {
+  pub orders: Vec<OrderStatus>,
+
+  /// Present when there are more orders to fetch.
+  /// Pass this value as `PollOrdersArgs::cursor` in the next call.
+  pub next_cursor: Option<u64>,
+}
+
+// --- Public types ---
+
+/// The lifecycle status of a video generation task.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TaskStatus {
+  /// The task is queued and has not started yet.
+  Pending,
+  /// The task is actively being processed.
+  Processing,
+  /// The task finished successfully. `result_url` and `results` will be populated.
+  Completed,
+  /// The task failed. `fail_reason` will contain the reason.
+  Failed,
+  /// An unrecognised status string was returned by the server.
+  Unknown(String),
+}
+
+impl TaskStatus {
+  fn from_str(s: &str) -> Self {
+    match s {
+      "PENDING" => Self::Pending,
+      "PROCESSING" => Self::Processing,
+      "COMPLETED" => Self::Completed,
+      "FAILED" => Self::Failed,
+      other => Self::Unknown(other.to_string()),
+    }
+  }
+
+  pub fn is_terminal(&self) -> bool {
+    matches!(self, Self::Completed | Self::Failed)
+  }
+}
+
+/// A single generated video result attached to an order.
+#[derive(Debug, Clone)]
+pub struct VideoResult {
+  pub url: String,
+  pub width: u32,
+  pub height: u32,
+  /// Width / height ratio (e.g. 1.777… for 16:9).
+  pub ratio: f64,
+}
+
+/// The status of one order (one video generation task).
+#[derive(Debug, Clone)]
+pub struct OrderStatus {
+  pub order_id: String,
+
+  pub task_status: TaskStatus,
+
+  /// Top-level result video URL. Populated when `task_status` is `Completed`.
+  pub result_url: Option<String>,
+
+  /// Detailed result entries. Typically one entry per video.
+  pub results: Vec<VideoResult>,
+
+  /// Failure reason. Populated when `task_status` is `Failed`.
+  pub fail_reason: Option<String>,
+
+  /// ISO 8601 creation timestamp (e.g. `"2026-02-19T01:20:50.398Z"`).
+  pub created_at: String,
+}
+
+// --- Implementation ---
+
+pub async fn poll_orders(args: PollOrdersArgs<'_>) -> Result<PollOrdersResponse, Seedance2ProError> {
+  info!("Polling orders (cursor: {:?})...", args.cursor);
+
+  let input_json = build_input_json(args.cursor);
+
+  let client = Client::builder()
+    .emulation(Emulation::Firefox143)
+    .build()
+    .map_err(|err| Seedance2ProClientError::WreqClientError(err))?;
+
+  let cookie = args.session.cookies.as_str();
+
+  let response = client.get(GET_ORDERS_BASE_URL)
+    .query(&[("batch", "1"), ("input", input_json.as_str())])
+    .header("User-Agent", FIREFOX_USER_AGENT)
+    .header("Accept", "*/*")
+    .header("Accept-Language", "en-US,en;q=0.9")
+    .header("Accept-Encoding", "gzip, deflate, br, zstd")
+    .header("Referer", "https://seedance2-pro.com/app/gallery")
+    .header("content-type", "application/json")
+    .header("x-trpc-source", "client")
+    .header("Connection", "keep-alive")
+    .header("Cookie", cookie)
+    .header("Sec-Fetch-Dest", "empty")
+    .header("Sec-Fetch-Mode", "cors")
+    .header("Sec-Fetch-Site", "same-origin")
+    .header("Priority", "u=4")
+    .header("TE", "trailers")
+    .send()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  let status = response.status();
+  let response_body = response.text()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  info!("Poll orders response status: {}", status);
+
+  if !status.is_success() {
+    return Err(Seedance2ProGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+      status_code: status,
+      body: response_body,
+    }.into());
+  }
+
+  let batch_response: Vec<BatchResponseItem> = serde_json::from_str(&response_body)
+    .map_err(|err| Seedance2ProGenericApiError::SerdeResponseParseErrorWithBody(err, response_body.clone()))?;
+
+  let json = batch_response
+    .into_iter()
+    .next()
+    .ok_or_else(|| Seedance2ProGenericApiError::UncategorizedBadResponse(
+      "Empty batch response array".to_string()
+    ))?
+    .result
+    .data
+    .json;
+
+  let next_cursor = json.next_cursor;
+
+  let orders: Vec<OrderStatus> = json.orders
+    .into_iter()
+    .map(|o| OrderStatus {
+      order_id: o.order_id,
+      task_status: TaskStatus::from_str(&o.task_status),
+      result_url: o.result_url,
+      results: o.results.into_iter().map(|r| VideoResult {
+        url: r.url,
+        width: r.width,
+        height: r.height,
+        ratio: r.ratio,
+      }).collect(),
+      fail_reason: o.fail_reason,
+      created_at: o.created_at,
+    })
+    .collect();
+
+  info!("Polled {} orders, next_cursor: {:?}", orders.len(), next_cursor);
+
+  Ok(PollOrdersResponse { orders, next_cursor })
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::creds::seedance2pro_session::Seedance2ProSession;
+  use crate::test_utils::get_test_cookies::get_test_cookies;
+  use crate::test_utils::setup_test_logging::setup_test_logging;
+  use errors::AnyhowResult;
+  use log::LevelFilter;
+
+  fn test_session() -> AnyhowResult<Seedance2ProSession> {
+    let cookies = get_test_cookies()?;
+    Ok(Seedance2ProSession::from_cookies_string(cookies))
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies
+  async fn test_poll_all_orders() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+    let result = poll_orders(PollOrdersArgs { session: &session, cursor: None }).await?;
+    println!("Orders returned: {}", result.orders.len());
+    println!("Next cursor: {:?}", result.next_cursor);
+    for order in &result.orders {
+      println!("  {} | {:?} | result_url={:?} | fail={:?}",
+        order.order_id, order.task_status, order.result_url, order.fail_reason);
+    }
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies and a known cursor value
+  async fn test_poll_with_cursor() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+    // Use the cursor value returned from a prior call (e.g. 394062 from the example responses).
+    let cursor: u64 = 394062;
+    let result = poll_orders(PollOrdersArgs { session: &session, cursor: Some(cursor) }).await?;
+    println!("Orders returned (with cursor {}): {}", cursor, result.orders.len());
+    println!("Next cursor: {:?}", result.next_cursor);
+    for order in &result.orders {
+      println!("  {} | {:?} | result_url={:?} | fail={:?}",
+        order.order_id, order.task_status, order.result_url, order.fail_reason);
+    }
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies; exhausts all pages
+  async fn test_poll_all_pages() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let session = test_session()?;
+
+    let mut cursor: Option<u64> = None;
+    let mut page = 0usize;
+    let mut total_orders = 0usize;
+
+    loop {
+      page += 1;
+      let result = poll_orders(PollOrdersArgs { session: &session, cursor }).await?;
+      let page_count = result.orders.len();
+      total_orders += page_count;
+
+      println!("Page {}: {} orders, next_cursor: {:?}", page, page_count, result.next_cursor);
+      for order in &result.orders {
+        println!("  {} | {:?}", order.order_id, order.task_status);
+      }
+
+      cursor = result.next_cursor;
+      if cursor.is_none() {
+        break;
+      }
+    }
+
+    println!("Total orders across {} pages: {}", page, total_orders);
+    assert_eq!(1, 2); // NB: Intentional failure to inspect output.
+    Ok(())
+  }
+}

crates/api_clients/seedance2pro/src/requests/poll_orders/request_types.rs

@@ -0,0 +1,42 @@
+use serde_derive::Deserialize;
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseItem {
+  pub result: BatchResponseResult,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseResult {
+  pub data: BatchResponseData,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseData {
+  pub json: OrdersResponseJson,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct OrdersResponseJson {
+  pub orders: Vec<RawOrder>,
+  pub next_cursor: Option<u64>,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct RawOrder {
+  pub order_id: String,
+  pub result_url: Option<String>,
+  pub task_status: String,
+  pub results: Vec<RawVideoResult>,
+  pub fail_reason: Option<String>,
+  pub created_at: String,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct RawVideoResult {
+  pub url: String,
+  pub width: u32,
+  pub height: u32,
+  pub ratio: f64,
+}

crates/api_clients/seedance2pro/src/requests/prepare_image_upload/mod.rs

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

crates/api_clients/seedance2pro/src/requests/prepare_image_upload/prepare_image_upload.rs

@@ -0,0 +1,140 @@
+use crate::creds::seedance2pro_session::Seedance2ProSession;
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_error::Seedance2ProError;
+use crate::error::seedance2pro_generic_api_error::Seedance2ProGenericApiError;
+use crate::requests::prepare_image_upload::request_types::*;
+use crate::utils::common_headers::FIREFOX_USER_AGENT;
+use chrono::Utc;
+use log::info;
+use rand::Rng;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const SIGNED_UPLOAD_URL: &str = "https://seedance2-pro.com/api/trpc/uploads.signedUploadUrl?batch=1";
+
+/// Generates a material path based on the current time.
+/// Format: `materials/YYYYMMDD/<unix_millis>-<random_hex>.png`
+fn generate_material_path() -> String {
+  let now = Utc::now();
+  let date_part = now.format("%Y%m%d").to_string();
+  let timestamp_millis = now.timestamp_millis();
+  let random_hex: u32 = rand::rng().random();
+  let hex_part = format!("{:08x}", random_hex);
+  format!("materials/{}/{}-{}.png", date_part, timestamp_millis, hex_part)
+}
+
+pub struct PrepareImageUploadArgs<'a> {
+  pub session: &'a Seedance2ProSession,
+}
+
+pub struct PrepareImageUploadResponse {
+  /// The signed URL to upload the image to (Cloudflare R2 / S3-compatible).
+  pub upload_url: String,
+
+  /// The material path that was generated for this upload.
+  pub material_path: String,
+}
+
+pub async fn prepare_image_upload(args: PrepareImageUploadArgs<'_>) -> Result<PrepareImageUploadResponse, Seedance2ProError> {
+  let material_path = generate_material_path();
+
+  info!("Preparing image upload with path: {}", material_path);
+
+  let client = Client::builder()
+    .emulation(Emulation::Firefox143)
+    .build()
+    .map_err(|err| Seedance2ProClientError::WreqClientError(err))?;
+
+  let request_body = BatchRequest {
+    zero: BatchRequestInner {
+      json: BatchRequestJson {
+        path: material_path.clone(),
+      },
+    },
+  };
+
+  let cookie = args.session.cookies.as_str();
+
+  let response = client.post(SIGNED_UPLOAD_URL)
+    .header("User-Agent", FIREFOX_USER_AGENT)
+    .header("Accept", "*/*")
+    .header("Accept-Language", "en-US,en;q=0.9")
+    .header("Accept-Encoding", "gzip, deflate, br, zstd")
+    .header("Referer", "https://seedance2-pro.com/")
+    .header("Content-Type", "application/json")
+    .header("x-trpc-source", "client")
+    .header("Origin", "https://seedance2-pro.com")
+    .header("Connection", "keep-alive")
+    .header("Cookie", cookie)
+    .header("Sec-Fetch-Dest", "empty")
+    .header("Sec-Fetch-Mode", "cors")
+    .header("Sec-Fetch-Site", "same-origin")
+    .header("Priority", "u=4")
+    .header("TE", "trailers")
+    .json(&request_body)
+    .send()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  let status = response.status();
+  let response_body = response.text()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  info!("Response status: {}, body: {}", status, response_body);
+
+  if !status.is_success() {
+    return Err(Seedance2ProGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+      status_code: status,
+      body: response_body,
+    }.into());
+  }
+
+  let batch_response: Vec<BatchResponseItem> = serde_json::from_str(&response_body)
+    .map_err(|err| Seedance2ProGenericApiError::SerdeResponseParseErrorWithBody(err, response_body.clone()))?;
+
+  let upload_url = batch_response
+    .into_iter()
+    .next()
+    .ok_or_else(|| Seedance2ProGenericApiError::UncategorizedBadResponse(
+      "Empty batch response array".to_string()
+    ))?
+    .result
+    .data
+    .json;
+
+  Ok(PrepareImageUploadResponse {
+    upload_url,
+    material_path,
+  })
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::creds::seedance2pro_session::Seedance2ProSession;
+  use crate::test_utils::get_test_cookies::get_test_cookies;
+  use crate::test_utils::setup_test_logging::setup_test_logging;
+  use errors::AnyhowResult;
+  use log::LevelFilter;
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies
+  async fn test_prepare_image_upload() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+    let cookies = get_test_cookies()?;
+    let session = Seedance2ProSession::from_cookies_string(cookies);
+    let args = PrepareImageUploadArgs {
+      session: &session,
+    };
+    let result = prepare_image_upload(args).await?;
+    println!("Upload URL: {}", result.upload_url);
+    println!("Material path: {}", result.material_path);
+    assert!(!result.upload_url.is_empty());
+    assert!(result.upload_url.contains("cloudflarestorage.com"));
+    assert!(result.material_path.starts_with("materials/"));
+
+    assert_eq!(1, 2); // NB: Intentional failure to check the response.
+    Ok(())
+  }
+}

crates/api_clients/seedance2pro/src/requests/prepare_image_upload/request_types.rs

@@ -0,0 +1,32 @@
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Serialize)]
+pub(super) struct BatchRequest {
+  #[serde(rename = "0")]
+  pub zero: BatchRequestInner,
+}
+
+#[derive(Serialize)]
+pub(super) struct BatchRequestInner {
+  pub json: BatchRequestJson,
+}
+
+#[derive(Serialize)]
+pub(super) struct BatchRequestJson {
+  pub path: String,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseItem {
+  pub result: BatchResponseResult,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseResult {
+  pub data: BatchResponseData,
+}
+
+#[derive(Deserialize, Debug)]
+pub(super) struct BatchResponseData {
+  pub json: String,
+}

crates/api_clients/seedance2pro/src/requests/upload_image/mod.rs

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

crates/api_clients/seedance2pro/src/requests/upload_image/upload_image.rs

@@ -0,0 +1,127 @@
+use crate::error::seedance2pro_client_error::Seedance2ProClientError;
+use crate::error::seedance2pro_error::Seedance2ProError;
+use crate::error::seedance2pro_generic_api_error::Seedance2ProGenericApiError;
+use crate::utils::common_headers::FIREFOX_USER_AGENT;
+use log::info;
+use url::Url;
+use wreq::Client;
+use wreq_util::Emulation;
+
+const STATIC_BASE_URL: &str = "https://static.seedance2-pro.com";
+
+pub struct UploadImageArgs {
+  /// The signed upload URL returned by `prepare_image_upload`.
+  pub upload_url: String,
+
+  /// The raw image bytes to upload.
+  pub image_bytes: Vec<u8>,
+}
+
+pub struct UploadImageResponse {
+  /// The public-facing URL for the uploaded image.
+  /// e.g. `https://static.seedance2-pro.com/materials/20260219/1771463564512-b14bfe90.png`
+  pub public_url: String,
+}
+
+/// Extracts the path from the R2 upload URL and builds the static public URL.
+/// e.g. `https://comm.….r2.cloudflarestorage.com/materials/20260219/…?X-Amz-…`
+///   -> `https://static.seedance2-pro.com/materials/20260219/…`
+fn build_public_url(upload_url: &str) -> Result<String, Seedance2ProError> {
+  let parsed = Url::parse(upload_url)
+    .map_err(|err| Seedance2ProClientError::UrlParseError(err))?;
+  let path = parsed.path(); // e.g. "/materials/20260219/1771463564512-b14bfe90.png"
+  Ok(format!("{}{}", STATIC_BASE_URL, path))
+}
+
+pub async fn upload_image(args: UploadImageArgs) -> Result<UploadImageResponse, Seedance2ProError> {
+  info!("Uploading image to: {}", args.upload_url);
+
+  let client = Client::builder()
+    .emulation(Emulation::Firefox143)
+    .build()
+    .map_err(|err| Seedance2ProClientError::WreqClientError(err))?;
+
+  let response = client.put(&args.upload_url)
+    .header("User-Agent", FIREFOX_USER_AGENT)
+    .header("Accept", "*/*")
+    .header("Accept-Language", "en-US,en;q=0.9")
+    .header("Accept-Encoding", "gzip, deflate, br, zstd")
+    .header("Referer", "https://seedance2-pro.com/")
+    .header("Origin", "https://seedance2-pro.com")
+    .header("Connection", "keep-alive")
+    .header("Sec-Fetch-Dest", "empty")
+    .header("Sec-Fetch-Mode", "cors")
+    .header("Sec-Fetch-Site", "cross-site")
+    .header("Priority", "u=4")
+    .body(args.image_bytes)
+    .send()
+    .await
+    .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+  let status = response.status();
+
+  info!("Upload response status: {}", status);
+
+  if !status.is_success() {
+    let body = response.text()
+      .await
+      .map_err(|err| Seedance2ProGenericApiError::WreqError(err))?;
+
+    return Err(Seedance2ProGenericApiError::UncategorizedBadResponseWithStatusAndBody {
+      status_code: status,
+      body,
+    }.into());
+  }
+
+  let public_url = build_public_url(&args.upload_url)?;
+
+  info!("Public URL: {}", public_url);
+
+  Ok(UploadImageResponse { public_url })
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::creds::seedance2pro_session::Seedance2ProSession;
+  use crate::test_utils::get_test_cookies::get_test_cookies;
+  use crate::test_utils::setup_test_logging::setup_test_logging;
+  use crate::requests::prepare_image_upload::prepare_image_upload::{
+    prepare_image_upload, PrepareImageUploadArgs,
+  };
+  use errors::AnyhowResult;
+  use log::LevelFilter;
+  use std::fs;
+
+  #[tokio::test]
+  #[ignore] // manually test — requires real cookies and a test image
+  async fn test_upload_image() -> AnyhowResult<()> {
+    setup_test_logging(LevelFilter::Trace);
+
+    // Step 1: Get a signed upload URL
+    let cookies = get_test_cookies()?;
+    let session = Seedance2ProSession::from_cookies_string(cookies);
+    let prepare_args = PrepareImageUploadArgs {
+      session: &session,
+    };
+    let prepare_result = prepare_image_upload(prepare_args).await?;
+    println!("Upload URL: {}", prepare_result.upload_url);
+
+    // Step 2: Read a test image
+    let image_bytes = fs::read("/Users/bt/dev/storyteller/artcraft/test_data/image/juno.jpg")?;
+    println!("Image size: {} bytes", image_bytes.len());
+
+    // Step 3: Upload
+    let upload_args = UploadImageArgs {
+      upload_url: prepare_result.upload_url,
+      image_bytes,
+    };
+    let result = upload_image(upload_args).await?;
+    println!("Public URL: {}", result.public_url);
+
+    assert!(result.public_url.starts_with("https://static.seedance2-pro.com/materials/"));
+    assert_eq!(1, 2); // NB: Intentional failure to check the response.
+
+    Ok(())
+  }
+}

crates/api_clients/seedance2pro/src/test_utils/get_test_cookies.rs

@@ -0,0 +1,9 @@
+use errors::AnyhowResult;
+use std::fs::read_to_string;
+
+#[cfg(test)]
+pub fn get_test_cookies() -> AnyhowResult<String> {
+  let cookies = read_to_string("/Users/bt/Artcraft/credentials/seedance2pro_cookies.txt")?;
+  let cookies = cookies.trim().to_string();
+  Ok(cookies)
+}

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

@@ -0,0 +1,5 @@
+#[cfg(test)]
+pub (crate) mod get_test_cookies;
+
+#[cfg(test)]
+pub (crate) mod setup_test_logging;

crates/api_clients/seedance2pro/src/test_utils/setup_test_logging.rs

@@ -0,0 +1,52 @@
+use chrono::Local;
+use env_logger::Builder;
+use log::{debug, error, info, trace, warn, LevelFilter};
+use std::io::Write;
+
+const RUST_LOG: &str = "RUST_LOG";
+
+pub fn setup_test_logging(level: LevelFilter) {
+  let level_str = get_level_str(level);
+
+  println!("Previous log level: {:?}", env::var(RUST_LOG));
+
+  let is_unsafe = env::set_var(RUST_LOG, level_str);
+
+  if is_unsafe.is_none() {
+    println!("Unsafely setting Rust Log Level...");
+    unsafe { std::env::set_var(RUST_LOG, level_str) }
+  }
+
+  println!("Log level: {:?}", env::var(RUST_LOG));
+
+  Builder::new()
+    .is_test(true)
+    .format(|buf, record| {
+      writeln!(buf,
+        "{} [{}] - {}",
+        Local::now().format("%H:%M:%S%.6f"),
+        record.level(),
+        record.args()
+      )
+    })
+    .filter(None, level)
+    .filter_level(level)
+    .init();
+
+  trace!("Test trace log");
+  debug!("Test debug log");
+  info!("Test info log");
+  warn!("Test warn log");
+  error!("Test error log");
+}
+
+fn get_level_str(level: LevelFilter) -> &'static str {
+  match level {
+    LevelFilter::Error => "error",
+    LevelFilter::Warn => "warn",
+    LevelFilter::Info => "info",
+    LevelFilter::Debug => "debug",
+    LevelFilter::Trace => "trace",
+    LevelFilter::Off => "off",
+  }
+}

crates/api_clients/seedance2pro/src/utils/common_headers.rs

@@ -0,0 +1,2 @@
+pub const FIREFOX_USER_AGENT: &str =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0";

crates/api_clients/seedance2pro/src/utils/mod.rs

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