merge: origin/main into litellm_jwt_token_exchange_grant

.github/workflows/test-unit-proxy-db.yml

@@ -94,7 +94,6 @@ jobs:
               tests/proxy_unit_tests/test_jwt_key_mapping.py
               tests/proxy_unit_tests/test_proxy_custom_auth.py
               tests/proxy_unit_tests/test_key_generate_dynamodb.py
-              tests/proxy_unit_tests/test_deployed_proxy_keygen.py
             workers: 4
             dist: loadscope
             timeout: 15
@@ -110,8 +109,6 @@ jobs:
           - test-group: proxy-server-core
             test-path: >-
               tests/proxy_unit_tests/test_proxy_server.py
-              tests/proxy_unit_tests/test_proxy_server_keys.py
-              tests/proxy_unit_tests/test_proxy_server_spend.py
               tests/proxy_unit_tests/test_aproxy_startup.py
             workers: 4
             dist: loadscope
@@ -120,7 +117,6 @@ jobs:
             test-path: >-
               tests/proxy_unit_tests/test_proxy_config_unit_test.py
               tests/proxy_unit_tests/test_proxy_routes.py
-              tests/proxy_unit_tests/test_proxy_gunicorn.py
               tests/proxy_unit_tests/test_server_root_path.py
               tests/proxy_unit_tests/test_proxy_pass_user_config.py
               tests/proxy_unit_tests/test_proxy_token_counter.py
@@ -198,7 +194,6 @@ jobs:
               tests/proxy_unit_tests/test_realtime_cache.py
               tests/proxy_unit_tests/test_proxy_exception_mapping.py
               tests/proxy_unit_tests/test_custom_tokenizer_bug.py
-              tests/proxy_unit_tests/test_model_response_typing
             workers: 4
             dist: loadscope
             timeout: 15

.github/workflows/test-unit.yml

@@ -213,7 +213,6 @@ jobs:
             test-path: >-
               tests/local_testing/test_cache_preset_key.py
               tests/local_testing/test_caching_handler.py
-              tests/local_testing/test_prompt_caching.py
               tests/local_testing/test_responses_stream_cache_keys.py
               tests/local_testing/test_unit_test_caching.py
             workers: 2

litellm-rust/Cargo.lock

@@ -2001,33 +2001,49 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "litellm-callbacks"
+version = "0.1.0"
+dependencies = [
+ "rstest",
+ "serde_json",
+ "tokio",
+]
+
+[[package]]
+name = "litellm-callbacks-legacy"
+version = "0.1.0"
+dependencies = [
+ "litellm-callbacks",
+ "litellm-host-python",
+ "pyo3",
+ "rstest",
+ "serde_json",
+]
+
 [[package]]
 name = "litellm-core"
 version = "0.1.0"
 dependencies = [
- "aws-smithy-eventstream",
- "aws-smithy-types",
  "base64 0.22.1",
  "bytes",
- "data-url",
  "futures-util",
  "litellm-auth",
  "litellm-auth-aws",
- "litellm-auth-azure",
- "litellm-auth-gcp",
- "litellm-framing",
- "litellm-providers",
+ "litellm-callbacks",
+ "litellm-core-utils",
+ "litellm-llms",
+ "litellm-types",
  "mime_guess",
  "moka",
  "rand 0.8.7",
  "reqwest 0.12.28",
  "rstest",
+ "rstest_reuse",
  "rustls 0.23.42",
  "rustls-native-certs",
  "serde",
  "serde_json",
- "serde_path_to_error",
- "serde_with",
  "sha2 0.10.9",
  "strum",
  "subtle",
@@ -2039,6 +2055,19 @@ dependencies = [
  "veil",
 ]
 
+[[package]]
+name = "litellm-core-utils"
+version = "0.1.0"
+dependencies = [
+ "litellm-types",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_with",
+ "thiserror 2.0.19",
+ "url",
+]
+
 [[package]]
 name = "litellm-framing"
 version = "0.1.0"
@@ -2054,15 +2083,48 @@ dependencies = [
 ]
 
 [[package]]
-name = "litellm-providers"
+name = "litellm-host-python"
 version = "0.1.0"
 dependencies = [
- "litellm-auth",
- "litellm-auth-aws",
+ "futures-util",
+ "litellm-callbacks",
+ "pyo3",
+ "pyo3-async-runtimes",
+ "pythonize",
  "rstest",
  "serde",
  "serde_json",
+ "tokio",
+]
+
+[[package]]
+name = "litellm-llms"
+version = "0.1.0"
+dependencies = [
+ "aws-smithy-eventstream",
+ "aws-smithy-types",
+ "base64 0.22.1",
+ "bytes",
+ "data-url",
+ "futures-util",
+ "litellm-auth",
+ "litellm-auth-aws",
+ "litellm-auth-azure",
+ "litellm-auth-gcp",
+ "litellm-callbacks",
+ "litellm-core-utils",
+ "litellm-framing",
+ "litellm-types",
+ "reqwest 0.12.28",
+ "rstest",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_with",
  "thiserror 2.0.19",
+ "time",
+ "tokio",
+ "url",
 ]
 
 [[package]]
@@ -2073,29 +2135,20 @@ dependencies = [
  "criterion",
  "futures-util",
  "litellm-auth",
+ "litellm-callbacks-legacy",
  "litellm-core",
- "litellm-python-interop",
+ "litellm-host-python",
+ "litellm-llms",
  "litellm-token-counter",
+ "litellm-types",
  "pyo3",
  "pyo3-async-runtimes",
  "rstest",
- "serde",
  "serde_json",
  "tokio",
  "tokio-tungstenite",
 ]
 
-[[package]]
-name = "litellm-python-interop"
-version = "0.1.0"
-dependencies = [
- "pyo3",
- "pythonize",
- "rstest",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "litellm-token-counter"
 version = "0.1.0"
@@ -2114,6 +2167,14 @@ dependencies = [
  "unicode-normalization-alignments",
 ]
 
+[[package]]
+name = "litellm-types"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "litemap"
 version = "0.8.2"
@@ -3009,6 +3070,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "rstest_reuse"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3a8fb4672e840a587a66fc577a5491375df51ddb88f2a2c2a792598c326fe14"
+dependencies = [
+ "quote",
+ "rand 0.8.7",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"

litellm-rust/Cargo.toml

@@ -9,24 +9,30 @@ license = "MIT"
 repository = "https://github.com/BerriAI/litellm"
 
 [workspace.dependencies]
-bytes = "1"
 litellm-core = { path = "crates/core" }
+litellm-callbacks = { path = "crates/callbacks" }
+litellm-callbacks-legacy = { path = "crates/callbacks-legacy" }
 litellm-framing = { path = "crates/framer" }
 litellm-auth = { path = "crates/auth" }
 litellm-auth-aws = { path = "crates/auth-aws" }
 litellm-auth-azure = { path = "crates/auth-azure" }
 litellm-auth-gcp = { path = "crates/auth-gcp" }
-litellm-providers = { path = "crates/providers" }
+litellm-llms = { path = "crates/llms" }
+litellm-types = { path = "crates/types" }
+litellm-core-utils = { path = "crates/core-utils" }
 litellm-cache = { path = "crates/cache" }
 litellm-cache-memory = { path = "crates/cache-memory" }
 litellm-token-counter = { path = "crates/token-counter" }
-litellm-python-interop = { path = "crates/python-interop" }
+litellm-host-python = { path = "crates/host-python" }
+
+bytes = "1"
 pyo3 = "0.29.2"
 pyo3-async-runtimes = { version = "0.29.0", features = ["tokio-runtime"] }
 pythonize = "0.29.0"
 rand = "0.8"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls", "http2", "stream"] }
 rstest = "0.26.1"
+rstest_reuse = "0.7.0"
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
 rustls-native-certs = "0.8"
 serde = { version = "1.0", features = ["derive"] }

litellm-rust/crates/auth-azure/src/resolve.rs

@@ -657,4 +657,49 @@ mod tests {
 
         assert!(matches!(error, Error::CredentialChain(errors) if errors.len() == 2));
     }
+
+    #[derive(Debug)]
+    struct CallerToken(&'static str);
+
+    impl litellm_auth::TokenProvider for CallerToken {
+        fn acquire(&self) -> litellm_auth::TokenFuture<'_> {
+            Box::pin(async move {
+                Ok(ResolvedCredential::AccessToken {
+                    token: SecretValue::new(self.0),
+                    expires_on: None,
+                })
+            })
+        }
+    }
+
+    fn caller_inputs(token: &'static str) -> AzureAuthInputs {
+        let params = json!({"azure_ad_token": "static-token"});
+        AzureAuthInputs {
+            azure_ad_token_provider: Some(litellm_auth::TokenProviderHandle::new(Arc::new(
+                CallerToken(token),
+            ))),
+            ..AzureAuthInputs::from_optional_params(params.as_object().unwrap()).unwrap()
+        }
+    }
+
+    #[tokio::test]
+    async fn caller_token_is_chosen_over_supplied_static_token() {
+        let credential = AzureAuthService::default()
+            .get_azure_ad_token(&caller_inputs("caller-token"), &|_| None)
+            .await
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(credential.value().secret().expose(), "caller-token");
+    }
+
+    #[tokio::test]
+    async fn empty_caller_token_is_rejected() {
+        let error = AzureAuthService::default()
+            .get_azure_ad_token(&caller_inputs(""), &|_| None)
+            .await
+            .unwrap_err();
+
+        assert!(matches!(error, Error::EmptyAzureToken));
+    }
 }

litellm-rust/crates/auth/src/credential.rs

@@ -9,21 +9,6 @@ use crate::Error;
 
 use super::{ResolvedCredential, SecretValue, TokenProviderHandle};
 
-pub fn credential_index(requested: &str, names: &[String]) -> Option<usize> {
-    names.iter().position(|name| name == requested)
-}
-
-pub fn credential_default_fields<'a>(
-    supplied: &[String],
-    credential_fields: &'a [String],
-) -> Vec<&'a str> {
-    credential_fields
-        .iter()
-        .filter(|name| !supplied.contains(name))
-        .map(String::as_str)
-        .collect()
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum CredentialFileRef {
     Path(PathBuf),

litellm-rust/crates/auth/src/lib.rs

@@ -47,7 +47,6 @@ impl<T> Sourced<T> {
 pub use credential::{
     CredentialFileRef, CredentialLookup, CredentialLookupFuture, CredentialPlan,
     CredentialPlanResolution, CredentialRef, CredentialResolver, CredentialResolverHandle,
-    credential_default_fields, credential_index,
 };
 pub use error::Error;
 pub use http::{CredentialPlacement, RequestAuth};

litellm-rust/crates/callbacks-legacy/AGENTS.md

@@ -0,0 +1,17 @@
+- Target invariants, not completion claims
+- Keep this crate the legacy `@client` wrapper as the native call sees it, and nothing else: the `Logging` contract (`function_setup`, the deployment hooks, `pre_call`/`post_call`, the sync and async success and failure fan-out, the deferred proxy release, the argument sharing those callbacks rely on) plus the kwargs rewrites the wrapper makes on the way in (credential-name inheritance, the budget and retry-count limits)
+  - The driver in `litellm-host-python`, the routes and core see one `CallbackAdapter`; they never learn which Python objects consume a call
+  - `PublicCall` is the caller's call as `Logging` sees it: the positional arguments, the keyword view as the legacy path rewrites it (setup, deployment hook, prepare) and the bound request object whose attributes back keywords the caller omitted; routes hand it over through `run_legacy_call` and keep no copy
+- `setup` decides once who owns the `Logging` instance and returns it as `CallSetup.bridge_owned`; `PythonLogger` carries it and nothing on the instance records it
+  - A logger the caller passed as `litellm_logging_obj` is caller-owned and observed in full, because the caller reads it after the call; the proxy is the live case
+  - A logger `function_setup` built for this call is bridge-owned, so each fan-out phase is skipped when `callbacks_needed` finds no registry, dynamic callback, `logger_fn` or debug switch for it; cost, timing and response metadata still run
+- Callbacks receive the caller's own objects and may mutate them; this crate alone carries that obligation
+  - Retain complete boundary arguments, opaque unknown values, aliases, omitted/default distinctions and deliberate copies; preserve the established deployment-hook kwargs view
+  - Re-alias every `passthrough_fields` body key to the caller's object before `pre_call`; a keyword wins over the request attribute even when it is an explicit `None`
+  - Retain independently captured body/header roots from `pre_call` to `post_call`; in-place mutation reaches the wire, envelope field replacement is visible to later callbacks only
+  - A later kind of callback host (WASM, in-process Rust) has none of these obligations, so they stay out of `litellm-callbacks`, `litellm-host-python` and the bridge; the only facts that cross from the route are the prepared keyword view and `RequestContext.passthrough_fields`
+- Success and failure handlers receive the exact selected public response or exception; logging projections, redaction and snapshots keep their own copy contracts
+  - Ordinary failure-handler errors cannot suppress the other eligible family or replace the mapped provider error; a cancellation ends the call with no further dispatch
+  - Dispatch errors never replay provider work or trigger the opposite outcome; the proxy's acceptance or rejection releases deferred success at most once
+  - Delivery follows the registry, not the callable's type: direct, awaited, executor-submitted, logging-worker and deferred paths stay distinct
+- Traverse every retained Python edge; `close` is idempotent and restores the correlation context once

litellm-rust/crates/callbacks-legacy/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "litellm-callbacks-legacy"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+autotests = false
+
+[dependencies]
+litellm-callbacks.workspace = true
+litellm-host-python.workspace = true
+pyo3.workspace = true
+
+[dev-dependencies]
+rstest.workspace = true
+serde_json.workspace = true

litellm-rust/crates/callbacks-legacy/src/adapter.rs

@@ -0,0 +1,385 @@
+//! The legacy `Logging` contract as one adapter: every event and interception the driver
+//! raises is answered with the same `Logging` calls, in the same order, as the Python
+//! `@client` path makes them.
+
+use litellm_callbacks::event::{CallEvent, FailureOrigin, RequestContext, Timing, WireRequest};
+use litellm_host_python::{
+    AdapterStep, CallbackAdapter, PublicValue, from_py, missing_state, to_py,
+};
+use pyo3::{
+    exceptions::{PyBaseException, PyException},
+    gc::{PyTraverseError, PyVisit},
+    prelude::*,
+    types::PyDict,
+};
+
+use crate::{
+    DeploymentHooks, LegacyCallbacks, PublicCall, PythonLogger,
+    deferred::{PendingLogging, PendingSuccess},
+    finalize, is_internal_call, prepare, setup,
+};
+
+/// What the legacy contract needs to know about the route it is logging.
+#[derive(Clone, Copy, Debug)]
+pub struct LegacySurface {
+    pub call_type: &'static str,
+    /// What `Logging.pre_call` is told the input was.
+    pub input_description: &'static str,
+}
+
+enum Pending {
+    DeploymentPreCall,
+    DeploymentPostCall,
+    DeploymentFailure,
+    AsyncFailure,
+}
+
+pub struct LegacyLogging {
+    surface: LegacySurface,
+    call: PublicCall,
+    logger: Option<PythonLogger>,
+    start: Py<PyAny>,
+    end: Option<Py<PyAny>>,
+    response: Option<Py<PyAny>>,
+    error: Option<Py<PyBaseException>>,
+    body: Option<Py<PyDict>>,
+    headers: Option<Py<PyDict>>,
+    asynchronous: bool,
+    internal: bool,
+    pending: Option<Pending>,
+}
+
+fn datetime(py: Python<'_>, epoch_seconds: f64) -> PyResult<Py<PyAny>> {
+    py.import("datetime")?
+        .getattr("datetime")?
+        .call_method1("fromtimestamp", (epoch_seconds,))
+        .map(Bound::unbind)
+}
+
+fn is_cancellation(py: Python<'_>, error: &PyErr) -> bool {
+    !error.is_instance_of::<PyException>(py)
+}
+
+impl LegacyLogging {
+    pub fn new(
+        py: Python<'_>,
+        surface: LegacySurface,
+        call: PublicCall,
+        asynchronous: bool,
+    ) -> Self {
+        Self {
+            surface,
+            call,
+            logger: None,
+            start: py.None(),
+            end: None,
+            response: None,
+            error: None,
+            body: None,
+            headers: None,
+            asynchronous,
+            internal: false,
+            pending: None,
+        }
+    }
+
+    /// Deployment hooks are awaited, and Python's synchronous `@client` wrapper never
+    /// runs them.
+    fn deployment_hooks(&self, py: Python<'_>) -> PyResult<bool> {
+        Ok(self.asynchronous && DeploymentHooks::needed(py)?)
+    }
+
+    fn logger(&self) -> PyResult<&PythonLogger> {
+        self.logger.as_ref().ok_or_else(|| {
+            pyo3::exceptions::PyRuntimeError::new_err("call logging is not initialized")
+        })
+    }
+
+    fn prepare(&mut self, py: Python<'_>) -> PyResult<AdapterStep> {
+        let prepared = prepare(py, self.call.kwargs().bind(py), self.logger()?)?.unbind();
+        self.call.set_kwargs(prepared);
+        Ok(AdapterStep::Arguments(self.call.kwargs().clone_ref(py)))
+    }
+
+    fn finalize(&mut self, py: Python<'_>) -> PyResult<AdapterStep> {
+        finalize(
+            py,
+            &self.response,
+            self.logger()?,
+            self.call.kwargs(),
+            &self.start,
+            &self.end,
+        )?;
+        self.response
+            .as_ref()
+            .map(|response| AdapterStep::Response(response.clone_ref(py)))
+            .ok_or_else(missing_state)
+    }
+
+    fn dispatch_success(&self, py: Python<'_>) -> PyResult<()> {
+        match self.try_dispatch_success(py) {
+            Err(error) if error.is_instance_of::<PyException>(py) => {
+                error.write_unraisable(py, self.logger.as_ref().map(|logger| logger.object(py)));
+                Ok(())
+            }
+            result => result,
+        }
+    }
+
+    fn try_dispatch_success(&self, py: Python<'_>) -> PyResult<()> {
+        let logger = self.logger()?;
+        let pending = || PendingSuccess {
+            logger: logger.clone_ref(py),
+            response: self.response.as_ref().map(|value| value.clone_ref(py)),
+            start: self.start.clone_ref(py),
+            end: self.end.as_ref().map(|value| value.clone_ref(py)),
+        };
+        if !self.asynchronous {
+            return pending().sync(py);
+        }
+        if !self.internal
+            && self
+                .call
+                .kwargs()
+                .bind(py)
+                .get_item("fallbacks")?
+                .is_none_or(|value| value.is_none())
+        {
+            if !logger.callbacks_needed(py, "async_success")? {
+                logger.success_bookkeeping(py, &self.response, &self.start, &self.end, true)?;
+            } else if logger.defers_async_logging(py) {
+                let pending = Py::new(
+                    py,
+                    PendingLogging {
+                        pending: Some(pending()),
+                    },
+                )?;
+                logger.defer_success(py, pending.bind(py).as_any())?;
+            } else {
+                pending().asynchronous(py)?;
+            }
+        }
+        logger.sync_success_for_async_call(py, &self.response, &self.start, &self.end)
+    }
+
+    /// The sync failure handler, then the async one for async calls. Ordinary handler
+    /// errors never replace the selected failure or suppress the other family; a
+    /// cancellation does end the call.
+    fn dispatch_failure(&mut self, py: Python<'_>) -> PyResult<AdapterStep> {
+        let (Some(logger), Some(error)) = (&self.logger, &self.error) else {
+            return Ok(AdapterStep::Done);
+        };
+        if self.asynchronous && self.internal {
+            return Ok(AdapterStep::Done);
+        }
+        if let Err(failure) = logger.failure(py, error, &self.start, &self.end, false)
+            && is_cancellation(py, &failure)
+        {
+            return Err(failure);
+        }
+        if !self.asynchronous {
+            return Ok(AdapterStep::Done);
+        }
+        match logger.failure(py, error, &self.start, &self.end, true) {
+            Ok(Some(awaitable)) => {
+                self.pending = Some(Pending::AsyncFailure);
+                Ok(AdapterStep::Await(awaitable))
+            }
+            Ok(None) => Ok(AdapterStep::Done),
+            Err(failure) if is_cancellation(py, &failure) => Err(failure),
+            Err(_) => Ok(AdapterStep::Done),
+        }
+    }
+}
+
+impl CallbackAdapter for LegacyLogging {
+    fn begin(
+        &mut self,
+        py: Python<'_>,
+        arguments: Py<PyDict>,
+        started_at: f64,
+    ) -> PyResult<AdapterStep> {
+        self.call.set_kwargs(arguments);
+        self.start = datetime(py, started_at)?;
+        self.internal = is_internal_call(py)?;
+        let result = setup(
+            py,
+            self.surface.call_type,
+            self.call.args(),
+            self.call.kwargs(),
+            &self.start,
+            self.asynchronous,
+        )?;
+        self.logger = Some(result.logger()?);
+        self.call.set_kwargs(result.kwargs()?);
+        if self.deployment_hooks(py)? {
+            self.pending = Some(Pending::DeploymentPreCall);
+            return Ok(AdapterStep::Await(DeploymentHooks::before_call(
+                py,
+                self.call.kwargs(),
+                self.surface.call_type,
+            )?));
+        }
+        self.prepare(py)
+    }
+
+    fn before_send(
+        &mut self,
+        py: Python<'_>,
+        wire: Box<WireRequest>,
+        context: &RequestContext,
+    ) -> PyResult<AdapterStep> {
+        let logger = self.logger()?;
+        logger.update_from_kwargs(py, self.call.kwargs(), &wire, context)?;
+        if !logger.callbacks_needed(py, "payload")? {
+            logger.record_api_call_start(py)?;
+            return Ok(AdapterStep::Wire(wire));
+        }
+        let body = to_py(py, &wire.body)?
+            .into_bound(py)
+            .cast_into::<PyDict>()?;
+        for name in context.passthrough_fields.iter() {
+            if let Some(value) = self.call.lookup(py, name)? {
+                body.set_item(name, value)?;
+            }
+        }
+        let headers = PyDict::new(py);
+        for (name, value) in &wire.headers {
+            headers.set_item(name, value)?;
+        }
+        self.body = Some(body.clone().unbind());
+        self.headers = Some(headers.clone().unbind());
+        let api_key = self.call.lookup(py, "api_key")?;
+        self.logger()?.pre_call(
+            py,
+            self.surface.input_description,
+            api_key.as_ref(),
+            &body,
+            &headers,
+            &wire.url,
+        )?;
+        let headers = headers
+            .iter()
+            .map(|(name, value)| Ok((name.extract::<String>()?, value.extract::<String>()?)))
+            .collect::<PyResult<Vec<_>>>()?;
+        Ok(AdapterStep::Wire(Box::new(WireRequest {
+            body: from_py(&body)?,
+            headers,
+            ..*wire
+        })))
+    }
+
+    fn after_success(
+        &mut self,
+        py: Python<'_>,
+        response: Py<PyAny>,
+        timing: Timing,
+    ) -> PyResult<AdapterStep> {
+        self.end = Some(datetime(py, timing.end_time)?);
+        self.response = Some(response);
+        if self.deployment_hooks(py)? {
+            self.pending = Some(Pending::DeploymentPostCall);
+            return Ok(AdapterStep::Await(DeploymentHooks::after_success(
+                py,
+                self.call.kwargs(),
+                &self.response,
+                self.surface.call_type,
+            )?));
+        }
+        self.finalize(py)
+    }
+
+    fn emit(
+        &mut self,
+        py: Python<'_>,
+        event: &CallEvent,
+        public: Option<PublicValue<'_>>,
+    ) -> PyResult<AdapterStep> {
+        match (event, public) {
+            (CallEvent::ResponseReceived { raw }, _) => {
+                let logger = self.logger()?;
+                if logger.callbacks_needed(py, "payload")? {
+                    logger.post_call(py, &raw.body, self.body.as_ref(), self.headers.as_ref())?;
+                }
+                Ok(AdapterStep::Done)
+            }
+            (CallEvent::Succeeded { timing }, Some(PublicValue::Response(response))) => {
+                self.end = Some(datetime(py, timing.end_time)?);
+                self.response = Some(response.clone_ref(py));
+                self.dispatch_success(py)?;
+                Ok(AdapterStep::Done)
+            }
+            (CallEvent::Failed { timing, origin }, Some(PublicValue::Error(error))) => {
+                self.end = Some(datetime(py, timing.end_time)?);
+                self.error = Some(error.clone_ref(py).into_value(py));
+                if *origin == FailureOrigin::Call
+                    && self.logger.is_some()
+                    && self.deployment_hooks(py)?
+                {
+                    let error = self.error.as_ref().ok_or_else(missing_state)?;
+                    self.pending = Some(Pending::DeploymentFailure);
+                    return Ok(AdapterStep::Await(DeploymentHooks::after_failure(
+                        py,
+                        self.call.kwargs(),
+                        error,
+                        self.surface.call_type,
+                    )?));
+                }
+                self.dispatch_failure(py)
+            }
+            _ => Err(missing_state()),
+        }
+    }
+
+    fn resume(&mut self, py: Python<'_>, result: PyResult<Py<PyAny>>) -> PyResult<AdapterStep> {
+        match self.pending.take().ok_or_else(missing_state)? {
+            Pending::DeploymentPreCall => {
+                self.call
+                    .set_kwargs(result?.into_bound(py).cast_into::<PyDict>()?.unbind());
+                self.prepare(py)
+            }
+            Pending::DeploymentPostCall => {
+                self.response = Some(result?);
+                self.finalize(py)
+            }
+            Pending::DeploymentFailure => self.dispatch_failure(py),
+            Pending::AsyncFailure => match result {
+                Err(failure) if is_cancellation(py, &failure) => Err(failure),
+                _ => Ok(AdapterStep::Done),
+            },
+        }
+    }
+
+    fn close(&mut self, py: Python<'_>) {
+        if let Some(logger) = self.logger.take()
+            && let Err(error) = logger.restore_context(py)
+        {
+            error.write_unraisable(py, None);
+        }
+        self.body = None;
+        self.headers = None;
+    }
+
+    fn traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        self.call.traverse(visit)?;
+        if let Some(logger) = &self.logger {
+            logger.traverse(visit)?;
+        }
+        visit.call(&self.start)?;
+        visit.call(&self.end)?;
+        visit.call(&self.response)?;
+        visit.call(&self.error)?;
+        visit.call(&self.body)?;
+        visit.call(&self.headers)
+    }
+}
+
+#[cfg(test)]
+#[path = "../tests/deployment_hooks.rs"]
+mod deployment_hooks_tests;
+#[cfg(test)]
+#[path = "../tests/payload.rs"]
+mod payload_tests;
+#[cfg(test)]
+#[path = "../tests/terminal.rs"]
+mod terminal_tests;

litellm-rust/crates/callbacks-legacy/src/call.rs

@@ -0,0 +1,179 @@
+//! The caller's public call as the legacy `Logging` contract sees it. Legacy callbacks
+//! receive these exact objects and may mutate them, so the call keeps them for its whole
+//! lifetime. No other callback host has that obligation, which is why nothing outside
+//! this crate holds them.
+
+use litellm_callbacks::{machine::Machine, route::Route};
+use litellm_host_python::{RouteHost, run_call};
+use pyo3::{
+    gc::{PyTraverseError, PyVisit},
+    prelude::*,
+    types::{PyDict, PyTuple},
+};
+
+use crate::{LegacyLogging, LegacySurface};
+
+pub struct PublicCall {
+    args: Py<PyTuple>,
+    kwargs: Py<PyDict>,
+    request: Py<PyAny>,
+}
+
+impl PublicCall {
+    /// Copies the keyword arguments once, so the legacy path's rewrites never reach the
+    /// caller's own dict while every value keeps its identity.
+    pub fn capture(
+        request: &Bound<'_, PyAny>,
+        args: &Bound<'_, PyTuple>,
+        kwargs: &Bound<'_, PyDict>,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            args: args.clone().unbind(),
+            kwargs: kwargs.copy()?.unbind(),
+            request: request.clone().unbind(),
+        })
+    }
+
+    pub(crate) fn args(&self) -> &Py<PyTuple> {
+        &self.args
+    }
+
+    /// The keyword view the legacy path currently reads: the caller's copy until
+    /// `function_setup`, then each rewrite (setup, deployment hook, prepare) in turn.
+    pub(crate) fn kwargs(&self) -> &Py<PyDict> {
+        &self.kwargs
+    }
+
+    pub(crate) fn set_kwargs(&mut self, kwargs: Py<PyDict>) {
+        self.kwargs = kwargs;
+    }
+
+    pub(crate) fn lookup<'py>(
+        &self,
+        py: Python<'py>,
+        name: &str,
+    ) -> PyResult<Option<Bound<'py, PyAny>>> {
+        lookup(self.kwargs.bind(py), self.request.bind(py), name)
+    }
+
+    pub(crate) fn traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        visit.call(&self.args)?;
+        visit.call(&self.kwargs)?;
+        visit.call(&self.request)
+    }
+}
+
+/// The caller's own object for a public argument, as every legacy reader resolves it: the
+/// keyword if given, even an explicit `None`, else the bound request's attribute. A route
+/// host projecting from the prepared keyword view uses the same rule, so the callbacks
+/// and the provider see one object per argument.
+pub fn lookup<'py>(
+    kwargs: &Bound<'py, PyDict>,
+    request: &Bound<'py, PyAny>,
+    name: &str,
+) -> PyResult<Option<Bound<'py, PyAny>>> {
+    if let Some(value) = kwargs.get_item(name)? {
+        return Ok(Some(value));
+    }
+    request.getattr_opt(name)
+}
+
+/// Runs one native call under the legacy `Logging` contract: the route host projects from
+/// the keyword view the contract prepares, and the contract observes the call.
+pub fn run_legacy_call<H, M>(
+    py: Python<'_>,
+    surface: LegacySurface,
+    call: PublicCall,
+    machine: M,
+    route: H,
+    asynchronous: bool,
+) -> PyResult<Py<PyAny>>
+where
+    H: RouteHost + 'static,
+    M: Machine<Route = H::Route, Complete = <H::Route as Route>::Response> + 'static,
+{
+    let arguments = call.kwargs.clone_ref(py);
+    run_call(
+        py,
+        machine,
+        route,
+        Box::new(LegacyLogging::new(py, surface, call, asynchronous)),
+        arguments,
+        asynchronous,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn capture<'py>(py: Python<'py>, source: &std::ffi::CStr) -> (PublicCall, Bound<'py, PyDict>) {
+        let locals = PyDict::new(py);
+        py.run(source, Some(&locals), Some(&locals)).unwrap();
+        let request = locals.get_item("request").unwrap().unwrap();
+        let kwargs = locals
+            .get_item("kwargs")
+            .unwrap()
+            .unwrap()
+            .cast_into::<PyDict>()
+            .unwrap();
+        let call = PublicCall::capture(&request, &PyTuple::empty(py), &kwargs).unwrap();
+        (call, locals)
+    }
+
+    #[test]
+    fn lookup_prefers_the_keyword_even_when_none_and_falls_back_to_the_request() {
+        Python::initialize();
+        Python::attach(|py| {
+            let (call, locals) = capture(
+                py,
+                c"
+key = object()
+document = {'type': 'document_url'}
+class Request:
+    api_key = 'from-request'
+    api_base = 'from-request'
+    document = document
+request = Request()
+kwargs = {'api_key': key, 'api_base': None}
+",
+            );
+            let key = locals.get_item("key").unwrap().unwrap();
+            let document = locals.get_item("document").unwrap().unwrap();
+            assert!(call.lookup(py, "api_key").unwrap().unwrap().is(&key));
+            assert!(call.lookup(py, "api_base").unwrap().unwrap().is_none());
+            assert!(call.lookup(py, "document").unwrap().unwrap().is(&document));
+            assert!(call.lookup(py, "model").unwrap().is_none());
+        });
+    }
+
+    #[test]
+    fn capture_copies_the_keyword_dict_without_copying_its_values() {
+        Python::initialize();
+        Python::attach(|py| {
+            let (call, locals) = capture(
+                py,
+                c"
+pages = [0]
+class Request:
+    pass
+request = Request()
+kwargs = {'pages': pages}
+",
+            );
+            let caller = locals
+                .get_item("kwargs")
+                .unwrap()
+                .unwrap()
+                .cast_into::<PyDict>()
+                .unwrap();
+            call.kwargs()
+                .bind(py)
+                .set_item("litellm_call_id", "call")
+                .unwrap();
+            assert!(!caller.contains("litellm_call_id").unwrap());
+            let pages = locals.get_item("pages").unwrap().unwrap();
+            assert!(call.lookup(py, "pages").unwrap().unwrap().is(&pages));
+        });
+    }
+}

litellm-rust/crates/callbacks-legacy/src/callbacks.rs

