Shouldn't be doing this yet

- failed tasks to show in image generation session view
- failed tasks now show in task queue dropdown
- completed and failed tasks clearable on "clear all" click
- styling updates

Cargo.lock

@@ -791,6 +791,7 @@ dependencies = [
  "seedance2pro",
  "serde",
  "serde_derive",
+ "strum 0.28.0",
  "test_data",
  "tokens",
  "tokio",
@@ -1523,7 +1524,7 @@ dependencies = [
  "bitflags 2.11.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
@@ -3471,7 +3472,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
- "libloading 0.7.4",
+ "libloading 0.8.6",
 ]
 
 [[package]]
@@ -3776,7 +3777,7 @@ dependencies = [
  "serde_json",
  "sqlx",
  "storyteller_root",
- "strum",
+ "strum 0.26.2",
  "tokens",
  "tokio",
  "workspace-build-acceleration",
@@ -3938,7 +3939,7 @@ dependencies = [
  "sqlx",
  "sqlx-core",
  "sqlx-mysql",
- "strum",
+ "strum 0.26.2",
  "toml 0.8.23",
  "utoipa",
  "workspace-build-acceleration",
@@ -3952,7 +3953,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "strum",
+ "strum 0.26.2",
  "toml 0.8.23",
  "utoipa",
  "workspace-build-acceleration",
@@ -6501,7 +6502,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7066,7 +7067,7 @@ dependencies = [
  "serde_json",
  "sqlx",
  "storyteller_root",
- "strum",
+ "strum 0.26.2",
  "tempdir",
  "tokens",
  "tokio",
@@ -11581,8 +11582,8 @@ dependencies = [
  "server_environment",
  "speculoos",
  "sqlx",
- "strum",
- "strum_macros",
+ "strum 0.26.2",
+ "strum_macros 0.26.4",
  "tempdir",
  "tempfile",
  "testing",
@@ -11667,7 +11668,16 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.26.4",
+]
+
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros 0.28.0",
 ]
 
 [[package]]
@@ -11683,6 +11693,18 @@ dependencies = [
  "syn 2.0.106",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "subprocess"
 version = "0.2.9"
@@ -12679,7 +12701,7 @@ dependencies = [
  "sqlx",
  "sqlx-core",
  "sqlx-mysql",
- "strum",
+ "strum 0.26.2",
  "utoipa",
  "workspace-build-acceleration",
 ]
@@ -14029,7 +14051,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "strum",
+ "strum 0.26.2",
  "workspace-build-acceleration",
 ]
 

Cargo.toml

@@ -283,12 +283,13 @@ redis = { version = "1.0.2", features = ["r2d2", "tokio-rustls-comp", "tokio-com
 regex = "1.12.3"
 reqwest = { version = "0.12.23", default-features = false, features = [ "charset", "http2", "system-proxy", "json", "cookies", "rustls-tls", "gzip" ] }
 reqwest-websocket = {  version = "0.5.0" }
-serde = {  version = "1.0.219", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive"] }
 serde_derive = "1.0.219"
 serde_json = "1.0.140"
 serde_yaml = "0.9.34+deprecated"
 sha2 = "0.11.0-rc.2"
 sha3 = "0.10.8"
+strum = { version = "0.28.0", features = ["derive"] }
 tauri = { version = "2.8.3", features = ["unstable", "devtools"] } # NB: "devtools" prevents App Store distribution; "ubstable" is needed for window access
 tauri-plugin-dialog = "2.3.3"
 tauri-plugin-fs = "2.4.2"

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/bytedance_seedream_5_lite_multi_function_image_gen.rs

@@ -0,0 +1,68 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH: &str = "/v1/generate/image/multi_function/bytedance_seedream_5_lite";
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct BytedanceSeedream5LiteMultiFunctionImageGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt to generate the image from.
+  pub prompt: Option<String>,
+
+  /// Image media tokens to include in the editing context.
+  /// If present, we're doing image editing (image-to-image / image-editing)
+  /// If absent, we're doing image generation (text-to-image)
+  pub image_media_tokens: Option<Vec<MediaFileToken>>,
+
+  /// Number of images to generate. Default is one.
+  pub num_images: Option<BytedanceSeedream5LiteMultiFunctionImageGenNumImages>,
+
+  pub max_images: Option<BytedanceSeedream5LiteMultiFunctionImageGenMaxImages>,
+
+  pub image_size: Option<BytedanceSeedream5LiteMultiFunctionImageGenImageSize>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenMaxImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BytedanceSeedream5LiteMultiFunctionImageGenImageSize {
+  // Square
+  Square,
+  SquareHd,
+  // Tall
+  PortraitFourThree,
+  PortraitSixteenNine,
+  // Wide
+  LandscapeFourThree,
+  LandscapeSixteenNine,
+  // Auto (NB: 5 Lite max is auto_3K, not auto_4K like V4.5)
+  Auto2k,
+  Auto3k,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct BytedanceSeedream5LiteMultiFunctionImageGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/mod.rs

@@ -1,5 +1,7 @@
 pub mod bytedance_seedream_v4_multi_function_image_gen;
 pub mod bytedance_seedream_v4p5_multi_function_image_gen;
+pub mod bytedance_seedream_5_lite_multi_function_image_gen;
 pub mod gpt_image_1p5_multi_function_image_gen;
+pub mod nano_banana_2_multi_function_image_gen;
 pub mod nano_banana_multi_function_image_gen;
 pub mod nano_banana_pro_multi_function_image_gen;

crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/nano_banana_2_multi_function_image_gen.rs

@@ -0,0 +1,74 @@
+use serde_derive::{Deserialize, Serialize};
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::media_files::MediaFileToken;
+use utoipa::ToSchema;
+
+pub const NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH: &str = "/v1/generate/image/multi_function/nano_banana_2";
+
+#[derive(Serialize, Deserialize, ToSchema, Debug)]
+pub struct NanaBanana2MultiFunctionImageGenRequest {
+  /// Idempotency token to prevent duplicate requests.
+  pub uuid_idempotency_token: String,
+
+  /// Text prompt to generate the image from.
+  pub prompt: Option<String>,
+
+  /// Image media tokens to include in the editing context.
+  /// If present, we're doing image editing (image-to-image / image-editing)
+  /// If absent, we're doing image generation (text-to-image)
+  pub image_media_tokens: Option<Vec<MediaFileToken>>,
+
+  /// Number of images to generate. Default is one.
+  pub num_images: Option<NanaBanana2MultiFunctionImageGenNumImages>,
+
+  /// Resolution of the image to generate. Default is OneK (1K).
+  pub resolution: Option<NanaBanana2MultiFunctionImageGenImageResolution>,
+
+  /// Aspect ratio of the images to generate. Default is "1:1"
+  pub aspect_ratio: Option<NanaBanana2MultiFunctionImageGenAspectRatio>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenNumImages {
+  One, // Default
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenImageResolution {
+  HalfK,
+  OneK,
+  TwoK,
+  FourK,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum NanaBanana2MultiFunctionImageGenAspectRatio {
+  // Auto (only for image editing)
+  Auto, // Default for image editing.
+  // Square
+  OneByOne, // Default for text-to-image
+  // Wide
+  FiveByFour,
+  FourByThree,
+  ThreeByTwo,
+  SixteenByNine,
+  TwentyOneByNine,
+  // Tall
+  FourByFive,
+  ThreeByFour,
+  TwoByThree,
+  NineBySixteen,
+}
+
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct NanaBanana2MultiFunctionImageGenResponse {
+  pub success: bool,
+  pub inference_job_token: InferenceJobToken,
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/bytedance_seedream_5_lite_multi_function_image_gen_image.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::{BytedanceSeedream5LiteMultiFunctionImageGenRequest, BytedanceSeedream5LiteMultiFunctionImageGenResponse, BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH};
+
+pub async fn bytedance_seedream_5_lite_multi_function_image_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: BytedanceSeedream5LiteMultiFunctionImageGenRequest,
+) -> Result<BytedanceSeedream5LiteMultiFunctionImageGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    BYTEDANCE_SEEDREAM_5_LITE_MULTI_FUNCTION_IMAGE_GEN_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/mod.rs

@@ -1,5 +1,7 @@
 pub mod bytedance_seedream_v4_multi_function_image_gen_image;
 pub mod bytedance_seedream_v4p5_multi_function_image_gen_image;
+pub mod bytedance_seedream_5_lite_multi_function_image_gen_image;
 pub mod gpt_image_1p5_multi_function_image_gen_image;
+pub mod nano_banana_2_multi_function_image_gen_image;
 pub mod nano_banana_multi_function_image_gen_image;
 pub mod nano_banana_pro_multi_function_image_gen_image;

crates/api_clients/artcraft/artcraft_client/src/endpoints/generate/image/multi_function/nano_banana_2_multi_function_image_gen_image.rs

@@ -0,0 +1,18 @@
+use crate::credentials::storyteller_credential_set::StorytellerCredentialSet;
+use crate::error::storyteller_error::StorytellerError;
+use crate::utils::api_host::ApiHost;
+use crate::utils::basic_json_post_request::basic_json_post_request;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{NanaBanana2MultiFunctionImageGenRequest, NanaBanana2MultiFunctionImageGenResponse, NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH};
+
+pub async fn nano_banana_2_multi_function_image_gen(
+  api_host: &ApiHost,
+  maybe_creds: Option<&StorytellerCredentialSet>,
+  request: NanaBanana2MultiFunctionImageGenRequest,
+) -> Result<NanaBanana2MultiFunctionImageGenResponse, StorytellerError> {
+  Ok(basic_json_post_request(
+    api_host,
+    NANO_BANANA_2_MULTI_FUNCTION_IMAGE_GEN_PATH,
+    maybe_creds,
+    request,
+  ).await?)
+}

crates/api_clients/artcraft/artcraft_router/Cargo.toml

@@ -32,3 +32,5 @@ uuid.workspace = true
 
 [dev-dependencies]
 test_data.workspace = true
+strum.workspace = true
+

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

@@ -1,9 +1,12 @@
 use serde_derive::{Deserialize, Serialize};
+#[cfg(test)]
+use strum::EnumIter;
 
 /// This is a comprehensive list of common aspect ratios you can specify when enqueuing a generation.
 /// Not every model will support every aspect ratio.
 /// In the case a model doesn't support the aspect ratio, gracefully pick the nearest option.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(EnumIter))]
 #[serde(rename_all = "snake_case")]
 pub enum CommonAspectRatio {
   // Auto (eg. for image editing to use the source; used by Nano Banana Pro edit image, but not text-to-image)

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

@@ -5,6 +5,26 @@ use serde_derive::{Deserialize, Serialize};
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CommonImageModel {
+  #[serde(rename = "flux_1_dev")]
+  Flux1Dev,
+  #[serde(rename = "flux_1_schnell")]
+  Flux1Schnell,
+  #[serde(rename = "flux_pro_1p1")]
+  FluxPro11,
+  #[serde(rename = "flux_pro_1p1_ultra")]
+  FluxPro11Ultra,
+  #[serde(rename = "gpt_image_1p5")]
+  GptImage1p5,
+  #[serde(rename = "nano_banana")]
+  NanaBanana,
+  #[serde(rename = "nano_banana_2")]
+  NanaBanana2,
   #[serde(rename = "nano_banana_pro")]
   NanaBananaPro,
+  #[serde(rename = "seedream_4")]
+  Seedream4,
+  #[serde(rename = "seedream_4p5")]
+  Seedream4p5,
+  #[serde(rename = "seedream_5_lite")]
+  Seedream5Lite,
 }

crates/api_clients/artcraft/artcraft_router/src/client/generation_mode_mismatch_strategy.rs

@@ -0,0 +1,12 @@
+
+/// Strategy for handling requests where the model only supports text-to-image
+/// but the request includes image inputs (image editing mode).
+#[derive(Copy, Clone, Debug)]
+pub enum GenerationModeMismatchStrategy {
+  /// Abort the generation: return an error if image inputs are provided
+  /// for a text-to-image-only model.
+  AbortGeneration,
+
+  /// Proceed anyway, ignoring the image inputs for the generation.
+  GenerateAnyway,
+}

crates/api_clients/artcraft/artcraft_router/src/client/mod.rs

@@ -1,3 +1,4 @@
+pub mod generation_mode_mismatch_strategy;
 pub mod multi_router_client;
 pub mod multi_router_client_builder;
 pub mod request_mismatch_mitigation_strategy;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_1_dev.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::GenerateFlux1DevTextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_1_dev(
+  plan: &PlanArtcraftFlux1Dev<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.02/image (2 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 2;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFlux1DevTextToImageNumImages::One => 1,
+    GenerateFlux1DevTextToImageNumImages::Two => 2,
+    GenerateFlux1DevTextToImageNumImages::Three => 3,
+    GenerateFlux1DevTextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Flux1Dev,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.02/image = 2 cents each
+    assert_eq!(estimate_usd_cents(1), 2);
+    assert_eq!(estimate_usd_cents(2), 4);
+    assert_eq!(estimate_usd_cents(3), 6);
+    assert_eq!(estimate_usd_cents(4), 8);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_1_schnell.rs

@@ -0,0 +1,45 @@
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_1_schnell(
+  _plan: &PlanArtcraftFlux1Schnell<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: not available
+  ImageGenerationCostEstimate {
+    cost_in_credits: None,
+    cost_in_usd_cents: None,
+    is_free: true,
+    is_unlimited: true,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  #[test]
+  fn test_estimate_cost_is_none() {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Flux1Schnell,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(1),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    let estimate = request.build()
+      .expect("build should succeed")
+      .estimate_costs();
+    assert!(estimate.cost_in_usd_cents.is_none());
+    assert!(estimate.cost_in_credits.is_none());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::GenerateFluxPro11TextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_pro_1p1(
+  plan: &PlanArtcraftFluxPro11<'_>,
+) -> ImageGenerationCostEstimate {
+  // NB(bt): Slightly more than 3 cents, weird megapixel maths. We can eat that cost for now.
+  let cost_per_image: u64 = 3;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFluxPro11TextToImageNumImages::One => 1,
+    GenerateFluxPro11TextToImageNumImages::Two => 2,
+    GenerateFluxPro11TextToImageNumImages::Three => 3,
+    GenerateFluxPro11TextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::FluxPro11,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // ~$0.03/image = 3 cents each (slightly more than 3¢ actual, rounded up)
+    assert_eq!(estimate_usd_cents(1), 3);
+    assert_eq!(estimate_usd_cents(2), 6);
+    assert_eq!(estimate_usd_cents(3), 9);
+    assert_eq!(estimate_usd_cents(4), 12);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+
+pub(crate) fn estimate_image_cost_artcraft_flux_pro_1p1_ultra(
+  plan: &PlanArtcraftFluxPro11Ultra<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.06/image (6 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 6;
+
+  let num_images: u64 = match plan.num_images {
+    GenerateFluxPro11UltraTextToImageNumImages::One => 1,
+    GenerateFluxPro11UltraTextToImageNumImages::Two => 2,
+    GenerateFluxPro11UltraTextToImageNumImages::Three => 3,
+    GenerateFluxPro11UltraTextToImageNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::FluxPro11Ultra,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.06/image = 6 cents each
+    assert_eq!(estimate_usd_cents(1), 6);
+    assert_eq!(estimate_usd_cents(2), 12);
+    assert_eq!(estimate_usd_cents(3), 18);
+    assert_eq!(estimate_usd_cents(4), 24);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,120 @@
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+  GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality,
+  GptImage1p5MultiFunctionImageGenSize,
+};
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+
+pub(crate) fn estimate_image_cost_artcraft_gpt_image_1p5(
+  plan: &PlanArtcraftGptImage1p5<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing varies by quality and image size. 1 credit = 1 USD cent.
+  // Low:    $0.01/image (any size)
+  // Medium: $0.03/image (square/unset), $0.05/image (wide or tall)
+  // High:   $0.13/image (square/unset), $0.20/image (wide or tall)
+  //
+  // From Fal (text to image) -
+  //
+  // Your request will cost different amounts based on the number of images, quality, and size.
+  //
+  //     You will be charged $0.005 per 1,000 input text tokens. One word is roughly 4 tokens.
+  //     You will be charged $0.010 per 1,000 output text tokens. The model will consume tokens reasoning about your prompt based on it's complexity.
+  //     For low quality, you will be charged $0.009 for 1024x1024 or $0.013 for any other size per image.
+  //     For medium quality, you will be charged $0.034 for 1024x1024, $0.051 for 1024x1536 and $0.050 for 1536x1024 per image.
+  //     For high quality, you will be charged $0.133 for 1024x1024, $0.200 for 1024x1536 or $0.199 for 1536x1024 per image.
+  //
+  // From Fal (image to image) -
+  //
+  // Your request will cost different amounts based on the number of images, quality, and size.
+  //
+  //     You will be charged $0.005 per 1,000 input text tokens. One word is roughly 4 tokens.
+  //     You will be charged $0.008 per 1,000 input image tokens. One 1024x1024 image is roughly 135 tokens in low fidelity mode, or 3,050 tokens in high fidelity mode.
+  //     You will be charged $0.010 per 1,000 output text tokens. The model will consume tokens reasoning about your prompt based on it's complexity.
+  //     For low quality, you will be charged $0.009 for 1024x1024 or $0.013 for any other size per image.
+  //     For medium quality, you will be charged $0.034 for 1024x1024, $0.051 for 1024x1536 and $0.050 for 1536x1024 per image.
+  //     For high quality, you will be charged $0.133 for 1024x1024, $0.200 for 1024x1536 or $0.199 for 1536x1024 per image.
+  //
+  let cost_per_image: u64 = match plan.quality {
+    GptImage1p5MultiFunctionImageGenQuality::Low => 1,
+    GptImage1p5MultiFunctionImageGenQuality::Medium => match plan.image_size {
+      Some(GptImage1p5MultiFunctionImageGenSize::Square) | None => 3,
+      Some(GptImage1p5MultiFunctionImageGenSize::Wide) | Some(GptImage1p5MultiFunctionImageGenSize::Tall) => 5,
+    },
+    GptImage1p5MultiFunctionImageGenQuality::High => match plan.image_size {
+      Some(GptImage1p5MultiFunctionImageGenSize::Square) | None => 13,
+      Some(GptImage1p5MultiFunctionImageGenSize::Wide) | Some(GptImage1p5MultiFunctionImageGenSize::Tall) => 20,
+    },
+  };
+
+  let num_images: u64 = match plan.num_images {
+    GptImage1p5MultiFunctionImageGenNumImages::One => 1,
+    GptImage1p5MultiFunctionImageGenNumImages::Two => 2,
+    GptImage1p5MultiFunctionImageGenNumImages::Three => 3,
+    GptImage1p5MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16, aspect_ratio: Option<CommonAspectRatio>) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::GptImage1p5,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_square() {
+    // Default quality (Medium) + square/unset size = 3 cents each
+    assert_eq!(estimate_usd_cents(1, None), 3);
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::Square)), 3);
+    assert_eq!(estimate_usd_cents(2, Some(CommonAspectRatio::Square)), 6);
+    assert_eq!(estimate_usd_cents(3, Some(CommonAspectRatio::Square)), 9);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::Square)), 12);
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_wide() {
+    // Medium + wide = 5 cents each
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::WideSixteenByNine)), 5);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::WideSixteenByNine)), 20);
+  }
+
+  #[test]
+  fn test_estimate_cost_medium_tall() {
+    // Medium + tall = 5 cents each
+    assert_eq!(estimate_usd_cents(1, Some(CommonAspectRatio::TallNineBySixteen)), 5);
+    assert_eq!(estimate_usd_cents(4, Some(CommonAspectRatio::TallNineBySixteen)), 20);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::NanoBananaMultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+
+pub(crate) fn estimate_image_cost_artcraft_nano_banana(
+  plan: &PlanArtcraftNanaBanana<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    NanoBananaMultiFunctionImageGenNumImages::One => 1,
+    NanoBananaMultiFunctionImageGenNumImages::Two => 2,
+    NanoBananaMultiFunctionImageGenNumImages::Three => 3,
+    NanoBananaMultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::NanaBanana,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana_2.rs

@@ -0,0 +1,79 @@
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+  NanaBanana2MultiFunctionImageGenImageResolution, NanaBanana2MultiFunctionImageGenNumImages,
+};
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
+
+pub(crate) fn estimate_image_cost_artcraft_nano_banana_2(
+  plan: &PlanArtcraftNanaBanana2<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.08/image at 0.5K, $0.15/image at 1K or 2K, $0.30/image at 4K.
+  // (Stored as USD cents.)
+  let cost_per_image: u64 = match plan.resolution {
+    Some(NanaBanana2MultiFunctionImageGenImageResolution::HalfK) => 8,
+    Some(NanaBanana2MultiFunctionImageGenImageResolution::FourK) => 30,
+    _ => 15, // OneK, TwoK, or None (default 1K)
+  };
+
+  let num_images: u64 = match plan.num_images {
+    NanaBanana2MultiFunctionImageGenNumImages::One => 1,
+    NanaBanana2MultiFunctionImageGenNumImages::Two => 2,
+    NanaBanana2MultiFunctionImageGenNumImages::Three => 3,
+    NanaBanana2MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(resolution: Option<CommonResolution>, image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::NanaBanana2,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // 1K/2K: $0.15/image = 15 cents
+    assert_eq!(estimate_usd_cents(None, 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::TwoK), 1), 15);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 2), 30);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::OneK), 4), 60);
+
+    // 4K: $0.30/image = 30 cents
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::FourK), 1), 30);
+    assert_eq!(estimate_usd_cents(Some(CommonResolution::FourK), 2), 60);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_nano_banana_pro.rs

@@ -52,6 +52,7 @@ mod tests {
       aspect_ratio: None,
       image_batch_count: Some(image_batch_count),
       request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
       idempotency_token: None,
     };
     request.build()

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_4.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::BytedanceSeedreamV4MultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_4(
+  plan: &PlanArtcraftSeedream4<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.03/image (3 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 3;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream4,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.03/image = 3 cents each
+    assert_eq!(estimate_usd_cents(1), 3);
+    assert_eq!(estimate_usd_cents(2), 6);
+    assert_eq!(estimate_usd_cents(3), 9);
+    assert_eq!(estimate_usd_cents(4), 12);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_4p5.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::BytedanceSeedreamV4p5MultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_4p5(
+  plan: &PlanArtcraftSeedream4p5<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream4p5,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/estimate_image_cost_artcraft_seedream_5_lite.rs

@@ -0,0 +1,66 @@
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::BytedanceSeedream5LiteMultiFunctionImageGenNumImages;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
+
+pub(crate) fn estimate_image_cost_artcraft_seedream_5_lite(
+  plan: &PlanArtcraftSeedream5Lite<'_>,
+) -> ImageGenerationCostEstimate {
+  // Pricing: $0.04/image (4 cents). 1 credit = 1 USD cent.
+  let cost_per_image: u64 = 4;
+
+  let num_images: u64 = match plan.num_images {
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::One => 1,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Two => 2,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Three => 3,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages::Four => 4,
+  };
+
+  let cost_in_usd_cents = cost_per_image * num_images;
+
+  ImageGenerationCostEstimate {
+    cost_in_credits: Some(cost_in_usd_cents),
+    cost_in_usd_cents: Some(cost_in_usd_cents),
+    is_free: false,
+    is_unlimited: false,
+    is_rate_limited: false,
+    has_watermark: false,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_image_model::CommonImageModel;
+  use crate::api::provider::Provider;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+
+  fn estimate_usd_cents(image_batch_count: u16) -> u64 {
+    let request = GenerateImageRequest {
+      model: CommonImageModel::Seedream5Lite,
+      provider: Provider::Artcraft,
+      prompt: None,
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      image_batch_count: Some(image_batch_count),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    };
+    request.build()
+      .expect("build should succeed")
+      .estimate_costs()
+      .cost_in_usd_cents
+      .expect("cost_in_usd_cents should be present")
+  }
+
+  #[test]
+  fn test_estimate_cost_usd_cents() {
+    // $0.04/image = 4 cents each
+    assert_eq!(estimate_usd_cents(1), 4);
+    assert_eq!(estimate_usd_cents(2), 8);
+    assert_eq!(estimate_usd_cents(3), 12);
+    assert_eq!(estimate_usd_cents(4), 16);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod estimate_image_cost_artcraft_flux_1_dev;
+pub mod estimate_image_cost_artcraft_flux_1_schnell;
+pub mod estimate_image_cost_artcraft_flux_pro_1p1;
+pub mod estimate_image_cost_artcraft_flux_pro_1p1_ultra;
+pub mod estimate_image_cost_artcraft_gpt_image_1p5;
+pub mod estimate_image_cost_artcraft_nano_banana;
+pub mod estimate_image_cost_artcraft_nano_banana_2;
 pub mod estimate_image_cost_artcraft_nano_banana_pro;
+pub mod estimate_image_cost_artcraft_seedream_4;
+pub mod estimate_image_cost_artcraft_seedream_4p5;
+pub mod estimate_image_cost_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/cost/fal/estimate_image_cost_fal_nano_banana_pro.rs

@@ -50,6 +50,7 @@ mod tests {
       aspect_ratio: None,
       image_batch_count: Some(image_batch_count),
       request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
       idempotency_token: None,
     };
     request.build()

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_1_dev.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::GenerateFlux1DevTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_1_dev_text_to_image::generate_flux_1_dev_text_to_image;
+
+pub async fn execute_artcraft_flux_1_dev(
+  plan: &PlanArtcraftFlux1Dev<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFlux1DevTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_1_dev_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_1_dev_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_dev() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_1_dev_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_dev_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_1_dev_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_1_dev_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_1_dev_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_1_schnell.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::GenerateFlux1SchnellTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_1_schnell_text_to_image::generate_flux_1_schnell_text_to_image;
+
+pub async fn execute_artcraft_flux_1_schnell(
+  plan: &PlanArtcraftFlux1Schnell<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFlux1SchnellTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_1_schnell_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_1_schnell_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_schnell() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a man and woman walking through a cyberpunk city at night"),
+      ..base_flux_1_schnell_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_1_schnell_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_1_schnell_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_1_schnell_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a man and woman walking through a futuristic city at evening"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_1_schnell_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::GenerateFluxPro11TextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_text_to_image::generate_flux_pro_11_text_to_image;
+
+pub async fn execute_artcraft_flux_pro_1p1(
+  plan: &PlanArtcraftFluxPro11<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFluxPro11TextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_pro_11_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_pro_1p1_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_pro_1p1_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_pro_1p1_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_pro_1p1_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_pro_1p1_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,116 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::GenerateFluxPro11UltraTextToImageRequest;
+use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_ultra_text_to_image::generate_flux_pro_11_ultra_text_to_image;
+
+pub async fn execute_artcraft_flux_pro_1p1_ultra(
+  plan: &PlanArtcraftFluxPro11Ultra<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GenerateFluxPro11UltraTextToImageRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    aspect_ratio: plan.aspect_ratio,
+    num_images: Some(plan.num_images),
+  };
+
+  let response = generate_flux_pro_11_ultra_text_to_image(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_flux_pro_1p1_ultra_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_ultra() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_flux_pro_1p1_ultra_batch_four() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Square),
+      image_batch_count: Some(4),
+      prompt: Some("a dog surfing a wave, cinematic"),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_flux_pro_1p1_ultra_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a t-rex walking through an abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,164 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::GptImage1p5MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen_image::gpt_image_1p5_multi_function_image_gen;
+
+pub async fn execute_artcraft_gpt_image_1p5(
+  plan: &PlanArtcraftGptImage1p5<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = GptImage1p5MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    mask_image_token: None,
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    background: None,
+    quality: Some(plan.quality),
+    input_fidelity: None,
+    output_format: None,
+  };
+
+  let response = gpt_image_1p5_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_gpt_image_1p5_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_gpt_image_1p5() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a horse walking through a cyberpunk city at night"),
+      ..base_gpt_image_1p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_gpt_image_1p5() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a desert with cacti"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_gpt_image_1p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_gpt_image_1p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a bear walking through a abandoned desert city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_gpt_image_1p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_gpt_image_1p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to an alien world"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_gpt_image_1p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_nano_banana.rs

@@ -0,0 +1,159 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::NanoBananaMultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::nano_banana_multi_function_image_gen_image::nano_banana_multi_function_image_gen;
+
+pub async fn execute_artcraft_nano_banana(
+  plan: &PlanArtcraftNanaBanana<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = NanoBananaMultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    aspect_ratio: plan.aspect_ratio,
+  };
+
+  let response = nano_banana_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_nano_banana_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_nano_banana() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_nano_banana_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_nano_banana() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a sunny beach"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_nano_banana_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_nano_banana_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a shiba walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_nano_banana_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_nano_banana_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a sunny beach"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_nano_banana_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_nano_banana_2.rs

@@ -0,0 +1,67 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::NanaBanana2MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::nano_banana_2_multi_function_image_gen_image::nano_banana_2_multi_function_image_gen;
+
+pub async fn execute_artcraft_nano_banana_2(
+  plan: &PlanArtcraftNanaBanana2<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = NanaBanana2MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    resolution: plan.resolution,
+    aspect_ratio: plan.aspect_ratio,
+  };
+
+  let response = nano_banana_2_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_nano_banana_2_image_request, get_artcraft_client};
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_nano_banana_2() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      resolution: Some(CommonResolution::OneK),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_nano_banana_2_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_4.rs

@@ -0,0 +1,160 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::BytedanceSeedreamV4MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen_image::bytedance_seedream_v4_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_4(
+  plan: &PlanArtcraftSeedream4<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedreamV4MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_v4_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_4_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_4() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a cat walking through a cyberpunk city at night"),
+      ..base_seedream_4_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_seedream_4() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a sunny beach"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_batch_count: Some(1),
+      ..base_seedream_4_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_seedream_4_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a shiba walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_seedream_4_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a sunny beach"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_4p5.rs

@@ -0,0 +1,160 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::BytedanceSeedreamV4p5MultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen_image::bytedance_seedream_v4p5_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_4p5(
+  plan: &PlanArtcraftSeedream4p5<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedreamV4p5MultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_v4p5_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_4p5_image_request, get_artcraft_client};
+  use strum::IntoEnumIterator;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_4p5() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a corgi walking through a cyberpunk city at night"),
+      ..base_seedream_4p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_edit_image_seedream_4p5() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    let request = GenerateImageRequest {
+      prompt: Some("Change the background to a spooky haunted house"),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+      aspect_ratio: Some(CommonAspectRatio::Auto2k),
+      image_batch_count: Some(1),
+      ..base_seedream_4p5_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_text_to_image_seedream_4p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- text-to-image aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        prompt: Some("a corgi walking through a cyberpunk city at night"),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+
+  #[tokio::test]
+  #[ignore] // manually run — fires one real API request per aspect ratio variant (expensive)
+  async fn test_edit_image_seedream_4p5_all_aspect_ratios() {
+    let client = get_artcraft_client();
+
+    let image_tokens = vec![
+      MediaFileToken::new_from_str("m_r45apt2swza6wp8j2z10237t92kkr8"),
+    ];
+
+    for ar in CommonAspectRatio::iter() {
+      println!("--- image-edit aspect ratio: {:?} ---", ar);
+      let request = GenerateImageRequest {
+        prompt: Some("Change the background to a spooky haunted house"),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&image_tokens)),
+        aspect_ratio: Some(ar),
+        image_batch_count: Some(1),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+        ..base_seedream_4p5_image_request()
+      };
+      match request.build() {
+        Err(e) => println!("  plan error: {:?}", e),
+        Ok(plan) => match plan.generate_image(&client).await {
+          Ok(response) => {
+            let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+            println!("  job token: {:?}", payload.inference_job_token);
+          }
+          Err(e) => println!("  generate error: {:?}", e),
+        },
+      }
+    }
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the responses above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/generate_image_artcraft_seedream_5_lite.rs

@@ -0,0 +1,65 @@
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::provider_error::ProviderError;
+use crate::generate::generate_image::generate_image_response::{
+  ArtcraftImageResponsePayload, GenerateImageResponse,
+};
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::BytedanceSeedream5LiteMultiFunctionImageGenRequest;
+use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen_image::bytedance_seedream_5_lite_multi_function_image_gen;
+
+pub async fn execute_artcraft_seedream_5_lite(
+  plan: &PlanArtcraftSeedream5Lite<'_>,
+  artcraft_client: &RouterArtcraftClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+  let request = BytedanceSeedream5LiteMultiFunctionImageGenRequest {
+    uuid_idempotency_token: plan.idempotency_token.clone(),
+    prompt: plan.prompt.map(|p| p.to_string()),
+    image_media_tokens: plan.image_inputs.map(|tokens| tokens.to_owned()),
+    num_images: Some(plan.num_images),
+    image_size: plan.image_size,
+    max_images: None,
+  };
+
+  let response = bytedance_seedream_5_lite_multi_function_image_gen(
+    &artcraft_client.api_host,
+    Some(&artcraft_client.credentials),
+    request,
+  )
+    .await
+    .map_err(|err| ArtcraftRouterError::Provider(ProviderError::Storyteller(err)))?;
+
+  Ok(GenerateImageResponse::Artcraft(ArtcraftImageResponsePayload {
+    inference_job_token: response.inference_job_token,
+  }))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::{base_seedream_5_lite_image_request, get_artcraft_client};
+
+  #[tokio::test]
+  #[ignore] // manually run — fires a real API request and incurs cost
+  async fn test_text_to_image_seedream_5_lite() {
+    let client = get_artcraft_client();
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::WideSixteenByNine),
+      image_batch_count: Some(1),
+      prompt: Some("a corgi walking through a cyberpunk city at night"),
+      ..base_seedream_5_lite_image_request()
+    };
+
+    let plan = request.build().unwrap();
+    let result = plan.generate_image(&client).await;
+
+    println!("Result: {:?}", result);
+    let response = result.expect("generate_image request failed");
+    let payload = response.get_artcraft_payload().expect("expected Artcraft payload");
+    println!("Job token: {:?}", payload.inference_job_token);
+
+    assert_eq!(1, 2); // NB: Intentional failure to inspect the response above.
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/execute/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod generate_image_artcraft_flux_1_dev;
+pub mod generate_image_artcraft_flux_1_schnell;
+pub mod generate_image_artcraft_flux_pro_1p1;
+pub mod generate_image_artcraft_flux_pro_1p1_ultra;
+pub mod generate_image_artcraft_gpt_image_1p5;
+pub mod generate_image_artcraft_nano_banana;
+pub mod generate_image_artcraft_nano_banana_2;
 pub mod generate_image_artcraft_nano_banana_pro;
+pub mod generate_image_artcraft_seedream_4;
+pub mod generate_image_artcraft_seedream_4p5;
+pub mod generate_image_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request.rs

@@ -3,10 +3,22 @@ use crate::api::common_image_model::CommonImageModel;
 use crate::api::common_resolution::CommonResolution;
 use crate::api::image_list_ref::ImageListRef;
 use crate::api::provider::Provider;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
 use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
 use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::plan_generate_image_artcraft_flux_1_dev;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::plan_generate_image_artcraft_flux_1_schnell;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::plan_generate_image_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::plan_generate_image_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::plan_generate_image_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::plan_generate_image_artcraft_nano_banana;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::plan_generate_image_artcraft_nano_banana_2;
 use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_pro::plan_generate_image_artcraft_nano_banana_pro;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::plan_generate_image_artcraft_seedream_4;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::plan_generate_image_artcraft_seedream_4p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::plan_generate_image_artcraft_seedream_5_lite;
 use crate::generate::generate_image::plan::fal::plan_generate_image_fal_nano_banana_pro::plan_generate_image_fal_nano_banana_pro;
 
 pub struct GenerateImageRequest<'a> {
@@ -36,6 +48,11 @@ pub struct GenerateImageRequest<'a> {
   /// If the request is a mismatch with the (model/provider), how to mitigate it.
   pub request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy,
 
+  /// Controls behavior when `image_inputs` are supplied to a text-to-image-only model.
+  /// `None` is equivalent to `GenerateAnyway` — image inputs are silently ignored.
+  /// Set `AbortGeneration` to return an error instead.
+  pub generation_mode_mismatch_strategy: Option<GenerationModeMismatchStrategy>,
+
   /// Some providers support idempotency.
   /// If not supplied, we'll generate one for the required providers.
   pub idempotency_token: Option<&'a str>,
@@ -46,14 +63,59 @@ impl<'a> GenerateImageRequest<'a> {
   pub fn build(&self) -> Result<ImageGenerationPlan<'_>, ArtcraftRouterError> {
     match self.provider {
       Provider::Artcraft => match self.model {
+        CommonImageModel::Flux1Dev => {
+          plan_generate_image_artcraft_flux_1_dev(self).map(ImageGenerationPlan::ArtcraftFlux1Dev)
+        }
+        CommonImageModel::Flux1Schnell => {
+          plan_generate_image_artcraft_flux_1_schnell(self).map(ImageGenerationPlan::ArtcraftFlux1Schnell)
+        }
+        CommonImageModel::FluxPro11 => {
+          plan_generate_image_artcraft_flux_pro_1p1(self).map(ImageGenerationPlan::ArtcraftFluxPro11)
+        }
+        CommonImageModel::FluxPro11Ultra => {
+          plan_generate_image_artcraft_flux_pro_1p1_ultra(self).map(ImageGenerationPlan::ArtcraftFluxPro11Ultra)
+        }
+        CommonImageModel::GptImage1p5 => {
+          plan_generate_image_artcraft_gpt_image_1p5(self).map(ImageGenerationPlan::ArtcraftGptImage1p5)
+        }
+        CommonImageModel::NanaBanana => {
+          plan_generate_image_artcraft_nano_banana(self).map(ImageGenerationPlan::ArtcraftNanaBanana)
+        }
+        CommonImageModel::NanaBanana2 => {
+          plan_generate_image_artcraft_nano_banana_2(self).map(ImageGenerationPlan::ArtcraftNanaBanana2)
+        }
         CommonImageModel::NanaBananaPro => {
           plan_generate_image_artcraft_nano_banana_pro(self).map(ImageGenerationPlan::ArtcraftNanaBananaPro)
         }
+        CommonImageModel::Seedream4 => {
+          plan_generate_image_artcraft_seedream_4(self).map(ImageGenerationPlan::ArtcraftSeedream4)
+        }
+        CommonImageModel::Seedream4p5 => {
+          plan_generate_image_artcraft_seedream_4p5(self).map(ImageGenerationPlan::ArtcraftSeedream4p5)
+        }
+        CommonImageModel::Seedream5Lite => {
+          plan_generate_image_artcraft_seedream_5_lite(self).map(ImageGenerationPlan::ArtcraftSeedream5Lite)
+        }
       },
       Provider::Fal => match self.model {
         CommonImageModel::NanaBananaPro => {
           plan_generate_image_fal_nano_banana_pro(self).map(ImageGenerationPlan::FalNanaBananaPro)
         }
+        CommonImageModel::Flux1Dev
+        | CommonImageModel::Flux1Schnell
+        | CommonImageModel::FluxPro11
+        | CommonImageModel::FluxPro11Ultra
+        | CommonImageModel::GptImage1p5
+        | CommonImageModel::NanaBanana
+        | CommonImageModel::NanaBanana2
+        | CommonImageModel::Seedream4
+        | CommonImageModel::Seedream4p5
+        | CommonImageModel::Seedream5Lite => {
+          Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+            field: "provider",
+            value: format!("{:?} is only available on the Artcraft provider", self.model),
+          }))
+        }
       },
     }
   }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_plan.rs

@@ -1,17 +1,57 @@
 use crate::client::router_client::RouterClient;
 use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_1_dev::estimate_image_cost_artcraft_flux_1_dev;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_1_schnell::estimate_image_cost_artcraft_flux_1_schnell;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_pro_1p1::estimate_image_cost_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_flux_pro_1p1_ultra::estimate_image_cost_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_gpt_image_1p5::estimate_image_cost_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana::estimate_image_cost_artcraft_nano_banana;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana_2::estimate_image_cost_artcraft_nano_banana_2;
 use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_nano_banana_pro::estimate_image_cost_artcraft_nano_banana_pro;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_4::estimate_image_cost_artcraft_seedream_4;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_4p5::estimate_image_cost_artcraft_seedream_4p5;
+use crate::generate::generate_image::cost::artcraft::estimate_image_cost_artcraft_seedream_5_lite::estimate_image_cost_artcraft_seedream_5_lite;
 use crate::generate::generate_image::cost::fal::estimate_image_cost_fal_nano_banana_pro::estimate_image_cost_fal_nano_banana_pro;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_1_dev::execute_artcraft_flux_1_dev;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_1_schnell::execute_artcraft_flux_1_schnell;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_pro_1p1::execute_artcraft_flux_pro_1p1;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_flux_pro_1p1_ultra::execute_artcraft_flux_pro_1p1_ultra;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_gpt_image_1p5::execute_artcraft_gpt_image_1p5;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana::execute_artcraft_nano_banana;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana_2::execute_artcraft_nano_banana_2;
 use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_nano_banana_pro::execute_artcraft_nano_banana_pro;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_4::execute_artcraft_seedream_4;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_4p5::execute_artcraft_seedream_4p5;
+use crate::generate::generate_image::execute::artcraft::generate_image_artcraft_seedream_5_lite::execute_artcraft_seedream_5_lite;
 use crate::generate::generate_image::execute::fal::generate_image_fal_nano_banana_pro::execute_fal_nano_banana_pro;
 use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
 use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_dev::PlanArtcraftFlux1Dev;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_1_schnell::PlanArtcraftFlux1Schnell;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1::PlanArtcraftFluxPro11;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_flux_pro_1p1_ultra::PlanArtcraftFluxPro11Ultra;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_gpt_image_1p5::PlanArtcraftGptImage1p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana::PlanArtcraftNanaBanana;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_2::PlanArtcraftNanaBanana2;
 use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_nano_banana_pro::PlanArtcraftNanaBananaPro;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4::PlanArtcraftSeedream4;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_4p5::PlanArtcraftSeedream4p5;
+use crate::generate::generate_image::plan::artcraft::plan_generate_image_artcraft_seedream_5_lite::PlanArtcraftSeedream5Lite;
 use crate::generate::generate_image::plan::fal::plan_generate_image_fal_nano_banana_pro::PlanFalNanaBananaPro;
 
 #[derive(Debug)]
 pub enum ImageGenerationPlan<'a> {
+  ArtcraftFlux1Dev(PlanArtcraftFlux1Dev<'a>),
+  ArtcraftFlux1Schnell(PlanArtcraftFlux1Schnell<'a>),
+  ArtcraftFluxPro11(PlanArtcraftFluxPro11<'a>),
+  ArtcraftFluxPro11Ultra(PlanArtcraftFluxPro11Ultra<'a>),
+  ArtcraftGptImage1p5(PlanArtcraftGptImage1p5<'a>),
+  ArtcraftNanaBanana(PlanArtcraftNanaBanana<'a>),
+  ArtcraftNanaBanana2(PlanArtcraftNanaBanana2<'a>),
   ArtcraftNanaBananaPro(PlanArtcraftNanaBananaPro<'a>),
+  ArtcraftSeedream4(PlanArtcraftSeedream4<'a>),
+  ArtcraftSeedream4p5(PlanArtcraftSeedream4p5<'a>),
+  ArtcraftSeedream5Lite(PlanArtcraftSeedream5Lite<'a>),
   FalNanaBananaPro(PlanFalNanaBananaPro<'a>),
 }
 
@@ -21,10 +61,50 @@ impl<'a> ImageGenerationPlan<'a> {
     client: &RouterClient,
   ) -> Result<GenerateImageResponse, ArtcraftRouterError> {
     match self {
+      ImageGenerationPlan::ArtcraftFlux1Dev(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_1_dev(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFlux1Schnell(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_1_schnell(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_pro_1p1(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_flux_pro_1p1_ultra(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftGptImage1p5(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_gpt_image_1p5(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_nano_banana(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana2(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_nano_banana_2(plan, artcraft_client).await
+      }
       ImageGenerationPlan::ArtcraftNanaBananaPro(plan) => {
         let artcraft_client = client.get_artcraft_client_ref()?;
         execute_artcraft_nano_banana_pro(plan, artcraft_client).await
       }
+      ImageGenerationPlan::ArtcraftSeedream4(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_4(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftSeedream4p5(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_4p5(plan, artcraft_client).await
+      }
+      ImageGenerationPlan::ArtcraftSeedream5Lite(plan) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        execute_artcraft_seedream_5_lite(plan, artcraft_client).await
+      }
       ImageGenerationPlan::FalNanaBananaPro(plan) => {
         let fal_client = client.get_fal_client_ref()?;
         execute_fal_nano_banana_pro(plan, fal_client).await
@@ -34,9 +114,39 @@ impl<'a> ImageGenerationPlan<'a> {
 
   pub fn estimate_costs(&self) -> ImageGenerationCostEstimate {
     match self {
+      ImageGenerationPlan::ArtcraftFlux1Dev(plan) => {
+        estimate_image_cost_artcraft_flux_1_dev(plan)
+      }
+      ImageGenerationPlan::ArtcraftFlux1Schnell(plan) => {
+        estimate_image_cost_artcraft_flux_1_schnell(plan)
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11(plan) => {
+        estimate_image_cost_artcraft_flux_pro_1p1(plan)
+      }
+      ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) => {
+        estimate_image_cost_artcraft_flux_pro_1p1_ultra(plan)
+      }
+      ImageGenerationPlan::ArtcraftGptImage1p5(plan) => {
+        estimate_image_cost_artcraft_gpt_image_1p5(plan)
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana(plan) => {
+        estimate_image_cost_artcraft_nano_banana(plan)
+      }
+      ImageGenerationPlan::ArtcraftNanaBanana2(plan) => {
+        estimate_image_cost_artcraft_nano_banana_2(plan)
+      }
       ImageGenerationPlan::ArtcraftNanaBananaPro(plan) => {
         estimate_image_cost_artcraft_nano_banana_pro(plan)
       }
+      ImageGenerationPlan::ArtcraftSeedream4(plan) => {
+        estimate_image_cost_artcraft_seedream_4(plan)
+      }
+      ImageGenerationPlan::ArtcraftSeedream4p5(plan) => {
+        estimate_image_cost_artcraft_seedream_4p5(plan)
+      }
+      ImageGenerationPlan::ArtcraftSeedream5Lite(plan) => {
+        estimate_image_cost_artcraft_seedream_5_lite(plan)
+      }
       ImageGenerationPlan::FalNanaBananaPro(plan) => {
         estimate_image_cost_fal_nano_banana_pro(plan)
       }

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/mod.rs

@@ -1 +1,11 @@
+pub mod plan_generate_image_artcraft_flux_1_dev;
+pub mod plan_generate_image_artcraft_flux_1_schnell;
+pub mod plan_generate_image_artcraft_flux_pro_1p1;
+pub mod plan_generate_image_artcraft_flux_pro_1p1_ultra;
+pub mod plan_generate_image_artcraft_gpt_image_1p5;
+pub mod plan_generate_image_artcraft_nano_banana;
+pub mod plan_generate_image_artcraft_nano_banana_2;
 pub mod plan_generate_image_artcraft_nano_banana_pro;
+pub mod plan_generate_image_artcraft_seedream_4;
+pub mod plan_generate_image_artcraft_seedream_4p5;
+pub mod plan_generate_image_artcraft_seedream_5_lite;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_1_dev.rs

@@ -0,0 +1,323 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::{
+  GenerateFlux1DevTextToImageAspectRatio, GenerateFlux1DevTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFlux1Dev<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFlux1DevTextToImageAspectRatio>,
+  pub num_images: GenerateFlux1DevTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_1_dev<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFlux1Dev<'a>, ArtcraftRouterError> {
+  // Flux 1 Dev is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux 1 Dev is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFlux1Dev {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux 1 Dev supported aspect ratios:
+//   Square, SquareHd, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFlux1DevTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFlux1DevTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: not valid for text-to-image; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::SquareHd)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFlux1DevTextToImageAspectRatio {
+  use GenerateFlux1DevTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFlux1DevTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFlux1DevTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_1_dev_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::{
+    GenerateFlux1DevTextToImageAspectRatio as FlAr,
+    GenerateFlux1DevTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_1_dev_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_1_dev_image_request() };
+    let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_falls_back_to_square() {
+    for ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::SquareHd, FlAr::SquareHd),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_dev_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)),
+        "expected LandscapeFourByThree nearest match with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_1_dev_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_dev_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_dev_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Dev(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Dev") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_1_schnell.rs

@@ -0,0 +1,319 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::{
+  GenerateFlux1SchnellTextToImageAspectRatio, GenerateFlux1SchnellTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFlux1Schnell<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFlux1SchnellTextToImageAspectRatio>,
+  pub num_images: GenerateFlux1SchnellTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_1_schnell<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFlux1Schnell<'a>, ArtcraftRouterError> {
+  // Flux 1 Schnell is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux 1 Schnell is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFlux1Schnell {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux 1 Schnell supported aspect ratios (identical to Flux 1 Dev):
+//   Square, SquareHd, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFlux1SchnellTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFlux1SchnellTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: not valid for text-to-image; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::SquareHd)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFlux1SchnellTextToImageAspectRatio {
+  use GenerateFlux1SchnellTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFlux1SchnellTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFlux1SchnellTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_1_schnell_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::{
+    GenerateFlux1SchnellTextToImageAspectRatio as FlAr,
+    GenerateFlux1SchnellTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_1_schnell_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_1_schnell_image_request() };
+    let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_falls_back_to_square() {
+    for ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::SquareHd, FlAr::SquareHd),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_1_schnell_image_request() };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_1_schnell_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_1_schnell_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFlux1Schnell(plan) = request.build().unwrap() else { panic!("expected ArtcraftFlux1Schnell") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_pro_1p1.rs

@@ -0,0 +1,323 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::{
+  GenerateFluxPro11TextToImageAspectRatio, GenerateFluxPro11TextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFluxPro11<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFluxPro11TextToImageAspectRatio>,
+  pub num_images: GenerateFluxPro11TextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_pro_1p1<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFluxPro11<'a>, ArtcraftRouterError> {
+  // Flux Pro 1.1 is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux Pro 1.1 is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFluxPro11 {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux Pro 1.1 supported aspect ratios (no SquareHd):
+//   Square, LandscapeFourByThree, LandscapeSixteenByNine,
+//   PortraitThreeByFour, PortraitNineBySixteen
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFluxPro11TextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFluxPro11TextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto and SquareHd: no direct equivalent; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k)
+    | Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::WideFourByThree) | Some(CommonAspectRatio::WideThreeByTwo) => {
+      Ok(Some(FlAr::LandscapeFourByThree))
+    }
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideTwentyOneByNine) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(FlAr::PortraitThreeByFour)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineByTwentyOne) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFluxPro11TextToImageAspectRatio {
+  use GenerateFluxPro11TextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFluxPro11TextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFluxPro11TextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_pro_1p1_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::{
+    GenerateFluxPro11TextToImageAspectRatio as FlAr,
+    GenerateFluxPro11TextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_pro_1p1_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_pro_1p1_image_request() };
+    let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_and_square_hd_fall_back_to_square() {
+    for ar in [
+      CommonAspectRatio::Auto,
+      CommonAspectRatio::Auto2k,
+      CommonAspectRatio::Auto4k,
+      CommonAspectRatio::SquareHd,
+    ] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_pro_1p1_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_flux_pro_1p1_ultra.rs

@@ -0,0 +1,326 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::{
+  GenerateFluxPro11UltraTextToImageAspectRatio, GenerateFluxPro11UltraTextToImageNumImages,
+};
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftFluxPro11Ultra<'a> {
+  pub prompt: Option<&'a str>,
+  pub aspect_ratio: Option<GenerateFluxPro11UltraTextToImageAspectRatio>,
+  pub num_images: GenerateFluxPro11UltraTextToImageNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_flux_pro_1p1_ultra<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftFluxPro11Ultra<'a>, ArtcraftRouterError> {
+  // Flux Pro 1.1 Ultra is text-to-image only. Abort if image inputs are provided and
+  // the caller has opted into strict mode.
+  if request.image_inputs.is_some() {
+    if let Some(GenerationModeMismatchStrategy::AbortGeneration) = request.generation_mode_mismatch_strategy {
+      return Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+        field: "image_inputs",
+        value: "Flux Pro 1.1 Ultra is a text-to-image model and does not support image editing".to_string(),
+      }));
+    }
+    // None or GenerateAnyway: silently ignore image inputs
+  }
+
+  let strategy = request.request_mismatch_mitigation_strategy;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftFluxPro11Ultra {
+    prompt: request.prompt,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+// Flux Pro 1.1 Ultra supported aspect ratios:
+//   Square, LandscapeThreeByTwo, LandscapeFourByThree, LandscapeSixteenByNine,
+//   LandscapeTwentyOneByNine, PortraitTwoByThree, PortraitThreeByFour,
+//   PortraitNineBySixteen, PortraitNineByTwentyOne
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GenerateFluxPro11UltraTextToImageAspectRatio>, ArtcraftRouterError> {
+  use GenerateFluxPro11UltraTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto and SquareHd: no direct equivalent; fall back to square
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k)
+    | Some(CommonAspectRatio::SquareHd) => Ok(Some(FlAr::Square)),
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) => Ok(Some(FlAr::Square)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(FlAr::LandscapeThreeByTwo)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(FlAr::LandscapeFourByThree)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => {
+      Ok(Some(FlAr::LandscapeSixteenByNine))
+    }
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(FlAr::LandscapeTwentyOneByNine)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(FlAr::PortraitTwoByThree)),
+    Some(CommonAspectRatio::TallThreeByFour) | Some(CommonAspectRatio::WideFiveByFour) => {
+      Ok(Some(FlAr::PortraitThreeByFour))
+    }
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => {
+      Ok(Some(FlAr::PortraitNineBySixteen))
+    }
+    Some(CommonAspectRatio::TallNineByTwentyOne) => Ok(Some(FlAr::PortraitNineByTwentyOne)),
+
+    // Mismatch — TallFourByFive maps to nearest (LandscapeFourByThree per existing desktop behavior)
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> GenerateFluxPro11UltraTextToImageAspectRatio {
+  use GenerateFluxPro11UltraTextToImageAspectRatio as FlAr;
+  match aspect_ratio {
+    // TallFourByFive (0.8) — nearest is LandscapeFourByThree per existing desktop behavior
+    CommonAspectRatio::TallFourByFive => FlAr::LandscapeFourByThree,
+    _ => FlAr::Square,
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GenerateFluxPro11UltraTextToImageNumImages, ArtcraftRouterError> {
+  use GenerateFluxPro11UltraTextToImageNumImages as FlN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(FlN::One),
+    2 => Ok(FlN::Two),
+    3 => Ok(FlN::Three),
+    4 => Ok(FlN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(FlN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::client::generation_mode_mismatch_strategy::GenerationModeMismatchStrategy;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_flux_pro_1p1_ultra_image_request;
+  use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::{
+    GenerateFluxPro11UltraTextToImageAspectRatio as FlAr,
+    GenerateFluxPro11UltraTextToImageNumImages as FlN,
+  };
+
+  // ── Generation mode mismatch ─────────────────────────────────────────────
+
+  #[test]
+  fn image_inputs_with_abort_returns_error() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::AbortGeneration),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { field: "image_inputs", .. }))
+    ));
+  }
+
+  #[test]
+  fn image_inputs_with_generate_anyway_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: Some(GenerationModeMismatchStrategy::GenerateAnyway),
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  #[test]
+  fn image_inputs_with_none_strategy_succeeds() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      generation_mode_mismatch_strategy: None,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(request.build().is_ok());
+  }
+
+  // ── Aspect ratio ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_flux_pro_1p1_ultra_image_request() };
+    let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_auto_and_square_hd_fall_back_to_square() {
+    for ar in [
+      CommonAspectRatio::Auto,
+      CommonAspectRatio::Auto2k,
+      CommonAspectRatio::Auto4k,
+      CommonAspectRatio::SquareHd,
+    ] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_mappings() {
+    let cases = [
+      (CommonAspectRatio::Square, FlAr::Square),
+      (CommonAspectRatio::WideThreeByTwo, FlAr::LandscapeThreeByTwo),
+      (CommonAspectRatio::WideFourByThree, FlAr::LandscapeFourByThree),
+      (CommonAspectRatio::WideSixteenByNine, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::Wide, FlAr::LandscapeSixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, FlAr::LandscapeTwentyOneByNine),
+      (CommonAspectRatio::TallTwoByThree, FlAr::PortraitTwoByThree),
+      (CommonAspectRatio::TallThreeByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::WideFiveByFour, FlAr::PortraitThreeByFour),
+      (CommonAspectRatio::TallNineBySixteen, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::Tall, FlAr::PortraitNineBySixteen),
+      (CommonAspectRatio::TallNineByTwentyOne, FlAr::PortraitNineByTwentyOne),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.aspect_ratio, Some(FlAr::LandscapeFourByThree)));
+    }
+  }
+
+  // ── Num images ───────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+      ));
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, FlN::One), (2, FlN::Two), (3, FlN::Three), (4, FlN::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_flux_pro_1p1_ultra_image_request() };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_flux_pro_1p1_ultra_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_flux_pro_1p1_ultra_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftFluxPro11Ultra(plan) = request.build().unwrap() else { panic!("expected ArtcraftFluxPro11Ultra") };
+      assert!(matches!(plan.num_images, FlN::Four));
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_gpt_image_1p5.rs

@@ -0,0 +1,310 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+  GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality,
+  GptImage1p5MultiFunctionImageGenSize,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftGptImage1p5<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<GptImage1p5MultiFunctionImageGenSize>,
+  /// Quality defaults to Medium when not specified in the request.
+  pub quality: GptImage1p5MultiFunctionImageGenQuality,
+  pub num_images: GptImage1p5MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_gpt_image_1p5<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftGptImage1p5<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftGptImage1p5 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    quality: GptImage1p5MultiFunctionImageGenQuality::Medium,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// GPT Image 1.5 image sizes: Square (1024x1024), Wide (1536x1024), Tall (1024x1536).
+// All 17 CommonAspectRatio variants map to one of these three sizes or None.
+// Auto aspect ratios yield None (let the API choose its default).
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  _strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<GptImage1p5MultiFunctionImageGenSize>, ArtcraftRouterError> {
+  use GptImage1p5MultiFunctionImageGenSize as GS;
+  match aspect_ratio {
+    // No preference or auto — let the model use its default
+    None
+    | Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => Ok(None),
+
+    // Square
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(GS::Square)),
+
+    // Wide
+    Some(CommonAspectRatio::WideThreeByTwo)
+    | Some(CommonAspectRatio::WideFourByThree)
+    | Some(CommonAspectRatio::WideFiveByFour)
+    | Some(CommonAspectRatio::WideSixteenByNine)
+    | Some(CommonAspectRatio::WideTwentyOneByNine)
+    | Some(CommonAspectRatio::Wide) => Ok(Some(GS::Wide)),
+
+    // Tall
+    Some(CommonAspectRatio::TallTwoByThree)
+    | Some(CommonAspectRatio::TallThreeByFour)
+    | Some(CommonAspectRatio::TallFourByFive)
+    | Some(CommonAspectRatio::TallNineBySixteen)
+    | Some(CommonAspectRatio::TallNineByTwentyOne)
+    | Some(CommonAspectRatio::Tall) => Ok(Some(GS::Tall)),
+  }
+}
+
+// GPT Image 1.5 supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GptImage1p5MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use GptImage1p5MultiFunctionImageGenNumImages as GN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(GN::One),
+    2 => Ok(GN::Two),
+    3 => Ok(GN::Three),
+    4 => Ok(GN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(GN::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(GN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_gpt_image_1p5_image_request;
+  use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{
+    GptImage1p5MultiFunctionImageGenNumImages as GN,
+    GptImage1p5MultiFunctionImageGenQuality,
+    GptImage1p5MultiFunctionImageGenSize as GS,
+  };
+
+  // ── Image size (aspect ratio mapping) ────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_gpt_image_1p5_image_request() };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_auto_variants_yield_none() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest { aspect_ratio: Some(auto_ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(plan.image_size.is_none(), "expected None for {:?}", auto_ar);
+    }
+  }
+
+  #[test]
+  fn image_size_square_variants() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Square)), "expected Square for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_wide_variants() {
+    let wide_ars = [
+      CommonAspectRatio::WideThreeByTwo,
+      CommonAspectRatio::WideFourByThree,
+      CommonAspectRatio::WideFiveByFour,
+      CommonAspectRatio::WideSixteenByNine,
+      CommonAspectRatio::WideTwentyOneByNine,
+      CommonAspectRatio::Wide,
+    ];
+    for ar in wide_ars {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Wide)), "expected Wide for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_tall_variants() {
+    let tall_ars = [
+      CommonAspectRatio::TallTwoByThree,
+      CommonAspectRatio::TallThreeByFour,
+      CommonAspectRatio::TallFourByFive,
+      CommonAspectRatio::TallNineBySixteen,
+      CommonAspectRatio::TallNineByTwentyOne,
+      CommonAspectRatio::Tall,
+    ];
+    for ar in tall_ars {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(matches!(plan.image_size, Some(GS::Tall)), "expected Tall for {:?}", ar);
+    }
+  }
+
+  // ── Quality ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn quality_defaults_to_medium() {
+    let request = base_gpt_image_1p5_image_request();
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(matches!(plan.quality, GptImage1p5MultiFunctionImageGenQuality::Medium));
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_gpt_image_1p5_image_request()
+      };
+      let result = request.build();
+      assert!(
+        matches!(result, Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, GN::One),
+      (2, GN::Two),
+      (3, GN::Three),
+      (4, GN::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_gpt_image_1p5_image_request() };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_gpt_image_1p5_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_gpt_image_1p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+      assert!(
+        matches!(plan.num_images, GN::Four),
+        "expected Four for count 5 with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Image inputs ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_gpt_image_1p5_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_gpt_image_1p5_image_request() };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_gpt_image_1p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftGptImage1p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftGptImage1p5") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_nano_banana.rs

@@ -0,0 +1,389 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{
+  NanoBananaMultiFunctionImageGenAspectRatio, NanoBananaMultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftNanaBanana<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub aspect_ratio: Option<NanoBananaMultiFunctionImageGenAspectRatio>,
+  pub num_images: NanoBananaMultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_nano_banana<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftNanaBanana<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftNanaBanana {
+    prompt: request.prompt,
+    image_inputs,
+    aspect_ratio,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Nano Banana supported aspect ratios:
+//   Text-to-image: OneByOne, FiveByFour, FourByThree, ThreeByTwo, SixteenByNine, TwentyOneByNine,
+//                  FourByFive, ThreeByFour, TwoByThree, NineBySixteen
+//   Image editing: Auto (uses source image AR), plus all text-to-image ratios
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanoBananaMultiFunctionImageGenAspectRatio>, ArtcraftRouterError> {
+  use NanoBananaMultiFunctionImageGenAspectRatio as NbAr;
+  match aspect_ratio {
+    // No preference — let the model use its default
+    None => Ok(None),
+
+    // Auto: only valid in edit mode (use source image dimensions)
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => {
+      if is_edit_mode {
+        Ok(Some(NbAr::Auto))
+      } else {
+        // Auto not valid for text-to-image; fall back to square default
+        Ok(Some(NbAr::OneByOne))
+      }
+    }
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(NbAr::OneByOne)),
+    Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(NbAr::FiveByFour)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(NbAr::FourByThree)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(NbAr::ThreeByTwo)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => Ok(Some(NbAr::SixteenByNine)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(NbAr::TwentyOneByNine)),
+    Some(CommonAspectRatio::TallFourByFive) => Ok(Some(NbAr::FourByFive)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(NbAr::ThreeByFour)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(NbAr::TwoByThree)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => Ok(Some(NbAr::NineBySixteen)),
+
+    // Mismatch — TallNineByTwentyOne has no direct equivalent
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+/// Pick the nearest supported aspect ratio for unsupported inputs.
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> NanoBananaMultiFunctionImageGenAspectRatio {
+  use NanoBananaMultiFunctionImageGenAspectRatio as NbAr;
+  match aspect_ratio {
+    // TallNineByTwentyOne (0.43) — nearest is NineBySixteen (0.5625)
+    CommonAspectRatio::TallNineByTwentyOne => NbAr::NineBySixteen,
+    _ => NbAr::OneByOne,
+  }
+}
+
+// Nano Banana supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<NanoBananaMultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use NanoBananaMultiFunctionImageGenNumImages as NbN;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(NbN::One),
+    2 => Ok(NbN::Two),
+    3 => Ok(NbN::Three),
+    4 => Ok(NbN::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(NbN::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(NbN::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_nano_banana_image_request;
+  use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{
+    NanoBananaMultiFunctionImageGenAspectRatio as NbAr,
+    NanoBananaMultiFunctionImageGenNumImages as NbN,
+  };
+
+  // ── Aspect ratio ────────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_nano_banana_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_direct_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(matches!(plan.aspect_ratio, Some(NbAr::OneByOne)), "expected OneByOne for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_wide() {
+    let cases = [
+      (CommonAspectRatio::WideFiveByFour, NbAr::FiveByFour),
+      (CommonAspectRatio::WideFourByThree, NbAr::FourByThree),
+      (CommonAspectRatio::WideThreeByTwo, NbAr::ThreeByTwo),
+      (CommonAspectRatio::WideSixteenByNine, NbAr::SixteenByNine),
+      (CommonAspectRatio::Wide, NbAr::SixteenByNine),
+      (CommonAspectRatio::WideTwentyOneByNine, NbAr::TwentyOneByNine),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_direct_tall() {
+    let cases = [
+      (CommonAspectRatio::TallFourByFive, NbAr::FourByFive),
+      (CommonAspectRatio::TallThreeByFour, NbAr::ThreeByFour),
+      (CommonAspectRatio::TallTwoByThree, NbAr::TwoByThree),
+      (CommonAspectRatio::TallNineBySixteen, NbAr::NineBySixteen),
+      (CommonAspectRatio::Tall, NbAr::NineBySixteen),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(common), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(ar) if std::mem::discriminant(&ar) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_edit_mode_yields_auto() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let tokens = vec![];
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::Auto)),
+        "expected Auto in edit mode for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_text_to_image_mode_falls_back_to_square() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: None,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::OneByOne)),
+        "expected OneByOne fallback in text-to-image for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_error_out() {
+    // TallNineByTwentyOne has no direct equivalent
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::TallNineByTwentyOne),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn aspect_ratio_unsupported_nearest_match() {
+    // TallNineByTwentyOne (0.43) is nearest to NineBySixteen (0.5625)
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallNineByTwentyOne),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(NbAr::NineBySixteen)),
+        "expected NineBySixteen nearest match with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let result = request.build();
+      assert!(
+        matches!(result, Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, NbN::One),
+      (2, NbN::Two),
+      (3, NbN::Three),
+      (4, NbN::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_nano_banana_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_nano_banana_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+      assert!(
+        matches!(plan.num_images, NbN::Four),
+        "expected Four for count 5 with {:?}", strategy,
+      );
+    }
+  }
+
+  // ── Image inputs ─────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_nano_banana_image_request()
+    };
+    let result = request.build();
+    assert!(matches!(
+      result,
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_nano_banana_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_nano_banana_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftNanaBanana(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_nano_banana_2.rs

@@ -0,0 +1,289 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::common_resolution::CommonResolution;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+  NanaBanana2MultiFunctionImageGenAspectRatio, NanaBanana2MultiFunctionImageGenImageResolution,
+  NanaBanana2MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftNanaBanana2<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub aspect_ratio: Option<NanaBanana2MultiFunctionImageGenAspectRatio>,
+  pub resolution: Option<NanaBanana2MultiFunctionImageGenImageResolution>,
+  pub num_images: NanaBanana2MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_nano_banana_2<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftNanaBanana2<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let aspect_ratio = plan_aspect_ratio(request.aspect_ratio, is_edit_mode, strategy)?;
+  let resolution = plan_resolution(request.resolution, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftNanaBanana2 {
+    prompt: request.prompt,
+    image_inputs,
+    aspect_ratio,
+    resolution,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Nano Banana 2 supported aspect ratios:
+//   Text-to-image: OneByOne, FiveByFour, FourByThree, ThreeByTwo, SixteenByNine, TwentyOneByNine,
+//                  FourByFive, ThreeByFour, TwoByThree, NineBySixteen
+//   Image editing: Auto (uses source image AR), plus all text-to-image ratios
+fn plan_aspect_ratio(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanaBanana2MultiFunctionImageGenAspectRatio>, ArtcraftRouterError> {
+  use NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar;
+  match aspect_ratio {
+    // No preference — let the model use its default
+    None => Ok(None),
+
+    // Auto: only valid in edit mode (use source image dimensions)
+    Some(CommonAspectRatio::Auto)
+    | Some(CommonAspectRatio::Auto2k)
+    | Some(CommonAspectRatio::Auto4k) => {
+      if is_edit_mode {
+        Ok(Some(Nb2Ar::Auto))
+      } else {
+        // Auto not valid for text-to-image; fall back to square default
+        Ok(Some(Nb2Ar::OneByOne))
+      }
+    }
+
+    // Direct mappings
+    Some(CommonAspectRatio::Square) | Some(CommonAspectRatio::SquareHd) => Ok(Some(Nb2Ar::OneByOne)),
+    Some(CommonAspectRatio::WideFiveByFour) => Ok(Some(Nb2Ar::FiveByFour)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(Nb2Ar::FourByThree)),
+    Some(CommonAspectRatio::WideThreeByTwo) => Ok(Some(Nb2Ar::ThreeByTwo)),
+    Some(CommonAspectRatio::WideSixteenByNine) | Some(CommonAspectRatio::Wide) => Ok(Some(Nb2Ar::SixteenByNine)),
+    Some(CommonAspectRatio::WideTwentyOneByNine) => Ok(Some(Nb2Ar::TwentyOneByNine)),
+    Some(CommonAspectRatio::TallFourByFive) => Ok(Some(Nb2Ar::FourByFive)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(Nb2Ar::ThreeByFour)),
+    Some(CommonAspectRatio::TallTwoByThree) => Ok(Some(Nb2Ar::TwoByThree)),
+    Some(CommonAspectRatio::TallNineBySixteen) | Some(CommonAspectRatio::Tall) => Ok(Some(Nb2Ar::NineBySixteen)),
+
+    // Mismatch — TallNineByTwentyOne has no direct equivalent
+    Some(unsupported) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => {
+        Ok(Some(nearest_aspect_ratio(unsupported)))
+      }
+    },
+  }
+}
+
+/// Pick the nearest supported aspect ratio for unsupported inputs.
+fn nearest_aspect_ratio(aspect_ratio: CommonAspectRatio) -> NanaBanana2MultiFunctionImageGenAspectRatio {
+  use NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar;
+  match aspect_ratio {
+    // TallNineByTwentyOne (0.43) — nearest is NineBySixteen (0.5625)
+    CommonAspectRatio::TallNineByTwentyOne => Nb2Ar::NineBySixteen,
+    _ => Nb2Ar::OneByOne,
+  }
+}
+
+fn plan_resolution(
+  resolution: Option<CommonResolution>,
+  _strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<NanaBanana2MultiFunctionImageGenImageResolution>, ArtcraftRouterError> {
+  use CommonResolution as R;
+  use NanaBanana2MultiFunctionImageGenImageResolution as Nb2Res;
+  match resolution {
+    None => Ok(None),
+    Some(R::OneK) => Ok(Some(Nb2Res::OneK)),
+    Some(R::TwoK) => Ok(Some(Nb2Res::TwoK)),
+    Some(R::FourK) => Ok(Some(Nb2Res::FourK)),
+    Some(R::ThreeK) => {
+      // No 3K option; default to 2K
+      Ok(Some(Nb2Res::TwoK))
+    }
+  }
+}
+
+// Nano Banana 2 supports 1, 2, 3, and 4 images.
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<NanaBanana2MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use NanaBanana2MultiFunctionImageGenNumImages as Nb2N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(Nb2N::One),
+    2 => Ok(Nb2N::Two),
+    3 => Ok(Nb2N::Three),
+    4 => Ok(Nb2N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade => Ok(Nb2N::Four),
+      RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Nb2N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::common_resolution::CommonResolution;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_nano_banana_2_image_request;
+  use artcraft_api_defs::generate::image::multi_function::nano_banana_2_multi_function_image_gen::{
+    NanaBanana2MultiFunctionImageGenAspectRatio as Nb2Ar,
+    NanaBanana2MultiFunctionImageGenImageResolution as Nb2Res,
+    NanaBanana2MultiFunctionImageGenNumImages as Nb2N,
+  };
+
+  // ── Aspect ratio ────────────────────────────────────────────────────────────
+
+  #[test]
+  fn aspect_ratio_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_nano_banana_2_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(plan.aspect_ratio.is_none());
+  }
+
+  #[test]
+  fn aspect_ratio_direct_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(matches!(plan.aspect_ratio, Some(Nb2Ar::OneByOne)), "expected OneByOne for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_edit_mode_yields_auto() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let tokens = vec![];
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+        ..base_nano_banana_2_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(Nb2Ar::Auto)),
+        "expected Auto in edit mode for {:?}", auto_ar,
+      );
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_auto_in_text_to_image_falls_back_to_square() {
+    for auto_ar in [CommonAspectRatio::Auto, CommonAspectRatio::Auto2k, CommonAspectRatio::Auto4k] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(auto_ar),
+        image_inputs: None,
+        ..base_nano_banana_2_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.aspect_ratio, Some(Nb2Ar::OneByOne)),
+        "expected OneByOne fallback in text-to-image for {:?}", auto_ar,
+      );
+    }
+  }
+
+  // ── Resolution ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn resolution_none_is_none() {
+    let request = GenerateImageRequest { resolution: None, ..base_nano_banana_2_image_request() };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(plan.resolution.is_none());
+  }
+
+  #[test]
+  fn resolution_direct_mappings() {
+    let cases = [
+      (CommonResolution::OneK, Nb2Res::OneK),
+      (CommonResolution::TwoK, Nb2Res::TwoK),
+      (CommonResolution::FourK, Nb2Res::FourK),
+    ];
+    for (common, expected) in cases {
+      let request = GenerateImageRequest { resolution: Some(common), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        matches!(plan.resolution, Some(r) if std::mem::discriminant(&r) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, common,
+      );
+    }
+  }
+
+  #[test]
+  fn resolution_three_k_falls_back_to_two_k() {
+    let request = GenerateImageRequest {
+      resolution: Some(CommonResolution::ThreeK),
+      ..base_nano_banana_2_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+    assert!(matches!(plan.resolution, Some(Nb2Res::TwoK)));
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [
+      (1, Nb2N::One),
+      (2, Nb2N::Two),
+      (3, Nb2N::Three),
+      (4, Nb2N::Four),
+    ];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_nano_banana_2_image_request() };
+      let ImageGenerationPlan::ArtcraftNanaBanana2(plan) = request.build().unwrap() else { panic!("expected ArtcraftNanaBanana2") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_seedream_4.rs

@@ -0,0 +1,380 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{
+  BytedanceSeedreamV4MultiFunctionImageGenImageSize,
+  BytedanceSeedreamV4MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftSeedream4<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize>,
+  pub num_images: BytedanceSeedreamV4MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_seedream_4<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftSeedream4<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftSeedream4 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Seedream V4 supported image sizes:
+//   Square, SquareHd
+//   PortraitFourThree, PortraitSixteenNine
+//   LandscapeFourThree, LandscapeSixteenNine
+//   Auto (edit mode: preserve source dimensions), Auto2k, Auto4k
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize>, ArtcraftRouterError> {
+  use BytedanceSeedreamV4MultiFunctionImageGenImageSize as S;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: valid in edit mode (preserve source dimensions); fall back to Square for text-to-image
+    Some(CommonAspectRatio::Auto) => {
+      if is_edit_mode { Ok(Some(S::Auto)) } else { Ok(Some(S::Square)) }
+    }
+
+    Some(CommonAspectRatio::Auto2k) => Ok(Some(S::Auto2k)),
+    Some(CommonAspectRatio::Auto4k) => Ok(Some(S::Auto4k)),
+
+    // Square
+    Some(CommonAspectRatio::Square) => Ok(Some(S::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(S::SquareHd)),
+
+    // Wide — direct mappings
+    Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideSixteenByNine) => Ok(Some(S::LandscapeSixteenNine)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(S::LandscapeFourThree)),
+
+    // Wide — no direct equivalent, nearest is LandscapeSixteenNine
+    Some(unsupported @ CommonAspectRatio::WideFiveByFour)
+    | Some(unsupported @ CommonAspectRatio::WideThreeByTwo)
+    | Some(unsupported @ CommonAspectRatio::WideTwentyOneByNine) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::LandscapeSixteenNine)),
+    },
+
+    // Tall — direct mappings
+    Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineBySixteen) => Ok(Some(S::PortraitSixteenNine)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(S::PortraitFourThree)),
+
+    // Tall — no direct equivalent, nearest is PortraitSixteenNine
+    Some(unsupported @ CommonAspectRatio::TallFourByFive)
+    | Some(unsupported @ CommonAspectRatio::TallTwoByThree)
+    | Some(unsupported @ CommonAspectRatio::TallNineByTwentyOne) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::PortraitSixteenNine)),
+    },
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<BytedanceSeedreamV4MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use BytedanceSeedreamV4MultiFunctionImageGenNumImages as N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(N::One),
+    2 => Ok(N::Two),
+    3 => Ok(N::Three),
+    4 => Ok(N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_seedream_4_image_request;
+  use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{
+    BytedanceSeedreamV4MultiFunctionImageGenImageSize as S,
+    BytedanceSeedreamV4MultiFunctionImageGenNumImages as N,
+  };
+
+  // ── Image size (from aspect ratio) ──────────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_seedream_4_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      let expected = match ar {
+        CommonAspectRatio::Square => S::Square,
+        CommonAspectRatio::SquareHd => S::SquareHd,
+        _ => unreachable!(),
+      };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_wide_direct() {
+    let cases = [
+      (CommonAspectRatio::Wide, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideSixteenByNine, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideFourByThree, S::LandscapeFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_tall_direct() {
+    let cases = [
+      (CommonAspectRatio::Tall, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallNineBySixteen, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallThreeByFour, S::PortraitFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_auto_in_edit_mode_yields_auto() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(matches!(plan.image_size, Some(S::Auto)));
+  }
+
+  #[test]
+  fn image_size_auto_in_text_to_image_yields_square() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: None,
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(matches!(plan.image_size, Some(S::Square)));
+  }
+
+  #[test]
+  fn image_size_auto2k_and_auto4k() {
+    for (ar, expected) in [(CommonAspectRatio::Auto2k, S::Auto2k), (CommonAspectRatio::Auto4k, S::Auto4k)] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_error_out() {
+    for ar in [CommonAspectRatio::WideFiveByFour, CommonAspectRatio::TallFourByFive] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..base_seedream_4_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+      ), "expected error for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_nearest_match() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::WideFiveByFour),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.image_size, Some(S::LandscapeSixteenNine)), "expected LandscapeSixteenNine with {:?}", strategy);
+
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.image_size, Some(S::PortraitSixteenNine)), "expected PortraitSixteenNine with {:?}", strategy);
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      assert!(
+        matches!(request.build(), Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, N::One), (2, N::Two), (3, N::Three), (4, N::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_seedream_4_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_seedream_4_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+      assert!(matches!(plan.num_images, N::Four), "expected Four for count 5 with {:?}", strategy);
+    }
+  }
+
+  // ── Image inputs ──────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_seedream_4_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_seedream_4_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_seedream_4p5.rs

@@ -0,0 +1,381 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{
+  BytedanceSeedreamV4p5MultiFunctionImageGenImageSize,
+  BytedanceSeedreamV4p5MultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftSeedream4p5<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize>,
+  pub num_images: BytedanceSeedreamV4p5MultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_seedream_4p5<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftSeedream4p5<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftSeedream4p5 {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Seedream V4.5 supported image sizes:
+//   Square, SquareHd
+//   PortraitFourThree, PortraitSixteenNine
+//   LandscapeFourThree, LandscapeSixteenNine
+//   Auto2k, Auto4k (no bare Auto — unlike V4)
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize>, ArtcraftRouterError> {
+  use BytedanceSeedreamV4p5MultiFunctionImageGenImageSize as S;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: V4.5 has no bare Auto; fall back to Auto2k in edit mode, Square for text-to-image
+    Some(CommonAspectRatio::Auto) => {
+      if is_edit_mode { Ok(Some(S::Auto2k)) } else { Ok(Some(S::Square)) }
+    }
+
+    Some(CommonAspectRatio::Auto2k) => Ok(Some(S::Auto2k)),
+    Some(CommonAspectRatio::Auto4k) => Ok(Some(S::Auto4k)),
+
+    // Square
+    Some(CommonAspectRatio::Square) => Ok(Some(S::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(S::SquareHd)),
+
+    // Wide — direct mappings
+    Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideSixteenByNine) => Ok(Some(S::LandscapeSixteenNine)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(S::LandscapeFourThree)),
+
+    // Wide — no direct equivalent, nearest is LandscapeSixteenNine
+    Some(unsupported @ CommonAspectRatio::WideFiveByFour)
+    | Some(unsupported @ CommonAspectRatio::WideThreeByTwo)
+    | Some(unsupported @ CommonAspectRatio::WideTwentyOneByNine) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::LandscapeSixteenNine)),
+    },
+
+    // Tall — direct mappings
+    Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineBySixteen) => Ok(Some(S::PortraitSixteenNine)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(S::PortraitFourThree)),
+
+    // Tall — no direct equivalent, nearest is PortraitSixteenNine
+    Some(unsupported @ CommonAspectRatio::TallFourByFive)
+    | Some(unsupported @ CommonAspectRatio::TallTwoByThree)
+    | Some(unsupported @ CommonAspectRatio::TallNineByTwentyOne) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::PortraitSixteenNine)),
+    },
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<BytedanceSeedreamV4p5MultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use BytedanceSeedreamV4p5MultiFunctionImageGenNumImages as N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(N::One),
+    2 => Ok(N::Two),
+    3 => Ok(N::Three),
+    4 => Ok(N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_seedream_4p5_image_request;
+  use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{
+    BytedanceSeedreamV4p5MultiFunctionImageGenImageSize as S,
+    BytedanceSeedreamV4p5MultiFunctionImageGenNumImages as N,
+  };
+
+  // ── Image size (from aspect ratio) ──────────────────────────────────────────
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_seedream_4p5_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_square() {
+    for ar in [CommonAspectRatio::Square, CommonAspectRatio::SquareHd] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      let expected = match ar {
+        CommonAspectRatio::Square => S::Square,
+        CommonAspectRatio::SquareHd => S::SquareHd,
+        _ => unreachable!(),
+      };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_wide_direct() {
+    let cases = [
+      (CommonAspectRatio::Wide, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideSixteenByNine, S::LandscapeSixteenNine),
+      (CommonAspectRatio::WideFourByThree, S::LandscapeFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_tall_direct() {
+    let cases = [
+      (CommonAspectRatio::Tall, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallNineBySixteen, S::PortraitSixteenNine),
+      (CommonAspectRatio::TallThreeByFour, S::PortraitFourThree),
+    ];
+    for (ar, expected) in cases {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_auto_in_edit_mode_yields_auto2k() {
+    // V4.5 has no bare Auto; falls back to Auto2k in edit mode
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(matches!(plan.image_size, Some(S::Auto2k)));
+  }
+
+  #[test]
+  fn image_size_auto_in_text_to_image_yields_square() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: None,
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(matches!(plan.image_size, Some(S::Square)));
+  }
+
+  #[test]
+  fn image_size_auto2k_and_auto4k() {
+    for (ar, expected) in [(CommonAspectRatio::Auto2k, S::Auto2k), (CommonAspectRatio::Auto4k, S::Auto4k)] {
+      let request = GenerateImageRequest { aspect_ratio: Some(ar), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        matches!(plan.image_size, Some(s) if std::mem::discriminant(&s) == std::mem::discriminant(&expected)),
+        "expected {:?} for {:?}", expected, ar,
+      );
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_error_out() {
+    for ar in [CommonAspectRatio::WideFiveByFour, CommonAspectRatio::TallFourByFive] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(ar),
+        request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+        ..base_seedream_4p5_image_request()
+      };
+      assert!(matches!(
+        request.build(),
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+      ), "expected error for {:?}", ar);
+    }
+  }
+
+  #[test]
+  fn image_size_unsupported_nearest_match() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::WideFiveByFour),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.image_size, Some(S::LandscapeSixteenNine)), "expected LandscapeSixteenNine with {:?}", strategy);
+
+      let request = GenerateImageRequest {
+        aspect_ratio: Some(CommonAspectRatio::TallFourByFive),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.image_size, Some(S::PortraitSixteenNine)), "expected PortraitSixteenNine with {:?}", strategy);
+    }
+  }
+
+  // ── Num images ──────────────────────────────────────────────────────────────
+
+  #[test]
+  fn num_images_zero_is_always_error() {
+    for strategy in [
+      RequestMismatchMitigationStrategy::ErrorOut,
+      RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      RequestMismatchMitigationStrategy::PayLessDowngrade,
+    ] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(0),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      assert!(
+        matches!(request.build(), Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))),
+        "expected UserRequestedZeroGenerations with {:?}", strategy,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, N::One), (2, N::Two), (3, N::Three), (4, N::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_seedream_4p5_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+
+  #[test]
+  fn num_images_out_of_range_error_out() {
+    let request = GenerateImageRequest {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      ..base_seedream_4p5_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+  }
+
+  #[test]
+  fn num_images_out_of_range_clamps_to_four() {
+    for strategy in [RequestMismatchMitigationStrategy::PayMoreUpgrade, RequestMismatchMitigationStrategy::PayLessDowngrade] {
+      let request = GenerateImageRequest {
+        image_batch_count: Some(5),
+        request_mismatch_mitigation_strategy: strategy,
+        ..base_seedream_4p5_image_request()
+      };
+      let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+      assert!(matches!(plan.num_images, N::Four), "expected Four for count 5 with {:?}", strategy);
+    }
+  }
+
+  // ── Image inputs ──────────────────────────────────────────────────────────
+
+  #[test]
+  fn url_image_inputs_returns_error() {
+    let urls = vec!["https://example.com/image.jpg".to_string()];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::Urls(&urls)),
+      ..base_seedream_4p5_image_request()
+    };
+    assert!(matches!(
+      request.build(),
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    ));
+  }
+
+  #[test]
+  fn no_image_inputs_is_text_to_image_mode() {
+    let request = GenerateImageRequest { image_inputs: None, ..base_seedream_4p5_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_inputs.is_none());
+  }
+
+  #[test]
+  fn media_token_image_inputs_is_edit_mode() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_4p5_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream4p5(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream4p5") };
+    assert!(plan.image_inputs.is_some());
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/artcraft/plan_generate_image_artcraft_seedream_5_lite.rs

@@ -0,0 +1,211 @@
+use crate::api::common_aspect_ratio::CommonAspectRatio;
+use crate::api::image_list_ref::ImageListRef;
+use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::errors::client_error::ClientError;
+use crate::generate::generate_image::generate_image_request::GenerateImageRequest;
+use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::{
+  BytedanceSeedream5LiteMultiFunctionImageGenImageSize,
+  BytedanceSeedream5LiteMultiFunctionImageGenNumImages,
+};
+use tokens::tokens::media_files::MediaFileToken;
+
+#[derive(Debug, Clone)]
+pub struct PlanArtcraftSeedream5Lite<'a> {
+  pub prompt: Option<&'a str>,
+  /// Input images for image editing. None means text-to-image mode.
+  pub image_inputs: Option<&'a Vec<MediaFileToken>>,
+  pub image_size: Option<BytedanceSeedream5LiteMultiFunctionImageGenImageSize>,
+  pub num_images: BytedanceSeedream5LiteMultiFunctionImageGenNumImages,
+  pub idempotency_token: String,
+}
+
+pub fn plan_generate_image_artcraft_seedream_5_lite<'a>(
+  request: &'a GenerateImageRequest<'a>,
+) -> Result<PlanArtcraftSeedream5Lite<'a>, ArtcraftRouterError> {
+  let strategy = request.request_mismatch_mitigation_strategy;
+
+  let is_edit_mode = request.image_inputs.is_some();
+  let image_inputs = resolve_image_list_ref(request.image_inputs)?;
+  let image_size = plan_image_size(request.aspect_ratio, is_edit_mode, strategy)?;
+  let num_images = plan_num_images(request.image_batch_count, strategy)?;
+
+  Ok(PlanArtcraftSeedream5Lite {
+    prompt: request.prompt,
+    image_inputs,
+    image_size,
+    num_images,
+    idempotency_token: request.get_or_generate_idempotency_token(),
+  })
+}
+
+fn resolve_image_list_ref<'a>(
+  image_list_ref: Option<ImageListRef<'a>>,
+) -> Result<Option<&'a Vec<MediaFileToken>>, ArtcraftRouterError> {
+  match image_list_ref {
+    None => Ok(None),
+    Some(ImageListRef::MediaFileTokens(tokens)) => Ok(Some(tokens)),
+    Some(ImageListRef::Urls(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::ArtcraftOnlySupportsMediaTokens))
+    }
+  }
+}
+
+// Seedream 5 Lite supported image sizes:
+//   Square, SquareHd
+//   PortraitFourThree, PortraitSixteenNine
+//   LandscapeFourThree, LandscapeSixteenNine
+//   Auto2k, Auto3k (NB: 5 Lite max is auto_3K, unlike V4.5's auto_4K)
+fn plan_image_size(
+  aspect_ratio: Option<CommonAspectRatio>,
+  is_edit_mode: bool,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<Option<BytedanceSeedream5LiteMultiFunctionImageGenImageSize>, ArtcraftRouterError> {
+  use BytedanceSeedream5LiteMultiFunctionImageGenImageSize as S;
+  match aspect_ratio {
+    None => Ok(None),
+
+    // Auto: V5 has no bare Auto; fall back to Auto2k in edit mode, Square for text-to-image
+    Some(CommonAspectRatio::Auto) => {
+      if is_edit_mode { Ok(Some(S::Auto2k)) } else { Ok(Some(S::Square)) }
+    }
+
+    Some(CommonAspectRatio::Auto2k) => Ok(Some(S::Auto2k)),
+    // 5 Lite max is auto_3K; map Auto4k down to Auto3k
+    Some(CommonAspectRatio::Auto4k) => Ok(Some(S::Auto3k)),
+
+    // Square
+    Some(CommonAspectRatio::Square) => Ok(Some(S::Square)),
+    Some(CommonAspectRatio::SquareHd) => Ok(Some(S::SquareHd)),
+
+    // Wide — direct mappings
+    Some(CommonAspectRatio::Wide) | Some(CommonAspectRatio::WideSixteenByNine) => Ok(Some(S::LandscapeSixteenNine)),
+    Some(CommonAspectRatio::WideFourByThree) => Ok(Some(S::LandscapeFourThree)),
+
+    // Wide — no direct equivalent, nearest is LandscapeSixteenNine
+    Some(unsupported @ CommonAspectRatio::WideFiveByFour)
+    | Some(unsupported @ CommonAspectRatio::WideThreeByTwo)
+    | Some(unsupported @ CommonAspectRatio::WideTwentyOneByNine) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::LandscapeSixteenNine)),
+    },
+
+    // Tall — direct mappings
+    Some(CommonAspectRatio::Tall) | Some(CommonAspectRatio::TallNineBySixteen) => Ok(Some(S::PortraitSixteenNine)),
+    Some(CommonAspectRatio::TallThreeByFour) => Ok(Some(S::PortraitFourThree)),
+
+    // Tall — no direct equivalent, nearest is PortraitSixteenNine
+    Some(unsupported @ CommonAspectRatio::TallFourByFive)
+    | Some(unsupported @ CommonAspectRatio::TallTwoByThree)
+    | Some(unsupported @ CommonAspectRatio::TallNineByTwentyOne) => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "aspect_ratio",
+          value: format!("{:?}", unsupported),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(Some(S::PortraitSixteenNine)),
+    },
+  }
+}
+
+fn plan_num_images(
+  image_batch_count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<BytedanceSeedream5LiteMultiFunctionImageGenNumImages, ArtcraftRouterError> {
+  use BytedanceSeedream5LiteMultiFunctionImageGenNumImages as N;
+  let count = image_batch_count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(N::One),
+    2 => Ok(N::Two),
+    3 => Ok(N::Three),
+    4 => Ok(N::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      RequestMismatchMitigationStrategy::PayMoreUpgrade
+      | RequestMismatchMitigationStrategy::PayLessDowngrade => Ok(N::Four),
+    },
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::api::common_aspect_ratio::CommonAspectRatio;
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::errors::artcraft_router_error::ArtcraftRouterError;
+  use crate::errors::client_error::ClientError;
+  use crate::generate::generate_image::image_generation_plan::ImageGenerationPlan;
+  use crate::test_helpers::base_seedream_5_lite_image_request;
+  use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_5_lite_multi_function_image_gen::{
+    BytedanceSeedream5LiteMultiFunctionImageGenImageSize as S,
+    BytedanceSeedream5LiteMultiFunctionImageGenNumImages as N,
+  };
+
+  #[test]
+  fn image_size_none_is_none() {
+    let request = GenerateImageRequest { aspect_ratio: None, ..base_seedream_5_lite_image_request() };
+    let ImageGenerationPlan::ArtcraftSeedream5Lite(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream5Lite") };
+    assert!(plan.image_size.is_none());
+  }
+
+  #[test]
+  fn image_size_auto_in_edit_mode_yields_auto2k() {
+    let tokens = vec![];
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: Some(ImageListRef::MediaFileTokens(&tokens)),
+      ..base_seedream_5_lite_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream5Lite(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream5Lite") };
+    assert!(matches!(plan.image_size, Some(S::Auto2k)));
+  }
+
+  #[test]
+  fn image_size_auto_in_text_to_image_yields_square() {
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto),
+      image_inputs: None,
+      ..base_seedream_5_lite_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream5Lite(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream5Lite") };
+    assert!(matches!(plan.image_size, Some(S::Square)));
+  }
+
+  #[test]
+  fn auto4k_is_mapped_to_auto3k() {
+    // 5 Lite only supports up to auto_3K; auto_4K is downgraded
+    let request = GenerateImageRequest {
+      aspect_ratio: Some(CommonAspectRatio::Auto4k),
+      ..base_seedream_5_lite_image_request()
+    };
+    let ImageGenerationPlan::ArtcraftSeedream5Lite(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream5Lite") };
+    assert!(matches!(plan.image_size, Some(S::Auto3k)));
+  }
+
+  #[test]
+  fn num_images_direct_mapping() {
+    let cases = [(1, N::One), (2, N::Two), (3, N::Three), (4, N::Four)];
+    for (count, expected) in cases {
+      let request = GenerateImageRequest { image_batch_count: Some(count), ..base_seedream_5_lite_image_request() };
+      let ImageGenerationPlan::ArtcraftSeedream5Lite(plan) = request.build().unwrap() else { panic!("expected ArtcraftSeedream5Lite") };
+      assert!(
+        std::mem::discriminant(&plan.num_images) == std::mem::discriminant(&expected),
+        "expected {:?} for count {}", expected, count,
+      );
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/plan/fal/plan_generate_image_fal_nano_banana_pro.rs

@@ -252,6 +252,7 @@ mod tests {
       aspect_ratio: None,
       image_batch_count: None,
       request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
       idempotency_token: None,
     }
   }

crates/api_clients/artcraft/artcraft_router/src/test_helpers.rs

@@ -31,6 +31,7 @@ pub fn base_image_request() -> GenerateImageRequest<'static> {
     aspect_ratio: None,
     image_batch_count: None,
     request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
     idempotency_token: None,
   }
 }
@@ -53,6 +54,157 @@ pub fn base_fal_image_request() -> GenerateImageRequest<'static> {
     aspect_ratio: None,
     image_batch_count: None,
     request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_seedream_4_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::Seedream4,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_seedream_4p5_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::Seedream4p5,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_seedream_5_lite_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::Seedream5Lite,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_nano_banana_2_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::NanaBanana2,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_nano_banana_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::NanaBanana,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_gpt_image_1p5_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::GptImage1p5,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_flux_1_dev_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::Flux1Dev,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_flux_1_schnell_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::Flux1Schnell,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_flux_pro_1p1_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::FluxPro11,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
+    idempotency_token: None,
+  }
+}
+
+pub fn base_flux_pro_1p1_ultra_image_request() -> GenerateImageRequest<'static> {
+  GenerateImageRequest {
+    model: CommonImageModel::FluxPro11Ultra,
+    provider: Provider::Artcraft,
+    prompt: Some("a cat in space"),
+    image_inputs: None,
+    resolution: None,
+    aspect_ratio: None,
+    image_batch_count: None,
+    request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+    generation_mode_mismatch_strategy: None,
     idempotency_token: None,
   }
 }

crates/api_clients/fal_client/src/requests/http/image/http_nano_banana_2_edit_image.rs

@@ -0,0 +1,79 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct NanoBanana2EditImageInput {
+  pub prompt: String,
+
+  pub image_urls: Vec<String>,
+
+  /// Eg. "auto", "16:9", "1:1", etc.
+  /// Options: auto, 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+  /// Default: "auto"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+
+  /// Eg. "0.5K", "1K", "2K", "4K"
+  /// Default: "1K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub resolution: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// "jpeg", "png", "webp"
+  /// Default: "png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<u64>,
+
+  /// The safety tolerance level for content moderation.
+  /// 1 is the most strict (blocks most content), 6 is the least strict.
+  /// Default value: "4"
+  ///
+  /// Possible enum values: 1, 2, 3, 4, 5, 6
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub safety_tolerance: Option<String>,
+
+  /// Experimental parameter to limit the number of generations from each round
+  /// of prompting to 1. Set to True to to disregard any instructions in the
+  /// prompt regarding the number of images to generate and ignore any
+  /// intermediate images generated by the model. This may affect generation
+  /// quality.
+  ///
+  /// Default value: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub limit_generations: Option<bool>,
+
+  /// Enable web search for the image generation task. This will allow
+  /// the model to use the latest information from the web to generate
+  /// the image.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_web_search: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBanana2EditImageFile {
+  pub url: String,
+  //pub content_type: Option<String>,
+  //pub file_name: Option<String>,
+  //pub file_size: Option<u64>,
+  //pub width: Option<u32>,
+  //pub height: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBanana2EditImageOutput {
+  pub images: Vec<NanoBanana2EditImageFile>,
+  //pub description: String,
+}
+
+pub fn nano_banana_2_edit_image(
+  params: NanoBanana2EditImageInput,
+) -> FalRequest<NanoBanana2EditImageInput, NanoBanana2EditImageOutput> {
+  FalRequest::new("fal-ai/nano-banana-2/edit", params)
+}

crates/api_clients/fal_client/src/requests/http/image/http_nano_banana_2_text_to_image.rs

@@ -0,0 +1,77 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct NanoBanana2TextToImageInput {
+  pub prompt: String,
+
+  /// Eg. "auto", "16:9", "1:1", etc.
+  /// Options: auto, 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+  /// Default: "auto"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+
+  /// Eg. "0.5K", "1K", "2K", "4K"
+  /// Default: "1K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub resolution: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// The safety tolerance level for content moderation.
+  /// 1 is the most strict (blocks most content), 6 is the least strict.
+  /// Default value: "4"
+  ///
+  /// Possible enum values: 1, 2, 3, 4, 5, 6
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub safety_tolerance: Option<String>,
+
+  /// "jpeg", "png", "webp"
+  /// Default: "png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<u64>,
+
+  /// Experimental parameter to limit the number of generations from each round
+  /// of prompting to 1. Set to True to to disregard any instructions in the
+  /// prompt regarding the number of images to generate and ignore any
+  /// intermediate images generated by the model. This may affect generation
+  /// quality.
+  ///
+  /// Default value: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub limit_generations: Option<bool>,
+
+  /// Enable web search for the image generation task. This will allow
+  /// the model to use the latest information from the web to generate
+  /// the image.
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_web_search: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBanana2ImageFile {
+  pub url: String,
+  //pub content_type: Option<String>,
+  //pub file_name: Option<String>,
+  //pub file_size: Option<u64>,
+  //pub width: Option<u32>,
+  //pub height: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBanana2TextToImageOutput {
+  pub images: Vec<NanoBanana2ImageFile>,
+  //pub description: String,
+}
+
+pub fn nano_banana_2_text_to_image(
+  params: NanoBanana2TextToImageInput,
+) -> FalRequest<NanoBanana2TextToImageInput, NanoBanana2TextToImageOutput> {
+  FalRequest::new("fal-ai/nano-banana-2", params)
+}

crates/api_clients/fal_client/src/requests/http/image/http_seedream_5_edit_image.rs

@@ -0,0 +1,49 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct SeedreamV5LiteEditImageInput {
+  pub prompt: String,
+
+  /// Maximum 10 images. Excess images are ignored.
+  pub image_urls: Vec<String>,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9, auto_2K, auto_3K
+  /// Default: "auto_2K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub max_images: Option<u8>,
+
+  /// Default: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV5LiteEditImageFile {
+  pub url: String,
+  //pub content_type: Option<String>,
+  //pub file_name: Option<String>,
+  //pub file_size: Option<u64>,
+  //pub width: Option<u32>,
+  //pub height: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV5LiteEditImageOutput {
+  pub images: Vec<SeedreamV5LiteEditImageFile>,
+  pub seed: u64,
+}
+
+pub fn http_seedream_5_edit_image(
+  params: SeedreamV5LiteEditImageInput,
+) -> FalRequest<SeedreamV5LiteEditImageInput, SeedreamV5LiteEditImageOutput> {
+  FalRequest::new("fal-ai/bytedance/seedream/v5/lite/edit", params)
+}

crates/api_clients/fal_client/src/requests/http/image/http_seedream_5_text_to_image.rs

@@ -0,0 +1,46 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct SeedreamV5LiteTextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9, auto_2K, auto_3K
+  /// Default: "auto_2K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub max_images: Option<u8>,
+
+  /// Default: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV5LiteImageFile {
+  pub url: String,
+  //pub content_type: Option<String>,
+  //pub file_name: Option<String>,
+  //pub file_size: Option<u64>,
+  //pub width: Option<u32>,
+  //pub height: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV5LiteTextToImageOutput {
+  pub images: Vec<SeedreamV5LiteImageFile>,
+  pub seed: u64,
+}
+
+pub fn http_seedream_5_text_to_image(
+  params: SeedreamV5LiteTextToImageInput,
+) -> FalRequest<SeedreamV5LiteTextToImageInput, SeedreamV5LiteTextToImageOutput> {
+  FalRequest::new("fal-ai/bytedance/seedream/v5/lite/text-to-image", params)
+}

crates/api_clients/fal_client/src/requests/http/image/mod.rs

@@ -0,0 +1,4 @@
+pub mod http_nano_banana_2_edit_image;
+pub mod http_nano_banana_2_text_to_image;
+pub mod http_seedream_5_edit_image;
+pub mod http_seedream_5_text_to_image;

crates/api_clients/fal_client/src/requests/http/mod.rs

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

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

@@ -1,3 +1,4 @@
+pub mod http;
 pub mod queue;
-pub mod webhook;
-pub mod traits;
+pub mod traits;
+pub mod webhook;

crates/api_clients/fal_client/src/requests/webhook/image/edit/enqueue_bytedance_seedream_v5_lite_edit_image_webhook.rs

@@ -0,0 +1,158 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use crate::requests::http::image::http_seedream_5_edit_image::{http_seedream_5_edit_image, SeedreamV5LiteEditImageInput};
+use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct EnqueueBytedanceSeedreamV5LiteEditImageArgs<'a, R: IntoUrl> {
+  // Request required
+  pub prompt: &'a str,
+  pub image_urls: Vec<String>,
+
+  // Optional args
+  pub num_images: Option<EnqueueBytedanceSeedreamV5LiteEditImageNumImages>,
+  pub max_images: Option<EnqueueBytedanceSeedreamV5LiteEditImageMaxImages>,
+  pub image_size: Option<EnqueueBytedanceSeedreamV5LiteEditImageSize>,
+
+  // Fulfillment
+  pub webhook_url: R,
+  pub api_key: &'a FalApiKey,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteEditImageNumImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteEditImageMaxImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteEditImageSize {
+  // Square
+  Square,
+  SquareHd,
+  // Tall
+  PortraitFourThree,
+  PortraitSixteenNine,
+  // Wide
+  LandscapeFourThree,
+  LandscapeSixteenNine,
+  // Auto
+  Auto2k,
+  Auto3k, // NB: v5 uses auto_3K instead of v4's auto_4K
+}
+
+
+impl <U: IntoUrl> FalRequestCostCalculator for EnqueueBytedanceSeedreamV5LiteEditImageArgs<'_, U> {
+  fn calculate_cost_in_cents(&self) -> UsdCents {
+    // TODO(bt): Verify actual pricing for Seedream v5 Lite on fal.ai.
+    let unit_cost = 4;
+    let cost = match self.num_images {
+      None => unit_cost,
+      Some(EnqueueBytedanceSeedreamV5LiteEditImageNumImages::One) => unit_cost,
+      Some(EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Two) => unit_cost * 2,
+      Some(EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Three) => unit_cost * 3,
+      Some(EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Four) => unit_cost * 4,
+    };
+    cost as UsdCents
+  }
+}
+
+
+pub async fn enqueue_bytedance_seedream_v5_lite_edit_image_webhook<R: IntoUrl>(
+  args: EnqueueBytedanceSeedreamV5LiteEditImageArgs<'_, R>
+) -> Result<WebhookResponse, FalErrorPlus> {
+
+  let num_images = args.num_images
+      .map(|n| match n {
+        EnqueueBytedanceSeedreamV5LiteEditImageNumImages::One => 1,
+        EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Two => 2,
+        EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Three => 3,
+        EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Four => 4,
+      });
+
+  let max_images = args.max_images
+      .map(|n| match n {
+        EnqueueBytedanceSeedreamV5LiteEditImageMaxImages::One => 1,
+        EnqueueBytedanceSeedreamV5LiteEditImageMaxImages::Two => 2,
+        EnqueueBytedanceSeedreamV5LiteEditImageMaxImages::Three => 3,
+        EnqueueBytedanceSeedreamV5LiteEditImageMaxImages::Four => 4,
+      });
+
+  let image_size = args.image_size
+      .map(|s| match s {
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::Square => "square",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::SquareHd => "square_hd",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::PortraitFourThree => "portrait_4_3",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::PortraitSixteenNine => "portrait_16_9",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::LandscapeFourThree => "landscape_4_3",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::LandscapeSixteenNine => "landscape_16_9",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::Auto2k => "auto_2K",
+        EnqueueBytedanceSeedreamV5LiteEditImageSize::Auto3k => "auto_3K",
+      })
+      .map(|s| s.to_string());
+
+  let request = SeedreamV5LiteEditImageInput {
+    prompt: args.prompt.to_string(),
+    image_urls: args.image_urls,
+    // Optionals
+    num_images,
+    max_images,
+    image_size,
+    // Constants
+    enable_safety_checker: Some(false),
+  };
+
+  let result = http_seedream_5_edit_image(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::edit::enqueue_bytedance_seedream_v5_lite_edit_image_webhook::{enqueue_bytedance_seedream_v5_lite_edit_image_webhook, EnqueueBytedanceSeedreamV5LiteEditImageArgs, EnqueueBytedanceSeedreamV5LiteEditImageMaxImages, EnqueueBytedanceSeedreamV5LiteEditImageNumImages, EnqueueBytedanceSeedreamV5LiteEditImageSize};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+  use test_data::web::image_urls::{GHOST_IMAGE_URL, TREX_SKELETON_IMAGE_URL};
+
+  #[tokio::test]
+  #[ignore]
+  async fn test() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = EnqueueBytedanceSeedreamV5LiteEditImageArgs {
+      image_urls: vec![
+        GHOST_IMAGE_URL.to_string(),
+        TREX_SKELETON_IMAGE_URL.to_string(),
+      ],
+      prompt: "add the ghost to the image of the t-rex skeleton, make it look spooky but friendly",
+      num_images: Some(EnqueueBytedanceSeedreamV5LiteEditImageNumImages::Two),
+      max_images: Some(EnqueueBytedanceSeedreamV5LiteEditImageMaxImages::Two),
+      image_size: Some(EnqueueBytedanceSeedreamV5LiteEditImageSize::Auto2k),
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_bytedance_seedream_v5_lite_edit_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/api_clients/fal_client/src/requests/webhook/image/edit/enqueue_nano_banana_2_edit_image_webhook.rs

@@ -0,0 +1,181 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use crate::requests::http::image::http_nano_banana_2_edit_image::{nano_banana_2_edit_image, NanoBanana2EditImageInput};
+use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct EnqueueNanoBanana2EditImageArgs<'a, R: IntoUrl> {
+  // Request required
+  pub prompt: &'a str,
+  pub image_urls: Vec<String>,
+  pub num_images: EnqueueNanoBanana2EditImageNumImages,
+
+  // Optional args
+  pub resolution: Option<EnqueueNanoBanana2EditImageResolution>,
+  pub aspect_ratio: Option<EnqueueNanoBanana2EditImageAspectRatio>,
+
+  // Fulfillment
+  pub webhook_url: R,
+  pub api_key: &'a FalApiKey,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2EditImageNumImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2EditImageResolution {
+  HalfK, // "0.5K"
+  OneK,  // "1K" (default)
+  TwoK,  // "2K"
+  FourK, // "4K"
+}
+
+/// auto, 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+/// Default: "auto"
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2EditImageAspectRatio {
+  // Automatic (default)
+  Auto,
+  // Square
+  OneByOne,
+  // Wide
+  FiveByFour,
+  FourByThree,
+  ThreeByTwo,
+  SixteenByNine,
+  TwentyOneByNine,
+  // Tall
+  FourByFive,
+  ThreeByFour,
+  TwoByThree,
+  NineBySixteen,
+}
+
+
+impl <U: IntoUrl> FalRequestCostCalculator for EnqueueNanoBanana2EditImageArgs<'_, U> {
+  fn calculate_cost_in_cents(&self) -> UsdCents {
+    // TODO(bt): Verify actual pricing for Nano Banana 2 on fal.ai.
+    // 4K outputs may be charged at double the standard rate.
+    let cost = match self.resolution {
+      None => 15,
+      Some(EnqueueNanoBanana2EditImageResolution::HalfK) => 8,
+      Some(EnqueueNanoBanana2EditImageResolution::OneK) => 15,
+      Some(EnqueueNanoBanana2EditImageResolution::TwoK) => 15,
+      Some(EnqueueNanoBanana2EditImageResolution::FourK) => 30,
+    };
+    let cost = match self.num_images {
+      EnqueueNanoBanana2EditImageNumImages::One => cost,
+      EnqueueNanoBanana2EditImageNumImages::Two => cost * 2,
+      EnqueueNanoBanana2EditImageNumImages::Three => cost * 3,
+      EnqueueNanoBanana2EditImageNumImages::Four => cost * 4,
+    };
+    cost as UsdCents
+  }
+}
+
+
+pub async fn enqueue_nano_banana_2_edit_image_webhook<R: IntoUrl>(
+  args: EnqueueNanoBanana2EditImageArgs<'_, R>
+) -> Result<WebhookResponse, FalErrorPlus> {
+
+  let num_images = match args.num_images {
+    EnqueueNanoBanana2EditImageNumImages::One => 1,
+    EnqueueNanoBanana2EditImageNumImages::Two => 2,
+    EnqueueNanoBanana2EditImageNumImages::Three => 3,
+    EnqueueNanoBanana2EditImageNumImages::Four => 4,
+  };
+
+  let resolution = args.resolution
+      .map(|resolution| match resolution {
+        EnqueueNanoBanana2EditImageResolution::HalfK => "0.5K",
+        EnqueueNanoBanana2EditImageResolution::OneK => "1K",
+        EnqueueNanoBanana2EditImageResolution::TwoK => "2K",
+        EnqueueNanoBanana2EditImageResolution::FourK => "4K",
+      })
+      .map(|r| r.to_string());
+
+  let aspect_ratio = args.aspect_ratio
+      .map(|ar| match ar {
+        // Auto
+        EnqueueNanoBanana2EditImageAspectRatio::Auto => "auto",
+        // Square
+        EnqueueNanoBanana2EditImageAspectRatio::OneByOne => "1:1",
+        // Wide
+        EnqueueNanoBanana2EditImageAspectRatio::FiveByFour => "5:4",
+        EnqueueNanoBanana2EditImageAspectRatio::FourByThree => "4:3",
+        EnqueueNanoBanana2EditImageAspectRatio::ThreeByTwo => "3:2",
+        EnqueueNanoBanana2EditImageAspectRatio::SixteenByNine => "16:9",
+        EnqueueNanoBanana2EditImageAspectRatio::TwentyOneByNine => "21:9",
+        // Tall
+        EnqueueNanoBanana2EditImageAspectRatio::FourByFive => "4:5",
+        EnqueueNanoBanana2EditImageAspectRatio::ThreeByFour => "3:4",
+        EnqueueNanoBanana2EditImageAspectRatio::TwoByThree => "2:3",
+        EnqueueNanoBanana2EditImageAspectRatio::NineBySixteen => "9:16",
+      })
+      .map(|ar| ar.to_string());
+
+  let request = NanoBanana2EditImageInput {
+    prompt: args.prompt.to_string(),
+    image_urls: args.image_urls,
+    num_images: Some(num_images),
+    // Optionals
+    aspect_ratio,
+    resolution,
+    // Constants
+    output_format: Some("png".to_string()),
+    safety_tolerance: Some("6".to_string()),
+    limit_generations: None,
+    enable_web_search: None,
+    seed: None,
+  };
+
+  let result = nano_banana_2_edit_image(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::edit::enqueue_nano_banana_2_edit_image_webhook::{enqueue_nano_banana_2_edit_image_webhook, EnqueueNanoBanana2EditImageArgs, EnqueueNanoBanana2EditImageAspectRatio, EnqueueNanoBanana2EditImageNumImages, EnqueueNanoBanana2EditImageResolution};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+  use test_data::web::image_urls::{ERNEST_SCARED_STUPID_IMAGE_URL, GHOST_IMAGE_URL, TREX_SKELETON_IMAGE_URL};
+
+  #[tokio::test]
+  #[ignore]
+  async fn test() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = EnqueueNanoBanana2EditImageArgs {
+      image_urls: vec![
+        GHOST_IMAGE_URL.to_string(),
+        TREX_SKELETON_IMAGE_URL.to_string(),
+        ERNEST_SCARED_STUPID_IMAGE_URL.to_string(),
+      ],
+      prompt: "add the ghost and scared man to the image of the t-rex skeleton, make it look spooky but friendly",
+      num_images: EnqueueNanoBanana2EditImageNumImages::Two,
+      aspect_ratio: Some(EnqueueNanoBanana2EditImageAspectRatio::SixteenByNine),
+      resolution: Some(EnqueueNanoBanana2EditImageResolution::TwoK),
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_nano_banana_2_edit_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/api_clients/fal_client/src/requests/webhook/image/edit/mod.rs

@@ -1,5 +1,7 @@
 pub mod enqueue_bytedance_seedream_v4_edit_image_webhook;
 pub mod enqueue_bytedance_seedream_v4p5_edit_image_webhook;
+pub mod enqueue_bytedance_seedream_v5_lite_edit_image_webhook;
+pub mod enqueue_nano_banana_2_edit_image_webhook;
 pub mod enqueue_flux_pro_kontext_max_edit_webhook;
 pub mod enqueue_gemini_25_flash_edit_webhook;
 pub mod enqueue_gpt_image_1_edit_image_webhook;

crates/api_clients/fal_client/src/requests/webhook/image/mod.rs

@@ -1,9 +1,4 @@
 pub mod edit;
-pub mod enqueue_flux_1_dev_text_to_image_webhook;
-pub mod enqueue_flux_1_schnell_text_to_image_webhook;
-pub mod enqueue_flux_pro_11_text_to_image_webhook;
-pub mod enqueue_flux_pro_11_ultra_text_to_image_webhook;
-pub mod enqueue_gpt_image_1_text_to_image_webhook;
 pub mod infill;
 pub mod remove_background_rembg_webhook;
 pub mod text;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_bytedance_seedream_v5_lite_text_to_image_webhook.rs

@@ -0,0 +1,151 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use crate::requests::http::image::http_seedream_5_text_to_image::{http_seedream_5_text_to_image, SeedreamV5LiteTextToImageInput};
+use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct EnqueueBytedanceSeedreamV5LiteTextToImageArgs<'a, R: IntoUrl> {
+  // Request required
+  pub prompt: &'a str,
+
+  // Optional args
+  pub num_images: Option<EnqueueBytedanceSeedreamV5LiteTextToImageNumImages>,
+  pub max_images: Option<EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages>,
+  pub image_size: Option<EnqueueBytedanceSeedreamV5LiteTextToImageSize>,
+
+  // Fulfillment
+  pub webhook_url: R,
+  pub api_key: &'a FalApiKey,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteTextToImageNumImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueBytedanceSeedreamV5LiteTextToImageSize {
+  // Square
+  Square,
+  SquareHd,
+  // Tall
+  PortraitFourThree,
+  PortraitSixteenNine,
+  // Wide
+  LandscapeFourThree,
+  LandscapeSixteenNine,
+  // Auto
+  Auto2k,
+  Auto3k, // NB: v5 uses auto_3K instead of v4's auto_4K
+}
+
+
+impl <U: IntoUrl> FalRequestCostCalculator for EnqueueBytedanceSeedreamV5LiteTextToImageArgs<'_, U> {
+  fn calculate_cost_in_cents(&self) -> UsdCents {
+    // TODO(bt): Verify actual pricing for Seedream v5 Lite on fal.ai.
+    let unit_cost = 4;
+    let cost = match self.num_images {
+      None => unit_cost,
+      Some(EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::One) => unit_cost,
+      Some(EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Two) => unit_cost * 2,
+      Some(EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Three) => unit_cost * 3,
+      Some(EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Four) => unit_cost * 4,
+    };
+    cost as UsdCents
+  }
+}
+
+
+pub async fn enqueue_bytedance_seedream_v5_lite_text_to_image_webhook<R: IntoUrl>(
+  args: EnqueueBytedanceSeedreamV5LiteTextToImageArgs<'_, R>
+) -> Result<WebhookResponse, FalErrorPlus> {
+
+  let num_images = args.num_images
+      .map(|n| match n {
+        EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::One => 1,
+        EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Two => 2,
+        EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Three => 3,
+        EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Four => 4,
+      });
+
+  let max_images = args.max_images
+      .map(|n| match n {
+        EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages::One => 1,
+        EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages::Two => 2,
+        EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages::Three => 3,
+        EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages::Four => 4,
+      });
+
+  let image_size = args.image_size
+      .map(|s| match s {
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::Square => "square",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::SquareHd => "square_hd",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::PortraitFourThree => "portrait_4_3",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::PortraitSixteenNine => "portrait_16_9",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::LandscapeFourThree => "landscape_4_3",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::LandscapeSixteenNine => "landscape_16_9",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::Auto2k => "auto_2K",
+        EnqueueBytedanceSeedreamV5LiteTextToImageSize::Auto3k => "auto_3K",
+      })
+      .map(|s| s.to_string());
+
+  let request = SeedreamV5LiteTextToImageInput {
+    prompt: args.prompt.to_string(),
+    // Optionals
+    num_images,
+    max_images,
+    image_size,
+    // Constants
+    enable_safety_checker: Some(false),
+  };
+
+  let result = http_seedream_5_text_to_image(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::text::enqueue_bytedance_seedream_v5_lite_text_to_image_webhook::{enqueue_bytedance_seedream_v5_lite_text_to_image_webhook, EnqueueBytedanceSeedreamV5LiteTextToImageArgs, EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages, EnqueueBytedanceSeedreamV5LiteTextToImageNumImages, EnqueueBytedanceSeedreamV5LiteTextToImageSize};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = EnqueueBytedanceSeedreamV5LiteTextToImageArgs {
+      prompt: "an anime girl is riding a t-rex in the forest",
+      num_images: Some(EnqueueBytedanceSeedreamV5LiteTextToImageNumImages::Two),
+      max_images: Some(EnqueueBytedanceSeedreamV5LiteTextToImageMaxImages::Two),
+      image_size: Some(EnqueueBytedanceSeedreamV5LiteTextToImageSize::LandscapeSixteenNine),
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_bytedance_seedream_v5_lite_text_to_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_1_dev_text_to_image_webhook.rs

@@ -37,14 +37,14 @@ pub enum Flux1DevNumImages {
 pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
   args: Flux1DevArgs<'_, U>
 ) -> Result<WebhookResponse, FalErrorPlus> {
-  
+
   let num_images = match args.num_images {
     Flux1DevNumImages::One => 1,
     Flux1DevNumImages::Two => 2,
     Flux1DevNumImages::Three => 3,
     Flux1DevNumImages::Four => 4,
   };
-  
+
   let image_size = match args.aspect_ratio {
     Flux1DevAspectRatio::Square => ImageSizeProperty::Square,
     Flux1DevAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
@@ -53,7 +53,7 @@ pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
     Flux1DevAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
     Flux1DevAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
   };
-  
+
   let request = DevTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
@@ -67,7 +67,7 @@ pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
     // Constants
     sync_mode: None, // Synchronous / slow
   };
-  
+
   let result = dev(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
@@ -79,7 +79,7 @@ pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::webhook::image::enqueue_flux_1_dev_text_to_image_webhook::{enqueue_flux_1_dev_text_to_image_webhook, Flux1DevArgs, Flux1DevAspectRatio, Flux1DevNumImages};
+  use crate::requests::webhook::image::text::enqueue_flux_1_dev_text_to_image_webhook::{enqueue_flux_1_dev_text_to_image_webhook, Flux1DevArgs, Flux1DevAspectRatio, Flux1DevNumImages};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_1_schnell_text_to_image_webhook.rs

@@ -37,14 +37,14 @@ pub enum Flux1SchnellNumImages {
 pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
   args: Flux1SchnellArgs<'_, U>
 ) -> Result<WebhookResponse, FalErrorPlus> {
-  
+
   let num_images = match args.num_images {
     Flux1SchnellNumImages::One => 1,
     Flux1SchnellNumImages::Two => 2,
     Flux1SchnellNumImages::Three => 3,
     Flux1SchnellNumImages::Four => 4,
   };
-  
+
   let image_size = match args.aspect_ratio {
     Flux1SchnellAspectRatio::Square => ImageSizeProperty::Square,
     Flux1SchnellAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
@@ -53,7 +53,7 @@ pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
     Flux1SchnellAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
     Flux1SchnellAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
   };
-  
+
   let request = SchnellTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
@@ -66,7 +66,7 @@ pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
     // Constants
     sync_mode: None, // Synchronous / slow
   };
-  
+
   let result = schnell(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
@@ -78,7 +78,7 @@ pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::webhook::image::enqueue_flux_1_schnell_text_to_image_webhook::{enqueue_flux_1_schnell_text_to_image_webhook, Flux1SchnellArgs, Flux1SchnellAspectRatio, Flux1SchnellNumImages};
+  use crate::requests::webhook::image::text::enqueue_flux_1_schnell_text_to_image_webhook::{enqueue_flux_1_schnell_text_to_image_webhook, Flux1SchnellArgs, Flux1SchnellAspectRatio, Flux1SchnellNumImages};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_pro_11_text_to_image_webhook.rs

@@ -53,7 +53,7 @@ impl <U: IntoUrl> FalRequestCostCalculator for FluxPro11Args<'_, U> {
 pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
   args: FluxPro11Args<'_, U>
 ) -> Result<WebhookResponse, FalErrorPlus> {
-  
+
   let num_images = match args.num_images {
     FluxPro11NumImages::One => 1,
     FluxPro11NumImages::Two => 2,
@@ -69,7 +69,7 @@ pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
     FluxPro11AspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
     FluxPro11AspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
   };
-  
+
   let request = FluxProPlusTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
@@ -83,7 +83,7 @@ pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
     output_format: Some("png".to_string()),
     sync_mode: None, // Synchronous / slow
   };
-  
+
   let result = v1_1(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
@@ -95,7 +95,7 @@ pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
 #[cfg(test)]
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
-  use crate::requests::webhook::image::enqueue_flux_pro_11_text_to_image_webhook::{enqueue_flux_pro_11_text_to_image_webhook, FluxPro11Args, FluxPro11AspectRatio, FluxPro11NumImages};
+  use crate::requests::webhook::image::text::enqueue_flux_pro_11_text_to_image_webhook::{enqueue_flux_pro_11_text_to_image_webhook, FluxPro11Args, FluxPro11AspectRatio, FluxPro11NumImages};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_pro_11_ultra_text_to_image_webhook.rs

@@ -55,7 +55,7 @@ impl <U: IntoUrl> FalRequestCostCalculator for FluxPro11UltraArgs<'_, U> {
 pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
   args: FluxPro11UltraArgs<'_, U>
 ) -> Result<WebhookResponse, FalErrorPlus> {
-  
+
   let num_images = match args.num_images {
     FluxPro11UltraNumImages::One => 1,
     FluxPro11UltraNumImages::Two => 2,
@@ -74,7 +74,7 @@ pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
     FluxPro11UltraAspectRatio::PortraitNineBySixteen => AspectRatioProperty::Property_9_16,
     FluxPro11UltraAspectRatio::PortraitNineByTwentyOne => AspectRatioProperty::Property_9_21,
   };
-  
+
   let request = FluxProUltraTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
@@ -89,7 +89,7 @@ pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
     output_format: Some("png".to_string()),
     sync_mode: None, // Synchronous / slow
   };
-  
+
   let result = v1_1_ultra(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_gpt_image_1_text_to_image_webhook.rs

@@ -13,7 +13,7 @@ pub struct GptTextToImageByokArgs<'a, V: IntoUrl> {
   pub image_size: GptTextToImageSize,
   pub num_images: GptTextToImageNumImages,
   pub quality: GptTextToImageQuality,
-  
+
   // Fulfillment
   pub api_key: &'a FalApiKey,
   pub openai_api_key: &'a OpenAiApiKey,
@@ -80,7 +80,7 @@ pub async fn enqueue_gpt_image_1_text_to_image_webhook<V: IntoUrl>(
     GptTextToImageSize::Horizontal => "1536x1024",
     GptTextToImageSize::Vertical => "1024x1536",
   };
-  
+
   let quality = match args.quality {
     GptTextToImageQuality::Auto => "auto",
     GptTextToImageQuality::Low => "low",
@@ -116,7 +116,7 @@ pub async fn enqueue_gpt_image_1_text_to_image_webhook<V: IntoUrl>(
 mod tests {
   use crate::creds::fal_api_key::FalApiKey;
   use crate::creds::open_ai_api_key::OpenAiApiKey;
-  use crate::requests::webhook::image::enqueue_gpt_image_1_text_to_image_webhook::{enqueue_gpt_image_1_text_to_image_webhook, GptTextToImageByokArgs, GptTextToImageNumImages, GptTextToImageQuality, GptTextToImageSize};
+  use crate::requests::webhook::image::text::enqueue_gpt_image_1_text_to_image_webhook::{enqueue_gpt_image_1_text_to_image_webhook, GptTextToImageByokArgs, GptTextToImageNumImages, GptTextToImageQuality, GptTextToImageSize};
   use errors::AnyhowResult;
   use std::fs::read_to_string;
 

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_nano_banana_2_text_to_image_webhook.rs

@@ -0,0 +1,173 @@
+use crate::creds::fal_api_key::FalApiKey;
+use crate::error::classify_fal_error::classify_fal_error;
+use crate::error::fal_error_plus::FalErrorPlus;
+use crate::requests::http::image::http_nano_banana_2_text_to_image::{nano_banana_2_text_to_image, NanoBanana2TextToImageInput};
+use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
+use fal::webhook::WebhookResponse;
+use reqwest::IntoUrl;
+
+pub struct EnqueueNanoBanana2TextToImageArgs<'a, R: IntoUrl> {
+  // Request required
+  pub prompt: &'a str,
+  pub num_images: EnqueueNanoBanana2TextToImageNumImages,
+
+  // Optional args
+  pub resolution: Option<EnqueueNanoBanana2TextToImageResolution>,
+  pub aspect_ratio: Option<EnqueueNanoBanana2TextToImageAspectRatio>,
+
+  // Fulfillment
+  pub webhook_url: R,
+  pub api_key: &'a FalApiKey,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2TextToImageNumImages {
+  One,
+  Two,
+  Three,
+  Four,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2TextToImageResolution {
+  HalfK, // "0.5K"
+  OneK,  // "1K" (default)
+  TwoK,  // "2K"
+  FourK, // "4K"
+}
+
+/// auto, 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+/// Default: "auto"
+#[derive(Copy, Clone, Debug)]
+pub enum EnqueueNanoBanana2TextToImageAspectRatio {
+  // Automatic (default)
+  Auto,
+  // Square
+  OneByOne,
+  // Wide
+  FiveByFour,
+  FourByThree,
+  ThreeByTwo,
+  SixteenByNine,
+  TwentyOneByNine,
+  // Tall
+  FourByFive,
+  ThreeByFour,
+  TwoByThree,
+  NineBySixteen,
+}
+
+
+impl <U: IntoUrl> FalRequestCostCalculator for EnqueueNanoBanana2TextToImageArgs<'_, U> {
+  fn calculate_cost_in_cents(&self) -> UsdCents {
+    // TODO(bt): Verify actual pricing for Nano Banana 2 on fal.ai.
+    // 4K outputs may be charged at double the standard rate.
+    let cost = match self.resolution {
+      None => 15,
+      Some(EnqueueNanoBanana2TextToImageResolution::HalfK) => 8,
+      Some(EnqueueNanoBanana2TextToImageResolution::OneK) => 15,
+      Some(EnqueueNanoBanana2TextToImageResolution::TwoK) => 15,
+      Some(EnqueueNanoBanana2TextToImageResolution::FourK) => 30,
+    };
+    let cost = match self.num_images {
+      EnqueueNanoBanana2TextToImageNumImages::One => cost,
+      EnqueueNanoBanana2TextToImageNumImages::Two => cost * 2,
+      EnqueueNanoBanana2TextToImageNumImages::Three => cost * 3,
+      EnqueueNanoBanana2TextToImageNumImages::Four => cost * 4,
+    };
+    cost as UsdCents
+  }
+}
+
+
+pub async fn enqueue_nano_banana_2_text_to_image_webhook<R: IntoUrl>(
+  args: EnqueueNanoBanana2TextToImageArgs<'_, R>
+) -> Result<WebhookResponse, FalErrorPlus> {
+
+  let num_images = match args.num_images {
+    EnqueueNanoBanana2TextToImageNumImages::One => 1,
+    EnqueueNanoBanana2TextToImageNumImages::Two => 2,
+    EnqueueNanoBanana2TextToImageNumImages::Three => 3,
+    EnqueueNanoBanana2TextToImageNumImages::Four => 4,
+  };
+
+  let resolution = args.resolution
+      .map(|resolution| match resolution {
+        EnqueueNanoBanana2TextToImageResolution::HalfK => "0.5K",
+        EnqueueNanoBanana2TextToImageResolution::OneK => "1K",
+        EnqueueNanoBanana2TextToImageResolution::TwoK => "2K",
+        EnqueueNanoBanana2TextToImageResolution::FourK => "4K",
+      })
+      .map(|r| r.to_string());
+
+  let aspect_ratio = args.aspect_ratio
+      .map(|ar| match ar {
+        // Auto
+        EnqueueNanoBanana2TextToImageAspectRatio::Auto => "auto",
+        // Square
+        EnqueueNanoBanana2TextToImageAspectRatio::OneByOne => "1:1",
+        // Wide
+        EnqueueNanoBanana2TextToImageAspectRatio::FiveByFour => "5:4",
+        EnqueueNanoBanana2TextToImageAspectRatio::FourByThree => "4:3",
+        EnqueueNanoBanana2TextToImageAspectRatio::ThreeByTwo => "3:2",
+        EnqueueNanoBanana2TextToImageAspectRatio::SixteenByNine => "16:9",
+        EnqueueNanoBanana2TextToImageAspectRatio::TwentyOneByNine => "21:9",
+        // Tall
+        EnqueueNanoBanana2TextToImageAspectRatio::FourByFive => "4:5",
+        EnqueueNanoBanana2TextToImageAspectRatio::ThreeByFour => "3:4",
+        EnqueueNanoBanana2TextToImageAspectRatio::TwoByThree => "2:3",
+        EnqueueNanoBanana2TextToImageAspectRatio::NineBySixteen => "9:16",
+      })
+      .map(|ar| ar.to_string());
+
+  let request = NanoBanana2TextToImageInput {
+    prompt: args.prompt.to_string(),
+    num_images: Some(num_images),
+    // Optionals
+    aspect_ratio,
+    resolution,
+    // Constants
+    output_format: Some("png".to_string()),
+    limit_generations: None,
+    safety_tolerance: Some("6".to_string()),
+    enable_web_search: None,
+    seed: None,
+  };
+
+  let result = nano_banana_2_text_to_image(request)
+      .with_api_key(&args.api_key.0)
+      .queue_webhook(args.webhook_url)
+      .await;
+
+  result.map_err(|err| classify_fal_error(err))
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::creds::fal_api_key::FalApiKey;
+  use crate::requests::webhook::image::text::enqueue_nano_banana_2_text_to_image_webhook::{enqueue_nano_banana_2_text_to_image_webhook, EnqueueNanoBanana2TextToImageArgs, EnqueueNanoBanana2TextToImageAspectRatio, EnqueueNanoBanana2TextToImageNumImages, EnqueueNanoBanana2TextToImageResolution};
+  use errors::AnyhowResult;
+  use std::fs::read_to_string;
+
+  #[tokio::test]
+  #[ignore]
+  async fn test() -> AnyhowResult<()> {
+    // XXX: Don't commit secrets!
+    let secret = read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")?;
+
+    let api_key = FalApiKey::from_str(&secret);
+
+    let args = EnqueueNanoBanana2TextToImageArgs {
+      prompt: "an anime girl riding on the back of a t-rex",
+      num_images: EnqueueNanoBanana2TextToImageNumImages::One,
+      aspect_ratio: Some(EnqueueNanoBanana2TextToImageAspectRatio::SixteenByNine),
+      resolution: Some(EnqueueNanoBanana2TextToImageResolution::TwoK),
+      api_key: &api_key,
+      webhook_url: "https://example.com/webhook",
+    };
+
+    let result = enqueue_nano_banana_2_text_to_image_webhook(args).await?;
+
+    Ok(())
+  }
+}

crates/api_clients/fal_client/src/requests/webhook/image/text/mod.rs

@@ -1,5 +1,12 @@
 pub mod enqueue_bytedance_seedream_v4_text_to_image_webhook;
 pub mod enqueue_bytedance_seedream_v4p5_text_to_image_webhook;
+pub mod enqueue_bytedance_seedream_v5_lite_text_to_image_webhook;
+pub mod enqueue_nano_banana_2_text_to_image_webhook;
+pub mod enqueue_flux_1_dev_text_to_image_webhook;
+pub mod enqueue_flux_1_schnell_text_to_image_webhook;
+pub mod enqueue_flux_pro_11_text_to_image_webhook;
+pub mod enqueue_flux_pro_11_ultra_text_to_image_webhook;
 pub mod enqueue_gemini_25_flash_text_to_image_webhook;
+pub mod enqueue_gpt_image_1_text_to_image_webhook;
 pub mod enqueue_gpt_image_1p5_text_to_image_webhook;
 pub mod enqueue_nano_banana_pro_text_to_image_webhook;

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_artcraft_gpt_image_1p5_edit.rs

@@ -1,150 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_gpt_image_1::aspect_ratio_to_artcraft_gpt_image_1;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_gpt_image_1p5::aspect_ratio_to_artcraft_gpt_image_1p5;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana_pro::aspect_ratio_to_artcraft_nano_banana_pro;
-use crate::core::commands::enqueue::generate_error::{BadInputReason, GenerateError};
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use anyhow::anyhow;
-use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality, GptImage1p5MultiFunctionImageGenRequest, GptImage1p5MultiFunctionImageGenSize};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::edit::gpt_image_1_edit_image::gpt_image_1_edit_image;
-use artcraft_client::endpoints::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen_image::gpt_image_1p5_multi_function_image_gen;
-use tauri::AppHandle;
-
-const MAX_IMAGES: usize = 4;
-
-pub async fn handle_artcraft_gpt_image_1p5_edit(
-  request: &EnqueueEditImageCommand,
-  app: &AppHandle,
-  app_data_root: &AppDataRoot,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft gpt-image-1.5 (edit) ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let image_quality = request.image_quality
-      .map(|quality| match quality {
-        EditImageQuality::Auto => GptImage1p5MultiFunctionImageGenQuality::High,
-        EditImageQuality::High => GptImage1p5MultiFunctionImageGenQuality::High,
-        EditImageQuality::Medium => GptImage1p5MultiFunctionImageGenQuality::Medium,
-        EditImageQuality::Low => GptImage1p5MultiFunctionImageGenQuality::Low,
-      });
-  
-  let image_size = get_aspect_ratio(request);
-
-  let num_images = match request.image_count {
-    None => None,
-    Some(1) => Some(GptImage1p5MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(GptImage1p5MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(GptImage1p5MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(GptImage1p5MultiFunctionImageGenNumImages::Four),
-    Some(other) => {
-      return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfRequestedImages {
-        min: 1,
-        max: 4,
-        requested: other,
-      }));
-    },
-  };
-  
-  let mut media_tokens = Vec::with_capacity(10);
-  
-  if let Some(scene_image_media_token) = request.scene_image_media_token.clone() {
-    media_tokens.push(scene_image_media_token);
-  }
-  
-  if let Some(image_media_tokens) = request.image_media_tokens.as_ref() {
-    media_tokens.extend_from_slice(image_media_tokens);
-  }
-  
-  if media_tokens.len() > MAX_IMAGES {
-    return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfInputImages { 
-      min: 1,
-      max: MAX_IMAGES as u32,
-      provided: media_tokens.len() as u32,
-    }));
-  }
-
-  let request = GptImage1p5MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: Some(request.prompt.clone()),
-    image_media_tokens: Some(media_tokens),
-    quality: image_quality,
-    image_size,
-    num_images,
-    // Only for inpainting
-    mask_image_token: None,
-    // Not provided
-    input_fidelity: None,
-    output_format: None,
-    background: None,
-  };
-
-  let result = gpt_image_1p5_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_id = match result {
-    Ok(enqueued) => {
-      // TODO(bt,2025-07-05): Enqueue job token?
-      info!("Successfully enqueued Artcraft gpt-image-1.5. Job token: {}", 
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft gpt-image-1.5: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-  
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::GptImage1p5),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueEditImageCommand) -> Option<GptImage1p5MultiFunctionImageGenSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_gpt_image_1p5(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    return match aspect_ratio {
-      EditImageSize::Auto => Some(GptImage1p5MultiFunctionImageGenSize::Square),
-      EditImageSize::Square => Some(GptImage1p5MultiFunctionImageGenSize::Square),
-      EditImageSize::Wide => Some(GptImage1p5MultiFunctionImageGenSize::Wide),
-      EditImageSize::Tall => Some(GptImage1p5MultiFunctionImageGenSize::Tall),
-    }
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_artcraft_nano_banana_edit.rs

@@ -1,141 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana::aspect_ratio_to_artcraft_nano_banana;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana_pro::aspect_ratio_to_artcraft_nano_banana_pro;
-use crate::core::commands::enqueue::generate_error::{BadInputReason, GenerateError};
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use anyhow::anyhow;
-use artcraft_api_defs::generate::image::edit::flux_pro_kontext_max_edit_image::{FluxProKontextMaxEditImageNumImages, FluxProKontextMaxEditImageRequest};
-use artcraft_api_defs::generate::image::edit::gemini_25_flash_edit_image::{Gemini25FlashEditImageNumImages, Gemini25FlashEditImageRequest};
-use artcraft_api_defs::generate::image::edit::gpt_image_1_edit_image::{GptImage1EditImageImageQuality, GptImage1EditImageImageSize, GptImage1EditImageNumImages, GptImage1EditImageRequest};
-use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{NanoBananaMultiFunctionImageGenAspectRatio, NanoBananaMultiFunctionImageGenNumImages, NanoBananaMultiFunctionImageGenRequest};
-use artcraft_api_defs::generate::image::multi_function::nano_banana_pro_multi_function_image_gen::{NanoBananaProMultiFunctionImageGenAspectRatio, NanoBananaProMultiFunctionImageGenRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::edit::flux_pro_kontext_max_edit_image::flux_pro_kontext_max_edit_image;
-use artcraft_client::endpoints::generate::image::edit::gemini_25_flash_edit_image::gemini_25_flash_edit_image;
-use artcraft_client::endpoints::generate::image::edit::gpt_image_1_edit_image::gpt_image_1_edit_image;
-use artcraft_client::endpoints::generate::image::multi_function::nano_banana_multi_function_image_gen_image::nano_banana_multi_function_image_gen;
-use artcraft_client::endpoints::generate::image::multi_function::nano_banana_pro_multi_function_image_gen_image::nano_banana_pro_multi_function_image_gen;
-use tauri::AppHandle;
-
-pub(super) const MAX_IMAGES: usize = 10;
-
-pub async fn handle_artcraft_nano_banana_edit(
-  request: &EnqueueEditImageCommand,
-  app: &AppHandle,
-  app_data_root: &AppDataRoot,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft Nano Banana (edit) ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let aspect_ratio = get_aspect_ratio(request);
-
-  let num_images = match request.image_count {
-    None => None,
-    Some(1) => Some(NanoBananaMultiFunctionImageGenNumImages::One),
-    Some(2) => Some(NanoBananaMultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(NanoBananaMultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(NanoBananaMultiFunctionImageGenNumImages::Four),
-    Some(other) => {
-      return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfRequestedImages {
-        min: 1,
-        max: 4,
-        requested: other,
-      }));
-    },
-  };
-
-  let mut media_tokens = Vec::with_capacity(10);
-
-  if let Some(scene_image_media_token) = request.scene_image_media_token.clone() {
-    media_tokens.push(scene_image_media_token);
-  }
-
-  if let Some(image_media_tokens) = request.image_media_tokens.as_ref() {
-    media_tokens.extend_from_slice(image_media_tokens);
-  }
-
-  if media_tokens.len() > MAX_IMAGES {
-    return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfInputImages {
-      min: 1,
-      max: MAX_IMAGES as u32,
-      provided: media_tokens.len() as u32, 
-    }));
-  }
-
-  let request = NanoBananaMultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: Some(request.prompt.clone()),
-    image_media_tokens: Some(media_tokens),
-    num_images,
-    aspect_ratio,
-  };
-
-  let result = nano_banana_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_id = match result {
-    Ok(enqueued) => {
-      // TODO(bt,2025-07-05): Enqueue job token?
-      info!("Successfully enqueued Artcraft Nano Banana. Job token: {}",
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Nano Banana: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-  
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::Gemini25Flash),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueEditImageCommand) -> Option<NanoBananaMultiFunctionImageGenAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_nano_banana(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    return match aspect_ratio {
-      EditImageSize::Auto => Some(NanoBananaMultiFunctionImageGenAspectRatio::Auto),
-      EditImageSize::Square => Some(NanoBananaMultiFunctionImageGenAspectRatio::OneByOne),
-      EditImageSize::Wide => Some(NanoBananaMultiFunctionImageGenAspectRatio::SixteenByNine),
-      EditImageSize::Tall => Some(NanoBananaMultiFunctionImageGenAspectRatio::NineBySixteen),
-    }
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_artcraft_seedream_4_edit.rs

@@ -1,137 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana_pro::aspect_ratio_to_artcraft_nano_banana_pro;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_seedream_4::aspect_ratio_to_artcraft_seedream_4;
-use crate::core::commands::enqueue::generate_error::{BadInputReason, GenerateError};
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use anyhow::anyhow;
-use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{BytedanceSeedreamV4MultiFunctionImageGenImageSize, BytedanceSeedreamV4MultiFunctionImageGenNumImages, BytedanceSeedreamV4MultiFunctionImageGenRequest};
-use artcraft_api_defs::generate::image::multi_function::nano_banana_pro_multi_function_image_gen::NanoBananaProMultiFunctionImageGenAspectRatio;
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen_image::bytedance_seedream_v4_multi_function_image_gen;
-use tauri::AppHandle;
-
-const MAX_IMAGES: usize = 4;
-
-pub async fn handle_artcraft_seedream_4_edit(
-  request: &EnqueueEditImageCommand,
-  app: &AppHandle,
-  app_data_root: &AppDataRoot,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft seedream 4 (edit) ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let image_size = get_aspect_ratio(request);
-
-  let num_images = match request.image_count {
-    None => None,
-    Some(1) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Four),
-    Some(other) => {
-      return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfRequestedImages {
-        min: 1,
-        max: 4,
-        requested: other,
-      }));
-    },
-  };
-  
-  let mut media_tokens = Vec::with_capacity(10);
-  
-  if let Some(scene_image_media_token) = request.scene_image_media_token.clone() {
-    media_tokens.push(scene_image_media_token);
-  }
-  
-  if let Some(image_media_tokens) = request.image_media_tokens.as_ref() {
-    media_tokens.extend_from_slice(image_media_tokens);
-  }
-  
-  if media_tokens.len() > MAX_IMAGES {
-    return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfInputImages { 
-      min: 1,
-      max: MAX_IMAGES as u32,
-      provided: media_tokens.len() as u32,
-    }));
-  }
-
-  let request = BytedanceSeedreamV4MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: Some(request.prompt.clone()),
-    image_media_tokens: Some(media_tokens),
-    image_size,
-    num_images,
-    // Not provided
-    max_images: None,
-  };
-
-  let result = bytedance_seedream_v4_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_id = match result {
-    Ok(enqueued) => {
-      // TODO(bt,2025-07-05): Enqueue job token?
-      info!("Successfully enqueued Artcraft seedream 4. Job token: {}", 
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft seedream 4: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-  
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::Seedream4),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueEditImageCommand) -> Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_seedream_4(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect_ratio = match aspect_ratio {
-      EditImageSize::Auto => BytedanceSeedreamV4MultiFunctionImageGenImageSize::Square,
-      EditImageSize::Square => BytedanceSeedreamV4MultiFunctionImageGenImageSize::Square,
-      EditImageSize::Tall => BytedanceSeedreamV4MultiFunctionImageGenImageSize::PortraitSixteenNine,
-      EditImageSize::Wide => BytedanceSeedreamV4MultiFunctionImageGenImageSize::LandscapeSixteenNine,
-    };
-    return Some(aspect_ratio);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_artcraft_seedream_4p5_edit.rs

@@ -1,136 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_seedream_4::aspect_ratio_to_artcraft_seedream_4;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_seedream_4p5::aspect_ratio_to_artcraft_seedream_4p5;
-use crate::core::commands::enqueue::generate_error::{BadInputReason, GenerateError};
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use anyhow::anyhow;
-use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{BytedanceSeedreamV4p5MultiFunctionImageGenImageSize, BytedanceSeedreamV4p5MultiFunctionImageGenNumImages, BytedanceSeedreamV4p5MultiFunctionImageGenRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen_image::bytedance_seedream_v4p5_multi_function_image_gen;
-use tauri::AppHandle;
-
-const MAX_IMAGES: usize = 4;
-
-pub async fn handle_artcraft_seedream_4p5_edit(
-  request: &EnqueueEditImageCommand,
-  app: &AppHandle,
-  app_data_root: &AppDataRoot,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft seedream 4.5 (edit) ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let image_size = get_aspect_ratio(request);
-
-  let num_images = match request.image_count {
-    None => None,
-    Some(1) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Four),
-    Some(other) => {
-      return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfRequestedImages {
-        min: 1,
-        max: 4,
-        requested: other,
-      }));
-    },
-  };
-  
-  let mut media_tokens = Vec::with_capacity(10);
-  
-  if let Some(scene_image_media_token) = request.scene_image_media_token.clone() {
-    media_tokens.push(scene_image_media_token);
-  }
-  
-  if let Some(image_media_tokens) = request.image_media_tokens.as_ref() {
-    media_tokens.extend_from_slice(image_media_tokens);
-  }
-  
-  if media_tokens.len() > MAX_IMAGES {
-    return Err(GenerateError::BadInput(BadInputReason::InvalidNumberOfInputImages { 
-      min: 1,
-      max: MAX_IMAGES as u32,
-      provided: media_tokens.len() as u32,
-    }));
-  }
-
-  let request = BytedanceSeedreamV4p5MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: Some(request.prompt.clone()),
-    image_media_tokens: Some(media_tokens),
-    image_size,
-    num_images,
-    // Not provided
-    max_images: None,
-  };
-
-  let result = bytedance_seedream_v4p5_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_id = match result {
-    Ok(enqueued) => {
-      // TODO(bt,2025-07-05): Enqueue job token?
-      info!("Successfully enqueued Artcraft seedream 4.5. Job token: {}",
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft seedream 4.5: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-  
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::Seedream4p5),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueEditImageCommand) -> Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_seedream_4p5(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect_ratio = match aspect_ratio {
-      EditImageSize::Auto => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::Square,
-      EditImageSize::Square => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::Square,
-      EditImageSize::Tall => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::PortraitSixteenNine,
-      EditImageSize::Wide => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::LandscapeSixteenNine,
-    };
-    return Some(aspect_ratio);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_image_edit_artcraft.rs

@@ -1,11 +1,7 @@
 use crate::core::commands::enqueue::generate_error::GenerateError;
 use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_flux_kontext_edit::handle_artcraft_flux_kontext_edit;
 use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_gpt_image_1_edit::handle_artcraft_gpt_image_1_edit;
-use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_gpt_image_1p5_edit::handle_artcraft_gpt_image_1p5_edit;
-use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_nano_banana_edit::handle_artcraft_nano_banana_edit;
 use crate::core::commands::enqueue::image_edit::artcraft::handle_image_edit_artcraft_via_router::handle_image_edit_artcraft_via_router;
-use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_seedream_4_edit::handle_artcraft_seedream_4_edit;
-use crate::core::commands::enqueue::image_edit::artcraft::handle_artcraft_seedream_4p5_edit::handle_artcraft_seedream_4p5_edit;
 use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EnqueueEditImageCommand, ImageEditModel};
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
 use crate::core::events::generation_events::common::GenerationModel;
@@ -27,12 +23,14 @@ pub async fn handle_image_edit_artcraft(
   match model {
     ImageEditModel::FluxProKontextMax => handle_artcraft_flux_kontext_edit(request, app, app_data_root, app_env_configs, storyteller_creds_manager).await,
     ImageEditModel::Gemini25Flash | ImageEditModel::NanoBanana => {
-      handle_artcraft_nano_banana_edit( request, app, app_data_root, app_env_configs, storyteller_creds_manager).await
+      handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBanana, GenerationModel::NanoBanana).await
     },
+    ImageEditModel::NanoBanana2 => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBanana2, GenerationModel::NanoBanana2).await,
     ImageEditModel::NanoBananaPro => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBananaPro, GenerationModel::NanoBananaPro).await,
     ImageEditModel::GptImage1 => handle_artcraft_gpt_image_1_edit(request, app, app_data_root, app_env_configs, storyteller_creds_manager).await,
-    ImageEditModel::GptImage1p5 => handle_artcraft_gpt_image_1p5_edit(request, app, app_data_root, app_env_configs, storyteller_creds_manager).await,
-    ImageEditModel::Seedream4 => handle_artcraft_seedream_4_edit(request, app, app_data_root, app_env_configs, storyteller_creds_manager).await,
-    ImageEditModel::Seedream4p5 => handle_artcraft_seedream_4p5_edit(request, app, app_data_root, app_env_configs, storyteller_creds_manager).await,
+    ImageEditModel::GptImage1p5 => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::GptImage1p5, GenerationModel::GptImage1p5).await,
+    ImageEditModel::Seedream4 => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream4, GenerationModel::Seedream4).await,
+    ImageEditModel::Seedream4p5 => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream4p5, GenerationModel::Seedream4p5).await,
+    ImageEditModel::Seedream5Lite => handle_image_edit_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream5Lite, GenerationModel::Seedream5Lite).await,
   }
 }

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/handle_image_edit_artcraft_via_router.rs

@@ -74,6 +74,7 @@ pub(super) async fn handle_image_edit_artcraft_via_router(
     aspect_ratio,
     image_batch_count: request.image_count.map(|n| n as u16),
     request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+    generation_mode_mismatch_strategy: None,
     idempotency_token: None,
   };
 

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/artcraft/mod.rs

@@ -1,9 +1,5 @@
 mod handle_image_edit_artcraft_via_router;
 mod handle_artcraft_flux_kontext_edit;
 mod handle_artcraft_gpt_image_1_edit;
-mod handle_artcraft_gpt_image_1p5_edit;
-mod handle_artcraft_nano_banana_edit;
-mod handle_artcraft_seedream_4_edit;
-mod handle_artcraft_seedream_4p5_edit;
 
 pub (super) mod handle_image_edit_artcraft;

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/enqueue_edit_image_command.rs

@@ -60,24 +60,30 @@ pub enum ImageEditModel {
   #[serde(rename = "nano_banana")]
   NanoBanana,
 
+  #[serde(rename = "nano_banana_2")]
+  NanoBanana2,
+
   #[serde(rename = "nano_banana_pro")]
   NanoBananaPro,
 
   #[serde(rename = "gpt_image_1")]
   GptImage1,
-  
+
   #[serde(rename = "gpt_image_1p5")]
   GptImage1p5,
-  
+
   #[serde(rename = "seedream_4")]
   Seedream4,
-  
+
   #[serde(rename = "seedream_4p5")]
   Seedream4p5,
-  
+
+  #[serde(rename = "seedream_5_lite")]
+  Seedream5Lite,
+
 //  #[serde(rename = "qwen")]
 //  Qwen,
-//  
+//
 //  #[serde(rename = "seededit_3")]
 //  SeedEdit3,
 }

crates/desktop/artcraft/src/core/commands/enqueue/image_edit/image_edit_models.rs

@@ -6,10 +6,12 @@ pub fn image_edit_model_to_model_type(model: ImageEditModel) -> ModelType {
     ImageEditModel::FluxProKontextMax => ModelType::FluxProKontextMax,
     ImageEditModel::Gemini25Flash => ModelType::NanoBanana,
     ImageEditModel::NanoBanana => ModelType::NanoBanana,
+    ImageEditModel::NanoBanana2 => ModelType::NanoBanana2,
     ImageEditModel::NanoBananaPro => ModelType::NanoBananaPro,
     ImageEditModel::GptImage1 => ModelType::GptImage1,
     ImageEditModel::GptImage1p5 => ModelType::GptImage1p5,
     ImageEditModel::Seedream4 => ModelType::Seedream4,
     ImageEditModel::Seedream4p5 => ModelType::Seedream4p5,
+    ImageEditModel::Seedream5Lite => ModelType::Seedream5Lite,
   }
 }

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_flux_1_dev_text_to_image.rs

@@ -1,91 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_1_dev::aspect_ratio_to_artcraft_flux_1_dev;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana_pro::aspect_ratio_to_artcraft_nano_banana_pro;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::generation_events::common::GenerationModel;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::multi_function::nano_banana_pro_multi_function_image_gen::NanoBananaProMultiFunctionImageGenAspectRatio;
-use artcraft_api_defs::generate::image::text::generate_flux_1_dev_text_to_image::{GenerateFlux1DevTextToImageAspectRatio, GenerateFlux1DevTextToImageNumImages, GenerateFlux1DevTextToImageRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::text::generate_flux_1_dev_text_to_image::generate_flux_1_dev_text_to_image;
-
-pub async fn handle_artcraft_flux_1_dev_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("enqueue Flux 1 Dev");
-  
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let request = GenerateFlux1DevTextToImageRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    aspect_ratio: get_aspect_ratio(request),
-    num_images: request.number_images
-        .and_then(|num| match num {
-          1 => Some(GenerateFlux1DevTextToImageNumImages::One),
-          2 => Some(GenerateFlux1DevTextToImageNumImages::Two),
-          3 => Some(GenerateFlux1DevTextToImageNumImages::Three),
-          4 => Some(GenerateFlux1DevTextToImageNumImages::Four),
-          _ => None, // NB: use service defaults
-        }),
-  };
-
-  let result = generate_flux_1_dev_text_to_image(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-
-  let job_token = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft Flux 1 Dev text to image generation");
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Flux 1 Dev text to image generation: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    task_type: TaskType::ImageGeneration,
-    model: Some(GenerationModel::Flux1Dev),
-    provider_job_id: Some(job_token.to_string()),
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<GenerateFlux1DevTextToImageAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_flux_1_dev(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect = match aspect_ratio {
-      TextToImageSize::Tall => GenerateFlux1DevTextToImageAspectRatio::PortraitNineBySixteen,
-      TextToImageSize::Wide => GenerateFlux1DevTextToImageAspectRatio::LandscapeSixteenByNine,
-      TextToImageSize::Auto => GenerateFlux1DevTextToImageAspectRatio::SquareHd,
-      TextToImageSize::Square => GenerateFlux1DevTextToImageAspectRatio::SquareHd,
-    };
-    return Some(aspect);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_flux_1_schnell_text_to_image.rs

@@ -1,90 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_1_dev::aspect_ratio_to_artcraft_flux_1_dev;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_1_schnell::aspect_ratio_to_artcraft_flux_1_schnell;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::generation_events::common::GenerationModel;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::text::generate_flux_1_schnell_text_to_image::{GenerateFlux1SchnellTextToImageAspectRatio, GenerateFlux1SchnellTextToImageNumImages, GenerateFlux1SchnellTextToImageRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::text::generate_flux_1_schnell_text_to_image::generate_flux_1_schnell_text_to_image;
-
-pub async fn handle_artcraft_flux_1_schnell_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("enqueue Flux 1 Schnell");
-  
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let request = GenerateFlux1SchnellTextToImageRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    aspect_ratio: get_aspect_ratio(request),
-    num_images: request.number_images
-        .and_then(|num| match num {
-          1 => Some(GenerateFlux1SchnellTextToImageNumImages::One),
-          2 => Some(GenerateFlux1SchnellTextToImageNumImages::Two),
-          3 => Some(GenerateFlux1SchnellTextToImageNumImages::Three),
-          4 => Some(GenerateFlux1SchnellTextToImageNumImages::Four),
-          _ => None, // NB: use service defaults
-        }),
-  };
-  
-  let result = generate_flux_1_schnell_text_to_image(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_token = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft Flux 1 Schnell text to image generation");
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Flux 1 Schnell text to image generation: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    task_type: TaskType::ImageGeneration,
-    model: Some(GenerationModel::Flux1Schnell),
-    provider_job_id: Some(job_token.to_string()),
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<GenerateFlux1SchnellTextToImageAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_flux_1_schnell(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect = match aspect_ratio {
-      TextToImageSize::Tall => GenerateFlux1SchnellTextToImageAspectRatio::PortraitNineBySixteen,
-      TextToImageSize::Wide => GenerateFlux1SchnellTextToImageAspectRatio::LandscapeSixteenByNine,
-      TextToImageSize::Auto => GenerateFlux1SchnellTextToImageAspectRatio::SquareHd,
-      TextToImageSize::Square => GenerateFlux1SchnellTextToImageAspectRatio::SquareHd,
-    };
-    return Some(aspect);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_flux_pro_1p1_text_to_image.rs

@@ -1,90 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_1_schnell::aspect_ratio_to_artcraft_flux_1_schnell;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_pro_1p1::aspect_ratio_to_artcraft_flux_pro_1p1;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::generation_events::common::GenerationModel;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::text::generate_flux_pro_11_text_to_image::{GenerateFluxPro11TextToImageAspectRatio, GenerateFluxPro11TextToImageNumImages, GenerateFluxPro11TextToImageRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_text_to_image::generate_flux_pro_11_text_to_image;
-
-pub async fn handle_artcraft_flux_pro_1p1_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("enqueue Flux Pro 1.1");
-
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let request = GenerateFluxPro11TextToImageRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    aspect_ratio: get_aspect_ratio(request),
-    num_images: request.number_images
-        .and_then(|num| match num {
-          1 => Some(GenerateFluxPro11TextToImageNumImages::One),
-          2 => Some(GenerateFluxPro11TextToImageNumImages::Two),
-          3 => Some(GenerateFluxPro11TextToImageNumImages::Three),
-          4 => Some(GenerateFluxPro11TextToImageNumImages::Four),
-          _ => None, // NB: use service defaults
-        }),
-  };
-  
-  let result = generate_flux_pro_11_text_to_image(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_token = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft Flux Pro 1.1 text to image generation");
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Flux Pro 1.1 text to image generation: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    task_type: TaskType::ImageGeneration,
-    model: Some(GenerationModel::FluxPro11),
-    provider_job_id: Some(job_token.to_string()),
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<GenerateFluxPro11TextToImageAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_flux_pro_1p1(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect = match aspect_ratio {
-      TextToImageSize::Tall => GenerateFluxPro11TextToImageAspectRatio::PortraitNineBySixteen,
-      TextToImageSize::Wide => GenerateFluxPro11TextToImageAspectRatio::LandscapeSixteenByNine,
-      TextToImageSize::Square => GenerateFluxPro11TextToImageAspectRatio::Square,
-      TextToImageSize::Auto => GenerateFluxPro11TextToImageAspectRatio::Square,
-    };
-    return Some(aspect);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_flux_pro_1p1_ultra_text_to_image.rs

@@ -1,91 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_pro_1p1::aspect_ratio_to_artcraft_flux_pro_1p1;
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_flux_pro_1p1_ultra::aspect_ratio_to_artcraft_flux_pro_1p1_ultra;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::generation_events::common::GenerationModel;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::text::generate_flux_pro_11_ultra_text_to_image::{GenerateFluxPro11UltraTextToImageAspectRatio, GenerateFluxPro11UltraTextToImageNumImages, GenerateFluxPro11UltraTextToImageRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use artcraft_client::endpoints::generate::image::text::generate_flux_pro_11_ultra_text_to_image::generate_flux_pro_11_ultra_text_to_image;
-
-pub async fn handle_artcraft_flux_pro_1p1_ultra_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("enqueue Flux Pro 1.1 Ultra");
-
-  let uuid_idempotency_token = generate_random_uuid();
-  
-  let request = GenerateFluxPro11UltraTextToImageRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    aspect_ratio: get_aspect_ratio(request),
-    num_images: request.number_images
-        .and_then(|num| match num {
-          1 => Some(GenerateFluxPro11UltraTextToImageNumImages::One),
-          2 => Some(GenerateFluxPro11UltraTextToImageNumImages::Two),
-          3 => Some(GenerateFluxPro11UltraTextToImageNumImages::Three),
-          4 => Some(GenerateFluxPro11UltraTextToImageNumImages::Four),
-          _ => None, // NB: use service defaults
-        }),
-  };
-  
-  let result = generate_flux_pro_11_ultra_text_to_image(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-  
-  let job_token = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft Flux Pro 1.1 Ultra text to image generation");
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Flux Pro 1.1 Ultra text to image generation: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    task_type: TaskType::ImageGeneration,
-    model: Some(GenerationModel::FluxPro11Ultra),
-    provider_job_id: Some(job_token.to_string()),
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<GenerateFluxPro11UltraTextToImageAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_flux_pro_1p1_ultra(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect = match aspect_ratio {
-      TextToImageSize::Tall => GenerateFluxPro11UltraTextToImageAspectRatio::PortraitNineBySixteen,
-      TextToImageSize::Wide => GenerateFluxPro11UltraTextToImageAspectRatio::LandscapeSixteenByNine,
-      TextToImageSize::Square => GenerateFluxPro11UltraTextToImageAspectRatio::Square,
-      TextToImageSize::Auto => GenerateFluxPro11UltraTextToImageAspectRatio::Square,
-    };
-    return Some(aspect);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_gpt_image_1p5_text_to_image.rs

@@ -1,118 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_gpt_image_1p5::aspect_ratio_to_artcraft_gpt_image_1p5;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen::{GptImage1p5MultiFunctionImageGenNumImages, GptImage1p5MultiFunctionImageGenQuality, GptImage1p5MultiFunctionImageGenRequest, GptImage1p5MultiFunctionImageGenSize};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use std::time::Duration;
-use artcraft_client::endpoints::generate::image::multi_function::gpt_image_1p5_multi_function_image_gen_image::gpt_image_1p5_multi_function_image_gen;
-use tauri::AppHandle;
-
-pub async fn handle_artcraft_gpt_image_1p5_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft gpt-image-1.5 ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let aspect_ratio = get_aspect_ratio(request);
-
-  let num_images = match request.number_images {
-    None => None,
-    Some(1) => Some(GptImage1p5MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(GptImage1p5MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(GptImage1p5MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(GptImage1p5MultiFunctionImageGenNumImages::Four),
-    // TODO: Error
-    //Some(other) => {
-    //  return Err(InternalImageError::InvalidNumberOfRequestedImages {
-    //    min: 1,
-    //    max: 4,
-    //    requested: other,
-    //  });
-    //},
-    _ => Some(GptImage1p5MultiFunctionImageGenNumImages::One), // Default to one image if invalid number
-  };
-
-  let request = GptImage1p5MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    image_size: aspect_ratio,
-    num_images,
-    image_media_tokens: request.image_media_tokens.clone(),
-    mask_image_token: None,
-    input_fidelity: None,
-    // Not provided
-    output_format: None,
-    background: None,
-    quality: None,
-  };
-
-  let result = gpt_image_1p5_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-
-  let job_id = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft gpt-image-1.5. Job token: {}", 
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft gpt-image-1.5: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::GptImage1p5),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<GptImage1p5MultiFunctionImageGenSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_gpt_image_1p5(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    return match aspect_ratio {
-      TextToImageSize::Auto => Some(GptImage1p5MultiFunctionImageGenSize::Square),
-      TextToImageSize::Square => Some(GptImage1p5MultiFunctionImageGenSize::Square),
-      TextToImageSize::Wide => Some(GptImage1p5MultiFunctionImageGenSize::Wide),
-      TextToImageSize::Tall => Some(GptImage1p5MultiFunctionImageGenSize::Tall),
-    }
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_nano_banana_text_to_image.rs

@@ -1,109 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_nano_banana::aspect_ratio_to_artcraft_nano_banana;
-use crate::core::commands::enqueue::generate_error::{GenerateError, MissingCredentialsReason, ProviderFailureReason};
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::edit::gemini_25_flash_edit_image::{Gemini25FlashEditImageNumImages, Gemini25FlashEditImageRequest};
-use artcraft_api_defs::generate::image::multi_function::nano_banana_multi_function_image_gen::{NanoBananaMultiFunctionImageGenAspectRatio, NanoBananaMultiFunctionImageGenNumImages, NanoBananaMultiFunctionImageGenRequest};
-use artcraft_api_defs::generate::image::multi_function::nano_banana_pro_multi_function_image_gen::NanoBananaProMultiFunctionImageGenAspectRatio;
-use artcraft_api_defs::generate::image::text::generate_gpt_image_1_text_to_image::{GenerateGptImage1TextToImageImageQuality, GenerateGptImage1TextToImageImageSize, GenerateGptImage1TextToImageNumImages, GenerateGptImage1TextToImageRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use std::time::Duration;
-use artcraft_client::endpoints::generate::image::multi_function::nano_banana_multi_function_image_gen_image::nano_banana_multi_function_image_gen;
-use artcraft_client::endpoints::generate::image::multi_function::nano_banana_pro_multi_function_image_gen_image::nano_banana_pro_multi_function_image_gen;
-use tauri::AppHandle;
-
-pub async fn handle_artcraft_nano_banana_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::MissingCredentials(MissingCredentialsReason::NeedsStorytellerCredentials));
-    },
-  };
-
-  info!("Calling Artcraft Nano Banana...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let num_images = match request.number_images {
-    None => None,
-    Some(1) => Some(NanoBananaMultiFunctionImageGenNumImages::One),
-    Some(2) => Some(NanoBananaMultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(NanoBananaMultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(NanoBananaMultiFunctionImageGenNumImages::Four),
-    _ => Some(NanoBananaMultiFunctionImageGenNumImages::One), // Default to one image if invalid number
-  };
-
-  let aspect_ratio = get_aspect_ratio(request);
-  
-  let request = NanoBananaMultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    image_media_tokens: request.image_media_tokens.clone(),
-    num_images,
-    aspect_ratio,
-  };
-
-  let result = nano_banana_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-
-  let job_id = match result {
-    Ok(enqueued) => {
-      // TODO(bt,2025-07-05): Enqueue job token?
-      info!("Successfully enqueued Artcraft Nano Banana. Job token: {}",
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft Nano Banana: {:?}", err);
-      return Err(GenerateError::ProviderFailure(ProviderFailureReason::StorytellerError(err)));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::NanoBanana),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<NanoBananaMultiFunctionImageGenAspectRatio> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_nano_banana(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    return match aspect_ratio {
-      TextToImageSize::Auto => Some(NanoBananaMultiFunctionImageGenAspectRatio::Auto),
-      TextToImageSize::Square => Some(NanoBananaMultiFunctionImageGenAspectRatio::OneByOne),
-      TextToImageSize::Wide => Some(NanoBananaMultiFunctionImageGenAspectRatio::SixteenByNine),
-      TextToImageSize::Tall => Some(NanoBananaMultiFunctionImageGenAspectRatio::NineBySixteen),
-    }
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_seedream_4_text_to_image.rs

@@ -1,116 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_seedream_4::aspect_ratio_to_artcraft_seedream_4;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EditImageSize, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen::{BytedanceSeedreamV4MultiFunctionImageGenImageSize, BytedanceSeedreamV4MultiFunctionImageGenNumImages, BytedanceSeedreamV4MultiFunctionImageGenRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use std::time::Duration;
-use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4_multi_function_image_gen_image::bytedance_seedream_v4_multi_function_image_gen;
-use tauri::AppHandle;
-
-pub async fn handle_artcraft_seedream_4_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft seedream 4 ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let image_size = get_aspect_ratio(request);
-
-  let num_images = match request.number_images {
-    None => None,
-    Some(1) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::Four),
-    // TODO: Error
-    //Some(other) => {
-    //  return Err(InternalImageError::InvalidNumberOfRequestedImages {
-    //    min: 1,
-    //    max: 4,
-    //    requested: other,
-    //  });
-    //},
-    _ => Some(BytedanceSeedreamV4MultiFunctionImageGenNumImages::One), // Default to one image if invalid number
-  };
-
-  let request = BytedanceSeedreamV4MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    num_images,
-    image_size,
-    // Not provided for text-to-image
-    image_media_tokens: None,
-    // Not provided
-    max_images: None,
-  };
-
-  let result = bytedance_seedream_v4_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-
-  let job_id = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft seedream 4. Job token: {}", 
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft seedream 4: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::Seedream4p5),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<BytedanceSeedreamV4MultiFunctionImageGenImageSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_seedream_4(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect_ratio = match aspect_ratio {
-      TextToImageSize::Auto => BytedanceSeedreamV4MultiFunctionImageGenImageSize::Square,
-      TextToImageSize::Square => BytedanceSeedreamV4MultiFunctionImageGenImageSize::Square,
-      TextToImageSize::Tall => BytedanceSeedreamV4MultiFunctionImageGenImageSize::PortraitSixteenNine,
-      TextToImageSize::Wide => BytedanceSeedreamV4MultiFunctionImageGenImageSize::LandscapeSixteenNine,
-    };
-    return Some(aspect_ratio);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_artcraft_seedream_4p5_text_to_image.rs

@@ -1,116 +0,0 @@
-use crate::core::api_adapters::aspect_ratio::convert::aspect_ratio_to_artcraft_seedream_4p5::aspect_ratio_to_artcraft_seedream_4p5;
-use crate::core::commands::enqueue::generate_error::GenerateError;
-use crate::core::commands::enqueue::image_edit::enqueue_edit_image_command::{EditImageQuality, EnqueueEditImageCommand};
-use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageSize};
-use crate::core::events::basic_sendable_event_trait::BasicSendableEvent;
-use crate::core::events::generation_events::common::{GenerationAction, GenerationModel, GenerationServiceProvider};
-use crate::core::events::generation_events::generation_enqueue_failure_event::GenerationEnqueueFailureEvent;
-use crate::core::state::app_env_configs::app_env_configs::AppEnvConfigs;
-use crate::core::state::data_dir::app_data_root::AppDataRoot;
-use crate::core::state::provider_priority::ProviderPriorityStore;
-use crate::services::sora::state::sora_credential_manager::SoraCredentialManager;
-use crate::services::sora::state::sora_task_queue::SoraTaskQueue;
-use crate::services::storyteller::state::storyteller_credential_manager::StorytellerCredentialManager;
-use artcraft_api_defs::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen::{BytedanceSeedreamV4p5MultiFunctionImageGenImageSize, BytedanceSeedreamV4p5MultiFunctionImageGenNumImages, BytedanceSeedreamV4p5MultiFunctionImageGenRequest};
-use enums::common::generation_provider::GenerationProvider;
-use enums::tauri::tasks::task_type::TaskType;
-use idempotency::uuid::generate_random_uuid;
-use log::{error, info};
-use std::time::Duration;
-use artcraft_client::endpoints::generate::image::multi_function::bytedance_seedream_v4p5_multi_function_image_gen_image::bytedance_seedream_v4p5_multi_function_image_gen;
-use tauri::AppHandle;
-
-pub async fn handle_artcraft_seedream_4p5_text_to_image(
-  request: &EnqueueTextToImageRequest,
-  app_env_configs: &AppEnvConfigs,
-  storyteller_creds_manager: &StorytellerCredentialManager,
-) -> Result<TaskEnqueueSuccess, GenerateError> {
-
-  let creds = match storyteller_creds_manager.get_credentials()? {
-    Some(creds) => creds,
-    None => {
-      return Err(GenerateError::needs_storyteller_credentials());
-    },
-  };
-
-  info!("Calling Artcraft seedream 4.5 ...");
-
-  let uuid_idempotency_token = generate_random_uuid();
-
-  let image_size = get_aspect_ratio(request);
-
-  let num_images = match request.number_images {
-    None => None,
-    Some(1) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::One),
-    Some(2) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Two),
-    Some(3) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Three),
-    Some(4) => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::Four),
-    // TODO: Error
-    //Some(other) => {
-    //  return Err(InternalImageError::InvalidNumberOfRequestedImages {
-    //    min: 1,
-    //    max: 4,
-    //    requested: other,
-    //  });
-    //},
-    _ => Some(BytedanceSeedreamV4p5MultiFunctionImageGenNumImages::One), // Default to one image if invalid number
-  };
-
-  let request = BytedanceSeedreamV4p5MultiFunctionImageGenRequest {
-    uuid_idempotency_token,
-    prompt: request.prompt.clone(),
-    num_images,
-    image_size,
-    // Not provided for text-to-image
-    image_media_tokens: None,
-    // Not provided
-    max_images: None,
-  };
-
-  let result = bytedance_seedream_v4p5_multi_function_image_gen(
-    &app_env_configs.storyteller_host,
-    Some(&creds),
-    request,
-  ).await;
-
-  let job_id = match result {
-    Ok(enqueued) => {
-      info!("Successfully enqueued Artcraft seedream 4.5. Job token: {}", 
-        enqueued.inference_job_token);
-      enqueued.inference_job_token
-    }
-    Err(err) => {
-      error!("Failed to use Artcraft seedream 4.5: {:?}", err);
-      return Err(GenerateError::from(err));
-    }
-  };
-
-  Ok(TaskEnqueueSuccess {
-    provider: GenerationProvider::Artcraft,
-    model: Some(GenerationModel::Seedream4p5),
-    provider_job_id: Some(job_id.to_string()),
-    task_type: TaskType::ImageGeneration,
-  })
-}
-
-fn get_aspect_ratio(request: &EnqueueTextToImageRequest) -> Option<BytedanceSeedreamV4p5MultiFunctionImageGenImageSize> {
-  if let Some(common_aspect_ratio) = request.common_aspect_ratio {
-    // Handle modern aspect ratio
-    let aspect = aspect_ratio_to_artcraft_seedream_4p5(common_aspect_ratio);
-    return Some(aspect);
-  }
-
-  if let Some(aspect_ratio) = request.aspect_ratio {
-    // Handle deprecated aspect ratio
-    let aspect_ratio = match aspect_ratio {
-      TextToImageSize::Auto => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::Square,
-      TextToImageSize::Square => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::Square,
-      TextToImageSize::Tall => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::PortraitSixteenNine,
-      TextToImageSize::Wide => BytedanceSeedreamV4p5MultiFunctionImageGenImageSize::LandscapeSixteenNine,
-    };
-    return Some(aspect_ratio);
-  }
-
-  None
-}

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_text_to_image_artcraft.rs

@@ -1,15 +1,7 @@
 use crate::core::commands::enqueue::generate_error::GenerateError;
 use crate::core::commands::enqueue::task_enqueue_success::TaskEnqueueSuccess;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_flux_1_dev_text_to_image::handle_artcraft_flux_1_dev_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_flux_1_schnell_text_to_image::handle_artcraft_flux_1_schnell_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_flux_pro_1p1_text_to_image::handle_artcraft_flux_pro_1p1_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_flux_pro_1p1_ultra_text_to_image::handle_artcraft_flux_pro_1p1_ultra_text_to_image;
 use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_gpt_image_1_text_to_image::handle_artcraft_gpt_image_1_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_gpt_image_1p5_text_to_image::handle_artcraft_gpt_image_1p5_text_to_image;
 use crate::core::commands::enqueue::text_to_image::artcraft::handle_text_to_image_artcraft_via_router::handle_text_to_image_artcraft_via_router;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_nano_banana_text_to_image::handle_artcraft_nano_banana_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_seedream_4_text_to_image::handle_artcraft_seedream_4_text_to_image;
-use crate::core::commands::enqueue::text_to_image::artcraft::handle_artcraft_seedream_4p5_text_to_image::handle_artcraft_seedream_4p5_text_to_image;
 use crate::core::commands::enqueue::text_to_image::enqueue_text_to_image_command::{EnqueueTextToImageRequest, TextToImageModel};
 use crate::core::commands::enqueue::text_to_image::text_to_image_models::text_to_image_model_to_model_type;
 use crate::core::events::generation_events::common::GenerationModel;
@@ -28,7 +20,7 @@ pub async fn handle_text_to_image_artcraft(
   app_env_configs: &AppEnvConfigs,
   storyteller_creds_manager: &StorytellerCredentialManager,
 ) -> Result<TaskEnqueueSuccess, GenerateError> {
-  
+
   match model {
     TextToImageModel::Midjourney | TextToImageModel::GrokImage => {
       Err(GenerateError::BadProviderForModel {
@@ -39,17 +31,19 @@ pub async fn handle_text_to_image_artcraft(
     TextToImageModel::Recraft3 => {
       Err(GenerateError::NotYetImplemented(format!("not yet implemented in Artcraft")))
     }
-    TextToImageModel::Flux1Dev => handle_artcraft_flux_1_dev_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
-    TextToImageModel::Flux1Schnell => handle_artcraft_flux_1_schnell_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
-    TextToImageModel::FluxPro11 =>handle_artcraft_flux_pro_1p1_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
-    TextToImageModel::FluxPro11Ultra => handle_artcraft_flux_pro_1p1_ultra_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
+    TextToImageModel::Flux1Dev => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Flux1Dev, GenerationModel::Flux1Dev).await,
+    TextToImageModel::Flux1Schnell => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Flux1Schnell, GenerationModel::Flux1Schnell).await,
+    TextToImageModel::FluxPro11 => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::FluxPro11, GenerationModel::FluxPro11).await,
+    TextToImageModel::FluxPro11Ultra => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::FluxPro11Ultra, GenerationModel::FluxPro11Ultra).await,
     TextToImageModel::GptImage1 => handle_artcraft_gpt_image_1_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
-    TextToImageModel::GptImage1p5 => handle_artcraft_gpt_image_1p5_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
+    TextToImageModel::GptImage1p5 => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::GptImage1p5, GenerationModel::GptImage1p5).await,
     TextToImageModel::Gemini25Flash | TextToImageModel::NanoBanana => {
-      handle_artcraft_nano_banana_text_to_image(request, app_env_configs, storyteller_creds_manager).await
+      handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBanana, GenerationModel::NanoBanana).await
     },
+    TextToImageModel::NanoBanana2 => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBanana2, GenerationModel::NanoBanana2).await,
     TextToImageModel::NanoBananaPro => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::NanaBananaPro, GenerationModel::NanoBananaPro).await,
-    TextToImageModel::Seedream4 => handle_artcraft_seedream_4_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
-    TextToImageModel::Seedream4p5 => handle_artcraft_seedream_4p5_text_to_image(request, app_env_configs, storyteller_creds_manager).await,
+    TextToImageModel::Seedream4 => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream4, GenerationModel::Seedream4).await,
+    TextToImageModel::Seedream4p5 => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream4p5, GenerationModel::Seedream4p5).await,
+    TextToImageModel::Seedream5Lite => handle_text_to_image_artcraft_via_router(request, app_env_configs, storyteller_creds_manager, CommonImageModel::Seedream5Lite, GenerationModel::Seedream5Lite).await,
   }
 }

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/handle_text_to_image_artcraft_via_router.rs

@@ -52,6 +52,7 @@ pub(super) async fn handle_text_to_image_artcraft_via_router(
     aspect_ratio,
     image_batch_count: request.number_images.map(|n| n as u16),
     request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+    generation_mode_mismatch_strategy: None,
     idempotency_token: None,
   };
 

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/artcraft/mod.rs

@@ -2,11 +2,3 @@ pub (super) mod handle_text_to_image_artcraft;
 
 mod handle_text_to_image_artcraft_via_router;
 mod handle_artcraft_gpt_image_1_text_to_image;
-mod handle_artcraft_gpt_image_1p5_text_to_image;
-mod handle_artcraft_nano_banana_text_to_image;
-mod handle_artcraft_seedream_4_text_to_image;
-mod handle_artcraft_seedream_4p5_text_to_image;
-mod handle_artcraft_flux_pro_1p1_ultra_text_to_image;
-mod handle_artcraft_flux_1_dev_text_to_image;
-mod handle_artcraft_flux_pro_1p1_text_to_image;
-mod handle_artcraft_flux_1_schnell_text_to_image;

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/enqueue_text_to_image_command.rs

@@ -65,12 +65,16 @@ pub enum TextToImageModel {
   Gemini25Flash,
   #[serde(rename = "nano_banana")]
   NanoBanana,
+  #[serde(rename = "nano_banana_2")]
+  NanoBanana2,
   #[serde(rename = "nano_banana_pro")]
   NanoBananaPro,
   #[serde(rename = "seedream_4")]
   Seedream4,
   #[serde(rename = "seedream_4p5")]
   Seedream4p5,
+  #[serde(rename = "seedream_5_lite")]
+  Seedream5Lite,
 
   // Generic Midjourney model, version unknown.
   #[serde(rename = "midjourney")]

crates/desktop/artcraft/src/core/commands/enqueue/text_to_image/text_to_image_models.rs

@@ -13,9 +13,11 @@ pub fn text_to_image_model_to_model_type(model: TextToImageModel) -> ModelType {
     TextToImageModel::GptImage1p5 => ModelType::GptImage1p5,
     TextToImageModel::Gemini25Flash => ModelType::NanoBanana,
     TextToImageModel::NanoBanana => ModelType::NanoBanana,
+    TextToImageModel::NanoBanana2 => ModelType::NanoBanana2,
     TextToImageModel::NanoBananaPro => ModelType::NanoBananaPro,
     TextToImageModel::Seedream4 => ModelType::Seedream4,
     TextToImageModel::Seedream4p5 => ModelType::Seedream4p5,
+    TextToImageModel::Seedream5Lite => ModelType::Seedream5Lite,
     TextToImageModel::Midjourney => ModelType::Midjourney,
   }
 }

crates/desktop/artcraft/src/core/events/generation_events/common.rs

@@ -39,12 +39,16 @@ pub enum GenerationModel {
   Gemini25Flash,
   #[serde(rename = "nano_banana")]
   NanoBanana,
+  #[serde(rename = "nano_banana_2")]
+  NanoBanana2,
   #[serde(rename = "nano_banana_pro")]
   NanoBananaPro,
   #[serde(rename = "seedream_4")]
   Seedream4,
   #[serde(rename = "seedream_4p5")]
   Seedream4p5,
+  #[serde(rename = "seedream_5_lite")]
+  Seedream5Lite,
 
   #[serde(rename = "hunyuan_3d_2_0")]
   Hunyuan3d2_0,

crates/desktop/artcraft/src/services/storyteller/threads/storyteller_task_polling_thread.rs

@@ -126,77 +126,119 @@ async fn polling_loop(
         .collect::<HashMap<String, Task>>();
 
     for job in jobs.iter() {
-      match job.status.status {
-        JobStatusPlus::CompleteSuccess => {} // Fall-through.
-        _ => continue,
-      }
-
       let task = match tasks_by_provider_job_id.get(job.job_token.as_str()) {
-        Some(job) => job,
+        Some(task) => task,
         None => continue,
       };
 
-      match task.status {
-        TaskStatus::CompleteSuccess => continue,
-        _ => {} // Fall-through.
-      }
-
-      let maybe_primary_media_file_token = job.maybe_result
-          .as_ref()
-          .map(|result| MediaFileToken::new_from_str(&result.entity_token));
-
-      let updated = update_successful_task_status_with_metadata(UpdateSuccessfulTaskArgs {
-        db: task_database.get_connection(),
-        task_id: &task.id,
-        maybe_batch_token: job.maybe_result
-            .as_ref()
-            .map(|result| result.maybe_batch_token.as_ref())
-            .flatten(),
-        maybe_primary_media_file_token: maybe_primary_media_file_token.as_ref(),
-        maybe_primary_media_file_class: get_media_file_class(&job),
-        maybe_primary_media_file_thumbnail_url_template: get_thumbnail_template(&job),
-        maybe_primary_media_file_cdn_url: job.maybe_result
-            .as_ref()
-            .map(|result| result.media_links.cdn_url.as_str()),
-      }).await?;
-
-      if !updated {
-        continue; // If anything breaks with queries, don't spam events.
-      }
-
-      send_additional_events(
-        &app_handle,
-        &app_env_configs,
-        creds.as_ref(),
-        &job,
-        &task,
-      ).await;
-
-      let service = to_generation_service_provider(task.provider);
-      let action = to_generation_action(task.task_type);
-
-      let event = GenerationCompleteEvent {
-        action: Some(action),
-        service,
-        model: None, // TODO
-      };
-
-      if let Err(err) = event.send(&app_handle) {
-        error!("Failed to send GenerationCompleteEvent: {:?}", err); // Fail open
+      match job.status.status {
+        JobStatusPlus::CompleteSuccess => {
+          match task.status {
+            TaskStatus::CompleteSuccess => continue,
+            _ => {}
+          }
+          handle_successful_job(app_handle, app_env_configs, creds.as_ref(), job, task, task_database).await?;
+        }
+        JobStatusPlus::CompleteFailure => {
+          match task.status {
+            TaskStatus::CompleteFailure => continue,
+            _ => {}
+          }
+          handle_failed_job(app_handle, job, task, task_database).await?;
+        }
+        _ => continue,
       }
     }
 
   }
 }
 
-async fn send_additional_events(
+async fn handle_successful_job(
+  app_handle: &AppHandle,
+  app_env_configs: &AppEnvConfigs,
+  creds: Option<&StorytellerCredentialSet>,
+  job: &ListSessionJobsItem,
+  task: &Task,
+  task_database: &TaskDatabase,
+) -> AnyhowResult<()> {
+  let maybe_primary_media_file_token = job.maybe_result
+      .as_ref()
+      .map(|result| MediaFileToken::new_from_str(&result.entity_token));
+
+  let updated = update_successful_task_status_with_metadata(UpdateSuccessfulTaskArgs {
+    db: task_database.get_connection(),
+    task_id: &task.id,
+    maybe_batch_token: job.maybe_result
+        .as_ref()
+        .map(|result| result.maybe_batch_token.as_ref())
+        .flatten(),
+    maybe_primary_media_file_token: maybe_primary_media_file_token.as_ref(),
+    maybe_primary_media_file_class: get_media_file_class(job),
+    maybe_primary_media_file_thumbnail_url_template: get_thumbnail_template(job),
+    maybe_primary_media_file_cdn_url: job.maybe_result
+        .as_ref()
+        .map(|result| result.media_links.cdn_url.as_str()),
+  }).await?;
+
+  if !updated {
+    return Ok(()); // If anything breaks with queries, don't spam events.
+  }
+
+  send_additional_success_events(app_handle, app_env_configs, creds, job, task).await;
+
+  let service = to_generation_service_provider(task.provider);
+  let action = to_generation_action(task.task_type);
+
+  let event = GenerationCompleteEvent {
+    action: Some(action),
+    service,
+    model: None, // TODO
+  };
+
+  if let Err(err) = event.send(app_handle) {
+    error!("Failed to send GenerationCompleteEvent: {:?}", err); // Fail open
+  }
+
+  Ok(())
+}
+
+async fn handle_failed_job(
+  app_handle: &AppHandle,
+  job: &ListSessionJobsItem,
+  task: &Task,
+  task_database: &TaskDatabase,
+) -> AnyhowResult<()> {
+  info!("Marking storyteller job as failed: {:?}", task.id);
+
+  update_task_status(UpdateTaskArgs {
+    db: task_database.get_connection(),
+    task_id: &task.id,
+    status: TaskStatus::CompleteFailure,
+  }).await?;
+
+  let service = to_generation_service_provider(task.provider);
+  let action = to_generation_action(task.task_type);
+
+  let event = GenerationFailedEvent {
+    action,
+    service,
+    model: None,
+    reason: None,
+  };
+
+  event.send_infallible(app_handle);
+
+  Ok(())
+}
+
+async fn send_additional_success_events(
   app_handle: &AppHandle,
   app_env_configs: &AppEnvConfigs,
   creds: Option<&StorytellerCredentialSet>,
   job: &ListSessionJobsItem,
   task: &Task
 ) {
-  info!("Attempting to dispatch events for completed Storyteller : {:?}", task);
+  info!("Attempting to dispatch events for completed Storyteller job: {:?}", task);
 
   let result = maybe_handle_frontend_caller_notification(
     app_handle,

crates/desktop/artcraft/src/version.rs

@@ -1,4 +1,4 @@
 
 /// The version of the ArtCraft desktop app reported in the UI and via Analytics.
 /// This should match the CI builds.
-pub const ARTCRAFT_VERSION: &str = "0.10.0";
+pub const ARTCRAFT_VERSION: &str = "0.11.0";

crates/desktop/artcraft/tauri-mac.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0-rc",
   "productName": "ArtCraft",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "identifier": "ai.artcraft.app",
   "build": {
     "frontendDist": "../../../frontend/apps/artcraft/dist",

crates/desktop/artcraft/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0-rc",
   "productName": "ArtCraft",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "identifier": "ai.artcraft.app",
   "build": {
     "frontendDist": "../../../frontend/apps/artcraft/dist",

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/insert_generic_inference_job_for_fal_queue.rs

@@ -62,6 +62,7 @@ pub async fn insert_generic_inference_job_for_fal_queue<'e, 'c : 'e, E>(args: In
     maybe_avt_token: args.maybe_avt_token,
     creator_ip_address: args.creator_ip_address,
     creator_set_visibility: args.creator_set_visibility,
+    starting_job_status_override: None,
     mysql_executor: args.mysql_executor,
     phantom: args.phantom,
   };

crates/schema/database/mysql_queries/src/queries/generic_inference/fal/insert_generic_inference_job_for_fal_queue_mock_failure.rs

@@ -0,0 +1,70 @@
+use idempotency::uuid::generate_random_uuid;
+use sqlx::{Executor, MySql};
+use std::marker::PhantomData;
+
+use enums::common::job_status_plus::JobStatusPlus;
+use enums::common::visibility::Visibility;
+use tokens::tokens::anonymous_visitor_tracking::AnonymousVisitorTrackingToken;
+use tokens::tokens::generic_inference_jobs::InferenceJobToken;
+use tokens::tokens::prompts::PromptToken;
+use tokens::tokens::users::UserToken;
+
+use crate::errors::database_query_error::DatabaseQueryError;
+use crate::payloads::generic_inference_args::generic_inference_args::GenericInferenceArgs;
+use crate::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::FalCategory;
+use crate::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue_with_apriori_job_token::{
+  insert_generic_inference_job_for_fal_queue_with_apriori_job_token,
+  InsertGenericInferenceForFalWithAprioriJobTokenArgs,
+};
+
+/// Same as [`InsertGenericInferenceForFalArgs`] but without `maybe_external_third_party_id`,
+/// since no external Fal call was made. The inserted job will have status
+/// [`JobStatusPlus::CompleteFailure`] immediately, making it a synthetic failed job useful
+/// for testing error-handling paths on the frontend without touching real inference services.
+pub struct InsertGenericInferenceForFalMockFailureArgs<'e, 'c, E>
+  where E: 'e + Executor<'c, Database = MySql>
+{
+  pub uuid_idempotency_token: &'e str,
+
+  pub fal_category: FalCategory,
+
+  pub maybe_inference_args: Option<GenericInferenceArgs>,
+
+  pub maybe_prompt_token: Option<&'e PromptToken>,
+
+  pub maybe_creator_user_token: Option<&'e UserToken>,
+  pub maybe_avt_token: Option<&'e AnonymousVisitorTrackingToken>,
+  pub creator_ip_address: &'e str,
+  pub creator_set_visibility: Visibility,
+
+  pub mysql_executor: E,
+
+  pub phantom: PhantomData<&'c E>,
+}
+
+pub async fn insert_generic_inference_job_for_fal_queue_mock_failure<'e, 'c: 'e, E>(
+  args: InsertGenericInferenceForFalMockFailureArgs<'e, 'c, E>,
+) -> Result<InferenceJobToken, DatabaseQueryError>
+  where E: 'e + Executor<'c, Database = MySql>
+{
+  let job_token = InferenceJobToken::generate();
+  let synthetic_external_id = format!("synthetic_{}", generate_random_uuid());
+
+  let inner_args = InsertGenericInferenceForFalWithAprioriJobTokenArgs {
+    uuid_idempotency_token: args.uuid_idempotency_token,
+    apriori_job_token: &job_token,
+    maybe_external_third_party_id: &synthetic_external_id,
+    fal_category: args.fal_category,
+    maybe_inference_args: args.maybe_inference_args,
+    maybe_prompt_token: args.maybe_prompt_token,
+    maybe_creator_user_token: args.maybe_creator_user_token,
+    maybe_avt_token: args.maybe_avt_token,
+    creator_ip_address: args.creator_ip_address,
+    creator_set_visibility: args.creator_set_visibility,
+    starting_job_status_override: Some(JobStatusPlus::CompleteFailure),
+    mysql_executor: args.mysql_executor,
+    phantom: args.phantom,
+  };
+
+  insert_generic_inference_job_for_fal_queue_with_apriori_job_token(inner_args).await
+}