artcraft_router

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

@@ -19,6 +19,10 @@ pub enum RouterImageModel {
   GptImage1p5,
   #[serde(rename = "gpt_image_2")]
   GptImage2,
+  #[serde(rename = "gpt_image_2p5_flare")]
+  GptImage2p5Flare,
+  #[serde(rename = "gpt_image_2p5_sunburst")]
+  GptImage2p5Sunburst,
   #[serde(rename = "grok_imagine_image")]
   GrokImagineImage,
   #[serde(rename = "grok_imagine_image_q")]
@@ -87,4 +91,14 @@ mod tests {
   fn seedream_5p0_pro_ultra_serializes_to_seedream_5p0_pro_u() {
     assert_round_trip(RouterImageModel::Seedream5p0ProUltra, "seedream_5p0_pro_u");
   }
+
+  #[test]
+  fn gpt_image_2p5_flare_serializes_to_gpt_image_2p5_flare() {
+    assert_round_trip(RouterImageModel::GptImage2p5Flare, "gpt_image_2p5_flare");
+  }
+
+  #[test]
+  fn gpt_image_2p5_sunburst_serializes_to_gpt_image_2p5_sunburst() {
+    assert_round_trip(RouterImageModel::GptImage2p5Sunburst, "gpt_image_2p5_sunburst");
+  }
 }

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

@@ -16,6 +16,8 @@ use crate::generate::generate_image::providers::artcraft::flux_pro_1p1_ultra::bu
 use crate::generate::generate_image::providers::artcraft::gpt_image_1::build::build_artcraft_gpt_image_1;
 use crate::generate::generate_image::providers::artcraft::gpt_image_1p5::build::build_artcraft_gpt_image_1p5;
 use crate::generate::generate_image::providers::artcraft::gpt_image_2::build::build_artcraft_gpt_image_2;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_flare::build::build_artcraft_gpt_image_2p5_flare;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_sunburst::build::build_artcraft_gpt_image_2p5_sunburst;
 use crate::generate::generate_image::providers::artcraft::midjourney_7::build::build_artcraft_midjourney_7;
 use crate::generate::generate_image::providers::artcraft::midjourney_7_niji::build::build_artcraft_midjourney_7_niji;
 use crate::generate::generate_image::providers::artcraft::midjourney_8::build::build_artcraft_midjourney_8;
@@ -36,6 +38,8 @@ use crate::generate::generate_image::providers::fal::flux_pro_1p1_ultra::build::
 use crate::generate::generate_image::providers::fal::gpt_image_1::build::build_fal_gpt_image_1;
 use crate::generate::generate_image::providers::fal::gpt_image_1p5::build::build_fal_gpt_image_1p5;
 use crate::generate::generate_image::providers::fal::gpt_image_2::build::build_fal_gpt_image_2;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_flare::build::build_fal_gpt_image_2p5_flare;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_sunburst::build::build_fal_gpt_image_2p5_sunburst;
 use crate::generate::generate_image::providers::fal::nano_banana::build::build_fal_nano_banana;
 use crate::generate::generate_image::providers::fal::nano_banana_2::build::build_fal_nano_banana_2;
 use crate::generate::generate_image::providers::fal::nano_banana_pro::build::build_fal_nano_banana_pro;
@@ -116,6 +120,8 @@ impl GenerateImageRequestBuilder {
       (RouterProvider::Artcraft, RouterImageModel::GptImage1) => build_artcraft_gpt_image_1(self),
       (RouterProvider::Artcraft, RouterImageModel::GptImage1p5) => build_artcraft_gpt_image_1p5(self),
       (RouterProvider::Artcraft, RouterImageModel::GptImage2) => build_artcraft_gpt_image_2(self),
+      (RouterProvider::Artcraft, RouterImageModel::GptImage2p5Flare) => build_artcraft_gpt_image_2p5_flare(self),
+      (RouterProvider::Artcraft, RouterImageModel::GptImage2p5Sunburst) => build_artcraft_gpt_image_2p5_sunburst(self),
       (RouterProvider::Artcraft, RouterImageModel::NanoBanana) => build_artcraft_nano_banana(self),
       (RouterProvider::Artcraft, RouterImageModel::NanoBanana2) => build_artcraft_nano_banana_2(self),
       (RouterProvider::Artcraft, RouterImageModel::NanoBananaPro) => build_artcraft_nano_banana_pro(self),
@@ -137,6 +143,8 @@ impl GenerateImageRequestBuilder {
       (RouterProvider::Fal, RouterImageModel::GptImage1) => build_fal_gpt_image_1(self),
       (RouterProvider::Fal, RouterImageModel::GptImage1p5) => build_fal_gpt_image_1p5(self),
       (RouterProvider::Fal, RouterImageModel::GptImage2) => build_fal_gpt_image_2(self),
+      (RouterProvider::Fal, RouterImageModel::GptImage2p5Flare) => build_fal_gpt_image_2p5_flare(self),
+      (RouterProvider::Fal, RouterImageModel::GptImage2p5Sunburst) => build_fal_gpt_image_2p5_sunburst(self),
       (RouterProvider::Fal, RouterImageModel::NanoBanana) => build_fal_nano_banana(self),
       (RouterProvider::Fal, RouterImageModel::NanoBanana2) => build_fal_nano_banana_2(self),
       (RouterProvider::Fal, RouterImageModel::NanoBananaPro) => build_fal_nano_banana_pro(self),

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

@@ -19,6 +19,10 @@ use crate::generate::generate_image::providers::artcraft::gpt_image_1p5::cost::A
 use crate::generate::generate_image::providers::artcraft::gpt_image_1p5::request::ArtcraftGptImage1p5RequestState;
 use crate::generate::generate_image::providers::artcraft::gpt_image_2::cost::ArtcraftGptImage2CostState;
 use crate::generate::generate_image::providers::artcraft::gpt_image_2::request::ArtcraftGptImage2RequestState;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_flare::cost::ArtcraftGptImage2p5FlareCostState;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_flare::request::ArtcraftGptImage2p5FlareRequestState;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_sunburst::cost::ArtcraftGptImage2p5SunburstCostState;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_sunburst::request::ArtcraftGptImage2p5SunburstRequestState;
 use crate::generate::generate_image::providers::artcraft::midjourney_7::cost::ArtcraftMidjourney7CostState;
 use crate::generate::generate_image::providers::artcraft::midjourney_7::request::ArtcraftMidjourney7RequestState;
 use crate::generate::generate_image::providers::artcraft::midjourney_7_niji::cost::ArtcraftMidjourney7NijiCostState;
@@ -59,6 +63,10 @@ use crate::generate::generate_image::providers::fal::gpt_image_1p5::cost::FalGpt
 use crate::generate::generate_image::providers::fal::gpt_image_1p5::request::FalGptImage1p5RequestState;
 use crate::generate::generate_image::providers::fal::gpt_image_2::cost::FalGptImage2CostState;
 use crate::generate::generate_image::providers::fal::gpt_image_2::request::FalGptImage2RequestState;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_flare::cost::FalGptImage2p5FlareCostState;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_flare::request::FalGptImage2p5FlareRequestState;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_sunburst::cost::FalGptImage2p5SunburstCostState;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_sunburst::request::FalGptImage2p5SunburstRequestState;
 use crate::generate::generate_image::providers::fal::nano_banana::cost::FalNanoBananaCostState;
 use crate::generate::generate_image::providers::fal::nano_banana::request::FalNanoBananaRequestState;
 use crate::generate::generate_image::providers::fal::nano_banana_2::cost::FalNanoBanana2CostState;
@@ -92,6 +100,8 @@ pub enum ImageGenerationRequest {
   ArtcraftGptImage1(ArtcraftGptImage1RequestState),
   ArtcraftGptImage1p5(ArtcraftGptImage1p5RequestState),
   ArtcraftGptImage2(ArtcraftGptImage2RequestState),
+  ArtcraftGptImage2p5Flare(ArtcraftGptImage2p5FlareRequestState),
+  ArtcraftGptImage2p5Sunburst(ArtcraftGptImage2p5SunburstRequestState),
   ArtcraftNanoBanana(ArtcraftNanoBananaRequestState),
   ArtcraftNanoBanana2(ArtcraftNanoBanana2RequestState),
   ArtcraftNanoBananaPro(ArtcraftNanoBananaProRequestState),
@@ -114,6 +124,8 @@ pub enum ImageGenerationRequest {
   FalGptImage1(FalGptImage1RequestState),
   FalGptImage1p5(FalGptImage1p5RequestState),
   FalGptImage2(FalGptImage2RequestState),
+  FalGptImage2p5Flare(FalGptImage2p5FlareRequestState),
+  FalGptImage2p5Sunburst(FalGptImage2p5SunburstRequestState),
   FalNanoBanana(FalNanoBananaRequestState),
   FalNanoBanana2(FalNanoBanana2RequestState),
   FalNanoBananaPro(FalNanoBananaProRequestState),
@@ -140,6 +152,8 @@ impl ImageGenerationRequest {
       Self::ArtcraftGptImage1(_) => RouterProvider::Artcraft,
       Self::ArtcraftGptImage1p5(_) => RouterProvider::Artcraft,
       Self::ArtcraftGptImage2(_) => RouterProvider::Artcraft,
+      Self::ArtcraftGptImage2p5Flare(_) => RouterProvider::Artcraft,
+      Self::ArtcraftGptImage2p5Sunburst(_) => RouterProvider::Artcraft,
       Self::ArtcraftNanoBanana(_) => RouterProvider::Artcraft,
       Self::ArtcraftNanoBanana2(_) => RouterProvider::Artcraft,
       Self::ArtcraftNanoBananaPro(_) => RouterProvider::Artcraft,
@@ -161,6 +175,8 @@ impl ImageGenerationRequest {
       Self::FalGptImage1(_) => RouterProvider::Fal,
       Self::FalGptImage1p5(_) => RouterProvider::Fal,
       Self::FalGptImage2(_) => RouterProvider::Fal,
+      Self::FalGptImage2p5Flare(_) => RouterProvider::Fal,
+      Self::FalGptImage2p5Sunburst(_) => RouterProvider::Fal,
       Self::FalNanoBanana(_) => RouterProvider::Fal,
       Self::FalNanoBanana2(_) => RouterProvider::Fal,
       Self::FalNanoBananaPro(_) => RouterProvider::Fal,
@@ -201,6 +217,12 @@ impl ImageGenerationRequest {
       Self::ArtcraftGptImage2(request) => {
         Ok(ArtcraftGptImage2CostState::from_request(request).estimate_cost())
       }
+      Self::ArtcraftGptImage2p5Flare(request) => {
+        Ok(ArtcraftGptImage2p5FlareCostState::from_request(request).estimate_cost())
+      }
+      Self::ArtcraftGptImage2p5Sunburst(request) => {
+        Ok(ArtcraftGptImage2p5SunburstCostState::from_request(request).estimate_cost())
+      }
       Self::ArtcraftNanoBanana(request) => {
         Ok(ArtcraftNanoBananaCostState::from_request(request).estimate_cost())
       }
@@ -249,6 +271,8 @@ impl ImageGenerationRequest {
       Self::FalGptImage1(request) => Ok(FalGptImage1CostState::from_request(request).estimate_cost()),
       Self::FalGptImage1p5(request) => Ok(FalGptImage1p5CostState::from_request(request).estimate_cost()),
       Self::FalGptImage2(request) => Ok(FalGptImage2CostState::from_request(request).estimate_cost()),
+      Self::FalGptImage2p5Flare(request) => Ok(FalGptImage2p5FlareCostState::from_request(request).estimate_cost()),
+      Self::FalGptImage2p5Sunburst(request) => Ok(FalGptImage2p5SunburstCostState::from_request(request).estimate_cost()),
       Self::FalNanoBanana(request) => Ok(FalNanoBananaCostState::from_request(request).estimate_cost()),
       Self::FalNanoBanana2(request) => Ok(FalNanoBanana2CostState::from_request(request).estimate_cost()),
       Self::FalNanoBananaPro(request) => Ok(FalNanoBananaProCostState::from_request(request).estimate_cost()),
@@ -296,6 +320,14 @@ impl ImageGenerationRequest {
         let artcraft_client = client.get_artcraft_client_ref()?;
         request.send(artcraft_client).await
       }
+      Self::ArtcraftGptImage2p5Flare(request) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        request.send(artcraft_client).await
+      }
+      Self::ArtcraftGptImage2p5Sunburst(request) => {
+        let artcraft_client = client.get_artcraft_client_ref()?;
+        request.send(artcraft_client).await
+      }
       Self::ArtcraftNanoBanana(request) => {
         let artcraft_client = client.get_artcraft_client_ref()?;
         request.send(artcraft_client).await
@@ -379,6 +411,14 @@ impl ImageGenerationRequest {
         let fal_client = client.get_fal_client_ref()?;
         request.send(fal_client).await
       }
+      Self::FalGptImage2p5Flare(request) => {
+        let fal_client = client.get_fal_client_ref()?;
+        request.send(fal_client).await
+      }
+      Self::FalGptImage2p5Sunburst(request) => {
+        let fal_client = client.get_fal_client_ref()?;
+        request.send(fal_client).await
+      }
       Self::FalNanoBanana(request) => {
         // nano_banana (Gemini 2.5 Flash) is webhook-required.
         let fal_client = client.get_fal_client_ref()?;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_common_cost.rs

@@ -0,0 +1,290 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
+use enums::common::generation::common_quality::CommonQuality as CommonQualityEnum;
+use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+use fal_client::requests::api::image::common::gpt_image_2_resolution::GptImage2Resolution;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_image_size::GptImage2p5ImageSize;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+
+/// Artcraft price per output image, in hundredths of a US cent, by output dimensions and
+/// quality (`[low, medium, high]`). Rows are stored landscape-first; portrait orientations of
+/// the same dimensions price identically. Dimensions come from the aspect ratio preset and
+/// resolution tier the same way the Fal request builder derives them.
+const OUTPUT_IMAGE_PRICE_TABLE: &[(u32, u32, [u64; 3])] = &[
+  // 1:1
+  (1024, 1024, [ 65, 152,  582]),
+  (2048, 2048, [103, 239,  919]),
+  (2880, 2880, [151, 352, 1357]),
+  // 4:3
+  (1024,  768, [ 46, 105,  400]),
+  (2048, 1536, [ 73, 170,  652]),
+  (3072, 2304, [120, 279, 1073]),
+  (3312, 2480, [134, 311, 1194]),
+  // 16:9
+  (1088,  608, [ 32,  75,  285]),
+  (1920, 1080, [ 49, 114,  436]),
+  (2048, 1152, [ 53, 121,  467]),
+  (3072, 1728, [ 87, 204,  783]),
+  (3840, 2160, [124, 286, 1102]),
+];
+
+/// Artcraft price per reference image on an edit request, in hundredths of a US cent.
+const REFERENCE_IMAGE_PRICE: u64 = 88;
+
+/// The inputs that determine an Artcraft GPT Image 2.5 price. Shared by Flare and Sunburst,
+/// which are priced identically.
+#[derive(Clone, Debug)]
+pub struct ArtcraftGptImage2p5CostInputs {
+  pub quality: Option<CommonQualityEnum>,
+  pub aspect_ratio: Option<CommonAspectRatioEnum>,
+  pub resolution: Option<CommonResolutionEnum>,
+  pub num_reference_images: usize,
+  pub num_images: u16,
+}
+
+impl ArtcraftGptImage2p5CostInputs {
+  pub fn from_omni_request(request: &OmniGenImageCostAndGenerateRequest) -> Self {
+    Self {
+      quality: request.quality,
+      aspect_ratio: request.aspect_ratio,
+      resolution: request.resolution,
+      num_reference_images: request.image_media_tokens.as_ref().map(|tokens| tokens.len()).unwrap_or(0),
+      num_images: request.image_batch_count.unwrap_or(1),
+    }
+  }
+
+  /// Per-image price rounded up to whole cents, times the batch size. Quality defaults to
+  /// high. Without an aspect ratio, text-to-image prices as landscape 4:3 and edit as auto,
+  /// matching the Fal defaults the request would fall back to.
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    let quality = self.quality.unwrap_or(CommonQualityEnum::High);
+    let (width, height) = self.output_dimensions();
+    let hundredths_per_image = output_image_price(quality, width, height)
+      + REFERENCE_IMAGE_PRICE * self.num_reference_images as u64;
+    let cost_in_usd_cents = hundredths_per_image.div_ceil(100) * self.num_images as u64;
+
+    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,
+      failures_are_refunded: None,
+    }
+  }
+
+  fn output_dimensions(&self) -> (u32, u32) {
+    let is_edit = self.num_reference_images > 0;
+    let default_size = if is_edit { GptImage2p5ImageSize::Auto } else { GptImage2p5ImageSize::Landscape4x3 };
+    let size = self.aspect_ratio.map(to_image_size).unwrap_or(default_size);
+    size.estimated_output_dimensions(self.resolution.map(to_resolution))
+  }
+}
+
+/// Look up the per-image price. Dimensions not in the table fall back to the largest row,
+/// which is the most expensive.
+fn output_image_price(quality: CommonQualityEnum, width: u32, height: u32) -> u64 {
+  let prices = lookup_price_row(width, height)
+    .unwrap_or_else(|| OUTPUT_IMAGE_PRICE_TABLE[OUTPUT_IMAGE_PRICE_TABLE.len() - 1].2);
+  match quality {
+    CommonQualityEnum::Low => prices[0],
+    CommonQualityEnum::Medium => prices[1],
+    CommonQualityEnum::High => prices[2],
+  }
+}
+
+fn lookup_price_row(width: u32, height: u32) -> Option<[u64; 3]> {
+  let long_edge = width.max(height);
+  let short_edge = width.min(height);
+  OUTPUT_IMAGE_PRICE_TABLE.iter()
+    .find(|(w, h, _)| *w == long_edge && *h == short_edge)
+    .map(|(_, _, prices)| *prices)
+}
+
+/// Mirrors the Fal request builder's aspect ratio mapping.
+fn to_image_size(aspect_ratio: CommonAspectRatioEnum) -> GptImage2p5ImageSize {
+  use CommonAspectRatioEnum as Ar;
+  match aspect_ratio {
+    Ar::Auto | Ar::Auto2k | Ar::Auto3k | Ar::Auto4k => GptImage2p5ImageSize::Auto,
+    Ar::Square => GptImage2p5ImageSize::Square,
+    Ar::SquareHd => GptImage2p5ImageSize::SquareHd,
+    Ar::WideFourByThree | Ar::WideFiveByFour => GptImage2p5ImageSize::Landscape4x3,
+    Ar::WideThreeByTwo | Ar::WideSixteenByNine | Ar::WideTwentyOneByNine | Ar::Wide => GptImage2p5ImageSize::Landscape16x9,
+    Ar::TallThreeByFour | Ar::TallFourByFive => GptImage2p5ImageSize::Portrait4x3,
+    Ar::TallTwoByThree | Ar::TallNineBySixteen | Ar::TallNineByTwentyOne | Ar::Tall => GptImage2p5ImageSize::Portrait16x9,
+  }
+}
+
+/// Mirrors the Fal request builder's resolution mapping.
+fn to_resolution(resolution: CommonResolutionEnum) -> GptImage2Resolution {
+  use CommonResolutionEnum as R;
+  match resolution {
+    R::HalfK | R::FourEightyP | R::SevenTwentyP | R::OneK => GptImage2Resolution::OneK,
+    R::TenEightyP | R::TwoK => GptImage2Resolution::TwoK,
+    R::ThreeK => GptImage2Resolution::ThreeK,
+    R::FourK => GptImage2Resolution::FourK,
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use CommonAspectRatioEnum as Ar;
+  use CommonQualityEnum as Q;
+  use CommonResolutionEnum as R;
+
+  const ALL_ASPECT_RATIOS: &[Ar] = &[
+    Ar::Auto, Ar::Auto2k, Ar::Auto3k, Ar::Auto4k, Ar::Square, Ar::SquareHd,
+    Ar::WideFourByThree, Ar::WideFiveByFour, Ar::WideThreeByTwo, Ar::WideSixteenByNine,
+    Ar::WideTwentyOneByNine, Ar::Wide, Ar::TallThreeByFour, Ar::TallFourByFive,
+    Ar::TallTwoByThree, Ar::TallNineBySixteen, Ar::TallNineByTwentyOne, Ar::Tall,
+  ];
+
+  const ALL_RESOLUTIONS: &[Option<R>] = &[
+    None, Some(R::HalfK), Some(R::FourEightyP), Some(R::SevenTwentyP), Some(R::OneK),
+    Some(R::TenEightyP), Some(R::TwoK), Some(R::ThreeK), Some(R::FourK),
+  ];
+
+  // (aspect_ratio, resolution, [low, medium, high]) — cents per image, text-to-image
+  const TEXT_GRID: &[(Option<Ar>, Option<R>, [u64; 3])] = &[
+    (None,                        None,           [1, 2,  4]), // landscape 4:3 default
+    (Some(Ar::Square),            None,           [1, 2,  6]),
+    (Some(Ar::Square),            Some(R::OneK),  [1, 2,  6]),
+    (Some(Ar::Square),            Some(R::TwoK),  [2, 3, 10]),
+    (Some(Ar::Square),            Some(R::ThreeK), [2, 4, 14]),
+    (Some(Ar::Square),            Some(R::FourK), [2, 4, 14]),
+    (Some(Ar::SquareHd),          None,           [2, 3, 10]),
+    (Some(Ar::SquareHd),          Some(R::OneK),  [1, 2,  6]),
+    (Some(Ar::WideFourByThree),   None,           [1, 2,  4]),
+    (Some(Ar::WideFourByThree),   Some(R::TwoK),  [1, 2,  7]),
+    (Some(Ar::WideFourByThree),   Some(R::ThreeK), [2, 3, 11]),
+    (Some(Ar::WideFourByThree),   Some(R::FourK), [2, 4, 12]),
+    (Some(Ar::TallThreeByFour),   None,           [1, 2,  4]),
+    (Some(Ar::TallFourByFive),    Some(R::FourK), [2, 4, 12]),
+    (Some(Ar::WideSixteenByNine), None,           [1, 2,  5]),
+    (Some(Ar::WideSixteenByNine), Some(R::OneK),  [1, 1,  3]),
+    (Some(Ar::WideSixteenByNine), Some(R::TenEightyP), [1, 2, 5]),
+    (Some(Ar::WideSixteenByNine), Some(R::TwoK),  [1, 2,  5]),
+    (Some(Ar::WideSixteenByNine), Some(R::ThreeK), [1, 3,  8]),
+    (Some(Ar::WideSixteenByNine), Some(R::FourK), [2, 3, 12]),
+    (Some(Ar::TallNineBySixteen), None,           [1, 2,  5]),
+    (Some(Ar::Wide),              Some(R::HalfK), [1, 1,  3]),
+    (Some(Ar::Tall),              Some(R::ThreeK), [1, 3,  8]),
+    (Some(Ar::Auto),              None,           [2, 3, 12]),
+    (Some(Ar::Auto4k),            Some(R::OneK),  [2, 3, 12]),
+  ];
+
+  mod text_to_image_tests {
+    use super::*;
+
+    #[test]
+    fn grid() {
+      for &(aspect_ratio, resolution, expected) in TEXT_GRID {
+        for (quality, expected) in [Q::Low, Q::Medium, Q::High].into_iter().zip(expected) {
+          let actual = make_inputs(0, Some(quality), aspect_ratio, resolution, 1).estimate_cost().cost_in_usd_cents.unwrap();
+          assert_eq!(actual, expected, "{aspect_ratio:?} {resolution:?} {quality:?}");
+        }
+      }
+    }
+
+    #[test]
+    fn quality_defaults_to_high() {
+      assert_eq!(cents(make_inputs(0, None, Some(Ar::Square), None, 1)), 6);
+    }
+
+    #[test]
+    fn batch_multiplies_per_image_cents() {
+      for &(aspect_ratio, resolution, _) in TEXT_GRID {
+        let per_image = cents(make_inputs(0, Some(Q::High), aspect_ratio, resolution, 1));
+        for batch in 2..=4u16 {
+          assert_eq!(cents(make_inputs(0, Some(Q::High), aspect_ratio, resolution, batch)), per_image * batch as u64);
+        }
+      }
+    }
+  }
+
+  mod edit_image_tests {
+    use super::*;
+
+    #[test]
+    fn no_aspect_ratio_prices_as_auto() {
+      // 1102 + 88 = 1190
+      assert_eq!(cents(make_inputs(1, Some(Q::High), None, None, 1)), 12);
+      assert_eq!(cents(make_inputs(1, Some(Q::High), Some(Ar::Auto), None, 1)), 12);
+    }
+
+    #[test]
+    fn reference_images_add_to_price() {
+      // Square high 582, plus 88 per reference image
+      assert_eq!(cents(make_inputs(1, Some(Q::High), Some(Ar::Square), None, 1)), 7);   // 670
+      assert_eq!(cents(make_inputs(4, Some(Q::High), Some(Ar::Square), None, 1)), 10);  // 934
+      assert_eq!(cents(make_inputs(16, Some(Q::High), Some(Ar::Square), None, 1)), 20); // 1990
+      assert_eq!(cents(make_inputs(1, Some(Q::Low), Some(Ar::Square), None, 1)), 2);    // 153
+    }
+
+    #[test]
+    fn batch_multiplies_per_image_cents() {
+      assert_eq!(cents(make_inputs(1, Some(Q::High), Some(Ar::Square), None, 4)), 28);
+    }
+  }
+
+  mod table_coverage_tests {
+    use super::*;
+
+    #[test]
+    fn every_reachable_dimension_has_a_table_row() {
+      for &aspect_ratio in ALL_ASPECT_RATIOS {
+        for &resolution in ALL_RESOLUTIONS {
+          for refs in [0, 1] {
+            let (w, h) = make_inputs(refs, None, Some(aspect_ratio), resolution, 1).output_dimensions();
+            assert!(lookup_price_row(w, h).is_some(), "{aspect_ratio:?} {resolution:?} => {w}x{h} missing from price table");
+          }
+        }
+      }
+      for refs in [0, 1] {
+        for &resolution in ALL_RESOLUTIONS {
+          let (w, h) = make_inputs(refs, None, None, resolution, 1).output_dimensions();
+          assert!(lookup_price_row(w, h).is_some(), "no aspect, {resolution:?}, {refs} refs => {w}x{h} missing from price table");
+        }
+      }
+    }
+
+    #[test]
+    fn unknown_dimensions_fall_back_to_most_expensive_row() {
+      assert_eq!(output_image_price(Q::High, 640, 640), 1102);
+    }
+
+    #[test]
+    fn orientation_does_not_change_price() {
+      assert_eq!(output_image_price(Q::High, 768, 1024), output_image_price(Q::High, 1024, 768));
+      assert_eq!(output_image_price(Q::Medium, 1080, 1920), output_image_price(Q::Medium, 1920, 1080));
+    }
+
+    #[test]
+    fn prices_rise_with_quality_and_size() {
+      for &(_, _, prices) in OUTPUT_IMAGE_PRICE_TABLE {
+        assert!(prices[0] < prices[1] && prices[1] < prices[2], "{prices:?}");
+      }
+      assert!(output_image_price(Q::High, 1024, 1024) < output_image_price(Q::High, 2048, 2048));
+      assert!(output_image_price(Q::High, 2048, 2048) < output_image_price(Q::High, 2880, 2880));
+      assert!(output_image_price(Q::High, 1088, 608) < output_image_price(Q::High, 1920, 1080));
+      assert!(output_image_price(Q::High, 3072, 1728) < output_image_price(Q::High, 3840, 2160));
+    }
+  }
+
+  fn cents(inputs: ArtcraftGptImage2p5CostInputs) -> u64 {
+    inputs.estimate_cost().cost_in_usd_cents.unwrap()
+  }
+
+  fn make_inputs(
+    num_reference_images: usize,
+    quality: Option<Q>,
+    aspect_ratio: Option<Ar>,
+    resolution: Option<R>,
+    num_images: u16,
+  ) -> ArtcraftGptImage2p5CostInputs {
+    ArtcraftGptImage2p5CostInputs { quality, aspect_ratio, resolution, num_reference_images, num_images }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/build.rs

@@ -0,0 +1,114 @@
+use enums::common::generation::common_image_model::CommonImageModel as CommonImageModelEnum;
+
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::artcraft::build_common::build_artcraft_omni_image_request;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_flare::request::ArtcraftGptImage2p5FlareRequestState;
+
+pub fn build_artcraft_gpt_image_2p5_flare(
+  builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let request = build_artcraft_omni_image_request(builder, CommonImageModelEnum::GptImage2p5Flare)?;
+  Ok(ImageGenerationDraftOrRequest::Request(
+    ImageGenerationRequest::ArtcraftGptImage2p5Flare(ArtcraftGptImage2p5FlareRequestState { request }),
+  ))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+  use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
+  use enums::common::generation::common_quality::CommonQuality as CommonQualityEnum;
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::errors::client_error::ClientError;
+
+  #[test]
+  fn build2_routes_to_omni_request_with_flare_model() {
+    let request = unwrap_request(base_builder().build2());
+    assert_eq!(request.model, Some(CommonImageModelEnum::GptImage2p5Flare));
+    assert_eq!(request.prompt.as_deref(), Some("a cat in space"));
+    assert_eq!(request.image_batch_count, Some(1));
+    assert!(request.image_media_tokens.is_none());
+    assert!(request.aspect_ratio.is_none());
+    assert!(request.resolution.is_none());
+    assert!(request.quality.is_none());
+    assert!(request.idempotency_token.is_some());
+  }
+
+  #[test]
+  fn omni_request_carries_all_generation_fields() {
+    let request = unwrap_request(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
+      resolution: Some(RouterResolution::TwoK),
+      quality: Some(RouterQuality::Medium),
+      image_batch_count: Some(3),
+      idempotency_token: Some("idem-123".to_string()),
+      image_inputs: Some(ImageListRef::MediaFileTokens(vec![MediaFileToken::generate(), MediaFileToken::generate()])),
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.aspect_ratio, Some(CommonAspectRatioEnum::WideSixteenByNine));
+    assert_eq!(request.resolution, Some(CommonResolutionEnum::TwoK));
+    assert_eq!(request.quality, Some(CommonQualityEnum::Medium));
+    assert_eq!(request.image_batch_count, Some(3));
+    assert_eq!(request.idempotency_token.as_deref(), Some("idem-123"));
+    assert_eq!(request.image_media_tokens.map(|tokens| tokens.len()), Some(2));
+  }
+
+  #[test]
+  fn batch_count_is_validated() {
+    assert!(matches!(
+      GenerateImageRequestBuilder { image_batch_count: Some(0), ..base_builder() }.build2(),
+      Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+    ));
+    assert!(matches!(
+      GenerateImageRequestBuilder { image_batch_count: Some(5), ..base_builder() }.build2(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+    let request = unwrap_request(GenerateImageRequestBuilder {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayLessDowngrade,
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.image_batch_count, Some(4));
+  }
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Flare,
+      provider: RouterProvider::Artcraft,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn unwrap_request(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> OmniGenImageCostAndGenerateRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::ArtcraftGptImage2p5Flare(state)
+    ) = result.expect("build should succeed") else {
+      panic!("expected Artcraft GPT Image 2.5 Flare request")
+    };
+    state.request
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/cost.rs

@@ -0,0 +1,106 @@
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_common_cost::ArtcraftGptImage2p5CostInputs;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_flare::request::ArtcraftGptImage2p5FlareRequestState;
+
+/// Cost state for Artcraft GPT Image 2.5 Flare. The price table is shared with the other
+/// GPT Image 2.5 variant; see `gpt_image_2p5_common_cost`.
+#[derive(Clone, Debug)]
+pub struct ArtcraftGptImage2p5FlareCostState {
+  inputs: ArtcraftGptImage2p5CostInputs,
+}
+
+impl ArtcraftGptImage2p5FlareCostState {
+  pub fn from_request(request: &ArtcraftGptImage2p5FlareRequestState) -> Self {
+    Self { inputs: ArtcraftGptImage2p5CostInputs::from_omni_request(&request.request) }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    self.inputs.estimate_cost()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+  use RouterAspectRatio as Ar;
+  use RouterQuality as Q;
+  use RouterResolution as R;
+
+  // (reference_images, quality, aspect_ratio, resolution, batch, expected_cents)
+  const CASES: &[(usize, Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (0, None,            None,                        None,           1,  4),
+    (0, Some(Q::Low),    Some(Ar::Square),            None,           1,  1),
+    (0, Some(Q::Medium), Some(Ar::Square),            None,           1,  2),
+    (0, Some(Q::High),   Some(Ar::Square),            None,           1,  6),
+    (0, Some(Q::High),   Some(Ar::Square),            None,           4, 24),
+    (0, Some(Q::High),   Some(Ar::SquareHd),          None,           1, 10),
+    (0, Some(Q::High),   Some(Ar::Square),            Some(R::TwoK),  1, 10),
+    (0, Some(Q::High),   Some(Ar::Square),            Some(R::FourK), 1, 14),
+    (0, Some(Q::High),   Some(Ar::WideFourByThree),   None,           1,  4),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), None,           1,  5),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::OneK),  1,  3),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 12),
+    (0, Some(Q::Medium), Some(Ar::TallNineBySixteen), Some(R::ThreeK), 2, 6),
+    (0, Some(Q::High),   Some(Ar::Auto),              None,           1, 12),
+    (1, None,            None,                        None,           1, 12),
+    (1, Some(Q::High),   Some(Ar::Square),            None,           1,  7),
+    (4, Some(Q::High),   Some(Ar::Square),            None,           1, 10),
+    (1, Some(Q::High),   Some(Ar::Square),            None,           4, 28),
+    (1, Some(Q::Low),    Some(Ar::Square),            None,           1,  2),
+  ];
+
+  #[test]
+  fn costs_through_build2() {
+    for &(refs, quality, aspect_ratio, resolution, batch, expected) in CASES {
+      assert_eq!(cost_cents(refs, quality, aspect_ratio, resolution, batch), expected, "{refs} refs {quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn estimate_flags() {
+    let cost = builder(0, Some(Q::High), Some(Ar::Square), None, 1).build2().unwrap().estimate_cost().unwrap();
+    assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
+    assert!(!cost.is_free);
+    assert!(!cost.is_unlimited);
+    assert!(!cost.is_rate_limited);
+    assert!(!cost.has_watermark);
+  }
+
+  fn cost_cents(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> u64 {
+    builder(refs, quality, aspect_ratio, resolution, batch)
+      .build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
+  }
+
+  fn builder(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> GenerateImageRequestBuilder {
+    let image_inputs = if refs == 0 {
+      None
+    } else {
+      Some(ImageListRef::MediaFileTokens((0..refs).map(|_| MediaFileToken::generate()).collect()))
+    };
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Flare,
+      provider: RouterProvider::Artcraft,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs,
+      resolution,
+      aspect_ratio,
+      quality,
+      image_batch_count: Some(batch),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod cost;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/request.rs

@@ -0,0 +1,17 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
+use crate::generate::generate_image::providers::artcraft::request_common::send_artcraft_omni_image_request;
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftGptImage2p5FlareRequestState {
+  pub request: OmniGenImageCostAndGenerateRequest,
+}
+
+impl ArtcraftGptImage2p5FlareRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    send_artcraft_omni_image_request(&self.request, client).await
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/build.rs

@@ -0,0 +1,114 @@
+use enums::common::generation::common_image_model::CommonImageModel as CommonImageModelEnum;
+
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::artcraft::build_common::build_artcraft_omni_image_request;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_sunburst::request::ArtcraftGptImage2p5SunburstRequestState;
+
+pub fn build_artcraft_gpt_image_2p5_sunburst(
+  builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let request = build_artcraft_omni_image_request(builder, CommonImageModelEnum::GptImage2p5Sunburst)?;
+  Ok(ImageGenerationDraftOrRequest::Request(
+    ImageGenerationRequest::ArtcraftGptImage2p5Sunburst(ArtcraftGptImage2p5SunburstRequestState { request }),
+  ))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+  use enums::common::generation::common_aspect_ratio::CommonAspectRatio as CommonAspectRatioEnum;
+  use enums::common::generation::common_quality::CommonQuality as CommonQualityEnum;
+  use enums::common::generation::common_resolution::CommonResolution as CommonResolutionEnum;
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::errors::client_error::ClientError;
+
+  #[test]
+  fn build2_routes_to_omni_request_with_sunburst_model() {
+    let request = unwrap_request(base_builder().build2());
+    assert_eq!(request.model, Some(CommonImageModelEnum::GptImage2p5Sunburst));
+    assert_eq!(request.prompt.as_deref(), Some("a cat in space"));
+    assert_eq!(request.image_batch_count, Some(1));
+    assert!(request.image_media_tokens.is_none());
+    assert!(request.aspect_ratio.is_none());
+    assert!(request.resolution.is_none());
+    assert!(request.quality.is_none());
+    assert!(request.idempotency_token.is_some());
+  }
+
+  #[test]
+  fn omni_request_carries_all_generation_fields() {
+    let request = unwrap_request(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
+      resolution: Some(RouterResolution::TwoK),
+      quality: Some(RouterQuality::Medium),
+      image_batch_count: Some(3),
+      idempotency_token: Some("idem-123".to_string()),
+      image_inputs: Some(ImageListRef::MediaFileTokens(vec![MediaFileToken::generate(), MediaFileToken::generate()])),
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.aspect_ratio, Some(CommonAspectRatioEnum::WideSixteenByNine));
+    assert_eq!(request.resolution, Some(CommonResolutionEnum::TwoK));
+    assert_eq!(request.quality, Some(CommonQualityEnum::Medium));
+    assert_eq!(request.image_batch_count, Some(3));
+    assert_eq!(request.idempotency_token.as_deref(), Some("idem-123"));
+    assert_eq!(request.image_media_tokens.map(|tokens| tokens.len()), Some(2));
+  }
+
+  #[test]
+  fn batch_count_is_validated() {
+    assert!(matches!(
+      GenerateImageRequestBuilder { image_batch_count: Some(0), ..base_builder() }.build2(),
+      Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+    ));
+    assert!(matches!(
+      GenerateImageRequestBuilder { image_batch_count: Some(5), ..base_builder() }.build2(),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+    let request = unwrap_request(GenerateImageRequestBuilder {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayLessDowngrade,
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.image_batch_count, Some(4));
+  }
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Sunburst,
+      provider: RouterProvider::Artcraft,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn unwrap_request(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> OmniGenImageCostAndGenerateRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::ArtcraftGptImage2p5Sunburst(state)
+    ) = result.expect("build should succeed") else {
+      panic!("expected Artcraft GPT Image 2.5 Sunburst request")
+    };
+    state.request
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/cost.rs

@@ -0,0 +1,106 @@
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_common_cost::ArtcraftGptImage2p5CostInputs;
+use crate::generate::generate_image::providers::artcraft::gpt_image_2p5_sunburst::request::ArtcraftGptImage2p5SunburstRequestState;
+
+/// Cost state for Artcraft GPT Image 2.5 Sunburst. The price table is shared with the other
+/// GPT Image 2.5 variant; see `gpt_image_2p5_common_cost`.
+#[derive(Clone, Debug)]
+pub struct ArtcraftGptImage2p5SunburstCostState {
+  inputs: ArtcraftGptImage2p5CostInputs,
+}
+
+impl ArtcraftGptImage2p5SunburstCostState {
+  pub fn from_request(request: &ArtcraftGptImage2p5SunburstRequestState) -> Self {
+    Self { inputs: ArtcraftGptImage2p5CostInputs::from_omni_request(&request.request) }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    self.inputs.estimate_cost()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use tokens::tokens::media_files::MediaFileToken;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+  use RouterAspectRatio as Ar;
+  use RouterQuality as Q;
+  use RouterResolution as R;
+
+  // (reference_images, quality, aspect_ratio, resolution, batch, expected_cents)
+  const CASES: &[(usize, Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (0, None,            None,                        None,           1,  4),
+    (0, Some(Q::Low),    Some(Ar::Square),            None,           1,  1),
+    (0, Some(Q::Medium), Some(Ar::Square),            None,           1,  2),
+    (0, Some(Q::High),   Some(Ar::Square),            None,           1,  6),
+    (0, Some(Q::High),   Some(Ar::Square),            None,           4, 24),
+    (0, Some(Q::High),   Some(Ar::SquareHd),          None,           1, 10),
+    (0, Some(Q::High),   Some(Ar::Square),            Some(R::TwoK),  1, 10),
+    (0, Some(Q::High),   Some(Ar::Square),            Some(R::FourK), 1, 14),
+    (0, Some(Q::High),   Some(Ar::WideFourByThree),   None,           1,  4),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), None,           1,  5),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::OneK),  1,  3),
+    (0, Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 12),
+    (0, Some(Q::Medium), Some(Ar::TallNineBySixteen), Some(R::ThreeK), 2, 6),
+    (0, Some(Q::High),   Some(Ar::Auto),              None,           1, 12),
+    (1, None,            None,                        None,           1, 12),
+    (1, Some(Q::High),   Some(Ar::Square),            None,           1,  7),
+    (4, Some(Q::High),   Some(Ar::Square),            None,           1, 10),
+    (1, Some(Q::High),   Some(Ar::Square),            None,           4, 28),
+    (1, Some(Q::Low),    Some(Ar::Square),            None,           1,  2),
+  ];
+
+  #[test]
+  fn costs_through_build2() {
+    for &(refs, quality, aspect_ratio, resolution, batch, expected) in CASES {
+      assert_eq!(cost_cents(refs, quality, aspect_ratio, resolution, batch), expected, "{refs} refs {quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn estimate_flags() {
+    let cost = builder(0, Some(Q::High), Some(Ar::Square), None, 1).build2().unwrap().estimate_cost().unwrap();
+    assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
+    assert!(!cost.is_free);
+    assert!(!cost.is_unlimited);
+    assert!(!cost.is_rate_limited);
+    assert!(!cost.has_watermark);
+  }
+
+  fn cost_cents(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> u64 {
+    builder(refs, quality, aspect_ratio, resolution, batch)
+      .build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
+  }
+
+  fn builder(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> GenerateImageRequestBuilder {
+    let image_inputs = if refs == 0 {
+      None
+    } else {
+      Some(ImageListRef::MediaFileTokens((0..refs).map(|_| MediaFileToken::generate()).collect()))
+    };
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Sunburst,
+      provider: RouterProvider::Artcraft,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs,
+      resolution,
+      aspect_ratio,
+      quality,
+      image_batch_count: Some(batch),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod cost;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/request.rs

@@ -0,0 +1,17 @@
+use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_image_cost_and_generate_request::OmniGenImageCostAndGenerateRequest;
+
+use crate::client::router_artcraft_client::RouterArtcraftClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
+use crate::generate::generate_image::providers::artcraft::request_common::send_artcraft_omni_image_request;
+
+#[derive(Clone, Debug)]
+pub struct ArtcraftGptImage2p5SunburstRequestState {
+  pub request: OmniGenImageCostAndGenerateRequest,
+}
+
+impl ArtcraftGptImage2p5SunburstRequestState {
+  pub async fn send(&self, client: &RouterArtcraftClient) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    send_artcraft_omni_image_request(&self.request, client).await
+  }
+}

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

@@ -8,6 +8,9 @@ pub mod flux_pro_1p1_ultra;
 pub mod gpt_image_1;
 pub mod gpt_image_1p5;
 pub mod gpt_image_2;
+pub(crate) mod gpt_image_2p5_common_cost;
+pub mod gpt_image_2p5_flare;
+pub mod gpt_image_2p5_sunburst;
 pub mod midjourney_7;
 pub mod midjourney_7_niji;
 pub mod midjourney_8;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/mod.rs

@@ -0,0 +1,5 @@
+//! Planning and transport shared by the GPT Image 2.5 Flare and Sunburst Fal providers.
+//! The two models take identical parameters; only the Fal endpoint differs.
+
+pub mod plan;
+pub mod send;

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

@@ -0,0 +1,330 @@
+use fal_client::requests::api::image::common::gpt_image_2_resolution::GptImage2Resolution;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_edit_image_params::GptImage2p5EditImageParams;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_image_size::GptImage2p5ImageSize;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_num_images::GptImage2p5NumImages;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_quality::GptImage2p5Quality;
+use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_text_to_image_params::GptImage2p5TextToImageParams;
+
+use crate::api::image_list_ref::ImageListRef;
+use crate::api::router_aspect_ratio::RouterAspectRatio;
+use crate::api::router_quality::RouterQuality;
+use crate::api::router_resolution::RouterResolution;
+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_builder::GenerateImageRequestBuilder;
+
+/// Planned GPT Image 2.5 parameters. The mode is chosen by whether the builder carries
+/// reference images: none means text-to-image, one or more means edit.
+#[derive(Clone, Debug)]
+pub enum PlannedGptImage2p5Params {
+  TextToImage(GptImage2p5TextToImageParams),
+  EditImage(GptImage2p5EditImageParams),
+}
+
+pub fn plan_gpt_image_2p5_params(
+  builder: &GenerateImageRequestBuilder,
+) -> Result<PlannedGptImage2p5Params, ArtcraftRouterError> {
+  let prompt = builder.prompt.clone().unwrap_or_default();
+  let image_urls = resolve_image_urls(builder.image_inputs.clone())?;
+  let num_images = plan_num_images(builder.image_batch_count, builder.request_mismatch_mitigation_strategy)?;
+  let image_size = plan_image_size(builder.aspect_ratio);
+  let resolution = plan_resolution(builder.resolution);
+  let quality = Some(plan_quality(builder.quality));
+
+  if image_urls.is_empty() {
+    Ok(PlannedGptImage2p5Params::TextToImage(GptImage2p5TextToImageParams {
+      prompt,
+      num_images,
+      image_size,
+      resolution,
+      quality,
+      background: None,
+      output_format: None,
+      output_compression: None,
+    }))
+  } else {
+    Ok(PlannedGptImage2p5Params::EditImage(GptImage2p5EditImageParams {
+      prompt,
+      image_urls,
+      mask_url: None,
+      num_images,
+      image_size,
+      resolution,
+      quality,
+      background: None,
+      output_format: None,
+      output_compression: None,
+    }))
+  }
+}
+
+fn plan_num_images(
+  count: Option<u16>,
+  strategy: RequestMismatchMitigationStrategy,
+) -> Result<GptImage2p5NumImages, ArtcraftRouterError> {
+  let count = count.unwrap_or(1);
+  match count {
+    0 => Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations)),
+    1 => Ok(GptImage2p5NumImages::One),
+    2 => Ok(GptImage2p5NumImages::Two),
+    3 => Ok(GptImage2p5NumImages::Three),
+    4 => Ok(GptImage2p5NumImages::Four),
+    _ => match strategy {
+      RequestMismatchMitigationStrategy::ErrorOut => {
+        Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption {
+          field: "image_batch_count",
+          value: format!("{}", count),
+        }))
+      }
+      _ => Ok(GptImage2p5NumImages::Four),
+    },
+  }
+}
+
+/// The router only exposes low / medium / high; GPT Image 2.5's `xhigh` and `max` tiers are
+/// not reachable through it. Fal's default (`high`) applies when unspecified.
+fn plan_quality(quality: Option<RouterQuality>) -> GptImage2p5Quality {
+  match quality {
+    Some(RouterQuality::Low) => GptImage2p5Quality::Low,
+    Some(RouterQuality::Medium) => GptImage2p5Quality::Medium,
+    Some(RouterQuality::High) | None => GptImage2p5Quality::High,
+  }
+}
+
+fn plan_resolution(resolution: Option<RouterResolution>) -> Option<GptImage2Resolution> {
+  resolution.map(|r| match r {
+    RouterResolution::HalfK
+    | RouterResolution::FourEightyP
+    | RouterResolution::SevenTwentyP
+    | RouterResolution::OneK => GptImage2Resolution::OneK,
+    RouterResolution::TenEightyP | RouterResolution::TwoK => GptImage2Resolution::TwoK,
+    RouterResolution::ThreeK => GptImage2Resolution::ThreeK,
+    RouterResolution::FourK => GptImage2Resolution::FourK,
+  })
+}
+
+/// `None` lets Fal apply its own default (`landscape_4_3` for text-to-image, `auto` for edit).
+fn plan_image_size(aspect_ratio: Option<RouterAspectRatio>) -> Option<GptImage2p5ImageSize> {
+  aspect_ratio.map(|ar| match ar {
+    RouterAspectRatio::Auto
+    | RouterAspectRatio::Auto2k
+    | RouterAspectRatio::Auto3k
+    | RouterAspectRatio::Auto4k => GptImage2p5ImageSize::Auto,
+    RouterAspectRatio::Square => GptImage2p5ImageSize::Square,
+    RouterAspectRatio::SquareHd => GptImage2p5ImageSize::SquareHd,
+    RouterAspectRatio::WideFourByThree
+    | RouterAspectRatio::WideFiveByFour => GptImage2p5ImageSize::Landscape4x3,
+    RouterAspectRatio::WideThreeByTwo
+    | RouterAspectRatio::WideSixteenByNine
+    | RouterAspectRatio::WideTwentyOneByNine
+    | RouterAspectRatio::Wide => GptImage2p5ImageSize::Landscape16x9,
+    RouterAspectRatio::TallThreeByFour
+    | RouterAspectRatio::TallFourByFive => GptImage2p5ImageSize::Portrait4x3,
+    RouterAspectRatio::TallTwoByThree
+    | RouterAspectRatio::TallNineBySixteen
+    | RouterAspectRatio::TallNineByTwentyOne
+    | RouterAspectRatio::Tall => GptImage2p5ImageSize::Portrait16x9,
+  })
+}
+
+fn resolve_image_urls(
+  image_inputs: Option<ImageListRef>,
+) -> Result<Vec<String>, ArtcraftRouterError> {
+  match image_inputs {
+    None => Ok(vec![]),
+    Some(ImageListRef::Urls(urls)) => Ok(urls),
+    Some(ImageListRef::MediaFileTokens(_)) => {
+      Err(ArtcraftRouterError::Client(ClientError::FalOnlySupportsUrls))
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use std::fmt::Debug;
+
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+
+  const IMAGE_URL: &str = "https://example.com/img.jpg";
+
+  #[test]
+  fn mode_is_based_on_image_urls() {
+    let text = unwrap_t2i(plan_gpt_image_2p5_params(&base_builder()));
+    assert_eq!(text.prompt, "a cat in space");
+
+    let edit = unwrap_edit(plan_gpt_image_2p5_params(&with_reference_image(base_builder())));
+    assert_eq!(edit.prompt, "a cat in space");
+    assert_eq!(edit.image_urls, vec![IMAGE_URL]);
+    assert!(edit.mask_url.is_none());
+  }
+
+  #[test]
+  fn optional_fal_fields_are_left_to_fal_defaults() {
+    let text = unwrap_t2i(plan_gpt_image_2p5_params(&base_builder()));
+    assert!(text.background.is_none());
+    assert!(text.output_format.is_none());
+    assert!(text.output_compression.is_none());
+    assert!(text.image_size.is_none());
+    assert!(text.resolution.is_none());
+  }
+
+  #[test]
+  fn media_file_tokens_are_rejected() {
+    let result = plan_gpt_image_2p5_params(&GenerateImageRequestBuilder {
+      image_inputs: Some(ImageListRef::MediaFileTokens(vec![])),
+      ..base_builder()
+    });
+    assert!(matches!(result, Err(ArtcraftRouterError::Client(ClientError::FalOnlySupportsUrls))));
+  }
+
+  #[test]
+  fn num_images_maps_exhaustively_for_text_and_edit() {
+    let cases = [(1, "One"), (2, "Two"), (3, "Three"), (4, "Four")];
+    for (count, expected) in cases {
+      let text = unwrap_t2i(plan_gpt_image_2p5_params(&GenerateImageRequestBuilder {
+        image_batch_count: Some(count),
+        ..base_builder()
+      }));
+      assert_debug(text.num_images, expected);
+
+      let edit = unwrap_edit(plan_gpt_image_2p5_params(&with_reference_image(GenerateImageRequestBuilder {
+        image_batch_count: Some(count),
+        ..base_builder()
+      })));
+      assert_debug(edit.num_images, expected);
+    }
+  }
+
+  #[test]
+  fn num_images_rejects_zero_and_handles_overflow_by_strategy() {
+    assert!(matches!(
+      plan_gpt_image_2p5_params(&GenerateImageRequestBuilder { image_batch_count: Some(0), ..base_builder() }),
+      Err(ArtcraftRouterError::Client(ClientError::UserRequestedZeroGenerations))
+    ));
+    assert!(matches!(
+      plan_gpt_image_2p5_params(&GenerateImageRequestBuilder { image_batch_count: Some(5), ..base_builder() }),
+      Err(ArtcraftRouterError::Client(ClientError::ModelDoesNotSupportOption { .. }))
+    ));
+    let text = unwrap_t2i(plan_gpt_image_2p5_params(&GenerateImageRequestBuilder {
+      image_batch_count: Some(5),
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::PayMoreUpgrade,
+      ..base_builder()
+    }));
+    assert_debug(text.num_images, "Four");
+  }
+
+  #[test]
+  fn quality_maps_exhaustively_for_text_and_edit() {
+    let cases = [
+      (None, "Some(High)"),
+      (Some(RouterQuality::Low), "Some(Low)"),
+      (Some(RouterQuality::Medium), "Some(Medium)"),
+      (Some(RouterQuality::High), "Some(High)"),
+    ];
+    for (quality, expected) in cases {
+      let text = unwrap_t2i(plan_gpt_image_2p5_params(&GenerateImageRequestBuilder { quality, ..base_builder() }));
+      assert_debug(text.quality, expected);
+      let edit = unwrap_edit(plan_gpt_image_2p5_params(&with_reference_image(GenerateImageRequestBuilder { quality, ..base_builder() })));
+      assert_debug(edit.quality, expected);
+    }
+  }
+
+  #[test]
+  fn resolution_maps_exhaustively_for_text_and_edit() {
+    let cases = [
+      (None, "None"),
+      (Some(RouterResolution::HalfK), "Some(OneK)"),
+      (Some(RouterResolution::FourEightyP), "Some(OneK)"),
+      (Some(RouterResolution::SevenTwentyP), "Some(OneK)"),
+      (Some(RouterResolution::OneK), "Some(OneK)"),
+      (Some(RouterResolution::TenEightyP), "Some(TwoK)"),
+      (Some(RouterResolution::TwoK), "Some(TwoK)"),
+      (Some(RouterResolution::ThreeK), "Some(ThreeK)"),
+      (Some(RouterResolution::FourK), "Some(FourK)"),
+    ];
+    for (resolution, expected) in cases {
+      let text = unwrap_t2i(plan_gpt_image_2p5_params(&GenerateImageRequestBuilder { resolution, ..base_builder() }));
+      assert_debug(text.resolution, expected);
+      let edit = unwrap_edit(plan_gpt_image_2p5_params(&with_reference_image(GenerateImageRequestBuilder { resolution, ..base_builder() })));
+      assert_debug(edit.resolution, expected);
+    }
+  }
+
+  #[test]
+  fn aspect_ratio_maps_exhaustively_for_text_and_edit() {
+    let cases = [
+      (None, "None"),
+      (Some(RouterAspectRatio::Auto), "Some(Auto)"),
+      (Some(RouterAspectRatio::Auto2k), "Some(Auto)"),
+      (Some(RouterAspectRatio::Auto3k), "Some(Auto)"),
+      (Some(RouterAspectRatio::Auto4k), "Some(Auto)"),
+      (Some(RouterAspectRatio::Square), "Some(Square)"),
+      (Some(RouterAspectRatio::SquareHd), "Some(SquareHd)"),
+      (Some(RouterAspectRatio::WideThreeByTwo), "Some(Landscape16x9)"),
+      (Some(RouterAspectRatio::WideFourByThree), "Some(Landscape4x3)"),
+      (Some(RouterAspectRatio::WideFiveByFour), "Some(Landscape4x3)"),
+      (Some(RouterAspectRatio::WideSixteenByNine), "Some(Landscape16x9)"),
+      (Some(RouterAspectRatio::WideTwentyOneByNine), "Some(Landscape16x9)"),
+      (Some(RouterAspectRatio::Wide), "Some(Landscape16x9)"),
+      (Some(RouterAspectRatio::TallTwoByThree), "Some(Portrait16x9)"),
+      (Some(RouterAspectRatio::TallThreeByFour), "Some(Portrait4x3)"),
+      (Some(RouterAspectRatio::TallFourByFive), "Some(Portrait4x3)"),
+      (Some(RouterAspectRatio::TallNineBySixteen), "Some(Portrait16x9)"),
+      (Some(RouterAspectRatio::TallNineByTwentyOne), "Some(Portrait16x9)"),
+      (Some(RouterAspectRatio::Tall), "Some(Portrait16x9)"),
+    ];
+    for (aspect_ratio, expected) in cases {
+      let text = unwrap_t2i(plan_gpt_image_2p5_params(&GenerateImageRequestBuilder { aspect_ratio, ..base_builder() }));
+      assert_debug(text.image_size, expected);
+      let edit = unwrap_edit(plan_gpt_image_2p5_params(&with_reference_image(GenerateImageRequestBuilder { aspect_ratio, ..base_builder() })));
+      assert_debug(edit.image_size, expected);
+    }
+  }
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Flare,
+      provider: RouterProvider::Fal,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn with_reference_image(builder: GenerateImageRequestBuilder) -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      image_inputs: Some(ImageListRef::Urls(vec![IMAGE_URL.to_string()])),
+      ..builder
+    }
+  }
+
+  fn unwrap_t2i(result: Result<PlannedGptImage2p5Params, ArtcraftRouterError>) -> GptImage2p5TextToImageParams {
+    match result.expect("plan should succeed") {
+      PlannedGptImage2p5Params::TextToImage(params) => params,
+      PlannedGptImage2p5Params::EditImage(_) => panic!("expected text-to-image"),
+    }
+  }
+
+  fn unwrap_edit(result: Result<PlannedGptImage2p5Params, ArtcraftRouterError>) -> GptImage2p5EditImageParams {
+    match result.expect("plan should succeed") {
+      PlannedGptImage2p5Params::EditImage(params) => params,
+      PlannedGptImage2p5Params::TextToImage(_) => panic!("expected edit-image"),
+    }
+  }
+
+  fn assert_debug<T: Debug>(actual: T, expected: &str) {
+    assert_eq!(format!("{:?}", actual), expected);
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/send.rs

@@ -0,0 +1,42 @@
+use std::fmt::Debug;
+use std::sync::Arc;
+
+use fal_client::requests::traits::fal_endpoint_trait::FalEndpoint;
+
+use crate::client::router_fal_client::RouterFalClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::{FalImageResponsePayload, GenerateImageResponse};
+
+/// Send any GPT Image 2.5 request (Flare or Sunburst, text-to-image or edit) to Fal, via
+/// webhook when the client has one configured and via the queue otherwise.
+pub async fn send_gpt_image_2p5_request<T>(
+  request: &T,
+  client: &RouterFalClient,
+) -> Result<GenerateImageResponse, ArtcraftRouterError>
+where
+  T: FalEndpoint + Clone + Debug + Send + Sync + 'static,
+{
+  let outbound: Arc<dyn Debug + Send + Sync> = Arc::new(request.clone());
+
+  let payload = if let Some(webhook_url) = &client.webhook_url {
+    let response = request.send_webhook_request(&client.api_key, webhook_url).await?;
+    FalImageResponsePayload {
+      request_id: response.request_id,
+      gateway_request_id: response.gateway_request_id,
+      maybe_status_url: None,
+      maybe_response_url: None,
+      maybe_outbound_request: Some(outbound),
+    }
+  } else {
+    let response = request.send_queue_request(&client.api_key).await?;
+    FalImageResponsePayload {
+      request_id: Some(response.request_id),
+      gateway_request_id: None,
+      maybe_status_url: Some(response.status_url),
+      maybe_response_url: Some(response.response_url),
+      maybe_outbound_request: Some(outbound),
+    }
+  };
+
+  Ok(GenerateImageResponse::Fal(payload))
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/build.rs

@@ -0,0 +1,129 @@
+use fal_client::requests::api::image::edit::gpt_image_2p5_flare_edit_image::api::GptImage2p5FlareEditImageRequest;
+use fal_client::requests::api::image::text::gpt_image_2p5_flare_text_to_image::api::GptImage2p5FlareTextToImageRequest;
+
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_common::plan::{plan_gpt_image_2p5_params, PlannedGptImage2p5Params};
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_flare::request::FalGptImage2p5FlareRequestState;
+
+/// Text-to-image and edit share one model entry; the mode is chosen by whether the builder
+/// carries reference images. Planning is shared with the other GPT Image 2.5 variant.
+pub fn build_fal_gpt_image_2p5_flare(
+  builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let state = match plan_gpt_image_2p5_params(&builder)? {
+    PlannedGptImage2p5Params::TextToImage(params) => {
+      FalGptImage2p5FlareRequestState::TextToImage(GptImage2p5FlareTextToImageRequest { params })
+    }
+    PlannedGptImage2p5Params::EditImage(params) => {
+      FalGptImage2p5FlareRequestState::EditImage(GptImage2p5FlareEditImageRequest { params })
+    }
+  };
+
+  Ok(ImageGenerationDraftOrRequest::Request(
+    ImageGenerationRequest::FalGptImage2p5Flare(state),
+  ))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use fal_client::requests::traits::fal_endpoint_trait::FalEndpoint;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+
+  #[test]
+  fn build2_routes_to_flare_text_to_image() {
+    let request = unwrap_t2i(base_builder().build2());
+    assert_eq!(request.params.prompt, "a cat in space");
+    assert_eq!(GptImage2p5FlareTextToImageRequest::ENDPOINT, "openai/gpt-image-2.5/flare/text-to-image");
+  }
+
+  #[test]
+  fn build2_routes_to_flare_edit_when_reference_images_present() {
+    let request = unwrap_edit(GenerateImageRequestBuilder {
+      image_inputs: Some(ImageListRef::Urls(vec!["https://example.com/img.jpg".to_string()])),
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.params.image_urls, vec!["https://example.com/img.jpg"]);
+    assert_eq!(GptImage2p5FlareEditImageRequest::ENDPOINT, "openai/gpt-image-2.5/flare/edit");
+  }
+
+  #[test]
+  fn planned_fields_reach_the_fal_request() {
+    let request = unwrap_t2i(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
+      resolution: Some(RouterResolution::TwoK),
+      quality: Some(RouterQuality::Medium),
+      image_batch_count: Some(3),
+      ..base_builder()
+    }.build2());
+    assert_eq!(format!("{:?}", request.params.image_size), "Some(Landscape16x9)");
+    assert_eq!(format!("{:?}", request.params.resolution), "Some(TwoK)");
+    assert_eq!(format!("{:?}", request.params.quality), "Some(Medium)");
+    assert_eq!(format!("{:?}", request.params.num_images), "Three");
+  }
+
+  #[test]
+  fn raw_wire_request_matches_fal_schema() {
+    let request = unwrap_t2i(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::Square),
+      quality: Some(RouterQuality::High),
+      image_batch_count: Some(2),
+      ..base_builder()
+    }.build2());
+    let json = serde_json::to_value(request.to_raw_request().unwrap()).unwrap();
+    assert_eq!(json, serde_json::json!({
+      "prompt": "a cat in space",
+      "image_size": "square",
+      "quality": "high",
+      "num_images": 2,
+      "output_format": "png",
+    }));
+  }
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Flare,
+      provider: RouterProvider::Fal,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn unwrap_t2i(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> GptImage2p5FlareTextToImageRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::FalGptImage2p5Flare(FalGptImage2p5FlareRequestState::TextToImage(request))
+    ) = result.expect("build should succeed") else {
+      panic!("expected GPT Image 2.5 Flare text-to-image request")
+    };
+    request
+  }
+
+  fn unwrap_edit(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> GptImage2p5FlareEditImageRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::FalGptImage2p5Flare(FalGptImage2p5FlareRequestState::EditImage(request))
+    ) = result.expect("build should succeed") else {
+      panic!("expected GPT Image 2.5 Flare edit-image request")
+    };
+    request
+  }
+}

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

@@ -0,0 +1,133 @@
+use fal_client::requests::traits::fal_request_cost_calculator_trait::FalRequestCostCalculator;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_flare::request::FalGptImage2p5FlareRequestState;
+
+/// Cost state for Fal GPT Image 2.5 Flare. Delegates to `fal_client`'s calculator, which
+/// prices by output dimensions (aspect ratio and resolution tier), quality, batch size and,
+/// for edits, the number of reference images.
+#[derive(Clone, Debug)]
+pub struct FalGptImage2p5FlareCostState {
+  cost_in_usd_cents: u64,
+}
+
+impl FalGptImage2p5FlareCostState {
+  pub fn from_request(request: &FalGptImage2p5FlareRequestState) -> Self {
+    let cost_in_usd_cents = match request {
+      FalGptImage2p5FlareRequestState::TextToImage(request) => request.calculate_cost_in_cents(),
+      FalGptImage2p5FlareRequestState::EditImage(request) => request.calculate_cost_in_cents(),
+    };
+    Self { cost_in_usd_cents }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    ImageGenerationCostEstimate {
+      cost_in_credits: Some(self.cost_in_usd_cents),
+      cost_in_usd_cents: Some(self.cost_in_usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+  use RouterAspectRatio as Ar;
+  use RouterQuality as Q;
+  use RouterResolution as R;
+
+  // (quality, aspect_ratio, resolution, batch, expected_cents) — text-to-image
+  const TEXT_CASES: &[(Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (None,            None,                    None,          1,  4), // Fal default: landscape_4_3, high
+    (Some(Q::Low),    Some(Ar::Square),        None,          1,  1),
+    (Some(Q::Medium), Some(Ar::Square),        None,          1,  2),
+    (Some(Q::High),   Some(Ar::Square),        None,          1,  6),
+    (Some(Q::High),   Some(Ar::Square),        None,          4, 24),
+    (Some(Q::High),   Some(Ar::SquareHd),      None,          1,  9),
+    (Some(Q::High),   Some(Ar::Square),        Some(R::TwoK), 1,  9),
+    (Some(Q::High),   Some(Ar::Square),        Some(R::FourK), 1, 13),
+    (Some(Q::High),   Some(Ar::WideFourByThree), None,        1,  4),
+    (Some(Q::High),   Some(Ar::TallThreeByFour), None,        1,  4),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), None,      1,  4),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::OneK), 1, 3),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 11),
+    (Some(Q::Medium), Some(Ar::TallNineBySixteen), Some(R::ThreeK), 2, 4),
+    (Some(Q::High),   Some(Ar::Auto),          None,          1, 11),
+    (Some(Q::High),   Some(Ar::Auto4k),        None,          1, 11),
+  ];
+
+  // (reference_images, quality, aspect_ratio, resolution, batch, expected_cents) — edit
+  const EDIT_CASES: &[(usize, Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (1, None,          None,             None,          1, 11), // Fal default: auto, high
+    (1, Some(Q::Low),  Some(Ar::Square), None,          1,  2),
+    (1, Some(Q::High), Some(Ar::Square), None,          1,  7),
+    (3, Some(Q::High), Some(Ar::Square), None,          1,  8),
+    (1, Some(Q::High), Some(Ar::Square), None,          4, 28),
+    (1, Some(Q::High), Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 11),
+    (2, Some(Q::High), Some(Ar::Auto),   None,          1, 12),
+  ];
+
+  #[test]
+  fn text_to_image_costs() {
+    for &(quality, aspect_ratio, resolution, batch, expected) in TEXT_CASES {
+      assert_eq!(cost_cents(0, quality, aspect_ratio, resolution, batch), expected, "{quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn edit_image_costs() {
+    for &(refs, quality, aspect_ratio, resolution, batch, expected) in EDIT_CASES {
+      assert_eq!(cost_cents(refs, quality, aspect_ratio, resolution, batch), expected, "{refs} refs {quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn estimate_flags() {
+    let cost = builder(0, Some(Q::High), Some(Ar::Square), None, 1).build2().unwrap().estimate_cost().unwrap();
+    assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
+    assert!(!cost.is_free);
+    assert!(!cost.is_unlimited);
+    assert!(!cost.is_rate_limited);
+    assert!(!cost.has_watermark);
+  }
+
+  fn cost_cents(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> u64 {
+    builder(refs, quality, aspect_ratio, resolution, batch)
+      .build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
+  }
+
+  fn builder(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> GenerateImageRequestBuilder {
+    let image_inputs = if refs == 0 {
+      None
+    } else {
+      Some(ImageListRef::Urls(vec!["https://example.com/img.jpg".to_string(); refs]))
+    };
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Flare,
+      provider: RouterProvider::Fal,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs,
+      resolution,
+      aspect_ratio,
+      quality,
+      image_batch_count: Some(batch),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod cost;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/request.rs

@@ -0,0 +1,86 @@
+use fal_client::requests::api::image::edit::gpt_image_2p5_flare_edit_image::api::GptImage2p5FlareEditImageRequest;
+use fal_client::requests::api::image::text::gpt_image_2p5_flare_text_to_image::api::GptImage2p5FlareTextToImageRequest;
+
+use crate::client::router_fal_client::RouterFalClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_common::send::send_gpt_image_2p5_request;
+
+#[derive(Clone, Debug)]
+pub enum FalGptImage2p5FlareRequestState {
+  TextToImage(GptImage2p5FlareTextToImageRequest),
+  EditImage(GptImage2p5FlareEditImageRequest),
+}
+
+impl FalGptImage2p5FlareRequestState {
+  pub async fn send(&self, client: &RouterFalClient) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    match self {
+      Self::TextToImage(request) => send_gpt_image_2p5_request(request, client).await,
+      Self::EditImage(request) => send_gpt_image_2p5_request(request, client).await,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use fal_client::creds::fal_api_key::FalApiKey;
+  use fal_client::requests::api::image::common::gpt_image_2_resolution::GptImage2Resolution;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_edit_image_params::GptImage2p5EditImageParams;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_image_size::GptImage2p5ImageSize;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_num_images::GptImage2p5NumImages;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_quality::GptImage2p5Quality;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_text_to_image_params::GptImage2p5TextToImageParams;
+  use test_data::web::image_urls::JUNO_AT_LAKE_IMAGE_URL;
+
+  #[tokio::test]
+  #[ignore] // requires real API key, incurs cost
+  async fn send_text_to_image_webhook() {
+    let request = FalGptImage2p5FlareRequestState::TextToImage(GptImage2p5FlareTextToImageRequest {
+      params: GptImage2p5TextToImageParams {
+        prompt: "a polished product photo of a glass compass".to_string(),
+        num_images: GptImage2p5NumImages::One,
+        image_size: Some(GptImage2p5ImageSize::Square),
+        resolution: Some(GptImage2Resolution::OneK),
+        quality: Some(GptImage2p5Quality::Low),
+        background: None,
+        output_format: None,
+        output_compression: None,
+      },
+    });
+    let response = request.send(&client_with_webhook()).await.expect("send should succeed");
+    let payload = response.get_fal_payload().expect("expected Fal payload");
+    assert!(payload.request_id.is_some() || payload.gateway_request_id.is_some());
+  }
+
+  #[tokio::test]
+  #[ignore] // requires real API key, incurs cost
+  async fn send_edit_image_webhook() {
+    let request = FalGptImage2p5FlareRequestState::EditImage(GptImage2p5FlareEditImageRequest {
+      params: GptImage2p5EditImageParams {
+        prompt: "make this look like an elegant magazine cover image".to_string(),
+        image_urls: vec![JUNO_AT_LAKE_IMAGE_URL.to_string()],
+        mask_url: None,
+        num_images: GptImage2p5NumImages::One,
+        image_size: Some(GptImage2p5ImageSize::Square),
+        resolution: Some(GptImage2Resolution::OneK),
+        quality: Some(GptImage2p5Quality::Low),
+        background: None,
+        output_format: None,
+        output_compression: None,
+      },
+    });
+    let response = request.send(&client_with_webhook()).await.expect("send should succeed");
+    let payload = response.get_fal_payload().expect("expected Fal payload");
+    assert!(payload.request_id.is_some() || payload.gateway_request_id.is_some());
+  }
+
+  fn client_with_webhook() -> RouterFalClient {
+    let secret = std::fs::read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")
+      .expect("Failed to read fal_api_key.txt");
+    RouterFalClient::new_with_webhook(
+      FalApiKey::from_str(secret.trim()),
+      "https://example.com/fal-webhook-test".to_string(),
+    )
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/build.rs

@@ -0,0 +1,129 @@
+use fal_client::requests::api::image::edit::gpt_image_2p5_sunburst_edit_image::api::GptImage2p5SunburstEditImageRequest;
+use fal_client::requests::api::image::text::gpt_image_2p5_sunburst_text_to_image::api::GptImage2p5SunburstTextToImageRequest;
+
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+use crate::generate::generate_image::image_generation_draft_or_request::ImageGenerationDraftOrRequest;
+use crate::generate::generate_image::image_generation_request::ImageGenerationRequest;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_common::plan::{plan_gpt_image_2p5_params, PlannedGptImage2p5Params};
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_sunburst::request::FalGptImage2p5SunburstRequestState;
+
+/// Text-to-image and edit share one model entry; the mode is chosen by whether the builder
+/// carries reference images. Planning is shared with the other GPT Image 2.5 variant.
+pub fn build_fal_gpt_image_2p5_sunburst(
+  builder: GenerateImageRequestBuilder,
+) -> Result<ImageGenerationDraftOrRequest, ArtcraftRouterError> {
+  let state = match plan_gpt_image_2p5_params(&builder)? {
+    PlannedGptImage2p5Params::TextToImage(params) => {
+      FalGptImage2p5SunburstRequestState::TextToImage(GptImage2p5SunburstTextToImageRequest { params })
+    }
+    PlannedGptImage2p5Params::EditImage(params) => {
+      FalGptImage2p5SunburstRequestState::EditImage(GptImage2p5SunburstEditImageRequest { params })
+    }
+  };
+
+  Ok(ImageGenerationDraftOrRequest::Request(
+    ImageGenerationRequest::FalGptImage2p5Sunburst(state),
+  ))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use fal_client::requests::traits::fal_endpoint_trait::FalEndpoint;
+
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+
+  #[test]
+  fn build2_routes_to_sunburst_text_to_image() {
+    let request = unwrap_t2i(base_builder().build2());
+    assert_eq!(request.params.prompt, "a cat in space");
+    assert_eq!(GptImage2p5SunburstTextToImageRequest::ENDPOINT, "openai/gpt-image-2.5/sunburst/text-to-image");
+  }
+
+  #[test]
+  fn build2_routes_to_sunburst_edit_when_reference_images_present() {
+    let request = unwrap_edit(GenerateImageRequestBuilder {
+      image_inputs: Some(ImageListRef::Urls(vec!["https://example.com/img.jpg".to_string()])),
+      ..base_builder()
+    }.build2());
+    assert_eq!(request.params.image_urls, vec!["https://example.com/img.jpg"]);
+    assert_eq!(GptImage2p5SunburstEditImageRequest::ENDPOINT, "openai/gpt-image-2.5/sunburst/edit");
+  }
+
+  #[test]
+  fn planned_fields_reach_the_fal_request() {
+    let request = unwrap_t2i(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::WideSixteenByNine),
+      resolution: Some(RouterResolution::TwoK),
+      quality: Some(RouterQuality::Medium),
+      image_batch_count: Some(3),
+      ..base_builder()
+    }.build2());
+    assert_eq!(format!("{:?}", request.params.image_size), "Some(Landscape16x9)");
+    assert_eq!(format!("{:?}", request.params.resolution), "Some(TwoK)");
+    assert_eq!(format!("{:?}", request.params.quality), "Some(Medium)");
+    assert_eq!(format!("{:?}", request.params.num_images), "Three");
+  }
+
+  #[test]
+  fn raw_wire_request_matches_fal_schema() {
+    let request = unwrap_t2i(GenerateImageRequestBuilder {
+      aspect_ratio: Some(RouterAspectRatio::Square),
+      quality: Some(RouterQuality::High),
+      image_batch_count: Some(2),
+      ..base_builder()
+    }.build2());
+    let json = serde_json::to_value(request.to_raw_request().unwrap()).unwrap();
+    assert_eq!(json, serde_json::json!({
+      "prompt": "a cat in space",
+      "image_size": "square",
+      "quality": "high",
+      "num_images": 2,
+      "output_format": "png",
+    }));
+  }
+
+  fn base_builder() -> GenerateImageRequestBuilder {
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Sunburst,
+      provider: RouterProvider::Fal,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs: None,
+      resolution: None,
+      aspect_ratio: None,
+      quality: None,
+      image_batch_count: None,
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+
+  fn unwrap_t2i(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> GptImage2p5SunburstTextToImageRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::FalGptImage2p5Sunburst(FalGptImage2p5SunburstRequestState::TextToImage(request))
+    ) = result.expect("build should succeed") else {
+      panic!("expected GPT Image 2.5 Sunburst text-to-image request")
+    };
+    request
+  }
+
+  fn unwrap_edit(result: Result<ImageGenerationDraftOrRequest, ArtcraftRouterError>) -> GptImage2p5SunburstEditImageRequest {
+    let ImageGenerationDraftOrRequest::Request(
+      ImageGenerationRequest::FalGptImage2p5Sunburst(FalGptImage2p5SunburstRequestState::EditImage(request))
+    ) = result.expect("build should succeed") else {
+      panic!("expected GPT Image 2.5 Sunburst edit-image request")
+    };
+    request
+  }
+}

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

@@ -0,0 +1,133 @@
+use fal_client::requests::traits::fal_request_cost_calculator_trait::FalRequestCostCalculator;
+
+use crate::generate::generate_image::image_generation_cost_estimate::ImageGenerationCostEstimate;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_sunburst::request::FalGptImage2p5SunburstRequestState;
+
+/// Cost state for Fal GPT Image 2.5 Sunburst. Delegates to `fal_client`'s calculator, which
+/// prices by output dimensions (aspect ratio and resolution tier), quality, batch size and,
+/// for edits, the number of reference images.
+#[derive(Clone, Debug)]
+pub struct FalGptImage2p5SunburstCostState {
+  cost_in_usd_cents: u64,
+}
+
+impl FalGptImage2p5SunburstCostState {
+  pub fn from_request(request: &FalGptImage2p5SunburstRequestState) -> Self {
+    let cost_in_usd_cents = match request {
+      FalGptImage2p5SunburstRequestState::TextToImage(request) => request.calculate_cost_in_cents(),
+      FalGptImage2p5SunburstRequestState::EditImage(request) => request.calculate_cost_in_cents(),
+    };
+    Self { cost_in_usd_cents }
+  }
+
+  pub fn estimate_cost(&self) -> ImageGenerationCostEstimate {
+    ImageGenerationCostEstimate {
+      cost_in_credits: Some(self.cost_in_usd_cents),
+      cost_in_usd_cents: Some(self.cost_in_usd_cents),
+      is_free: false,
+      is_unlimited: false,
+      is_rate_limited: false,
+      has_watermark: false,
+      failures_are_refunded: None,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use crate::api::image_list_ref::ImageListRef;
+  use crate::api::router_aspect_ratio::RouterAspectRatio;
+  use crate::api::router_image_model::RouterImageModel;
+  use crate::api::router_provider::RouterProvider;
+  use crate::api::router_quality::RouterQuality;
+  use crate::api::router_resolution::RouterResolution;
+  use crate::client::request_mismatch_mitigation_strategy::RequestMismatchMitigationStrategy;
+  use crate::generate::generate_image::generate_image_request_builder::GenerateImageRequestBuilder;
+  use RouterAspectRatio as Ar;
+  use RouterQuality as Q;
+  use RouterResolution as R;
+
+  // (quality, aspect_ratio, resolution, batch, expected_cents) — text-to-image
+  const TEXT_CASES: &[(Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (None,            None,                    None,          1,  4), // Fal default: landscape_4_3, high
+    (Some(Q::Low),    Some(Ar::Square),        None,          1,  1),
+    (Some(Q::Medium), Some(Ar::Square),        None,          1,  2),
+    (Some(Q::High),   Some(Ar::Square),        None,          1,  6),
+    (Some(Q::High),   Some(Ar::Square),        None,          4, 24),
+    (Some(Q::High),   Some(Ar::SquareHd),      None,          1,  9),
+    (Some(Q::High),   Some(Ar::Square),        Some(R::TwoK), 1,  9),
+    (Some(Q::High),   Some(Ar::Square),        Some(R::FourK), 1, 13),
+    (Some(Q::High),   Some(Ar::WideFourByThree), None,        1,  4),
+    (Some(Q::High),   Some(Ar::TallThreeByFour), None,        1,  4),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), None,      1,  4),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::OneK), 1, 3),
+    (Some(Q::High),   Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 11),
+    (Some(Q::Medium), Some(Ar::TallNineBySixteen), Some(R::ThreeK), 2, 4),
+    (Some(Q::High),   Some(Ar::Auto),          None,          1, 11),
+    (Some(Q::High),   Some(Ar::Auto4k),        None,          1, 11),
+  ];
+
+  // (reference_images, quality, aspect_ratio, resolution, batch, expected_cents) — edit
+  const EDIT_CASES: &[(usize, Option<Q>, Option<Ar>, Option<R>, u16, u64)] = &[
+    (1, None,          None,             None,          1, 11), // Fal default: auto, high
+    (1, Some(Q::Low),  Some(Ar::Square), None,          1,  2),
+    (1, Some(Q::High), Some(Ar::Square), None,          1,  7),
+    (3, Some(Q::High), Some(Ar::Square), None,          1,  8),
+    (1, Some(Q::High), Some(Ar::Square), None,          4, 28),
+    (1, Some(Q::High), Some(Ar::WideSixteenByNine), Some(R::FourK), 1, 11),
+    (2, Some(Q::High), Some(Ar::Auto),   None,          1, 12),
+  ];
+
+  #[test]
+  fn text_to_image_costs() {
+    for &(quality, aspect_ratio, resolution, batch, expected) in TEXT_CASES {
+      assert_eq!(cost_cents(0, quality, aspect_ratio, resolution, batch), expected, "{quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn edit_image_costs() {
+    for &(refs, quality, aspect_ratio, resolution, batch, expected) in EDIT_CASES {
+      assert_eq!(cost_cents(refs, quality, aspect_ratio, resolution, batch), expected, "{refs} refs {quality:?} {aspect_ratio:?} {resolution:?} x{batch}");
+    }
+  }
+
+  #[test]
+  fn estimate_flags() {
+    let cost = builder(0, Some(Q::High), Some(Ar::Square), None, 1).build2().unwrap().estimate_cost().unwrap();
+    assert_eq!(cost.cost_in_credits, cost.cost_in_usd_cents);
+    assert!(!cost.is_free);
+    assert!(!cost.is_unlimited);
+    assert!(!cost.is_rate_limited);
+    assert!(!cost.has_watermark);
+  }
+
+  fn cost_cents(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> u64 {
+    builder(refs, quality, aspect_ratio, resolution, batch)
+      .build2().unwrap().estimate_cost().unwrap().cost_in_usd_cents.unwrap()
+  }
+
+  fn builder(refs: usize, quality: Option<Q>, aspect_ratio: Option<Ar>, resolution: Option<R>, batch: u16) -> GenerateImageRequestBuilder {
+    let image_inputs = if refs == 0 {
+      None
+    } else {
+      Some(ImageListRef::Urls(vec!["https://example.com/img.jpg".to_string(); refs]))
+    };
+    GenerateImageRequestBuilder {
+      model: RouterImageModel::GptImage2p5Sunburst,
+      provider: RouterProvider::Fal,
+      prompt: Some("a cat in space".to_string()),
+      image_inputs,
+      resolution,
+      aspect_ratio,
+      quality,
+      image_batch_count: Some(batch),
+      horizontal_angle: None,
+      vertical_angle: None,
+      zoom: None,
+      request_mismatch_mitigation_strategy: RequestMismatchMitigationStrategy::ErrorOut,
+      generation_mode_mismatch_strategy: None,
+      idempotency_token: None,
+    }
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/mod.rs

@@ -0,0 +1,3 @@
+pub mod build;
+pub mod cost;
+pub mod request;

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/request.rs

@@ -0,0 +1,86 @@
+use fal_client::requests::api::image::edit::gpt_image_2p5_sunburst_edit_image::api::GptImage2p5SunburstEditImageRequest;
+use fal_client::requests::api::image::text::gpt_image_2p5_sunburst_text_to_image::api::GptImage2p5SunburstTextToImageRequest;
+
+use crate::client::router_fal_client::RouterFalClient;
+use crate::errors::artcraft_router_error::ArtcraftRouterError;
+use crate::generate::generate_image::generate_image_response::GenerateImageResponse;
+use crate::generate::generate_image::providers::fal::gpt_image_2p5_common::send::send_gpt_image_2p5_request;
+
+#[derive(Clone, Debug)]
+pub enum FalGptImage2p5SunburstRequestState {
+  TextToImage(GptImage2p5SunburstTextToImageRequest),
+  EditImage(GptImage2p5SunburstEditImageRequest),
+}
+
+impl FalGptImage2p5SunburstRequestState {
+  pub async fn send(&self, client: &RouterFalClient) -> Result<GenerateImageResponse, ArtcraftRouterError> {
+    match self {
+      Self::TextToImage(request) => send_gpt_image_2p5_request(request, client).await,
+      Self::EditImage(request) => send_gpt_image_2p5_request(request, client).await,
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use fal_client::creds::fal_api_key::FalApiKey;
+  use fal_client::requests::api::image::common::gpt_image_2_resolution::GptImage2Resolution;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_edit_image_params::GptImage2p5EditImageParams;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_image_size::GptImage2p5ImageSize;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_num_images::GptImage2p5NumImages;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_quality::GptImage2p5Quality;
+  use fal_client::requests::api::image::common::gpt_image_2p5::gpt_image_2p5_text_to_image_params::GptImage2p5TextToImageParams;
+  use test_data::web::image_urls::JUNO_AT_LAKE_IMAGE_URL;
+
+  #[tokio::test]
+  #[ignore] // requires real API key, incurs cost
+  async fn send_text_to_image_webhook() {
+    let request = FalGptImage2p5SunburstRequestState::TextToImage(GptImage2p5SunburstTextToImageRequest {
+      params: GptImage2p5TextToImageParams {
+        prompt: "a polished product photo of a glass compass".to_string(),
+        num_images: GptImage2p5NumImages::One,
+        image_size: Some(GptImage2p5ImageSize::Square),
+        resolution: Some(GptImage2Resolution::OneK),
+        quality: Some(GptImage2p5Quality::Low),
+        background: None,
+        output_format: None,
+        output_compression: None,
+      },
+    });
+    let response = request.send(&client_with_webhook()).await.expect("send should succeed");
+    let payload = response.get_fal_payload().expect("expected Fal payload");
+    assert!(payload.request_id.is_some() || payload.gateway_request_id.is_some());
+  }
+
+  #[tokio::test]
+  #[ignore] // requires real API key, incurs cost
+  async fn send_edit_image_webhook() {
+    let request = FalGptImage2p5SunburstRequestState::EditImage(GptImage2p5SunburstEditImageRequest {
+      params: GptImage2p5EditImageParams {
+        prompt: "make this look like an elegant magazine cover image".to_string(),
+        image_urls: vec![JUNO_AT_LAKE_IMAGE_URL.to_string()],
+        mask_url: None,
+        num_images: GptImage2p5NumImages::One,
+        image_size: Some(GptImage2p5ImageSize::Square),
+        resolution: Some(GptImage2Resolution::OneK),
+        quality: Some(GptImage2p5Quality::Low),
+        background: None,
+        output_format: None,
+        output_compression: None,
+      },
+    });
+    let response = request.send(&client_with_webhook()).await.expect("send should succeed");
+    let payload = response.get_fal_payload().expect("expected Fal payload");
+    assert!(payload.request_id.is_some() || payload.gateway_request_id.is_some());
+  }
+
+  fn client_with_webhook() -> RouterFalClient {
+    let secret = std::fs::read_to_string("/Users/bt/Artcraft/credentials/fal_api_key.txt")
+      .expect("Failed to read fal_api_key.txt");
+    RouterFalClient::new_with_webhook(
+      FalApiKey::from_str(secret.trim()),
+      "https://example.com/fal-webhook-test".to_string(),
+    )
+  }
+}

crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/mod.rs

@@ -6,6 +6,9 @@ pub mod flux_pro_1p1_ultra;
 pub mod gpt_image_1;
 pub mod gpt_image_1p5;
 pub mod gpt_image_2;
+pub mod gpt_image_2p5_common;
+pub mod gpt_image_2p5_flare;
+pub mod gpt_image_2p5_sunburst;
 pub mod nano_banana;
 pub mod nano_banana_2;
 pub mod nano_banana_pro;

crates/desktop/artcraft/src/core/commands/generate/common/router_image_request_to_artcraft_prompt.rs

@@ -48,6 +48,8 @@ fn image_model_to_common_model_type(model: RouterImageModel) -> Option<CommonMod
     RouterImageModel::GptImage1 => Some(CommonModelType::GptImage1),
     RouterImageModel::GptImage1p5 => Some(CommonModelType::GptImage1p5),
     RouterImageModel::GptImage2 => Some(CommonModelType::GptImage2),
+    RouterImageModel::GptImage2p5Flare => Some(CommonModelType::GptImage2p5Flare),
+    RouterImageModel::GptImage2p5Sunburst => Some(CommonModelType::GptImage2p5Sunburst),
     RouterImageModel::NanoBanana => Some(CommonModelType::NanoBanana),
     RouterImageModel::NanoBanana2 => Some(CommonModelType::NanoBanana2),
     RouterImageModel::NanoBananaPro => Some(CommonModelType::NanoBananaPro),

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

@@ -103,6 +103,10 @@ pub enum InferenceModelType {
   GptImage1p5,
   #[serde(rename = "gpt_image_2")]
   GptImage2,
+  #[serde(rename = "gpt_image_2p5_flare")]
+  GptImage2p5Flare,
+  #[serde(rename = "gpt_image_2p5_sunburst")]
+  GptImage2p5Sunburst,
   #[serde(rename = "grok_image")]
   GrokImage,
   #[serde(rename = "grok_imagine_image")]
@@ -346,6 +350,8 @@ impl InferenceModelType {
       Self::GptImage1 => "gpt_image_1",
       Self::GptImage1p5 => "gpt_image_1p5",
       Self::GptImage2 => "gpt_image_2",
+      Self::GptImage2p5Flare => "gpt_image_2p5_flare",
+      Self::GptImage2p5Sunburst => "gpt_image_2p5_sunburst",
       Self::GrokImage => "grok_image",
       Self::GrokImagineImage => "grok_imagine_image",
       Self::GrokImagineImageQuality => "grok_imagine_image_q",
@@ -484,6 +490,8 @@ impl InferenceModelType {
       "gpt_image_1" => Ok(Self::GptImage1),
       "gpt_image_1p5" => Ok(Self::GptImage1p5),
       "gpt_image_2" => Ok(Self::GptImage2),
+      "gpt_image_2p5_flare" => Ok(Self::GptImage2p5Flare),
+      "gpt_image_2p5_sunburst" => Ok(Self::GptImage2p5Sunburst),
       "grok_image" => Ok(Self::GrokImage),
       "grok_imagine_image" => Ok(Self::GrokImagineImage),
       "grok_imagine_image_q" => Ok(Self::GrokImagineImageQuality),
@@ -626,6 +634,8 @@ impl InferenceModelType {
       Self::GptImage1,
       Self::GptImage1p5,
       Self::GptImage2,
+      Self::GptImage2p5Flare,
+      Self::GptImage2p5Sunburst,
       Self::GrokImage,
       Self::GrokImagineImage,
       Self::GrokImagineImageQuality,
@@ -751,6 +761,8 @@ impl InferenceModelType {
       CommonModelType::GptImage1 => Self::GptImage1,
       CommonModelType::GptImage1p5 => Self::GptImage1p5,
       CommonModelType::GptImage2 => Self::GptImage2,
+      CommonModelType::GptImage2p5Flare => Self::GptImage2p5Flare,
+      CommonModelType::GptImage2p5Sunburst => Self::GptImage2p5Sunburst,
       CommonModelType::GrokImage => Self::GrokImage,
       CommonModelType::GrokImagineImage => Self::GrokImagineImage,
       CommonModelType::GrokImagineImageQuality => Self::GrokImagineImageQuality,
@@ -899,6 +911,8 @@ mod tests {
       assert_serialization(InferenceModelType::GptImage1, "gpt_image_1");
       assert_serialization(InferenceModelType::GptImage1p5, "gpt_image_1p5");
       assert_serialization(InferenceModelType::GptImage2, "gpt_image_2");
+      assert_serialization(InferenceModelType::GptImage2p5Flare, "gpt_image_2p5_flare");
+      assert_serialization(InferenceModelType::GptImage2p5Sunburst, "gpt_image_2p5_sunburst");
       assert_serialization(InferenceModelType::GrokImage, "grok_image");
       assert_serialization(InferenceModelType::GrokImagineImage, "grok_imagine_image");
       assert_serialization(InferenceModelType::GrokImagineImageQuality, "grok_imagine_image_q");
@@ -1033,6 +1047,8 @@ mod tests {
       assert_eq!(InferenceModelType::GptImage1.to_str(), "gpt_image_1");
       assert_eq!(InferenceModelType::GptImage1p5.to_str(), "gpt_image_1p5");
       assert_eq!(InferenceModelType::GptImage2.to_str(), "gpt_image_2");
+      assert_eq!(InferenceModelType::GptImage2p5Flare.to_str(), "gpt_image_2p5_flare");
+      assert_eq!(InferenceModelType::GptImage2p5Sunburst.to_str(), "gpt_image_2p5_sunburst");
       assert_eq!(InferenceModelType::GrokImage.to_str(), "grok_image");
       assert_eq!(InferenceModelType::GrokImagineImage.to_str(), "grok_imagine_image");
       assert_eq!(InferenceModelType::GrokImagineImageQuality.to_str(), "grok_imagine_image_q");
@@ -1169,6 +1185,8 @@ mod tests {
       assert_eq!(InferenceModelType::from_str("gpt_image_1").unwrap(), InferenceModelType::GptImage1);
       assert_eq!(InferenceModelType::from_str("gpt_image_1p5").unwrap(), InferenceModelType::GptImage1p5);
       assert_eq!(InferenceModelType::from_str("gpt_image_2").unwrap(), InferenceModelType::GptImage2);
+      assert_eq!(InferenceModelType::from_str("gpt_image_2p5_flare").unwrap(), InferenceModelType::GptImage2p5Flare);
+      assert_eq!(InferenceModelType::from_str("gpt_image_2p5_sunburst").unwrap(), InferenceModelType::GptImage2p5Sunburst);
       assert_eq!(InferenceModelType::from_str("grok_image").unwrap(), InferenceModelType::GrokImage);
       assert_eq!(InferenceModelType::from_str("grok_imagine_image").unwrap(), InferenceModelType::GrokImagineImage);
       assert_eq!(InferenceModelType::from_str("grok_imagine_image_q").unwrap(), InferenceModelType::GrokImagineImageQuality);

crates/schema/public/enums/src/common/generation/common_image_model.rs

@@ -25,6 +25,10 @@ pub enum CommonImageModel {
   GptImage1p5,
   #[serde(rename = "gpt_image_2")]
   GptImage2,
+  #[serde(rename = "gpt_image_2p5_flare")]
+  GptImage2p5Flare,
+  #[serde(rename = "gpt_image_2p5_sunburst")]
+  GptImage2p5Sunburst,
   #[serde(rename = "grok_imagine_image")]
   GrokImagineImage,
   #[serde(rename = "grok_imagine_image_q")]
@@ -68,6 +72,8 @@ impl CommonImageModel {
       Self::GptImage1 => CommonModelType::GptImage1,
       Self::GptImage1p5 => CommonModelType::GptImage1p5,
       Self::GptImage2 => CommonModelType::GptImage2,
+      Self::GptImage2p5Flare => CommonModelType::GptImage2p5Flare,
+      Self::GptImage2p5Sunburst => CommonModelType::GptImage2p5Sunburst,
       Self::GrokImagineImage => CommonModelType::GrokImagineImage,
       Self::GrokImagineImageQuality => CommonModelType::GrokImagineImageQuality,
       Self::Midjourney7 => CommonModelType::Midjourney7,
@@ -106,6 +112,8 @@ mod tests {
       assert_serialization(CommonImageModel::GptImage1, "gpt_image_1");
       assert_serialization(CommonImageModel::GptImage1p5, "gpt_image_1p5");
       assert_serialization(CommonImageModel::GptImage2, "gpt_image_2");
+      assert_serialization(CommonImageModel::GptImage2p5Flare, "gpt_image_2p5_flare");
+      assert_serialization(CommonImageModel::GptImage2p5Sunburst, "gpt_image_2p5_sunburst");
       assert_serialization(CommonImageModel::GrokImagineImage, "grok_imagine_image");
       assert_serialization(CommonImageModel::GrokImagineImageQuality, "grok_imagine_image_q");
       assert_serialization(CommonImageModel::Midjourney7, "midjourney_7");
@@ -133,6 +141,8 @@ mod tests {
         (CommonImageModel::GptImage1, CommonModelType::GptImage1),
         (CommonImageModel::GptImage1p5, CommonModelType::GptImage1p5),
         (CommonImageModel::GptImage2, CommonModelType::GptImage2),
+        (CommonImageModel::GptImage2p5Flare, CommonModelType::GptImage2p5Flare),
+        (CommonImageModel::GptImage2p5Sunburst, CommonModelType::GptImage2p5Sunburst),
         (CommonImageModel::GrokImagineImage, CommonModelType::GrokImagineImage),
         (CommonImageModel::GrokImagineImageQuality, CommonModelType::GrokImagineImageQuality),
         (CommonImageModel::Midjourney7, CommonModelType::Midjourney7),
@@ -174,7 +184,7 @@ mod tests {
     #[test]
     fn variant_count() {
       use strum::IntoEnumIterator;
-      assert_eq!(CommonImageModel::iter().len(), 22);
+      assert_eq!(CommonImageModel::iter().len(), 24);
     }
 
     #[test]

crates/schema/public/enums/src/common/generation/common_model_type.rs

@@ -54,6 +54,10 @@ pub enum CommonModelType {
   GptImage1p5,
   #[serde(rename = "gpt_image_2")]
   GptImage2,
+  #[serde(rename = "gpt_image_2p5_flare")]
+  GptImage2p5Flare,
+  #[serde(rename = "gpt_image_2p5_sunburst")]
+  GptImage2p5Sunburst,
   // Generic grok image model without a version
   #[serde(rename = "grok_image")]
   GrokImage,
@@ -301,6 +305,8 @@ impl CommonModelType {
       Self::GptImage1 => "gpt_image_1",
       Self::GptImage1p5 => "gpt_image_1p5",
       Self::GptImage2 => "gpt_image_2",
+      Self::GptImage2p5Flare => "gpt_image_2p5_flare",
+      Self::GptImage2p5Sunburst => "gpt_image_2p5_sunburst",
       Self::GrokImage => "grok_image",
       Self::GrokImagineImage => "grok_imagine_image",
       Self::GrokImagineImageQuality => "grok_imagine_image_q",
@@ -422,6 +428,8 @@ impl CommonModelType {
       "gpt_image_1" => Ok(Self::GptImage1),
       "gpt_image_1p5" => Ok(Self::GptImage1p5),
       "gpt_image_2" => Ok(Self::GptImage2),
+      "gpt_image_2p5_flare" => Ok(Self::GptImage2p5Flare),
+      "gpt_image_2p5_sunburst" => Ok(Self::GptImage2p5Sunburst),
       "grok_image" => Ok(Self::GrokImage),
       "grok_imagine_image" => Ok(Self::GrokImagineImage),
       "grok_imagine_image_q" => Ok(Self::GrokImagineImageQuality),
@@ -547,6 +555,8 @@ impl CommonModelType {
       Self::GptImage1,
       Self::GptImage1p5,
       Self::GptImage2,
+      Self::GptImage2p5Flare,
+      Self::GptImage2p5Sunburst,
       Self::GrokImage,
       Self::GrokImagineImage,
       Self::GrokImagineImageQuality,
@@ -669,6 +679,8 @@ impl CommonModelType {
       Self::GptImage1 => CommonModelClass::Image,
       Self::GptImage1p5 => CommonModelClass::Image,
       Self::GptImage2 => CommonModelClass::Image,
+      Self::GptImage2p5Flare => CommonModelClass::Image,
+      Self::GptImage2p5Sunburst => CommonModelClass::Image,
       Self::GrokImage => CommonModelClass::Image,
       Self::GrokImagineImage => CommonModelClass::Image,
       Self::GrokImagineImageQuality => CommonModelClass::Image,
@@ -801,6 +813,8 @@ mod tests {
       assert_serialization(CommonModelType::GptImage1, "gpt_image_1");
       assert_serialization(CommonModelType::GptImage1p5, "gpt_image_1p5");
       assert_serialization(CommonModelType::GptImage2, "gpt_image_2");
+      assert_serialization(CommonModelType::GptImage2p5Flare, "gpt_image_2p5_flare");
+      assert_serialization(CommonModelType::GptImage2p5Sunburst, "gpt_image_2p5_sunburst");
       assert_serialization(CommonModelType::GrokImage, "grok_image");
       assert_serialization(CommonModelType::GrokImagineImage, "grok_imagine_image");
       assert_serialization(CommonModelType::GrokImagineImageQuality, "grok_imagine_image_q");
@@ -916,6 +930,8 @@ mod tests {
       assert_eq!(CommonModelType::GptImage1.to_str(), "gpt_image_1");
       assert_eq!(CommonModelType::GptImage1p5.to_str(), "gpt_image_1p5");
       assert_eq!(CommonModelType::GptImage2.to_str(), "gpt_image_2");
+      assert_eq!(CommonModelType::GptImage2p5Flare.to_str(), "gpt_image_2p5_flare");
+      assert_eq!(CommonModelType::GptImage2p5Sunburst.to_str(), "gpt_image_2p5_sunburst");
       assert_eq!(CommonModelType::GrokImage.to_str(), "grok_image");
       assert_eq!(CommonModelType::GrokImagineImage.to_str(), "grok_imagine_image");
       assert_eq!(CommonModelType::GrokImagineImageQuality.to_str(), "grok_imagine_image_q");
@@ -1035,6 +1051,8 @@ mod tests {
       assert_eq!(CommonModelType::from_str("gpt_image_1").unwrap(), CommonModelType::GptImage1);
       assert_eq!(CommonModelType::from_str("gpt_image_1p5").unwrap(), CommonModelType::GptImage1p5);
       assert_eq!(CommonModelType::from_str("gpt_image_2").unwrap(), CommonModelType::GptImage2);
+      assert_eq!(CommonModelType::from_str("gpt_image_2p5_flare").unwrap(), CommonModelType::GptImage2p5Flare);
+      assert_eq!(CommonModelType::from_str("gpt_image_2p5_sunburst").unwrap(), CommonModelType::GptImage2p5Sunburst);
       assert_eq!(CommonModelType::from_str("grok_image").unwrap(), CommonModelType::GrokImage);
       assert_eq!(CommonModelType::from_str("grok_imagine_image").unwrap(), CommonModelType::GrokImagineImage);
       assert_eq!(CommonModelType::from_str("grok_imagine_image_q").unwrap(), CommonModelType::GrokImagineImageQuality);
@@ -1140,7 +1158,7 @@ mod tests {
     #[test]
     fn all_variants() {
       let mut variants = CommonModelType::all_variants();
-      assert_eq!(variants.len(), 106);
+      assert_eq!(variants.len(), 108);
       // Image models
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Dev));
       assert_eq!(variants.pop_first(), Some(CommonModelType::Flux1Schnell));
@@ -1153,6 +1171,8 @@ mod tests {
       assert_eq!(variants.pop_first(), Some(CommonModelType::GptImage1));
       assert_eq!(variants.pop_first(), Some(CommonModelType::GptImage1p5));
       assert_eq!(variants.pop_first(), Some(CommonModelType::GptImage2));
+      assert_eq!(variants.pop_first(), Some(CommonModelType::GptImage2p5Flare));
+      assert_eq!(variants.pop_first(), Some(CommonModelType::GptImage2p5Sunburst));
       assert_eq!(variants.pop_first(), Some(CommonModelType::GrokImage));
       assert_eq!(variants.pop_first(), Some(CommonModelType::GrokImagineImage));
       assert_eq!(variants.pop_first(), Some(CommonModelType::GrokImagineImageQuality));

crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/image/estimate_image_cost_handler.rs

@@ -135,6 +135,8 @@ fn map_image_model(model: CommonImageModel) -> Result<RouterImageModel, HandlerE
     CommonImageModel::GptImage1 => RouterImageModel::GptImage1,
     CommonImageModel::GptImage1p5 => RouterImageModel::GptImage1p5,
     CommonImageModel::GptImage2 => RouterImageModel::GptImage2,
+    CommonImageModel::GptImage2p5Flare => RouterImageModel::GptImage2p5Flare,
+    CommonImageModel::GptImage2p5Sunburst => RouterImageModel::GptImage2p5Sunburst,
     CommonImageModel::NanoBanana => RouterImageModel::NanoBanana,
     CommonImageModel::NanoBanana2 => RouterImageModel::NanoBanana2,
     CommonImageModel::NanoBananaPro => RouterImageModel::NanoBananaPro,