@@ -0,0 +1,404 @@
+//! Callback fan-out over litellm's `Logging` object: which callbacks are registered,
+//! the deferred and worker-submitted success paths, and the sync-callbacks-for-async-calls
+//! duplication. All of it expires with the legacy callback contract.
+
+use litellm_callbacks::event::{RequestContext, WireRequest};
+use litellm_host_python::to_py;
+use pyo3::{exceptions::PyBaseException, prelude::*, types::PyDict};
+
+use crate::logger::PythonLogger;
+
+pub trait LegacyCallbacks {
+    fn callbacks_needed(&self, py: Python<'_>, phase: &str) -> PyResult<bool>;
+
+    /// `Logging.update_from_kwargs`: what the logger is told about the request it is
+    /// about to see, with consumed credentials redacted.
+    fn update_from_kwargs(
+        &self,
+        py: Python<'_>,
+        kwargs: &Py<PyDict>,
+        wire: &WireRequest,
+        context: &RequestContext,
+    ) -> PyResult<()>;
+
+    fn record_api_call_start(&self, py: Python<'_>) -> PyResult<()>;
+
+    /// `Logging.pre_call`, or its payload-free shortcut when no input callback listens.
+    fn pre_call(
+        &self,
+        py: Python<'_>,
+        input: &str,
+        api_key: Option<&Bound<'_, PyAny>>,
+        body: &Bound<'_, PyDict>,
+        headers: &Bound<'_, PyDict>,
+        url: &str,
+    ) -> PyResult<()>;
+
+    /// `Logging.post_call`, or its payload-free shortcut when no input callback listens.
+    fn post_call(
+        &self,
+        py: Python<'_>,
+        original_response: &str,
+        body: Option<&Py<PyDict>>,
+        headers: Option<&Py<PyDict>>,
+    ) -> PyResult<()>;
+
+    fn defers_async_logging(&self, py: Python<'_>) -> bool;
+
+    fn defer_success(&self, py: Python<'_>, pending: &Bound<'_, PyAny>) -> PyResult<()>;
+
+    fn sync_success_for_async_call(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()>;
+
+    fn failure(
+        &self,
+        py: Python<'_>,
+        error: &Py<PyBaseException>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+        asynchronous: bool,
+    ) -> PyResult<Option<Py<PyAny>>>;
+
+    fn submit_success(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()>;
+
+    fn enqueue_success(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()>;
+}
+
+impl LegacyCallbacks for PythonLogger {
+    fn callbacks_needed(&self, py: Python<'_>, phase: &str) -> PyResult<bool> {
+        if !self.bridge_owned() {
+            return Ok(true);
+        }
+        py.import("litellm.rust_bridge.legacy_callbacks")?
+            .getattr("callbacks_needed")?
+            .call1((self.object(py), phase))?
+            .extract()
+    }
+
+    fn update_from_kwargs(
+        &self,
+        py: Python<'_>,
+        kwargs: &Py<PyDict>,
+        wire: &WireRequest,
+        context: &RequestContext,
+    ) -> PyResult<()> {
+        let secret_fields: Vec<&str> = context.secret_fields.iter().map(String::as_str).collect();
+        let update = PyDict::new(py);
+        update.set_item("kwargs", redact(py, kwargs.bind(py), &secret_fields)?)?;
+        update.set_item("model", &context.model)?;
+        update.set_item(
+            "optional_params",
+            redact(
+                py,
+                &to_py(py, &context.optional_params)?
+                    .into_bound(py)
+                    .cast_into::<PyDict>()?,
+                &secret_fields,
+            )?,
+        )?;
+        let params = PyDict::new(py);
+        params.set_item(
+            "litellm_call_id",
+            kwargs.bind(py).get_item("litellm_call_id")?,
+        )?;
+        params.set_item("api_base", &wire.url)?;
+        for name in ["logger_fn", "litellm_request_debug"] {
+            if let Some(value) = kwargs.bind(py).get_item(name)? {
+                params.set_item(name, value)?;
+            }
+        }
+        for name in custom_pricing_fields(py)? {
+            if let Some(value) = kwargs.bind(py).get_item(&name)?
+                && !value.is_none()
+            {
+                params.set_item(name, value)?;
+            }
+        }
+        update.set_item("litellm_params", params)?;
+        update.set_item("custom_llm_provider", &context.custom_llm_provider)?;
+        self.object(py)
+            .call_method("update_from_kwargs", (), Some(&update))?;
+        Ok(())
+    }
+
+    fn record_api_call_start(&self, py: Python<'_>) -> PyResult<()> {
+        self.object(py).call_method0("record_api_call_start_time")?;
+        Ok(())
+    }
+
+    fn pre_call(
+        &self,
+        py: Python<'_>,
+        input: &str,
+        api_key: Option<&Bound<'_, PyAny>>,
+        body: &Bound<'_, PyDict>,
+        headers: &Bound<'_, PyDict>,
+        url: &str,
+    ) -> PyResult<()> {
+        let additional = PyDict::new(py);
+        additional.set_item("complete_input_dict", body)?;
+        additional.set_item("headers", headers)?;
+        additional.set_item("api_base", url)?;
+        let kwargs = PyDict::new(py);
+        kwargs.set_item("input", input)?;
+        kwargs.set_item("api_key", api_key)?;
+        kwargs.set_item("additional_args", &additional)?;
+        if self.callbacks_needed(py, "input")? {
+            self.object(py).call_method("pre_call", (), Some(&kwargs))?;
+        } else {
+            self.object(py)
+                .call_method("_pre_call", (), Some(&kwargs))?;
+            self.record_api_call_start(py)?;
+        }
+        Ok(())
+    }
+
+    fn post_call(
+        &self,
+        py: Python<'_>,
+        original_response: &str,
+        body: Option<&Py<PyDict>>,
+        headers: Option<&Py<PyDict>>,
+    ) -> PyResult<()> {
+        let additional = PyDict::new(py);
+        additional.set_item("complete_input_dict", body)?;
+        additional.set_item("headers", headers)?;
+        if self.callbacks_needed(py, "input")? {
+            let kwargs = PyDict::new(py);
+            kwargs.set_item("original_response", original_response)?;
+            kwargs.set_item("additional_args", &additional)?;
+            self.object(py)
+                .call_method("post_call", (), Some(&kwargs))?;
+        } else {
+            let response = py
+                .import("json")?
+                .call_method1("dumps", (original_response,))?;
+            self.object(py).call_method1(
+                "record_post_call",
+                (response, py.None(), py.None(), additional),
+            )?;
+        }
+        Ok(())
+    }
+    fn defers_async_logging(&self, py: Python<'_>) -> bool {
+        self.object(py)
+            .getattr("_defer_async_logging")
+            .is_ok_and(|value| value.is_truthy().unwrap_or(false))
+    }
+
+    fn defer_success(&self, py: Python<'_>, pending: &Bound<'_, PyAny>) -> PyResult<()> {
+        self.object(py).setattr("_native_pending_logging", pending)
+    }
+
+    fn sync_success_for_async_call(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()> {
+        if !self.callbacks_needed(py, "sync_success_async")? {
+            return Ok(());
+        }
+        self.object(py).call_method1(
+            "handle_sync_success_callbacks_for_async_calls",
+            (response, start, end),
+        )?;
+        Ok(())
+    }
+
+    fn failure(
+        &self,
+        py: Python<'_>,
+        error: &Py<PyBaseException>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+        asynchronous: bool,
+    ) -> PyResult<Option<Py<PyAny>>> {
+        if !self.callbacks_needed(
+            py,
+            if asynchronous {
+                "async_failure"
+            } else {
+                "sync_failure"
+            },
+        )? {
+            py.import("litellm.rust_bridge.legacy_callbacks")?
+                .getattr("failure_bookkeeping")?
+                .call1((self.object(py), error, start, end, asynchronous))?;
+            return Ok(None);
+        }
+        let trace = py
+            .import("traceback")?
+            .getattr("format_exception")?
+            .call1((error,))?;
+        let trace = pyo3::types::PyString::new(py, "").call_method1("join", (trace,))?;
+        let value = self.object(py).call_method1(
+            if asynchronous {
+                "async_failure_handler"
+            } else {
+                "failure_handler"
+            },
+            (error, trace, start, end),
+        )?;
+        Ok(asynchronous.then(|| value.unbind()))
+    }
+    fn submit_success(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()> {
+        if !self.callbacks_needed(py, "sync_success")? {
+            return self.success_bookkeeping(py, response, start, end, false);
+        }
+        let context = py.import("contextvars")?.call_method0("copy_context")?;
+        py.import("litellm.litellm_core_utils.litellm_logging")?
+            .getattr("executor")?
+            .call_method1(
+                "submit",
+                (
+                    context.getattr("run")?,
+                    self.object(py).getattr("success_handler")?,
+                    response,
+                    start,
+                    end,
+                ),
+            )?;
+        Ok(())
+    }
+
+    fn enqueue_success(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+    ) -> PyResult<()> {
+        if !self.callbacks_needed(py, "async_success")? {
+            return self.success_bookkeeping(py, response, start, end, true);
+        }
+        let context = py.import("contextvars")?.call_method0("copy_context")?;
+        let worker = py
+            .import("litellm.litellm_core_utils.logging_worker")?
+            .getattr("GLOBAL_LOGGING_WORKER")?
+            .getattr("ensure_initialized_and_enqueue")?;
+        let coroutine = self
+            .object(py)
+            .call_method1("async_success_handler", (response, start, end))?;
+        let enqueue = context.call_method1("run", (worker, &coroutine));
+        if enqueue.is_err()
+            && let Err(error) = coroutine.call_method0("close")
+        {
+            error.write_unraisable(py, Some(&coroutine));
+        }
+        enqueue.map(|_| ())
+    }
+}
+
+fn custom_pricing_fields(py: Python<'_>) -> PyResult<Vec<String>> {
+    py.import("litellm.types.utils")?
+        .getattr("CustomPricingLiteLLMParams")?
+        .getattr("model_fields")?
+        .cast_into::<PyDict>()?
+        .keys()
+        .iter()
+        .map(|name| name.extract::<String>())
+        .collect()
+}
+
+fn redact(
+    py: Python<'_>,
+    params: &Bound<'_, PyDict>,
+    secret_fields: &[&str],
+) -> PyResult<Py<PyDict>> {
+    let redacted = PyDict::new(py);
+    for (name, value) in params {
+        let name = name.extract::<String>()?;
+        if name == "proxy_server_request" {
+            continue;
+        }
+        if secret_fields.contains(&name.as_str()) {
+            redacted.set_item(name, "****")?;
+        } else {
+            redacted.set_item(name, value)?;
+        }
+    }
+    Ok(redacted.unbind())
+}
+
+/// Proxy-internal calls skip the legacy success fan-out.
+pub fn is_internal_call(py: Python<'_>) -> PyResult<bool> {
+    py.import("litellm._internal_context")?
+        .getattr("is_internal_call")?
+        .call_method0("get")?
+        .extract()
+}
+
+#[cfg(test)]
+mod tests {
+    use pyo3::types::PyDict;
+
+    use super::*;
+
+    fn logger_whose_registries_need_no_input(py: Python<'_>, bridge_owned: bool) -> PythonLogger {
+        let locals = PyDict::new(py);
+        py.run(
+            c"
+import sys
+import types
+for name in ('litellm', 'litellm.rust_bridge', 'litellm.rust_bridge.legacy_callbacks'):
+    sys.modules.setdefault(name, types.ModuleType(name))
+legacy = sys.modules['litellm.rust_bridge.legacy_callbacks']
+legacy.callbacks_needed = lambda logger, phase: logger.needed.get(phase, True)
+class Logger:
+    needed = {'input': False}
+logger = Logger()
+",
+            Some(&locals),
+            Some(&locals),
+        )
+        .unwrap();
+        PythonLogger::new(
+            locals.get_item("logger").unwrap().unwrap().unbind(),
+            bridge_owned,
+        )
+    }
+
+    #[test]
+    fn a_caller_owned_logger_is_observed_in_full() {
+        Python::initialize();
+        Python::attach(|py| {
+            let logger = logger_whose_registries_need_no_input(py, false);
+            assert!(logger.callbacks_needed(py, "input").unwrap());
+        });
+    }
+
+    #[test]
+    fn a_bridge_owned_logger_is_elided_where_no_registry_needs_it() {
+        Python::initialize();
+        Python::attach(|py| {
+            let logger = logger_whose_registries_need_no_input(py, true);
+            assert!(!logger.callbacks_needed(py, "input").unwrap());
+            assert!(logger.callbacks_needed(py, "payload").unwrap());
+        });
+    }
+}

litellm-rust/crates/callbacks-legacy/src/deferred.rs

@@ -0,0 +1,67 @@
+//! The proxy's deferred success release: the async success handler is queued only once
+//! the proxy accepts the response, and at most once.
+
+use pyo3::{exceptions::PyException, prelude::*};
+
+use crate::{LegacyCallbacks, PythonLogger};
+
+pub(crate) struct PendingSuccess {
+    pub(crate) logger: PythonLogger,
+    pub(crate) response: Option<Py<PyAny>>,
+    pub(crate) start: Py<PyAny>,
+    pub(crate) end: Option<Py<PyAny>>,
+}
+
+impl PendingSuccess {
+    pub(crate) fn sync(&self, py: Python<'_>) -> PyResult<()> {
+        self.logger
+            .submit_success(py, &self.response, &self.start, &self.end)
+    }
+
+    pub(crate) fn asynchronous(&self, py: Python<'_>) -> PyResult<()> {
+        self.logger
+            .enqueue_success(py, &self.response, &self.start, &self.end)
+    }
+}
+
+#[pyclass]
+pub(crate) struct PendingLogging {
+    pub(crate) pending: Option<PendingSuccess>,
+}
+
+#[pymethods]
+impl PendingLogging {
+    fn release(slf: &Bound<'_, Self>, py: Python<'_>, success: bool) -> PyResult<()> {
+        let pending = slf.borrow_mut().pending.take();
+        if let Some(pending) = pending
+            && success
+        {
+            match pending.asynchronous(py) {
+                Err(error) if error.is_instance_of::<PyException>(py) => {
+                    error.write_unraisable(py, Some(pending.logger.object(py)));
+                }
+                result => return result,
+            }
+        }
+        Ok(())
+    }
+
+    fn __traverse__(&self, visit: pyo3::gc::PyVisit<'_>) -> Result<(), pyo3::gc::PyTraverseError> {
+        if let Some(pending) = &self.pending {
+            pending.logger.traverse(&visit)?;
+            visit.call(&pending.response)?;
+            visit.call(&pending.start)?;
+            visit.call(&pending.end)?;
+        }
+        Ok(())
+    }
+
+    fn __clear__(slf: &Bound<'_, Self>) {
+        let pending = slf.borrow_mut().pending.take();
+        drop(pending);
+    }
+}
+
+#[cfg(test)]
+#[path = "../tests/deferred.rs"]
+mod tests;

litellm-rust/crates/callbacks-legacy/src/lib.rs

@@ -0,0 +1,27 @@
+//! The legacy `@client` wrapper as the native call sees it: litellm's `Logging` object, the
+//! sync and async callback registries it fans out to, the deployment hooks, the deferred
+//! proxy release, and the kwargs rewrites the wrapper makes on the way in (credential-name
+//! inheritance, budget and retry-count limits). All of it sits behind one
+//! [`CallbackAdapter`](litellm_host_python::CallbackAdapter), so the driver, the routes and
+//! core never learn which Python object is on the other end.
+//!
+//! Legacy callbacks receive the caller's own objects and may mutate them. [`PublicCall`]
+//! is where those objects live, and [`run_legacy_call`] is how a route hands them over
+//! without keeping a copy.
+
+mod adapter;
+mod call;
+mod callbacks;
+mod deferred;
+mod logger;
+mod preparation;
+#[cfg(test)]
+#[path = "../tests/support.rs"]
+mod test_support;
+
+pub(crate) use adapter::LegacyLogging;
+pub use adapter::LegacySurface;
+pub use call::{PublicCall, lookup, run_legacy_call};
+pub(crate) use callbacks::{LegacyCallbacks, is_internal_call};
+pub(crate) use logger::{DeploymentHooks, PythonLogger, finalize, setup};
+pub(crate) use preparation::prepare;

litellm-rust/crates/callbacks-legacy/src/logger.rs

@@ -0,0 +1,236 @@
+use pyo3::{
+    exceptions::PyBaseException,
+    gc::{PyTraverseError, PyVisit},
+    prelude::*,
+    types::{PyDict, PyTuple},
+};
+
+/// The `Logging` instance one call fans out through, and who owns it. A logger the caller
+/// handed in is observed in full, because the caller reads it after the call; one this
+/// crate built through `function_setup` is elided wherever no registry needs it.
+pub struct PythonLogger {
+    object: Py<PyAny>,
+    bridge_owned: bool,
+}
+
+impl PythonLogger {
+    pub(crate) fn new(object: Py<PyAny>, bridge_owned: bool) -> Self {
+        Self {
+            object,
+            bridge_owned,
+        }
+    }
+
+    pub(crate) fn object<'py>(&self, py: Python<'py>) -> &Bound<'py, PyAny> {
+        self.object.bind(py)
+    }
+
+    pub(crate) fn bridge_owned(&self) -> bool {
+        self.bridge_owned
+    }
+
+    pub fn clone_ref(&self, py: Python<'_>) -> Self {
+        Self {
+            object: self.object.clone_ref(py),
+            bridge_owned: self.bridge_owned,
+        }
+    }
+
+    pub fn traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        visit.call(&self.object)
+    }
+
+    pub fn success_bookkeeping(
+        &self,
+        py: Python<'_>,
+        response: &Option<Py<PyAny>>,
+        start: &Py<PyAny>,
+        end: &Option<Py<PyAny>>,
+        asynchronous: bool,
+    ) -> PyResult<()> {
+        py.import("litellm.rust_bridge.legacy_callbacks")?
+            .getattr("success_bookkeeping")?
+            .call1((self.object(py), response, start, end, asynchronous))?;
+        Ok(())
+    }
+
+    pub fn restore_context(&self, py: Python<'_>) -> PyResult<()> {
+        py.import("litellm.utils")?
+            .getattr("_restore_correlation_context_if_supported")?
+            .call1((self.object(py),))?;
+        Ok(())
+    }
+}
+
+/// A bare Python object was not obtained from `setup`, so it is caller-owned.
+impl FromPyObject<'_, '_> for PythonLogger {
+    type Error = PyErr;
+
+    fn extract(object: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+        Ok(Self::new(object.to_owned().unbind(), false))
+    }
+}
+
+pub struct SetupResult<'py>(Bound<'py, PyAny>);
+
+impl SetupResult<'_> {
+    pub fn logger(&self) -> PyResult<PythonLogger> {
+        let object = self.0.getattr("logger")?.unbind();
+        let bridge_owned = self.0.getattr("bridge_owned")?.extract()?;
+        Ok(PythonLogger::new(object, bridge_owned))
+    }
+
+    pub fn kwargs(&self) -> PyResult<Py<PyDict>> {
+        Ok(self.0.getattr("kwargs")?.extract()?)
+    }
+}
+
+pub fn setup<'py>(
+    py: Python<'py>,
+    call_type: &str,
+    args: &Py<PyTuple>,
+    kwargs: &Py<PyDict>,
+    start: &Py<PyAny>,
+    asynchronous: bool,
+) -> PyResult<SetupResult<'py>> {
+    py.import("litellm.rust_bridge.legacy_callbacks")?
+        .getattr("setup")?
+        .call1((call_type, args, kwargs, start, asynchronous))
+        .map(SetupResult)
+}
+
+pub fn finalize(
+    py: Python<'_>,
+    response: &Option<Py<PyAny>>,
+    logger: &PythonLogger,
+    kwargs: &Py<PyDict>,
+    start: &Py<PyAny>,
+    end: &Option<Py<PyAny>>,
+) -> PyResult<()> {
+    py.import("litellm.rust_bridge.legacy_callbacks")?
+        .getattr("finalize")?
+        .call1((response, logger.object(py), kwargs, start, end))?;
+    Ok(())
+}
+
+pub struct DeploymentHooks;
+
+impl DeploymentHooks {
+    pub fn needed(py: Python<'_>) -> PyResult<bool> {
+        py.import("litellm.rust_bridge.legacy_callbacks")?
+            .getattr("deployment_callbacks_needed")?
+            .call0()?
+            .extract()
+    }
+
+    pub fn before_call(
+        py: Python<'_>,
+        kwargs: &Py<PyDict>,
+        call_type: &str,
+    ) -> PyResult<Py<PyAny>> {
+        py.import("litellm.utils")?
+            .getattr("async_pre_call_deployment_hook")?
+            .call1((kwargs, call_type))
+            .map(Bound::unbind)
+    }
+
+    pub fn after_success(
+        py: Python<'_>,
+        kwargs: &Py<PyDict>,
+        response: &Option<Py<PyAny>>,
+        call_type: &str,
+    ) -> PyResult<Py<PyAny>> {
+        py.import("litellm.utils")?
+            .getattr("async_post_call_success_deployment_hook")?
+            .call1((kwargs, response, call_type))
+            .map(Bound::unbind)
+    }
+
+    pub fn after_failure(
+        py: Python<'_>,
+        kwargs: &Py<PyDict>,
+        error: &Py<PyBaseException>,
+        call_type: &str,
+    ) -> PyResult<Py<PyAny>> {
+        py.import("litellm.utils")?
+            .getattr("async_post_call_failure_deployment_hook")?
+            .call1((kwargs, error, call_type))
+            .map(Bound::unbind)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pyo3::exceptions::PyTypeError;
+
+    use super::*;
+
+    #[test]
+    fn setup_fields_are_checked_lazily() {
+        Python::initialize();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(
+                pyo3::ffi::c_str!(
+                    r#"
+reads = []
+class Logger:
+    def __getattribute__(self, name):
+        reads.append(name)
+        raise AssertionError('logger methods must remain lazy')
+logger = Logger()
+class Setup:
+    @property
+    def logger(self):
+        reads.append('logger')
+        return logger
+    @property
+    def bridge_owned(self):
+        reads.append('bridge_owned')
+        return True
+    @property
+    def kwargs(self):
+        reads.append('kwargs')
+        return []
+result = Setup()
+"#
+                ),
+                Some(&locals),
+                Some(&locals),
+            )
+            .unwrap();
+            let result = SetupResult(locals.get_item("result").unwrap().unwrap());
+            let logger = result.logger().unwrap();
+            assert!(
+                logger
+                    .object(py)
+                    .is(locals.get_item("logger").unwrap().unwrap())
+            );
+            assert!(logger.bridge_owned());
+            assert!(
+                result
+                    .kwargs()
+                    .unwrap_err()
+                    .is_instance_of::<PyTypeError>(py)
+            );
+            assert_eq!(
+                locals
+                    .get_item("reads")
+                    .unwrap()
+                    .unwrap()
+                    .extract::<Vec<String>>()
+                    .unwrap(),
+                ["logger", "bridge_owned", "kwargs"]
+            );
+        });
+    }
+
+    #[test]
+    fn a_logger_extracted_from_a_bare_object_is_caller_owned() {
+        Python::initialize();
+        Python::attach(|py| {
+            let logger: PythonLogger = py.None().into_bound(py).extract().unwrap();
+            assert!(!logger.bridge_owned());
+        });
+    }
+}

litellm-rust/crates/callbacks-legacy/src/preparation.rs

@@ -1,6 +1,7 @@
-use litellm_auth::{credential_default_fields, credential_index};
-use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList};
+use pyo3::{
+    prelude::*,
+    types::{PyDict, PyList},
+};
 
 struct CredentialEntry<'py>(Bound<'py, PyAny>);
 
@@ -14,16 +15,16 @@ impl<'py> CredentialEntry<'py> {
     }
 }
 
-pub(super) fn prepare<'py>(
+pub fn prepare<'py>(
     py: Python<'py>,
     kwargs: &Bound<'py, PyDict>,
-    logger: &super::PythonLogger,
+    logger: &crate::PythonLogger,
 ) -> PyResult<Bound<'py, PyDict>> {
     let arguments = kwargs.copy()?;
     arguments.set_item("litellm_logging_obj", logger.object(py))?;
     let litellm = py.import("litellm")?;
     inherit_credentials(py, &litellm, &arguments)?;
-    py.import("litellm.rust_bridge.lifecycle")?
+    py.import("litellm.rust_bridge.legacy_callbacks")?
         .getattr("check_limits")?
         .call1((&arguments,))?;
     Ok(arguments)
@@ -49,7 +50,7 @@ fn inherit_credentials(
         .iter()
         .map(|credential| CredentialEntry(credential).name())
         .collect::<PyResult<Vec<_>>>()?;
-    let Some(index) = credential_index(&requested, &names) else {
+    let Some(index) = names.iter().position(|name| *name == requested) else {
         py.import("litellm._logging")?.getattr("verbose_logger")?.call_method1(
             "warning",
             ("litellm_credential_name=%s matched none of the %d loaded credentials; the request runs without it", requested, names.len()),
@@ -60,9 +61,9 @@ fn inherit_credentials(
     let values = selected.values()?;
     let supplied: Vec<String> = arguments.keys().extract()?;
     let fields: Vec<String> = values.keys().extract()?;
-    for name in credential_default_fields(&supplied, &fields) {
-        if let Some(value) = values.get_item(name)? {
-            arguments.set_item(name, value)?;
+    for name in fields.iter().filter(|name| !supplied.contains(name)) {
+        if let Some(value) = values.get_item(name.as_str())? {
+            arguments.set_item(name.as_str(), value)?;
         }
     }
     Ok(())

litellm-rust/crates/callbacks-legacy/tests/deferred.rs

@@ -0,0 +1,162 @@
+use std::ffi::CStr;
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use rstest::rstest;
+
+use super::{PendingLogging, PendingSuccess};
+use crate::PythonLogger;
+use crate::test_support::{local, namespace, run};
+
+/// A deferred success for the namespace's `logger` and `response`, bound as `pending`.
+fn defer<'py>(py: Python<'py>, script: &CStr) -> Bound<'py, PyDict> {
+    let locals = namespace(py, c"response = object()");
+    run(py, &locals, script);
+    let pending = Py::new(
+        py,
+        PendingLogging {
+            pending: Some(PendingSuccess {
+                logger: PythonLogger::new(local(&locals, "logger").unbind(), true),
+                response: Some(local(&locals, "response").unbind()),
+                start: py.None(),
+                end: Some(py.None()),
+            }),
+        },
+    )
+    .unwrap();
+    locals.set_item("pending", pending).unwrap();
+    locals
+}
+
+#[test]
+fn release_enqueues_the_success_once_in_the_releasing_context() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = defer(
+            py,
+            c"
+from contextvars import ContextVar
+
+marker = ContextVar('marker', default='unset')
+observed = []
+
+def on_enqueue(coroutine):
+    observed.append(marker.get())
+    pending.release(True)
+
+logger.on_enqueue = on_enqueue
+",
+        );
+        run(
+            py,
+            &locals,
+            c"
+marker.set('release')
+pending.release(True)
+pending.release(True)
+assert observed == ['release'], observed
+assert logger.names() == ['async_success_handler', 'enqueued'], logger.calls
+assert logger.calls[0][1] is response
+",
+        );
+    });
+}
+
+#[test]
+fn a_blocked_release_drops_the_success_for_good() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = defer(py, c"");
+        run(
+            py,
+            &locals,
+            c"
+pending.release(False)
+pending.release(True)
+assert logger.calls == [], logger.calls
+",
+        );
+    });
+}
+
+#[test]
+fn a_release_after_the_async_callbacks_went_away_only_keeps_the_books() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = defer(py, c"logger.needed = {'async_success': False}");
+        run(
+            py,
+            &locals,
+            c"
+pending.release(True)
+assert logger.calls == [('success_bookkeeping', True)], logger.calls
+",
+        );
+    });
+}
+
+#[rstest]
+#[case::ordinary_error(c"RuntimeError('queue full')", false)]
+#[case::cancellation(c"asyncio.CancelledError()", true)]
+fn a_failed_enqueue_closes_the_coroutine_and_is_never_replayed(
+    #[case] failure: &CStr,
+    #[case] propagates: bool,
+) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = defer(
+            py,
+            c"
+import asyncio
+
+def on_enqueue(coroutine):
+    raise failure
+
+logger.on_enqueue = on_enqueue
+",
+        );
+        locals
+            .set_item("failure", py.eval(failure, None, Some(&locals)).unwrap())
+            .unwrap();
+        let released = local(&locals, "pending").call_method1("release", (true,));
+        match released {
+            Ok(_) => assert!(!propagates),
+            Err(error) => {
+                assert!(propagates);
+                assert!(error.value(py).is(local(&locals, "failure")));
+            }
+        }
+        locals.set_item("propagates", propagates).unwrap();
+        run(
+            py,
+            &locals,
+            c"
+pending.release(True)
+assert logger.names() == ['async_success_handler', 'enqueued', 'closed'], logger.calls
+assert unraisable_from(logger) == ([] if propagates else [failure])
+",
+        );
+    });
+}
+
+#[test]
+fn an_unreleased_success_does_not_keep_its_logger_alive() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = defer(py, c"");
+        run(
+            py,
+            &locals,
+            c"
+import gc
+import weakref
+
+logger.pending = pending
+reference = weakref.ref(logger)
+del logger, pending
+gc.collect()
+assert reference() is None
+",
+        );
+    });
+}

litellm-rust/crates/callbacks-legacy/tests/deployment_hooks.rs

@@ -0,0 +1,246 @@
+use std::ffi::CStr;
+
+use litellm_callbacks::event::{CallEvent, FailureOrigin, Timing};
+use litellm_host_python::{AdapterStep, CallbackAdapter, PublicValue};
+use pyo3::exceptions::asyncio::CancelledError;
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use rstest::rstest;
+
+use super::LegacyLogging;
+use crate::test_support::{legacy_call, local, namespace, run};
+
+const CALL: &CStr = c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+kwargs = {'logger': logger, 'document': document}
+";
+
+const TIMING: Timing = Timing {
+    start_time: 0.0,
+    end_time: 1.0,
+};
+
+fn begin<'py>(
+    py: Python<'py>,
+    locals: &Bound<'py, PyDict>,
+    asynchronous: bool,
+) -> (LegacyLogging, AdapterStep) {
+    let mut logging = legacy_call(py, locals, asynchronous);
+    let kwargs = local(locals, "kwargs")
+        .cast_into::<PyDict>()
+        .unwrap()
+        .unbind();
+    let step = logging.begin(py, kwargs, 0.0).unwrap();
+    (logging, step)
+}
+
+fn arguments<'py>(py: Python<'py>, step: AdapterStep) -> Bound<'py, PyDict> {
+    let AdapterStep::Arguments(arguments) = step else {
+        panic!("expected the prepared arguments");
+    };
+    arguments.into_bound(py)
+}
+
+fn awaits_deployment_hook(step: &AdapterStep) -> bool {
+    matches!(step, AdapterStep::Await(_))
+}
+
+#[rstest]
+#[case::synchronous(false)]
+#[case::asynchronous(true)]
+fn deployment_pre_call_hook_runs_only_for_asynchronous_calls(#[case] asynchronous: bool) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, CALL);
+        let (_, step) = begin(py, &locals, asynchronous);
+        assert_eq!(awaits_deployment_hook(&step), asynchronous);
+        let names: Vec<String> = local(&locals, "logger")
+            .call_method0("names")
+            .unwrap()
+            .extract()
+            .unwrap();
+        assert_eq!(names.contains(&"pre_hook".to_string()), asynchronous);
+    });
+}
+
+#[test]
+fn kwargs_returned_by_the_pre_call_hook_are_what_the_call_prepares() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+replacement = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,ZWRpdGVk'}
+kwargs = {'logger': logger, 'document': document}
+replaced_kwargs = {'logger': logger, 'document': replacement, 'pages': [0]}
+",
+        );
+        let (mut logging, step) = begin(py, &locals, true);
+        assert!(awaits_deployment_hook(&step));
+        let step = logging
+            .resume(py, Ok(local(&locals, "replaced_kwargs").unbind()))
+            .unwrap();
+        locals.set_item("prepared", arguments(py, step)).unwrap();
+        run(
+            py,
+            &locals,
+            c"
+assert prepared['document'] is replacement
+assert prepared['pages'] is replaced_kwargs['pages']
+assert prepared['litellm_logging_obj'] is logger
+assert 'litellm_logging_obj' not in replaced_kwargs
+[checked] = [value for name, value in logger.calls if name == 'check_limits']
+assert checked is prepared
+",
+        );
+    });
+}
+
+#[test]
+fn response_returned_by_the_post_call_hook_is_finalized_and_returned() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"
+kwargs = {'logger': logger}
+response = object()
+replacement = object()
+logger.hooks = {'pre': lambda kwargs: kwargs}
+",
+        );
+        let (mut logging, _) = begin(py, &locals, true);
+        logging
+            .resume(py, Ok(local(&locals, "kwargs").unbind()))
+            .unwrap();
+        let step = logging
+            .after_success(py, local(&locals, "response").unbind(), TIMING)
+            .unwrap();
+        assert!(awaits_deployment_hook(&step));
+        let step = logging
+            .resume(py, Ok(local(&locals, "replacement").unbind()))
+            .unwrap();
+        let AdapterStep::Response(returned) = step else {
+            panic!("expected the finalized response");
+        };
+        assert!(returned.bind(py).is(local(&locals, "replacement")));
+        run(
+            py,
+            &locals,
+            c"
+[finalized] = [value for name, value in logger.calls if name == 'finalize']
+assert finalized is replacement
+",
+        );
+    });
+}
+
+#[rstest]
+#[case::pre_call(false)]
+#[case::post_call(true)]
+fn cancelling_a_deployment_hook_ends_the_call_with_that_cancellation(#[case] post_call: bool) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"kwargs = {'logger': logger}\nresponse = object()");
+        let (mut logging, _) = begin(py, &locals, true);
+        if post_call {
+            logging
+                .resume(py, Ok(local(&locals, "kwargs").unbind()))
+                .unwrap();
+            logging
+                .after_success(py, local(&locals, "response").unbind(), TIMING)
+                .unwrap();
+        }
+        let cancellation = CancelledError::new_err("cancelled");
+        let cancelled = cancellation.value(py).clone();
+        let error = logging.resume(py, Err(cancellation)).err().unwrap();
+        assert!(error.value(py).is(&cancelled));
+        let names: Vec<String> = local(&locals, "logger")
+            .call_method0("names")
+            .unwrap()
+            .extract()
+            .unwrap();
+        assert!(!names.iter().any(|name| name.contains("handler")));
+    });
+}
+
+#[rstest]
+#[case::hook_completed(false)]
+#[case::hook_cancelled(true)]
+fn failure_callbacks_run_after_the_failure_hook_however_it_ends(#[case] cancelled: bool) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"kwargs = {'logger': logger}\nfailure = ValueError('provider')",
+        );
+        let (mut logging, _) = begin(py, &locals, true);
+        logging
+            .resume(py, Ok(local(&locals, "kwargs").unbind()))
+            .unwrap();
+        let failure = PyErr::from_value(local(&locals, "failure"));
+        let failed = CallEvent::Failed {
+            timing: TIMING,
+            origin: FailureOrigin::Call,
+        };
+        let step = logging
+            .emit(py, &failed, Some(PublicValue::Error(&failure)))
+            .unwrap();
+        assert!(awaits_deployment_hook(&step));
+        let hook_result = if cancelled {
+            Err(CancelledError::new_err("cancelled"))
+        } else {
+            Ok(py.None())
+        };
+        assert!(matches!(
+            logging.resume(py, hook_result).unwrap(),
+            AdapterStep::Await(_)
+        ));
+        run(
+            py,
+            &locals,
+            c"
+assert logger.names()[-3:] == ['failure_hook', 'failure_handler', 'async_failure_handler'], logger.calls
+assert all(value is failure for name, value in logger.calls if name.endswith('_handler'))
+",
+        );
+    });
+}
+
+#[rstest]
+#[case::synchronous(false)]
+#[case::asynchronous(true)]
+fn a_limit_rejected_before_the_call_surfaces_as_the_callers_error(#[case] asynchronous: bool) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"
+class BudgetExceeded(Exception):
+    pass
+
+rejection = BudgetExceeded('over budget')
+
+class LimitedLogger(StubLogger):
+    def check_limits(self, arguments):
+        raise rejection
+
+logger = LimitedLogger()
+logger.hooks = {'pre': lambda kwargs: kwargs}
+kwargs = {'logger': logger}
+",
+        );
+        let mut logging = legacy_call(py, &locals, asynchronous);
+        let kwargs = local(&locals, "kwargs")
+            .cast_into::<PyDict>()
+            .unwrap()
+            .unbind();
+        let result = logging.begin(py, kwargs, 0.0).and_then(|step| match step {
+            AdapterStep::Await(_) => logging.resume(py, Ok(local(&locals, "kwargs").unbind())),
+            step => Ok(step),
+        });
+        let error = result.err().unwrap();
+        assert!(error.value(py).is(local(&locals, "rejection")));
+    });
+}

litellm-rust/crates/callbacks-legacy/tests/payload.rs

