diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/multi_function/seedance_2p0_multi_function_video_gen_handler.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/multi_function/seedance_2p0_multi_function_video_gen_handler.rs index 2ab29c54a7..29e52ee8d4 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/multi_function/seedance_2p0_multi_function_video_gen_handler.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/generate/video/multi_function/seedance_2p0_multi_function_video_gen_handler.rs @@ -18,6 +18,7 @@ use crate::http_server::web_utils::get_request_platform_type::get_request_platfo use crate::state::server_state::ServerState; use crate::util::http_download_url_to_bytes::http_download_url_to_bytes; use crate::util::lookup::lookup_media_file_urls_as_map::lookup_media_file_urls_as_map; +use crate::util::text_contains_cjk::text_contains_cjk; use actix_web::web::Json; use actix_web::{web, HttpRequest, ResponseError}; use artcraft_api_defs::generate::video::multi_function::seedance_2p0_multi_function_video_gen::{ @@ -61,6 +62,9 @@ use tokens::tokens::users::UserToken; use url::Url; use url_utils::extension::extract_extension_from_url::{extract_extension_from_url, ExtractExtensions}; +const MAX_PROMPT_CHARS: usize = 10_000; +const MAX_IMAGE_REFERENCES: usize = 9; + // ======================== Result of a successful generation ======================== /// Everything the caller needs after a successful upload + generate cycle. @@ -97,6 +101,10 @@ pub async fn seedance_2p0_multi_function_video_gen_handler( server_state: web::Data>, ) -> Result, CommonWebError> { + // Reject requests that exceed Seedance 2.0's upstream limits (prompt length, + // reference image count) before any billable or DB-mutating work. + validate_seedance_2p0_limits(&request)?; + payments_error_test(&request.prompt.as_deref().unwrap_or(""))?; let mut mysql_connection = server_state.mysql_pool @@ -538,6 +546,38 @@ pub async fn seedance_2p0_multi_function_video_gen_handler( // ======================== Helpers ======================== +/// Seedance 2.0 fails upstream when the prompt exceeds 10,000 characters +/// (unless it contains Chinese, Japanese, or Korean text, which the provider +/// handles differently) or when more than 9 reference images are supplied. +/// Reject these doomed requests up front so callers see a clean 400 with an +/// actionable message and we don't charge their wallet for an inference job +/// we know will fail. +fn validate_seedance_2p0_limits( + request: &Seedance2p0MultiFunctionVideoGenRequest, +) -> Result<(), CommonWebError> { + if let Some(prompt) = request.prompt.as_deref() { + let char_count = prompt.chars().count(); + if char_count > MAX_PROMPT_CHARS && !text_contains_cjk(prompt) { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Prompt is too long: Seedance 2.0 models accept at most {MAX_PROMPT_CHARS} characters (got {char_count}).", + ))); + } + } + + let image_reference_count = request + .reference_image_media_tokens + .as_ref() + .map_or(0, |tokens| tokens.len()); + + if image_reference_count > MAX_IMAGE_REFERENCES { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Too many image references: Seedance 2.0 models accept at most {MAX_IMAGE_REFERENCES} reference images (got {image_reference_count}).", + ))); + } + + Ok(()) +} + fn map_resolution(aspect_ratio: Option) -> KinoviAspectRatio { match aspect_ratio { Some(Seedance2p0AspectRatio::Landscape16x9) => KinoviAspectRatio::Landscape16x9, @@ -828,3 +868,86 @@ async fn upload_to_seedance2pro( Ok(upload_result.public_url) } + +#[cfg(test)] +mod tests { + use super::*; + + mod seedance_limits_tests { + use super::*; + + #[test] + fn accepts_prompt_at_limit() { + let req = Seedance2p0MultiFunctionVideoGenRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_prompt_over_limit() { + let req = Seedance2p0MultiFunctionVideoGenRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn accepts_over_limit_prompt_containing_cjk() { + let mut prompt = "a".repeat(MAX_PROMPT_CHARS + 1); + prompt.push('猫'); + let req = Seedance2p0MultiFunctionVideoGenRequest { + prompt: Some(prompt), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn accepts_nine_image_references() { + let req = Seedance2p0MultiFunctionVideoGenRequest { + reference_image_media_tokens: Some(reference_tokens(MAX_IMAGE_REFERENCES)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_ten_image_references() { + let req = Seedance2p0MultiFunctionVideoGenRequest { + reference_image_media_tokens: Some(reference_tokens(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + } + + fn base_request() -> Seedance2p0MultiFunctionVideoGenRequest { + Seedance2p0MultiFunctionVideoGenRequest { + uuid_idempotency_token: "a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string(), + prompt: Some("test".to_string()), + start_frame_media_token: None, + end_frame_media_token: None, + reference_image_media_tokens: None, + reference_video_media_tokens: None, + reference_audio_media_tokens: None, + reference_character_tokens: None, + aspect_ratio: None, + output_resolution: None, + duration_seconds: Some(5), + batch_count: None, + } + } + + fn reference_tokens(count: usize) -> Vec { + (0..count).map(|i| MediaFileToken::new(format!("mf_{i}"))).collect() + } +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/mod.rs index bfdbcc2afa..30f45d614e 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/mod.rs @@ -1,2 +1,3 @@ +mod validate_seedance_2p0_limits; pub mod validate_video_request; mod validate_when_image_required; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_seedance_2p0_limits.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_seedance_2p0_limits.rs new file mode 100644 index 0000000000..ca5e87aec6 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_seedance_2p0_limits.rs @@ -0,0 +1,255 @@ +use artcraft_api_defs::omni_api::generate_requests::omni_api_video_generate_request::OmniApiVideoGenerateRequest; +use enums::common::generation::common_video_model::CommonVideoModel; + +use crate::http_server::common_responses::common_web_error::CommonWebError; +use crate::util::text_contains_cjk::text_contains_cjk; + +const MAX_PROMPT_CHARS: usize = 10_000; +const MAX_IMAGE_REFERENCES: usize = 9; + +/// Seedance 2.0 fails upstream when the prompt exceeds 10,000 characters +/// (unless it contains Chinese, Japanese, or Korean text, which the provider +/// handles differently) or when more than 9 reference images are supplied. +/// Reject these doomed requests at the handler layer so callers see a clean +/// 400 with an actionable message and we don't charge their wallet for an +/// inference job we know will fail. +pub (super) fn validate_seedance_2p0_limits( + request: &OmniApiVideoGenerateRequest, +) -> Result<(), CommonWebError> { + match request.model { + Some(model) if is_seedance_2p0_model(model) => {}, // Fall-through + _ => return Ok(()), + } + + if let Some(prompt) = request.prompt.as_deref() { + let char_count = prompt.chars().count(); + if char_count > MAX_PROMPT_CHARS && !text_contains_cjk(prompt) { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Prompt is too long: Seedance 2.0 models accept at most {MAX_PROMPT_CHARS} characters (got {char_count}).", + ))); + } + } + + // NB: Reference images may be supplied as media tokens or as URLs (the two + // are mutually exclusive, enforced by check_request); count both. + let image_reference_count = request + .reference_image_media_tokens + .as_ref() + .map_or(0, |tokens| tokens.len()) + + request + .reference_image_urls + .as_ref() + .map_or(0, |urls| urls.len()); + + if image_reference_count > MAX_IMAGE_REFERENCES { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Too many image references: Seedance 2.0 models accept at most {MAX_IMAGE_REFERENCES} reference images (got {image_reference_count}).", + ))); + } + + Ok(()) +} + +/// Seedance 2.0 base / Fast / Mini, across the Volcengine and BytePlus +/// accounts. The Ultra and preview_model variants are deliberately excluded. +fn is_seedance_2p0_model(model: CommonVideoModel) -> bool { + matches!(model, + CommonVideoModel::Seedance2p0 + | CommonVideoModel::Seedance2p0Fast + | CommonVideoModel::Seedance2p0Mini + | CommonVideoModel::Seedance2p0BytePlus + | CommonVideoModel::Seedance2p0BytePlusFast + | CommonVideoModel::Seedance2p0BytePlusMini + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use tokens::tokens::media_files::MediaFileToken; + + fn base_request() -> OmniApiVideoGenerateRequest { + OmniApiVideoGenerateRequest { + idempotency_token: Some("a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string()), + model: Some(CommonVideoModel::Seedance2p0), + prompt: Some("test".to_string()), + negative_prompt: None, + start_frame_image_media_token: None, + start_frame_image_url: None, + end_frame_image_media_token: None, + end_frame_image_url: None, + reference_image_media_tokens: None, + reference_image_urls: None, + reference_video_media_tokens: None, + reference_video_urls: None, + reference_audio_media_tokens: None, + reference_audio_urls: None, + reference_character_tokens: None, + resolution: None, + aspect_ratio: None, + bitrate: None, + quality: None, + duration_seconds: Some(5), + video_batch_count: Some(1), + generate_audio: None, + } + } + + fn tokens(count: usize) -> Vec { + (0..count).map(|i| MediaFileToken::new(format!("mf_{i}"))).collect() + } + + fn urls(count: usize) -> Vec { + (0..count).map(|i| format!("https://example.com/image_{i}.png")).collect() + } + + mod prompt_length_tests { + use super::*; + + #[test] + fn accepts_prompt_at_limit() { + let req = OmniApiVideoGenerateRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_prompt_over_limit() { + let req = OmniApiVideoGenerateRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn accepts_over_limit_prompt_containing_cjk() { + let mut prompt = "a".repeat(MAX_PROMPT_CHARS + 1); + prompt.push('猫'); + let req = OmniApiVideoGenerateRequest { + prompt: Some(prompt), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_over_limit_prompt_for_all_seedance_2p0_variants() { + let seedance_models = [ + CommonVideoModel::Seedance2p0, + CommonVideoModel::Seedance2p0Fast, + CommonVideoModel::Seedance2p0Mini, + CommonVideoModel::Seedance2p0BytePlus, + CommonVideoModel::Seedance2p0BytePlusFast, + CommonVideoModel::Seedance2p0BytePlusMini, + ]; + for model in seedance_models { + let req = OmniApiVideoGenerateRequest { + model: Some(model), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!( + validate_seedance_2p0_limits(&req).is_err(), + "expected rejection for {:?}", model, + ); + } + } + + #[test] + fn ignores_over_limit_prompt_for_excluded_seedance_variants() { + let excluded_models = [ + CommonVideoModel::Seedance2p0Ultra, + CommonVideoModel::Seedance2p0UltraFast, + CommonVideoModel::Seedance2p0BytePlusUltra, + CommonVideoModel::Seedance2p0BytePlusUltraFast, + CommonVideoModel::Seedance2p0BytePlusUltraMini, + CommonVideoModel::PreviewModel, + CommonVideoModel::PreviewModelFast, + ]; + for model in excluded_models { + let req = OmniApiVideoGenerateRequest { + model: Some(model), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!( + validate_seedance_2p0_limits(&req).is_ok(), + "expected no check for {:?}", model, + ); + } + } + + #[test] + fn ignores_over_limit_prompt_for_other_models() { + let req = OmniApiVideoGenerateRequest { + model: Some(CommonVideoModel::Veo3p1), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn ignores_over_limit_prompt_when_model_is_none() { + let req = OmniApiVideoGenerateRequest { + model: None, + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + } + + mod image_reference_tests { + use super::*; + + #[test] + fn accepts_nine_image_reference_tokens() { + let req = OmniApiVideoGenerateRequest { + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_ten_image_reference_tokens() { + let req = OmniApiVideoGenerateRequest { + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn rejects_ten_image_reference_urls() { + let req = OmniApiVideoGenerateRequest { + reference_image_urls: Some(urls(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn ignores_ten_image_references_for_other_models() { + let req = OmniApiVideoGenerateRequest { + model: Some(CommonVideoModel::Kling3p0Pro), + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + } +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_video_request.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_video_request.rs index 346684f58a..f578f69c39 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_video_request.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_api/shared_utils/video/validate_video_request.rs @@ -1,4 +1,5 @@ use crate::http_server::common_responses::common_web_error::CommonWebError; +use crate::http_server::endpoints::omni_api::shared_utils::video::validate_seedance_2p0_limits::validate_seedance_2p0_limits; use crate::http_server::endpoints::omni_api::shared_utils::video::validate_when_image_required::validate_when_image_required; use artcraft_api_defs::omni_api::generate_requests::omni_api_video_generate_request::OmniApiVideoGenerateRequest; @@ -7,5 +8,6 @@ pub fn validate_video_request( request: &OmniApiVideoGenerateRequest, ) -> Result<(), CommonWebError> { validate_when_image_required(request)?; + validate_seedance_2p0_limits(request)?; Ok(()) } diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/mod.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/mod.rs index bfdbcc2afa..30f45d614e 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/mod.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/mod.rs @@ -1,2 +1,3 @@ +mod validate_seedance_2p0_limits; pub mod validate_video_request; mod validate_when_image_required; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_seedance_2p0_limits.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_seedance_2p0_limits.rs new file mode 100644 index 0000000000..52f995f0b3 --- /dev/null +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_seedance_2p0_limits.rs @@ -0,0 +1,228 @@ +use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest; +use enums::common::generation::common_video_model::CommonVideoModel; + +use crate::http_server::common_responses::common_web_error::CommonWebError; +use crate::util::text_contains_cjk::text_contains_cjk; + +const MAX_PROMPT_CHARS: usize = 10_000; +const MAX_IMAGE_REFERENCES: usize = 9; + +/// Seedance 2.0 fails upstream when the prompt exceeds 10,000 characters +/// (unless it contains Chinese, Japanese, or Korean text, which the provider +/// handles differently) or when more than 9 reference images are supplied. +/// Reject these doomed requests at the handler layer so callers see a clean +/// 400 with an actionable message and we don't charge their wallet for an +/// inference job we know will fail. +pub (super) fn validate_seedance_2p0_limits( + request: &OmniGenVideoCostAndGenerateRequest, +) -> Result<(), CommonWebError> { + match request.model { + Some(model) if is_seedance_2p0_model(model) => {}, // Fall-through + _ => return Ok(()), + } + + if let Some(prompt) = request.prompt.as_deref() { + let char_count = prompt.chars().count(); + if char_count > MAX_PROMPT_CHARS && !text_contains_cjk(prompt) { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Prompt is too long: Seedance 2.0 models accept at most {MAX_PROMPT_CHARS} characters (got {char_count}).", + ))); + } + } + + let image_reference_count = request + .reference_image_media_tokens + .as_ref() + .map_or(0, |tokens| tokens.len()); + + if image_reference_count > MAX_IMAGE_REFERENCES { + return Err(CommonWebError::BadInputWithSimpleMessage(format!( + "Too many image references: Seedance 2.0 models accept at most {MAX_IMAGE_REFERENCES} reference images (got {image_reference_count}).", + ))); + } + + Ok(()) +} + +/// Seedance 2.0 base / Fast / Mini, across the Volcengine and BytePlus +/// accounts. The Ultra and preview_model variants are deliberately excluded. +fn is_seedance_2p0_model(model: CommonVideoModel) -> bool { + matches!(model, + CommonVideoModel::Seedance2p0 + | CommonVideoModel::Seedance2p0Fast + | CommonVideoModel::Seedance2p0Mini + | CommonVideoModel::Seedance2p0BytePlus + | CommonVideoModel::Seedance2p0BytePlusFast + | CommonVideoModel::Seedance2p0BytePlusMini + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use tokens::tokens::media_files::MediaFileToken; + + fn base_request() -> OmniGenVideoCostAndGenerateRequest { + OmniGenVideoCostAndGenerateRequest { + idempotency_token: Some("a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string()), + model: Some(CommonVideoModel::Seedance2p0), + prompt: Some("test".to_string()), + negative_prompt: None, + start_frame_image_media_token: None, + end_frame_image_media_token: None, + reference_image_media_tokens: None, + reference_video_media_tokens: None, + reference_audio_media_tokens: None, + reference_character_tokens: None, + resolution: None, + aspect_ratio: None, + bitrate: None, + quality: None, + duration_seconds: Some(5), + video_batch_count: Some(1), + generate_audio: None, + } + } + + fn tokens(count: usize) -> Vec { + (0..count).map(|i| MediaFileToken::new(format!("mf_{i}"))).collect() + } + + mod prompt_length_tests { + use super::*; + + #[test] + fn accepts_prompt_at_limit() { + let req = OmniGenVideoCostAndGenerateRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_prompt_over_limit() { + let req = OmniGenVideoCostAndGenerateRequest { + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn accepts_over_limit_prompt_containing_cjk() { + let mut prompt = "a".repeat(MAX_PROMPT_CHARS + 1); + prompt.push('猫'); + let req = OmniGenVideoCostAndGenerateRequest { + prompt: Some(prompt), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_over_limit_prompt_for_all_seedance_2p0_variants() { + let seedance_models = [ + CommonVideoModel::Seedance2p0, + CommonVideoModel::Seedance2p0Fast, + CommonVideoModel::Seedance2p0Mini, + CommonVideoModel::Seedance2p0BytePlus, + CommonVideoModel::Seedance2p0BytePlusFast, + CommonVideoModel::Seedance2p0BytePlusMini, + ]; + for model in seedance_models { + let req = OmniGenVideoCostAndGenerateRequest { + model: Some(model), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!( + validate_seedance_2p0_limits(&req).is_err(), + "expected rejection for {:?}", model, + ); + } + } + + #[test] + fn ignores_over_limit_prompt_for_excluded_seedance_variants() { + let excluded_models = [ + CommonVideoModel::Seedance2p0Ultra, + CommonVideoModel::Seedance2p0UltraFast, + CommonVideoModel::Seedance2p0BytePlusUltra, + CommonVideoModel::Seedance2p0BytePlusUltraFast, + CommonVideoModel::Seedance2p0BytePlusUltraMini, + CommonVideoModel::PreviewModel, + CommonVideoModel::PreviewModelFast, + ]; + for model in excluded_models { + let req = OmniGenVideoCostAndGenerateRequest { + model: Some(model), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!( + validate_seedance_2p0_limits(&req).is_ok(), + "expected no check for {:?}", model, + ); + } + } + + #[test] + fn ignores_over_limit_prompt_for_other_models() { + let req = OmniGenVideoCostAndGenerateRequest { + model: Some(CommonVideoModel::Veo3p1), + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn ignores_over_limit_prompt_when_model_is_none() { + let req = OmniGenVideoCostAndGenerateRequest { + model: None, + prompt: Some("a".repeat(MAX_PROMPT_CHARS + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + } + + mod image_reference_tests { + use super::*; + + #[test] + fn accepts_nine_image_references() { + let req = OmniGenVideoCostAndGenerateRequest { + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + + #[test] + fn rejects_ten_image_references() { + let req = OmniGenVideoCostAndGenerateRequest { + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(matches!( + validate_seedance_2p0_limits(&req), + Err(CommonWebError::BadInputWithSimpleMessage(_)) + )); + } + + #[test] + fn ignores_ten_image_references_for_other_models() { + let req = OmniGenVideoCostAndGenerateRequest { + model: Some(CommonVideoModel::Kling3p0Pro), + reference_image_media_tokens: Some(tokens(MAX_IMAGE_REFERENCES + 1)), + ..base_request() + }; + assert!(validate_seedance_2p0_limits(&req).is_ok()); + } + } +} diff --git a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_video_request.rs b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_video_request.rs index be9e4c6e0d..ea21b8a800 100644 --- a/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_video_request.rs +++ b/crates/service/web/storyteller_web/src/http_server/endpoints/omni_gen/shared_utils/video/validate_video_request.rs @@ -1,4 +1,5 @@ use crate::http_server::common_responses::common_web_error::CommonWebError; +use crate::http_server::endpoints::omni_gen::shared_utils::video::validate_seedance_2p0_limits::validate_seedance_2p0_limits; use crate::http_server::endpoints::omni_gen::shared_utils::video::validate_when_image_required::validate_when_image_required; use artcraft_api_defs::omni_gen::cost_and_generate_requests::omni_gen_video_cost_and_generate_request::OmniGenVideoCostAndGenerateRequest; @@ -7,5 +8,6 @@ pub fn validate_video_request( request: &OmniGenVideoCostAndGenerateRequest, ) -> Result<(), CommonWebError> { validate_when_image_required(request)?; + validate_seedance_2p0_limits(request)?; Ok(()) } diff --git a/crates/service/web/storyteller_web/src/util/mod.rs b/crates/service/web/storyteller_web/src/util/mod.rs index 54665af215..b4daad8894 100644 --- a/crates/service/web/storyteller_web/src/util/mod.rs +++ b/crates/service/web/storyteller_web/src/util/mod.rs @@ -13,6 +13,7 @@ pub mod http_download_url_to_tempfile; pub mod lookup; pub mod placeholder_images; pub mod read_toml_file_to_struct; +pub mod text_contains_cjk; pub mod title_to_url_slug; pub mod traits; pub mod troll_user_bans; \ No newline at end of file diff --git a/crates/service/web/storyteller_web/src/util/text_contains_cjk.rs b/crates/service/web/storyteller_web/src/util/text_contains_cjk.rs new file mode 100644 index 0000000000..28247995f4 --- /dev/null +++ b/crates/service/web/storyteller_web/src/util/text_contains_cjk.rs @@ -0,0 +1,64 @@ +/// Returns true if the text contains any Chinese, Japanese, or Korean characters. +pub fn text_contains_cjk(text: &str) -> bool { + text.chars().any(is_cjk_char) +} + +fn is_cjk_char(c: char) -> bool { + matches!(c as u32, + 0x1100..=0x11FF // Hangul Jamo + | 0x3040..=0x309F // Hiragana + | 0x30A0..=0x30FF // Katakana + | 0x3130..=0x318F // Hangul Compatibility Jamo + | 0x31F0..=0x31FF // Katakana Phonetic Extensions + | 0x3400..=0x4DBF // CJK Unified Ideographs Extension A + | 0x4E00..=0x9FFF // CJK Unified Ideographs + | 0xA960..=0xA97F // Hangul Jamo Extended-A + | 0xAC00..=0xD7AF // Hangul Syllables + | 0xD7B0..=0xD7FF // Hangul Jamo Extended-B + | 0xF900..=0xFAFF // CJK Compatibility Ideographs + | 0xFF66..=0xFF9D // Halfwidth Katakana + | 0x20000..=0x2FA1F // CJK Unified Ideographs Extensions B+ and Supplement + ) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn detects_chinese() { + assert!(text_contains_cjk("一只猫在田野里奔跑")); + } + + #[test] + fn detects_japanese_hiragana_and_katakana() { + assert!(text_contains_cjk("ねこ")); + assert!(text_contains_cjk("ネコ")); + } + + #[test] + fn detects_korean() { + assert!(text_contains_cjk("고양이")); + } + + #[test] + fn detects_cjk_mixed_into_latin_text() { + assert!(text_contains_cjk("a cat 猫 running")); + } + + #[test] + fn does_not_detect_latin_or_accented_text() { + assert!(!text_contains_cjk("a cat running through a field")); + assert!(!text_contains_cjk("un château élégant")); + } + + #[test] + fn does_not_detect_emoji() { + assert!(!text_contains_cjk("a cat 🐱 running")); + } + + #[test] + fn does_not_detect_empty_string() { + assert!(!text_contains_cjk("")); + } +}