From 4b03767ec2bfb586e4534767721416b6325e76b7 Mon Sep 17 00:00:00 2001 From: Yujong Lee Date: Wed, 9 Sep 2026 17:26:54 -0700 Subject: [PATCH] refactor(ocr): separate formats backends and integrations --- litellm-rust/CLAUDE.md | 8 +- litellm-rust/crates/core/CLAUDE.md | 9 + litellm-rust/crates/core/src/http_utils.rs | 79 ++++++ .../crates/core/src/ocr/backends/azure_ai.rs | 233 +++++------------- .../azure_document_intelligence/polling.rs | 14 +- .../crates/core/src/ocr/backends/mistral.rs | 76 ++---- .../crates/core/src/ocr/backends/mod.rs | 91 +------ .../crates/core/src/ocr/backends/reducto.rs | 142 +++++------ .../crates/core/src/ocr/backends/vertex_ai.rs | 179 +++----------- litellm-rust/crates/core/src/ocr/document.rs | 41 +++ .../core/src/ocr/formats/reducto/types.rs | 15 ++ litellm-rust/crates/core/src/ocr/handler.rs | 36 ++- litellm-rust/crates/core/src/ocr/hooks.rs | 2 +- .../azure_document_intelligence.rs | 92 +++++++ .../src/ocr/integrations/azure_mistral.rs | 48 ++++ .../src/ocr/integrations/mistral_direct.rs | 31 +++ .../crates/core/src/ocr/integrations/mod.rs | 144 +++++++++++ .../src/ocr/integrations/reducto_legacy.rs | 37 +++ .../core/src/ocr/integrations/reducto_v3.rs | 37 +++ .../src/ocr/integrations/vertex_deepseek.rs | 57 +++++ .../src/ocr/integrations/vertex_mistral.rs | 63 +++++ litellm-rust/crates/core/src/ocr/mod.rs | 4 + litellm-rust/crates/core/src/ocr/prepare.rs | 2 +- litellm-rust/crates/core/src/ocr/registry.rs | 208 ++++++---------- .../crates/core/tests/azure_ai_ocr.rs | 6 +- .../tests/azure_document_intelligence_ocr.rs | 45 ++-- litellm-rust/crates/core/tests/mistral_ocr.rs | 50 ++-- litellm-rust/crates/core/tests/ocr.rs | 161 +----------- litellm-rust/crates/core/tests/ocr/support.rs | 189 ++++++++++++++ litellm-rust/crates/core/tests/ocr_prepare.rs | 111 +++------ litellm-rust/crates/core/tests/reducto_ocr.rs | 70 +++++- .../core/tests/vertex_ai_deepseek_ocr.rs | 25 +- .../crates/core/tests/vertex_ai_ocr.rs | 6 +- 33 files changed, 1328 insertions(+), 983 deletions(-) create mode 100644 litellm-rust/crates/core/src/ocr/integrations/azure_document_intelligence.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/azure_mistral.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/mistral_direct.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/mod.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/reducto_legacy.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/reducto_v3.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/vertex_deepseek.rs create mode 100644 litellm-rust/crates/core/src/ocr/integrations/vertex_mistral.rs create mode 100644 litellm-rust/crates/core/tests/ocr/support.rs diff --git a/litellm-rust/CLAUDE.md b/litellm-rust/CLAUDE.md index 6a198d79829..41ab64731dd 100644 --- a/litellm-rust/CLAUDE.md +++ b/litellm-rust/CLAUDE.md @@ -46,9 +46,11 @@ Route-level Rust structure mirrors LiteLLM's Python responsibilities: provider-specific transform. For Anthropic Messages, this means `core/src/providers/anthropic/messages/transformation.rs`. - OCR separates API shape from hosting. `core/src/ocr/formats/` owns wire types - and transforms, `core/src/ocr/backends/` owns OCR transport behavior, and - `core/src/ocr/registry.rs` lists supported format/backend pairings. Shared - provider authentication remains in `core/src/providers//auth.rs`. + and transforms, `core/src/ocr/backends/` owns reusable hosting behavior, and + each file in `core/src/ocr/integrations/` owns one format/backend pairing, + while `core/src/ocr/registry.rs` resolves providers and models through the shared + integration declaration. Shared provider authentication remains in + `core/src/providers//auth.rs`. - Handlers live in `core`, never in a host. `ai-gateway` must not contain a route handler that talks to a provider; its axum route reads the HTTP request, picks a deployment, and calls the `core` entrypoint. `python-bridge` marshals diff --git a/litellm-rust/crates/core/CLAUDE.md b/litellm-rust/crates/core/CLAUDE.md index 5d36305ded5..9f923c31088 100644 --- a/litellm-rust/crates/core/CLAUDE.md +++ b/litellm-rust/crates/core/CLAUDE.md @@ -56,6 +56,15 @@ handler.rs the provider call client.rs the shared reqwest client ``` +OCR keeps each concern independently changeable: + +``` +ocr/formats// typed wire shape and transforms +ocr/backends/.rs shared auth, upload, polling, and hosting behavior +ocr/integrations/.rs one typed format/backend pairing +ocr/registry.rs provider/model resolution and generated dispatch +``` + ## Parity Rules - Every shared type used by a provider transform needs unit tests for diff --git a/litellm-rust/crates/core/src/http_utils.rs b/litellm-rust/crates/core/src/http_utils.rs index 1a40bf914bc..bd8b89e7b1b 100644 --- a/litellm-rust/crates/core/src/http_utils.rs +++ b/litellm-rust/crates/core/src/http_utils.rs @@ -5,6 +5,33 @@ use serde_json::{Map, Value}; use crate::constants::UPSTREAM_ERROR_BODY_MAX_CHARS; use crate::error::{Error, json_type_name}; +pub(crate) enum HeaderPolicy<'a> { + All, + Only(&'a [&'a str]), + Except(&'a [&'a str]), +} + +pub(crate) fn with_headers( + builder: reqwest::RequestBuilder, + headers: &[(String, String)], + policy: HeaderPolicy<'_>, +) -> reqwest::RequestBuilder { + headers + .iter() + .filter(|(name, _)| match policy { + HeaderPolicy::All => true, + HeaderPolicy::Only(names) => names + .iter() + .any(|allowed| name.eq_ignore_ascii_case(allowed)), + HeaderPolicy::Except(names) => !names + .iter() + .any(|excluded| name.eq_ignore_ascii_case(excluded)), + }) + .fold(builder, |builder, (name, value)| { + builder.header(name, value) + }) +} + #[tracing::instrument(target = "litellm::function_trace", level = "trace", skip_all)] pub async fn http_request( request: reqwest::RequestBuilder, @@ -76,6 +103,58 @@ mod tests { use super::*; use serde_json::json; + #[rstest::rstest] + #[case(HeaderPolicy::All, true, true)] + #[case(HeaderPolicy::Only(&["authorization"]), true, false)] + #[case(HeaderPolicy::Except(&["authorization"]), false, true)] + fn forwarding_policy_preserves_matching_headers_and_duplicates( + #[case] policy: HeaderPolicy<'_>, + #[case] auth: bool, + #[case] trace: bool, + ) { + let request = with_headers( + reqwest::Client::new().get("https://example.com"), + &[ + ("AuThOrIzAtIoN".into(), "Bearer token".into()), + ("X-Trace".into(), "first".into()), + ("x-trace".into(), "second".into()), + ], + policy, + ) + .build() + .unwrap(); + assert_eq!(request.headers().contains_key("authorization"), auth); + let traces: Vec<_> = request.headers().get_all("x-trace").iter().collect(); + if trace { + assert_eq!(traces, ["first", "second"]); + } else { + assert!(traces.is_empty()); + } + } + + #[test] + fn multipart_policy_leaves_content_headers_to_reqwest() { + let request = with_headers( + reqwest::Client::new() + .post("https://example.com") + .multipart(reqwest::multipart::Form::new().text("file", "abc")), + &[ + ("Content-Type".into(), "application/json".into()), + ("CONTENT-LENGTH".into(), "0".into()), + ], + HeaderPolicy::Except(&["content-type", "content-length"]), + ) + .build() + .unwrap(); + assert!( + request.headers()["content-type"] + .to_str() + .unwrap() + .starts_with("multipart/form-data; boundary=") + ); + assert_ne!(request.headers()["content-length"], "0"); + } + #[test] fn truncate_leaves_short_bodies_untouched() { assert_eq!(truncate_error_body("short"), "short"); diff --git a/litellm-rust/crates/core/src/ocr/backends/azure_ai.rs b/litellm-rust/crates/core/src/ocr/backends/azure_ai.rs index 20a2002ef86..24139352253 100644 --- a/litellm-rust/crates/core/src/ocr/backends/azure_ai.rs +++ b/litellm-rust/crates/core/src/ocr/backends/azure_ai.rs @@ -1,176 +1,11 @@ +use serde_json::{Map, Value}; + +use crate::Error; use crate::auth::azure::AzureAuthInputs; -use crate::constants::{AZURE_AI_OCR_PATH, AZURE_DI_API_VERSION}; -use crate::ocr::backends::{BackendConfig, OcrBackend, OcrIntegration, PreparedOcrBackend}; -use crate::ocr::error::{OcrError, OcrRequestError}; -use crate::ocr::formats::document_intelligence::{ - AzureDocumentIntelligenceOcrFormat, - types::{AzureDocumentIntelligenceOperation, DocumentIntelligenceParams}, -}; -use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; -use crate::ocr::types::{OcrConnection, OcrDocument, OcrRequestFormat}; -use crate::ocr::wire::DecodedOcrResponse; +use crate::ocr::backends::OcrBackend; +use crate::ocr::error::OcrError; +use crate::ocr::types::OcrConnection; use crate::providers::azure_ai::auth; -use crate::url_utils::ApiUrl; - -fn model_id(model: &str) -> Result<&str, OcrRequestError> { - let model = model.rsplit('/').next().unwrap_or(model); - if matches!(model, "." | "..") { - return Err(OcrRequestError::DotModel); - } - Ok(model) -} - -#[derive(Clone, Debug)] -pub struct AzureMistral; - -impl OcrIntegration for AzureMistral { - type Backend = AzureBackend; - type Format = MistralOcrFormat; - type PreparedDocument = crate::ocr::document::InlineOcrDocument; - const FORMAT: Self::Format = MistralOcrFormat; - - #[tracing::instrument(target = "litellm::function_trace", level = "trace", skip_all)] - async fn prepare( - &self, - connection: &OcrConnection, - config: &BackendConfig, - _model: &str, - _params: &MistralOcrParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let base = auth::resolve_api_base(connection.api_base.as_deref(), env_lookup)?; - let headers = auth::authenticate( - connection.extra_headers.clone(), - connection.api_key.as_deref(), - Some(config), - env_lookup, - ) - .await?; - let path: Vec<&str> = AZURE_AI_OCR_PATH.trim_matches('/').split('/').collect(); - Ok(PreparedOcrBackend { - url: ApiUrl::parse(&base) - .and_then(|url| url.complete_path(&path)) - .map(|url| url.into_string()) - .map_err(|_| OcrRequestError::RequestField { - path: "api_base".into(), - })?, - headers, - }) - } - - fn validate_request_body( - &self, - body: &crate::ocr::formats::mistral::types::MistralOcrRequest, - ) -> Result<(), crate::ocr::error::OcrRequestError> { - crate::ocr::document::InlineOcrDocument::try_from(body.document.clone())?; - Ok(()) - } - - async fn prepare_document( - &self, - client: &crate::ocr::OcrClient, - document: OcrDocument, - connection: &OcrConnection, - _headers: &[(String, String)], - ) -> Result { - crate::ocr::document::inline_remote_document( - client.document_fetcher(), - document, - connection, - ) - .await - } -} - -#[derive(Clone, Debug)] -pub struct AzureDocumentIntelligence; - -impl OcrIntegration for AzureDocumentIntelligence { - type Backend = AzureBackend; - type Format = AzureDocumentIntelligenceOcrFormat; - type PreparedDocument = OcrDocument; - const FORMAT: Self::Format = AzureDocumentIntelligenceOcrFormat; - - async fn prepare( - &self, - connection: &OcrConnection, - config: &BackendConfig, - model: &str, - params: &DocumentIntelligenceParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let endpoint = auth::resolve_document_intelligence_endpoint( - connection.api_base.as_deref(), - env_lookup, - )?; - let model = format!("{}:analyze", model_id(model)?); - let url = ApiUrl::parse(&endpoint) - .and_then(|url| url.complete_path(&["documentintelligence", "documentModels", &model])) - .map(|url| { - url.append_query_pairs( - [("api-version", AZURE_DI_API_VERSION)] - .into_iter() - .chain(params.pages.iter().map(|pages| ("pages", pages.0.as_str()))) - .chain( - params - .features - .iter() - .map(|features| ("features", features.0.as_str())), - ), - ) - .into_string() - }) - .map_err(|_| OcrRequestError::RequestField { - path: "api_base".into(), - })?; - let headers = auth::authenticate_document_intelligence( - connection.extra_headers.clone(), - connection.api_key.as_deref(), - Some(config), - env_lookup, - ) - .await?; - Ok(PreparedOcrBackend { url, headers }) - } - - async fn prepare_document( - &self, - _client: &crate::ocr::OcrClient, - document: OcrDocument, - _connection: &OcrConnection, - _headers: &[(String, String)], - ) -> Result { - Ok(document) - } - - fn preserve_native_response(&self, params: &DocumentIntelligenceParams) -> bool { - params.request_format == OcrRequestFormat::Native - } - - fn supports_native_request_format(&self) -> bool { - true - } - - async fn read_response( - &self, - client: &crate::ocr::OcrClient, - response: reqwest::Response, - url: &str, - headers: &[(String, String)], - connection: &OcrConnection, - params: &DocumentIntelligenceParams, - ) -> Result, OcrError> { - super::azure_document_intelligence::polling::read_operation_response( - client.provider_http(), - response, - url, - headers, - connection, - params.request_format == OcrRequestFormat::Native, - ) - .await - } -} #[derive(Clone, Debug)] pub struct AzureBackend; @@ -178,4 +13,60 @@ pub struct AzureBackend; impl OcrBackend for AzureBackend { type Config = AzureAuthInputs; const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::AzureAi; + + fn decode_config(params: &Map) -> Result { + Ok(AzureAuthInputs::from_optional_params(params)?) + } +} + +pub(crate) fn resolve_integration( + model: &crate::ocr::registry::OcrModel, +) -> crate::ocr::registry::OcrIntegrationKind { + let model = model.as_str().to_ascii_lowercase(); + if model.contains("doc-intelligence") || model.contains("documentintelligence") { + crate::ocr::registry::OcrIntegrationKind::AzureDocumentIntelligence + } else { + crate::ocr::registry::OcrIntegrationKind::AzureMistral + } +} + +pub(crate) async fn authenticate_mistral( + connection: &OcrConnection, + config: &AzureAuthInputs, + env_lookup: &(dyn Fn(&str) -> Option + Sync), +) -> Result, OcrError> { + Ok(auth::authenticate( + connection.extra_headers.clone(), + connection.api_key.as_deref(), + Some(config), + env_lookup, + ) + .await?) +} + +pub(crate) async fn prepare_document_intelligence_auth( + connection: &OcrConnection, + config: &AzureAuthInputs, + env_lookup: &(dyn Fn(&str) -> Option + Sync), +) -> Result<(String, Vec<(String, String)>), OcrError> { + let endpoint = + auth::resolve_document_intelligence_endpoint(connection.api_base.as_deref(), env_lookup)?; + let headers = auth::authenticate_document_intelligence( + connection.extra_headers.clone(), + connection.api_key.as_deref(), + Some(config), + env_lookup, + ) + .await?; + Ok((endpoint, headers)) +} + +pub(crate) fn resolve_mistral_api_base( + connection: &OcrConnection, + env_lookup: &(dyn Fn(&str) -> Option + Sync), +) -> Result { + Ok(auth::resolve_api_base( + connection.api_base.as_deref(), + env_lookup, + )?) } diff --git a/litellm-rust/crates/core/src/ocr/backends/azure_document_intelligence/polling.rs b/litellm-rust/crates/core/src/ocr/backends/azure_document_intelligence/polling.rs index a10699e52ab..530499f4c5b 100644 --- a/litellm-rust/crates/core/src/ocr/backends/azure_document_intelligence/polling.rs +++ b/litellm-rust/crates/core/src/ocr/backends/azure_document_intelligence/polling.rs @@ -56,16 +56,14 @@ async fn poll_document_intelligence( .checked_duration_since(Instant::now()) .filter(|remaining| !remaining.is_zero()) .ok_or(OcrPollingError::PollTimeout)?; - let mut builder = http_client + let builder = http_client .get(url.clone()) .timeout(remaining.min(connection.timeout)); - for (name, value) in headers { - if name.eq_ignore_ascii_case(AZURE_DI_SUBSCRIPTION_HEADER) - || name.eq_ignore_ascii_case("authorization") - { - builder = builder.header(name, value); - } - } + let builder = crate::http_utils::with_headers( + builder, + headers, + crate::http_utils::HeaderPolicy::Only(&[AZURE_DI_SUBSCRIPTION_HEADER, "authorization"]), + ); let response = tokio::time::timeout_at(deadline, crate::http_utils::http_request(builder)) .await .map_err(|_| OcrPollingError::PollTimeout)? diff --git a/litellm-rust/crates/core/src/ocr/backends/mistral.rs b/litellm-rust/crates/core/src/ocr/backends/mistral.rs index c7648877135..8a627dc27ff 100644 --- a/litellm-rust/crates/core/src/ocr/backends/mistral.rs +++ b/litellm-rust/crates/core/src/ocr/backends/mistral.rs @@ -1,12 +1,26 @@ +use serde_json::{Map, Value}; + +use crate::Error; use crate::constants::MISTRAL_OCR_API_BASE; -use crate::ocr::backends::{BackendConfig, OcrBackend, OcrIntegration, PreparedOcrBackend}; +use crate::ocr::backends::OcrBackend; use crate::ocr::error::{OcrError, OcrRequestError}; -use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; -use crate::ocr::types::{OcrConnection, OcrDocument}; +use crate::ocr::types::OcrConnection; use crate::providers::mistral::auth; use crate::url_utils::ApiUrl; -pub fn complete_url(api_base: Option<&str>) -> Result { +#[derive(Clone, Debug)] +pub struct MistralBackend; + +impl OcrBackend for MistralBackend { + type Config = (); + const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::Mistral; + + fn decode_config(_params: &Map) -> Result { + Ok(()) + } +} + +pub(crate) fn complete_url(api_base: Option<&str>) -> Result { let base = api_base .map(str::trim) .filter(|base| !base.is_empty()) @@ -22,49 +36,13 @@ pub fn complete_url(api_base: Option<&str>) -> Result { }) } -#[derive(Clone, Debug)] -pub struct MistralDirect; - -impl OcrIntegration for MistralDirect { - type Backend = MistralBackend; - type Format = MistralOcrFormat; - type PreparedDocument = OcrDocument; - const FORMAT: Self::Format = MistralOcrFormat; - - async fn prepare( - &self, - connection: &OcrConnection, - _config: &BackendConfig, - _model: &str, - _params: &MistralOcrParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let headers = auth::validate_environment( - connection.extra_headers.clone(), - connection.api_key.as_deref(), - env_lookup, - )?; - Ok(PreparedOcrBackend { - url: complete_url(connection.api_base.as_deref())?, - headers, - }) - } - - async fn prepare_document( - &self, - _client: &crate::ocr::OcrClient, - document: OcrDocument, - _connection: &OcrConnection, - _headers: &[(String, String)], - ) -> Result { - Ok(document) - } -} - -#[derive(Clone, Debug)] -pub struct MistralBackend; - -impl OcrBackend for MistralBackend { - type Config = (); - const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::Mistral; +pub(crate) fn authenticate( + connection: &OcrConnection, + env_lookup: &(dyn Fn(&str) -> Option + Sync), +) -> Result, OcrError> { + Ok(auth::validate_environment( + connection.extra_headers.clone(), + connection.api_key.as_deref(), + env_lookup, + )?) } diff --git a/litellm-rust/crates/core/src/ocr/backends/mod.rs b/litellm-rust/crates/core/src/ocr/backends/mod.rs index f52202e1f8b..595176f4903 100644 --- a/litellm-rust/crates/core/src/ocr/backends/mod.rs +++ b/litellm-rust/crates/core/src/ocr/backends/mod.rs @@ -1,98 +1,21 @@ -use std::future::Future; - -use super::OcrClient; -use super::error::OcrError; -use super::formats::OcrFormat; -use super::types::{OcrConnection, OcrDocument}; -use super::wire::DecodedOcrResponse; - pub(crate) mod azure_ai; -mod azure_document_intelligence; +pub(crate) mod azure_document_intelligence; pub(crate) mod mistral; pub(crate) mod reducto; pub(crate) mod vertex_ai; +use serde_json::{Map, Value}; + +use crate::Error; + pub struct PreparedOcrBackend { pub url: String, pub headers: Vec<(String, String)>, } -pub trait OcrIntegration: Send + Sync + Sized + 'static { - type Backend: OcrBackend; - type Format: OcrFormat; - type PreparedDocument: Into<::PreparedDocument> + Send; - const FORMAT: Self::Format; - - fn supports_native_request_format(&self) -> bool { - false - } - - fn guard_document_before_preparation(&self) -> bool { - false - } - - fn decode_input_params( - &self, - params: serde_json::Map, - prefix: &str, - ) -> Result, super::error::OcrRequestError> { - super::registry::validate_request_format( - ¶ms, - self.supports_native_request_format(), - Self::Backend::PROVIDER.as_str(), - )?; - Self::Format::validate_input_params(¶ms)?; - super::wire::decode_request_value(serde_json::Value::Object(params), prefix) - } - - fn prepare( - &self, - connection: &OcrConnection, - config: &BackendConfig, - model: &str, - params: &MappedParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> impl Future> + Send; - - fn prepare_document( - &self, - client: &OcrClient, - document: OcrDocument, - connection: &OcrConnection, - headers: &[(String, String)], - ) -> impl Future> + Send; - - fn validate_request_body( - &self, - _body: &::RequestBody, - ) -> Result<(), super::error::OcrRequestError> { - Ok(()) - } - - fn preserve_native_response(&self, _params: &MappedParams) -> bool { - false - } - - fn read_response( - &self, - _client: &OcrClient, - response: reqwest::Response, - _url: &str, - _headers: &[(String, String)], - _connection: &OcrConnection, - params: &MappedParams, - ) -> impl Future< - Output = Result::ResponseBody>, OcrError>, - > + Send { - super::client::read_json_response(response, self.preserve_native_response(params)) - } -} - pub trait OcrBackend: Send + Sync + 'static { type Config: Clone + std::fmt::Debug + Send + Sync + 'static; const PROVIDER: super::registry::OcrProvider; -} -pub type InputParams = <::Format as OcrFormat>::InputParams; -pub type MappedParams = <::Format as OcrFormat>::MappedParams; -pub type BackendConfig = <::Backend as OcrBackend>::Config; + fn decode_config(params: &Map) -> Result; +} diff --git a/litellm-rust/crates/core/src/ocr/backends/reducto.rs b/litellm-rust/crates/core/src/ocr/backends/reducto.rs index 53a85cc4556..5cc2121ec27 100644 --- a/litellm-rust/crates/core/src/ocr/backends/reducto.rs +++ b/litellm-rust/crates/core/src/ocr/backends/reducto.rs @@ -1,14 +1,13 @@ +use crate::Error; use crate::constants::{REDUCTO_ID_PREFIX, REDUCTO_OCR_API_BASE}; -use crate::ocr::backends::{BackendConfig, OcrBackend, OcrIntegration, PreparedOcrBackend}; -use crate::ocr::document::InlineDocument; -use crate::ocr::error::{OcrError, OcrRequestError, OcrResponseError}; -use crate::ocr::formats::reducto::{ - ReductoParseLegacyFormat, ReductoParseV3Format, - types::{ReductoFileId, ReductoLegacyParams, ReductoUploadResponse, ReductoV3Params}, -}; +use crate::ocr::backends::OcrBackend; +use crate::ocr::document::{DocumentPreparation, InlineDocument}; +use crate::ocr::error::{OcrError, OcrRequestError}; +use crate::ocr::formats::reducto::types::{ReductoFileId, ReductoUploadResponse}; use crate::ocr::types::{OcrConnection, OcrDocument}; use crate::providers::reducto::auth; use crate::url_utils::ApiUrl; +use serde_json::{Map, Value}; #[derive(Clone, Debug)] pub struct ReductoBackend; @@ -16,9 +15,24 @@ pub struct ReductoBackend; impl OcrBackend for ReductoBackend { type Config = (); const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::Reducto; + + fn decode_config(_params: &Map) -> Result { + Ok(()) + } } -pub fn complete_url(api_base: Option<&str>, path: &str) -> Result { +pub(crate) fn resolve_integration( + model: &crate::ocr::registry::OcrModel, +) -> crate::ocr::registry::OcrIntegrationKind { + match model { + crate::ocr::registry::OcrModel::ReductoLegacy => { + crate::ocr::registry::OcrIntegrationKind::ReductoLegacy + } + _ => crate::ocr::registry::OcrIntegrationKind::ReductoV3, + } +} + +pub(crate) fn complete_url(api_base: Option<&str>, path: &str) -> Result { let base = api_base .map(str::trim) .filter(|base| !base.is_empty()) @@ -34,100 +48,64 @@ pub fn complete_url(api_base: Option<&str>, path: &str) -> Result Result { + let source = document.source(); + if source.starts_with(REDUCTO_ID_PREFIX) { + return Ok(ReductoFileId(source.to_string())); + } + let document = InlineDocument::parse(source)?.ok_or(OcrRequestError::ReductoSource)?; + upload_document(client, document, connection, headers).await + } +} + +async fn upload_document( client: &crate::ocr::OcrClient, - document: OcrDocument, + document: InlineDocument<'_>, connection: &OcrConnection, headers: &[(String, String)], ) -> Result { - let source = document.source(); - if source.starts_with(REDUCTO_ID_PREFIX) { - return Ok(ReductoFileId(source.to_string())); - } - let document = InlineDocument::parse(source)?.ok_or(OcrRequestError::ReductoSource)?; let mime = document.mime_type().to_string(); let bytes = document.decode(crate::constants::OCR_INLINE_MAX_BYTES)?; let part = reqwest::multipart::Part::bytes(bytes) .file_name("document") .mime_str(&mime) .map_err(|_| OcrRequestError::InvalidDataUri)?; - let mut builder = client + let builder = client .provider_http() .post(complete_url(connection.api_base.as_deref(), "upload")?) .multipart(reqwest::multipart::Form::new().part("file", part)) .timeout(connection.timeout); - for (name, value) in headers { - if !name.eq_ignore_ascii_case("content-type") - && !name.eq_ignore_ascii_case("content-length") - { - builder = builder.header(name, value); - } - } + let builder = crate::http_utils::with_headers( + builder, + headers, + crate::http_utils::HeaderPolicy::Except(&["content-type", "content-length"]), + ); let response = crate::http_utils::http_request(builder) .await .map_err(crate::error::TransportError::from)?; let response = crate::ocr::client::read_json_response::(response, false) .await? .data; - if response.file_id.is_empty() { - return Err(OcrResponseError::ResponseField { - path: "file_id".into(), - } - .into()); - } - Ok(ReductoFileId(response.file_id)) + response.try_into() } -macro_rules! impl_reducto_backend { - ($integration:ident, $format:ident, $params:ty) => { - #[derive(Clone, Debug)] - pub struct $integration; - - impl OcrIntegration for $integration { - type Backend = ReductoBackend; - type Format = $format; - type PreparedDocument = ReductoFileId; - const FORMAT: Self::Format = $format; - - async fn prepare( - &self, - connection: &OcrConnection, - _config: &BackendConfig, - _model: &str, - _params: &$params, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let headers = auth::validate_environment( - connection.extra_headers.clone(), - connection.api_key.as_deref(), - env_lookup, - )?; - Ok(PreparedOcrBackend { - url: complete_url(connection.api_base.as_deref(), "parse")?, - headers, - }) - } - - async fn prepare_document( - &self, - client: &crate::ocr::OcrClient, - document: OcrDocument, - connection: &OcrConnection, - headers: &[(String, String)], - ) -> Result { - prepare_reducto_document(client, document, connection, headers).await - } - - fn guard_document_before_preparation(&self) -> bool { - true - } - - fn preserve_native_response(&self, _params: &$params) -> bool { - true - } - } - }; +pub(crate) fn authenticate( + connection: &OcrConnection, + env_lookup: &(dyn Fn(&str) -> Option + Sync), +) -> Result, OcrError> { + Ok(auth::validate_environment( + connection.extra_headers.clone(), + connection.api_key.as_deref(), + env_lookup, + )?) } - -impl_reducto_backend!(ReductoV3, ReductoParseV3Format, ReductoV3Params); -impl_reducto_backend!(ReductoLegacy, ReductoParseLegacyFormat, ReductoLegacyParams); diff --git a/litellm-rust/crates/core/src/ocr/backends/vertex_ai.rs b/litellm-rust/crates/core/src/ocr/backends/vertex_ai.rs index c33ffa85b63..bb722fc1f8b 100644 --- a/litellm-rust/crates/core/src/ocr/backends/vertex_ai.rs +++ b/litellm-rust/crates/core/src/ocr/backends/vertex_ai.rs @@ -1,13 +1,35 @@ -use crate::constants::{VERTEX_DEEPSEEK_API_BASE, VERTEX_OCR_DEFAULT_LOCATION}; -use crate::ocr::backends::{BackendConfig, OcrBackend, OcrIntegration, PreparedOcrBackend}; -use crate::ocr::error::OcrError; -use crate::ocr::formats::deepseek::{DeepSeekOcrFormat, types::DeepSeekOcrParams}; -use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; -use crate::ocr::types::{OcrConnection, OcrDocument}; -use crate::providers::vertex_ai::auth::{self, VertexAuthInputs}; -use crate::url_utils::ApiUrl; +use serde_json::{Map, Value}; -async fn authenticate( +use crate::Error; +use crate::constants::VERTEX_OCR_DEFAULT_LOCATION; +use crate::ocr::backends::OcrBackend; +use crate::ocr::error::OcrError; +use crate::ocr::types::OcrConnection; +use crate::providers::vertex_ai::auth::{self, VertexAuthInputs}; + +#[derive(Clone, Debug)] +pub struct VertexBackend; + +impl OcrBackend for VertexBackend { + type Config = VertexAuthInputs; + const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::VertexAi; + + fn decode_config(params: &Map) -> Result { + Ok(VertexAuthInputs::from_optional_params(params)?) + } +} + +pub(crate) fn resolve_integration( + model: &crate::ocr::registry::OcrModel, +) -> crate::ocr::registry::OcrIntegrationKind { + if model.as_str().to_ascii_lowercase().contains("deepseek") { + crate::ocr::registry::OcrIntegrationKind::VertexDeepSeek + } else { + crate::ocr::registry::OcrIntegrationKind::VertexMistral + } +} + +pub(crate) async fn authenticate( connection: &OcrConnection, config: &VertexAuthInputs, env_lookup: &(dyn Fn(&str) -> Option + Sync), @@ -22,141 +44,10 @@ async fn authenticate( .await?) } -fn location(config: &VertexAuthInputs, env_lookup: &dyn Fn(&str) -> Option) -> String { +pub(crate) fn location( + config: &VertexAuthInputs, + env_lookup: &dyn Fn(&str) -> Option, +) -> String { auth::resolve_location(config, env_lookup) .unwrap_or_else(|| VERTEX_OCR_DEFAULT_LOCATION.to_string()) } - -#[derive(Clone, Debug)] -pub struct VertexMistral; - -impl OcrIntegration for VertexMistral { - type Backend = VertexBackend; - type Format = MistralOcrFormat; - type PreparedDocument = crate::ocr::document::InlineOcrDocument; - const FORMAT: Self::Format = MistralOcrFormat; - - #[tracing::instrument(target = "litellm::function_trace", level = "trace", skip_all)] - async fn prepare( - &self, - connection: &OcrConnection, - config: &BackendConfig, - model: &str, - _params: &MistralOcrParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let authentication = authenticate(connection, config, env_lookup).await?; - let location = location(config, env_lookup); - let default_base = format!("https://{location}-aiplatform.googleapis.com"); - let base = connection.api_base.as_deref().unwrap_or(&default_base); - let prediction = format!("{model}:rawPredict"); - let path = [ - "v1", - "projects", - authentication.project_id.as_str(), - "locations", - location.as_str(), - "publishers", - "mistralai", - "models", - prediction.as_str(), - ]; - Ok(PreparedOcrBackend { - url: ApiUrl::parse(base) - .and_then(|url| url.complete_path(&path)) - .map(|url| url.into_string()) - .map_err(|_| crate::ocr::error::OcrRequestError::RequestField { - path: "api_base".into(), - })?, - headers: authentication.headers, - }) - } - - fn validate_request_body( - &self, - body: &crate::ocr::formats::mistral::types::MistralOcrRequest, - ) -> Result<(), crate::ocr::error::OcrRequestError> { - crate::ocr::document::InlineOcrDocument::try_from(body.document.clone())?; - Ok(()) - } - - async fn prepare_document( - &self, - client: &crate::ocr::OcrClient, - document: OcrDocument, - connection: &OcrConnection, - _headers: &[(String, String)], - ) -> Result { - crate::ocr::document::inline_remote_document( - client.document_fetcher(), - document, - connection, - ) - .await - } -} - -#[derive(Clone, Debug)] -pub struct VertexDeepSeek; - -impl OcrIntegration for VertexDeepSeek { - type Backend = VertexBackend; - type Format = DeepSeekOcrFormat; - type PreparedDocument = OcrDocument; - const FORMAT: Self::Format = DeepSeekOcrFormat; - - async fn prepare( - &self, - connection: &OcrConnection, - config: &BackendConfig, - _model: &str, - _params: &DeepSeekOcrParams, - env_lookup: &(dyn Fn(&str) -> Option + Sync), - ) -> Result { - let authentication = authenticate(connection, config, env_lookup).await?; - let location = location(config, env_lookup); - let base = connection - .api_base - .as_deref() - .unwrap_or(VERTEX_DEEPSEEK_API_BASE); - Ok(PreparedOcrBackend { - url: ApiUrl::parse(base) - .and_then(|url| { - url.complete_path(&[ - "v1", - "projects", - authentication.project_id.as_str(), - "locations", - location.as_str(), - "endpoints", - "openapi", - "chat", - "completions", - ]) - }) - .map(|url| url.into_string()) - .map_err(|_| crate::ocr::error::OcrRequestError::RequestField { - path: "api_base".into(), - })?, - headers: authentication.headers, - }) - } - - async fn prepare_document( - &self, - _client: &crate::ocr::OcrClient, - document: OcrDocument, - _connection: &OcrConnection, - _headers: &[(String, String)], - ) -> Result { - Ok(document) - } -} - -#[derive(Clone, Debug)] -pub struct VertexBackend; - -impl OcrBackend for VertexBackend { - type Config = VertexAuthInputs; - const PROVIDER: crate::ocr::registry::OcrProvider = crate::ocr::registry::OcrProvider::VertexAi; -} diff --git a/litellm-rust/crates/core/src/ocr/document.rs b/litellm-rust/crates/core/src/ocr/document.rs index b865eb96671..51367ab5172 100644 --- a/litellm-rust/crates/core/src/ocr/document.rs +++ b/litellm-rust/crates/core/src/ocr/document.rs @@ -8,6 +8,47 @@ use crate::constants::OCR_MAX_FETCH_REDIRECTS; use crate::error::{MediaError, TransportError}; use crate::media::{DownloadPolicy, MediaFetcher}; +pub trait DocumentPreparation: Send + Sync + 'static { + type Output: Send; + + fn prepare( + client: &super::OcrClient, + document: OcrDocument, + connection: &OcrConnection, + headers: &[(String, String)], + ) -> impl std::future::Future> + Send; +} + +pub struct PassThrough; + +impl DocumentPreparation for PassThrough { + type Output = OcrDocument; + + async fn prepare( + _client: &super::OcrClient, + document: OcrDocument, + _connection: &OcrConnection, + _headers: &[(String, String)], + ) -> Result { + Ok(document) + } +} + +pub struct RequireInline; + +impl DocumentPreparation for RequireInline { + type Output = InlineOcrDocument; + + async fn prepare( + client: &super::OcrClient, + document: OcrDocument, + connection: &OcrConnection, + _headers: &[(String, String)], + ) -> Result { + inline_remote_document(client.document_fetcher(), document, connection).await + } +} + pub(crate) struct InlineDocument<'a>(DataUrl<'a>); impl<'a> InlineDocument<'a> { diff --git a/litellm-rust/crates/core/src/ocr/formats/reducto/types.rs b/litellm-rust/crates/core/src/ocr/formats/reducto/types.rs index 26eb0a25e8b..62370991d34 100644 --- a/litellm-rust/crates/core/src/ocr/formats/reducto/types.rs +++ b/litellm-rust/crates/core/src/ocr/formats/reducto/types.rs @@ -28,6 +28,21 @@ pub struct ReductoLegacyRequest { pub options: Option, } pub struct ReductoFileId(pub(crate) String); + +impl TryFrom for ReductoFileId { + type Error = crate::ocr::error::OcrError; + + fn try_from(response: ReductoUploadResponse) -> Result { + if response.file_id.is_empty() { + return Err(crate::ocr::error::OcrResponseError::ResponseField { + path: "file_id".into(), + } + .into()); + } + Ok(Self(response.file_id)) + } +} + #[derive(Deserialize)] pub struct ReductoUploadResponse { pub file_id: String, diff --git a/litellm-rust/crates/core/src/ocr/handler.rs b/litellm-rust/crates/core/src/ocr/handler.rs index 22992ac33c1..353c5df61e0 100644 --- a/litellm-rust/crates/core/src/ocr/handler.rs +++ b/litellm-rust/crates/core/src/ocr/handler.rs @@ -1,14 +1,11 @@ use std::sync::Arc; use super::OcrClient; -use super::backends::{MappedParams, OcrIntegration}; use super::formats::{OcrFormat, request_error}; use super::hooks::{OcrDuringCallRequest, OcrHooks, OcrLifecycleHooks}; +use super::integrations::{GuardrailStage, MappedParams, OcrIntegration}; use super::prepare::{MappedOcrRequest, prepare_ocr_call}; -use super::registry::{ - AZURE_DOCUMENT_INTELLIGENCE, AZURE_MISTRAL, MISTRAL, OcrIntegrationInput, - OcrIntegrationRequest, REDUCTO_LEGACY, REDUCTO_V3, VERTEX_DEEPSEEK, VERTEX_MISTRAL, -}; +use super::registry::{OcrIntegrationInput, OcrIntegrationRequest}; use super::types::{OcrConnection, OcrDocument, OcrRequest, OcrResponseData}; use crate::Error; use crate::call_lifecycle::{CallLifecycle, CallLifecycleContext}; @@ -42,17 +39,15 @@ pub(crate) async fn perform_ocr_request( lifecycle_context: context, hooks: request.hooks, }; - match request.integration { - OcrIntegrationRequest::Mistral(input) => execution.run(MISTRAL, input).await, - OcrIntegrationRequest::AzureMistral(input) => execution.run(AZURE_MISTRAL, input).await, - OcrIntegrationRequest::AzureDocumentIntelligence(input) => { - execution.run(AZURE_DOCUMENT_INTELLIGENCE, input).await - } - OcrIntegrationRequest::VertexMistral(input) => execution.run(VERTEX_MISTRAL, input).await, - OcrIntegrationRequest::VertexDeepSeek(input) => execution.run(VERTEX_DEEPSEEK, input).await, - OcrIntegrationRequest::ReductoV3(input) => execution.run(REDUCTO_V3, input).await, - OcrIntegrationRequest::ReductoLegacy(input) => execution.run(REDUCTO_LEGACY, input).await, + macro_rules! execute_selected_integration { + ($( $variant:ident, $integration:ty, $instance:expr, $provider:ident; )+) => { + match request.integration { + $( OcrIntegrationRequest::$variant(input) => execution.run($instance, input).await, )+ + } + }; } + + super::integrations::for_each_ocr_integration!(execute_selected_integration) } impl OcrExecution<'_> { @@ -121,7 +116,7 @@ where .await?; let url = prepared_backend.url; let headers = prepared_backend.headers; - let document = if backend.guard_document_before_preparation() && hooks.has_guardrails() { + let document = if I::GUARDRAIL_STAGE == GuardrailStage::Document && hooks.has_guardrails() { let guarded = hooks .during_call(OcrDuringCallRequest { model: request.model.clone(), @@ -139,7 +134,7 @@ where .prepare_document(client, document, &request.connection, &headers) .await?; let body = format.transform_request(&request.model, document.into(), &request.params)?; - let body = if !backend.guard_document_before_preparation() && hooks.has_guardrails() { + let body = if I::GUARDRAIL_STAGE == GuardrailStage::RequestBody && hooks.has_guardrails() { let guarded = hooks .during_call(OcrDuringCallRequest { model: request.model.clone(), @@ -221,14 +216,13 @@ async fn send_ocr_call( } = request; let backend = &integration; let format = I::FORMAT; - let mut builder = client + let builder = client .provider_http() .post(&url) .json(&body) .timeout(connection.timeout); - for (name, value) in &headers { - builder = builder.header(name, value); - } + let builder = + crate::http_utils::with_headers(builder, &headers, crate::http_utils::HeaderPolicy::All); let response = crate::http_utils::http_request(builder) .await .map_err(crate::error::TransportError::from)?; diff --git a/litellm-rust/crates/core/src/ocr/hooks.rs b/litellm-rust/crates/core/src/ocr/hooks.rs index 6ceacca7d79..f9be77d0913 100644 --- a/litellm-rust/crates/core/src/ocr/hooks.rs +++ b/litellm-rust/crates/core/src/ocr/hooks.rs @@ -2,8 +2,8 @@ use std::future::Future; use std::pin::Pin; use std::sync::Arc; -use super::backends::OcrIntegration; use super::formats::OcrFormat; +use super::integrations::OcrIntegration; use super::prepare::MappedOcrRequest; use super::types::{OcrDocument, OcrResponseData}; use crate::Error; diff --git a/litellm-rust/crates/core/src/ocr/integrations/azure_document_intelligence.rs b/litellm-rust/crates/core/src/ocr/integrations/azure_document_intelligence.rs new file mode 100644 index 00000000000..67951361e1b --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/azure_document_intelligence.rs @@ -0,0 +1,92 @@ +use crate::constants::AZURE_DI_API_VERSION; +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::azure_ai::{self, AzureBackend}; +use crate::ocr::error::{OcrError, OcrRequestError}; +use crate::ocr::formats::document_intelligence::{ + AzureDocumentIntelligenceOcrFormat, + types::{AzureDocumentIntelligenceOperation, DocumentIntelligenceParams}, +}; +use crate::ocr::types::{OcrConnection, OcrRequestFormat}; +use crate::ocr::wire::DecodedOcrResponse; +use crate::url_utils::ApiUrl; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct AzureDocumentIntelligence; + +impl OcrIntegration for AzureDocumentIntelligence { + type Backend = AzureBackend; + type Format = AzureDocumentIntelligenceOcrFormat; + type DocumentPreparation = super::PassThrough; + const FORMAT: Self::Format = AzureDocumentIntelligenceOcrFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + config: &BackendConfig, + model: &str, + params: &DocumentIntelligenceParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + let (endpoint, headers) = + azure_ai::prepare_document_intelligence_auth(connection, config, env_lookup).await?; + let model = format!("{}:analyze", model_id(model)?); + let url = ApiUrl::parse(&endpoint) + .and_then(|url| url.complete_path(&["documentintelligence", "documentModels", &model])) + .map(|url| { + url.append_query_pairs( + [("api-version", AZURE_DI_API_VERSION)] + .into_iter() + .chain(params.pages.iter().map(|pages| ("pages", pages.0.as_str()))) + .chain( + params + .features + .iter() + .map(|features| ("features", features.0.as_str())), + ), + ) + .into_string() + }) + .map_err(|_| OcrRequestError::RequestField { + path: "api_base".into(), + })?; + Ok(PreparedOcrBackend { url, headers }) + } + + fn preserve_native_response(&self, params: &DocumentIntelligenceParams) -> bool { + params.request_format == OcrRequestFormat::Native + } + + fn supports_native_request_format(&self) -> bool { + true + } + + async fn read_response( + &self, + client: &crate::ocr::OcrClient, + response: reqwest::Response, + url: &str, + headers: &[(String, String)], + connection: &OcrConnection, + params: &DocumentIntelligenceParams, + ) -> Result, OcrError> { + crate::ocr::backends::azure_document_intelligence::polling::read_operation_response( + client.provider_http(), + response, + url, + headers, + connection, + params.request_format == OcrRequestFormat::Native, + ) + .await + } +} + +fn model_id(model: &str) -> Result<&str, OcrRequestError> { + let model = model.rsplit('/').next().unwrap_or(model); + if matches!(model, "." | "..") { + return Err(OcrRequestError::DotModel); + } + Ok(model) +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/azure_mistral.rs b/litellm-rust/crates/core/src/ocr/integrations/azure_mistral.rs new file mode 100644 index 00000000000..20cc399bea1 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/azure_mistral.rs @@ -0,0 +1,48 @@ +use crate::constants::AZURE_AI_OCR_PATH; +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::azure_ai::{self, AzureBackend}; +use crate::ocr::document::InlineOcrDocument; +use crate::ocr::error::{OcrError, OcrRequestError}; +use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; +use crate::ocr::types::OcrConnection; +use crate::url_utils::ApiUrl; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct AzureMistral; + +impl OcrIntegration for AzureMistral { + type Backend = AzureBackend; + type Format = MistralOcrFormat; + type DocumentPreparation = super::RequireInline; + const FORMAT: Self::Format = MistralOcrFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + config: &BackendConfig, + _model: &str, + _params: &MistralOcrParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + let base = azure_ai::resolve_mistral_api_base(connection, env_lookup)?; + let path: Vec<&str> = AZURE_AI_OCR_PATH.trim_matches('/').split('/').collect(); + let url = ApiUrl::parse(&base) + .and_then(|url| url.complete_path(&path)) + .map(|url| url.into_string()) + .map_err(|_| OcrRequestError::RequestField { + path: "api_base".into(), + })?; + let headers = azure_ai::authenticate_mistral(connection, config, env_lookup).await?; + Ok(PreparedOcrBackend { url, headers }) + } + + fn validate_request_body( + &self, + body: &crate::ocr::formats::mistral::types::MistralOcrRequest, + ) -> Result<(), OcrRequestError> { + InlineOcrDocument::try_from(body.document.clone())?; + Ok(()) + } +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/mistral_direct.rs b/litellm-rust/crates/core/src/ocr/integrations/mistral_direct.rs new file mode 100644 index 00000000000..e0c1492c38a --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/mistral_direct.rs @@ -0,0 +1,31 @@ +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::mistral::{self, MistralBackend}; +use crate::ocr::error::OcrError; +use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; +use crate::ocr::types::OcrConnection; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct MistralDirect; + +impl OcrIntegration for MistralDirect { + type Backend = MistralBackend; + type Format = MistralOcrFormat; + type DocumentPreparation = super::PassThrough; + const FORMAT: Self::Format = MistralOcrFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + _config: &BackendConfig, + _model: &str, + _params: &MistralOcrParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + Ok(PreparedOcrBackend { + url: mistral::complete_url(connection.api_base.as_deref())?, + headers: mistral::authenticate(connection, env_lookup)?, + }) + } +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/mod.rs b/litellm-rust/crates/core/src/ocr/integrations/mod.rs new file mode 100644 index 00000000000..5c8511300a6 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/mod.rs @@ -0,0 +1,144 @@ +use std::future::Future; + +use serde_json::{Map, Value}; + +use super::OcrClient; +use super::backends::{OcrBackend, PreparedOcrBackend}; +use super::error::{OcrError, OcrRequestError}; +use super::formats::OcrFormat; +use super::types::{OcrConnection, OcrDocument, OcrRequestFormat}; +use super::wire::DecodedOcrResponse; + +mod azure_document_intelligence; +mod azure_mistral; +mod mistral_direct; +mod reducto_legacy; +mod reducto_v3; +mod vertex_deepseek; +mod vertex_mistral; + +pub use super::backends::reducto::ReductoUpload; +pub use super::document::{DocumentPreparation, PassThrough, RequireInline}; +pub use azure_document_intelligence::AzureDocumentIntelligence; +pub use azure_mistral::AzureMistral; +pub use mistral_direct::MistralDirect; +pub use reducto_legacy::ReductoLegacy; +pub use reducto_v3::ReductoV3; +pub use vertex_deepseek::VertexDeepSeek; +pub use vertex_mistral::VertexMistral; + +#[derive(Clone, Copy, PartialEq, Eq)] +pub enum GuardrailStage { + Document, + RequestBody, +} + +pub trait OcrIntegration: Send + Sync + Sized + 'static { + type Backend: OcrBackend; + type Format: OcrFormat; + type DocumentPreparation: DocumentPreparation< + Output: Into<::PreparedDocument>, + >; + const FORMAT: Self::Format; + const GUARDRAIL_STAGE: GuardrailStage = GuardrailStage::RequestBody; + + fn supports_native_request_format(&self) -> bool { + false + } + + fn decode_input_params( + &self, + params: Map, + prefix: &str, + ) -> Result, OcrRequestError> { + validate_request_format( + ¶ms, + self.supports_native_request_format(), + Self::Backend::PROVIDER.as_str(), + )?; + Self::Format::validate_input_params(¶ms)?; + super::wire::decode_request_value(Value::Object(params), prefix) + } + + fn prepare( + &self, + connection: &OcrConnection, + config: &BackendConfig, + model: &str, + params: &MappedParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> impl Future> + Send; + + fn prepare_document( + &self, + client: &OcrClient, + document: OcrDocument, + connection: &OcrConnection, + headers: &[(String, String)], + ) -> impl Future< + Output = Result<::Output, OcrError>, + > + Send { + Self::DocumentPreparation::prepare(client, document, connection, headers) + } + + fn validate_request_body( + &self, + _body: &::RequestBody, + ) -> Result<(), OcrRequestError> { + Ok(()) + } + + fn preserve_native_response(&self, _params: &MappedParams) -> bool { + false + } + + fn read_response( + &self, + _client: &OcrClient, + response: reqwest::Response, + _url: &str, + _headers: &[(String, String)], + _connection: &OcrConnection, + params: &MappedParams, + ) -> impl Future< + Output = Result::ResponseBody>, OcrError>, + > + Send { + super::client::read_json_response(response, self.preserve_native_response(params)) + } +} + +fn validate_request_format( + params: &Map, + supports_native: bool, + provider: &'static str, +) -> Result<(), OcrRequestError> { + let Some(format) = params.get("req_format") else { + return Ok(()); + }; + let format: OcrRequestFormat = + serde_json::from_value(format.clone()).map_err(|_| OcrRequestError::RequestFormat)?; + if format == OcrRequestFormat::Native && !supports_native { + return Err(OcrRequestError::NativeUnsupported(provider)); + } + Ok(()) +} + +pub type InputParams = <::Format as OcrFormat>::InputParams; +pub type MappedParams = <::Format as OcrFormat>::MappedParams; +pub type BackendConfig = <::Backend as OcrBackend>::Config; + +macro_rules! for_each_ocr_integration { + ($callback:ident) => { + $callback! { + Mistral, $crate::ocr::integrations::MistralDirect, $crate::ocr::integrations::MistralDirect, Mistral; + AzureMistral, $crate::ocr::integrations::AzureMistral, $crate::ocr::integrations::AzureMistral, AzureAi; + AzureDocumentIntelligence, $crate::ocr::integrations::AzureDocumentIntelligence, $crate::ocr::integrations::AzureDocumentIntelligence, AzureAi; + VertexMistral, $crate::ocr::integrations::VertexMistral, $crate::ocr::integrations::VertexMistral, VertexAi; + VertexDeepSeek, $crate::ocr::integrations::VertexDeepSeek, $crate::ocr::integrations::VertexDeepSeek, VertexAi; + ReductoV3, $crate::ocr::integrations::ReductoV3, $crate::ocr::integrations::ReductoV3, Reducto; + ReductoLegacy, $crate::ocr::integrations::ReductoLegacy, $crate::ocr::integrations::ReductoLegacy, Reducto; + } + }; +} + +pub(crate) use for_each_ocr_integration; diff --git a/litellm-rust/crates/core/src/ocr/integrations/reducto_legacy.rs b/litellm-rust/crates/core/src/ocr/integrations/reducto_legacy.rs new file mode 100644 index 00000000000..0080b88c502 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/reducto_legacy.rs @@ -0,0 +1,37 @@ +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::reducto::{self, ReductoBackend}; +use crate::ocr::error::OcrError; +use crate::ocr::formats::reducto::{ReductoParseLegacyFormat, types::ReductoLegacyParams}; +use crate::ocr::types::OcrConnection; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct ReductoLegacy; + +impl OcrIntegration for ReductoLegacy { + type Backend = ReductoBackend; + type Format = ReductoParseLegacyFormat; + type DocumentPreparation = super::ReductoUpload; + const FORMAT: Self::Format = ReductoParseLegacyFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + _config: &BackendConfig, + _model: &str, + _params: &ReductoLegacyParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + Ok(PreparedOcrBackend { + url: reducto::complete_url(connection.api_base.as_deref(), "parse")?, + headers: reducto::authenticate(connection, env_lookup)?, + }) + } + + const GUARDRAIL_STAGE: super::GuardrailStage = super::GuardrailStage::Document; + + fn preserve_native_response(&self, _params: &ReductoLegacyParams) -> bool { + true + } +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/reducto_v3.rs b/litellm-rust/crates/core/src/ocr/integrations/reducto_v3.rs new file mode 100644 index 00000000000..e1a09ef1fb3 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/reducto_v3.rs @@ -0,0 +1,37 @@ +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::reducto::{self, ReductoBackend}; +use crate::ocr::error::OcrError; +use crate::ocr::formats::reducto::{ReductoParseV3Format, types::ReductoV3Params}; +use crate::ocr::types::OcrConnection; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct ReductoV3; + +impl OcrIntegration for ReductoV3 { + type Backend = ReductoBackend; + type Format = ReductoParseV3Format; + type DocumentPreparation = super::ReductoUpload; + const FORMAT: Self::Format = ReductoParseV3Format; + + async fn prepare( + &self, + connection: &OcrConnection, + _config: &BackendConfig, + _model: &str, + _params: &ReductoV3Params, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + Ok(PreparedOcrBackend { + url: reducto::complete_url(connection.api_base.as_deref(), "parse")?, + headers: reducto::authenticate(connection, env_lookup)?, + }) + } + + const GUARDRAIL_STAGE: super::GuardrailStage = super::GuardrailStage::Document; + + fn preserve_native_response(&self, _params: &ReductoV3Params) -> bool { + true + } +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/vertex_deepseek.rs b/litellm-rust/crates/core/src/ocr/integrations/vertex_deepseek.rs new file mode 100644 index 00000000000..24f1a5ffd27 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/vertex_deepseek.rs @@ -0,0 +1,57 @@ +use crate::constants::VERTEX_DEEPSEEK_API_BASE; +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::vertex_ai::{self, VertexBackend}; +use crate::ocr::error::{OcrError, OcrRequestError}; +use crate::ocr::formats::deepseek::{DeepSeekOcrFormat, types::DeepSeekOcrParams}; +use crate::ocr::types::OcrConnection; +use crate::url_utils::ApiUrl; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct VertexDeepSeek; + +impl OcrIntegration for VertexDeepSeek { + type Backend = VertexBackend; + type Format = DeepSeekOcrFormat; + type DocumentPreparation = super::PassThrough; + const FORMAT: Self::Format = DeepSeekOcrFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + config: &BackendConfig, + _model: &str, + _params: &DeepSeekOcrParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + let authentication = vertex_ai::authenticate(connection, config, env_lookup).await?; + let location = vertex_ai::location(config, env_lookup); + let base = connection + .api_base + .as_deref() + .unwrap_or(VERTEX_DEEPSEEK_API_BASE); + let url = ApiUrl::parse(base) + .and_then(|url| { + url.complete_path(&[ + "v1", + "projects", + authentication.project_id.as_str(), + "locations", + location.as_str(), + "endpoints", + "openapi", + "chat", + "completions", + ]) + }) + .map(|url| url.into_string()) + .map_err(|_| OcrRequestError::RequestField { + path: "api_base".into(), + })?; + Ok(PreparedOcrBackend { + url, + headers: authentication.headers, + }) + } +} diff --git a/litellm-rust/crates/core/src/ocr/integrations/vertex_mistral.rs b/litellm-rust/crates/core/src/ocr/integrations/vertex_mistral.rs new file mode 100644 index 00000000000..bfdd5d58342 --- /dev/null +++ b/litellm-rust/crates/core/src/ocr/integrations/vertex_mistral.rs @@ -0,0 +1,63 @@ +use crate::ocr::backends::PreparedOcrBackend; +use crate::ocr::backends::vertex_ai::{self, VertexBackend}; +use crate::ocr::document::InlineOcrDocument; +use crate::ocr::error::{OcrError, OcrRequestError}; +use crate::ocr::formats::mistral::{MistralOcrFormat, types::MistralOcrParams}; +use crate::ocr::types::OcrConnection; +use crate::url_utils::ApiUrl; + +use super::{BackendConfig, OcrIntegration}; + +#[derive(Clone, Debug)] +pub struct VertexMistral; + +impl OcrIntegration for VertexMistral { + type Backend = VertexBackend; + type Format = MistralOcrFormat; + type DocumentPreparation = super::RequireInline; + const FORMAT: Self::Format = MistralOcrFormat; + + async fn prepare( + &self, + connection: &OcrConnection, + config: &BackendConfig, + model: &str, + _params: &MistralOcrParams, + env_lookup: &(dyn Fn(&str) -> Option + Sync), + ) -> Result { + let authentication = vertex_ai::authenticate(connection, config, env_lookup).await?; + let location = vertex_ai::location(config, env_lookup); + let default_base = format!("https://{location}-aiplatform.googleapis.com"); + let base = connection.api_base.as_deref().unwrap_or(&default_base); + let prediction = format!("{model}:rawPredict"); + let path = [ + "v1", + "projects", + authentication.project_id.as_str(), + "locations", + location.as_str(), + "publishers", + "mistralai", + "models", + prediction.as_str(), + ]; + let url = ApiUrl::parse(base) + .and_then(|url| url.complete_path(&path)) + .map(|url| url.into_string()) + .map_err(|_| OcrRequestError::RequestField { + path: "api_base".into(), + })?; + Ok(PreparedOcrBackend { + url, + headers: authentication.headers, + }) + } + + fn validate_request_body( + &self, + body: &crate::ocr::formats::mistral::types::MistralOcrRequest, + ) -> Result<(), OcrRequestError> { + InlineOcrDocument::try_from(body.document.clone())?; + Ok(()) + } +} diff --git a/litellm-rust/crates/core/src/ocr/mod.rs b/litellm-rust/crates/core/src/ocr/mod.rs index 8af14415437..0c82444b1b7 100644 --- a/litellm-rust/crates/core/src/ocr/mod.rs +++ b/litellm-rust/crates/core/src/ocr/mod.rs @@ -5,6 +5,7 @@ pub mod error; pub mod formats; mod handler; pub mod hooks; +pub mod integrations; pub mod prepare; pub mod registry; pub mod types; @@ -26,6 +27,9 @@ mod mistral_tests; #[path = "../../tests/reducto_ocr.rs"] mod reducto_tests; #[cfg(test)] +#[path = "../../tests/ocr/support.rs"] +pub(crate) mod test_support; +#[cfg(test)] #[path = "../../tests/ocr.rs"] pub(crate) mod tests; #[cfg(test)] diff --git a/litellm-rust/crates/core/src/ocr/prepare.rs b/litellm-rust/crates/core/src/ocr/prepare.rs index 2fc885f61d9..16fc1f36136 100644 --- a/litellm-rust/crates/core/src/ocr/prepare.rs +++ b/litellm-rust/crates/core/src/ocr/prepare.rs @@ -1,5 +1,5 @@ -use super::backends::{BackendConfig, InputParams, MappedParams, OcrIntegration}; use super::formats::OcrFormat; +use super::integrations::{BackendConfig, InputParams, MappedParams, OcrIntegration}; use super::types::{OcrConnection, OcrDocument}; use crate::Error; diff --git a/litellm-rust/crates/core/src/ocr/registry.rs b/litellm-rust/crates/core/src/ocr/registry.rs index 4c226588c10..3c68357f2a2 100644 --- a/litellm-rust/crates/core/src/ocr/registry.rs +++ b/litellm-rust/crates/core/src/ocr/registry.rs @@ -2,41 +2,14 @@ use serde_json::{Map, Value}; use strum::EnumString; use crate::Error; -use crate::auth::azure::AzureAuthInputs; -use crate::providers::vertex_ai::auth::VertexAuthInputs; use crate::routing_utils::provider::{CustomLlmProvider, get_custom_llm_provider}; -pub use super::backends::azure_ai::{AzureDocumentIntelligence, AzureMistral}; -pub use super::backends::mistral::MistralDirect; -pub use super::backends::reducto::{ReductoLegacy, ReductoV3}; -pub use super::backends::vertex_ai::{VertexDeepSeek, VertexMistral}; -use super::backends::{BackendConfig, InputParams}; -pub use super::backends::{OcrBackend, OcrIntegration}; -use super::types::OcrRequestFormat; - -pub(crate) fn validate_request_format( - params: &Map, - supports_native: bool, - provider: &'static str, -) -> Result<(), super::error::OcrRequestError> { - let Some(format) = params.get("req_format") else { - return Ok(()); - }; - let format: OcrRequestFormat = serde_json::from_value(format.clone()) - .map_err(|_| super::error::OcrRequestError::RequestFormat)?; - if format == OcrRequestFormat::Native && !supports_native { - return Err(super::error::OcrRequestError::NativeUnsupported(provider)); - } - Ok(()) -} - -pub(crate) const MISTRAL: MistralDirect = MistralDirect; -pub(crate) const AZURE_MISTRAL: AzureMistral = AzureMistral; -pub(crate) const AZURE_DOCUMENT_INTELLIGENCE: AzureDocumentIntelligence = AzureDocumentIntelligence; -pub(crate) const VERTEX_MISTRAL: VertexMistral = VertexMistral; -pub(crate) const VERTEX_DEEPSEEK: VertexDeepSeek = VertexDeepSeek; -pub(crate) const REDUCTO_V3: ReductoV3 = ReductoV3; -pub(crate) const REDUCTO_LEGACY: ReductoLegacy = ReductoLegacy; +pub use super::backends::OcrBackend; +pub use super::integrations::{ + AzureDocumentIntelligence, AzureMistral, MistralDirect, ReductoLegacy, ReductoV3, + VertexDeepSeek, VertexMistral, +}; +use super::integrations::{BackendConfig, InputParams, OcrIntegration}; /// ``` /// use litellm_core::ocr::registry::{MistralDirect, OcrIntegrationInput}; @@ -70,27 +43,37 @@ pub struct OcrIntegrationInput { pub backend_config: BackendConfig, } -#[derive(Clone, Debug)] -pub enum OcrIntegrationRequest { - Mistral(OcrIntegrationInput), - AzureMistral(OcrIntegrationInput), - AzureDocumentIntelligence(OcrIntegrationInput), - VertexMistral(OcrIntegrationInput), - VertexDeepSeek(OcrIntegrationInput), - ReductoV3(OcrIntegrationInput), - ReductoLegacy(OcrIntegrationInput), +macro_rules! define_integration_types { + ($( $variant:ident, $integration:ty, $instance:expr, $provider:ident; )+) => { + #[derive(Clone, Debug)] + pub enum OcrIntegrationRequest { + $( $variant(OcrIntegrationInput<$integration>), )+ + } + + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + pub enum OcrIntegrationKind { + $( $variant, )+ + } + + impl OcrIntegrationKind { + pub const fn provider(self) -> OcrProvider { + match self { + $( Self::$variant => OcrProvider::$provider, )+ + } + } + } + + impl OcrIntegrationRequest { + pub fn kind(&self) -> OcrIntegrationKind { + match self { + $( Self::$variant(_) => OcrIntegrationKind::$variant, )+ + } + } + } + }; } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum OcrIntegrationKind { - Mistral, - AzureMistral, - AzureDocumentIntelligence, - VertexMistral, - VertexDeepSeek, - ReductoV3, - ReductoLegacy, -} +super::integrations::for_each_ocr_integration!(define_integration_types); #[derive(Clone, Copy, Debug, EnumString, PartialEq, Eq)] #[strum(serialize_all = "snake_case")] @@ -112,17 +95,6 @@ impl OcrProvider { } } -impl OcrIntegrationKind { - pub const fn provider(self) -> OcrProvider { - match self { - Self::Mistral => OcrProvider::Mistral, - Self::AzureMistral | Self::AzureDocumentIntelligence => OcrProvider::AzureAi, - Self::VertexMistral | Self::VertexDeepSeek => OcrProvider::VertexAi, - Self::ReductoV3 | Self::ReductoLegacy => OcrProvider::Reducto, - } - } -} - #[derive(Clone, Debug, EnumString, PartialEq, Eq)] pub enum OcrModel { #[strum(serialize = "parse-v3")] @@ -143,37 +115,13 @@ impl OcrModel { } } -impl OcrIntegrationRequest { - pub fn kind(&self) -> OcrIntegrationKind { - match self { - Self::Mistral(_) => OcrIntegrationKind::Mistral, - Self::AzureMistral(_) => OcrIntegrationKind::AzureMistral, - Self::AzureDocumentIntelligence(_) => OcrIntegrationKind::AzureDocumentIntelligence, - Self::VertexMistral(_) => OcrIntegrationKind::VertexMistral, - Self::VertexDeepSeek(_) => OcrIntegrationKind::VertexDeepSeek, - Self::ReductoV3(_) => OcrIntegrationKind::ReductoV3, - Self::ReductoLegacy(_) => OcrIntegrationKind::ReductoLegacy, - } - } -} - #[tracing::instrument(target = "litellm::function_trace", level = "trace", skip_all)] pub fn resolve_ocr_integration(provider: OcrProvider, model: &OcrModel) -> OcrIntegrationKind { - let lower = model.as_str().to_ascii_lowercase(); - match (provider, model) { - (OcrProvider::Mistral, _) => OcrIntegrationKind::Mistral, - (OcrProvider::AzureAi, _) - if lower.contains("doc-intelligence") || lower.contains("documentintelligence") => - { - OcrIntegrationKind::AzureDocumentIntelligence - } - (OcrProvider::AzureAi, _) => OcrIntegrationKind::AzureMistral, - (OcrProvider::VertexAi, _) if lower.contains("deepseek") => { - OcrIntegrationKind::VertexDeepSeek - } - (OcrProvider::VertexAi, _) => OcrIntegrationKind::VertexMistral, - (OcrProvider::Reducto, OcrModel::ReductoLegacy) => OcrIntegrationKind::ReductoLegacy, - (OcrProvider::Reducto, _) => OcrIntegrationKind::ReductoV3, + match provider { + OcrProvider::Mistral => OcrIntegrationKind::Mistral, + OcrProvider::AzureAi => super::backends::azure_ai::resolve_integration(model), + OcrProvider::VertexAi => super::backends::vertex_ai::resolve_integration(model), + OcrProvider::Reducto => super::backends::reducto::resolve_integration(model), } } @@ -199,50 +147,34 @@ pub fn decode_integration_request( kind: OcrIntegrationKind, params: Map, ) -> Result { - let request = match kind { - OcrIntegrationKind::Mistral => OcrIntegrationRequest::Mistral(OcrIntegrationInput { - params: MISTRAL.decode_input_params(params, "optional_params")?, - backend_config: (), - }), - OcrIntegrationKind::AzureMistral => { - let backend = AzureAuthInputs::from_optional_params(¶ms)?; - OcrIntegrationRequest::AzureMistral(OcrIntegrationInput { - params: AZURE_MISTRAL.decode_input_params(params, "optional_params")?, - backend_config: backend, - }) - } - OcrIntegrationKind::AzureDocumentIntelligence => { - let backend = AzureAuthInputs::from_optional_params(¶ms)?; - OcrIntegrationRequest::AzureDocumentIntelligence(OcrIntegrationInput { - params: AZURE_DOCUMENT_INTELLIGENCE - .decode_input_params(params, "optional_params")?, - backend_config: backend, - }) - } - OcrIntegrationKind::VertexMistral => { - let backend = VertexAuthInputs::from_optional_params(¶ms)?; - OcrIntegrationRequest::VertexMistral(OcrIntegrationInput { - params: VERTEX_MISTRAL.decode_input_params(params, "optional_params")?, - backend_config: backend, - }) - } - OcrIntegrationKind::VertexDeepSeek => { - let backend = VertexAuthInputs::from_optional_params(¶ms)?; - OcrIntegrationRequest::VertexDeepSeek(OcrIntegrationInput { - params: VERTEX_DEEPSEEK.decode_input_params(params, "optional_params")?, - backend_config: backend, - }) - } - OcrIntegrationKind::ReductoV3 => OcrIntegrationRequest::ReductoV3(OcrIntegrationInput { - params: REDUCTO_V3.decode_input_params(params, "optional_params")?, - backend_config: (), - }), - OcrIntegrationKind::ReductoLegacy => { - OcrIntegrationRequest::ReductoLegacy(OcrIntegrationInput { - params: REDUCTO_LEGACY.decode_input_params(params, "optional_params")?, - backend_config: (), - }) - } - }; - Ok(request) + macro_rules! decode_selected_integration { + ($( $variant:ident, $integration:ty, $instance:expr, $provider:ident; )+) => { + match kind { + $( + OcrIntegrationKind::$variant => OcrIntegrationRequest::$variant( + decode_input::<$integration>($instance, params)?, + ), + )+ + } + }; + } + + Ok(super::integrations::for_each_ocr_integration!( + decode_selected_integration + )) +} + +fn decode_input( + integration: I, + params: Map, +) -> Result, Error> +where + I: OcrIntegration, +{ + let backend_config = I::Backend::decode_config(¶ms)?; + let params = integration.decode_input_params(params, "optional_params")?; + Ok(OcrIntegrationInput { + params, + backend_config, + }) } diff --git a/litellm-rust/crates/core/tests/azure_ai_ocr.rs b/litellm-rust/crates/core/tests/azure_ai_ocr.rs index 20755436056..ab6b02c41a2 100644 --- a/litellm-rust/crates/core/tests/azure_ai_ocr.rs +++ b/litellm-rust/crates/core/tests/azure_ai_ocr.rs @@ -1,6 +1,6 @@ -use crate::ocr::backends::OcrIntegration; -use crate::ocr::registry::{AZURE_MISTRAL, MISTRAL}; -use crate::ocr::tests::body; +use crate::ocr::integrations::OcrIntegration; +use crate::ocr::integrations::{AzureMistral as AZURE_MISTRAL, MistralDirect as MISTRAL}; +use crate::ocr::test_support::body; use crate::ocr::types::OcrConnection; use serde_json::json; diff --git a/litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs b/litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs index 30dbcfd2966..0d4db3c3207 100644 --- a/litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs +++ b/litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs @@ -1,11 +1,12 @@ -use crate::ocr::backends::OcrIntegration; use crate::ocr::formats::OcrFormat; +use crate::ocr::integrations::AzureDocumentIntelligence as AZURE_DOCUMENT_INTELLIGENCE; +use crate::ocr::integrations::OcrIntegration; use crate::ocr::prepare::OcrIntegrationKind; -use crate::ocr::registry::{AZURE_DOCUMENT_INTELLIGENCE, decode_integration_request}; -use crate::ocr::tests::perform_ocr; -use crate::ocr::tests::{MockResponse, body, mock_server, params, transform, wire_request}; +use crate::ocr::registry::decode_integration_request; +use crate::ocr::test_support::perform_ocr; +use crate::ocr::test_support::{MockResponse, body, mock_server, params, transform, wire_request}; use crate::ocr::types::OcrConnection; -use rstest::rstest; +use rstest::{fixture, rstest}; use serde_json::{Value, json}; fn connection() -> OcrConnection { @@ -15,6 +16,7 @@ fn connection() -> OcrConnection { ..Default::default() } } +#[fixture] fn operation() -> Value { json!({"status":"succeeded","operationExtension":42,"analyzeResult":{ "content":"A\n\nB","tables":[{"cells":[]}],"keyValuePairs":[{"key":{"content":"A"}}], @@ -164,12 +166,12 @@ async fn azure_document_intelligence_dot_segment_model_id_is_rejected() { assert!(prepared_url(model, &mapped).await.is_err()); } } -#[test] -fn document_intelligence_response_normalizes_pages() { +#[rstest] +fn document_intelligence_response_normalizes_pages(operation: Value) { let result = transform( &AZURE_DOCUMENT_INTELLIGENCE, "model", - operation(), + operation.clone(), json!({}), ) .unwrap(); @@ -179,7 +181,7 @@ fn document_intelligence_response_normalizes_pages() { json!({"width":816,"height":1056,"dpi":96}) ); assert_eq!(result["usage_info"]["pages_processed"], 1); - assert_eq!(result["tables"], operation()["analyzeResult"]["tables"]); + assert_eq!(result["tables"], operation["analyzeResult"]["tables"]); } #[test] fn document_intelligence_response_tolerates_missing_native_fields() { @@ -255,21 +257,21 @@ fn document_intelligence_non_succeeded_status_is_rejected() { ); } } -#[test] -fn document_intelligence_native_format_carries_raw_operation() { +#[rstest] +fn document_intelligence_native_format_carries_raw_operation(operation: Value) { let response = transform( &AZURE_DOCUMENT_INTELLIGENCE, "model", - operation(), + operation.clone(), json!({"req_format":"native"}), ) .unwrap(); - assert_eq!(response["provider_native_response"], operation()); + assert_eq!(response["provider_native_response"], operation); assert!( transform( &AZURE_DOCUMENT_INTELLIGENCE, "model", - operation(), + operation.clone(), json!({"req_format":"litellm"}) ) .unwrap() @@ -301,7 +303,10 @@ fn document_intelligence_rejects_unknown_req_format() { #[case(false)] #[case(true)] #[tokio::test] -async fn polling_forwards_subscription_or_bearer_and_preserves_native(#[case] bearer: bool) { +async fn polling_forwards_subscription_or_bearer_and_preserves_native( + operation: Value, + #[case] bearer: bool, +) { let (base, requests, server) = mock_server(vec![ MockResponse { status: 202, @@ -313,7 +318,7 @@ async fn polling_forwards_subscription_or_bearer_and_preserves_native(#[case] be headers: vec![("Retry-After", "0".into())], body: json!({"status":"running"}), }, - MockResponse::json(operation()), + MockResponse::json(operation.clone()), ]) .await; let mut request = wire_request( @@ -325,15 +330,21 @@ async fn polling_forwards_subscription_or_bearer_and_preserves_native(#[case] be request.connection.api_key = None; request.connection.extra_headers = vec![("Authorization".into(), "Bearer token".into())]; } + request + .connection + .extra_headers + .push(("X-Trace".into(), "initial-request-only".into())); let result = perform_ocr(request).await.unwrap(); server.await.unwrap(); assert_eq!( result.provider_native_response, - Some(operation().as_object().unwrap().clone()) + Some(operation.as_object().unwrap().clone()) ); let seen = requests.lock().unwrap(); assert!(seen[0].contains("&pages=1%2C3")); + assert!(seen[0].contains("x-trace: initial-request-only")); for poll in &seen[1..] { + assert!(!poll.to_ascii_lowercase().contains("x-trace:")); assert!(poll.to_ascii_lowercase().contains(if bearer { "authorization: bearer token" } else { diff --git a/litellm-rust/crates/core/tests/mistral_ocr.rs b/litellm-rust/crates/core/tests/mistral_ocr.rs index b62fbbd9587..62c928fb8ab 100644 --- a/litellm-rust/crates/core/tests/mistral_ocr.rs +++ b/litellm-rust/crates/core/tests/mistral_ocr.rs @@ -1,6 +1,7 @@ use crate::ocr::backends::mistral::complete_url; -use crate::ocr::registry::MISTRAL; -use crate::ocr::tests::{body, transform}; +use crate::ocr::formats::mistral::MistralOcrFormat; +use crate::ocr::test_support::{format_body, transform_format}; +use crate::ocr::types::OcrDocument; use rstest::rstest; use serde_json::json; @@ -10,12 +11,15 @@ use serde_json::json; #[case(json!({"pages":[0,2],"include_image_base64":true,"image_limit":2,"image_min_size":100}))] #[case(json!({"table_format":"html","confidence_scores_granularity":"word","include_blocks":true,"id":"req-123"}))] #[case(json!({"bbox_annotation_format":{"type":"json_schema","schema":{"type":"object"}},"document_annotation_format":{"type":"json_schema"},"document_annotation_prompt":"extract"}))] -#[tokio::test] -async fn transform_ocr_request_includes_each_optional_param(#[case] options: serde_json::Value) { +fn transform_ocr_request_includes_each_optional_param(#[case] options: serde_json::Value) { let document = json!({"type":"document_url","document_url":"https://example.com/a.pdf"}); - let result = body(&MISTRAL, "model", document.clone(), options.clone()) - .await - .unwrap(); + let result = format_body( + &MistralOcrFormat, + "model", + serde_json::from_value::(document.clone()).unwrap(), + options.clone(), + ) + .unwrap(); assert_eq!(result["model"], "model"); assert_eq!(result["document"], document); for (name, value) in options.as_object().unwrap() { @@ -23,15 +27,17 @@ async fn transform_ocr_request_includes_each_optional_param(#[case] options: ser } } -#[tokio::test] -async fn map_ocr_params_drops_unknown_params() { - let result = body( - &MISTRAL, +#[test] +fn map_ocr_params_drops_unknown_params() { + let result = format_body( + &MistralOcrFormat, "model", - json!({"type":"image_url","image_url":"data:image/png;base64,YWJj"}), + serde_json::from_value::( + json!({"type":"image_url","image_url":"data:image/png;base64,YWJj"}), + ) + .unwrap(), json!({"unknown":{},"extract_header":true}), ) - .await .unwrap(); assert!(result.get("unknown").is_none()); assert_eq!(result["extract_header"], true); @@ -40,7 +46,7 @@ async fn map_ocr_params_drops_unknown_params() { #[test] fn transform_ocr_response_preserves_ocr4_page_fields() { let page = json!({"index":0,"markdown":"hello","header":"head","footer":"foot","confidence_scores":{"mean":0.99},"blocks":[{"type":"text","content":"hello"}],"images":[{"id":"img-1","image_base64":"YWJj","top_left_x":12}],"dimensions":{"width":100,"height":200,"dpi":96}}); - let response = transform(&MISTRAL, "model", json!({"pages":[page.clone()],"model":"returned-model","usage_info":{"pages_processed":1,"future_counter":5}}), json!({})).unwrap(); + let response = transform_format(&MistralOcrFormat, "model", json!({"pages":[page.clone()],"model":"returned-model","usage_info":{"pages_processed":1,"future_counter":5}}), json!({}), false).unwrap(); for (name, value) in page.as_object().unwrap() { if name != "images" { assert_eq!(&response["pages"][0][name], value); @@ -53,18 +59,28 @@ fn transform_ocr_response_preserves_ocr4_page_fields() { #[test] fn transform_ocr_response_normalizes_mistral_json() { - let result = transform( - &MISTRAL, + let result = transform_format( + &MistralOcrFormat, "model", json!({"pages":[{"index":"0","markdown":"hello"}],"usage_info":{"pages_processed":"1"}}), json!({}), + false, ) .unwrap(); assert_eq!(result["pages"][0]["index"], 0); assert_eq!(result["usage_info"]["pages_processed"], 1); assert_eq!(result["pages"][0]["images"], serde_json::Value::Null); assert!(result.get("provider_native_response").is_none()); - assert!(transform(&MISTRAL, "model", json!({"pages":null}), json!({})).is_err()); + assert!( + transform_format( + &MistralOcrFormat, + "model", + json!({"pages":null}), + json!({}), + false + ) + .is_err() + ); } #[test] diff --git a/litellm-rust/crates/core/tests/ocr.rs b/litellm-rust/crates/core/tests/ocr.rs index b0e7920bfcb..62312c063d4 100644 --- a/litellm-rust/crates/core/tests/ocr.rs +++ b/litellm-rust/crates/core/tests/ocr.rs @@ -1,93 +1,10 @@ -use serde_json::{Value, json}; use std::sync::{Arc, Mutex}; -use tokio::io::{AsyncReadExt, AsyncWriteExt}; -use tokio::net::TcpListener; -use super::backends::{MappedParams, OcrIntegration}; -use super::formats::OcrFormat; +use serde_json::{Value, json}; -use super::types::OcrConnection; +use super::OcrClient; +use super::test_support::{MockResponse, mock_server, perform_ocr, wire_request}; use super::wire::{OcrWireRequest, decode_request, decode_response}; -use super::{OcrClient, OcrRequest}; -use crate::ocr::error::OcrError; - -pub(crate) fn ocr_client() -> OcrClient { - let document_http = reqwest::Client::builder() - .redirect(reqwest::redirect::Policy::none()) - .build() - .expect("test document client builds"); - OcrClient::for_test(reqwest::Client::new(), document_http) -} - -pub(crate) async fn perform_ocr( - request: OcrRequest, -) -> Result { - ocr_client().perform(request).await -} - -pub(crate) fn params(_integration: &I, value: Value) -> MappedParams -where - I: OcrIntegration, -{ - I::FORMAT - .map_params(serde_json::from_value(value).unwrap()) - .unwrap() -} -pub(crate) fn transform( - integration: &I, - model: &str, - value: Value, - options: Value, -) -> Result -where - I: OcrIntegration, -{ - let params = I::FORMAT.map_params(serde_json::from_value(options).unwrap())?; - let decoded = decode_response( - &serde_json::to_vec(&value).unwrap(), - integration.preserve_native_response(¶ms), - )?; - let mut response = I::FORMAT.transform_response(model, decoded.data, ¶ms)?; - response.provider_native_response = decoded.native; - Ok(response.into_json()) -} -pub(crate) async fn body( - integration: &I, - model: &str, - document: Value, - options: Value, -) -> Result -where - I: OcrIntegration, -{ - let params = I::FORMAT.map_params(serde_json::from_value(options).unwrap())?; - let client = ocr_client(); - let document = integration - .prepare_document( - &client, - serde_json::from_value(document).unwrap(), - &OcrConnection::default(), - &[], - ) - .await?; - Ok( - serde_json::to_value(I::FORMAT.transform_request(model, document.into(), ¶ms)?) - .unwrap(), - ) -} -pub(crate) fn wire_request(model: &str, base: &str, options: Value) -> OcrRequest { - decode_request(OcrWireRequest { - model: model.into(), - document: json!({"type":"document_url","document_url":"data:application/pdf;base64,YWJj"}), - api_key: Some("test-key".into()), - api_base: Some(base.into()), - custom_llm_provider: None, - extra_headers: None, - optional_params: options.as_object().unwrap().clone(), - timeout_seconds: Some(2.0), - }) - .unwrap() -} #[test] fn provider_options_are_decoded_only_for_the_selected_backend() { @@ -116,78 +33,6 @@ fn provider_options_are_decoded_only_for_the_selected_backend() { assert!(vertex.is_err()); } -pub(crate) struct MockResponse { - pub status: u16, - pub headers: Vec<(&'static str, String)>, - pub body: Value, -} -impl MockResponse { - pub fn json(body: Value) -> Self { - Self { - status: 200, - headers: vec![], - body, - } - } -} -pub(crate) async fn mock_server( - responses: Vec, -) -> (String, Arc>>, tokio::task::JoinHandle<()>) { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let base = format!("http://{}", listener.local_addr().unwrap()); - let requests = Arc::new(Mutex::new(Vec::new())); - let seen = requests.clone(); - let server_base = base.clone(); - let task = tokio::spawn(async move { - for response in responses { - let (mut socket, _) = listener.accept().await.unwrap(); - let mut bytes = Vec::new(); - let mut buffer = [0u8; 4096]; - let header_end = loop { - let n = socket.read(&mut buffer).await.unwrap(); - assert!(n > 0); - bytes.extend_from_slice(&buffer[..n]); - if let Some(index) = bytes.windows(4).position(|s| s == b"\r\n\r\n") { - break index + 4; - } - }; - let length = String::from_utf8_lossy(&bytes[..header_end]) - .lines() - .find_map(|line| { - let (name, value) = line.split_once(':')?; - name.eq_ignore_ascii_case("content-length") - .then(|| value.trim().parse::().unwrap()) - }) - .unwrap_or(0); - while bytes.len() < header_end + length { - let n = socket.read(&mut buffer).await.unwrap(); - assert!(n > 0); - bytes.extend_from_slice(&buffer[..n]); - } - seen.lock() - .unwrap() - .push(String::from_utf8_lossy(&bytes).into_owned()); - let body = serde_json::to_vec(&response.body).unwrap(); - let headers = response - .headers - .into_iter() - .map(|(name, value)| { - format!("{name}: {}\r\n", value.replace("{base}", &server_base)) - }) - .collect::(); - let head = format!( - "HTTP/1.1 {} OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n{}\r\n", - response.status, - body.len(), - headers - ); - socket.write_all(head.as_bytes()).await.unwrap(); - socket.write_all(&body).await.unwrap(); - } - }); - (base, requests, task) -} - #[rstest::rstest] #[case("mistral/model", "/v1/ocr")] #[case( diff --git a/litellm-rust/crates/core/tests/ocr/support.rs b/litellm-rust/crates/core/tests/ocr/support.rs new file mode 100644 index 00000000000..477ed84defa --- /dev/null +++ b/litellm-rust/crates/core/tests/ocr/support.rs @@ -0,0 +1,189 @@ +use std::sync::{Arc, Mutex}; + +use serde_json::{Value, json}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::net::TcpListener; + +use crate::ocr::error::OcrError; +use crate::ocr::formats::OcrFormat; +use crate::ocr::integrations::{MappedParams, OcrIntegration}; +use crate::ocr::types::OcrConnection; +use crate::ocr::wire::{OcrWireRequest, decode_request, decode_response}; +use crate::ocr::{OcrClient, OcrRequest, OcrResponseData}; + +pub(crate) fn ocr_client() -> OcrClient { + let document_http = reqwest::Client::builder() + .redirect(reqwest::redirect::Policy::none()) + .build() + .expect("test document client builds"); + OcrClient::for_test(reqwest::Client::new(), document_http) +} + +pub(crate) async fn perform_ocr(request: OcrRequest) -> Result { + ocr_client().perform(request).await +} + +pub(crate) fn params(_integration: &I, value: Value) -> MappedParams +where + I: OcrIntegration, +{ + I::FORMAT + .map_params(serde_json::from_value(value).unwrap()) + .unwrap() +} + +pub(crate) fn transform( + integration: &I, + model: &str, + value: Value, + options: Value, +) -> Result +where + I: OcrIntegration, +{ + let params = I::FORMAT.map_params(serde_json::from_value(options.clone()).unwrap())?; + let preserve_native_response = integration.preserve_native_response(¶ms); + transform_format(&I::FORMAT, model, value, options, preserve_native_response) +} + +pub(crate) fn transform_format( + format: &F, + model: &str, + value: Value, + options: Value, + preserve_native_response: bool, +) -> Result +where + F: OcrFormat, +{ + let params = format.map_params(serde_json::from_value(options).unwrap())?; + let decoded = decode_response( + &serde_json::to_vec(&value).unwrap(), + preserve_native_response, + )?; + let mut response = format.transform_response(model, decoded.data, ¶ms)?; + response.provider_native_response = decoded.native; + Ok(response.into_json()) +} + +pub(crate) async fn body( + integration: &I, + model: &str, + document: Value, + options: Value, +) -> Result +where + I: OcrIntegration, +{ + let client = ocr_client(); + let document = integration + .prepare_document( + &client, + serde_json::from_value(document).unwrap(), + &OcrConnection::default(), + &[], + ) + .await?; + format_body(&I::FORMAT, model, document.into(), options) +} + +pub(crate) fn format_body( + format: &F, + model: &str, + document: F::PreparedDocument, + options: Value, +) -> Result +where + F: OcrFormat, +{ + let params = format.map_params(serde_json::from_value(options).unwrap())?; + Ok(serde_json::to_value(format.transform_request(model, document, ¶ms)?).unwrap()) +} + +pub(crate) fn wire_request(model: &str, base: &str, options: Value) -> OcrRequest { + decode_request(OcrWireRequest { + model: model.into(), + document: json!({"type":"document_url","document_url":"data:application/pdf;base64,YWJj"}), + api_key: Some("test-key".into()), + api_base: Some(base.into()), + custom_llm_provider: None, + extra_headers: None, + optional_params: options.as_object().unwrap().clone(), + timeout_seconds: Some(2.0), + }) + .unwrap() +} + +pub(crate) struct MockResponse { + pub status: u16, + pub headers: Vec<(&'static str, String)>, + pub body: Value, +} + +impl MockResponse { + pub fn json(body: Value) -> Self { + Self { + status: 200, + headers: vec![], + body, + } + } +} + +pub(crate) async fn mock_server( + responses: Vec, +) -> (String, Arc>>, tokio::task::JoinHandle<()>) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let requests = Arc::new(Mutex::new(Vec::new())); + let seen = requests.clone(); + let server_base = base.clone(); + let task = tokio::spawn(async move { + for response in responses { + let (mut socket, _) = listener.accept().await.unwrap(); + let mut bytes = Vec::new(); + let mut buffer = [0u8; 4096]; + let header_end = loop { + let n = socket.read(&mut buffer).await.unwrap(); + assert!(n > 0); + bytes.extend_from_slice(&buffer[..n]); + if let Some(index) = bytes.windows(4).position(|s| s == b"\r\n\r\n") { + break index + 4; + } + }; + let length = String::from_utf8_lossy(&bytes[..header_end]) + .lines() + .find_map(|line| { + let (name, value) = line.split_once(':')?; + name.eq_ignore_ascii_case("content-length") + .then(|| value.trim().parse::().unwrap()) + }) + .unwrap_or(0); + while bytes.len() < header_end + length { + let n = socket.read(&mut buffer).await.unwrap(); + assert!(n > 0); + bytes.extend_from_slice(&buffer[..n]); + } + seen.lock() + .unwrap() + .push(String::from_utf8_lossy(&bytes).into_owned()); + let body = serde_json::to_vec(&response.body).unwrap(); + let headers = response + .headers + .into_iter() + .map(|(name, value)| { + format!("{name}: {}\r\n", value.replace("{base}", &server_base)) + }) + .collect::(); + let head = format!( + "HTTP/1.1 {} OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n{}\r\n", + response.status, + body.len(), + headers + ); + socket.write_all(head.as_bytes()).await.unwrap(); + socket.write_all(&body).await.unwrap(); + } + }); + (base, requests, task) +} diff --git a/litellm-rust/crates/core/tests/ocr_prepare.rs b/litellm-rust/crates/core/tests/ocr_prepare.rs index 9e93f9964e3..b952bef6529 100644 --- a/litellm-rust/crates/core/tests/ocr_prepare.rs +++ b/litellm-rust/crates/core/tests/ocr_prepare.rs @@ -1,77 +1,48 @@ use super::*; +use rstest::rstest; -#[test] -fn typed_provider_and_model_select_the_request_contract() { - let cases = [ - ("mistral", "future-model", OcrIntegrationKind::Mistral), - ( - "azure_ai", - "doc-intelligence/prebuilt-read", - OcrIntegrationKind::AzureDocumentIntelligence, - ), - ("azure_ai", "future-model", OcrIntegrationKind::AzureMistral), - ( - "vertex_ai", - "deepseek-ocr", - OcrIntegrationKind::VertexDeepSeek, - ), - ( - "vertex_ai", - "future-model", - OcrIntegrationKind::VertexMistral, - ), - ("reducto", "parse-legacy", OcrIntegrationKind::ReductoLegacy), - ("reducto", "parse-v3", OcrIntegrationKind::ReductoV3), - ("reducto", "future-model", OcrIntegrationKind::ReductoV3), - ]; - - for (provider, model, expected) in cases { - let provider = provider.parse().expect("known provider"); - let model = OcrModel::from(model); - assert_eq!(resolve_ocr_integration(provider, &model), expected); - } +#[rstest] +#[case::mistral_default("mistral", "future-model", OcrIntegrationKind::Mistral)] +#[case::azure_document_intelligence( + "azure_ai", + "doc-intelligence/prebuilt-read", + OcrIntegrationKind::AzureDocumentIntelligence +)] +#[case::azure_mistral("azure_ai", "future-model", OcrIntegrationKind::AzureMistral)] +#[case::vertex_deepseek("vertex_ai", "deepseek-ocr", OcrIntegrationKind::VertexDeepSeek)] +#[case::vertex_mistral("vertex_ai", "future-model", OcrIntegrationKind::VertexMistral)] +#[case::reducto_legacy("reducto", "parse-legacy", OcrIntegrationKind::ReductoLegacy)] +#[case::reducto_v3("reducto", "parse-v3", OcrIntegrationKind::ReductoV3)] +#[case::reducto_default("reducto", "future-model", OcrIntegrationKind::ReductoV3)] +fn typed_provider_and_model_select_the_request_contract( + #[case] provider: &str, + #[case] model: &str, + #[case] expected: OcrIntegrationKind, +) { + let provider = provider.parse().expect("known provider"); + let model = OcrModel::from(model); + assert_eq!(resolve_ocr_integration(provider, &model), expected); } -#[test] -fn integration_kind_exposes_its_routing_provider() { - let cases = [ - (OcrIntegrationKind::Mistral, OcrProvider::Mistral, "mistral"), - ( - OcrIntegrationKind::AzureMistral, - OcrProvider::AzureAi, - "azure_ai", - ), - ( - OcrIntegrationKind::AzureDocumentIntelligence, - OcrProvider::AzureAi, - "azure_ai", - ), - ( - OcrIntegrationKind::VertexMistral, - OcrProvider::VertexAi, - "vertex_ai", - ), - ( - OcrIntegrationKind::VertexDeepSeek, - OcrProvider::VertexAi, - "vertex_ai", - ), - ( - OcrIntegrationKind::ReductoV3, - OcrProvider::Reducto, - "reducto", - ), - ( - OcrIntegrationKind::ReductoLegacy, - OcrProvider::Reducto, - "reducto", - ), - ]; - - for (integration, expected_provider, expected_name) in cases { - assert_eq!(integration.provider(), expected_provider); - assert_eq!(integration.provider().as_str(), expected_name); - } +#[rstest] +#[case::mistral(OcrIntegrationKind::Mistral, OcrProvider::Mistral, "mistral")] +#[case::azure_mistral(OcrIntegrationKind::AzureMistral, OcrProvider::AzureAi, "azure_ai")] +#[case::azure_document_intelligence( + OcrIntegrationKind::AzureDocumentIntelligence, + OcrProvider::AzureAi, + "azure_ai" +)] +#[case::vertex_mistral(OcrIntegrationKind::VertexMistral, OcrProvider::VertexAi, "vertex_ai")] +#[case::vertex_deepseek(OcrIntegrationKind::VertexDeepSeek, OcrProvider::VertexAi, "vertex_ai")] +#[case::reducto_v3(OcrIntegrationKind::ReductoV3, OcrProvider::Reducto, "reducto")] +#[case::reducto_legacy(OcrIntegrationKind::ReductoLegacy, OcrProvider::Reducto, "reducto")] +fn integration_kind_exposes_its_routing_provider( + #[case] integration: OcrIntegrationKind, + #[case] expected_provider: OcrProvider, + #[case] expected_name: &str, +) { + assert_eq!(integration.provider(), expected_provider); + assert_eq!(integration.provider().as_str(), expected_name); } #[test] diff --git a/litellm-rust/crates/core/tests/reducto_ocr.rs b/litellm-rust/crates/core/tests/reducto_ocr.rs index 1c12aaf10dc..1456f97720f 100644 --- a/litellm-rust/crates/core/tests/reducto_ocr.rs +++ b/litellm-rust/crates/core/tests/reducto_ocr.rs @@ -1,5 +1,7 @@ -use crate::ocr::registry::{REDUCTO_LEGACY, REDUCTO_V3}; -use crate::ocr::tests::{MockResponse, body, mock_server, perform_ocr, transform, wire_request}; +use crate::ocr::integrations::{ReductoLegacy as REDUCTO_LEGACY, ReductoV3 as REDUCTO_V3}; +use crate::ocr::test_support::{ + MockResponse, body, mock_server, perform_ocr, transform, wire_request, +}; use rstest::rstest; use serde_json::json; @@ -103,14 +105,78 @@ async fn test_parse_v3_file_upload_and_response_mapping( .await; let mut request = wire_request(&format!("reducto/{model}"), &base, json!({})); request.document = request.document.with_source(source.to_string()); + request.connection.extra_headers = vec![ + ("Content-Type".into(), "application/json".into()), + ("X-Trace".into(), "upload-test".into()), + ]; let response = perform_ocr(request).await.unwrap(); server.await.unwrap(); assert_eq!(response.pages[0].markdown, "hello"); let seen = seen.lock().unwrap(); assert_eq!(seen.len(), 2); assert!(seen[0].starts_with("POST /upload ")); + assert!(seen[0].contains("content-type: multipart/form-data; boundary=")); + assert!(seen[0].contains("x-trace: upload-test")); assert!(seen[0].contains("application/pdf")); assert!(seen[0].contains("abc")); assert!(seen[1].starts_with("POST /parse ")); assert!(seen[1].contains("reducto://uploaded.pdf")); } + +#[rstest] +#[case("parse-v3")] +#[case("parse-legacy")] +#[tokio::test] +async fn upload_rejects_empty_file_id_before_parsing(#[case] model: &str) { + let (base, seen, server) = mock_server(vec![MockResponse::json(json!({"file_id":""}))]).await; + let error = perform_ocr(wire_request(&format!("reducto/{model}"), &base, json!({}))) + .await + .unwrap_err(); + server.await.unwrap(); + assert!( + matches!(error, crate::Error::OcrResponse(crate::ocr::error::OcrResponseError::ResponseField { path }) if path == "file_id") + ); + assert_eq!(seen.lock().unwrap().len(), 1); +} + +#[rstest] +#[case("parse-v3")] +#[case("parse-legacy")] +#[tokio::test] +async fn guardrail_rewrites_document_before_upload(#[case] model: &str) { + use crate::ocr::hooks::{OcrDuringCallRequest, OcrHookFuture, OcrHooks}; + + struct RewriteDocument; + impl OcrHooks for RewriteDocument { + fn has_guardrails(&self) -> bool { + true + } + + fn during_call( + &self, + request: OcrDuringCallRequest, + ) -> OcrHookFuture<'_, OcrDuringCallRequest> { + Box::pin(async move { + assert_eq!( + request.body["document_url"], + "data:application/pdf;base64,YWJj" + ); + Ok(OcrDuringCallRequest { + body: json!({"type":"document_url","document_url":"reducto://guarded.pdf"}), + ..request + }) + }) + } + } + + let (base, seen, server) = + mock_server(vec![MockResponse::json(json!({"result":{"chunks":[]}}))]).await; + let mut request = wire_request(&format!("reducto/{model}"), &base, json!({})); + request.hooks = std::sync::Arc::new(RewriteDocument); + perform_ocr(request).await.unwrap(); + server.await.unwrap(); + let seen = seen.lock().unwrap(); + assert_eq!(seen.len(), 1); + assert!(seen[0].starts_with("POST /parse ")); + assert!(seen[0].contains("reducto://guarded.pdf")); +} diff --git a/litellm-rust/crates/core/tests/vertex_ai_deepseek_ocr.rs b/litellm-rust/crates/core/tests/vertex_ai_deepseek_ocr.rs index 0dbaef026af..35838cdf8fe 100644 --- a/litellm-rust/crates/core/tests/vertex_ai_deepseek_ocr.rs +++ b/litellm-rust/crates/core/tests/vertex_ai_deepseek_ocr.rs @@ -1,20 +1,22 @@ -use crate::ocr::registry::VERTEX_DEEPSEEK; -use crate::ocr::tests::{body, transform}; +use crate::ocr::formats::deepseek::DeepSeekOcrFormat; +use crate::ocr::test_support::{format_body, transform_format}; +use crate::ocr::types::OcrDocument; use rstest::rstest; use serde_json::json; #[rstest] #[case("deepseek-ocr-maas")] #[case("deepseek-ai/deepseek-ocr-maas")] -#[tokio::test] -async fn vertex_deepseek_request_uses_single_provider_namespace(#[case] model: &str) { - let result = body( - &VERTEX_DEEPSEEK, +fn deepseek_request_uses_single_provider_namespace(#[case] model: &str) { + let result = format_body( + &DeepSeekOcrFormat, model, - json!({"type":"image_url","image_url":"gs://bucket/a.png"}), + serde_json::from_value::( + json!({"type":"image_url","image_url":"gs://bucket/a.png"}), + ) + .unwrap(), json!({"temperature":0.1,"max_tokens":1024,"ignored":true}), ) - .await .unwrap(); assert_eq!(result["model"], "deepseek-ai/deepseek-ocr-maas"); assert_eq!( @@ -33,11 +35,12 @@ fn vertex_deepseek_response_wraps_markdown_content( #[case] content: serde_json::Value, #[case] expected: &str, ) { - let result = transform( - &VERTEX_DEEPSEEK, + let result = transform_format( + &DeepSeekOcrFormat, "model", json!({"choices":[{"message":{"content":content}}],"usage":{"prompt_tokens":1}}), json!({}), + false, ) .unwrap(); assert_eq!(result["pages"][0]["markdown"], expected); @@ -51,6 +54,6 @@ fn deepseek_rejects_missing_content_and_invalid_structured_pages() { json!({"choices":[{"message":{"content":""}}]}), json!({"choices":[{"message":{"content":{"pages":[{"markdown":42}]}}}]}), ] { - assert!(transform(&VERTEX_DEEPSEEK, "model", response, json!({})).is_err()); + assert!(transform_format(&DeepSeekOcrFormat, "model", response, json!({}), false).is_err()); } } diff --git a/litellm-rust/crates/core/tests/vertex_ai_ocr.rs b/litellm-rust/crates/core/tests/vertex_ai_ocr.rs index 8dc4aafce85..e04fb388a91 100644 --- a/litellm-rust/crates/core/tests/vertex_ai_ocr.rs +++ b/litellm-rust/crates/core/tests/vertex_ai_ocr.rs @@ -1,6 +1,6 @@ -use crate::ocr::backends::OcrIntegration; -use crate::ocr::registry::{MISTRAL, VERTEX_MISTRAL}; -use crate::ocr::tests::body; +use crate::ocr::integrations::OcrIntegration; +use crate::ocr::integrations::{MistralDirect as MISTRAL, VertexMistral as VERTEX_MISTRAL}; +use crate::ocr::test_support::body; use crate::ocr::types::OcrConnection; use crate::providers::vertex_ai::auth::VertexAuthInputs; use serde_json::json;