diff --git a/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/mod.rs b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/mod.rs index 7ca4412b6e..c236019482 100644 --- a/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/mod.rs +++ b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/mod.rs @@ -5,4 +5,5 @@ pub mod generate_flux_pro_11_text_to_image; pub mod generate_flux_pro_11_ultra_text_to_image; pub mod generate_gpt_image_1_text_to_image; pub mod inpaint; +pub mod multi_function; pub mod remove_image_background; \ No newline at end of file diff --git a/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/mod.rs b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/mod.rs new file mode 100644 index 0000000000..e2b04749c7 --- /dev/null +++ b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/mod.rs @@ -0,0 +1 @@ +pub mod nano_banana_pro_multi_function_image_gen; \ No newline at end of file diff --git a/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/nano_banana_pro_multi_function_image_gen.rs b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/nano_banana_pro_multi_function_image_gen.rs new file mode 100644 index 0000000000..31a8e52b67 --- /dev/null +++ b/crates/api_clients/artcraft/artcraft_api_defs/src/generate/image/multi_function/nano_banana_pro_multi_function_image_gen.rs @@ -0,0 +1,71 @@ +use serde_derive::{Deserialize, Serialize}; +use tokens::tokens::generic_inference_jobs::InferenceJobToken; +use tokens::tokens::media_files::MediaFileToken; +use utoipa::ToSchema; + +pub const NANO_BANANA_PRO_MULTI_FUNCTION_IMAGE_GEN_PATH: &str = "/v1/generate/image/multi_function/nano_banana_pro"; + +#[derive(Serialize, Deserialize, ToSchema)] +pub struct NanoBananaProMultiFunctionImageGenRequest { + /// Idempotency token to prevent duplicate requests. + pub uuid_idempotency_token: String, + + /// Text prompt to generate the image from. + pub prompt: Option, + + /// Image media tokens to include in the editing context. + /// If present, we're doing image editing (image-to-image / image-editing) + /// If absent, we're doing image generation (text-to-image) + pub image_media_tokens: Option>, + + /// Number of images to generate. Default is one. + pub num_images: Option, + + /// Resolution of the image to generate. Default is OneK (1K). + pub resolution: Option, + + /// Aspect ratio of the images to generate. Default is "1:1" + pub aspect_ratio: Option, +} + +#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum NanoBananaProMultiFunctionImageGenNumImages { + One, // Default + Two, + Three, + Four, +} + +#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum NanoBananaProMultiFunctionImageGenImageResolution { + OneK, + TwoK, + FourK, +} + +#[derive(Copy, Clone, Debug, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum NanoBananaProMultiFunctionImageGenAspectRatio { + // Square + OneByOne, // Default + // Wide + FiveByFour, + FourByThree, + ThreeByTwo, + SixteenByNine, + TwentyOneByNine, + // Tall + FourByFive, + ThreeByFour, + TwoByThree, + NineBySixteen, // NB: No NineByTwentyOne ? +} + + +#[derive(Serialize, Deserialize, ToSchema)] +pub struct NanoBananaProMultiFunctionImageGenResponse { + pub success: bool, + pub inference_job_token: InferenceJobToken, +} diff --git a/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/mod.rs b/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/mod.rs index 3b52212122..613bf832ba 100644 --- a/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/mod.rs +++ b/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/mod.rs @@ -1,3 +1,4 @@ pub mod flux_pro_kontext_max_edit_image; pub mod gemini_25_flash_edit_image; -pub mod gpt_image_1_edit_image; \ No newline at end of file +pub mod gpt_image_1_edit_image; +pub mod nano_banana_pro_edit_image; \ No newline at end of file diff --git a/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/nano_banana_pro_edit_image.rs b/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/nano_banana_pro_edit_image.rs new file mode 100644 index 0000000000..37e6c3d292 --- /dev/null +++ b/crates/api_clients/artcraft/storyteller_client/src/endpoints/generate/image/edit/nano_banana_pro_edit_image.rs @@ -0,0 +1,18 @@ +use crate::credentials::storyteller_credential_set::StorytellerCredentialSet; +use crate::error::storyteller_error::StorytellerError; +use crate::utils::api_host::ApiHost; +use crate::utils::basic_json_post_request::basic_json_post_request; +use artcraft_api_defs::generate::image::edit::gemini_25_flash_edit_image::{Gemini25FlashEditImageRequest, Gemini25FlashEditImageResponse, GEMINI_25_FLASH_EDIT_IMAGE_PATH}; + +pub async fn gemini_25_flash_edit_image( + api_host: &ApiHost, + maybe_creds: Option<&StorytellerCredentialSet>, + request: Gemini25FlashEditImageRequest, +) -> Result { + Ok(basic_json_post_request( + api_host, + GEMINI_25_FLASH_EDIT_IMAGE_PATH, + maybe_creds, + request, + ).await?) +} diff --git a/crates/schema/public/enums/src/common/model_type.rs b/crates/schema/public/enums/src/common/model_type.rs index 84e1842875..e1f0aaf115 100644 --- a/crates/schema/public/enums/src/common/model_type.rs +++ b/crates/schema/public/enums/src/common/model_type.rs @@ -38,8 +38,13 @@ pub enum ModelType { SeedEdit3, #[serde(rename = "qwen")] Qwen, + /// Gemini 2.5 Flash, AKA "Nano Banana" #[serde(rename = "gemini_25_flash")] Gemini25Flash, + #[serde(rename = "nano_banana")] + NanoBanana, + #[serde(rename = "nano_banana_pro")] + NanoBananaPro, /// Midjourney without distinguishing a model type or version #[serde(rename = "midjourney")] @@ -117,6 +122,8 @@ impl ModelType { Self::SeedEdit3 => "seededit_3", Self::Qwen => "qwen", Self::Gemini25Flash => "gemini_25_flash", + Self::NanoBanana => "nano_banana", + Self::NanoBananaPro => "nano_banana_pro", Self::Midjourney => "midjourney", Self::MidjourneyV6 => "midjourney_v6", Self::MidjourneyV6p1 => "midjourney_v6p1", @@ -160,6 +167,8 @@ impl ModelType { "seededit_3" => Ok(Self::SeedEdit3), "qwen" => Ok(Self::Qwen), "gemini_25_flash" => Ok(Self::Gemini25Flash), + "nano_banana" => Ok(Self::NanoBanana), + "nano_banana_pro" => Ok(Self::NanoBananaPro), "midjourney" => Ok(Self::Midjourney), "midjourney_v6" => Ok(Self::MidjourneyV6), "midjourney_v6p1" => Ok(Self::MidjourneyV6p1), @@ -207,6 +216,8 @@ impl ModelType { Self::SeedEdit3, Self::Qwen, Self::Gemini25Flash, + Self::NanoBanana, + Self::NanoBananaPro, Self::Midjourney, Self::MidjourneyV6, Self::MidjourneyV6p1, @@ -259,6 +270,8 @@ mod tests { assert_serialization(ModelType::SeedEdit3, "seededit_3"); assert_serialization(ModelType::Qwen, "qwen"); assert_serialization(ModelType::Gemini25Flash, "gemini_25_flash"); + assert_serialization(ModelType::NanoBanana, "nano_banana"); + assert_serialization(ModelType::NanoBananaPro, "nano_banana_pro"); assert_serialization(ModelType::Midjourney, "midjourney"); assert_serialization(ModelType::MidjourneyV6, "midjourney_v6"); assert_serialization(ModelType::MidjourneyV6p1, "midjourney_v6p1"); @@ -299,6 +312,8 @@ mod tests { assert_eq!(ModelType::SeedEdit3.to_str(), "seededit_3"); assert_eq!(ModelType::Qwen.to_str(), "qwen"); assert_eq!(ModelType::Gemini25Flash.to_str(), "gemini_25_flash"); + assert_eq!(ModelType::NanoBanana.to_str(), "nano_banana"); + assert_eq!(ModelType::NanoBananaPro.to_str(), "nano_banana_pro"); assert_eq!(ModelType::Midjourney.to_str(), "midjourney"); assert_eq!(ModelType::MidjourneyV6.to_str(), "midjourney_v6"); assert_eq!(ModelType::MidjourneyV6p1.to_str(), "midjourney_v6p1"); @@ -341,6 +356,8 @@ mod tests { assert_eq!(ModelType::from_str("seededit_3").unwrap(), ModelType::SeedEdit3); assert_eq!(ModelType::from_str("qwen").unwrap(), ModelType::Qwen); assert_eq!(ModelType::from_str("gemini_25_flash").unwrap(), ModelType::Gemini25Flash); + assert_eq!(ModelType::from_str("nano_banana").unwrap(), ModelType::NanoBanana); + assert_eq!(ModelType::from_str("nano_banana_pro").unwrap(), ModelType::NanoBananaPro); assert_eq!(ModelType::from_str("midjourney").unwrap(), ModelType::Midjourney); assert_eq!(ModelType::from_str("midjourney_v6").unwrap(), ModelType::MidjourneyV6); assert_eq!(ModelType::from_str("midjourney_v6p1").unwrap(), ModelType::MidjourneyV6p1); @@ -368,7 +385,7 @@ mod tests { #[test] fn all_variants() { let mut variants = ModelType::all_variants(); - assert_eq!(variants.len(), 33); + assert_eq!(variants.len(), 35); // Image models assert_eq!(variants.pop_first(), Some(ModelType::Flux1Dev)); assert_eq!(variants.pop_first(), Some(ModelType::Flux1Schnell)); @@ -383,6 +400,8 @@ mod tests { assert_eq!(variants.pop_first(), Some(ModelType::SeedEdit3)); assert_eq!(variants.pop_first(), Some(ModelType::Qwen)); assert_eq!(variants.pop_first(), Some(ModelType::Gemini25Flash)); + assert_eq!(variants.pop_first(), Some(ModelType::NanoBanana)); + assert_eq!(variants.pop_first(), Some(ModelType::NanoBananaPro)); assert_eq!(variants.pop_first(), Some(ModelType::Midjourney)); assert_eq!(variants.pop_first(), Some(ModelType::MidjourneyV6)); assert_eq!(variants.pop_first(), Some(ModelType::MidjourneyV6p1)); diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/mod.rs index 997a114fa5..f1cd6ccbdb 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/mod.rs @@ -5,4 +5,5 @@ pub mod generate_flux_pro_11_text_to_image_handler; pub mod generate_flux_pro_11_ultra_text_to_image_handler; pub mod generate_gpt_image_1_text_to_image_handler; pub mod inpaint; -pub mod remove_image_background_handler; \ No newline at end of file +pub mod remove_image_background_handler; +pub mod multi_function; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/mod.rs new file mode 100644 index 0000000000..1319718491 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/mod.rs @@ -0,0 +1 @@ +pub mod nano_banana_pro_edit_image_handler; diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/nano_banana_pro_edit_image_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/nano_banana_pro_edit_image_handler.rs new file mode 100644 index 0000000000..9a1e6ff704 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/image/multi_function/nano_banana_pro_edit_image_handler.rs @@ -0,0 +1,362 @@ +use std::sync::Arc; + +use crate::http_server::common_responses::common_web_error::CommonWebError; +use crate::http_server::common_responses::media::media_links_builder::MediaLinksBuilder; +use crate::http_server::endpoints::generate::common::payments_error_test::payments_error_test; +use crate::http_server::endpoints::media_files::helpers::get_media_domain::get_media_domain; +use crate::http_server::validations::validate_idempotency_token_format::validate_idempotency_token_format; +use crate::state::server_state::ServerState; +use actix_web::web::Json; +use actix_web::{web, HttpRequest}; +use artcraft_api_defs::generate::image::multi_function::nano_banana_pro_multi_function_image_gen::{NanoBananaProMultiFunctionImageGenAspectRatio, NanoBananaProMultiFunctionImageGenImageResolution, NanoBananaProMultiFunctionImageGenNumImages, NanoBananaProMultiFunctionImageGenRequest, NanoBananaProMultiFunctionImageGenResponse}; +use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath; +use enums::by_table::prompt_context_items::prompt_context_semantic_type::PromptContextSemanticType; +use enums::by_table::prompts::prompt_type::PromptType; +use enums::common::generation_provider::GenerationProvider; +use enums::common::model_type::ModelType; +use enums::common::visibility::Visibility; +use fal_client::creds::open_ai_api_key::OpenAiApiKey; +use http_server_common::request::get_request_ip::get_request_ip; +use log::{error, info, warn}; +use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::insert_generic_inference_job_for_fal_queue; +use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::FalCategory; +use mysql_queries::queries::generic_inference::fal::insert_generic_inference_job_for_fal_queue::InsertGenericInferenceForFalArgs; +use mysql_queries::queries::idepotency_tokens::insert_idempotency_token::insert_idempotency_token; +use mysql_queries::queries::media_files::get::batch_get_media_files_by_tokens::{batch_get_media_files_by_tokens, batch_get_media_files_by_tokens_with_connection}; +use mysql_queries::queries::prompt_context_items::insert_batch_prompt_context_items::{insert_batch_prompt_context_items, InsertBatchArgs, PromptContextItem}; +use mysql_queries::queries::prompts::insert_prompt::{insert_prompt, InsertPromptArgs}; +use server_environment::ServerEnvironment; +use sqlx::pool::PoolConnection; +use sqlx::{Acquire, MySql}; +use tokens::tokens::media_files::MediaFileToken; +use utoipa::ToSchema; +use fal_client::requests::webhook::image::edit::enqueue_nano_banana_pro_edit_image_webhook::{enqueue_nano_banana_pro_image_edit_webhook, EnqueueNanoBananaProEditImageArgs, EnqueueNanoBananaProEditImageAspectRatio, EnqueueNanoBananaProEditImageNumImages, EnqueueNanoBananaProEditImageResolution}; +use fal_client::requests::webhook::image::text::enqueue_nano_banana_pro_text_to_image_webhook::{enqueue_nano_banana_pro_text_to_image_webhook, EnqueueNanoBananaProTextToImageArgs, EnqueueNanoBananaProTextToImageAspectRatio, EnqueueNanoBananaProTextToImageNumImages, EnqueueNanoBananaProTextToImageResolution}; + +/// Nano Banana Pro Multi-Function (generate + edit) +#[utoipa::path( + post, + tag = "Generate Images (Multi-Function)", + path = "/v1/generate/image/multi_function/nano_banana_pro", + responses( + (status = 200, description = "Success", body = NanoBananaProMultiFunctionImageGenResponse), + ), + params( + ("request" = NanoBananaProMultiFunctionImageGenRequest, description = "Payload for Request"), + ) +)] +pub async fn nano_banana_pro_edit_image_handler( + http_request: HttpRequest, + request: Json, + server_state: web::Data> +) -> Result, CommonWebError> { + + payments_error_test(&request.prompt.as_deref().unwrap_or(""))?; + + let mut mysql_connection = server_state.mysql_pool + .acquire() + .await?; + + let maybe_user_session = server_state + .session_checker + .maybe_get_user_session_from_connection(&http_request, &mut mysql_connection) + .await + .map_err(|e| { + warn!("Session checker error: {:?}", e); + CommonWebError::ServerError + })?; + + let maybe_avt_token = server_state + .avt_cookie_manager + .get_avt_token_from_request(&http_request); + + // TODO: Limit usage for new accounts. Billing, free credits metering, etc. + + //let user_session = match maybe_user_session { + // Some(session) => session, + // None => { + // warn!("not logged in"); + // return Err(CommonWebError::NotAuthorized); + // } + //}; + + if let Err(reason) = validate_idempotency_token_format(&request.uuid_idempotency_token) { + return Err(CommonWebError::BadInputWithSimpleMessage(reason)); + } + + let image_urls = match request.image_media_tokens.as_ref() { + Some(media_tokens) => { + info!("Looking up image media tokens: {:?}", media_tokens); + lookup_image_urls( + &http_request, + &mut mysql_connection, + server_state.server_environment, + media_tokens, + ).await? + }, + None => None, + }; + + insert_idempotency_token(&request.uuid_idempotency_token, &mut *mysql_connection) + .await + .map_err(|err| { + error!("Error inserting idempotency token: {:?}", err); + CommonWebError::BadInputWithSimpleMessage("repeated idempotency token".to_string()) + })?; + + info!("Fal webhook URL: {}", server_state.fal.webhook_url); + + let fal_result; + + if let Some(input_image_urls) = image_urls.as_deref() { + info!("nano banana pro edit image"); + + let num_images = match request.num_images { + Some(NanoBananaProMultiFunctionImageGenNumImages::One) => EnqueueNanoBananaProEditImageNumImages::One, + Some(NanoBananaProMultiFunctionImageGenNumImages::Two) => EnqueueNanoBananaProEditImageNumImages::Two, + Some(NanoBananaProMultiFunctionImageGenNumImages::Three) => EnqueueNanoBananaProEditImageNumImages::Three, + Some(NanoBananaProMultiFunctionImageGenNumImages::Four) => EnqueueNanoBananaProEditImageNumImages::Four, + None => EnqueueNanoBananaProEditImageNumImages::One, // Default to One + }; + + let resolution = match request.resolution { + Some(NanoBananaProMultiFunctionImageGenImageResolution::OneK) => EnqueueNanoBananaProEditImageResolution::OneK, + Some(NanoBananaProMultiFunctionImageGenImageResolution::TwoK) => EnqueueNanoBananaProEditImageResolution::TwoK, + Some(NanoBananaProMultiFunctionImageGenImageResolution::FourK) => EnqueueNanoBananaProEditImageResolution::FourK, + None => EnqueueNanoBananaProEditImageResolution::OneK, + }; + + let aspect_ratio = match request.aspect_ratio { + Some(NanoBananaProMultiFunctionImageGenAspectRatio::OneByOne) => EnqueueNanoBananaProEditImageAspectRatio::OneByOne, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FiveByFour) => EnqueueNanoBananaProEditImageAspectRatio::FiveByFour, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FourByThree) => EnqueueNanoBananaProEditImageAspectRatio::FourByThree, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::ThreeByTwo) => EnqueueNanoBananaProEditImageAspectRatio::ThreeByTwo, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::SixteenByNine) => EnqueueNanoBananaProEditImageAspectRatio::SixteenByNine, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::TwentyOneByNine) => EnqueueNanoBananaProEditImageAspectRatio::TwentyOneByNine, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FourByFive) => EnqueueNanoBananaProEditImageAspectRatio::FourByFive, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::ThreeByFour) => EnqueueNanoBananaProEditImageAspectRatio::ThreeByFour, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::TwoByThree) => EnqueueNanoBananaProEditImageAspectRatio::TwoByThree, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::NineBySixteen) => EnqueueNanoBananaProEditImageAspectRatio::NineBySixteen, + None => EnqueueNanoBananaProEditImageAspectRatio::OneByOne, + }; + + let args = EnqueueNanoBananaProEditImageArgs { + prompt: request.prompt.as_deref().unwrap_or(""), + image_urls: input_image_urls.to_owned(), + num_images, + resolution: Some(resolution), + aspect_ratio: Some(aspect_ratio), + webhook_url: &server_state.fal.webhook_url, + api_key: &server_state.fal.api_key, + }; + + fal_result = enqueue_nano_banana_pro_image_edit_webhook(args) + .await + .map_err(|err| { + warn!("Error calling enqueue_nano_banana_pro_image_edit_webhook: {:?}", err); + CommonWebError::ServerError + })?; + + } else { + info!("nano banana pro text-to-image"); + + let num_images = match request.num_images { + Some(NanoBananaProMultiFunctionImageGenNumImages::One) => EnqueueNanoBananaProTextToImageNumImages::One, + Some(NanoBananaProMultiFunctionImageGenNumImages::Two) => EnqueueNanoBananaProTextToImageNumImages::Two, + Some(NanoBananaProMultiFunctionImageGenNumImages::Three) => EnqueueNanoBananaProTextToImageNumImages::Three, + Some(NanoBananaProMultiFunctionImageGenNumImages::Four) => EnqueueNanoBananaProTextToImageNumImages::Four, + None => EnqueueNanoBananaProTextToImageNumImages::One, // Default to One + }; + + let resolution = match request.resolution { + Some(NanoBananaProMultiFunctionImageGenImageResolution::OneK) => EnqueueNanoBananaProTextToImageResolution::OneK, + Some(NanoBananaProMultiFunctionImageGenImageResolution::TwoK) => EnqueueNanoBananaProTextToImageResolution::TwoK, + Some(NanoBananaProMultiFunctionImageGenImageResolution::FourK) => EnqueueNanoBananaProTextToImageResolution::FourK, + None => EnqueueNanoBananaProTextToImageResolution::OneK, + }; + + let aspect_ratio = match request.aspect_ratio { + Some(NanoBananaProMultiFunctionImageGenAspectRatio::OneByOne) => EnqueueNanoBananaProTextToImageAspectRatio::OneByOne, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FiveByFour) => EnqueueNanoBananaProTextToImageAspectRatio::FiveByFour, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FourByThree) => EnqueueNanoBananaProTextToImageAspectRatio::FourByThree, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::ThreeByTwo) => EnqueueNanoBananaProTextToImageAspectRatio::ThreeByTwo, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::SixteenByNine) => EnqueueNanoBananaProTextToImageAspectRatio::SixteenByNine, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::TwentyOneByNine) => EnqueueNanoBananaProTextToImageAspectRatio::TwentyOneByNine, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::FourByFive) => EnqueueNanoBananaProTextToImageAspectRatio::FourByFive, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::ThreeByFour) => EnqueueNanoBananaProTextToImageAspectRatio::ThreeByFour, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::TwoByThree) => EnqueueNanoBananaProTextToImageAspectRatio::TwoByThree, + Some(NanoBananaProMultiFunctionImageGenAspectRatio::NineBySixteen) => EnqueueNanoBananaProTextToImageAspectRatio::NineBySixteen, + None => EnqueueNanoBananaProTextToImageAspectRatio::OneByOne, + }; + + let args = EnqueueNanoBananaProTextToImageArgs { + prompt: request.prompt.as_deref().unwrap_or(""), + num_images, + resolution: Some(resolution), + aspect_ratio: Some(aspect_ratio), + webhook_url: &server_state.fal.webhook_url, + api_key: &server_state.fal.api_key, + }; + + fal_result = enqueue_nano_banana_pro_text_to_image_webhook(args) + .await + .map_err(|err| { + warn!("Error calling enqueue_nano_banana_pro_text_to_image_webhook: {:?}", err); + CommonWebError::ServerError + })?; + } + + let external_job_id = fal_result.request_id + .ok_or_else(|| { + warn!("Fal request_id is None"); + CommonWebError::ServerError + })?; + + info!("Fal request_id: {}", external_job_id); + + let ip_address = get_request_ip(&http_request); + + let mut transaction = mysql_connection + .begin() + .await + .map_err(|err| { + error!("Error starting MySQL transaction: {:?}", err); + CommonWebError::ServerError + })?; + + // NB: Don't fail the job if the query fails. + let prompt_result = insert_prompt(InsertPromptArgs { + maybe_apriori_prompt_token: None, + prompt_type: PromptType::ArtcraftApp, + maybe_creator_user_token: maybe_user_session + .as_ref() + .map(|s| &s.user_token), + maybe_model_type: Some(ModelType::NanoBananaPro), + maybe_generation_provider: Some(GenerationProvider::Artcraft), + maybe_positive_prompt: request.prompt.as_deref(), + maybe_negative_prompt: None, + maybe_other_args: None, + creator_ip_address: &ip_address, + mysql_executor: &mut *transaction, + phantom: Default::default(), + }).await; + + let prompt_token = match prompt_result { + Ok(token) => Some(token), + Err(err) => { + warn!("Error inserting prompt: {:?}", err); + None // Don't fail the job if the prompt insertion fails. + } + }; + + + if let Some(media_tokens) = request.image_media_tokens { + if let Some(token) = prompt_token.as_ref() { + let result = insert_batch_prompt_context_items(InsertBatchArgs { + prompt_token: token.clone(), + items: media_tokens.into_iter().map(|token| { + PromptContextItem { + media_token: token, + context_semantic_type: PromptContextSemanticType::Imgref, + } + }).collect(), + transaction: &mut transaction, + }).await; + + if let Err(err) = result { + // NB: Fail open. + warn!("Error inserting batch prompt context items: {:?}", err); + } + } + } + + let db_result = insert_generic_inference_job_for_fal_queue(InsertGenericInferenceForFalArgs { + uuid_idempotency_token: &request.uuid_idempotency_token, + maybe_external_third_party_id: &external_job_id, + fal_category: FalCategory::ImageGeneration, + maybe_inference_args: None, + maybe_prompt_token: prompt_token.as_ref(), + maybe_creator_user_token: maybe_user_session.as_ref().map(|s| &s.user_token), + maybe_avt_token: maybe_avt_token.as_ref(), + creator_ip_address: &ip_address, + creator_set_visibility: Visibility::Public, + mysql_executor: &mut *transaction, + phantom: Default::default(), + }).await; + + let job_token = match db_result { + Ok(token) => token, + Err(err) => { + warn!("Error inserting generic inference job for FAL queue: {:?}", err); + return Err(CommonWebError::ServerError); + } + }; + + let _r = transaction + .commit() + .await + .map_err(|err| { + error!("Error committing MySQL transaction: {:?}", err); + CommonWebError::ServerError + })?; + + Ok(Json(NanoBananaProMultiFunctionImageGenResponse { + success: true, + inference_job_token: job_token, + })) +} + + +async fn lookup_image_urls( + http_request: &HttpRequest, + mysql_connection: &mut PoolConnection, + server_environment: ServerEnvironment, + tokens: &[MediaFileToken], +) -> Result>, CommonWebError> { + const CAN_SEE_DELETED: bool = false; + + let result = batch_get_media_files_by_tokens_with_connection( + mysql_connection, + tokens, + CAN_SEE_DELETED, + ).await; + + let media_files = match result { + Ok(files) => files, + Err(err) => { + error!("Error getting media files by tokens: {:?}", err); + return Err(CommonWebError::ServerError); + } + }; + + if media_files.len() != tokens.len() { + warn!("Wrong number of media files returned for tokens: {} found for {} tokens", media_files.len(), tokens.len()); + return Err(CommonWebError::BadInputWithSimpleMessage( + format!("Not all media files could be found. Media files found: {}, tokens provided: {}", + media_files.len(), tokens.len()))); + } + + let media_domain = get_media_domain(&http_request); + + let image_urls = media_files.iter() + .map(|file| { + let public_bucket_path = MediaFileBucketPath::from_object_hash( + &file.public_bucket_directory_hash, + file.maybe_public_bucket_prefix.as_deref(), + file.maybe_public_bucket_extension.as_deref()); + + let media_links = MediaLinksBuilder::from_media_path_and_env( + media_domain, + server_environment, + &public_bucket_path); + + media_links.cdn_url.to_string() + }) + .collect::>(); + + if image_urls.is_empty() { + return Ok(None) + } + + Ok(Some(image_urls)) +}