@@ -0,0 +1,365 @@
+use std::ffi::CStr;
+
+use litellm_callbacks::event::{CallEvent, Passthrough, RawResponse, RequestContext, WireRequest};
+use litellm_host_python::{AdapterStep, CallbackAdapter};
+use pyo3::prelude::*;
+use rstest::rstest;
+use serde_json::{Value, json};
+
+use super::LegacyLogging;
+use crate::PythonLogger;
+use crate::test_support::{legacy_call, local, namespace, run};
+
+/// The payload phases of `Logging` on top of `StubLogger`, with `pre_call` handing the
+/// payload to the case's `on_pre_call`.
+const PAYLOAD_LOGGER: &CStr = c"
+class Request:
+    pass
+
+class PayloadLogger(StubLogger):
+    def update_from_kwargs(self, **update):
+        self.update = update
+
+    def pre_call(self, input, api_key, additional_args):
+        self.record('pre_call', None)
+        self.pre = additional_args
+        on_pre_call(additional_args)
+
+    def _pre_call(self, input, api_key, additional_args):
+        self.record('_pre_call', None)
+
+    def record_api_call_start_time(self):
+        self.record('record_api_call_start_time', None)
+
+    def post_call(self, original_response, additional_args):
+        self.record('post_call', None)
+        self.post = (original_response, additional_args)
+
+    def record_post_call(self, response, *rest):
+        self.record('record_post_call', response)
+
+request = Request()
+kwargs = {}
+logger = PayloadLogger()
+on_pre_call = lambda additional_args: None
+check = lambda: None
+";
+
+const DOCUMENT: &str = "data:application/pdf;base64,YWJj";
+const EDITED: &str = "data:application/pdf;base64,ZWRpdGVk";
+
+fn document(source: &str) -> Value {
+    json!({"type": "document_url", "document_url": source})
+}
+
+fn before_send(script: &CStr, caller: Value, body: Value) -> WireRequest {
+    before_send_with_secrets(script, caller, body, &[])
+}
+
+/// Runs `before_send` over `body` for a caller whose route-side view is `caller`, with the
+/// Python objects `script` binds, then delivers the provider's raw response the way the
+/// driver does and runs the script's `check()`.
+fn before_send_with_secrets(
+    script: &CStr,
+    caller: Value,
+    body: Value,
+    secret_fields: &[&str],
+) -> WireRequest {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, PAYLOAD_LOGGER);
+        run(py, &locals, script);
+        let mut logging = LegacyLogging {
+            logger: Some(PythonLogger::new(local(&locals, "logger").unbind(), true)),
+            ..legacy_call(py, &locals, false)
+        };
+        let context = RequestContext {
+            model: "model".into(),
+            custom_llm_provider: "provider".into(),
+            optional_params: caller.clone(),
+            passthrough_fields: Passthrough::unchanged(caller.as_object().unwrap(), &body),
+            secret_fields: secret_fields.iter().map(|name| name.to_string()).collect(),
+        };
+        let wire = WireRequest {
+            url: "https://provider.invalid/ocr".into(),
+            headers: vec![("x-route".into(), "route".into())],
+            body,
+        };
+        let step = logging.before_send(py, Box::new(wire), &context).unwrap();
+        let raw = CallEvent::ResponseReceived {
+            raw: RawResponse {
+                body: "raw response".into(),
+            },
+        };
+        assert!(matches!(
+            logging.emit(py, &raw, None).unwrap(),
+            AdapterStep::Done
+        ));
+        run(py, &locals, c"check()");
+        let AdapterStep::Wire(wire) = step else {
+            panic!("before_send did not hand back the wire request");
+        };
+        *wire
+    })
+}
+
+#[rstest]
+#[case::caller_keyword(c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+pages = [0]
+kwargs = {'document': document, 'pages': pages}
+observed = []
+on_pre_call = lambda args: observed.append(
+    (args['complete_input_dict']['document'] is document, args['complete_input_dict']['pages'] is pages)
+)
+def check():
+    assert observed == [(True, True)], observed
+")]
+#[case::request_attribute_behind_an_omitted_keyword(c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+pages = [0]
+request.document = document
+kwargs = {'pages': pages}
+observed = []
+on_pre_call = lambda args: observed.append(
+    (args['complete_input_dict']['document'] is document, args['complete_input_dict']['pages'] is pages)
+)
+def check():
+    assert observed == [(True, True)], observed
+")]
+fn passthrough_keys_reach_pre_call_as_the_callers_own_objects(#[case] script: &CStr) {
+    let body = json!({"model": "model", "document": document(DOCUMENT), "pages": [0]});
+    let wire = before_send(
+        script,
+        json!({"document": document(DOCUMENT), "pages": [0]}),
+        body.clone(),
+    );
+    assert_eq!(wire.body, body);
+}
+
+#[test]
+fn pre_call_edit_of_a_passthrough_object_reaches_the_caller_and_the_wire() {
+    let wire = before_send(
+        c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+kwargs = {'document': document}
+def on_pre_call(args):
+    args['complete_input_dict']['document']['document_url'] = 'data:application/pdf;base64,ZWRpdGVk'
+def check():
+    assert document['document_url'] == 'data:application/pdf;base64,ZWRpdGVk'
+",
+        json!({"document": document(DOCUMENT)}),
+        json!({"document": document(DOCUMENT)}),
+    );
+    assert_eq!(wire.body["document"], document(EDITED));
+}
+
+#[test]
+fn a_body_key_the_route_rewrote_is_not_the_callers_object() {
+    let wire = before_send(
+        c"
+document = {'type': 'document_url', 'document_url': 'https://example.invalid/scan.pdf'}
+kwargs = {'document': document}
+observed = []
+def on_pre_call(args):
+    observed.append(args['complete_input_dict']['document'] is document)
+    args['complete_input_dict']['document']['document_name'] = 'edited.pdf'
+def check():
+    assert observed == [False], observed
+    assert document == {'type': 'document_url', 'document_url': 'https://example.invalid/scan.pdf'}
+",
+        json!({"document": document("https://example.invalid/scan.pdf")}),
+        json!({"document": document(DOCUMENT)}),
+    );
+    assert_eq!(
+        wire.body["document"],
+        json!({"type": "document_url", "document_url": DOCUMENT, "document_name": "edited.pdf"})
+    );
+}
+
+#[rstest]
+#[case::body(
+    c"
+def on_pre_call(args):
+    args['complete_input_dict'] = {'replacement': True}
+"
+)]
+#[case::headers(
+    c"
+def on_pre_call(args):
+    args['headers'] = {'x-replacement': 'yes'}
+"
+)]
+fn rebinding_the_payload_envelope_does_not_reach_the_wire(#[case] script: &CStr) {
+    let body = json!({"document": document(DOCUMENT)});
+    let wire = before_send(script, json!({}), body.clone());
+    assert_eq!(wire.body, body);
+    assert_eq!(wire.headers, [("x-route".to_string(), "route".to_string())]);
+}
+
+#[test]
+fn pre_call_header_edit_reaches_the_wire() {
+    let wire = before_send(
+        c"
+def on_pre_call(args):
+    args['headers']['x-callback'] = 'edited'
+",
+        json!({}),
+        json!({}),
+    );
+    assert_eq!(
+        wire.headers,
+        [
+            ("x-route".to_string(), "route".to_string()),
+            ("x-callback".to_string(), "edited".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn pre_call_receives_the_wire_request_and_the_logger_its_redacted_request() {
+    let body = json!({"model": "model", "document": document(DOCUMENT)});
+    before_send_with_secrets(
+        c"
+logger_fn = lambda *args: None
+kwargs = {
+    'litellm_call_id': 'call-1',
+    'client_secret': 'shh',
+    'proxy_server_request': {'body': {}},
+    'logger_fn': logger_fn,
+    'litellm_request_debug': True,
+    'ocr_cost_per_page': 0.05,
+}
+observed = []
+on_pre_call = observed.append
+def check():
+    [args] = observed
+    assert args['api_base'] == 'https://provider.invalid/ocr', args
+    assert args['complete_input_dict'] == {
+        'model': 'model',
+        'document': {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'},
+    }, args
+    update = logger.update
+    assert update['model'] == 'model' and update['custom_llm_provider'] == 'provider', update
+    assert update['litellm_params']['litellm_call_id'] == 'call-1', update
+    assert update['litellm_params']['api_base'] == 'https://provider.invalid/ocr', update
+    assert update['litellm_params']['logger_fn'] is logger_fn, update
+    assert update['litellm_params']['litellm_request_debug'] is True, update
+    assert update['litellm_params']['ocr_cost_per_page'] == 0.05, update
+    assert update['kwargs']['client_secret'] == '****', update
+    assert 'proxy_server_request' not in update['kwargs'], update
+    assert update['optional_params']['client_secret'] == '****', update
+",
+        json!({"client_secret": "shh"}),
+        body,
+        &["client_secret"],
+    );
+}
+
+#[rstest]
+#[case::added_key(
+    c"
+def on_pre_call(args):
+    args['complete_input_dict']['include_image_base64'] = True
+",
+    json!({"document": document(DOCUMENT), "include_image_base64": true})
+)]
+#[case::replaced_document(
+    c"
+document = {'type': 'document_url', 'document_url': 'data:application/pdf;base64,YWJj'}
+kwargs = {'document': document}
+def on_pre_call(args):
+    args['complete_input_dict']['document'] = {
+        'type': 'document_url', 'document_url': 'data:application/pdf;base64,ZWRpdGVk'
+    }
+def check():
+    assert document['document_url'] == 'data:application/pdf;base64,YWJj', document
+",
+    json!({"document": document(EDITED)})
+)]
+#[case::retained_body_edited_after_rebinding(
+    c"
+def on_pre_call(args):
+    retained = args['complete_input_dict']
+    args['complete_input_dict'] = {'rebound': True}
+    retained['include_image_base64'] = True
+",
+    json!({"document": document(DOCUMENT), "include_image_base64": true})
+)]
+fn pre_call_body_edits_reach_the_wire(#[case] script: &CStr, #[case] expected: Value) {
+    let body = json!({"document": document(DOCUMENT)});
+    let wire = before_send(script, json!({"document": document(DOCUMENT)}), body);
+    assert_eq!(wire.body, expected);
+}
+
+#[test]
+fn retained_headers_edited_after_rebinding_reach_the_wire() {
+    let wire = before_send(
+        c"
+def on_pre_call(args):
+    retained = args['headers']
+    args['headers'] = {'x-rebound': 'rebound'}
+    retained['x-retained'] = 'sent'
+",
+        json!({}),
+        json!({}),
+    );
+    assert_eq!(
+        wire.headers,
+        [
+            ("x-route".to_string(), "route".to_string()),
+            ("x-retained".to_string(), "sent".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn post_call_receives_the_raw_response_and_the_payload_dicts_pre_call_saw() {
+    before_send(
+        c"
+def check():
+    original_response, additional_args = logger.post
+    assert original_response == 'raw response', original_response
+    assert additional_args['complete_input_dict'] is logger.pre['complete_input_dict']
+    assert additional_args['headers'] is logger.pre['headers']
+",
+        json!({}),
+        json!({"document": document(DOCUMENT)}),
+    );
+}
+
+#[rstest]
+#[case::every_phase_listens(c"{}", &["pre_call", "post_call"])]
+#[case::no_input_callback(
+    c"{'input': False}",
+    &["_pre_call", "record_api_call_start_time", "record_post_call"]
+)]
+#[case::no_payload_consumer(c"{'payload': False}", &["record_api_call_start_time"])]
+fn payload_callbacks_run_only_for_the_phases_someone_listens_to(
+    #[case] needed: &CStr,
+    #[case] expected_calls: &[&str],
+) {
+    let script = std::ffi::CString::new(format!(
+        "
+logger.needed = {needed}
+def on_pre_call(args):
+    args['complete_input_dict']['include_image_base64'] = True
+def check():
+    assert logger.names() == {expected_calls:?}, logger.calls
+",
+        needed = needed.to_str().unwrap(),
+        expected_calls = expected_calls,
+    ))
+    .unwrap();
+    let body = json!({"document": document(DOCUMENT)});
+    let wire = before_send(&script, json!({}), body.clone());
+    let edited = json!({"document": document(DOCUMENT), "include_image_base64": true});
+    assert_eq!(
+        wire.body,
+        if expected_calls.contains(&"pre_call") {
+            edited
+        } else {
+            body
+        }
+    );
+}

litellm-rust/crates/callbacks-legacy/tests/support.rs

@@ -0,0 +1,188 @@
+use std::ffi::CStr;
+
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyTuple};
+
+use crate::{LegacyLogging, LegacySurface, PublicCall};
+
+/// Stand-ins for every litellm function the legacy contract calls. Tests share one
+/// interpreter and run concurrently, so each stub is installed idempotently and forwards to
+/// the per-test `StubLogger` it is handed (directly, or as `kwargs['logger']`).
+const STUBS: &CStr = c"
+import contextvars
+import sys
+import types
+
+for name in (
+    'litellm',
+    'litellm.utils',
+    'litellm.types',
+    'litellm.types.utils',
+    'litellm._internal_context',
+    'litellm.litellm_core_utils',
+    'litellm.litellm_core_utils.logging_worker',
+    'litellm.litellm_core_utils.litellm_logging',
+    'litellm.rust_bridge',
+    'litellm.rust_bridge.legacy_callbacks',
+):
+    sys.modules.setdefault(name, types.ModuleType(name))
+
+legacy = sys.modules['litellm.rust_bridge.legacy_callbacks']
+legacy.setup = lambda call_type, args, kwargs, start, asynchronous: types.SimpleNamespace(
+    logger=kwargs['logger_factory'](kwargs) if 'logger_factory' in kwargs else kwargs['logger'],
+    kwargs=kwargs,
+    bridge_owned=True,
+)
+legacy.deployment_callbacks_needed = lambda: True
+legacy.check_limits = lambda arguments: arguments['logger'].check_limits(arguments)
+legacy.callbacks_needed = lambda logger, phase: logger.needed.get(phase, True)
+legacy.success_bookkeeping = lambda logger, response, start, end, asynchronous: logger.record(
+    'success_bookkeeping', asynchronous
+)
+legacy.failure_bookkeeping = lambda logger, error, start, end, asynchronous: logger.record(
+    'failure_bookkeeping', asynchronous
+)
+legacy.finalize = lambda response, logger, kwargs, start, end: logger.record('finalize', response)
+
+utils = sys.modules['litellm.utils']
+utils.async_pre_call_deployment_hook = lambda kwargs, call_type: kwargs['logger'].hook(
+    'pre', kwargs, call_type
+)
+utils.async_post_call_success_deployment_hook = lambda kwargs, response, call_type: kwargs[
+    'logger'
+].hook('success', response, call_type)
+utils.async_post_call_failure_deployment_hook = lambda kwargs, error, call_type: kwargs[
+    'logger'
+].hook('failure', error, call_type)
+utils._restore_correlation_context_if_supported = lambda logger: logger.record('restore', None)
+
+internal = sys.modules['litellm._internal_context']
+if not hasattr(internal, 'is_internal_call'):
+    internal.is_internal_call = contextvars.ContextVar('is_internal_call', default=False)
+
+sys.modules['litellm.types.utils'].CustomPricingLiteLLMParams = type(
+    'CustomPricingLiteLLMParams', (), {'model_fields': {'ocr_cost_per_page': None}}
+)
+
+
+unraisable = sys.modules.setdefault(
+    'litellm_test_unraisable', types.ModuleType('litellm_test_unraisable')
+)
+if not hasattr(unraisable, 'events'):
+    unraisable.events = []
+    sys.unraisablehook = lambda event: unraisable.events.append((event.object, event.exc_value))
+
+
+def unraisable_from(owner):
+    return [error for source, error in unraisable.events if source is owner]
+
+
+class Worker:
+    def ensure_initialized_and_enqueue(self, coroutine):
+        return coroutine.enqueue()
+
+
+class Executor:
+    def submit(self, run, handler, *args):
+        handler.__self__.record('submit', args)
+
+
+sys.modules['litellm.litellm_core_utils.logging_worker'].GLOBAL_LOGGING_WORKER = Worker()
+sys.modules['litellm.litellm_core_utils.litellm_logging'].executor = Executor()
+
+
+class StubCoroutine:
+    def __init__(self, logger):
+        self.logger = logger
+
+    def enqueue(self):
+        self.logger.record('enqueued', None)
+        self.logger.on_enqueue(self)
+
+    def close(self):
+        self.logger.record('closed', None)
+
+
+class StubLogger:
+    def __init__(self):
+        self.calls = []
+        self.needed = {}
+        self.hooks = {}
+        self.on_enqueue = lambda coroutine: None
+
+    def record(self, name, value):
+        self.calls.append((name, value))
+
+    def names(self):
+        return [name for name, _ in self.calls]
+
+    def hook(self, phase, value, call_type):
+        self.record(phase + '_hook', call_type)
+        return self.hooks.get(phase, lambda value: 'awaitable')(value)
+
+    def check_limits(self, arguments):
+        self.record('check_limits', arguments)
+
+    def failure_handler(self, error, trace, start, end):
+        self.record('failure_handler', error)
+
+    def async_failure_handler(self, error, trace, start, end):
+        self.record('async_failure_handler', error)
+        return 'awaitable'
+
+    def success_handler(self, response, start, end):
+        self.record('success_handler', response)
+
+    def async_success_handler(self, response, start, end):
+        self.record('async_success_handler', response)
+        return StubCoroutine(self)
+
+    def handle_sync_success_callbacks_for_async_calls(self, response, start, end):
+        self.record('sync_success_for_async_call', response)
+
+
+logger = StubLogger()
+";
+
+/// A namespace with the stubs, `StubLogger` and a fresh `logger`, after `script` ran in it.
+pub(crate) fn namespace<'py>(py: Python<'py>, script: &CStr) -> Bound<'py, PyDict> {
+    let locals = PyDict::new(py);
+    py.run(STUBS, Some(&locals), Some(&locals)).unwrap();
+    py.run(script, Some(&locals), Some(&locals)).unwrap();
+    locals
+}
+
+pub(crate) fn run(py: Python<'_>, locals: &Bound<'_, PyDict>, code: &CStr) {
+    py.run(code, Some(locals), Some(locals)).unwrap();
+}
+
+pub(crate) fn local<'py>(locals: &Bound<'py, PyDict>, name: &str) -> Bound<'py, PyAny> {
+    locals.get_item(name).unwrap().unwrap()
+}
+
+/// A legacy call over the namespace's `kwargs` (or none) and `request` (or `None`).
+pub(crate) fn legacy_call(
+    py: Python<'_>,
+    locals: &Bound<'_, PyDict>,
+    asynchronous: bool,
+) -> LegacyLogging {
+    let request = locals
+        .get_item("request")
+        .unwrap()
+        .unwrap_or_else(|| py.None().into_bound(py));
+    let kwargs = locals
+        .get_item("kwargs")
+        .unwrap()
+        .map(|kwargs| kwargs.cast_into::<PyDict>().unwrap())
+        .unwrap_or_else(|| PyDict::new(py));
+    let call = PublicCall::capture(&request, &PyTuple::empty(py), &kwargs).unwrap();
+    LegacyLogging::new(
+        py,
+        LegacySurface {
+            call_type: "test",
+            input_description: "test input",
+        },
+        call,
+        asynchronous,
+    )
+}

litellm-rust/crates/callbacks-legacy/tests/terminal.rs

@@ -0,0 +1,291 @@
+use std::ffi::CStr;
+
+use litellm_callbacks::event::{CallEvent, FailureOrigin, Timing};
+use litellm_host_python::{AdapterStep, CallbackAdapter, PublicValue};
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::exceptions::asyncio::CancelledError;
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use rstest::rstest;
+
+use super::LegacyLogging;
+use crate::PythonLogger;
+use crate::test_support::{legacy_call, local, namespace, run};
+
+const TIMING: Timing = Timing {
+    start_time: 0.0,
+    end_time: 1.0,
+};
+
+fn logged(py: Python<'_>, locals: &Bound<'_, PyDict>, asynchronous: bool) -> LegacyLogging {
+    LegacyLogging {
+        logger: Some(PythonLogger::new(local(locals, "logger").unbind(), true)),
+        ..legacy_call(py, locals, asynchronous)
+    }
+}
+
+fn succeed(py: Python<'_>, locals: &Bound<'_, PyDict>, logging: &mut LegacyLogging) -> AdapterStep {
+    let response = local(locals, "response").unbind();
+    logging
+        .emit(
+            py,
+            &CallEvent::Succeeded { timing: TIMING },
+            Some(PublicValue::Response(&response)),
+        )
+        .unwrap()
+}
+
+fn fail(py: Python<'_>, locals: &Bound<'_, PyDict>, logging: &mut LegacyLogging) -> AdapterStep {
+    let failure = PyErr::from_value(local(locals, "failure"));
+    logging
+        .emit(
+            py,
+            &CallEvent::Failed {
+                timing: TIMING,
+                origin: FailureOrigin::Host,
+            },
+            Some(PublicValue::Error(&failure)),
+        )
+        .unwrap()
+}
+
+#[rstest]
+#[case::sync_listened(false, c"", &["submit"])]
+#[case::sync_unlistened(false, c"logger.needed = {'sync_success': False}", &["success_bookkeeping"])]
+#[case::async_listened(
+    true,
+    c"",
+    &["async_success_handler", "enqueued", "sync_success_for_async_call"]
+)]
+#[case::async_unlistened(
+    true,
+    c"logger.needed = {'async_success': False, 'sync_success_async': False}",
+    &["success_bookkeeping"]
+)]
+#[case::async_deferred(true, c"logger._defer_async_logging = True", &["sync_success_for_async_call"])]
+#[case::async_with_fallbacks(true, c"kwargs = {'fallbacks': ['other']}", &["sync_success_for_async_call"])]
+fn success_reaches_only_the_callbacks_that_listen(
+    #[case] asynchronous: bool,
+    #[case] script: &CStr,
+    #[case] expected: &[&str],
+) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"response = object()");
+        run(py, &locals, script);
+        let mut logging = logged(py, &locals, asynchronous);
+        assert!(matches!(
+            succeed(py, &locals, &mut logging),
+            AdapterStep::Done
+        ));
+        let names: Vec<String> = local(&locals, "logger")
+            .call_method0("names")
+            .unwrap()
+            .extract()
+            .unwrap();
+        assert_eq!(names, expected);
+        run(
+            py,
+            &locals,
+            c"
+assert all(value is response for name, value in logger.calls if name.endswith('_handler'))
+assert hasattr(logger, '_native_pending_logging') == getattr(logger, '_defer_async_logging', False)
+",
+        );
+    });
+}
+
+#[rstest]
+#[case::synchronous(false, &["failure_handler"])]
+#[case::asynchronous(true, &[])]
+fn internal_calls_skip_failure_callbacks_only_when_asynchronous(
+    #[case] asynchronous: bool,
+    #[case] expected: &[&str],
+) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"failure = ValueError('provider')");
+        let mut logging = LegacyLogging {
+            internal: true,
+            ..logged(py, &locals, asynchronous)
+        };
+        assert!(matches!(fail(py, &locals, &mut logging), AdapterStep::Done));
+        let names: Vec<String> = local(&locals, "logger")
+            .call_method0("names")
+            .unwrap()
+            .extract()
+            .unwrap();
+        assert_eq!(names, expected);
+    });
+}
+
+#[test]
+fn internal_async_calls_skip_the_async_success_fan_out() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"response = object()");
+        let mut logging = LegacyLogging {
+            internal: true,
+            ..logged(py, &locals, true)
+        };
+        succeed(py, &locals, &mut logging);
+        run(
+            py,
+            &locals,
+            c"assert logger.names() == ['sync_success_for_async_call'], logger.calls",
+        );
+    });
+}
+
+#[test]
+fn a_failing_success_callback_is_reported_without_replacing_the_response() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"
+response = object()
+failure = ValueError('terminal diagnostic')
+
+class FailingLogger(StubLogger):
+    def handle_sync_success_callbacks_for_async_calls(self, *args):
+        raise failure
+
+logger = FailingLogger()
+",
+        );
+        let mut logging = logged(py, &locals, true);
+        assert!(matches!(
+            succeed(py, &locals, &mut logging),
+            AdapterStep::Done
+        ));
+        assert!(
+            logging
+                .response
+                .as_ref()
+                .unwrap()
+                .bind(py)
+                .is(local(&locals, "response"))
+        );
+        run(py, &locals, c"assert unraisable_from(logger) == [failure]");
+    });
+}
+
+#[rstest]
+#[case::sync_listened(false, c"", &["failure_handler"])]
+#[case::sync_unlistened(false, c"logger.needed = {'sync_failure': False}", &["failure_bookkeeping"])]
+#[case::async_listened(true, c"", &["failure_handler", "async_failure_handler"])]
+#[case::async_unlistened(
+    true,
+    c"logger.needed = {'sync_failure': False, 'async_failure': False}",
+    &["failure_bookkeeping", "failure_bookkeeping"]
+)]
+fn failure_reaches_only_the_callbacks_that_listen(
+    #[case] asynchronous: bool,
+    #[case] script: &CStr,
+    #[case] expected: &[&str],
+) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"failure = ValueError('provider')");
+        run(py, &locals, script);
+        let mut logging = logged(py, &locals, asynchronous);
+        let step = fail(py, &locals, &mut logging);
+        let awaits_async_handler = expected.contains(&"async_failure_handler");
+        assert_eq!(matches!(step, AdapterStep::Await(_)), awaits_async_handler);
+        let names: Vec<String> = local(&locals, "logger")
+            .call_method0("names")
+            .unwrap()
+            .extract()
+            .unwrap();
+        assert_eq!(names, expected);
+        run(
+            py,
+            &locals,
+            c"assert all(value is failure for name, value in logger.calls if name.endswith('_handler'))",
+        );
+    });
+}
+
+#[test]
+fn a_failing_sync_failure_callback_keeps_the_error_and_still_runs_the_async_family() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(
+            py,
+            c"
+failure = ValueError('selected')
+
+class FailingLogger(StubLogger):
+    def failure_handler(self, error, trace, start, end):
+        self.record('failure_handler', error)
+        raise RuntimeError('handler failed')
+
+logger = FailingLogger()
+",
+        );
+        let mut logging = logged(py, &locals, true);
+        assert!(matches!(
+            fail(py, &locals, &mut logging),
+            AdapterStep::Await(_)
+        ));
+        assert!(
+            logging
+                .error
+                .as_ref()
+                .unwrap()
+                .bind(py)
+                .is(local(&locals, "failure"))
+        );
+        run(
+            py,
+            &locals,
+            c"assert logger.names() == ['failure_handler', 'async_failure_handler'], logger.calls",
+        );
+    });
+}
+
+#[rstest]
+#[case::completed(None, true)]
+#[case::handler_error(Some(false), true)]
+#[case::cancelled(Some(true), false)]
+fn the_async_failure_handler_ends_the_call_unless_it_was_cancelled(
+    #[case] error: Option<bool>,
+    #[case] done: bool,
+) {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"failure = ValueError('provider')");
+        let mut logging = logged(py, &locals, true);
+        fail(py, &locals, &mut logging);
+        let result = match error {
+            None => Ok(py.None()),
+            Some(false) => Err(PyRuntimeError::new_err("handler failed")),
+            Some(true) => Err(CancelledError::new_err("cancelled")),
+        };
+        let expected = result.as_ref().err().map(|error| error.value(py).clone());
+        match logging.resume(py, result) {
+            Ok(step) => assert!(done && matches!(step, AdapterStep::Done)),
+            Err(propagated) => {
+                assert!(!done);
+                assert!(propagated.value(py).is(expected.unwrap()));
+            }
+        }
+    });
+}
+
+#[test]
+fn closing_restores_the_correlation_context_once() {
+    Python::initialize();
+    Python::attach(|py| {
+        let locals = namespace(py, c"");
+        let mut logging = logged(py, &locals, true);
+        logging.close(py);
+        logging.close(py);
+        run(
+            py,
+            &locals,
+            c"assert logger.names() == ['restore'], logger.calls",
+        );
+    });
+}

litellm-rust/crates/callbacks/Cargo.toml

@@ -1,15 +1,13 @@
 [package]
-name = "litellm-python-interop"
+name = "litellm-callbacks"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
 [dependencies]
-pyo3.workspace = true
-pythonize.workspace = true
-serde.workspace = true
+serde_json.workspace = true
 
 [dev-dependencies]
 rstest.workspace = true
-serde_json.workspace = true
+tokio = { workspace = true, features = ["macros"] }

litellm-rust/crates/callbacks/src/event.rs

@@ -0,0 +1,135 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde_json::{Map, Value};
+
+/// Seconds since the Unix epoch, on one clock for every host.
+pub fn epoch_seconds() -> f64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_secs_f64())
+        .unwrap_or(0.0)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Timing {
+    pub start_time: f64,
+    pub end_time: f64,
+}
+
+/// The provider request as it is about to leave, offered to the host for rewriting.
+#[derive(Clone, Debug, PartialEq)]
+pub struct WireRequest {
+    pub url: String,
+    pub headers: Vec<(String, String)>,
+    pub body: Value,
+}
+
+/// What the route knows about the request it is sending, for a host that logs it. The
+/// route owns these facts; a host reads them beside the wire request and never rewrites
+/// them.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RequestContext {
+    pub model: String,
+    pub custom_llm_provider: String,
+    /// The route's parameters before the provider transformation.
+    pub optional_params: Value,
+    pub passthrough_fields: Passthrough,
+    /// Optional-param names that carry credentials and must be redacted when logged.
+    pub secret_fields: Vec<String>,
+}
+
+/// Body keys whose values are the caller's inputs, unchanged by the route. The only way to
+/// build one is to compare the two, so a route cannot name a key it rewrote.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Passthrough(Vec<String>);
+
+impl Passthrough {
+    pub fn unchanged(caller: &Map<String, Value>, body: &Value) -> Self {
+        Self(
+            caller
+                .iter()
+                .filter(|(name, value)| body.get(name.as_str()) == Some(*value))
+                .map(|(name, _)| name.clone())
+                .collect(),
+        )
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &str> {
+        self.0.iter().map(String::as_str)
+    }
+
+    pub fn contains(&self, name: &str) -> bool {
+        self.0.iter().any(|field| field == name)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RawResponse {
+    pub body: String,
+}
+
+/// Whether a failure surfaced inside the call, including a host op the call asked for,
+/// or in a host step around it (preparing the arguments, finalizing the response).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FailureOrigin {
+    Call,
+    Host,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum CallEvent {
+    ResponseReceived {
+        raw: RawResponse,
+    },
+    Succeeded {
+        timing: Timing,
+    },
+    Failed {
+        timing: Timing,
+        origin: FailureOrigin,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::rstest;
+    use serde_json::json;
+
+    use super::*;
+
+    #[rstest]
+    #[case::unchanged_scalar(json!({"pages": [0]}), json!({"pages": [0]}), &["pages"])]
+    #[case::unchanged_explicit_null(json!({"pages": null}), json!({"pages": null}), &["pages"])]
+    #[case::unchanged_nested_object(
+        json!({"document": {"type": "document_url", "document_url": "https://a/b.pdf"}}),
+        json!({"document": {"type": "document_url", "document_url": "https://a/b.pdf"}, "model": "m"}),
+        &["document"]
+    )]
+    #[case::rewritten_value(
+        json!({"document": {"type": "document_url", "document_url": "https://a/b.pdf"}}),
+        json!({"document": {"type": "document_url", "document_url": "data:application/pdf;base64,YWJj"}}),
+        &[]
+    )]
+    #[case::dropped_nested_field(
+        json!({"document": {"type": "image_url", "image_url": "https://a/b.png", "document_name": "b.png"}}),
+        json!({"document": {"type": "image_url", "image_url": "https://a/b.png"}}),
+        &[]
+    )]
+    #[case::added_nested_field(
+        json!({"document": {"type": "image_url", "image_url": "https://a/b.png"}}),
+        json!({"document": {"type": "image_url", "image_url": "https://a/b.png", "detail": "high"}}),
+        &[]
+    )]
+    #[case::reordered_array(json!({"pages": [0, 1]}), json!({"pages": [1, 0]}), &[])]
+    #[case::consumed_by_the_route(json!({"api_key": "k", "pages": [0]}), json!({"pages": [0]}), &["pages"])]
+    #[case::added_by_the_route(json!({}), json!({"model": "m"}), &[])]
+    #[case::non_object_body(json!({"pages": [0]}), json!([{"pages": [0]}]), &[])]
+    fn passthrough_is_exactly_the_callers_unchanged_keys(
+        #[case] caller: Value,
+        #[case] body: Value,
+        #[case] expected: &[&str],
+    ) {
+        let passthrough = Passthrough::unchanged(caller.as_object().unwrap(), &body);
+        assert_eq!(passthrough.iter().collect::<Vec<_>>(), expected);
+    }
+}

litellm-rust/crates/callbacks/src/host.rs

@@ -0,0 +1,45 @@
+use std::future::Future;
+
+use crate::event::{CallEvent, RequestContext, WireRequest};
+use crate::route::Route;
+
+/// One suspension point of a native call, performed by the host.
+pub enum HostOp<R: Route> {
+    Route(R::Op),
+    BeforeSend {
+        wire: Box<WireRequest>,
+        context: Box<RequestContext>,
+    },
+    Emit(CallEvent),
+}
+
+pub enum HostResult<R: Route> {
+    Route(R::OpResult),
+    BeforeSend(Box<WireRequest>),
+    Emitted,
+}
+
+/// A host answer that is either available now or arrives once the host's own
+/// suspension (a Python awaitable, for example) resolves.
+pub enum HostStep<V, S> {
+    Ready(V),
+    Suspend(S),
+}
+
+/// An in-process host: answers route operations and observes the call without leaving
+/// the Rust runtime. Language hosts implement their own driver instead.
+pub trait Host<R: Route>: Send + Sync {
+    fn route(&self, op: R::Op) -> impl Future<Output = Result<R::OpResult, R::Error>> + Send;
+
+    fn before_send(
+        &self,
+        wire: WireRequest,
+        _context: &RequestContext,
+    ) -> impl Future<Output = Result<WireRequest, R::Error>> + Send {
+        async move { Ok(wire) }
+    }
+
+    fn emit(&self, _event: &CallEvent) -> impl Future<Output = Result<(), R::Error>> + Send {
+        async { Ok(()) }
+    }
+}

litellm-rust/crates/callbacks/src/lib.rs

@@ -0,0 +1,12 @@
+//! The contract between a native call and the host runtime that drives it.
+//!
+//! A host is whatever sits on the far side of the language boundary: CPython today,
+//! another runtime later. Core implements [`machine::Machine`] per route and never learns
+//! which host is on the other end. The machine yields [`host::HostOp`]s; a driver answers
+//! them, observes [`event::CallEvent`]s and may rewrite the wire request before it is sent.
+
+pub mod event;
+pub mod host;
+pub mod machine;
+pub mod route;
+pub mod run;

litellm-rust/crates/callbacks/src/machine.rs

@@ -0,0 +1,63 @@
+use std::future::Future;
+use std::pin::Pin;
+
+use crate::host::{HostOp, HostResult};
+use crate::route::Route;
+
+pub enum MachineStep<R: Route, C> {
+    Host(HostOp<R>),
+    Complete(C),
+}
+
+pub type Step<'a, M> = Pin<
+    Box<
+        dyn Future<
+                Output = Result<
+                    MachineStep<<M as Machine>::Route, <M as Machine>::Complete>,
+                    <<M as Machine>::Route as Route>::Error,
+                >,
+            > + Send
+            + 'a,
+    >,
+>;
+
+pub type Interrupted<'a, M> = Pin<
+    Box<
+        dyn Future<
+                Output = Result<<M as Machine>::Complete, <<M as Machine>::Route as Route>::Error>,
+            > + Send
+            + 'a,
+    >,
+>;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum HostFailure<E> {
+    Error(E),
+    Cancelled(E),
+}
+
+impl<E> HostFailure<E> {
+    pub fn into_error(self) -> E {
+        match self {
+            Self::Error(error) | Self::Cancelled(error) => error,
+        }
+    }
+}
+
+/// A resumable call. Core implements it per route; a host drives it. Every suspension
+/// point is an op the host performs and answers with a result.
+pub trait Machine: Send {
+    type Route: Route;
+    type Complete: Send + 'static;
+
+    /// `None` on the first call and whenever the previous step completed without
+    /// yielding an op; otherwise the result of the op last yielded.
+    fn resume(&mut self, result: Option<HostResult<Self::Route>>) -> Step<'_, Self>;
+
+    /// The host failed to perform the pending op, or the caller cancelled. The call
+    /// yields no further ops.
+    fn interrupt(
+        &mut self,
+        failure: HostFailure<<Self::Route as Route>::Error>,
+    ) -> Interrupted<'_, Self>;
+}

litellm-rust/crates/callbacks/src/route.rs

@@ -0,0 +1,9 @@
+/// One public call surface: what a completed call produces, how it fails, and the
+/// route-specific operations only its host can perform (request projection, file reads,
+/// token acquisition).
+pub trait Route: Send + Sync + 'static {
+    type Response: Send + 'static;
+    type Error: Clone + Send + Sync + 'static;
+    type Op: Send + 'static;
+    type OpResult: Send + 'static;
+}

litellm-rust/crates/callbacks/src/run.rs

