diff --git a/crates/api_clients/artcraft/artcraft_router/src/api/router_image_model.rs b/crates/api_clients/artcraft/artcraft_router/src/api/router_image_model.rs index f1f04abc9d..17f90236a4 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/api/router_image_model.rs +++ b/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"); + } } diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request_builder.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request_builder.rs index 76ccd72668..2a92513333 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/generate_image_request_builder.rs +++ b/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), diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_request.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_request.rs index 610fcf3c1d..5eed144b5c 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/image_generation_request.rs +++ b/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()?; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_common_cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_common_cost.rs new file mode 100644 index 0000000000..bc015b334f --- /dev/null +++ b/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, + pub aspect_ratio: Option, + pub resolution: Option, + 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] = &[ + 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, Option, [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, + aspect_ratio: Option, + resolution: Option, + num_images: u16, + ) -> ArtcraftGptImage2p5CostInputs { + ArtcraftGptImage2p5CostInputs { quality, aspect_ratio, resolution, num_reference_images, num_images } + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/build.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/build.rs new file mode 100644 index 0000000000..4d0bd784bf --- /dev/null +++ b/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 { + 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) -> OmniGenImageCostAndGenerateRequest { + let ImageGenerationDraftOrRequest::Request( + ImageGenerationRequest::ArtcraftGptImage2p5Flare(state) + ) = result.expect("build should succeed") else { + panic!("expected Artcraft GPT Image 2.5 Flare request") + }; + state.request + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/cost.rs new file mode 100644 index 0000000000..1525d76795 --- /dev/null +++ b/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, Option, Option, 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, aspect_ratio: Option, resolution: Option, 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, aspect_ratio: Option, resolution: Option, 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, + } + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/mod.rs new file mode 100644 index 0000000000..98150bd014 --- /dev/null +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/request.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_flare/request.rs new file mode 100644 index 0000000000..0584b6fab9 --- /dev/null +++ b/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 { + send_artcraft_omni_image_request(&self.request, client).await + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/build.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/build.rs new file mode 100644 index 0000000000..2e86e306e8 --- /dev/null +++ b/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 { + 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) -> OmniGenImageCostAndGenerateRequest { + let ImageGenerationDraftOrRequest::Request( + ImageGenerationRequest::ArtcraftGptImage2p5Sunburst(state) + ) = result.expect("build should succeed") else { + panic!("expected Artcraft GPT Image 2.5 Sunburst request") + }; + state.request + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/cost.rs new file mode 100644 index 0000000000..74feeed5c8 --- /dev/null +++ b/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, Option, Option, 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, aspect_ratio: Option, resolution: Option, 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, aspect_ratio: Option, resolution: Option, 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, + } + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/mod.rs new file mode 100644 index 0000000000..98150bd014 --- /dev/null +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/request.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/gpt_image_2p5_sunburst/request.rs new file mode 100644 index 0000000000..4da9eb772c --- /dev/null +++ b/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 { + send_artcraft_omni_image_request(&self.request, client).await + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/mod.rs index cde52f8c63..b5334f4aae 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/artcraft/mod.rs +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/mod.rs new file mode 100644 index 0000000000..5218ecb1e0 --- /dev/null +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/plan.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/plan.rs new file mode 100644 index 0000000000..56ac929795 --- /dev/null +++ b/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 { + 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, + strategy: RequestMismatchMitigationStrategy, +) -> Result { + 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) -> GptImage2p5Quality { + match quality { + Some(RouterQuality::Low) => GptImage2p5Quality::Low, + Some(RouterQuality::Medium) => GptImage2p5Quality::Medium, + Some(RouterQuality::High) | None => GptImage2p5Quality::High, + } +} + +fn plan_resolution(resolution: Option) -> Option { + 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) -> Option { + 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, +) -> Result, 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) -> GptImage2p5TextToImageParams { + match result.expect("plan should succeed") { + PlannedGptImage2p5Params::TextToImage(params) => params, + PlannedGptImage2p5Params::EditImage(_) => panic!("expected text-to-image"), + } + } + + fn unwrap_edit(result: Result) -> GptImage2p5EditImageParams { + match result.expect("plan should succeed") { + PlannedGptImage2p5Params::EditImage(params) => params, + PlannedGptImage2p5Params::TextToImage(_) => panic!("expected edit-image"), + } + } + + fn assert_debug(actual: T, expected: &str) { + assert_eq!(format!("{:?}", actual), expected); + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/send.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_common/send.rs new file mode 100644 index 0000000000..61fce963f7 --- /dev/null +++ b/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( + request: &T, + client: &RouterFalClient, +) -> Result +where + T: FalEndpoint + Clone + Debug + Send + Sync + 'static, +{ + let outbound: Arc = 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)) +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/build.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/build.rs new file mode 100644 index 0000000000..bb0257e11d --- /dev/null +++ b/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 { + 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) -> 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) -> 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 + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/cost.rs new file mode 100644 index 0000000000..936d6a6602 --- /dev/null +++ b/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, Option, Option, 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, Option, Option, 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, aspect_ratio: Option, resolution: Option, 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, aspect_ratio: Option, resolution: Option, 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, + } + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/mod.rs new file mode 100644 index 0000000000..98150bd014 --- /dev/null +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/request.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_flare/request.rs new file mode 100644 index 0000000000..3c64644624 --- /dev/null +++ b/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 { + 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(), + ) + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/build.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/build.rs new file mode 100644 index 0000000000..c95e0858a5 --- /dev/null +++ b/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 { + 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) -> 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) -> 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 + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/cost.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/cost.rs new file mode 100644 index 0000000000..7932ab7c38 --- /dev/null +++ b/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, Option, Option, 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, Option, Option, 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, aspect_ratio: Option, resolution: Option, 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, aspect_ratio: Option, resolution: Option, 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, + } + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/mod.rs new file mode 100644 index 0000000000..98150bd014 --- /dev/null +++ b/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; diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/request.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/gpt_image_2p5_sunburst/request.rs new file mode 100644 index 0000000000..191f92bb20 --- /dev/null +++ b/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 { + 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(), + ) + } +} diff --git a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/mod.rs b/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/mod.rs index 3245f1990d..5699db2340 100644 --- a/crates/api_clients/artcraft/artcraft_router/src/generate/generate_image/providers/fal/mod.rs +++ b/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; diff --git a/crates/desktop/artcraft/src/core/commands/generate/common/router_image_request_to_artcraft_prompt.rs b/crates/desktop/artcraft/src/core/commands/generate/common/router_image_request_to_artcraft_prompt.rs index 51c02cbdec..ef7bb5742a 100644 --- a/crates/desktop/artcraft/src/core/commands/generate/common/router_image_request_to_artcraft_prompt.rs +++ b/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 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), diff --git a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_model_type.rs b/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_model_type.rs index 676369bb77..f6f55c73fb 100644 --- a/crates/schema/public/enums/src/by_table/generic_inference_jobs/inference_model_type.rs +++ b/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); diff --git a/crates/schema/public/enums/src/common/generation/common_image_model.rs b/crates/schema/public/enums/src/common/generation/common_image_model.rs index 42e81d2bf6..5a458e2a2e 100644 --- a/crates/schema/public/enums/src/common/generation/common_image_model.rs +++ b/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] diff --git a/crates/schema/public/enums/src/common/generation/common_model_type.rs b/crates/schema/public/enums/src/common/generation/common_model_type.rs index 92d66e57ec..22ea6e6cfa 100644 --- a/crates/schema/public/enums/src/common/generation/common_model_type.rs +++ b/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)); diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/image/estimate_image_cost_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/image/estimate_image_cost_handler.rs index babc2d3501..4ca2425f2c 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/cost_estimate/image/estimate_image_cost_handler.rs +++ b/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::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,