From 396271e27c19478785fab45e6f4ca81af9b956dc Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Thu, 28 Aug 2025 10:38:21 -0400 Subject: [PATCH] veo3 fast handler --- .../generate_veo_3_fast_image_to_video.rs | 47 ++++ .../src/generate/video/mod.rs | 1 + .../public/enums/src/common/model_type.rs | 11 +- ...erate_veo_3_fast_image_to_video_handler.rs | 246 ++++++++++++++++++ .../endpoints/generate/video/mod.rs | 1 + .../http_server/routes/add_generate_routes.rs | 5 + 6 files changed, 310 insertions(+), 1 deletion(-) create mode 100644 crates/schema/public/api/artcraft_api_defs/src/generate/video/generate_veo_3_fast_image_to_video.rs create mode 100644 crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/generate_veo_3_fast_image_to_video_handler.rs diff --git a/crates/schema/public/api/artcraft_api_defs/src/generate/video/generate_veo_3_fast_image_to_video.rs b/crates/schema/public/api/artcraft_api_defs/src/generate/video/generate_veo_3_fast_image_to_video.rs new file mode 100644 index 0000000000..80af0d6ced --- /dev/null +++ b/crates/schema/public/api/artcraft_api_defs/src/generate/video/generate_veo_3_fast_image_to_video.rs @@ -0,0 +1,47 @@ +use serde::{Deserialize, Serialize}; +use tokens::tokens::generic_inference_jobs::InferenceJobToken; +use tokens::tokens::media_files::MediaFileToken; +use utoipa::ToSchema; + +pub const GENERATE_VEO_3_FAST_IMAGE_TO_VIDEO_URL_PATH: &str = "/v1/generate/video/veo_3_fast_image_to_video"; + +#[derive(Serialize, Deserialize, ToSchema)] +pub struct GenerateVeo3FastImageToVideoRequest { + /// Idempotency token to prevent duplicate requests. + pub uuid_idempotency_token: String, + + /// Source of the image file to convert to video. + /// It must be an image. + pub media_file_token: Option, + + /// Optional text prompt. + pub prompt: Option, + + /// Optional: resolution of the generated video. + pub resolution: Option, + + /// Optional: aspect ratio of the generated video. + pub duration: Option, + + /// Optional: Generate an audio track along with the video + pub generate_audio: Option, +} + +#[derive(Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum GenerateVeo3FastResolution { + SevenTwentyP, // 720p + TenEightyP, // 1080p +} + +#[derive(Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum GenerateVeo3FastDuration { + EightSeconds, +} + +#[derive(Serialize, Deserialize, ToSchema)] +pub struct GenerateVeo3FastImageToVideoResponse { + pub success: bool, + pub inference_job_token: InferenceJobToken, +} diff --git a/crates/schema/public/api/artcraft_api_defs/src/generate/video/mod.rs b/crates/schema/public/api/artcraft_api_defs/src/generate/video/mod.rs index f0bf537f8f..193249cb12 100644 --- a/crates/schema/public/api/artcraft_api_defs/src/generate/video/mod.rs +++ b/crates/schema/public/api/artcraft_api_defs/src/generate/video/mod.rs @@ -3,4 +3,5 @@ pub mod generate_kling_2_1_master_image_to_video; pub mod generate_kling_2_1_pro_image_to_video; pub mod generate_seedance_1_0_lite_image_to_video; pub mod generate_veo_2_image_to_video; +pub mod generate_veo_3_fast_image_to_video; pub mod generate_veo_3_image_to_video; \ No newline at end of file diff --git a/crates/schema/public/enums/src/common/model_type.rs b/crates/schema/public/enums/src/common/model_type.rs index 9d3fdf2126..5894615308 100644 --- a/crates/schema/public/enums/src/common/model_type.rs +++ b/crates/schema/public/enums/src/common/model_type.rs @@ -69,6 +69,8 @@ pub enum ModelType { Veo2, #[serde(rename = "veo_3")] Veo3, + #[serde(rename = "veo_3_fast")] + Veo3Fast, // 3D Object generation models #[serde(rename = "hunyuan_3d_2p0")] @@ -113,6 +115,7 @@ impl ModelType { Self::Seedance10Lite => "seedance_1p0_lite", Self::Veo2 => "veo_2", Self::Veo3 => "veo_3", + Self::Veo3Fast => "veo_3_fast", // 3D Object generation models Self::Hunyuan3d2_0 => "hunyuan_3d_2p0", @@ -149,6 +152,7 @@ impl ModelType { "seedance_1p0_lite" => Ok(Self::Seedance10Lite), "veo_2" => Ok(Self::Veo2), "veo_3" => Ok(Self::Veo3), + "veo_3_fast" => Ok(Self::Veo3Fast), // 3D Object generation models "hunyuan_3d_2p0" => Ok(Self::Hunyuan3d2_0), @@ -189,6 +193,7 @@ impl ModelType { Self::Seedance10Lite, Self::Veo2, Self::Veo3, + Self::Veo3Fast, // 3D Object generation models Self::Hunyuan3d2_0, @@ -233,6 +238,7 @@ mod tests { assert_serialization(ModelType::Seedance10Lite, "seedance_1p0_lite"); assert_serialization(ModelType::Veo2, "veo_2"); assert_serialization(ModelType::Veo3, "veo_3"); + assert_serialization(ModelType::Veo3Fast, "veo_3_fast"); // 3D Object generation models assert_serialization(ModelType::Hunyuan3d2_0, "hunyuan_3d_2p0"); assert_serialization(ModelType::Hunyuan3d2_1, "hunyuan_3d_2p1"); @@ -267,6 +273,7 @@ mod tests { assert_eq!(ModelType::Seedance10Lite.to_str(), "seedance_1p0_lite"); assert_eq!(ModelType::Veo2.to_str(), "veo_2"); assert_eq!(ModelType::Veo3.to_str(), "veo_3"); + assert_eq!(ModelType::Veo3Fast.to_str(), "veo_3_fast"); // 3D Object generation models assert_eq!(ModelType::Hunyuan3d2_0.to_str(), "hunyuan_3d_2p0"); @@ -301,6 +308,7 @@ mod tests { assert_eq!(ModelType::from_str("seedance_1p0_lite").unwrap(), ModelType::Seedance10Lite); assert_eq!(ModelType::from_str("veo_2").unwrap(), ModelType::Veo2); assert_eq!(ModelType::from_str("veo_3").unwrap(), ModelType::Veo3); + assert_eq!(ModelType::from_str("veo_3_fast").unwrap(), ModelType::Veo3Fast); // 3D Object generation models assert_eq!(ModelType::from_str("hunyuan_3d_2p0").unwrap(), ModelType::Hunyuan3d2_0); assert_eq!(ModelType::from_str("hunyuan_3d_2p1").unwrap(), ModelType::Hunyuan3d2_1); @@ -309,7 +317,7 @@ mod tests { #[test] fn all_variants() { let mut variants = ModelType::all_variants(); - assert_eq!(variants.len(), 26); + assert_eq!(variants.len(), 27); // Image models assert_eq!(variants.pop_first(), Some(ModelType::Flux1Dev)); assert_eq!(variants.pop_first(), Some(ModelType::Flux1Schnell)); @@ -336,6 +344,7 @@ mod tests { assert_eq!(variants.pop_first(), Some(ModelType::Seedance10Lite)); assert_eq!(variants.pop_first(), Some(ModelType::Veo2)); assert_eq!(variants.pop_first(), Some(ModelType::Veo3)); + assert_eq!(variants.pop_first(), Some(ModelType::Veo3Fast)); // 3D Object generation models assert_eq!(variants.pop_first(), Some(ModelType::Hunyuan3d2_0)); assert_eq!(variants.pop_first(), Some(ModelType::Hunyuan3d2_1)); diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/generate_veo_3_fast_image_to_video_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/generate_veo_3_fast_image_to_video_handler.rs new file mode 100644 index 0000000000..4966677849 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/generate_veo_3_fast_image_to_video_handler.rs @@ -0,0 +1,246 @@ +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::analytics::log_browser_session_handler::LogBrowserSessionError; +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 anyhow::anyhow; +use artcraft_api_defs::generate::video::generate_veo_3_fast_image_to_video::{GenerateVeo3FastDuration, GenerateVeo3FastImageToVideoRequest, GenerateVeo3FastImageToVideoResponse, GenerateVeo3FastResolution}; +use bucket_paths::legacy::typified_paths::public::media_files::bucket_file_path::MediaFileBucketPath; +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::requests::webhook::video::enqueue_veo_3_fast_image_to_video_webhook::{enqueue_veo_3_fast_image_to_video_webhook, Veo3FastArgs, Veo3FastDuration, Veo3FastResolution}; +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::get_media_file::get_media_file_with_connection; +use mysql_queries::queries::prompts::insert_prompt::{insert_prompt, InsertPromptArgs}; +use sqlx::Acquire; +use tokens::tokens::prompts::PromptToken; +use utoipa::ToSchema; + +/// Veo 3 Image to Video +#[utoipa::path( + post, + tag = "Generate Videos", + path = "/v1/generate/video/veo_3_fast_image_to_video", + responses( + (status = 200, description = "Success", body = GenerateVeo3FastImageToVideoResponse), + ), + params( + ("request" = GenerateVeo3FastImageToVideoRequest, description = "Payload for Request"), + ) +)] +pub async fn generate_veo_3_fast_image_to_video_handler( + http_request: HttpRequest, + request: Json, + server_state: web::Data> +) -> Result, CommonWebError> { + 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(RemoveImageBackgroundError::NotAuthorized); + // } + //}; + + let media_file_token = match &request.media_file_token { + Some(token) => token, + None => { + warn!("No media file token provided"); + return Err(CommonWebError::BadInputWithSimpleMessage("No media file token provided".to_string())); + } + }; + + if let Err(reason) = validate_idempotency_token_format(&request.uuid_idempotency_token) { + return Err(CommonWebError::BadInputWithSimpleMessage(reason)); + } + + insert_idempotency_token(&request.uuid_idempotency_token, &mut *mysql_connection) + .await + .map_err(|err| { + error!("Error inserting idempotency token: {:?}", err); + CommonWebError::BadInputWithSimpleMessage("invalid idempotency token".to_string()) + })?; + const IS_MOD : bool = false; + + let media_file_lookup_result = get_media_file_with_connection( + media_file_token, + IS_MOD, + &mut mysql_connection, + ).await; + + let media_file = match media_file_lookup_result { + Ok(Some(media_file)) => media_file, + Ok(None) => { + warn!("MediaFile not found: {:?}", media_file_token); + return Err(CommonWebError::NotFound); + }, + Err(err) => { + warn!("Error looking up media_file: {:?}", err); + return Err(CommonWebError::ServerError); + } + }; + + if !media_file.media_type.is_jpg_or_png_or_legacy_image() { + return Err(CommonWebError::BadInputWithSimpleMessage("Media file must be a JPG or PNG image".to_string())); + } + + let media_domain = get_media_domain(&http_request); + + let bucket_path = MediaFileBucketPath::from_object_hash( + &media_file.public_bucket_directory_hash, + media_file.maybe_public_bucket_prefix.as_deref(), + media_file.maybe_public_bucket_extension.as_deref()); + + let media_links = MediaLinksBuilder::from_media_path_and_env( + media_domain, + server_state.server_environment, + &bucket_path); + + info!("Fal webhook URL: {}", server_state.fal.webhook_url); + + let prompt = request.prompt + .as_deref() + .map(|prompt| prompt.trim()) + .unwrap_or_else(|| ""); + + let resolution = match &request.resolution { + Some(GenerateVeo3FastResolution::SevenTwentyP) => Veo3FastResolution::SevenTwentyP, + Some(GenerateVeo3FastResolution::TenEightyP) => Veo3FastResolution::TenEightyP, + None => Veo3FastResolution::Default, + }; + + let duration = match &request.duration { + Some(GenerateVeo3FastDuration::EightSeconds) => Veo3FastDuration::EightSeconds, + None => Veo3FastDuration::EightSeconds, + }; + + let generate_audio = request.generate_audio + .unwrap_or(false); + + let args = Veo3FastArgs { + image_url: media_links.cdn_url, + prompt, + duration, + resolution, + generate_audio, + webhook_url: &server_state.fal.webhook_url, + api_key: &server_state.fal.api_key, + }; + + let fal_result = enqueue_veo_3_fast_image_to_video_webhook(args) + .await + .map_err(|err| { + warn!("Error calling enqueue_veo_3_fast_image_to_video_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::Veo3Fast), + maybe_generation_provider: Some(GenerationProvider::Artcraft), + maybe_positive_prompt: Some(prompt), + 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. + } + }; + + 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::VideoGeneration, + 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(GenerateVeo3FastImageToVideoResponse { + success: true, + inference_job_token: job_token, + })) +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/mod.rs index b421e8094a..09e29abafb 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/mod.rs @@ -3,4 +3,5 @@ pub mod generate_kling_2_1_master_video_handler; pub mod generate_kling_2_1_pro_video_handler; pub mod generate_seedance_1_0_lite_image_to_video_handler; pub mod generate_veo_2_image_to_video_handler; +pub mod generate_veo_3_fast_image_to_video_handler; pub mod generate_veo_3_image_to_video_handler; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/routes/add_generate_routes.rs b/crates/service/web/storyteller_web/src/http_server/routes/add_generate_routes.rs index 6a76ee3a1e..a5e614559d 100644 --- a/crates/service/web/storyteller_web/src/http_server/routes/add_generate_routes.rs +++ b/crates/service/web/storyteller_web/src/http_server/routes/add_generate_routes.rs @@ -16,6 +16,7 @@ use crate::http_server::endpoints::generate::video::generate_kling_2_1_master_vi use crate::http_server::endpoints::generate::video::generate_kling_2_1_pro_video_handler::generate_kling_2_1_pro_video_handler; use crate::http_server::endpoints::generate::video::generate_seedance_1_0_lite_image_to_video_handler::generate_seedance_1_0_lite_image_to_video_handler; use crate::http_server::endpoints::generate::video::generate_veo_2_image_to_video_handler::generate_veo_2_image_to_video_handler; +use crate::http_server::endpoints::generate::video::generate_veo_3_fast_image_to_video_handler::generate_veo_3_fast_image_to_video_handler; use crate::http_server::endpoints::generate::video::generate_veo_3_image_to_video_handler::generate_veo_3_image_to_video_handler; use actix_http::body::MessageBody; use actix_service::ServiceFactory; @@ -110,6 +111,10 @@ where .route(web::post().to(generate_veo_3_image_to_video_handler)) .route(web::head().to(|| HttpResponse::Ok())) ) + .service(web::resource("/veo_3_fast_image_to_video") + .route(web::post().to(generate_veo_3_fast_image_to_video_handler)) + .route(web::head().to(|| HttpResponse::Ok())) + ) ) .service(web::scope("/object") .service(web::resource("/hunyuan_2.0_image_to_3d")