@@ -0,0 +1,149 @@
+use crate::event::{CallEvent, FailureOrigin, Timing, epoch_seconds};
+use crate::host::{Host, HostOp, HostResult};
+use crate::machine::{HostFailure, Machine, MachineStep};
+use crate::route::Route;
+
+/// Drives a machine to completion against an in-process host and emits exactly one
+/// terminal event.
+pub async fn run<M, H>(mut machine: M, host: &H) -> Result<M::Complete, <M::Route as Route>::Error>
+where
+    M: Machine,
+    H: Host<M::Route>,
+{
+    let start_time = epoch_seconds();
+    let mut result = None;
+    let outcome = loop {
+        let step = match machine.resume(result.take()).await {
+            Ok(MachineStep::Complete(complete)) => break Ok(complete),
+            Ok(MachineStep::Host(op)) => op,
+            Err(error) => break Err(error),
+        };
+        let answer = match step {
+            HostOp::Route(op) => host.route(op).await.map(HostResult::Route),
+            HostOp::BeforeSend { wire, context } => host
+                .before_send(*wire, &context)
+                .await
+                .map(|wire| HostResult::BeforeSend(Box::new(wire))),
+            HostOp::Emit(event) => host.emit(&event).await.map(|()| HostResult::Emitted),
+        };
+        match answer {
+            Ok(answer) => result = Some(answer),
+            Err(error) => break machine.interrupt(HostFailure::Error(error)).await,
+        }
+    };
+    let timing = Timing {
+        start_time,
+        end_time: epoch_seconds(),
+    };
+    let terminal = match &outcome {
+        Ok(_) => CallEvent::Succeeded { timing },
+        Err(_) => CallEvent::Failed {
+            timing,
+            origin: FailureOrigin::Call,
+        },
+    };
+    let _ = host.emit(&terminal).await;
+    outcome
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Mutex;
+
+    use super::*;
+    use crate::machine::{Interrupted, Step};
+
+    struct Unit;
+
+    impl Route for Unit {
+        type Response = ();
+        type Error = &'static str;
+        type Op = &'static str;
+        type OpResult = ();
+    }
+
+    struct Scripted {
+        ops: Vec<&'static str>,
+        outcome: Result<(), &'static str>,
+    }
+
+    impl Machine for Scripted {
+        type Route = Unit;
+        type Complete = ();
+
+        fn resume(&mut self, _: Option<HostResult<Unit>>) -> Step<'_, Self> {
+            Box::pin(async move {
+                if !self.ops.is_empty() {
+                    return Ok(MachineStep::Host(HostOp::Route(self.ops.remove(0))));
+                }
+                self.outcome.map(MachineStep::Complete)
+            })
+        }
+
+        fn interrupt(&mut self, failure: HostFailure<&'static str>) -> Interrupted<'_, Self> {
+            Box::pin(async move { Err(failure.into_error()) })
+        }
+    }
+
+    #[derive(Default)]
+    struct Recording {
+        seen: Mutex<Vec<String>>,
+        fail: Option<&'static str>,
+    }
+
+    impl Host<Unit> for Recording {
+        async fn route(&self, op: &'static str) -> Result<(), &'static str> {
+            self.seen.lock().unwrap().push(format!("route:{op}"));
+            match self.fail {
+                Some(failing) if failing == op => Err("host failed"),
+                _ => Ok(()),
+            }
+        }
+
+        async fn emit(&self, event: &CallEvent) -> Result<(), &'static str> {
+            self.seen.lock().unwrap().push(match event {
+                CallEvent::Succeeded { .. } => "succeeded".into(),
+                CallEvent::Failed { .. } => "failed".into(),
+                other => format!("{other:?}"),
+            });
+            Ok(())
+        }
+    }
+
+    fn scripted(ops: &[&'static str], outcome: Result<(), &'static str>) -> Scripted {
+        Scripted {
+            ops: ops.to_vec(),
+            outcome,
+        }
+    }
+
+    #[tokio::test]
+    async fn forwards_every_op_then_emits_one_succeeded() {
+        let host = Recording::default();
+        let outcome = run(scripted(&["project", "send"], Ok(())), &host).await;
+        assert_eq!(outcome, Ok(()));
+        assert_eq!(
+            *host.seen.lock().unwrap(),
+            ["route:project", "route:send", "succeeded"]
+        );
+    }
+
+    #[tokio::test]
+    async fn errors_and_host_failures_each_emit_failed_once() {
+        let host = Recording::default();
+        let outcome = run(scripted(&[], Err("boom")), &host).await;
+        assert_eq!(outcome, Err("boom"));
+        assert_eq!(*host.seen.lock().unwrap(), ["failed"]);
+
+        let host = Recording {
+            fail: Some("send"),
+            ..Recording::default()
+        };
+        let outcome = run(scripted(&["project", "send", "never"], Ok(())), &host).await;
+        assert_eq!(outcome, Err("host failed"));
+        assert_eq!(
+            *host.seen.lock().unwrap(),
+            ["route:project", "route:send", "failed"]
+        );
+    }
+}

litellm-rust/crates/core-utils/Cargo.toml

@@ -1,16 +1,15 @@
 [package]
-name = "litellm-providers"
+name = "litellm-core-utils"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
 [dependencies]
-litellm-auth.workspace = true
-litellm-auth-aws.workspace = true
+litellm-types.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+serde_path_to_error = "0.1"
+serde_with.workspace = true
 thiserror.workspace = true
-
-[dev-dependencies]
-rstest.workspace = true
+url.workspace = true

litellm-rust/crates/core-utils/src/call_arguments.rs

@@ -0,0 +1,181 @@
+use std::ops::Deref;
+
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use serde_json::{Map, Value};
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct CallArguments(Map<String, Value>);
+
+impl CallArguments {
+    pub fn select(&self, names: &[&str]) -> Map<String, Value> {
+        self.iter()
+            .filter(|(name, _)| names.contains(&name.as_str()))
+            .map(|(name, value)| (name.clone(), value.clone()))
+            .collect()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("invalid argument: {path}")]
+pub struct ArgumentError {
+    pub path: String,
+}
+
+pub fn parse_options<T: DeserializeOwned>(arguments: &CallArguments) -> Result<T, ArgumentError> {
+    let deserializer = serde::de::value::MapDeserializer::new(
+        arguments.iter().map(|(name, value)| (name.as_str(), value)),
+    );
+    serde_path_to_error::deserialize(deserializer).map_err(|error| ArgumentError {
+        path: error.path().to_string(),
+    })
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ArgumentSpec {
+    pub name: &'static str,
+    pub secret: bool,
+}
+
+pub fn compose_body<B: Serialize>(
+    arguments: &CallArguments,
+    body: &B,
+    consumed: &[&str],
+) -> Result<Value, crate::params::Error> {
+    let Value::Object(fields) =
+        serde_json::to_value(body).map_err(|_| crate::params::Error::Body)?
+    else {
+        return Err(crate::params::Error::Body);
+    };
+    let overrides = match arguments.get("extra_body") {
+        None | Some(Value::Null) => None,
+        Some(Value::Object(fields)) => Some(fields),
+        Some(_) => return Err(crate::params::Error::ExtraBody),
+    };
+    let extensions = arguments
+        .iter()
+        .filter(|(name, _)| !consumed.contains(&name.as_str()));
+    Ok(Value::Object(
+        fields
+            .into_iter()
+            .chain(
+                extensions
+                    .chain(overrides.into_iter().flatten())
+                    .filter(|(name, _)| {
+                        name.as_str() != "model"
+                            && name.as_str() != "extra_body"
+                            && !crate::params::is_control_param(name)
+                    })
+                    .map(|(name, value)| (name.clone(), value.clone())),
+            )
+            .collect(),
+    ))
+}
+
+impl Deref for CallArguments {
+    type Target = Map<String, Value>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<Map<String, Value>> for CallArguments {
+    fn from(values: Map<String, Value>) -> Self {
+        Self(values)
+    }
+}
+
+impl From<CallArguments> for Map<String, Value> {
+    fn from(arguments: CallArguments) -> Self {
+        arguments.0
+    }
+}
+
+impl FromIterator<(String, Value)> for CallArguments {
+    fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl IntoIterator for CallArguments {
+    type Item = (String, Value);
+    type IntoIter = serde_json::map::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn composition_preserves_extensions_and_applies_shallow_explicit_overrides() {
+        let original = json!({
+            "known": false, "future": {"old": 1}, "null": null, "zero": 0,
+            "metadata": {"host": true}, "timeout": 30, "api_key": "secret",
+            "extra_body": {
+                "known": null, "future": {"new": [false, 0, null]},
+                "metadata": {"provider": true}, "model": "ignored", "api_key": "ignored"
+            }
+        });
+        let arguments = serde_json::from_value(original.clone()).unwrap();
+        let body = compose_body(
+            &arguments,
+            &json!({"model":"resolved", "known":false}),
+            &["known"],
+        )
+        .unwrap();
+        assert_eq!(
+            body,
+            json!({
+                "model":"resolved", "known":null, "future":{"new":[false,0,null]},
+                "null":null, "zero":0, "metadata":{"provider":true}
+            })
+        );
+        assert_eq!(serde_json::to_value(arguments).unwrap(), original);
+    }
+
+    #[test]
+    fn invalid_extra_body_is_rejected_without_coercing_it_to_empty() {
+        for value in [json!(false), json!(0), json!([]), json!("")] {
+            let arguments = serde_json::from_value(json!({"extra_body":value})).unwrap();
+            assert_eq!(
+                compose_body(&arguments, &json!({}), &[]),
+                Err(crate::params::Error::ExtraBody)
+            );
+        }
+        let arguments = serde_json::from_value(json!({"extra_body":null})).unwrap();
+        assert_eq!(
+            compose_body(&arguments, &json!({}), &[]).unwrap(),
+            json!({})
+        );
+    }
+
+    #[test]
+    fn typed_views_preserve_missing_and_explicit_null_in_the_source() {
+        #[derive(Deserialize)]
+        struct Options {
+            enabled: Option<bool>,
+        }
+        let arguments: CallArguments =
+            serde_json::from_value(json!({"enabled":null,"future":0})).unwrap();
+        assert!(
+            parse_options::<Options>(&arguments)
+                .unwrap()
+                .enabled
+                .is_none()
+        );
+        assert_eq!(arguments.get("enabled"), Some(&Value::Null));
+        assert_eq!(arguments.get("missing"), None);
+        let invalid = serde_json::from_value(json!({"enabled":0})).unwrap();
+        assert_eq!(
+            parse_options::<Options>(&invalid).err().unwrap().path,
+            "enabled"
+        );
+    }
+}

litellm-rust/crates/core-utils/src/core_helpers.rs

@@ -2,7 +2,7 @@
 
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use super::types::{ChatCompletionsUsage, PromptTokensDetails};
+use litellm_types::utils::{ChatCompletionsUsage, PromptTokensDetails};
 
 /// OpenAI finish reasons, mirroring Python's `_FINISH_REASON_MAP` for the
 /// reasons the providers on this route can emit. Python warns and falls back to
@@ -54,6 +54,17 @@ pub fn unix_now() -> u64 {
         .map_or(0, |elapsed| elapsed.as_secs())
 }
 
+pub fn json_type_name(value: &serde_json::Value) -> &'static str {
+    match value {
+        serde_json::Value::Null => "null",
+        serde_json::Value::Bool(_) => "boolean",
+        serde_json::Value::Number(_) => "number",
+        serde_json::Value::String(_) => "string",
+        serde_json::Value::Array(_) => "array",
+        serde_json::Value::Object(_) => "object",
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

litellm-rust/crates/core-utils/src/get_llm_provider_logic.rs

@@ -1,4 +1,36 @@
-pub use litellm_providers::provider_resolution::{CustomLlmProvider, get_custom_llm_provider};
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CustomLlmProvider<'a> {
+    pub model: &'a str,
+    pub custom_llm_provider: &'a str,
+}
+
+pub fn get_custom_llm_provider<'a>(
+    model: &'a str,
+    custom_llm_provider: Option<&'a str>,
+) -> Option<CustomLlmProvider<'a>> {
+    if let Some(custom_llm_provider) = custom_llm_provider.filter(|provider| !provider.is_empty()) {
+        return Some(CustomLlmProvider {
+            model: strip_custom_llm_provider_prefix(model, custom_llm_provider),
+            custom_llm_provider,
+        });
+    }
+
+    let (custom_llm_provider, model) = model.split_once('/')?;
+    if custom_llm_provider.is_empty() || model.is_empty() {
+        return None;
+    }
+    Some(CustomLlmProvider {
+        model,
+        custom_llm_provider,
+    })
+}
+
+fn strip_custom_llm_provider_prefix<'a>(model: &'a str, custom_llm_provider: &str) -> &'a str {
+    model
+        .strip_prefix(custom_llm_provider)
+        .and_then(|model| model.strip_prefix('/'))
+        .unwrap_or(model)
+}
 
 #[cfg(test)]
 mod tests {

litellm-rust/crates/core-utils/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod call_arguments;
+pub mod core_helpers;
+pub mod get_llm_provider_logic;
+pub mod params;
+pub mod prompt_templates;
+pub mod serde_compat;
+pub mod url_utils;

litellm-rust/crates/core-utils/src/params.rs

@@ -28,14 +28,6 @@ pub fn is_control_param(name: &str) -> bool {
             | "max_retries"
             | "req_format"
             | "max_response_bytes"
-            | "litellm_call_id"
-            | "litellm_logging_obj"
-            | "litellm_metadata"
-            | "proxy_server_request"
-            | "callbacks"
-            | "success_callback"
-            | "failure_callback"
-            | "guardrails"
             | "azure_ad_token"
             | "azure_ad_token_provider"
             | "tenant_id"

litellm-rust/crates/core-utils/src/prompt_templates/factory.rs

@@ -10,8 +10,10 @@
 //! `_bedrock_converse_messages_pt` for the text-only surface this route
 //! accepts; anything richer is declined upstream by the capability gate.
 
-use super::types::{ChatMessage, ChatMessageContent};
-use crate::chat::EMPTY_TEXT_PLACEHOLDER;
+use litellm_types::llms::openai::{ChatMessage, ChatMessageContent};
+
+pub const EMPTY_TEXT_PLACEHOLDER: &str =
+    "[System: Empty message content sanitised to satisfy protocol]";
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum TurnRole {
@@ -203,8 +205,10 @@ mod tests {
             {"role": "assistant", "content": "   "},
             {"role": "user", "content": "real"}
         ])));
-        assert_eq!(conversation.turns[0].texts, vec![EMPTY_TEXT_PLACEHOLDER]);
-        assert_eq!(conversation.turns[1].texts, vec![EMPTY_TEXT_PLACEHOLDER]);
+        // Must equal `_EMPTY_TEXT_PLACEHOLDER` in litellm/litellm_core_utils/prompt_templates/factory.py
+        let placeholder = "[System: Empty message content sanitised to satisfy protocol]";
+        assert_eq!(conversation.turns[0].texts, vec![placeholder]);
+        assert_eq!(conversation.turns[1].texts, vec![placeholder]);
     }
 
     #[test]

litellm-rust/crates/core-utils/src/prompt_templates/mod.rs

@@ -0,0 +1 @@
+pub mod factory;

litellm-rust/crates/core-utils/src/serde_compat.rs

@@ -2,8 +2,8 @@ use serde::{Deserialize, Deserializer, de::Error};
 use serde_json::Value;
 use serde_with::DeserializeAs;
 
-pub(crate) struct LaxI64;
-pub(crate) struct FiniteF64;
+pub struct LaxI64;
+pub struct FiniteF64;
 
 impl<'de> DeserializeAs<'de, i64> for LaxI64 {
     fn deserialize_as<D: Deserializer<'de>>(deserializer: D) -> Result<i64, D::Error> {

litellm-rust/crates/core-utils/src/url_utils.rs

@@ -3,33 +3,30 @@ use std::marker::PhantomData;
 use url::Url;
 
 #[derive(Debug, thiserror::Error)]
-pub(crate) enum ApiUrlError {
+pub enum ApiUrlError {
     #[error("invalid URL: {0}")]
     Parse(#[from] url::ParseError),
     #[error("URL cannot be used as a base")]
     CannotBeBase,
 }
 
-pub(crate) struct Base;
-pub(crate) struct Complete;
+pub struct Base;
+pub struct Complete;
 
-pub(crate) struct ApiUrl<State> {
+pub struct ApiUrl<State> {
     url: Url,
     state: PhantomData<State>,
 }
 
 impl ApiUrl<Base> {
-    pub(crate) fn parse(value: &str) -> Result<Self, ApiUrlError> {
+    pub fn parse(value: &str) -> Result<Self, ApiUrlError> {
         Ok(Self {
             url: Url::parse(value.trim())?,
             state: PhantomData,
         })
     }
 
-    pub(crate) fn complete_path(
-        mut self,
-        target: &[&str],
-    ) -> Result<ApiUrl<Complete>, ApiUrlError> {
+    pub fn complete_path(mut self, target: &[&str]) -> Result<ApiUrl<Complete>, ApiUrlError> {
         let existing: Vec<String> = self
             .url
             .path_segments()
@@ -59,7 +56,7 @@ impl ApiUrl<Base> {
 }
 
 impl ApiUrl<Complete> {
-    pub(crate) fn append_query_pairs<'a>(
+    pub fn append_query_pairs<'a>(
         mut self,
         pairs: impl IntoIterator<Item = (&'a str, &'a str)>,
     ) -> Self {
@@ -67,7 +64,7 @@ impl ApiUrl<Complete> {
         self
     }
 
-    pub(crate) fn into_string(self) -> String {
+    pub fn into_string(self) -> String {
         self.url.into()
     }
 }

litellm-rust/crates/core/AGENTS.md

@@ -1,27 +1,14 @@
 litellm-core is the LiteLLM SDK in Rust — it makes the LLM call. Each top-level call is a module under `src/<route>/` exposing a public entrypoint named after the route (`messages::messages()`, the Rust equivalent of `litellm.messages()`): you call it and get a typed non-streaming response back.
 
-A route module owns the call entrypoint, runtime types, provider/auth/URL resolution, and the handler that performs the HTTP call. Provider code and base config traits live under `src/llms/`, mirroring their Python source paths. This applies to every API surface: shared orchestration stays in its route module (`ocr/`, `chat_completions/`, `messages/`, `audio_transcription/`, or `responses/`), while provider transformations live under the corresponding Python-mirrored `llms/<provider>/` path. Import implementations directly from their canonical paths; do not add a `src/providers/` layer or compatibility re-exports. Shared provider resolution lives under `src/litellm_core_utils/get_llm_provider_logic.rs`. Handlers belong in core, never in a host crate
+## Crate layering
 
-Not here: serving HTTP (axum routes, extractors), config file reading, rollout state, databases, or host-specific callback execution. Core owns lifecycle sequencing and callback payload construction; hosts execute the selected integrations. Env reads are limited to credential fallback in a route's `prepare.rs`.
+Each crate mirrors one top-level Python package, so a Rust path reads as its Python path with the crate name in place of the package directory. Dependencies only point down:
 
-Routes (messages, ocr, realtime) and providers (anthropic, mistral, openai) are modules, not crates.
+- `litellm-types` mirrors `litellm/types/`: pure serde data, no I/O
+- `litellm-core-utils` mirrors `litellm/litellm_core_utils/`: pure helpers (provider resolution, prompt factory, call arguments), no network I/O
+- `litellm-llms` mirrors `litellm/llms/`: `base_llm/<api>/transformation.rs`, `<provider>/<api>/transformation.rs`, and `custom_httpx/` (HTTP helpers and the OCR request handler)
+- `litellm-core` mirrors the route packages (`litellm/ocr/`, `litellm/messages/`, ...): entrypoints, route request types, provider dispatch, the route machine, and hooks
 
-## Python/Rust transformation pairs
+A route module owns the call entrypoint, route request types (`*Request<'a>`), credential fallback, provider dispatch, and the handler glue that runs a provider config. Provider code never imports from core; when it needs the caller's hooks mid-call it goes through `litellm_llms::custom_httpx::llm_http_handler::CallHooks`, which each route implements over its host. Import every item from its canonical path. Never re-export another crate's items or give an item a second public path; the only re-export allowed is a private submodule surfacing its item at its module root (`mod error; pub use error::Error;`). Handlers belong in core or llms, never in a host crate
 
-Use the base OCR and Mistral OCR pairs as the reference when aligning transformations. Derive `src/<relative_path>.rs` from `litellm/<relative_path>.py`, preserving meaningful basenames such as `messages_transformation`
-
-Keep corresponding operation names and parameter names when their responsibilities match. Rust types retain the Python semantic name with Rust acronym casing (`BaseOCRConfig` / `BaseOcrConfig`, `MistralOCRConfig` / `MistralOcrConfig`). Private Python helpers can drop their leading underscore. Give Rust adapter helpers distinct responsibility names rather than duplicating trait method names
-
-Order OCR config methods as supported parameters, credential metadata and connection resolution, health-check input, parameter mapping, environment validation, URL construction, request transformation, async request transformation, response transformation, async response transformation, and error conversion. Put constants and data types before the config, private helpers after it in operation order, and tests last. Rust-only trait hooks follow the corresponding Python methods
-
-Use trait defaults for unchanged inherited behavior and explicit delegation for shared provider behavior. Keep typed inputs, ownership, `Result`, and async I/O idiomatic. A matching path or symbol identifies the counterpart, not a claim of full behavioral parity
-
-Use named `#[rstest]` cases for independent input/output scenarios instead of loops or repeated calls in one test. Inject reusable setup with `#[fixture]` arguments and use `#[with(...)]` for fixture overrides. Keep assertions about the same result together
-
-For base OCR, Python response models correspond to `src/ocr/types.rs`; Rust context/environment types support the runtime. `BaseOcrConfig::prepare_request` corresponds to Python's HTTP-handler preparation rather than a `BaseOCRConfig` method, and `validate_request_body` is a Rust-only hook
-
-For Mistral, `async_transform_ocr_request` uses the base default in both languages. `resolve_headers` and `build_ocr_url` implement the respective environment and URL operations, and `normalize_response` implements the typed part of response transformation. Existing auth key/header handling and top-level response-extra preservation differ between languages; layout refactors must preserve those behaviors and verify them with the existing tests
-
-For non-OCR pairs, order corresponding methods as parameter support/mapping, environment validation, URL construction, request transformation, and response transformation, followed by Rust-only runtime hooks. Auth resolution remains split between configs and route preparation. Chat `supported_openai_param_mappings` describes accepted OpenAI/provider name pairs, unlike Python's `get_supported_openai_params` name list. Audio `map_transcription_params` remains a Rust filtering helper
-
-Azure Messages maps to `llms/azure_ai/anthropic/messages_transformation.py`; Bedrock Converse maps to `llms/bedrock/chat/converse_transformation.py`. `AnthropicConfig`, `AmazonConverseConfig`, and the non-OCR base traits are partial ports. `OpenAiResponsesApiConfig` currently implements only the WebSocket surface. Preserve their acceptance gates, passthrough behavior, and host fallback contracts when aligning layout
+Not here: serving HTTP (axum routes, extractors), config file reading, rollout state, databases, or callback execution of any kind. Core runs each route as a machine that yields host operations and call events; which integrations consume those events is the host's business.

litellm-rust/crates/core/Cargo.toml

@@ -7,16 +7,15 @@ repository.workspace = true
 autotests = false
 
 [dependencies]
+litellm-types.workspace = true
+litellm-core-utils.workspace = true
+litellm-callbacks.workspace = true
 bytes.workspace = true
 futures-util.workspace = true
 base64.workspace = true
-data-url = "0.3.2"
 litellm-auth.workspace = true
 litellm-auth-aws.workspace = true
-litellm-auth-azure.workspace = true
-litellm-auth-gcp.workspace = true
-litellm-providers.workspace = true
-litellm-framing.workspace = true
+litellm-llms.workspace = true
 moka.workspace = true
 mime_guess = "2.0.5"
 rand.workspace = true
@@ -25,8 +24,6 @@ rustls.workspace = true
 rustls-native-certs.workspace = true
 serde.workspace = true
 serde_json = { workspace = true, features = ["preserve_order"] }
-serde_with.workspace = true
-serde_path_to_error = "0.1"
 strum.workspace = true
 subtle.workspace = true
 tokio = { workspace = true, features = ["sync"] }
@@ -38,6 +35,6 @@ url.workspace = true
 veil.workspace = true
 
 [dev-dependencies]
-aws-smithy-eventstream = "=0.61.1"
-aws-smithy-types = "1.6.1"
+litellm-llms = { workspace = true, features = ["test-support"] }
 rstest.workspace = true
+rstest_reuse.workspace = true

litellm-rust/crates/core/src/audio_transcription/client.rs

@@ -1,5 +1,4 @@
-use std::sync::OnceLock;
-use std::time::Duration;
+use std::{sync::OnceLock, time::Duration};
 
 use crate::constants::AUDIO_TRANSCRIPTION_TIMEOUT_SECS;
 

litellm-rust/crates/core/src/audio_transcription/error.rs

@@ -1,3 +1,5 @@
+use litellm_llms::base_llm::chat::transformation::Error as LlmError;
+
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum Error {
     #[error("expected {expected}, got {actual}")]
@@ -18,29 +20,22 @@ pub enum Error {
     #[error(transparent)]
     Auth(#[from] litellm_auth::Error),
     #[error(transparent)]
-    Transport(#[from] crate::transport::Error),
+    Transport(#[from] litellm_llms::custom_httpx::transport::Error),
     #[error(transparent)]
-    Headers(#[from] crate::http_utils::HeaderError),
+    Headers(#[from] litellm_llms::custom_httpx::http_handler::HeaderError),
     #[error(transparent)]
     Aws(#[from] litellm_auth_aws::Error),
 }
 
-impl From<litellm_providers::audio_transcription::Error> for Error {
-    fn from(error: litellm_providers::audio_transcription::Error) -> Self {
+impl From<LlmError> for Error {
+    fn from(error: LlmError) -> Self {
         match error {
-            litellm_providers::audio_transcription::Error::InvalidType { expected, actual } => {
-                Self::InvalidType { expected, actual }
-            }
-            litellm_providers::audio_transcription::Error::MissingField(field) => {
-                Self::MissingField(field)
-            }
-            litellm_providers::audio_transcription::Error::InvalidRequest(message) => {
-                Self::InvalidRequest(message)
-            }
-            litellm_providers::audio_transcription::Error::InvalidResponse(message) => {
-                Self::InvalidResponse(message)
-            }
-            litellm_providers::audio_transcription::Error::Auth(error) => Self::Auth(error),
+            LlmError::InvalidType { expected, actual } => Self::InvalidType { expected, actual },
+            LlmError::MissingField(field) => Self::MissingField(field),
+            LlmError::InvalidRequest(message) => Self::InvalidRequest(message),
+            LlmError::InvalidResponse(message) => Self::InvalidResponse(message),
+            LlmError::Unsupported(reason) => Self::Unsupported(reason),
+            LlmError::Auth(error) => Self::Auth(error),
         }
     }
 }

litellm-rust/crates/core/src/audio_transcription/handler.rs

@@ -1,9 +1,8 @@
+use litellm_llms::custom_httpx::http_handler::{http_request, truncate_error_body};
 use serde_json::Value;
 
-use super::Error;
-use super::client::http_client;
-use super::types::ProviderAudioTranscriptionRequest;
-use crate::http_utils::{http_request, truncate_error_body};
+use super::{Error, client::http_client};
+use crate::audio_transcription::types::ProviderAudioTranscriptionRequest;
 
 pub async fn execute_audio_transcription_provider_call(
     request: ProviderAudioTranscriptionRequest,
@@ -18,19 +17,24 @@ pub async fn execute_audio_transcription_provider_call(
     if let Some(duration) = request.timeout {
         request_builder = request_builder.timeout(duration);
     }
-    let response = http_request(request_builder)
-        .await
-        .map_err(|error| Error::Transport(crate::transport::Error::Network(error.to_string())))?;
+    let response = http_request(request_builder).await.map_err(|error| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            error.to_string(),
+        ))
+    })?;
     let status = response.status();
-    let text = response
-        .text()
-        .await
-        .map_err(|error| Error::Transport(crate::transport::Error::Network(error.to_string())))?;
+    let text = response.text().await.map_err(|error| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            error.to_string(),
+        ))
+    })?;
     if !status.is_success() {
-        return Err(Error::Transport(crate::transport::Error::Http {
-            status: status.as_u16(),
-            body: truncate_error_body(&text),
-        }));
+        return Err(Error::Transport(
+            litellm_llms::custom_httpx::transport::Error::Http {
+                status: status.as_u16(),
+                body: truncate_error_body(&text),
+            },
+        ));
     }
     let response_json = serde_json::from_str(&text)
         .map_err(|error| Error::InvalidResponse(format!("invalid audio response JSON: {error}")))?;
@@ -44,11 +48,10 @@ async fn signed_headers(
     request: &ProviderAudioTranscriptionRequest,
     body: &[u8],
 ) -> Result<Vec<(String, String)>, Error> {
-    use std::collections::BTreeMap;
-    use std::time::SystemTime;
+    use std::{collections::BTreeMap, time::SystemTime};
 
     use litellm_auth_aws::{aws_auth_config, resolve_credentials, sign_bedrock_post};
-    use litellm_providers::base_llm::audio_transcription::transformation::AudioTranscriptionAuth;
+    use litellm_llms::base_llm::audio_transcription::transformation::AudioTranscriptionAuth;
 
     let AudioTranscriptionAuth::AwsSigV4 { region, .. } = &request.auth else {
         return Ok(request.upstream_headers.clone());

litellm-rust/crates/core/src/audio_transcription/mod.rs

@@ -1,14 +1,14 @@
 mod error;
+pub mod types;
 pub use error::Error;
 mod client;
 mod handler;
 mod prepare;
-pub use litellm_providers::audio_transcription::types;
-
 pub use handler::execute_audio_transcription_provider_call;
 pub use prepare::prepare_audio_transcription_provider_call;
 use serde_json::Value;
-pub use types::{AudioTranscriptionRequest, ProviderAudioTranscriptionRequest};
+
+use crate::audio_transcription::types::AudioTranscriptionRequest;
 
 pub async fn audio_transcription(request: AudioTranscriptionRequest<'_>) -> Result<Value, Error> {
     execute_audio_transcription_provider_call(prepare_audio_transcription_provider_call(request)?)

litellm-rust/crates/core/src/audio_transcription/prepare.rs

@@ -1,13 +1,16 @@
+use litellm_core_utils::get_llm_provider_logic::{CustomLlmProvider, get_custom_llm_provider};
+use litellm_llms::{
+    base_llm::audio_transcription::transformation::{
+        AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
+    },
+    bedrock::audio_transcription::BEDROCK_AUDIO_TRANSCRIPTION_CONFIG,
+    custom_httpx::http_handler::{has_header, string_headers},
+};
+
 use super::Error;
-use super::types::{AudioTranscriptionRequest, ProviderAudioTranscriptionRequest};
-use crate::http_utils::{has_header, string_headers};
-use crate::litellm_core_utils::get_llm_provider_logic::{
-    CustomLlmProvider, get_custom_llm_provider,
+use crate::audio_transcription::types::{
+    AudioTranscriptionRequest, ProviderAudioTranscriptionRequest,
 };
-use litellm_providers::base_llm::audio_transcription::transformation::{
-    AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
-};
-use litellm_providers::bedrock::audio_transcription::BEDROCK_AUDIO_TRANSCRIPTION_CONFIG;
 
 fn provider_config(provider: &str) -> Option<&'static dyn BaseAudioTranscriptionConfig> {
     if provider == "bedrock" {

litellm-rust/crates/core/src/audio_transcription/tests.rs

@@ -1,11 +1,13 @@
-use std::io::{Read, Write};
-use std::net::TcpListener;
-use std::thread;
+use std::{
+    io::{Read, Write},
+    net::TcpListener,
+    thread,
+};
 
 use serde_json::{Map, json};
 
 use super::audio_transcription;
-use super::types::AudioTranscriptionRequest;
+use crate::audio_transcription::types::AudioTranscriptionRequest;
 
 #[tokio::test]
 async fn bedrock_request_is_signed_and_contains_audio() {

litellm-rust/crates/core/src/audio_transcription/types.rs

@@ -1,11 +1,9 @@
 use std::time::Duration;
 
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-
-use crate::base_llm::audio_transcription::transformation::{
+use litellm_llms::base_llm::audio_transcription::transformation::{
     AudioTranscriptionAuth, BaseAudioTranscriptionConfig,
 };
+use serde_json::{Map, Value};
 
 pub struct AudioTranscriptionRequest<'a> {
     pub model: &'a str,
@@ -52,21 +50,3 @@ impl ProviderAudioTranscriptionRequest {
         Self { body, ..self }
     }
 }
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct AudioTranscriptionRequestData {
-    pub body: Value,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct AudioTranscriptionResponseData {
-    pub text: String,
-}
-
-impl AudioTranscriptionResponseData {
-    pub fn into_json(self) -> Value {
-        serde_json::json!({
-            "text": self.text,
-        })
-    }
-}

litellm-rust/crates/core/src/call_arguments.rs

@@ -1,468 +0,0 @@
-use std::ops::Deref;
-
-use serde::{Deserialize, Serialize, de::DeserializeOwned};
-use serde_json::{Map, Value};
-
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct CallArguments(Map<String, Value>);
-
-impl CallArguments {
-    pub(crate) fn select(&self, names: &[&str]) -> Map<String, Value> {
-        self.iter()
-            .filter(|(name, _)| names.contains(&name.as_str()))
-            .map(|(name, value)| (name.clone(), value.clone()))
-            .collect()
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
-#[error("invalid argument: {path}")]
-pub struct ArgumentError {
-    pub path: String,
-}
-
-pub fn parse_options<T: DeserializeOwned>(arguments: &CallArguments) -> Result<T, ArgumentError> {
-    let deserializer = serde::de::value::MapDeserializer::new(
-        arguments.iter().map(|(name, value)| (name.as_str(), value)),
-    );
-    serde_path_to_error::deserialize(deserializer).map_err(|error| ArgumentError {
-        path: error.path().to_string(),
-    })
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ArgumentSpec {
-    pub name: &'static str,
-    pub secret: bool,
-}
-
-pub fn should_project(name: &str, consumed: &[ArgumentSpec], bound_fields: &[&str]) -> bool {
-    consumed.iter().any(|field| field.name == name)
-        || (!bound_fields.contains(&name) && !is_control(name))
-}
-
-pub fn is_control(name: &str) -> bool {
-    crate::params::is_control_param(name) || HOST_CONTROLS.contains(&name)
-}
-
-const HOST_CONTROLS: &[&str] = &[
-    "_agentic_loop_api_surface",
-    "_agentic_loop_depth",
-    "_agentic_loop_fingerprints",
-    "_code_interpreter_interception_active",
-    "_code_interpreter_interception_converted_stream",
-    "_code_interpreter_interception_sandbox_key",
-    "_code_interpreter_interception_session_scoped",
-    "_headroom_interception_converted_stream",
-    "_litellm_strip_stream_usage",
-    "_router_weights",
-    "_websearch_interception_converted_stream",
-    "_websearch_interception_emit_native_blocks",
-    "acompletion",
-    "adaptive_router_config",
-    "adaptive_router_default_model",
-    "aembedding",
-    "aimg_generation",
-    "allm_passthrough_route",
-    "allow_client_keepalive_override",
-    "allowed_model_region",
-    "allowed_openai_params",
-    "annotation_cost_per_page",
-    "api_version",
-    "arize_api_key",
-    "arize_space_id",
-    "arize_space_key",
-    "assistant_continue_message",
-    "async_call",
-    "atext_completion",
-    "attempted_targets",
-    "auto_router_config",
-    "auto_router_config_path",
-    "auto_router_default_model",
-    "auto_router_embedding_model",
-    "auto_router_max_input_chars",
-    "auto_router_model_compression",
-    "auto_router_routing_compression",
-    "aws_batch_role_arn",
-    "azure",
-    "azure_password",
-    "azure_username",
-    "base_model",
-    "bedrock_tags",
-    "bos_token",
-    "budget_duration",
-    "cache",
-    "cache_creation_input_audio_token_cost",
-    "cache_creation_input_token_cost",
-    "cache_creation_input_token_cost_above_1hr",
-    "cache_creation_input_token_cost_above_200k_tokens",
-    "cache_creation_input_token_cost_above_272k_tokens",
-    "cache_creation_input_token_cost_above_272k_tokens_flex",
-    "cache_creation_input_token_cost_above_272k_tokens_priority",
-    "cache_creation_input_token_cost_flex",
-    "cache_creation_input_token_cost_priority",
-    "cache_creation_input_token_cost_ultrafast",
-    "cache_key",
-    "cache_read_input_audio_token_cost",
-    "cache_read_input_token_cost",
-    "cache_read_input_token_cost_above_200k_tokens",
-    "cache_read_input_token_cost_above_200k_tokens_priority",
-    "cache_read_input_token_cost_above_272k_tokens",
-    "cache_read_input_token_cost_above_272k_tokens_flex",
-    "cache_read_input_token_cost_above_272k_tokens_priority",
-    "cache_read_input_token_cost_above_512k_tokens",
-    "cache_read_input_token_cost_flex",
-    "cache_read_input_token_cost_priority",
-    "cache_read_input_token_cost_ultrafast",
-    "caching",
-    "caching_groups",
-    "citation_cost_per_token",
-    "client",
-    "client_side_timeout",
-    "complete_response",
-    "completion_call_id",
-    "complexity_router_config",
-    "complexity_router_default_model",
-    "configurable_clientside_auth_params",
-    "context_window_fallback_dict",
-    "cooldown_time",
-    "cost_per_query",
-    "custom_prompt_dict",
-    "data_residency",
-    "dd_agent_host",
-    "dd_agent_port",
-    "dd_api_key",
-    "dd_site",
-    "default_api_key_rpm_limit",
-    "default_api_key_tpm_limit",
-    "disable_add_transform_inline_image_block",
-    "enable_json_schema_validation",
-    "enable_prompt_caching",
-    "enable_tag_filtering",
-    "ensure_alternating_roles",
-    "eos_token",
-    "fallback_depth",
-    "fallbacks",
-    "fastest_response",
-    "final_prompt_value",
-    "force_timeout",
-    "gcs_bucket_name",
-    "gcs_path_service_account",
-    "google_maps_grounding_cost_per_query",
-    "headers",
-    "hf_model_name",
-    "humanloop_api_key",
-    "id",
-    "input_cost_per_audio_per_second",
-    "input_cost_per_audio_per_second_above_128k_tokens",
-    "input_cost_per_audio_token",
-    "input_cost_per_audio_token_batches",
-    "input_cost_per_character",
-    "input_cost_per_character_above_128k_tokens",
-    "input_cost_per_image",
-    "input_cost_per_image_above_128k_tokens",
-    "input_cost_per_image_token",
-    "input_cost_per_image_token_batches",
-    "input_cost_per_pixel",
-    "input_cost_per_query",
-    "input_cost_per_second",
-    "input_cost_per_token",
-    "input_cost_per_token_above_128k_tokens",
-    "input_cost_per_token_above_200k_tokens",
-    "input_cost_per_token_above_200k_tokens_priority",
-    "input_cost_per_token_above_272k_tokens",
-    "input_cost_per_token_above_272k_tokens_flex",
-    "input_cost_per_token_above_272k_tokens_priority",
-    "input_cost_per_token_above_512k_tokens",
-    "input_cost_per_token_batches",
-    "input_cost_per_token_cache_hit",
-    "input_cost_per_token_flex",
-    "input_cost_per_token_priority",
-    "input_cost_per_token_ultrafast",
-    "input_cost_per_video_per_second",
-    "input_cost_per_video_per_second_above_128k_tokens",
-    "input_cost_per_video_per_second_above_15s_interval",
-    "input_cost_per_video_per_second_above_8s_interval",
-    "input_cost_per_video_token",
-    "input_cost_per_video_token_batches",
-    "itpm",
-    "keepalive_seconds",
-    "langfuse_environment",
-    "langfuse_host",
-    "langfuse_prompt_version",
-    "langfuse_public_key",
-    "langfuse_secret",
-    "langfuse_secret_key",
-    "langsmith_api_key",
-    "langsmith_base_url",
-    "langsmith_project",
-    "langsmith_sampling_rate",
-    "langsmith_tenant_id",
-    "litellm_credential_name",
-    "litellm_disabled_callbacks",
-    "litellm_request_debug",
-    "litellm_session_id",
-    "litellm_system_prompt",
-    "litellm_trace_id",
-    "litellm_trusted_callback_vars",
-    "logger_fn",
-    "max_agentic_loops",
-    "max_budget",
-    "max_fallbacks",
-    "max_parallel_requests",
-    "merge_reasoning_content_in_choices",
-    "metadata",
-    "mock_response",
-    "mock_timeout",
-    "model_alias_map",
-    "model_config",
-    "model_file_id_mapping",
-    "model_info",
-    "model_list",
-    "newrelic_api_key",
-    "newrelic_region",
-    "no-log",
-    "num_retries",
-    "ocr_cost_per_credit",
-    "ocr_cost_per_page",
-    "order",
-    "otpm",
-    "output_cost_per_audio_per_second",
-    "output_cost_per_audio_token",
-    "output_cost_per_character",
-    "output_cost_per_character_above_128k_tokens",
-    "output_cost_per_image",
-    "output_cost_per_image_token",
-    "output_cost_per_pixel",
-    "output_cost_per_reasoning_token",
-    "output_cost_per_reasoning_token_flex",
-    "output_cost_per_reasoning_token_priority",
-    "output_cost_per_second",
-    "output_cost_per_second_1080p",
-    "output_cost_per_second_480p",
-    "output_cost_per_second_4k",
-    "output_cost_per_second_720p",
-    "output_cost_per_token",
-    "output_cost_per_token_above_128k_tokens",
-    "output_cost_per_token_above_200k_tokens",
-    "output_cost_per_token_above_200k_tokens_priority",
-    "output_cost_per_token_above_272k_tokens",
-    "output_cost_per_token_above_272k_tokens_flex",
-    "output_cost_per_token_above_272k_tokens_priority",
-    "output_cost_per_token_above_512k_tokens",
-    "output_cost_per_token_batches",
-    "output_cost_per_token_flex",
-    "output_cost_per_token_priority",
-    "output_cost_per_token_ultrafast",
-    "output_cost_per_video_per_second",
-    "output_cost_per_video_token",
-    "output_vector_size",
-    "posthog_api_key",
-    "posthog_api_url",
-    "preset_cache_key",
-    "prompt_environment",
-    "prompt_id",
-    "prompt_label",
-    "prompt_variables",
-    "prompt_version",
-    "provider_specific_header",
-    "quality_router_config",
-    "quality_router_default_model",
-    "region_name",
-    "regional_endpoint_uplift_multiplier",
-    "regional_processing_uplift_multiplier_eu",
-    "regional_processing_uplift_multiplier_us",
-    "retry_policy",
-    "retry_strategy",
-    "roles",
-    "routing_strategy",
-    "rpm",
-    "rust",
-    "s3_bucket_name",
-    "s3_output_bucket_name",
-    "s3_region_name",
-    "search_context_cost_per_query",
-    "search_tool_name",
-    "secret_fields",
-    "self",
-    "shared_session",
-    "ssl_verify",
-    "stream_response",
-    "stream_timeout",
-    "supports_system_message",
-    "tags",
-    "text_completion",
-    "tiered_pricing",
-    "tpm",
-    "ttl",
-    "turn_off_message_logging",
-    "use_chat_completions_api",
-    "use_client",
-    "use_in_pass_through",
-    "use_litellm_proxy",
-    "use_xai_oauth",
-    "user_continue_message",
-    "verbose",
-    "wandb_api_key",
-    "weave_project_id",
-    "weight",
-];
-
-pub fn compose_body<B: Serialize>(
-    arguments: &CallArguments,
-    body: &B,
-    consumed: &[&str],
-) -> Result<Value, crate::params::Error> {
-    let Value::Object(fields) =
-        serde_json::to_value(body).map_err(|_| crate::params::Error::Body)?
-    else {
-        return Err(crate::params::Error::Body);
-    };
-    let overrides = match arguments.get("extra_body") {
-        None | Some(Value::Null) => None,
-        Some(Value::Object(fields)) => Some(fields),
-        Some(_) => return Err(crate::params::Error::ExtraBody),
-    };
-    let extensions = arguments.iter().filter(|(name, _)| {
-        !consumed.contains(&name.as_str()) && name.as_str() != "extra_body" && !is_control(name)
-    });
-    Ok(Value::Object(
-        fields
-            .into_iter()
-            .chain(
-                extensions
-                    .chain(overrides.into_iter().flatten())
-                    .filter(|(name, _)| {
-                        name.as_str() != "model"
-                            && name.as_str() != "extra_body"
-                            && !crate::params::is_control_param(name)
-                    })
-                    .map(|(name, value)| (name.clone(), value.clone())),
-            )
-            .collect(),
-    ))
-}
-
-impl Deref for CallArguments {
-    type Target = Map<String, Value>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<Map<String, Value>> for CallArguments {
-    fn from(values: Map<String, Value>) -> Self {
-        Self(values)
-    }
-}
-
-impl From<CallArguments> for Map<String, Value> {
-    fn from(arguments: CallArguments) -> Self {
-        arguments.0
-    }
-}
-
-impl FromIterator<(String, Value)> for CallArguments {
-    fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> Self {
-        Self(iter.into_iter().collect())
-    }
-}
-
-impl IntoIterator for CallArguments {
-    type Item = (String, Value);
-    type IntoIter = serde_json::map::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    use super::*;
-
-    #[test]
-    fn composition_preserves_extensions_and_applies_shallow_explicit_overrides() {
-        let original = json!({
-            "known": false, "future": {"old": 1}, "null": null, "zero": 0,
-            "metadata": {"host": true}, "shared_session": "host", "api_key": "secret",
-            "extra_body": {
-                "known": null, "future": {"new": [false, 0, null]},
-                "metadata": {"provider": true}, "model": "ignored", "api_key": "ignored"
-            }
-        });
-        let arguments = serde_json::from_value(original.clone()).unwrap();
-        let body = compose_body(
-            &arguments,
-            &json!({"model":"resolved", "known":false}),
-            &["known"],
-        )
-        .unwrap();
-        assert_eq!(
-            body,
-            json!({
-                "model":"resolved", "known":null, "future":{"new":[false,0,null]},
-                "null":null, "zero":0, "metadata":{"provider":true}
-            })
-        );
-        assert_eq!(serde_json::to_value(arguments).unwrap(), original);
-    }
-
-    #[test]
-    fn projection_prioritizes_consumed_fields_and_keeps_unknown_names() {
-        let fields = [ArgumentSpec {
-            name: "id",
-            secret: false,
-        }];
-        assert!(should_project("id", &fields, &[]));
-        assert!(!should_project("id", &[], &[]));
-        assert!(should_project("future_option", &[], &[]));
-        assert!(!should_project("document", &fields, &["document"]));
-        assert!(!should_project("metadata", &fields, &[]));
-        assert!(!should_project("callbacks", &fields, &[]));
-        assert!(!should_project("ocr_cost_per_page", &fields, &[]));
-    }
-
-    #[test]
-    fn invalid_extra_body_is_rejected_without_coercing_it_to_empty() {
-        for value in [json!(false), json!(0), json!([]), json!("")] {
-            let arguments = serde_json::from_value(json!({"extra_body":value})).unwrap();
-            assert_eq!(
-                compose_body(&arguments, &json!({}), &[]),
-                Err(crate::params::Error::ExtraBody)
-            );
-        }
-        let arguments = serde_json::from_value(json!({"extra_body":null})).unwrap();
-        assert_eq!(
-            compose_body(&arguments, &json!({}), &[]).unwrap(),
-            json!({})
-        );
-    }
-
-    #[test]
-    fn typed_views_preserve_missing_and_explicit_null_in_the_source() {
-        #[derive(Deserialize)]
-        struct Options {
-            enabled: Option<bool>,
-        }
-        let arguments: CallArguments =
-            serde_json::from_value(json!({"enabled":null,"future":0})).unwrap();
-        assert!(
-            parse_options::<Options>(&arguments)
-                .unwrap()
-                .enabled
-                .is_none()
-        );
-        assert_eq!(arguments.get("enabled"), Some(&Value::Null));
-        assert_eq!(arguments.get("missing"), None);
-        let invalid = serde_json::from_value(json!({"enabled":0})).unwrap();
-        assert_eq!(
-            parse_options::<Options>(&invalid).err().unwrap().path,
-            "enabled"
-        );
-    }
-}

litellm-rust/crates/core/src/call_lifecycle/host.rs

@@ -1,122 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-
-pub enum HostCallStep<O, C> {
-    Host(O),
-    Complete(C),
-}
-
-pub type HostCallFuture<'a, O, C, E> =
-    Pin<Box<dyn Future<Output = Result<HostCallStep<O, C>, E>> + Send + 'a>>;
-
-pub trait HostCall: Send + Sync {
-    type Error: Send + Sync + 'static;
-    type Operation: Send + 'static;
-    type Result: Send + 'static;
-    type Complete: Send + 'static;
-
-    fn resume(
-        &mut self,
-        result: Option<Self::Result>,
-    ) -> HostCallFuture<'_, Self::Operation, Self::Complete, Self::Error>;
-
-    fn interrupt(
-        &mut self,
-        failure: HostFailure<Self::Error>,
-    ) -> HostCallFuture<'_, Self::Operation, Self::Complete, Self::Error>;
-}
-
-pub enum HostStep<V, S> {
-    Ready(V),
-    Suspend(S),
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HostPhase {
-    Setup,
-    DeploymentPreCall,
-    Prepare,
-    Execute,
-    ConstructResponse,
-    DeploymentPostCall,
-    Finalize,
-    Success,
-    MapFailure,
-    DeploymentFailure,
-    Failure,
-    AsyncFailure,
-    Complete,
-}
-
-#[derive(Clone, Debug)]
-pub enum HostFailure<E> {
-    Error(E),
-    Cancelled(E),
-}
-
-pub struct HostLifecycle {
-    phase: HostPhase,
-    asynchronous: bool,
-}
-
-impl HostLifecycle {
-    pub fn new(asynchronous: bool) -> Self {
-        Self {
-            phase: HostPhase::Setup,
-            asynchronous,
-        }
-    }
-
-    pub fn phase(&self) -> HostPhase {
-        self.phase
-    }
-
-    pub fn accept<E>(&mut self, result: Result<(), HostFailure<E>>) -> Option<E> {
-        if let Err(failure) = result {
-            if self.phase == HostPhase::DeploymentFailure {
-                self.phase = HostPhase::Failure;
-                return None;
-            }
-            let error = match failure {
-                HostFailure::Cancelled(error) => {
-                    self.phase = HostPhase::Complete;
-                    return Some(error);
-                }
-                HostFailure::Error(error) => error,
-            };
-            match self.phase {
-                HostPhase::Failure | HostPhase::AsyncFailure => {
-                    self.advance();
-                    return None;
-                }
-                HostPhase::Success => self.phase = HostPhase::Complete,
-                HostPhase::Execute | HostPhase::ConstructResponse => {
-                    self.phase = HostPhase::MapFailure;
-                }
-                _ => self.phase = HostPhase::Failure,
-            }
-            return Some(error);
-        }
-        self.advance();
-        None
-    }
-
-    fn advance(&mut self) {
-        self.phase = match self.phase {
-            HostPhase::Setup if self.asynchronous => HostPhase::DeploymentPreCall,
-            HostPhase::Setup | HostPhase::DeploymentPreCall => HostPhase::Prepare,
-            HostPhase::Prepare => HostPhase::Execute,
-            HostPhase::Execute => HostPhase::ConstructResponse,
-            HostPhase::ConstructResponse if self.asynchronous => HostPhase::DeploymentPostCall,
-            HostPhase::ConstructResponse | HostPhase::DeploymentPostCall => HostPhase::Finalize,
-            HostPhase::Finalize => HostPhase::Success,
-            HostPhase::MapFailure if self.asynchronous => HostPhase::DeploymentFailure,
-            HostPhase::MapFailure | HostPhase::DeploymentFailure => HostPhase::Failure,
-            HostPhase::Failure if self.asynchronous => HostPhase::AsyncFailure,
-            HostPhase::Failure
-            | HostPhase::AsyncFailure
-            | HostPhase::Success
-            | HostPhase::Complete => HostPhase::Complete,
-        };
-    }
-}

litellm-rust/crates/core/src/call_lifecycle/mod.rs

@@ -1,427 +0,0 @@
-use std::future::Future;
-use std::time::{Instant, SystemTime, UNIX_EPOCH};
-
-pub mod host;
-#[cfg(test)]
-#[path = "../../tests/host_lifecycle.rs"]
-mod host_tests;
-pub mod types;
-
-pub use types::{
-    CallLifecycleContext, CallLifecyclePhase, CallLifecyclePhaseTiming, CallLifecycleRequest,
-    CallLifecycleTiming,
-};
-
-pub trait CallLifecycleHooks<InitialReq, ProviderReq, Resp>: Send + Sync {
-    type Error: Send + Sync;
-    type PreCallFuture<'a>: Future<Output = Result<InitialReq, Self::Error>> + Send + 'a
-    where
-        Self: 'a,
-        InitialReq: 'a,
-        ProviderReq: 'a,
-        Resp: 'a;
-
-    type DuringCallFuture<'a>: Future<Output = Result<ProviderReq, Self::Error>> + Send + 'a
-    where
-        Self: 'a,
-        InitialReq: 'a,
-        ProviderReq: 'a,
-        Resp: 'a;
-
-    type SuccessFuture<'a>: Future<Output = ()> + Send + 'a
-    where
-        Self: 'a,
-        Resp: 'a;
-
-    type FailureFuture<'a>: Future<Output = ()> + Send + 'a
-    where
-        Self: 'a;
-
-    fn async_pre_call_hook<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        request: InitialReq,
-    ) -> Self::PreCallFuture<'a>;
-
-    fn async_during_call_hook<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        request: InitialReq,
-    ) -> Self::DuringCallFuture<'a>;
-
-    fn async_log_success_event<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        response: &'a Resp,
-        timing: &'a CallLifecycleTiming,
-    ) -> Self::SuccessFuture<'a>;
-
-    fn async_log_failure_event<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        error: &'a Self::Error,
-        timing: &'a CallLifecycleTiming,
-    ) -> Self::FailureFuture<'a>;
-}
-
-pub trait CallLifecycleObserver: Send + Sync {
-    fn on_phase_start(&self, _context: &CallLifecycleContext, _phase: CallLifecyclePhase) {}
-
-    fn on_phase_end(&self, _context: &CallLifecycleContext, _timing: &CallLifecyclePhaseTiming) {}
-}
-
-#[derive(Default)]
-pub struct NoopCallLifecycleObserver;
-
-impl CallLifecycleObserver for NoopCallLifecycleObserver {}
-
-pub struct CallLifecycle<'a> {
-    observer: &'a dyn CallLifecycleObserver,
-}
-
-impl<'a> CallLifecycle<'a> {
-    pub fn new(observer: &'a dyn CallLifecycleObserver) -> Self {
-        Self { observer }
-    }
-
-    pub async fn run_request<InitialReq, ProviderReq, Resp, Hooks, ProviderCall, ProviderFuture>(
-        &self,
-        request: InitialReq,
-        hooks: &Hooks,
-        provider_call: ProviderCall,
-    ) -> Result<Resp, Hooks::Error>
-    where
-        InitialReq: CallLifecycleRequest,
-        Hooks: CallLifecycleHooks<InitialReq, ProviderReq, Resp>,
-        ProviderCall: FnOnce(ProviderReq) -> ProviderFuture,
-        ProviderFuture: Future<Output = Result<Resp, Hooks::Error>>,
-    {
-        let context = request.lifecycle_context();
-        self.run(context, request, hooks, provider_call).await
-    }
-
-    pub async fn run<InitialReq, ProviderReq, Resp, Hooks, ProviderCall, ProviderFuture>(
-        &self,
-        context: CallLifecycleContext,
-        request: InitialReq,
-        hooks: &Hooks,
-        provider_call: ProviderCall,
-    ) -> Result<Resp, Hooks::Error>
-    where
-        Hooks: CallLifecycleHooks<InitialReq, ProviderReq, Resp>,
-        ProviderCall: FnOnce(ProviderReq) -> ProviderFuture,
-        ProviderFuture: Future<Output = Result<Resp, Hooks::Error>>,
-    {
-        let call_start = epoch_seconds();
-        let mut phases = Vec::new();
-
-        let pre_call = self.start_phase(&context, CallLifecyclePhase::PreCall);
-        let request = match hooks.async_pre_call_hook(&context, request).await {
-            Ok(request) => {
-                phases.push(self.finish_phase(&context, pre_call));
-                request
-            }
-            Err(error) => {
-                phases.push(self.finish_phase(&context, pre_call));
-                self.log_failure(&context, hooks, &error, call_start, &mut phases)
-                    .await;
-                return Err(error);
-            }
-        };
-
-        let during_call = self.start_phase(&context, CallLifecyclePhase::DuringCall);
-        let provider_request = match hooks.async_during_call_hook(&context, request).await {
-            Ok(request) => {
-                phases.push(self.finish_phase(&context, during_call));
-                request
-            }
-            Err(error) => {
-                phases.push(self.finish_phase(&context, during_call));
-                self.log_failure(&context, hooks, &error, call_start, &mut phases)
-                    .await;
-                return Err(error);
-            }
-        };
-
-        let provider_phase = self.start_phase(&context, CallLifecyclePhase::ProviderCall);
-        let result = provider_call(provider_request).await;
-        phases.push(self.finish_phase(&context, provider_phase));
-
-        match &result {
-            Ok(response) => {
-                let success_phase = self.start_phase(&context, CallLifecyclePhase::SuccessCallback);
-                let timing = CallLifecycleTiming::new(call_start, epoch_seconds(), phases.clone());
-                hooks
-                    .async_log_success_event(&context, response, &timing)
-                    .await;
-                phases.push(self.finish_phase(&context, success_phase));
-            }
-            Err(error) => {
-                self.log_failure(&context, hooks, error, call_start, &mut phases)
-                    .await;
-            }
-        }
-
-        result
-    }
-
-    async fn log_failure<InitialReq, ProviderReq, Resp, Hooks>(
-        &self,
-        context: &CallLifecycleContext,
-        hooks: &Hooks,
-        error: &Hooks::Error,
-        call_start: f64,
-        phases: &mut Vec<CallLifecyclePhaseTiming>,
-    ) where
-        Hooks: CallLifecycleHooks<InitialReq, ProviderReq, Resp>,
-    {
-        let failure_phase = self.start_phase(context, CallLifecyclePhase::FailureCallback);
-        let timing = CallLifecycleTiming::new(call_start, epoch_seconds(), phases.clone());
-        hooks.async_log_failure_event(context, error, &timing).await;
-        phases.push(self.finish_phase(context, failure_phase));
-    }
-
-    fn start_phase(&self, context: &CallLifecycleContext, phase: CallLifecyclePhase) -> PhaseStart {
-        self.observer.on_phase_start(context, phase);
-        PhaseStart {
-            phase,
-            start_time: epoch_seconds(),
-            started_at: Instant::now(),
-        }
-    }
-
-    fn finish_phase(
-        &self,
-        context: &CallLifecycleContext,
-        phase_start: PhaseStart,
-    ) -> CallLifecyclePhaseTiming {
-        let timing = CallLifecyclePhaseTiming {
-            phase: phase_start.phase,
-            start_time: phase_start.start_time,
-            end_time: epoch_seconds(),
-            duration: phase_start.started_at.elapsed(),
-        };
-        self.observer.on_phase_end(context, &timing);
-        timing
-    }
-}
-
-impl Default for CallLifecycle<'static> {
-    fn default() -> Self {
-        static OBSERVER: NoopCallLifecycleObserver = NoopCallLifecycleObserver;
-        Self::new(&OBSERVER)
-    }
-}
-
-struct PhaseStart {
-    phase: CallLifecyclePhase,
-    start_time: f64,
-    started_at: Instant,
-}
-
-fn epoch_seconds() -> f64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|duration| duration.as_secs_f64())
-        .unwrap_or(0.0)
-}
-
-#[cfg(test)]
-mod tests {
-    use std::pin::Pin;
-    use std::sync::Mutex;
-
-    use super::*;
-
-    type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
-
-    #[derive(Default)]
-    struct RecordingHooks {
-        events: Mutex<Vec<&'static str>>,
-    }
-
-    struct RecordingRequest(String);
-
-    impl CallLifecycleRequest for RecordingRequest {
-        fn lifecycle_context(&self) -> CallLifecycleContext {
-            CallLifecycleContext::new("ocr", "mistral-ocr-latest", "mistral", "call_1")
-        }
-    }
-
-    impl RecordingHooks {
-        fn events(&self) -> Vec<&'static str> {
-            self.events.lock().unwrap().clone()
-        }
-    }
-
-    impl CallLifecycleHooks<String, String, String> for RecordingHooks {
-        type Error = crate::messages::Error;
-        type PreCallFuture<'a> = BoxFuture<'a, Result<String, crate::messages::Error>>;
-        type DuringCallFuture<'a> = BoxFuture<'a, Result<String, crate::messages::Error>>;
-        type SuccessFuture<'a> = BoxFuture<'a, ()>;
-        type FailureFuture<'a> = BoxFuture<'a, ()>;
-
-        fn async_pre_call_hook<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            request: String,
-        ) -> Self::PreCallFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("pre_call");
-                Ok(format!("{request}:pre"))
-            })
-        }
-
-        fn async_during_call_hook<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            request: String,
-        ) -> Self::DuringCallFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("during_call");
-                Ok(format!("{request}:during"))
-            })
-        }
-
-        fn async_log_success_event<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            _response: &'a String,
-            timing: &'a CallLifecycleTiming,
-        ) -> Self::SuccessFuture<'a> {
-            Box::pin(async move {
-                assert!(timing.end_time >= timing.start_time);
-                assert_eq!(timing.phases.len(), 3);
-                self.events.lock().unwrap().push("success");
-            })
-        }
-
-        fn async_log_failure_event<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            _error: &'a crate::messages::Error,
-            _timing: &'a CallLifecycleTiming,
-        ) -> Self::FailureFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("failure");
-            })
-        }
-    }
-
-    impl CallLifecycleHooks<RecordingRequest, String, String> for RecordingHooks {
-        type Error = crate::messages::Error;
-        type PreCallFuture<'a> = BoxFuture<'a, Result<RecordingRequest, crate::messages::Error>>;
-        type DuringCallFuture<'a> = BoxFuture<'a, Result<String, crate::messages::Error>>;
-        type SuccessFuture<'a> = BoxFuture<'a, ()>;
-        type FailureFuture<'a> = BoxFuture<'a, ()>;
-
-        fn async_pre_call_hook<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            request: RecordingRequest,
-        ) -> Self::PreCallFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("pre_call");
-                Ok(RecordingRequest(format!("{}:pre", request.0)))
-            })
-        }
-
-        fn async_during_call_hook<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            request: RecordingRequest,
-        ) -> Self::DuringCallFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("during_call");
-                Ok(format!("{}:during", request.0))
-            })
-        }
-
-        fn async_log_success_event<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            _response: &'a String,
-            _timing: &'a CallLifecycleTiming,
-        ) -> Self::SuccessFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("success");
-            })
-        }
-
-        fn async_log_failure_event<'a>(
-            &'a self,
-            _context: &'a CallLifecycleContext,
-            _error: &'a crate::messages::Error,
-            _timing: &'a CallLifecycleTiming,
-        ) -> Self::FailureFuture<'a> {
-            Box::pin(async move {
-                self.events.lock().unwrap().push("failure");
-            })
-        }
-    }
-
-    #[tokio::test]
-    async fn lifecycle_runs_hooks_around_provider_call() {
-        let hooks = RecordingHooks::default();
-        let response = CallLifecycle::default()
-            .run(
-                CallLifecycleContext::new("ocr", "mistral-ocr-latest", "mistral", "call_1"),
-                "request".to_string(),
-                &hooks,
-                |request| async move {
-                    assert_eq!(request, "request:pre:during");
-                    Ok("response".to_string())
-                },
-            )
-            .await
-            .expect("call succeeds");
-
-        assert_eq!(response, "response");
-        assert_eq!(hooks.events(), vec!["pre_call", "during_call", "success"]);
-    }
-
-    #[tokio::test]
-    async fn lifecycle_logs_failure_when_provider_fails() {
-        let hooks = RecordingHooks::default();
-        let error = CallLifecycle::default()
-            .run(
-                CallLifecycleContext::new("ocr", "mistral-ocr-latest", "mistral", "call_1"),
-                "request".to_string(),
-                &hooks,
-                |_request| async move {
-                    Err::<String, crate::messages::Error>(crate::messages::Error::Transport(
-                        crate::transport::Error::Network("provider down".to_string()),
-                    ))
-                },
-            )
-            .await
-            .expect_err("call fails");
-
-        assert_eq!(
-            error,
-            crate::messages::Error::Transport(crate::transport::Error::Network(
-                "provider down".to_string()
-            ))
-        );
-        assert_eq!(hooks.events(), vec!["pre_call", "during_call", "failure"]);
-    }
-
-    #[tokio::test]
-    async fn lifecycle_can_run_any_request_with_embedded_context() {
-        let hooks = RecordingHooks::default();
-        let response = CallLifecycle::default()
-            .run_request(
-                RecordingRequest("request".to_string()),
-                &hooks,
-                |request| async move {
-                    assert_eq!(request, "request:pre:during");
-                    Ok("response".to_string())
-                },
-            )
-            .await
-            .expect("call succeeds");
-
-        assert_eq!(response, "response");
-        assert_eq!(hooks.events(), vec!["pre_call", "during_call", "success"]);
-    }
-}

litellm-rust/crates/core/src/call_lifecycle/types.rs

@@ -1,75 +0,0 @@
-use std::time::Duration;
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CallLifecycleContext {
-    pub call_type: String,
-    pub model: String,
-    pub custom_llm_provider: String,
-    pub litellm_call_id: String,
-}
-
-impl CallLifecycleContext {
-    pub fn new(
-        call_type: impl Into<String>,
-        model: impl Into<String>,
-        custom_llm_provider: impl Into<String>,
-        litellm_call_id: impl Into<String>,
-    ) -> Self {
-        Self {
-            call_type: call_type.into(),
-            model: model.into(),
-            custom_llm_provider: custom_llm_provider.into(),
-            litellm_call_id: litellm_call_id.into(),
-        }
-    }
-}
-
-pub trait CallLifecycleRequest {
-    fn lifecycle_context(&self) -> CallLifecycleContext;
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum CallLifecyclePhase {
-    PreCall,
-    DuringCall,
-    ProviderCall,
-    SuccessCallback,
-    FailureCallback,
-}
-
-impl CallLifecyclePhase {
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::PreCall => "pre_call",
-            Self::DuringCall => "during_call",
-            Self::ProviderCall => "provider_call",
-            Self::SuccessCallback => "success_callback",
-            Self::FailureCallback => "failure_callback",
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct CallLifecyclePhaseTiming {
-    pub phase: CallLifecyclePhase,
-    pub start_time: f64,
-    pub end_time: f64,
-    pub duration: Duration,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct CallLifecycleTiming {
-    pub start_time: f64,
-    pub end_time: f64,
-    pub phases: Vec<CallLifecyclePhaseTiming>,
-}
-
-impl CallLifecycleTiming {
-    pub fn new(start_time: f64, end_time: f64, phases: Vec<CallLifecyclePhaseTiming>) -> Self {
-        Self {
-            start_time,
-            end_time,
-            phases,
-        }
-    }
-}

litellm-rust/crates/core/src/chat_completions/client.rs

@@ -1,5 +1,4 @@
-use std::sync::OnceLock;
-use std::time::Duration;
+use std::{sync::OnceLock, time::Duration};
 
 use crate::constants::{CHAT_COMPLETIONS_CONNECT_TIMEOUT_SECS, CHAT_COMPLETIONS_TIMEOUT_SECS};
 

litellm-rust/crates/core/src/chat_completions/common_utils.rs

@@ -1,18 +1,19 @@
+use litellm_llms::{
+    anthropic::chat::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG,
+    base_llm::chat::transformation::BaseConfig,
+    bedrock::chat::converse_transformation::BEDROCK_CHAT_COMPLETIONS_CONFIG,
+    custom_httpx::http_handler::string_headers as shared_string_headers,
+};
 use serde_json::{Map, Value};
 
 use super::Error;
-use crate::http_utils::string_headers as shared_string_headers;
-use litellm_providers::anthropic::chat::transformation::ANTHROPIC_CHAT_COMPLETIONS_CONFIG;
-use litellm_providers::base_llm::chat::transformation::BaseConfig;
 
 const HEADER_CONTEXT: &str = "chat completions";
 
 pub(super) fn chat_completions_provider_config(provider: &str) -> Option<&'static dyn BaseConfig> {
     match provider {
         "anthropic" => Some(&ANTHROPIC_CHAT_COMPLETIONS_CONFIG),
-        "bedrock" => Some(
-            &litellm_providers::bedrock::chat::converse_transformation::BEDROCK_CHAT_COMPLETIONS_CONFIG,
-        ),
+        "bedrock" => Some(&BEDROCK_CHAT_COMPLETIONS_CONFIG),
         _ => None,
     }
 }

litellm-rust/crates/core/src/chat_completions/error.rs

@@ -1,3 +1,5 @@
+use litellm_llms::base_llm::chat::transformation::Error as LlmError;
+
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum Error {
     #[error("expected {expected}, got {actual}")]
@@ -18,25 +20,22 @@ pub enum Error {
     #[error(transparent)]
     Auth(#[from] litellm_auth::Error),
     #[error(transparent)]
-    Transport(#[from] crate::transport::Error),
+    Transport(#[from] litellm_llms::custom_httpx::transport::Error),
     #[error(transparent)]
-    Headers(#[from] crate::http_utils::HeaderError),
+    Headers(#[from] litellm_llms::custom_httpx::http_handler::HeaderError),
     #[error(transparent)]
     Aws(#[from] litellm_auth_aws::Error),
 }
 
-impl From<litellm_providers::chat::Error> for Error {
-    fn from(error: litellm_providers::chat::Error) -> Self {
+impl From<LlmError> for Error {
+    fn from(error: LlmError) -> Self {
         match error {
-            litellm_providers::chat::Error::MissingField(field) => Self::MissingField(field),
-            litellm_providers::chat::Error::InvalidRequest(message) => {
-                Self::InvalidRequest(message)
-            }
-            litellm_providers::chat::Error::InvalidResponse(message) => {
-                Self::InvalidResponse(message)
-            }
-            litellm_providers::chat::Error::Unsupported(reason) => Self::Unsupported(reason),
-            litellm_providers::chat::Error::Auth(error) => Self::Auth(error),
+            LlmError::InvalidType { expected, actual } => Self::InvalidType { expected, actual },
+            LlmError::MissingField(field) => Self::MissingField(field),
+            LlmError::InvalidRequest(message) => Self::InvalidRequest(message),
+            LlmError::InvalidResponse(message) => Self::InvalidResponse(message),
+            LlmError::Unsupported(reason) => Self::Unsupported(reason),
+            LlmError::Auth(error) => Self::Auth(error),
         }
     }
 }

litellm-rust/crates/core/src/chat_completions/handler.rs

@@ -1,14 +1,14 @@
+use litellm_llms::{
+    base_llm::chat::transformation::{ChatCompletionsAuth, ProviderChatResponseData},
+    custom_httpx::http_handler::{http_request, truncate_error_body},
+};
+use litellm_types::utils::ChatCompletionsResponse;
 use serde_json::Value;
 
-use super::Error;
-use super::client::http_client;
-use super::prepare::prepare_provider_request;
-use super::types::{
-    ChatCompletionsResponse, ProviderChatCompletionsRequest, ProviderChatResponseData,
-    ResolvedChatCompletionsRequest,
+use super::{Error, client::http_client, prepare::prepare_provider_request};
+use crate::chat_completions::types::{
+    ProviderChatCompletionsRequest, ResolvedChatCompletionsRequest,
 };
-use crate::http_utils::{http_request, truncate_error_body};
-use litellm_providers::base_llm::chat::transformation::ChatCompletionsAuth;
 
 pub(super) async fn execute_chat_completions_provider_call(
     request: ResolvedChatCompletionsRequest<'_>,
@@ -34,23 +34,30 @@ pub(super) async fn execute_chat_completions_provider_call(
         // so the host can still serve it. Everything else here, a timeout
         // above all, may have reached the provider and been answered.
         if err.is_connect() || err.is_builder() {
-            Error::Transport(crate::transport::Error::Connect(err.to_string()))
+            Error::Transport(litellm_llms::custom_httpx::transport::Error::Connect(
+                err.to_string(),
+            ))
         } else {
-            Error::Transport(crate::transport::Error::Network(err.to_string()))
+            Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+                err.to_string(),
+            ))
         }
     })?;
 
     let status = response.status();
-    let text = response
-        .text()
-        .await
-        .map_err(|err| Error::Transport(crate::transport::Error::Network(err.to_string())))?;
+    let text = response.text().await.map_err(|err| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            err.to_string(),
+        ))
+    })?;
 
     if !status.is_success() {
-        return Err(Error::Transport(crate::transport::Error::Http {
-            status: status.as_u16(),
-            body: truncate_error_body(&text),
-        }));
+        return Err(Error::Transport(
+            litellm_llms::custom_httpx::transport::Error::Http {
+                status: status.as_u16(),
+                body: truncate_error_body(&text),
+            },
+        ));
     }
 
     let body: Value = serde_json::from_str(&text).map_err(|err| {
@@ -75,7 +82,9 @@ pub(super) async fn execute_chat_completions_provider_call(
 pub(super) fn as_response_error(err: Error) -> Error {
     match err {
         already @ (Error::InvalidResponse(_)
-        | Error::Transport(crate::transport::Error::Http { .. })) => already,
+        | Error::Transport(litellm_llms::custom_httpx::transport::Error::Http {
+            ..
+        })) => already,
         other => Error::InvalidResponse(other.to_string()),
     }
 }
@@ -84,8 +93,7 @@ pub(super) async fn signed_headers(
     request: &ProviderChatCompletionsRequest,
     body: &[u8],
 ) -> Result<Vec<(String, String)>, Error> {
-    use std::collections::BTreeMap;
-    use std::time::SystemTime;
+    use std::{collections::BTreeMap, time::SystemTime};
 
     use litellm_auth_aws::{
         aws_auth_config, aws_signature_headers, host_supplied_credentials,

litellm-rust/crates/core/src/chat_completions/mod.rs

@@ -7,19 +7,18 @@
 //! calls the provider, and returns a typed OpenAI-shaped response.
 
 mod error;
+pub mod types;
 pub use error::Error;
 mod client;
 mod common_utils;
-pub use litellm_providers::chat::{conversation, response_utils};
 pub(crate) mod handler;
 mod prepare;
-pub mod streaming;
-pub use litellm_providers::chat::types;
-
 use handler::execute_chat_completions_provider_call;
+use litellm_types::utils::ChatCompletionsResponse;
 use prepare::{parse_messages, resolve_provider_config, resolve_request};
 use serde_json::{Map, Value};
-use types::{ChatCompletionsRequest, ChatCompletionsResponse};
+
+use crate::chat_completions::types::ChatCompletionsRequest;
 
 pub async fn chat_completions(
     request: ChatCompletionsRequest<'_>,

litellm-rust/crates/core/src/chat_completions/prepare.rs

@@ -1,16 +1,18 @@
+use litellm_core_utils::get_llm_provider_logic::{CustomLlmProvider, get_custom_llm_provider};
+use litellm_llms::{
+    base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth},
+    custom_httpx::http_handler::has_header,
+};
+use litellm_types::llms::openai::ChatMessage;
 use serde_json::Value;
 
-use super::Error;
-use super::common_utils::{chat_completions_provider_config, string_headers};
-use super::types::{
-    ChatCompletionsRequest, ChatMessage, ProviderChatCompletionsRequest,
-    ResolvedChatCompletionsRequest,
+use super::{
+    Error,
+    common_utils::{chat_completions_provider_config, string_headers},
 };
-use crate::http_utils::has_header;
-use crate::litellm_core_utils::get_llm_provider_logic::{
-    CustomLlmProvider, get_custom_llm_provider,
+use crate::chat_completions::types::{
+    ChatCompletionsRequest, ProviderChatCompletionsRequest, ResolvedChatCompletionsRequest,
 };
-use litellm_providers::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
 
 pub(super) fn resolve_provider_config<'a>(
     model: &'a str,

litellm-rust/crates/core/src/chat_completions/tests.rs

@@ -1,9 +1,11 @@
+use litellm_llms::base_llm::chat::transformation::ChatCompletionsAuth;
 use serde_json::{Map, Value, json};
 
-use super::Error;
-use super::prepare::{prepare_provider_request, resolve_request};
-use super::types::{ChatCompletionsRequest, ProviderChatCompletionsRequest};
-use litellm_providers::base_llm::chat::transformation::ChatCompletionsAuth;
+use super::{
+    Error,
+    prepare::{prepare_provider_request, resolve_request},
+};
+use crate::chat_completions::types::{ChatCompletionsRequest, ProviderChatCompletionsRequest};
 
 fn prepare_chat_completions_call(
     request: ChatCompletionsRequest<'_>,
@@ -263,7 +265,7 @@ fn rejects_non_string_extra_headers() {
     call.extra_headers = Some(Map::from_iter([("x-trace".to_string(), json!(7))]));
     assert_eq!(
         decline(call),
-        Error::Headers(crate::http_utils::HeaderError {
+        Error::Headers(litellm_llms::custom_httpx::http_handler::HeaderError {
             context: "chat completions",
             name: "x-trace".to_string(),
             actual: "number",
@@ -587,8 +589,10 @@ fn the_gate_agrees_with_prepare_on_every_case_it_accepts() {
 }
 
 mod round_trip {
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::{TcpListener, TcpStream};
+    use tokio::{
+        io::{AsyncReadExt, AsyncWriteExt},
+        net::{TcpListener, TcpStream},
+    };
 
     use super::*;
     use crate::chat_completions::chat_completions;
@@ -767,7 +771,10 @@ mod round_trip {
         assert!(
             matches!(
                 err,
-                Error::Transport(crate::transport::Error::Http { status: 429, .. })
+                Error::Transport(litellm_llms::custom_httpx::transport::Error::Http {
+                    status: 429,
+                    ..
+                })
             ),
             "expected a 429, got {err:?}"
         );
@@ -792,7 +799,10 @@ mod round_trip {
         .await
         .expect_err("nothing is listening");
         assert!(
-            matches!(err, Error::Transport(crate::transport::Error::Connect(_))),
+            matches!(
+                err,
+                Error::Transport(litellm_llms::custom_httpx::transport::Error::Connect(_))
+            ),
             "expected a pre-send connect failure, got {err:?}"
         );
     }
@@ -815,11 +825,16 @@ mod round_trip {
         }
         // An upstream status is already unambiguous, so it survives intact.
         assert!(matches!(
-            as_response_error(Error::Transport(crate::transport::Error::Http {
+            as_response_error(Error::Transport(
+                litellm_llms::custom_httpx::transport::Error::Http {
+                    status: 500,
+                    body: "boom".to_string()
+                }
+            )),
+            Error::Transport(litellm_llms::custom_httpx::transport::Error::Http {
                 status: 500,
-                body: "boom".to_string()
-            })),
-            Error::Transport(crate::transport::Error::Http { status: 500, .. })
+                ..
+            })
         ));
     }
 }

litellm-rust/crates/core/src/chat_completions/types.rs

@@ -0,0 +1,44 @@
+use std::time::Duration;
+
+use litellm_llms::base_llm::chat::transformation::{BaseConfig, ChatCompletionsAuth};
+use litellm_types::llms::openai::ChatMessage;
+use serde_json::{Map, Value};
+
+/// A `/chat/completions` call as it crosses into the core.
+///
+/// `optional_params` arrives already mapped to the provider's own parameter
+/// names by the host, exactly as the messages route receives an already
+/// Anthropic-shaped body. The core owns the conversation translation, the
+/// provider call, and the response normalization.
+pub struct ChatCompletionsRequest<'a> {
+    pub model: &'a str,
+    pub messages: Value,
+    pub optional_params: Map<String, Value>,
+    pub api_key: Option<&'a str>,
+    pub api_base: Option<&'a str>,
+    pub custom_llm_provider: Option<&'a str>,
+    pub extra_headers: Option<Map<String, Value>>,
+    pub timeout: Option<Duration>,
+}
+
+pub struct ResolvedChatCompletionsRequest<'a> {
+    pub model: String,
+    pub config: &'static dyn BaseConfig,
+    pub messages: Vec<ChatMessage>,
+    pub optional_params: Map<String, Value>,
+    pub api_key: Option<&'a str>,
+    pub api_base: Option<&'a str>,
+    pub extra_headers: Option<Map<String, Value>>,
+    pub timeout: Option<Duration>,
+}
+
+pub struct ProviderChatCompletionsRequest {
+    pub model: String,
+    pub config: &'static dyn BaseConfig,
+    pub url: String,
+    pub body: Value,
+    pub upstream_headers: Vec<(String, String)>,
+    pub auth: ChatCompletionsAuth,
+    pub optional_params: Map<String, Value>,
+    pub timeout: Option<Duration>,
+}

litellm-rust/crates/core/src/constants.rs

@@ -1,6 +1,4 @@
 pub const OPENAI_DEFAULT_API_BASE: &str = "https://api.openai.com";
-pub const OPENAI_RESPONSES_DEFAULT_API_BASE: &str = "https://api.openai.com/v1";
-pub const OPENAI_RESPONSES_PATH: &str = "/responses";
 
 /// Full-request timeout ceiling for Anthropic Messages provider calls, in
 /// seconds. Mirrors the Python Anthropic Messages default. The per-request
@@ -10,19 +8,10 @@ pub(crate) const MESSAGES_TIMEOUT_SECS: u64 = 600;
 /// Connect timeout for Anthropic Messages provider calls, in seconds.
 pub(crate) const MESSAGES_CONNECT_TIMEOUT_SECS: u64 = 10;
 
-/// Max characters of an upstream error body echoed across the call boundary
-/// before truncation, so provider bodies are bounded and data-minimized.
-pub(crate) const UPSTREAM_ERROR_BODY_MAX_CHARS: usize = 256;
-
 /// Provider name used for Anthropic Messages when a deployment's provider model
 /// does not carry an explicit provider prefix.
 pub const ANTHROPIC_MESSAGES_PROVIDER: &str = "anthropic";
 
-/// Prefix identifying an Anthropic OAuth token. Mirrors Python's
-/// `ANTHROPIC_OAUTH_TOKEN_PREFIX`, which is what makes `validate_environment`
-/// authenticate with `authorization` and drop `x-api-key` entirely.
-pub(crate) const ANTHROPIC_OAUTH_TOKEN_PREFIX: &str = "sk-ant-oat";
-
 /// Full-request timeout ceiling for chat completions provider calls, in
 /// seconds. Mirrors the Python chat completions default.
 pub(crate) const CHAT_COMPLETIONS_TIMEOUT_SECS: u64 = 600;
@@ -34,34 +23,3 @@ pub(crate) const AUDIO_TRANSCRIPTION_TIMEOUT_SECS: u64 = 600;
 
 /// `object` field every non-streaming chat completion response carries.
 pub const CHAT_COMPLETION_OBJECT: &str = "chat.completion";
-
-/// Placeholder Python substitutes for empty or whitespace-only message text,
-/// which Anthropic and Bedrock both reject. Must match
-/// `_EMPTY_TEXT_PLACEHOLDER` in
-/// `litellm/litellm_core_utils/prompt_templates/factory.py`.
-pub const EMPTY_TEXT_PLACEHOLDER: &str =
-    "[System: Empty message content sanitised to satisfy protocol]";
-
-pub(crate) const MEDIA_CONNECT_TIMEOUT_SECS: u64 = 10;
-
-pub(crate) const OCR_RESPONSE_MAX_BYTES: usize = 64 * 1024 * 1024;
-pub(crate) const OCR_HTTP_TIMEOUT_SECS: u64 = 600;
-pub(crate) const OCR_CONNECT_TIMEOUT_SECS: u64 = 10;
-pub const OCR_INLINE_MAX_BYTES: usize = 50 * 1024 * 1024;
-pub(crate) const OCR_DOWNLOAD_MAX_BYTES: u64 = 50 * 1024 * 1024;
-pub(crate) const OCR_MAX_FETCH_REDIRECTS: usize = 10;
-pub(crate) const OCR_POLL_TIMEOUT_SECS: u64 = 120;
-pub(crate) const OCR_POLL_RETRY_SECS: u64 = 2;
-pub(crate) const AZURE_DI_API_VERSION: &str = "2024-11-30";
-pub(crate) const AZURE_DI_SUBSCRIPTION_HEADER: &str = "Ocp-Apim-Subscription-Key";
-pub(crate) const AZURE_DI_DEFAULT_DPI: i64 = 96;
-pub(crate) const AZURE_DI_DEFAULT_WIDTH: f64 = 8.5;
-pub(crate) const AZURE_DI_DEFAULT_HEIGHT: f64 = 11.0;
-pub(crate) const REDUCTO_API_BASE: &str = "https://platform.reducto.ai";
-pub(crate) const REDUCTO_API_KEY_ENV: &str = "REDUCTO_API_KEY";
-pub(crate) const REDUCTO_ID_PREFIX: &str = "reducto://";
-pub(crate) const AZURE_AI_OCR_PATH: &str = "/providers/mistral/azure/ocr";
-pub(crate) const MISTRAL_OCR_API_BASE: &str = "https://api.mistral.ai/v1";
-
-pub(crate) const COHERE_PARSE_API_BASE: &str = "https://api.cohere.com";
-pub(crate) const COHERE_API_KEY_ENV: &str = "COHERE_API_KEY";

litellm-rust/crates/core/src/error.rs

@@ -1,7 +1,9 @@
+use litellm_llms::base_llm::ocr::error::Error as OcrError;
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error(transparent)]
-    Ocr(#[from] crate::ocr::Error),
+    Ocr(#[from] OcrError),
     #[error(transparent)]
     Messages(#[from] crate::messages::Error),
     #[error(transparent)]

litellm-rust/crates/core/src/lib.rs

@@ -1,19 +1,10 @@
 pub mod audio_transcription;
-pub mod call_arguments;
-pub mod call_lifecycle;
 pub mod chat_completions;
 pub mod constants;
 pub mod error;
-pub mod http_utils;
-pub mod litellm_core_utils;
-pub mod llms;
-mod media;
+pub mod machine;
 pub mod messages;
 pub mod ocr;
-pub mod params;
 pub mod responses;
-mod serde_compat;
-pub mod transport;
-mod url_utils;
 
 pub use error::Error;

litellm-rust/crates/core/src/litellm_core_utils/mod.rs

@@ -1 +0,0 @@
-pub mod get_llm_provider_logic;

litellm-rust/crates/core/src/llms/anthropic/chat/mod.rs

@@ -1 +0,0 @@
-pub mod streaming;

litellm-rust/crates/core/src/llms/anthropic/experimental_pass_through/messages/mod.rs

@@ -1,3 +0,0 @@
-pub mod batches;
-pub mod count_tokens;
-pub mod streaming;

litellm-rust/crates/core/src/llms/anthropic/mod.rs

@@ -1,2 +0,0 @@
-pub mod chat;
-pub mod experimental_pass_through;

litellm-rust/crates/core/src/llms/azure_ai/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/azure_ai/ocr/document_intelligence/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/azure_ai/ocr/mod.rs

@@ -1,4 +0,0 @@
-pub(crate) mod cohere_parse_transformation;
-pub(crate) mod common_utils;
-pub(crate) mod document_intelligence;
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/base_llm/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/base_llm/ocr/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/base_llm/ocr/transformation.rs

@@ -1,211 +0,0 @@
-use std::future::Future;
-use std::sync::Arc;
-
-use serde::Serialize;
-use serde::de::DeserializeOwned;
-use serde_json::Value;
-
-use crate::call_arguments::CallArguments;
-use crate::ocr::OcrClient;
-use crate::ocr::hooks::OcrHooks;
-use crate::ocr::types::{
-    LiteLLMOcrResponse, OcrConnection, OcrCredentialInputs, OcrDocument, OcrResponseFormat,
-    PreparedOcrRequest, ResolvedOcrCredentials,
-};
-
-const HEALTH_CHECK_PDF_DATA_URI: &str = "data:application/pdf;base64,JVBERi0xLjQKJeLjz9MKMyAwIG9iago8PC9UeXBlIC9QYWdlCi9QYXJlbnQgMSAwIFIKL01lZGlhQm94IFswIDAgNjEyIDc5Ml0KL0NvbnRlbnRzIDQgMCBSCi9SZXNvdXJjZXMgPDwvRm9udCA8PC9GMSAyIDAgUj4+Pj4+PgplbmRvYmoKNCAwIG9iago8PC9MZW5ndGggNDQ+PgpzdHJlYW0KQlQKL0YxIDI0IFRmCjEwMCA3MDAgVGQKKHRlc3QpIFRqCkVUCmVuZHN0cmVhbQplbmRvYmoKMiAwIG9iago8PC9UeXBlIC9Gb250Ci9TdWJ0eXBlIC9UeXBlMQovQmFzZUZvbnQgL0hlbHZldGljYT4+CmVuZG9iagoxIDAgb2JqCjw8L1R5cGUgL1BhZ2VzCi9LaWRzIFszIDAgUl0KL0NvdW50IDE+PgplbmRvYmoKNSAwIG9iago8PC9UeXBlIC9DYXRhbG9nCi9QYWdlcyAxIDAgUj4+CmVuZG9iagp0cmFpbGVyCjw8L1NpemUgNgovUm9vdCA1IDAgUj4+CnN0YXJ0eHJlZgozMjQKJSVFT0Y=";
-
-/// Output of `validate_environment`: whatever a provider resolves up front
-/// (headers at minimum; Vertex also carries the project id).
-pub(crate) trait OcrEnvironment: Send + Sync {
-    fn headers(&self) -> &[(String, String)];
-}
-
-impl OcrEnvironment for Vec<(String, String)> {
-    fn headers(&self) -> &[(String, String)] {
-        self
-    }
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct OcrRequestContext<'a> {
-    pub client: &'a OcrClient,
-    pub connection: &'a OcrConnection,
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct OcrResponseContext<'a> {
-    pub client: &'a OcrClient,
-    pub connection: &'a OcrConnection,
-    pub hooks: &'a Arc<dyn OcrHooks>,
-    pub request_format: OcrResponseFormat,
-    pub url: &'a str,
-    pub headers: &'a [(String, String)],
-}
-
-pub(crate) trait BaseOcrConfig: Send + Sync + Sized + 'static {
-    type OcrParams: Send + Sync;
-    type ProviderRequest: Serialize + Send;
-    type Environment: OcrEnvironment;
-
-    fn get_supported_ocr_params(&self, _model: &str) -> &'static [&'static str] {
-        &[]
-    }
-
-    fn get_api_key_env_var(&self) -> Option<&'static str> {
-        None
-    }
-
-    fn resolve_connection_params(&self, inputs: OcrCredentialInputs) -> ResolvedOcrCredentials {
-        ResolvedOcrCredentials {
-            api_key: inputs
-                .dynamic_api_key
-                .filter(|value| !value.value().is_empty())
-                .or(inputs.api_key),
-            api_base: inputs
-                .dynamic_api_base
-                .filter(|value| !value.value().is_empty())
-                .or(inputs.api_base),
-        }
-    }
-
-    fn get_health_check_document(&self) -> OcrDocument {
-        OcrDocument::DocumentUrl {
-            document_url: HEALTH_CHECK_PDF_DATA_URI.into(),
-            extra_fields: Default::default(),
-        }
-    }
-
-    fn map_ocr_params(
-        &self,
-        non_default_params: &CallArguments,
-        model: &str,
-    ) -> Result<Self::OcrParams, crate::ocr::Error>;
-
-    fn validate_environment(
-        &self,
-        request: &PreparedOcrRequest,
-        client: &OcrClient,
-    ) -> impl Future<Output = Result<Self::Environment, crate::ocr::Error>> + Send;
-
-    fn get_complete_url(
-        &self,
-        request: &PreparedOcrRequest,
-        optional_params: &Self::OcrParams,
-        environment: &Self::Environment,
-    ) -> Result<String, crate::ocr::Error>;
-
-    fn transform_ocr_request(
-        &self,
-        model: &str,
-        document: OcrDocument,
-        optional_params: &Self::OcrParams,
-        headers: &[(String, String)],
-    ) -> Result<Self::ProviderRequest, crate::ocr::Error>;
-
-    fn async_transform_ocr_request(
-        &self,
-        model: &str,
-        document: OcrDocument,
-        optional_params: &Self::OcrParams,
-        headers: &[(String, String)],
-        _context: OcrRequestContext<'_>,
-    ) -> impl Future<Output = Result<Self::ProviderRequest, crate::ocr::Error>> + Send {
-        async move { self.transform_ocr_request(model, document, optional_params, headers) }
-    }
-
-    fn transform_ocr_response(
-        &self,
-        model: &str,
-        raw_response: &[u8],
-        request_format: OcrResponseFormat,
-    ) -> Result<LiteLLMOcrResponse, crate::ocr::Error>;
-
-    fn async_transform_ocr_response(
-        &self,
-        model: &str,
-        raw_response: reqwest::Response,
-        context: OcrResponseContext<'_>,
-    ) -> impl Future<Output = Result<LiteLLMOcrResponse, crate::ocr::Error>> + Send {
-        async move {
-            let bytes = crate::ocr::client::read_response_bytes(
-                raw_response,
-                context.connection.max_response_bytes,
-            )
-            .await?;
-            crate::ocr::handler::post_call(context.hooks, &bytes).await?;
-            self.transform_ocr_response(model, &bytes, context.request_format)
-        }
-    }
-
-    fn get_error_class(
-        &self,
-        error_message: String,
-        status_code: u16,
-        headers: Vec<(String, String)>,
-    ) -> crate::ocr::Error {
-        crate::ocr::Error::Provider {
-            status: status_code,
-            body: error_message,
-            headers,
-        }
-    }
-
-    /// Provider-specific check applied to the composed body, both before and
-    /// after guardrail hooks. Defaults to accepting any body.
-    fn validate_request_body(&self, _body: &Value) -> Result<(), crate::ocr::Error> {
-        Ok(())
-    }
-
-    /// Rust counterpart of `BaseLLMHTTPHandler._async_prepare_ocr_request`:
-    /// map params, validate environment, build URL, transform, compose body.
-    fn prepare_request(
-        &self,
-        request: &PreparedOcrRequest,
-        client: &OcrClient,
-    ) -> impl Future<Output = Result<reqwest::Request, crate::ocr::Error>> + Send {
-        async move {
-            let params = self.map_ocr_params(&request.optional_params, &request.model)?;
-            let environment = self.validate_environment(request, client).await?;
-            let url = self.get_complete_url(request, &params, &environment)?;
-            let headers = environment.headers();
-            let body = self
-                .async_transform_ocr_request(
-                    &request.model,
-                    request.document.clone(),
-                    &params,
-                    headers,
-                    OcrRequestContext {
-                        client,
-                        connection: &request.connection,
-                    },
-                )
-                .await?;
-            crate::ocr::prepare::transform_request_body(
-                client,
-                request,
-                &url,
-                headers,
-                body,
-                |body| self.validate_request_body(body),
-            )
-            .await
-        }
-    }
-}
-
-pub(crate) fn decode_and_normalize_response<T: DeserializeOwned>(
-    model: &str,
-    raw_response: &[u8],
-    request_format: OcrResponseFormat,
-    normalize: impl FnOnce(&str, T) -> Result<LiteLLMOcrResponse, crate::ocr::Error>,
-) -> Result<LiteLLMOcrResponse, crate::ocr::Error> {
-    let decoded = crate::ocr::json::decode_response(
-        raw_response,
-        request_format == OcrResponseFormat::Native,
-    )?;
-    Ok(LiteLLMOcrResponse {
-        provider_native_response: decoded.native,
-        ..normalize(model, decoded.data)?
-    })
-}

litellm-rust/crates/core/src/llms/cohere/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/cohere/ocr/mod.rs

@@ -1,3 +0,0 @@
-pub(crate) mod transformation;
-
-pub(crate) use transformation::{CohereOptions, validate_document};

litellm-rust/crates/core/src/llms/mistral/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/mistral/ocr/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/mod.rs

@@ -1,8 +0,0 @@
-pub mod anthropic;
-pub mod azure_ai;
-pub mod base_llm;
-pub(crate) mod cohere;
-pub(crate) mod mistral;
-pub mod openai;
-pub(crate) mod reducto;
-pub(crate) mod vertex_ai;

litellm-rust/crates/core/src/llms/reducto/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/reducto/ocr/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/vertex_ai/mod.rs

@@ -1 +0,0 @@
-pub(crate) mod ocr;

litellm-rust/crates/core/src/llms/vertex_ai/ocr/mod.rs

@@ -1,3 +0,0 @@
-pub(crate) mod common_utils;
-pub(crate) mod deepseek_transformation;
-pub(crate) mod transformation;

litellm-rust/crates/core/src/llms/vertex_ai/ocr/transformation.rs

@@ -1,407 +0,0 @@
-use litellm_auth_gcp::{self as vertex, VertexConfig};
-use serde_json::Value;
-
-use super::common_utils::validate_destination;
-use crate::call_arguments::CallArguments;
-use crate::llms::base_llm::ocr::transformation::{
-    BaseOcrConfig, OcrEnvironment, OcrRequestContext,
-};
-use crate::llms::mistral::ocr::transformation::{MistralOcrConfig, MistralOcrRequest};
-use crate::ocr::OcrClient;
-use crate::ocr::document::{inline_remote_document, validate_inline_document};
-use crate::ocr::prepare::credential_env;
-use crate::ocr::types::{LiteLLMOcrResponse, OcrConnection, OcrDocument, PreparedOcrRequest};
-use crate::params::OpaqueParams;
-use crate::url_utils::ApiUrl;
-
-const DEFAULT_LOCATION: &str = "us-central1";
-
-#[derive(Clone, Debug, Default)]
-pub(crate) struct VertexAiOcrConfig;
-
-impl BaseOcrConfig for VertexAiOcrConfig {
-    type OcrParams = OpaqueParams;
-    type ProviderRequest = MistralOcrRequest;
-    type Environment = vertex::VertexEnvironment;
-
-    fn get_supported_ocr_params(&self, model: &str) -> &'static [&'static str] {
-        MistralOcrConfig.get_supported_ocr_params(model)
-    }
-
-    fn get_api_key_env_var(&self) -> Option<&'static str> {
-        Some("VERTEX_AI_API_KEY")
-    }
-
-    fn map_ocr_params(
-        &self,
-        non_default_params: &CallArguments,
-        model: &str,
-    ) -> Result<OpaqueParams, crate::ocr::Error> {
-        MistralOcrConfig.map_ocr_params(non_default_params, model)
-    }
-
-    async fn validate_environment(
-        &self,
-        request: &PreparedOcrRequest,
-        client: &OcrClient,
-    ) -> Result<Self::Environment, crate::ocr::Error> {
-        let config = VertexConfig::from_sourced_optional_params(
-            &request.optional_params,
-            &request.input_sources,
-        )?;
-        self.resolve_environment(&request.connection, &config, client)
-            .await
-    }
-
-    fn get_complete_url(
-        &self,
-        request: &PreparedOcrRequest,
-        _optional_params: &Self::OcrParams,
-        environment: &Self::Environment,
-    ) -> Result<String, crate::ocr::Error> {
-        let config = VertexConfig::from_sourced_optional_params(
-            &request.optional_params,
-            &request.input_sources,
-        )?;
-        let location = vertex::get_vertex_ai_location(&config, &credential_env)
-            .unwrap_or_else(|| DEFAULT_LOCATION.to_string());
-        self.build_ocr_url(
-            request.connection.api_base.as_deref(),
-            &environment.project_id,
-            &location,
-            &request.model,
-        )
-    }
-
-    fn transform_ocr_request(
-        &self,
-        model: &str,
-        document: OcrDocument,
-        optional_params: &OpaqueParams,
-        headers: &[(String, String)],
-    ) -> Result<MistralOcrRequest, crate::ocr::Error> {
-        MistralOcrConfig.transform_ocr_request(model, document, optional_params, headers)
-    }
-
-    async fn async_transform_ocr_request(
-        &self,
-        model: &str,
-        document: OcrDocument,
-        optional_params: &OpaqueParams,
-        headers: &[(String, String)],
-        context: OcrRequestContext<'_>,
-    ) -> Result<MistralOcrRequest, crate::ocr::Error> {
-        let document = inline_remote_document(
-            context.client.document_fetcher(),
-            document,
-            context.connection,
-        )
-        .await?;
-        self.transform_ocr_request(model, document, optional_params, headers)
-    }
-
-    fn transform_ocr_response(
-        &self,
-        model: &str,
-        raw_response: &[u8],
-        request_format: crate::ocr::types::OcrResponseFormat,
-    ) -> Result<LiteLLMOcrResponse, crate::ocr::Error> {
-        MistralOcrConfig.transform_ocr_response(model, raw_response, request_format)
-    }
-
-    fn validate_request_body(&self, body: &Value) -> Result<(), crate::ocr::Error> {
-        validate_inline_document(&crate::ocr::prepare::body_document(body)?)
-    }
-}
-
-impl OcrEnvironment for vertex::VertexEnvironment {
-    fn headers(&self) -> &[(String, String)] {
-        &self.headers
-    }
-}
-
-impl VertexAiOcrConfig {
-    async fn resolve_environment(
-        &self,
-        connection: &OcrConnection,
-        config: &VertexConfig,
-        client: &OcrClient,
-    ) -> Result<vertex::VertexEnvironment, crate::ocr::Error> {
-        validate_destination(connection)?;
-        client
-            .vertex_auth()
-            .validate_environment(
-                connection.extra_headers.clone(),
-                connection.api_key.as_deref(),
-                config,
-                &credential_env,
-            )
-            .await
-            .map_err(crate::ocr::Error::from)
-    }
-
-    fn build_ocr_url(
-        &self,
-        api_base: Option<&str>,
-        project: &str,
-        location: &str,
-        model: &str,
-    ) -> Result<String, crate::ocr::Error> {
-        validate_location(location)?;
-        let default_base = format!("https://{location}-aiplatform.googleapis.com");
-        let base = api_base
-            .map(str::trim)
-            .filter(|base| !base.is_empty())
-            .unwrap_or(&default_base);
-        let prediction = format!("{model}:rawPredict");
-        ApiUrl::parse(base)
-            .and_then(|url| {
-                url.complete_path(&[
-                    "v1",
-                    "projects",
-                    project,
-                    "locations",
-                    location,
-                    "publishers",
-                    "mistralai",
-                    "models",
-                    &prediction,
-                ])
-            })
-            .map(|url| url.into_string())
-            .map_err(|_| crate::ocr::Error::RequestField {
-                path: "api_base".into(),
-            })
-    }
-}
-
-fn validate_location(location: &str) -> Result<(), crate::ocr::Error> {
-    let valid = !location.is_empty()
-        && location
-            .bytes()
-            .all(|value| value.is_ascii_lowercase() || value.is_ascii_digit() || value == b'-')
-        && location
-            .as_bytes()
-            .first()
-            .is_some_and(u8::is_ascii_alphanumeric)
-        && location
-            .as_bytes()
-            .last()
-            .is_some_and(u8::is_ascii_alphanumeric);
-    if valid {
-        return Ok(());
-    }
-    Err(crate::ocr::Error::RequestField {
-        path: "vertex_location".into(),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::VertexAiOcrConfig;
-    use rstest::rstest;
-
-    #[test]
-    fn endpoint_uses_location_project_and_model() {
-        assert_eq!(
-            VertexAiOcrConfig
-                .build_ocr_url(None, "proj-1", "europe-west4", "mistral-ocr-maas")
-                .unwrap(),
-            "https://europe-west4-aiplatform.googleapis.com/v1/projects/proj-1/locations/europe-west4/publishers/mistralai/models/mistral-ocr-maas:rawPredict"
-        );
-    }
-
-    #[test]
-    fn endpoint_rejects_invalid_location() {
-        assert!(
-            VertexAiOcrConfig
-                .build_ocr_url(None, "proj-1", "attacker.example/path", "model")
-                .is_err()
-        );
-    }
-
-    use litellm_auth::InputSource;
-    use serde_json::{Value, json};
-
-    use crate::ocr::test_support::{MockResponse, mock_server, perform_ocr, wire_request};
-
-    fn request_body(request: &str) -> Value {
-        serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()
-    }
-
-    #[tokio::test]
-    async fn facade_executes_vertex_mistral_with_resolved_project_and_location() {
-        let (base, seen, server) = mock_server(vec![MockResponse::json(json!({
-            "pages":[{"index":0,"markdown":"hello"}],
-            "usage_info":{"pages_processed":1}
-        }))])
-        .await;
-        let request = wire_request(
-            "vertex_ai/mistral-ocr-maas",
-            &base,
-            json!({
-                "vertex_project":"project-1",
-                "vertex_location":"europe-west4",
-                "extract_footer":true
-            }),
-        );
-
-        let response = perform_ocr(request).await.unwrap();
-        server.await.unwrap();
-        assert_eq!(response.pages[0].markdown, "hello");
-        let requests = seen.lock().unwrap();
-        assert_eq!(requests.len(), 1);
-        assert!(requests[0].starts_with(
-            "POST /v1/projects/project-1/locations/europe-west4/publishers/mistralai/models/mistral-ocr-maas:rawPredict "
-        ));
-        assert!(
-            requests[0]
-                .to_ascii_lowercase()
-                .contains("authorization: bearer test-key")
-        );
-        assert_eq!(
-            request_body(&requests[0]),
-            json!({
-                "model":"mistral-ocr-maas",
-                "document":{"type":"document_url","document_url":"data:application/pdf;base64,YWJj"},
-                "extract_footer":true
-            })
-        );
-    }
-
-    #[tokio::test]
-    async fn supplied_authorization_is_forwarded_without_a_static_token() {
-        let (base, seen, server) = mock_server(vec![MockResponse::json(json!({"pages":[]}))]).await;
-        let mut request = wire_request(
-            "vertex_ai/model",
-            &base,
-            json!({"vertex_project":"project-1"}),
-        );
-        request.credentials.api_key = None;
-        request.transport.extra_headers = vec![("authorization".into(), "Bearer supplied".into())];
-
-        perform_ocr(request).await.unwrap();
-        server.await.unwrap();
-        assert!(
-            seen.lock().unwrap()[0]
-                .to_ascii_lowercase()
-                .contains("authorization: bearer supplied")
-        );
-    }
-
-    #[tokio::test]
-    async fn invalid_credentials_fail_before_provider_http() {
-        let request = wire_request(
-            "vertex_ai/model",
-            "http://127.0.0.1:1",
-            json!({"vertex_credentials": true}),
-        );
-        let error = perform_ocr(request).await.unwrap_err();
-        assert!(error.to_string().contains("vertex_credentials"));
-    }
-
-    #[tokio::test]
-    async fn request_controlled_api_base_is_rejected_before_vertex_auth() {
-        let mut request = wire_request(
-            "vertex_ai/mistral-ocr-maas",
-            "https://caller.example",
-            json!({"vertex_project":"project-1"}),
-        );
-        request.credentials.api_base = Some(litellm_auth::Sourced::new(
-            "https://caller.example".into(),
-            InputSource::Request,
-        ));
-
-        let error = perform_ocr(request).await.unwrap_err();
-        assert!(
-            error
-                .to_string()
-                .contains("request-controlled Vertex AI endpoint")
-        );
-    }
-
-    #[rstest]
-    #[case::mistral(false)]
-    #[case::vertex(true)]
-    #[tokio::test]
-    async fn configs_build_complete_requests_and_share_mistral_normalization(
-        #[case] use_vertex: bool,
-    ) {
-        use std::time::Duration;
-
-        use crate::llms::base_llm::ocr::transformation::BaseOcrConfig;
-        use crate::llms::mistral::ocr::transformation::MistralOcrConfig;
-        use crate::llms::vertex_ai::ocr::transformation::VertexAiOcrConfig;
-        use crate::ocr::test_support::ocr_client;
-
-        let client = ocr_client();
-        let options = json!({
-            "pages": [0, 2],
-            "include_image_base64": true,
-            "vertex_project": "project-1",
-            "vertex_location": "us-central1",
-            "unknown": "preserved"
-        });
-        let direct = wire_request(
-            "mistral/mistral-ocr-maas",
-            "https://mistral.test",
-            options.clone(),
-        );
-        let vertex = wire_request("vertex_ai/mistral-ocr-maas", "https://vertex.test", options);
-        let direct = crate::ocr::prepare::prepare_request(
-            crate::ocr::test_support::resolved_request(direct),
-        );
-        let vertex = crate::ocr::prepare::prepare_request(
-            crate::ocr::test_support::resolved_request(vertex),
-        );
-        let direct_http = MistralOcrConfig
-            .prepare_request(&direct, &client)
-            .await
-            .unwrap();
-        let vertex_http = VertexAiOcrConfig
-            .prepare_request(&vertex, &client)
-            .await
-            .unwrap();
-        assert_eq!(direct_http.url().as_str(), "https://mistral.test/v1/ocr");
-        assert_eq!(
-            vertex_http.url().as_str(),
-            "https://vertex.test/v1/projects/project-1/locations/us-central1/publishers/mistralai/models/mistral-ocr-maas:rawPredict"
-        );
-        let http = if use_vertex {
-            &vertex_http
-        } else {
-            &direct_http
-        };
-        assert_eq!(http.method(), reqwest::Method::POST);
-        assert_eq!(http.headers()["authorization"], "Bearer test-key");
-        assert_eq!(http.headers()["content-type"], "application/json");
-        assert_eq!(http.timeout(), Some(&Duration::from_secs(2)));
-        let body: Value = serde_json::from_slice(http.body().unwrap().as_bytes().unwrap()).unwrap();
-        assert_eq!(
-            body,
-            json!({
-                "model": "mistral-ocr-maas",
-                "document": {"type": "document_url", "document_url": "data:application/pdf;base64,YWJj"},
-                "pages": [0, 2],
-                "include_image_base64": true,
-                "unknown": "preserved"
-            })
-        );
-        let payload = serde_json::to_vec(
-            &json!({"pages": [{"index": 0, "markdown": "hello"}], "extra": "preserved"}),
-        )
-        .unwrap();
-        let direct_response = MistralOcrConfig
-            .transform_ocr_response(&direct.model, &payload, Default::default())
-            .unwrap()
-            .into_json();
-        let vertex_response = VertexAiOcrConfig
-            .transform_ocr_response(&vertex.model, &payload, Default::default())
-            .unwrap()
-            .into_json();
-        assert_eq!(direct_response, vertex_response);
-        assert_eq!(direct_response["model"], "mistral-ocr-maas");
-        assert_eq!(direct_response["object"], "ocr");
-        assert_eq!(direct_response["extra"], "preserved");
-    }
-}

litellm-rust/crates/core/src/machine/auth.rs

@@ -0,0 +1,53 @@
+use std::sync::Arc;
+
+use litellm_auth::{Error, ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
+use litellm_callbacks::route::Route;
+
+use super::{HostChannel, MachineFault};
+
+/// A route whose host can mint credentials on the call's behalf.
+pub trait TokenRoute: Route {
+    fn acquire_token_op() -> Self::Op;
+    fn token_credential(result: Self::OpResult) -> Option<ResolvedCredential>;
+}
+
+/// A [`TokenProvider`] that asks the host for each credential through the call's own
+/// operation channel, so the host answers it on the caller's thread and context.
+pub struct HostTokenProvider<R: Route> {
+    channel: HostChannel<R>,
+}
+
+impl<R: Route> std::fmt::Debug for HostTokenProvider<R> {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("HostTokenProvider")
+    }
+}
+
+impl<R> HostTokenProvider<R>
+where
+    R: TokenRoute,
+    R::Error: From<MachineFault> + std::fmt::Display,
+{
+    pub fn handle(channel: HostChannel<R>) -> TokenProviderHandle {
+        TokenProviderHandle::new(Arc::new(Self { channel }))
+    }
+}
+
+impl<R> TokenProvider for HostTokenProvider<R>
+where
+    R: TokenRoute,
+    R::Error: From<MachineFault> + std::fmt::Display,
+{
+    fn acquire(&self) -> TokenFuture<'_> {
+        Box::pin(async move {
+            let result = self
+                .channel
+                .route(R::acquire_token_op())
+                .await
+                .map_err(|error| Error::AzureTokenAcquisition(error.to_string()))?;
+            R::token_credential(result).ok_or_else(|| {
+                Error::AzureTokenAcquisition("invalid token provider host result".into())
+            })
+        })
+    }
+}

litellm-rust/crates/core/src/machine/mod.rs

@@ -0,0 +1,186 @@
+//! The one machine every route runs on: it owns the route's provider future, polls it in
+//! place, and turns the host operations that future requests into [`Machine`] steps. No
+//! task is spawned; dropping the machine drops the in-flight call.
+
+mod auth;
+
+use std::{future::Future, pin::Pin};
+
+pub use auth::{HostTokenProvider, TokenRoute};
+use litellm_callbacks::{
+    event::{CallEvent, RequestContext, WireRequest},
+    host::{HostOp, HostResult},
+    machine::{HostFailure, Interrupted, Machine, MachineStep, Step},
+    route::Route,
+};
+use tokio::sync::{mpsc, oneshot};
+
+/// The machine's own failures, distinct from anything the provider call reports.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum MachineFault {
+    /// The host driver went away while the call was waiting on it.
+    Abandoned,
+    /// The host answered out of turn: a result with nothing pending, or nothing when a
+    /// result was pending.
+    Protocol(&'static str),
+    /// The host answered a route operation with the wrong result variant.
+    Mismatch,
+}
+
+pub type ExecuteFuture<R> =
+    Pin<Box<dyn Future<Output = Result<<R as Route>::Response, <R as Route>::Error>> + Send>>;
+
+struct PendingOp<R: Route> {
+    op: HostOp<R>,
+    reply: oneshot::Sender<HostResult<R>>,
+}
+
+/// The provider side of the machine: how the in-flight call reaches its host.
+pub struct HostChannel<R: Route> {
+    ops: mpsc::UnboundedSender<PendingOp<R>>,
+}
+
+impl<R: Route> Clone for HostChannel<R> {
+    fn clone(&self) -> Self {
+        Self {
+            ops: self.ops.clone(),
+        }
+    }
+}
+
+impl<R: Route> HostChannel<R>
+where
+    R::Error: From<MachineFault>,
+{
+    async fn invoke(&self, op: HostOp<R>) -> Result<HostResult<R>, R::Error> {
+        let (reply, answer) = oneshot::channel();
+        self.ops
+            .send(PendingOp { op, reply })
+            .map_err(|_| MachineFault::Abandoned)?;
+        answer.await.map_err(|_| MachineFault::Abandoned.into())
+    }
+
+    pub async fn route(&self, op: R::Op) -> Result<R::OpResult, R::Error> {
+        match self.invoke(HostOp::Route(op)).await? {
+            HostResult::Route(result) => Ok(result),
+            _ => Err(MachineFault::Mismatch.into()),
+        }
+    }
+
+    pub async fn before_send(
+        &self,
+        wire: WireRequest,
+        context: RequestContext,
+    ) -> Result<WireRequest, R::Error> {
+        let op = HostOp::BeforeSend {
+            wire: Box::new(wire),
+            context: Box::new(context),
+        };
+        match self.invoke(op).await? {
+            HostResult::BeforeSend(wire) => Ok(*wire),
+            _ => Err(MachineFault::Mismatch.into()),
+        }
+    }
+
+    pub async fn emit(&self, event: CallEvent) -> Result<(), R::Error> {
+        match self.invoke(HostOp::Emit(event)).await? {
+            HostResult::Emitted => Ok(()),
+            _ => Err(MachineFault::Mismatch.into()),
+        }
+    }
+}
+
+enum Execution<R: Route> {
+    Unstarted(Box<dyn FnOnce(HostChannel<R>) -> ExecuteFuture<R> + Send>),
+    Running(ExecuteFuture<R>),
+    Done,
+}
+
+pub struct RouteMachine<R: Route> {
+    execution: Execution<R>,
+    ops: mpsc::UnboundedReceiver<PendingOp<R>>,
+    channel: HostChannel<R>,
+    reply: Option<oneshot::Sender<HostResult<R>>>,
+}
+
+impl<R: Route> RouteMachine<R>
+where
+    R::Error: From<MachineFault>,
+{
+    pub fn new(execute: impl FnOnce(HostChannel<R>) -> ExecuteFuture<R> + Send + 'static) -> Self {
+        let (ops_tx, ops) = mpsc::unbounded_channel();
+        Self {
+            execution: Execution::Unstarted(Box::new(execute)),
+            ops,
+            channel: HostChannel { ops: ops_tx },
+            reply: None,
+        }
+    }
+
+    async fn step(
+        &mut self,
+        result: Option<HostResult<R>>,
+    ) -> Result<MachineStep<R, R::Response>, R::Error> {
+        match (self.reply.take(), result) {
+            (Some(reply), Some(result)) => {
+                reply
+                    .send(result)
+                    .map_err(|_| MachineFault::Protocol("the call stopped waiting on the host"))?;
+            }
+            (None, None) if matches!(self.execution, Execution::Unstarted(_)) => {}
+            (Some(reply), None) => {
+                self.reply = Some(reply);
+                return Err(MachineFault::Protocol("host operation result is required").into());
+            }
+            (None, Some(_)) => {
+                return Err(MachineFault::Protocol("unexpected host operation result").into());
+            }
+            (None, None) => {
+                return Err(
+                    MachineFault::Protocol("call cannot be resumed after completion").into(),
+                );
+            }
+        }
+        if let Execution::Unstarted(_) = self.execution {
+            let Execution::Unstarted(start) =
+                std::mem::replace(&mut self.execution, Execution::Done)
+            else {
+                unreachable!()
+            };
+            self.execution = Execution::Running(start(self.channel.clone()));
+        }
+        let Execution::Running(future) = &mut self.execution else {
+            return Err(MachineFault::Protocol("call cannot be resumed after completion").into());
+        };
+        tokio::select! {
+            biased;
+            pending = self.ops.recv() => {
+                let pending = pending.ok_or(MachineFault::Abandoned)?;
+                self.reply = Some(pending.reply);
+                Ok(MachineStep::Host(pending.op))
+            }
+            outcome = future => {
+                self.execution = Execution::Done;
+                outcome.map(MachineStep::Complete)
+            }
+        }
+    }
+}
+
+impl<R: Route> Machine for RouteMachine<R>
+where
+    R::Error: From<MachineFault>,
+{
+    type Route = R;
+    type Complete = R::Response;
+
+    fn resume(&mut self, result: Option<HostResult<R>>) -> Step<'_, Self> {
+        Box::pin(self.step(result))
+    }
+
+    fn interrupt(&mut self, failure: HostFailure<R::Error>) -> Interrupted<'_, Self> {
+        self.reply = None;
+        self.execution = Execution::Done;
+        Box::pin(async move { Err(failure.into_error()) })
+    }
+}

litellm-rust/crates/core/src/messages/client.rs

@@ -1,5 +1,4 @@
-use std::sync::OnceLock;
-use std::time::Duration;
+use std::{sync::OnceLock, time::Duration};
 
 use crate::constants::{MESSAGES_CONNECT_TIMEOUT_SECS, MESSAGES_TIMEOUT_SECS};
 

litellm-rust/crates/core/src/messages/common_utils.rs

@@ -1,11 +1,15 @@
+pub(super) use litellm_llms::custom_httpx::http_handler::{
+    has_bearer_auth, has_header, truncate_error_body,
+};
+use litellm_llms::{
+    anthropic::experimental_pass_through::messages::transformation::ANTHROPIC_MESSAGES_CONFIG,
+    azure_ai::anthropic::messages_transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG,
+    base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig,
+    custom_httpx::http_handler::string_headers as shared_string_headers,
+};
 use serde_json::{Map, Value};
 
 use super::Error;
-use crate::http_utils::string_headers as shared_string_headers;
-pub(super) use crate::http_utils::{has_bearer_auth, has_header, truncate_error_body};
-use litellm_providers::anthropic::experimental_pass_through::messages::transformation::ANTHROPIC_MESSAGES_CONFIG;
-use litellm_providers::azure_ai::anthropic::messages_transformation::AZURE_ANTHROPIC_MESSAGES_CONFIG;
-use litellm_providers::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
 
 const HEADER_CONTEXT: &str = "messages";
 

litellm-rust/crates/core/src/messages/error.rs

@@ -1,3 +1,5 @@
+use litellm_llms::base_llm::chat::transformation::Error as LlmError;
+
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum Error {
     #[error("invalid provider: {0}")]
@@ -13,33 +15,20 @@ pub enum Error {
     #[error(transparent)]
     Auth(#[from] litellm_auth::Error),
     #[error(transparent)]
-    Transport(#[from] crate::transport::Error),
+    Transport(#[from] litellm_llms::custom_httpx::transport::Error),
     #[error(transparent)]
-    Headers(#[from] crate::http_utils::HeaderError),
-    #[error("stream framing failed: {0}")]
-    StreamFraming(String),
-    #[error("Anthropic SSE frame has no data")]
-    MissingStreamData,
-    #[error("Anthropic stream event is invalid: {0}")]
-    InvalidStreamEvent(String),
-    #[error("Bedrock event payload is invalid: {0}")]
-    InvalidBedrockPayload(String),
-    #[error("Bedrock event payload has invalid base64: {0}")]
-    InvalidBedrockBase64(String),
+    Headers(#[from] litellm_llms::custom_httpx::http_handler::HeaderError),
 }
 
-impl From<litellm_providers::messages::Error> for Error {
-    fn from(error: litellm_providers::messages::Error) -> Self {
+impl From<LlmError> for Error {
+    fn from(error: LlmError) -> Self {
         match error {
-            litellm_providers::messages::Error::MissingField(field) => Self::MissingField(field),
-            litellm_providers::messages::Error::InvalidRequest(message) => {
-                Self::InvalidRequest(message)
-            }
-            litellm_providers::messages::Error::InvalidResponse(message) => {
-                Self::InvalidResponse(message)
-            }
-            litellm_providers::messages::Error::Unsupported(reason) => Self::Unsupported(reason),
-            litellm_providers::messages::Error::Auth(error) => Self::Auth(error),
+            error @ LlmError::InvalidType { .. } => Self::InvalidRequest(error.to_string()),
+            LlmError::MissingField(field) => Self::MissingField(field),
+            LlmError::InvalidRequest(message) => Self::InvalidRequest(message),
+            LlmError::InvalidResponse(message) => Self::InvalidResponse(message),
+            LlmError::Unsupported(reason) => Self::Unsupported(reason),
+            LlmError::Auth(error) => Self::Auth(error),
         }
     }
 }
@@ -58,14 +47,6 @@ impl Error {
     }
 
     pub fn is_response(&self) -> bool {
-        matches!(
-            self,
-            Self::InvalidResponse(_)
-                | Self::StreamFraming(_)
-                | Self::MissingStreamData
-                | Self::InvalidStreamEvent(_)
-                | Self::InvalidBedrockPayload(_)
-                | Self::InvalidBedrockBase64(_)
-        )
+        matches!(self, Self::InvalidResponse(_))
     }
 }

litellm-rust/crates/core/src/messages/handler.rs

@@ -1,10 +1,11 @@
-use super::Error;
-use super::client::http_client;
-use super::common_utils::truncate_error_body;
-use super::prepare::prepare_provider_request;
-use super::types::{AnthropicMessagesResponse, MessagesRequest};
-use crate::constants::ANTHROPIC_MESSAGES_PROVIDER;
-use crate::http_utils::http_request;
+use litellm_llms::custom_httpx::http_handler::http_request;
+use litellm_types::llms::anthropic_messages::anthropic_response::AnthropicMessagesResponse;
+
+use super::{
+    Error, client::http_client, common_utils::truncate_error_body,
+    prepare::prepare_provider_request,
+};
+use crate::{constants::ANTHROPIC_MESSAGES_PROVIDER, messages::types::MessagesRequest};
 
 pub(super) async fn execute_messages_provider_call(
     request: MessagesRequest<'_>,
@@ -18,21 +19,26 @@ pub(super) async fn execute_messages_provider_call(
         request_builder = request_builder.timeout(duration);
     }
 
-    let response = http_request(request_builder)
-        .await
-        .map_err(|err| Error::Transport(crate::transport::Error::Network(err.to_string())))?;
+    let response = http_request(request_builder).await.map_err(|err| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            err.to_string(),
+        ))
+    })?;
 
     let status = response.status();
-    let text = response
-        .text()
-        .await
-        .map_err(|err| Error::Transport(crate::transport::Error::Network(err.to_string())))?;
+    let text = response.text().await.map_err(|err| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            err.to_string(),
+        ))
+    })?;
 
     if !status.is_success() {
-        return Err(Error::Transport(crate::transport::Error::Http {
-            status: status.as_u16(),
-            body: truncate_error_body(&text),
-        }));
+        return Err(Error::Transport(
+            litellm_llms::custom_httpx::transport::Error::Http {
+                status: status.as_u16(),
+                body: truncate_error_body(&text),
+            },
+        ));
     }
 
     let response = serde_json::from_str(&text)
@@ -59,19 +65,24 @@ pub(super) async fn execute_messages_provider_stream(
         request_builder = request_builder.timeout(duration);
     }
 
-    let response = http_request(request_builder)
-        .await
-        .map_err(|err| Error::Transport(crate::transport::Error::Network(err.to_string())))?;
+    let response = http_request(request_builder).await.map_err(|err| {
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+            err.to_string(),
+        ))
+    })?;
     let status = response.status();
     if !status.is_success() {
-        let text = response
-            .text()
-            .await
-            .map_err(|err| Error::Transport(crate::transport::Error::Network(err.to_string())))?;
-        return Err(Error::Transport(crate::transport::Error::Http {
-            status: status.as_u16(),
-            body: truncate_error_body(&text),
-        }));
+        let text = response.text().await.map_err(|err| {
+            Error::Transport(litellm_llms::custom_httpx::transport::Error::Network(
+                err.to_string(),
+            ))
+        })?;
+        return Err(Error::Transport(
+            litellm_llms::custom_httpx::transport::Error::Http {
+                status: status.as_u16(),
+                body: truncate_error_body(&text),
+            },
+        ));
     }
     Ok(response)
 }

litellm-rust/crates/core/src/messages/mod.rs

@@ -8,15 +8,16 @@
 //! can splice the event stream to its own caller.
 
 mod error;
+pub mod types;
 pub use error::Error;
 mod client;
 mod common_utils;
 mod handler;
 mod prepare;
-pub use litellm_providers::messages::types;
-
 use handler::{execute_messages_provider_call, execute_messages_provider_stream};
-use types::{AnthropicMessagesResponse, MessagesRequest};
+use litellm_types::llms::anthropic_messages::anthropic_response::AnthropicMessagesResponse;
+
+use crate::messages::types::MessagesRequest;
 
 pub async fn messages(request: MessagesRequest<'_>) -> Result<AnthropicMessagesResponse, Error> {
     execute_messages_provider_call(request).await

litellm-rust/crates/core/src/messages/prepare.rs

@@ -1,14 +1,14 @@
-use serde_json::{Map, Value};
-
-use super::Error;
-use super::common_utils::{has_bearer_auth, has_header, messages_provider_config, string_headers};
-use super::types::{MessagesRequest, ProviderMessagesRequest};
-use crate::litellm_core_utils::get_llm_provider_logic::{
-    CustomLlmProvider, get_custom_llm_provider,
-};
-use litellm_providers::base_llm::anthropic_messages::transformation::{
+use litellm_core_utils::get_llm_provider_logic::{CustomLlmProvider, get_custom_llm_provider};
+use litellm_llms::base_llm::anthropic_messages::transformation::{
     BaseAnthropicMessagesConfig, MessagesAuthStrategy,
 };
+use serde_json::{Map, Value};
+
+use super::{
+    Error,
+    common_utils::{has_bearer_auth, has_header, messages_provider_config, string_headers},
+};
+use crate::messages::types::{MessagesRequest, ProviderMessagesRequest};
 
 pub(super) fn prepare_provider_request(
     request: MessagesRequest<'_>,

litellm-rust/crates/core/src/messages/tests.rs

@@ -1,15 +1,19 @@
 use std::time::Duration;
 
 use serde_json::{Map, Value, json};
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::{TcpListener, TcpStream};
-
-use super::Error;
-use super::common_utils::{
-    has_bearer_auth, has_header, messages_provider_config, string_headers, truncate_error_body,
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::{TcpListener, TcpStream},
 };
-use super::messages;
-use super::types::MessagesRequest;
+
+use super::{
+    Error,
+    common_utils::{
+        has_bearer_auth, has_header, messages_provider_config, string_headers, truncate_error_body,
+    },
+    messages,
+};
+use crate::messages::types::MessagesRequest;
 
 async fn read_http_request(socket: &mut TcpStream) -> String {
     let mut request = Vec::new();
@@ -78,7 +82,7 @@ fn string_headers_rejects_non_string_values() {
     let err = string_headers(Some(headers)).expect_err("non-string header rejected");
     assert_eq!(
         err,
-        Error::Headers(crate::http_utils::HeaderError {
+        Error::Headers(litellm_llms::custom_httpx::http_handler::HeaderError {
             context: "messages",
             name: "x-count".to_string(),
             actual: "number",
@@ -428,7 +432,7 @@ async fn messages_maps_provider_error_status_to_http_error() {
 
     assert!(matches!(
         err,
-        Error::Transport(crate::transport::Error::Http { status: 401, .. })
+        Error::Transport(litellm_llms::custom_httpx::transport::Error::Http { status: 401, .. })
     ));
 }
 

litellm-rust/crates/core/src/messages/types.rs

@@ -0,0 +1,24 @@
+use std::time::Duration;
+
+use litellm_llms::base_llm::anthropic_messages::transformation::BaseAnthropicMessagesConfig;
+use serde_json::{Map, Value};
+
+pub struct MessagesRequest<'a> {
+    pub model: &'a str,
+    pub body: Value,
+    pub api_key: Option<&'a str>,
+    pub api_base: Option<&'a str>,
+    pub custom_llm_provider: Option<&'a str>,
+    pub extra_headers: Option<Map<String, Value>>,
+    pub timeout: Option<Duration>,
+}
+
+pub struct ProviderMessagesRequest {
+    pub provider: String,
+    pub model: String,
+    pub config: &'static dyn BaseAnthropicMessagesConfig,
+    pub url: String,
+    pub body: Value,
+    pub upstream_headers: Vec<(String, String)>,
+    pub timeout: Option<Duration>,
+}

litellm-rust/crates/core/src/ocr/arguments.rs

@@ -1,5 +1,7 @@
+use litellm_core_utils::call_arguments::ArgumentSpec;
+use litellm_llms::base_llm::ocr::error::Error;
+
 use super::provider_config::{OcrConfigKind, resolve_provider_config};
-use crate::call_arguments::ArgumentSpec;
 
 const COMMON_OPTION_FIELDS: &[&str] = &["req_format", "extra_body", "max_response_bytes"];
 const AZURE_AUTH_OPTION_FIELDS: &[&str] = &[
@@ -29,7 +31,7 @@ pub fn is_supported_request(model: &str, custom_llm_provider: Option<&str>) -> b
 pub fn consumed_optional_param_names(
     model: &str,
     custom_llm_provider: Option<&str>,
-) -> Result<Vec<&'static str>, super::Error> {
+) -> Result<Vec<&'static str>, Error> {
     let (model, config) = resolve_provider_config(model, custom_llm_provider)?;
     let provider_fields = config.get_supported_ocr_params(&model);
     let auth_fields: &[&str] = match config {
@@ -47,23 +49,27 @@ pub fn consumed_optional_param_names(
         .collect())
 }
 
+pub(crate) fn is_secret_param(name: &str) -> bool {
+    matches!(
+        name,
+        "azure_ad_token"
+            | "client_secret"
+            | "azure_federated_token_file"
+            | "vertex_credentials"
+            | "vertex_ai_credentials"
+    )
+}
+
 pub fn consumed_optional_params(
     model: &str,
     custom_llm_provider: Option<&str>,
-) -> Result<Vec<ArgumentSpec>, super::Error> {
+) -> Result<Vec<ArgumentSpec>, Error> {
     consumed_optional_param_names(model, custom_llm_provider).map(|names| {
         names
             .into_iter()
             .map(|name| ArgumentSpec {
                 name,
-                secret: matches!(
-                    name,
-                    "azure_ad_token"
-                        | "client_secret"
-                        | "azure_federated_token_file"
-                        | "vertex_credentials"
-                        | "vertex_ai_credentials"
-                ),
+                secret: is_secret_param(name),
             })
             .collect()
     })

litellm-rust/crates/core/src/ocr/client.rs

@@ -1,201 +1,20 @@
-use std::sync::OnceLock;
-use std::time::Duration;
+use litellm_llms::{
+    base_llm::ocr::{error::Error, transformation::LiteLLMOcrResponse},
+    custom_httpx::llm_http_handler::OcrClient,
+};
 
-use bytes::{Bytes, BytesMut};
-use litellm_auth_gcp::VertexAuth;
-use serde::de::DeserializeOwned;
+use crate::ocr::{
+    route::{LocalOcrHost, ocr_machine},
+    types::LiteLLMOcrRequest,
+};
 
-use super::json::{DecodedOcrResponse, decode_response};
-use super::types::{LiteLLMOcrRequest, LiteLLMOcrResponse};
-use crate::constants::OCR_CONNECT_TIMEOUT_SECS;
-use crate::media::MediaFetcher;
-
-#[derive(Clone)]
-pub struct OcrClient {
-    provider_http: reqwest::Client,
-    polling_http: reqwest::Client,
-    document_fetcher: MediaFetcher,
-    vertex_auth: VertexAuth,
+pub async fn perform(
+    client: &OcrClient,
+    request: LiteLLMOcrRequest,
+) -> Result<LiteLLMOcrResponse, Error> {
+    litellm_callbacks::run::run(ocr_machine(client.clone()), &LocalOcrHost::new(request)).await
 }
 
-impl OcrClient {
-    pub fn new(provider_http: reqwest::Client) -> Result<Self, crate::transport::Error> {
-        let document_fetcher = MediaFetcher::new().map_err(crate::transport::Error::from)?;
-        Ok(Self {
-            provider_http,
-            polling_http: no_redirect_http()?,
-            document_fetcher,
-            vertex_auth: VertexAuth::default(),
-        })
-    }
-
-    pub fn shared() -> Result<Self, crate::ocr::Error> {
-        shared_client()
-    }
-
-    pub async fn perform(
-        &self,
-        request: LiteLLMOcrRequest,
-    ) -> Result<LiteLLMOcrResponse, crate::ocr::Error> {
-        use super::{
-            NativeOutcome, OcrAdmission, OcrCall, OcrCallStep, OcrHookHost, OcrHost,
-            OcrHostOperation, OcrHostResult,
-        };
-
-        let host = OcrHookHost::new(request.hooks.clone());
-        let mut request = Some(request);
-        let NativeOutcome::Completed(mut call) = OcrCall::admit(self.clone(), OcrAdmission::all())
-        else {
-            return Err(crate::ocr::Error::InvalidRequest(
-                "native OCR host admission declined".into(),
-            ));
-        };
-        let mut result = None;
-        loop {
-            match call.resume(result.take()).await? {
-                OcrCallStep::Host(OcrHostOperation::ProjectRequest) => {
-                    result = Some(OcrHostResult::Request(Ok((
-                        Box::new(request.take().ok_or_else(|| {
-                            crate::ocr::Error::InvalidRequest(
-                                "OCR request was already projected".into(),
-                            )
-                        })?),
-                        false,
-                    ))))
-                }
-                OcrCallStep::Host(operation) => result = Some(host.invoke(operation).await),
-                OcrCallStep::Complete(response) => return Ok(response),
-            }
-        }
-    }
-
-    pub(crate) fn provider_http(&self) -> &reqwest::Client {
-        &self.provider_http
-    }
-
-    pub(crate) fn polling_http(&self) -> &reqwest::Client {
-        &self.polling_http
-    }
-
-    pub(crate) fn document_fetcher(&self) -> &MediaFetcher {
-        &self.document_fetcher
-    }
-
-    pub(crate) fn vertex_auth(&self) -> &VertexAuth {
-        &self.vertex_auth
-    }
-
-    #[cfg(test)]
-    pub(crate) fn for_test(provider_http: reqwest::Client, document_http: reqwest::Client) -> Self {
-        Self {
-            provider_http,
-            polling_http: no_redirect_http().expect("test polling client builds"),
-            document_fetcher: MediaFetcher::for_test(document_http),
-            vertex_auth: VertexAuth::default(),
-        }
-    }
-}
-
-fn no_redirect_http() -> Result<reqwest::Client, crate::transport::Error> {
-    reqwest::Client::builder()
-        .connect_timeout(Duration::from_secs(OCR_CONNECT_TIMEOUT_SECS))
-        .redirect(reqwest::redirect::Policy::none())
-        .build()
-        .map_err(crate::transport::Error::from)
-}
-
-pub(crate) fn shared_client() -> Result<OcrClient, crate::ocr::Error> {
-    static CLIENT: OnceLock<Result<OcrClient, crate::transport::Error>> = OnceLock::new();
-    let client = CLIENT
-        .get_or_init(|| {
-            reqwest::Client::builder()
-                .connect_timeout(Duration::from_secs(OCR_CONNECT_TIMEOUT_SECS))
-                .build()
-                .map_err(crate::transport::Error::from)
-                .and_then(OcrClient::new)
-        })
-        .clone()?;
-    Ok(client)
-}
-
-pub async fn ocr(request: LiteLLMOcrRequest) -> Result<LiteLLMOcrResponse, crate::ocr::Error> {
-    shared_client()?.perform(request).await
-}
-
-pub async fn read_json_response<T: DeserializeOwned>(
-    response: reqwest::Response,
-    native: bool,
-    max_response_bytes: usize,
-) -> Result<DecodedOcrResponse<T>, crate::ocr::Error> {
-    let bytes = read_response_bytes(response, max_response_bytes).await?;
-    decode_response(&bytes, native)
-}
-
-pub(crate) async fn read_response_bytes(
-    mut response: reqwest::Response,
-    limit: usize,
-) -> Result<Bytes, crate::ocr::Error> {
-    let status = response.status();
-    if status.is_success()
-        && response
-            .content_length()
-            .is_some_and(|length| length > limit as u64)
-    {
-        return Err(crate::ocr::Error::TooLarge { limit });
-    }
-    let mut bytes = BytesMut::new();
-    while let Some(chunk) = response.chunk().await.map_err(transport_error)? {
-        let remaining = limit.saturating_sub(bytes.len());
-        if status.is_success() && chunk.len() > remaining {
-            return Err(crate::ocr::Error::TooLarge { limit });
-        }
-        bytes.extend_from_slice(&chunk[..chunk.len().min(remaining)]);
-        if !status.is_success() && bytes.len() == limit {
-            break;
-        }
-    }
-    if !status.is_success() {
-        return Err(crate::transport::Error::Http {
-            status: status.as_u16(),
-            body: String::from_utf8_lossy(&bytes).into_owned(),
-        }
-        .into());
-    }
-    Ok(bytes.freeze())
-}
-
-pub(crate) fn transport_error(error: reqwest::Error) -> crate::ocr::Error {
-    if error.is_timeout() {
-        return crate::ocr::Error::Transport(crate::transport::Error::Http {
-            status: 408,
-            body: "OCR request timed out".into(),
-        });
-    }
-    crate::transport::Error::from(error).into()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn request_timeout_has_an_http_408_status() {
-        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let address = listener.local_addr().unwrap();
-        let server = tokio::spawn(async move {
-            let _connection = listener.accept().await.unwrap();
-            tokio::time::sleep(Duration::from_secs(1)).await;
-        });
-        let error = reqwest::Client::new()
-            .get(format!("http://{address}"))
-            .timeout(Duration::from_millis(10))
-            .send()
-            .await
-            .unwrap_err();
-        assert!(matches!(
-            transport_error(error),
-            crate::ocr::Error::Transport(crate::transport::Error::Http { status: 408, .. })
-        ));
-        server.abort();
-    }
+pub async fn ocr(request: LiteLLMOcrRequest) -> Result<LiteLLMOcrResponse, Error> {
+    perform(&OcrClient::shared()?, request).await
 }

litellm-rust/crates/core/src/ocr/document.rs

@@ -1,22 +1,14 @@
-use std::collections::BTreeMap as Map;
-use std::io::Read;
-use std::path::Path;
+use std::{collections::BTreeMap as Map, io::Read, path::Path};
 
 use base64::{Engine, engine::general_purpose::STANDARD};
-use data_url::mime::Mime;
-use data_url::{DataUrl, DataUrlError, forgiving_base64::DecodeError};
-use reqwest::Url;
+use litellm_llms::base_llm::ocr::{
+    error::Error,
+    transformation::{OCR_INLINE_MAX_BYTES, OcrDocument},
+};
 
-use super::Error as OcrError;
-use super::Error as OcrRequestError;
-use super::Error as OcrResponseError;
-use super::types::{OcrConnection, OcrDocument, OcrDocumentInput};
-use crate::constants::{OCR_INLINE_MAX_BYTES, OCR_MAX_FETCH_REDIRECTS};
-use crate::media::Error as MediaError;
-use crate::media::{DownloadPolicy, MediaFetcher};
-use crate::transport::Error as TransportError;
+use crate::ocr::types::OcrDocumentInput;
 
-pub fn prepare_document(input: OcrDocumentInput) -> Result<OcrDocument, super::Error> {
+pub fn prepare_document(input: OcrDocumentInput) -> Result<OcrDocument, Error> {
     match input {
         OcrDocumentInput::Document(document) => Ok(document),
         OcrDocumentInput::Path { path, mime_type } => {
@@ -31,23 +23,20 @@ pub fn prepare_document(input: OcrDocumentInput) -> Result<OcrDocument, super::E
             file_name.as_deref(),
             mime_type.as_deref(),
         )?),
-        OcrDocumentInput::HostReader { .. } => Err(super::Error::InvalidRequest(
+        OcrDocumentInput::HostReader { .. } => Err(Error::InvalidRequest(
             "OCR file reader was not read by the host".into(),
         )),
     }
 }
 
-pub fn read_path_document(
-    path: &Path,
-    mime_type: Option<&str>,
-) -> Result<OcrDocument, super::Error> {
+pub fn read_path_document(path: &Path, mime_type: Option<&str>) -> Result<OcrDocument, Error> {
     let mut bytes = Vec::new();
     std::fs::File::open(path)
         .and_then(|file| {
             file.take(OCR_INLINE_MAX_BYTES as u64 + 1)
                 .read_to_end(&mut bytes)
         })
-        .map_err(|source| super::Error::FileRead {
+        .map_err(|source| Error::FileRead {
             path: path.to_owned(),
             source: std::sync::Arc::new(source),
         })?;
@@ -59,17 +48,17 @@ pub fn encode_file_document(
     bytes: &[u8],
     file_name: Option<&str>,
     mime_type: Option<&str>,
-) -> Result<OcrDocument, OcrRequestError> {
+) -> Result<OcrDocument, Error> {
     if bytes.is_empty() {
-        return Err(OcrRequestError::EmptyFile);
+        return Err(Error::EmptyFile);
     }
     if bytes.len() > OCR_INLINE_MAX_BYTES {
-        return Err(OcrRequestError::InlineDocumentTooLarge);
+        return Err(Error::InlineDocumentTooLarge);
     }
     if let Some(value) = mime_type
         && !valid_mime_type(value)
     {
-        return Err(OcrRequestError::InvalidMimeType(value.into()));
+        return Err(Error::InvalidMimeType(value.into()));
     }
     let mime_type = mime_type
         .map(str::to_string)
@@ -119,105 +108,12 @@ pub fn mime_type_for_name(name: &str) -> &'static str {
     }
 }
 
-pub(crate) struct InlineDocument<'a>(DataUrl<'a>);
-
-impl<'a> InlineDocument<'a> {
-    pub(crate) fn parse(source: &'a str) -> Result<Option<Self>, OcrRequestError> {
-        match DataUrl::process(source) {
-            Ok(url) => Ok(Some(Self(url))),
-            Err(DataUrlError::NotADataUrl) => Ok(None),
-            Err(DataUrlError::NoComma) => Err(OcrRequestError::InvalidDataUri),
-        }
-    }
-
-    pub(crate) fn mime_type(&self) -> &Mime {
-        self.0.mime_type()
-    }
-
-    pub(crate) fn decode(&self, max_bytes: usize) -> Result<Vec<u8>, OcrRequestError> {
-        let mut body = Vec::new();
-        self.0
-            .decode(|bytes| {
-                if bytes.len() > max_bytes.saturating_sub(body.len()) {
-                    return Err(OcrRequestError::InlineDocumentTooLarge);
-                }
-                body.extend_from_slice(bytes);
-                Ok(())
-            })
-            .map_err(|error| match error {
-                DecodeError::InvalidBase64(_) => OcrRequestError::InvalidDataUri,
-                DecodeError::WriteError(error) => error,
-            })?;
-        Ok(body)
-    }
-}
-
-pub(crate) fn validate_inline_document(document: &OcrDocument) -> Result<(), OcrRequestError> {
-    let inline =
-        InlineDocument::parse(document.source())?.ok_or(OcrRequestError::InvalidDataUri)?;
-    inline.decode(crate::constants::OCR_INLINE_MAX_BYTES)?;
-    Ok(())
-}
-
-pub(crate) async fn inline_remote_document(
-    fetcher: &MediaFetcher,
-    document: OcrDocument,
-    connection: &OcrConnection,
-) -> Result<OcrDocument, OcrError> {
-    let source = document.source();
-    if !document.is_remote() {
-        validate_inline_document(&document)?;
-        return Ok(document);
-    }
-    let url = Url::parse(source).map_err(|_| OcrRequestError::RequestField {
-        path: "document URL".into(),
-    })?;
-    let downloaded = fetcher
-        .fetch(
-            url,
-            DownloadPolicy {
-                timeout: connection.timeout,
-                max_bytes: connection.max_download_bytes,
-                max_redirects: OCR_MAX_FETCH_REDIRECTS,
-            },
-        )
-        .await
-        .map_err(map_media_error)?;
-    let result = document.with_source(format!(
-        "data:{};base64,{}",
-        downloaded.content_type,
-        STANDARD.encode(downloaded.bytes)
-    ));
-    validate_inline_document(&result)?;
-    Ok(result)
-}
-
-fn map_media_error(error: MediaError) -> OcrError {
-    match error {
-        MediaError::BlockedUrl => OcrRequestError::BlockedDocumentUrl,
-        MediaError::DownloadDisabled => OcrRequestError::DownloadDisabled,
-        MediaError::DownloadTooLarge => OcrRequestError::DownloadTooLarge,
-        MediaError::TooManyRedirects => OcrRequestError::TooManyRedirects,
-        MediaError::MissingRedirectLocation => OcrResponseError::MissingRedirectLocation,
-        MediaError::InvalidRedirect => OcrResponseError::InvalidRedirect,
-        MediaError::Http(status) => TransportError::Http {
-            status,
-            body: "OCR document download failed".into(),
-        }
-        .into(),
-        MediaError::Timeout => TransportError::Http {
-            status: 408,
-            body: "OCR document download timed out".into(),
-        }
-        .into(),
-        MediaError::Transport(error) => error.into(),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeMap as Map;
 
+    use litellm_llms::base_llm::ocr::document::InlineDocument;
+
     use super::*;
 
     fn document(source: &str) -> OcrDocument {
@@ -293,12 +189,12 @@ mod tests {
                 path: path.clone(),
                 mime_type: None,
             }),
-            Err(OcrRequestError::InlineDocumentTooLarge)
+            Err(Error::InlineDocumentTooLarge)
         ));
         std::fs::remove_dir_all(&dir).unwrap();
 
         let missing = dir.join("missing.pdf");
-        let Err(super::super::Error::FileRead { path, source, .. }) =
+        let Err(super::Error::FileRead { path, source, .. }) =
             prepare_document(OcrDocumentInput::Path {
                 path: missing.clone(),
                 mime_type: None,
@@ -329,7 +225,7 @@ mod tests {
         let bytes = vec![b'a'; OCR_INLINE_MAX_BYTES + 1];
         assert!(matches!(
             encode_file_document(&bytes, None, None),
-            Err(OcrRequestError::InlineDocumentTooLarge)
+            Err(Error::InlineDocumentTooLarge)
         ));
         let document = encode_file_document(&bytes[..OCR_INLINE_MAX_BYTES], None, None).unwrap();
         let inline = InlineDocument::parse(document.source()).unwrap().unwrap();
@@ -351,100 +247,4 @@ mod tests {
             assert!(encode_file_document(b"abc", None, Some(mime)).is_err());
         }
     }
-
-    #[test]
-    fn decodes_data_urls_and_limits_decoded_size() {
-        for (source, expected) in [
-            ("data:application/pdf;base64,YWJj", b"abc".as_slice()),
-            ("DATA:application/pdf;BASE64,YWI", b"ab".as_slice()),
-            ("data:,a%20b%00%FF", b"a b\0\xff".as_slice()),
-        ] {
-            let inline = InlineDocument::parse(source).unwrap().unwrap();
-            assert_eq!(inline.decode(expected.len()).unwrap(), expected);
-            assert!(matches!(
-                inline.decode(expected.len() - 1),
-                Err(OcrRequestError::InlineDocumentTooLarge)
-            ));
-        }
-    }
-
-    #[test]
-    fn preserves_mime_parameters_and_standard_default() {
-        let inline = InlineDocument::parse("data:application/pdf;version=1.7;base64,YQ==")
-            .unwrap()
-            .unwrap();
-        assert!(inline.mime_type().matches("application", "pdf"));
-        assert_eq!(inline.mime_type().get_parameter("version"), Some("1.7"));
-        let default = InlineDocument::parse("data:,a").unwrap().unwrap();
-        assert!(default.mime_type().matches("text", "plain"));
-        assert_eq!(
-            default.mime_type().get_parameter("charset"),
-            Some("US-ASCII")
-        );
-    }
-
-    #[test]
-    fn rejects_invalid_inline_documents() {
-        for source in [
-            "https://example.com/document.pdf",
-            "data:application/pdf;base64",
-            "data:application/pdf;base64,INVALID!",
-        ] {
-            assert!(validate_inline_document(&document(source)).is_err());
-        }
-    }
-
-    #[tokio::test]
-    async fn remote_conversion_preserves_kind_and_isolates_provider_credentials() {
-        use tokio::io::{AsyncReadExt, AsyncWriteExt};
-        use tokio::net::TcpListener;
-
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let address = listener.local_addr().unwrap();
-        let server = tokio::spawn(async move {
-            let (mut socket, _) = listener.accept().await.unwrap();
-            let mut request = vec![0_u8; 2048];
-            let count = socket.read(&mut request).await.unwrap();
-            socket
-                .write_all(b"HTTP/1.1 200 OK\r\nContent-Type: image/png; charset=binary\r\nContent-Length: 3\r\nConnection: close\r\n\r\nabc")
-                .await
-                .unwrap();
-            String::from_utf8_lossy(&request[..count]).into_owned()
-        });
-        let mut provider_headers = reqwest::header::HeaderMap::new();
-        provider_headers.insert(
-            reqwest::header::AUTHORIZATION,
-            reqwest::header::HeaderValue::from_static("Bearer provider-secret"),
-        );
-        let provider_http = reqwest::Client::builder()
-            .default_headers(provider_headers)
-            .build()
-            .unwrap();
-        let document_http = reqwest::Client::builder()
-            .redirect(reqwest::redirect::Policy::none())
-            .build()
-            .unwrap();
-        let client = super::super::OcrClient::for_test(provider_http, document_http);
-        let converted = inline_remote_document(
-            client.document_fetcher(),
-            OcrDocument::ImageUrl {
-                image_url: format!("http://{address}/image"),
-                extra_fields: Map::from_iter([("detail".into(), Some("high".into()))]),
-            },
-            &OcrConnection::default(),
-        )
-        .await
-        .unwrap();
-        let request = server.await.unwrap();
-
-        assert_eq!(
-            converted,
-            OcrDocument::ImageUrl {
-                image_url: "data:image/png;base64,YWJj".into(),
-                extra_fields: Map::from_iter([("detail".into(), Some("high".into()))]),
-            }
-        );
-        assert!(!request.to_ascii_lowercase().contains("authorization"));
-        assert!(!request.contains("provider-secret"));
-    }
 }

litellm-rust/crates/core/src/ocr/handler.rs

@@ -1,125 +1,81 @@
-use std::sync::Arc;
+use futures_util::future::BoxFuture;
+use litellm_callbacks::event::{CallEvent, Passthrough, RawResponse, RequestContext, WireRequest};
+use litellm_llms::{
+    base_llm::ocr::{
+        error::Error,
+        transformation::{LiteLLMOcrResponse, PreparedOcrRequest},
+    },
+    custom_httpx::llm_http_handler::{CallHooks, OcrClient},
+};
+use serde_json::Value;
 
-use super::OcrClient;
-use super::hooks::{OcrHooks, OcrLifecycleHooks, OcrPostCallRequest};
-use super::types::{LiteLLMOcrResponse, PreparedOcrRequest, ResolvedOcrRequest};
-use crate::call_lifecycle::{CallLifecycle, CallLifecycleContext};
-use crate::llms::base_llm::ocr::transformation::OcrResponseContext;
+use super::{
+    arguments::is_secret_param, prepare::prepare_request, provider_config::OcrConfigKind,
+    route::OcrHost,
+};
+use crate::ocr::types::ResolvedOcrRequest;
 
 pub(crate) async fn perform_ocr_request(
     client: &OcrClient,
     request: ResolvedOcrRequest,
-) -> Result<LiteLLMOcrResponse, super::Error> {
+    host: &OcrHost,
+    caller_document: bool,
+) -> Result<LiteLLMOcrResponse, Error> {
     request.response_format()?;
-    let context = CallLifecycleContext::new(
-        "ocr",
-        request.model.clone(),
-        request.provider_name(),
-        request
-            .litellm_call_id
-            .clone()
-            .unwrap_or_else(|| format!("ocr-{:032x}", rand::random::<u128>())),
-    );
-    let hooks = OcrLifecycleHooks {
-        hooks: request.hooks.clone(),
-        provider_name: context.custom_llm_provider.clone(),
-    };
-    CallLifecycle::default()
-        .run(context, request, &hooks, |request| async move {
-            PreparedOcrCall::prepare(client.clone(), request)
-                .await?
-                .execute()
-                .await
-        })
-        .await
+    let config = request.config;
+    let request = prepare_request(request, caller_document);
+    let hooks = OcrCallHooks::new(host.clone(), &request, config);
+    config.ocr(client, &request, &hooks).await
 }
 
-pub(crate) struct PreparedOcrCall {
-    client: OcrClient,
-    request: PreparedOcrRequest,
-    http: reqwest::Request,
+/// Lets provider code reach the host mid-call, filling in the request context only the
+/// route knows.
+pub(crate) struct OcrCallHooks {
+    host: OcrHost,
+    model: String,
+    custom_llm_provider: &'static str,
+    optional_params: Value,
+    secret_fields: Vec<String>,
 }
 
-impl PreparedOcrCall {
-    pub(crate) async fn prepare(
-        client: OcrClient,
-        request: ResolvedOcrRequest,
-    ) -> Result<Self, super::Error> {
-        let request = super::prepare::prepare_request(request);
-        let http = request.config.prepare_request(&request, &client).await?;
-        Ok(Self {
-            client,
-            request,
-            http,
-        })
-    }
-
-    pub(crate) async fn execute(self) -> Result<LiteLLMOcrResponse, super::Error> {
-        let url = self.http.url().to_string();
-        let headers = request_headers(&self.http)?;
-        let response =
-            crate::http_utils::execute_http_request(self.client.provider_http(), self.http)
-                .await
-                .map_err(super::client::transport_error)?;
-        if !response.status().is_success() {
-            let headers = response
-                .headers()
-                .iter()
-                .filter_map(|(name, value)| {
-                    value
-                        .to_str()
-                        .ok()
-                        .map(|value| (name.to_string(), value.to_string()))
-                })
-                .collect();
-            return match super::client::read_response_bytes(
-                response,
-                self.request.connection.max_response_bytes,
-            )
-            .await
-            {
-                Err(super::Error::Transport(crate::transport::Error::Http { status, body })) => {
-                    Err(self.request.config.get_error_class(body, status, headers))
-                }
-                Err(error) => Err(error),
-                Ok(_) => unreachable!("non-success response produces an HTTP error"),
-            };
+impl OcrCallHooks {
+    pub(crate) fn new(host: OcrHost, request: &PreparedOcrRequest, config: OcrConfigKind) -> Self {
+        Self {
+            host,
+            model: request.model.clone(),
+            custom_llm_provider: config.provider().into(),
+            optional_params: Value::Object(request.optional_params.clone().into()),
+            secret_fields: request
+                .optional_params
+                .keys()
+                .filter(|name| is_secret_param(name))
+                .cloned()
+                .collect(),
         }
-        let model = &self.request.model;
-        let context = OcrResponseContext {
-            client: &self.client,
-            connection: &self.request.connection,
-            hooks: &self.request.hooks,
-            request_format: self.request.response_format()?,
-            url: &url,
-            headers: &headers,
-        };
-        self.request
-            .config
-            .async_transform_ocr_response(model, response, context)
-            .await
     }
 }
 
-fn request_headers(request: &reqwest::Request) -> Result<Vec<(String, String)>, super::Error> {
-    request
-        .headers()
-        .iter()
-        .map(|(name, value)| {
-            value
-                .to_str()
-                .map(|value| (name.to_string(), value.to_string()))
-                .map_err(|_| super::Error::RequestField {
-                    path: "headers".into(),
-                })
-        })
-        .collect()
-}
+impl CallHooks<Error> for OcrCallHooks {
+    fn before_send(
+        &self,
+        wire: WireRequest,
+        passthrough_fields: Passthrough,
+    ) -> BoxFuture<'_, Result<WireRequest, Error>> {
+        let context = RequestContext {
+            model: self.model.clone(),
+            custom_llm_provider: self.custom_llm_provider.into(),
+            optional_params: self.optional_params.clone(),
+            passthrough_fields,
+            secret_fields: self.secret_fields.clone(),
+        };
+        Box::pin(self.host.before_send(wire, context))
+    }
 
-pub(crate) async fn post_call(hooks: &Arc<dyn OcrHooks>, bytes: &[u8]) -> Result<(), super::Error> {
-    let original_response = serde_json::Value::String(String::from_utf8_lossy(bytes).into_owned());
-    hooks
-        .post_call(OcrPostCallRequest { original_response })
-        .await?;
-    Ok(())
+    fn response_received<'a>(&'a self, body: &'a [u8]) -> BoxFuture<'a, Result<(), Error>> {
+        Box::pin(self.host.emit(CallEvent::ResponseReceived {
+            raw: RawResponse {
+                body: String::from_utf8_lossy(body).into_owned(),
+            },
+        }))
+    }
 }

litellm-rust/crates/core/src/ocr/hooks.rs

@@ -1,147 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-
-use serde::Serialize;
-use serde_json::Value;
-
-use super::types::{LiteLLMOcrRequest, LiteLLMOcrResponse, OcrDocument, ResolvedOcrRequest};
-use crate::call_lifecycle::{CallLifecycleContext, CallLifecycleHooks, CallLifecycleTiming};
-use crate::ocr::Error;
-
-pub type OcrHookFuture<'a, T> = Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'a>>;
-pub type OcrLogFuture<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
-
-#[derive(Clone, Debug, Serialize)]
-pub struct OcrPreCallRequest {
-    pub model: String,
-    pub custom_llm_provider: String,
-    pub document: OcrDocument,
-    pub optional_params: Value,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct OcrDuringCallRequest {
-    pub model: String,
-    pub custom_llm_provider: String,
-    pub api_key: Option<String>,
-    pub url: String,
-    pub headers: Vec<(String, String)>,
-    pub body: Value,
-    #[serde(skip)]
-    pub retained_fields: Vec<String>,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct OcrPostCallRequest {
-    pub original_response: Value,
-}
-
-pub trait OcrHooks: Send + Sync {
-    fn intercepts_requests(&self) -> bool {
-        false
-    }
-    fn pre_call(&self, request: OcrPreCallRequest) -> OcrHookFuture<'_, OcrPreCallRequest> {
-        Box::pin(async move { Ok(request) })
-    }
-    fn during_call(
-        &self,
-        request: OcrDuringCallRequest,
-    ) -> OcrHookFuture<'_, OcrDuringCallRequest> {
-        Box::pin(async move { Ok(request) })
-    }
-    fn post_call(&self, request: OcrPostCallRequest) -> OcrHookFuture<'_, OcrPostCallRequest> {
-        Box::pin(async move { Ok(request) })
-    }
-    fn success<'a>(
-        &'a self,
-        _context: &'a CallLifecycleContext,
-        _response: &'a LiteLLMOcrResponse,
-        _timing: &'a CallLifecycleTiming,
-    ) -> OcrLogFuture<'a> {
-        Box::pin(async {})
-    }
-    fn failure<'a>(
-        &'a self,
-        _context: &'a CallLifecycleContext,
-        _error: &'a Error,
-        _timing: &'a CallLifecycleTiming,
-    ) -> OcrLogFuture<'a> {
-        Box::pin(async {})
-    }
-}
-
-pub struct NoopOcrHooks;
-impl OcrHooks for NoopOcrHooks {}
-
-pub(crate) struct OcrLifecycleHooks {
-    pub hooks: Arc<dyn OcrHooks>,
-    pub provider_name: String,
-}
-
-impl CallLifecycleHooks<ResolvedOcrRequest, ResolvedOcrRequest, LiteLLMOcrResponse>
-    for OcrLifecycleHooks
-{
-    type Error = crate::ocr::Error;
-    type PreCallFuture<'a> = OcrHookFuture<'a, ResolvedOcrRequest>;
-    type DuringCallFuture<'a> = OcrHookFuture<'a, ResolvedOcrRequest>;
-    type SuccessFuture<'a> = OcrLogFuture<'a>;
-    type FailureFuture<'a> = OcrLogFuture<'a>;
-
-    fn async_pre_call_hook<'a>(
-        &'a self,
-        _context: &'a CallLifecycleContext,
-        request: ResolvedOcrRequest,
-    ) -> Self::PreCallFuture<'a> {
-        Box::pin(async move {
-            if !self.hooks.intercepts_requests() {
-                return Ok(request);
-            }
-            let changed = self
-                .hooks
-                .pre_call(OcrPreCallRequest {
-                    model: request.model.clone(),
-                    custom_llm_provider: self.provider_name.clone(),
-                    document: request.document,
-                    optional_params: Value::Object(request.optional_params.into()),
-                })
-                .await?;
-            let Value::Object(optional_params) = changed.optional_params else {
-                return Err(super::Error::RequestField {
-                    path: "guardrail.optional_params".into(),
-                });
-            };
-            Ok(LiteLLMOcrRequest {
-                document: changed.document,
-                optional_params: optional_params.into(),
-                ..request
-            })
-        })
-    }
-
-    fn async_during_call_hook<'a>(
-        &'a self,
-        _context: &'a CallLifecycleContext,
-        request: ResolvedOcrRequest,
-    ) -> Self::DuringCallFuture<'a> {
-        Box::pin(async move { Ok(request) })
-    }
-
-    fn async_log_success_event<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        response: &'a LiteLLMOcrResponse,
-        timing: &'a CallLifecycleTiming,
-    ) -> Self::SuccessFuture<'a> {
-        self.hooks.success(context, response, timing)
-    }
-
-    fn async_log_failure_event<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        error: &'a Error,
-        timing: &'a CallLifecycleTiming,
-    ) -> Self::FailureFuture<'a> {
-        self.hooks.failure(context, error, timing)
-    }
-}

litellm-rust/crates/core/src/ocr/json.rs

@@ -1,62 +0,0 @@
-use serde::de::{DeserializeOwned, IntoDeserializer};
-use serde_json::{Map, Value};
-
-#[derive(Debug)]
-pub struct DecodedOcrResponse<T> {
-    pub data: T,
-    pub native: Option<Map<String, Value>>,
-    pub text: String,
-}
-
-pub(crate) fn decode_request_value<T: DeserializeOwned>(
-    value: Value,
-    prefix: &str,
-) -> Result<T, crate::ocr::Error> {
-    serde_path_to_error::deserialize(value.into_deserializer()).map_err(|error| {
-        crate::ocr::Error::RequestField {
-            path: format!("{prefix}.{}", error.path()),
-        }
-    })
-}
-
-pub(crate) fn decode_response_value<T: DeserializeOwned>(
-    value: Value,
-    prefix: &str,
-) -> Result<T, crate::ocr::Error> {
-    serde_path_to_error::deserialize(value.into_deserializer()).map_err(|error| {
-        crate::ocr::Error::ResponseField {
-            path: format!("{prefix}.{}", error.path()),
-        }
-    })
-}
-
-pub(crate) fn decode_response<T: DeserializeOwned>(
-    bytes: &[u8],
-    native: bool,
-) -> Result<DecodedOcrResponse<T>, crate::ocr::Error> {
-    let mut deserializer = serde_json::Deserializer::from_slice(bytes);
-    let data = serde_path_to_error::deserialize(&mut deserializer).map_err(|error| {
-        crate::ocr::Error::ResponseField {
-            path: error.path().to_string(),
-        }
-    })?;
-    deserializer
-        .end()
-        .map_err(|_| crate::ocr::Error::ResponseField {
-            path: "response".into(),
-        })?;
-    let native = if native {
-        Some(
-            serde_json::from_slice(bytes).map_err(|_| crate::ocr::Error::ResponseField {
-                path: "response".into(),
-            })?,
-        )
-    } else {
-        None
-    };
-    Ok(DecodedOcrResponse {
-        data,
-        native,
-        text: String::from_utf8_lossy(bytes).into_owned(),
-    })
-}

litellm-rust/crates/core/src/ocr/lifecycle.rs

@@ -1,727 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use litellm_auth::Error as AuthError;
-use litellm_auth::{ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
-use tokio::sync::{Notify, mpsc, oneshot};
-
-use super::handler::perform_ocr_request;
-use super::hooks::{
-    OcrDuringCallRequest, OcrHookFuture, OcrHooks, OcrLogFuture, OcrPostCallRequest,
-    OcrPreCallRequest,
-};
-use super::types::{OcrDocumentInput, OcrFileContent};
-use super::{LiteLLMOcrRequest, LiteLLMOcrResponse, OcrClient};
-use crate::call_lifecycle::host::{
-    HostCall, HostCallFuture, HostCallStep, HostFailure, HostLifecycle, HostPhase,
-};
-use crate::call_lifecycle::{CallLifecycleContext, CallLifecycleTiming};
-use crate::ocr::Error;
-
-pub type NativeResult<T> = Result<NativeOutcome<T>, Error>;
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum NativeOutcome<T> {
-    Completed(T),
-    Declined(OcrDecline),
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum OcrDecline {
-    ProviderWorkflow,
-    HostOperations,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct OcrAdmission {
-    pub provider_workflow: bool,
-    pub host_operations: bool,
-    pub asynchronous: bool,
-}
-
-impl OcrAdmission {
-    pub const fn all() -> Self {
-        Self {
-            provider_workflow: true,
-            host_operations: true,
-            asynchronous: false,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum OcrHostOperation {
-    ProjectRequest,
-    ReadDocument,
-    Lifecycle(HostPhase),
-    ConstructResponse(Arc<LiteLLMOcrResponse>),
-    MapFailure(Error),
-    Success {
-        context: CallLifecycleContext,
-        response: Arc<LiteLLMOcrResponse>,
-        timing: CallLifecycleTiming,
-    },
-    Failure {
-        context: CallLifecycleContext,
-        error: Error,
-        timing: CallLifecycleTiming,
-    },
-    AcquireAzureAdToken,
-    PreCall(OcrPreCallRequest),
-    DuringCall(OcrDuringCallRequest),
-    PostCall(OcrPostCallRequest),
-}
-
-impl OcrHostOperation {
-    pub const fn phase(&self) -> Option<HostPhase> {
-        match self {
-            Self::Lifecycle(phase) => Some(*phase),
-            Self::Success { .. } => Some(HostPhase::Success),
-            Self::Failure { .. } => Some(HostPhase::Failure),
-            _ => None,
-        }
-    }
-}
-
-pub enum OcrHostResult {
-    Request(Result<(Box<LiteLLMOcrRequest<OcrDocumentInput>>, bool), Error>),
-    Document(Result<OcrFileContent, Error>),
-    Lifecycle(Result<(), HostFailure<Error>>),
-    AzureAdToken(Result<ResolvedCredential, AuthError>),
-    PreCall(Result<OcrPreCallRequest, Error>),
-    DuringCall(Result<OcrDuringCallRequest, Error>),
-    PostCall(Result<OcrPostCallRequest, Error>),
-}
-
-pub type OcrCallStep = HostCallStep<OcrHostOperation, LiteLLMOcrResponse>;
-
-pub struct OcrCall {
-    lifecycle: HostLifecycle,
-    execution: OcrExecution,
-    response: Option<Arc<LiteLLMOcrResponse>>,
-    error: Option<Error>,
-    pending: bool,
-    completed: bool,
-    projecting: bool,
-}
-
-impl OcrCall {
-    pub fn admit(client: OcrClient, admission: OcrAdmission) -> NativeOutcome<Self> {
-        if !admission.provider_workflow {
-            return NativeOutcome::Declined(OcrDecline::ProviderWorkflow);
-        }
-        if !admission.host_operations {
-            return NativeOutcome::Declined(OcrDecline::HostOperations);
-        }
-        NativeOutcome::Completed(Self {
-            lifecycle: HostLifecycle::new(admission.asynchronous),
-            execution: OcrExecution::new(client),
-            response: None,
-            error: None,
-            pending: false,
-            completed: false,
-            projecting: false,
-        })
-    }
-
-    pub async fn resume(&mut self, result: Option<OcrHostResult>) -> Result<OcrCallStep, Error> {
-        if self.completed {
-            return Err(Error::InvalidRequest(
-                "OCR call cannot be resumed after completion".into(),
-            ));
-        }
-        if self.pending != result.is_some() {
-            return Err(Error::InvalidRequest(
-                "OCR host operation result does not match pending state".into(),
-            ));
-        }
-        match &result {
-            Some(OcrHostResult::Lifecycle(Ok(())))
-                if self.lifecycle.phase() == HostPhase::Execute =>
-            {
-                return Err(Error::InvalidRequest(
-                    "OCR provider operation requires a typed result".into(),
-                ));
-            }
-            Some(result)
-                if !matches!(result, OcrHostResult::Lifecycle(_))
-                    && self.lifecycle.phase() != HostPhase::Execute =>
-            {
-                return Err(Error::InvalidRequest(
-                    "unexpected OCR provider operation result".into(),
-                ));
-            }
-            _ => {}
-        }
-        self.pending = false;
-        let provider_result = match result {
-            Some(OcrHostResult::Request(result)) if self.projecting => {
-                self.projecting = false;
-                match result {
-                    Ok((request, azure_ad_token_provider)) => {
-                        self.execution.request = Some(*request);
-                        self.execution.azure_ad_token_provider = azure_ad_token_provider;
-                    }
-                    Err(error) => self.accept(Err(HostFailure::Error(error))),
-                }
-                None
-            }
-            Some(OcrHostResult::Request(_)) => {
-                return Err(Error::InvalidRequest(
-                    "unexpected OCR request projection".into(),
-                ));
-            }
-            Some(OcrHostResult::Lifecycle(result)) => {
-                self.accept(result);
-                None
-            }
-            result => result,
-        };
-        if self.lifecycle.phase() == HostPhase::Execute {
-            if self.execution.request.is_none()
-                && self.execution.execution.is_none()
-                && !self.execution.completed
-            {
-                self.projecting = true;
-                return Ok(self.host_step(OcrHostOperation::ProjectRequest));
-            }
-            match self.execution.resume(provider_result).await {
-                Ok(OcrCallStep::Host(operation)) => return Ok(self.host_step(operation)),
-                Ok(OcrCallStep::Complete(response)) => {
-                    self.response = Some(Arc::new(response));
-                    self.accept(Ok(()));
-                }
-                Err(error) => self.accept(Err(HostFailure::Error(error))),
-            }
-        }
-        if self.error.is_some() {
-            self.execution.stop().await;
-        }
-        let operation = match self.lifecycle.phase() {
-            HostPhase::Complete => {
-                self.completed = true;
-                return match self.error.take() {
-                    Some(error) => Err(error),
-                    None => self
-                        .response
-                        .take()
-                        .map(Arc::unwrap_or_clone)
-                        .map(OcrCallStep::Complete)
-                        .ok_or_else(|| {
-                            Error::InvalidRequest("OCR completed without a response".into())
-                        }),
-                };
-            }
-            HostPhase::ConstructResponse => OcrHostOperation::ConstructResponse(
-                self.response
-                    .as_ref()
-                    .ok_or_else(|| Error::InvalidRequest("missing OCR response".into()))?
-                    .clone(),
-            ),
-            HostPhase::MapFailure => OcrHostOperation::MapFailure(
-                self.error
-                    .as_ref()
-                    .ok_or_else(|| Error::InvalidRequest("missing OCR failure".into()))?
-                    .clone(),
-            ),
-            HostPhase::Success | HostPhase::Failure => {
-                let snapshot = self
-                    .execution
-                    .terminal
-                    .lock()
-                    .unwrap_or_else(|error| error.into_inner())
-                    .clone();
-                match (self.lifecycle.phase(), snapshot) {
-                    (HostPhase::Success, Some((context, timing))) => OcrHostOperation::Success {
-                        context,
-                        response: self
-                            .response
-                            .as_ref()
-                            .ok_or_else(|| Error::InvalidRequest("missing OCR response".into()))?
-                            .clone(),
-                        timing,
-                    },
-                    (HostPhase::Failure, Some((context, timing))) => OcrHostOperation::Failure {
-                        context,
-                        error: self
-                            .error
-                            .as_ref()
-                            .ok_or_else(|| Error::InvalidRequest("missing OCR failure".into()))?
-                            .clone(),
-                        timing,
-                    },
-                    (phase, _) => OcrHostOperation::Lifecycle(phase),
-                }
-            }
-            phase => OcrHostOperation::Lifecycle(phase),
-        };
-        Ok(self.host_step(operation))
-    }
-
-    fn accept(&mut self, result: Result<(), HostFailure<Error>>) {
-        let cancelled = matches!(&result, Err(HostFailure::Cancelled(_)));
-        if let Some(error) = self.lifecycle.accept(result) {
-            if cancelled {
-                self.error = Some(error);
-            } else {
-                self.error.get_or_insert(error);
-            }
-            self.execution.cancel();
-        }
-    }
-
-    pub async fn interrupt(&mut self, failure: HostFailure<Error>) -> Result<OcrCallStep, Error> {
-        if self.completed {
-            return Err(Error::InvalidRequest(
-                "OCR call cannot be interrupted after completion".into(),
-            ));
-        }
-        self.pending = false;
-        self.accept(Err(failure));
-        self.resume(None).await
-    }
-
-    fn host_step(&mut self, operation: OcrHostOperation) -> OcrCallStep {
-        self.pending = true;
-        OcrCallStep::Host(operation)
-    }
-}
-
-impl HostCall for OcrCall {
-    type Error = crate::ocr::Error;
-    type Operation = OcrHostOperation;
-    type Result = OcrHostResult;
-    type Complete = LiteLLMOcrResponse;
-
-    fn resume(
-        &mut self,
-        result: Option<Self::Result>,
-    ) -> HostCallFuture<'_, Self::Operation, Self::Complete, Self::Error> {
-        Box::pin(OcrCall::resume(self, result))
-    }
-
-    fn interrupt(
-        &mut self,
-        failure: HostFailure<Self::Error>,
-    ) -> HostCallFuture<'_, Self::Operation, Self::Complete, Self::Error> {
-        Box::pin(OcrCall::interrupt(self, failure))
-    }
-}
-
-struct PendingOperation {
-    operation: OcrHostOperation,
-    result: oneshot::Sender<OcrHostResult>,
-}
-
-struct OcrExecution {
-    client: Option<OcrClient>,
-    request: Option<LiteLLMOcrRequest<OcrDocumentInput>>,
-    operations_tx: mpsc::UnboundedSender<PendingOperation>,
-    operations_rx: mpsc::UnboundedReceiver<PendingOperation>,
-    pending_result: Option<oneshot::Sender<OcrHostResult>>,
-    execution: Option<tokio::task::JoinHandle<Result<LiteLLMOcrResponse, Error>>>,
-    blocking_preparation: Arc<BlockingPreparation>,
-    completed: bool,
-    azure_ad_token_provider: bool,
-    terminal: Arc<std::sync::Mutex<Option<(CallLifecycleContext, CallLifecycleTiming)>>>,
-}
-
-impl OcrExecution {
-    fn new(client: OcrClient) -> Self {
-        let (operations_tx, operations_rx) = mpsc::unbounded_channel();
-        Self {
-            client: Some(client),
-            request: None,
-            operations_tx,
-            operations_rx,
-            pending_result: None,
-            execution: None,
-            blocking_preparation: Arc::new(BlockingPreparation::default()),
-            completed: false,
-            azure_ad_token_provider: false,
-            terminal: Arc::default(),
-        }
-    }
-
-    pub async fn resume(&mut self, result: Option<OcrHostResult>) -> Result<OcrCallStep, Error> {
-        if self.completed {
-            return Err(Error::InvalidRequest(
-                "OCR call cannot be resumed after completion".into(),
-            ));
-        }
-        match (self.pending_result.take(), result) {
-            (Some(sender), Some(result)) => sender
-                .send(result)
-                .map_err(|_| Error::InvalidRequest("OCR host operation was abandoned".into()))?,
-            (None, None) if self.execution.is_none() => self.start(),
-            (Some(sender), None) => {
-                self.pending_result = Some(sender);
-                return Err(Error::InvalidRequest(
-                    "OCR host operation result is required".into(),
-                ));
-            }
-            (None, Some(_)) => {
-                return Err(Error::InvalidRequest(
-                    "unexpected OCR host operation result".into(),
-                ));
-            }
-            (None, None) => {}
-        }
-
-        let execution = self.execution.as_mut().ok_or_else(|| {
-            Error::InvalidRequest("OCR call cannot be resumed after completion".into())
-        })?;
-        tokio::select! {
-            operation = self.operations_rx.recv() => {
-                let operation = operation.ok_or_else(|| Error::InvalidRequest("OCR operation channel closed".into()))?;
-                self.pending_result = Some(operation.result);
-                Ok(OcrCallStep::Host(operation.operation))
-            }
-            result = execution => {
-                self.execution = None;
-                self.completed = true;
-                result
-                    .map_err(|error| Error::Transport(crate::transport::Error::Network(format!("OCR execution task failed: {error}"))))?
-                    .map(OcrCallStep::Complete)
-            }
-        }
-    }
-
-    fn start(&mut self) {
-        let client = self.client.take().expect("admitted OCR call has a client");
-        let mut request = self
-            .request
-            .take()
-            .expect("admitted OCR call has a request");
-        let intercepts_requests = request.hooks.intercepts_requests();
-        if self.azure_ad_token_provider {
-            request.azure_ad_token_provider = Some(TokenProviderHandle::new(Arc::new(
-                OcrAzureAdTokenProvider {
-                    operations: self.operations_tx.clone(),
-                },
-            )));
-        }
-        let hooks = Arc::new(ProtocolHooks {
-            operations: self.operations_tx.clone(),
-            intercepts_requests,
-            terminal: self.terminal.clone(),
-        });
-        request.hooks = hooks.clone();
-        let blocking_preparation = self.blocking_preparation.clone();
-        self.execution = Some(tokio::spawn(async move {
-            let request = prepare_request_document(request, &hooks, blocking_preparation).await?;
-            perform_ocr_request(&client, request).await
-        }));
-    }
-
-    fn cancel(&mut self) {
-        self.pending_result = None;
-        if let Some(execution) = &self.execution {
-            execution.abort();
-        }
-    }
-
-    async fn stop(&mut self) {
-        self.cancel();
-        if let Some(execution) = self.execution.as_mut() {
-            let _ = execution.await;
-        }
-        self.blocking_preparation.wait().await;
-        self.execution = None;
-    }
-}
-
-#[derive(Default)]
-struct BlockingPreparation {
-    running: AtomicBool,
-    finished: Notify,
-}
-
-impl BlockingPreparation {
-    fn start(self: &Arc<Self>) -> BlockingPreparationGuard {
-        self.running.store(true, Ordering::Release);
-        BlockingPreparationGuard(self.clone())
-    }
-
-    async fn wait(&self) {
-        loop {
-            let finished = self.finished.notified();
-            if !self.running.load(Ordering::Acquire) {
-                return;
-            }
-            finished.await;
-        }
-    }
-}
-
-struct BlockingPreparationGuard(Arc<BlockingPreparation>);
-
-impl Drop for BlockingPreparationGuard {
-    fn drop(&mut self) {
-        self.0.running.store(false, Ordering::Release);
-        self.0.finished.notify_waiters();
-    }
-}
-
-async fn prepare_request_document(
-    request: LiteLLMOcrRequest<OcrDocumentInput>,
-    hooks: &ProtocolHooks,
-    blocking_preparation: Arc<BlockingPreparation>,
-) -> Result<super::types::ResolvedOcrRequest, Error> {
-    let request = match &request.document {
-        OcrDocumentInput::HostReader { mime_type } => {
-            let mime_type = mime_type.clone();
-            let content = match hooks.invoke(OcrHostOperation::ReadDocument).await? {
-                OcrHostResult::Document(result) => result?,
-                _ => {
-                    return Err(Error::InvalidRequest(
-                        "invalid OCR document read host result".into(),
-                    ));
-                }
-            };
-            request.with_document(OcrDocumentInput::Bytes {
-                bytes: content.bytes,
-                file_name: content.file_name,
-                mime_type,
-            })
-        }
-        _ => request,
-    };
-    if let OcrDocumentInput::Document(_) = &request.document {
-        return request.map_document(super::document::prepare_document);
-    }
-    let guard = blocking_preparation.start();
-    tokio::task::spawn_blocking(move || {
-        let _guard = guard;
-        request.map_document(super::document::prepare_document)
-    })
-    .await
-    .map_err(|error| {
-        Error::InvalidRequest(format!("OCR document preparation task failed: {error}"))
-    })?
-}
-
-impl Drop for OcrExecution {
-    fn drop(&mut self) {
-        if let Some(execution) = &self.execution {
-            execution.abort();
-        }
-    }
-}
-
-struct ProtocolHooks {
-    operations: mpsc::UnboundedSender<PendingOperation>,
-    intercepts_requests: bool,
-    terminal: Arc<std::sync::Mutex<Option<(CallLifecycleContext, CallLifecycleTiming)>>>,
-}
-
-#[derive(Debug)]
-struct OcrAzureAdTokenProvider {
-    operations: mpsc::UnboundedSender<PendingOperation>,
-}
-
-impl TokenProvider for OcrAzureAdTokenProvider {
-    fn acquire(&self) -> TokenFuture<'_> {
-        Box::pin(async move {
-            let (result, receiver) = oneshot::channel();
-            self.operations
-                .send(PendingOperation {
-                    operation: OcrHostOperation::AcquireAzureAdToken,
-                    result,
-                })
-                .map_err(|_| {
-                    AuthError::AzureTokenAcquisition("OCR host driver was abandoned".into())
-                })?;
-            match receiver.await.map_err(|_| {
-                AuthError::AzureTokenAcquisition(
-                    "OCR token provider operation was abandoned".into(),
-                )
-            })? {
-                OcrHostResult::AzureAdToken(result) => result,
-                _ => Err(AuthError::AzureTokenAcquisition(
-                    "invalid OCR token provider host result".into(),
-                )),
-            }
-        })
-    }
-}
-
-impl ProtocolHooks {
-    async fn invoke(&self, operation: OcrHostOperation) -> Result<OcrHostResult, Error> {
-        let (result, receiver) = oneshot::channel();
-        self.operations
-            .send(PendingOperation { operation, result })
-            .map_err(|_| Error::InvalidRequest("OCR host driver was abandoned".into()))?;
-        receiver
-            .await
-            .map_err(|_| Error::InvalidRequest("OCR host operation was abandoned".into()))
-    }
-}
-
-impl OcrHooks for ProtocolHooks {
-    fn intercepts_requests(&self) -> bool {
-        self.intercepts_requests
-    }
-
-    fn pre_call(&self, request: OcrPreCallRequest) -> OcrHookFuture<'_, OcrPreCallRequest> {
-        Box::pin(async move {
-            match self.invoke(OcrHostOperation::PreCall(request)).await? {
-                OcrHostResult::PreCall(result) => result,
-                _ => Err(Error::InvalidRequest(
-                    "invalid OCR pre-call host result".into(),
-                )),
-            }
-        })
-    }
-
-    fn during_call(
-        &self,
-        request: OcrDuringCallRequest,
-    ) -> OcrHookFuture<'_, OcrDuringCallRequest> {
-        Box::pin(async move {
-            match self.invoke(OcrHostOperation::DuringCall(request)).await? {
-                OcrHostResult::DuringCall(result) => result,
-                _ => Err(Error::InvalidRequest(
-                    "invalid OCR during-call host result".into(),
-                )),
-            }
-        })
-    }
-
-    fn post_call(&self, request: OcrPostCallRequest) -> OcrHookFuture<'_, OcrPostCallRequest> {
-        Box::pin(async move {
-            match self.invoke(OcrHostOperation::PostCall(request)).await? {
-                OcrHostResult::PostCall(result) => result,
-                _ => Err(Error::InvalidRequest(
-                    "invalid OCR post-call host result".into(),
-                )),
-            }
-        })
-    }
-
-    fn success<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        _response: &'a LiteLLMOcrResponse,
-        timing: &'a CallLifecycleTiming,
-    ) -> OcrLogFuture<'a> {
-        Box::pin(async move {
-            *self
-                .terminal
-                .lock()
-                .unwrap_or_else(|error| error.into_inner()) =
-                Some((context.clone(), timing.clone()));
-        })
-    }
-
-    fn failure<'a>(
-        &'a self,
-        context: &'a CallLifecycleContext,
-        _error: &'a Error,
-        timing: &'a CallLifecycleTiming,
-    ) -> OcrLogFuture<'a> {
-        Box::pin(async move {
-            *self
-                .terminal
-                .lock()
-                .unwrap_or_else(|error| error.into_inner()) =
-                Some((context.clone(), timing.clone()));
-        })
-    }
-}
-
-pub type OcrHostFuture<'a> = Pin<Box<dyn Future<Output = OcrHostResult> + Send + 'a>>;
-
-pub trait OcrHost: Send + Sync {
-    fn invoke(&self, operation: OcrHostOperation) -> OcrHostFuture<'_>;
-}
-
-pub struct NoopOcrHost;
-
-impl OcrHost for NoopOcrHost {
-    fn invoke(&self, operation: OcrHostOperation) -> OcrHostFuture<'_> {
-        Box::pin(async move {
-            match operation {
-                OcrHostOperation::ProjectRequest => OcrHostResult::Request(Err(
-                    Error::InvalidRequest("OCR host has no request projection".into()),
-                )),
-                OcrHostOperation::ReadDocument => OcrHostResult::Document(Err(
-                    Error::InvalidRequest("OCR host has no document reader".into()),
-                )),
-                OcrHostOperation::Lifecycle(_)
-                | OcrHostOperation::ConstructResponse(_)
-                | OcrHostOperation::MapFailure(_)
-                | OcrHostOperation::Success { .. }
-                | OcrHostOperation::Failure { .. } => OcrHostResult::Lifecycle(Ok(())),
-                OcrHostOperation::AcquireAzureAdToken => {
-                    OcrHostResult::AzureAdToken(Err(AuthError::AzureTokenAcquisition(
-                        "OCR host has no Azure AD token provider".into(),
-                    )))
-                }
-                OcrHostOperation::PreCall(request) => OcrHostResult::PreCall(Ok(request)),
-                OcrHostOperation::DuringCall(request) => OcrHostResult::DuringCall(Ok(request)),
-                OcrHostOperation::PostCall(request) => OcrHostResult::PostCall(Ok(request)),
-            }
-        })
-    }
-}
-
-pub struct OcrHookHost {
-    hooks: Arc<dyn OcrHooks>,
-}
-
-impl OcrHookHost {
-    pub fn new(hooks: Arc<dyn OcrHooks>) -> Self {
-        Self { hooks }
-    }
-}
-
-impl OcrHost for OcrHookHost {
-    fn invoke(&self, operation: OcrHostOperation) -> OcrHostFuture<'_> {
-        Box::pin(async move {
-            match operation {
-                OcrHostOperation::ProjectRequest => OcrHostResult::Request(Err(
-                    Error::InvalidRequest("OCR hook host has no request projection".into()),
-                )),
-                OcrHostOperation::ReadDocument => OcrHostResult::Document(Err(
-                    Error::InvalidRequest("OCR hook host has no document reader".into()),
-                )),
-                OcrHostOperation::Success {
-                    context,
-                    response,
-                    timing,
-                } => {
-                    self.hooks.success(&context, &response, &timing).await;
-                    OcrHostResult::Lifecycle(Ok(()))
-                }
-                OcrHostOperation::Failure {
-                    context,
-                    error,
-                    timing,
-                } => {
-                    self.hooks.failure(&context, &error, &timing).await;
-                    OcrHostResult::Lifecycle(Ok(()))
-                }
-                OcrHostOperation::Lifecycle(_)
-                | OcrHostOperation::ConstructResponse(_)
-                | OcrHostOperation::MapFailure(_) => OcrHostResult::Lifecycle(Ok(())),
-                OcrHostOperation::AcquireAzureAdToken => {
-                    OcrHostResult::AzureAdToken(Err(AuthError::AzureTokenAcquisition(
-                        "OCR hook host has no Azure AD token provider".into(),
-                    )))
-                }
-                OcrHostOperation::PreCall(request) => {
-                    OcrHostResult::PreCall(self.hooks.pre_call(request).await)
-                }
-                OcrHostOperation::DuringCall(request) => {
-                    OcrHostResult::DuringCall(self.hooks.during_call(request).await)
-                }
-                OcrHostOperation::PostCall(request) => {
-                    OcrHostResult::PostCall(self.hooks.post_call(request).await)
-                }
-            }
-        })
-    }
-}

litellm-rust/crates/core/src/ocr/mod.rs

@@ -1,33 +1,13 @@
-mod arguments;
+pub mod arguments;
 pub mod client;
-pub(crate) mod document;
-pub mod error;
-pub use error::Error;
+pub mod document;
 pub(crate) mod handler;
-pub mod hooks;
-pub(crate) mod json;
-mod lifecycle;
 pub(crate) mod prepare;
-mod provider_config;
+pub mod provider_config;
+pub mod route;
 pub mod types;
 pub mod wire;
 
-pub use arguments::{
-    consumed_optional_param_names, consumed_optional_params, is_supported_request,
-};
-pub use client::{OcrClient, ocr};
-pub use document::{encode_file_document, mime_type_for_name, read_path_document};
-pub use lifecycle::{
-    NativeOutcome, NativeResult, NoopOcrHost, OcrAdmission, OcrCall, OcrCallStep, OcrDecline,
-    OcrHookHost, OcrHost, OcrHostOperation, OcrHostResult,
-};
-pub use provider_config::{get_api_key_env_var, get_health_check_document};
-pub use types::{
-    LiteLLMOcrRequest, LiteLLMOcrResponse, OcrConnection, OcrConnectionInputs, OcrCredentialInputs,
-    OcrDocument, OcrDocumentInput, OcrFileContent, OcrPage, OcrPageDimensions, OcrPageImage,
-    OcrTransportConfig, OcrUsageInfo,
-};
-
 #[cfg(test)]
 #[path = "../../tests/azure_ai_ocr.rs"]
 mod azure_ai_tests;
@@ -35,9 +15,15 @@ mod azure_ai_tests;
 #[path = "../../tests/azure_document_intelligence_ocr.rs"]
 mod azure_document_intelligence_tests;
 #[cfg(test)]
+#[path = "../../tests/cohere_ocr.rs"]
+mod cohere_tests;
+#[cfg(test)]
 #[path = "../../tests/deepseek_ocr.rs"]
 mod deepseek_tests;
 #[cfg(test)]
+#[path = "../../tests/ocr/passthrough.rs"]
+mod passthrough_tests;
+#[cfg(test)]
 #[path = "../../tests/reducto_ocr.rs"]
 mod reducto_tests;
 #[cfg(test)]