refactor(rust): rename litellm-callbacks to litellm-host and HostOpError to InvokeError

litellm-rust/Cargo.lock

@@ -2027,22 +2027,12 @@ dependencies = [
  "tokio",
 ]
 
-[[package]]
-name = "litellm-callbacks"
-version = "0.1.0"
-dependencies = [
- "litellm-auth",
- "rstest",
- "serde_json",
- "tokio",
-]
-
 [[package]]
 name = "litellm-callbacks-legacy"
 version = "0.1.0"
 dependencies = [
  "litellm-auth",
- "litellm-callbacks",
+ "litellm-host",
  "litellm-host-python",
  "proptest",
  "pyo3",
@@ -2060,8 +2050,8 @@ dependencies = [
  "futures-util",
  "litellm-auth",
  "litellm-auth-aws",
- "litellm-callbacks",
  "litellm-core-utils",
+ "litellm-host",
  "litellm-llms",
  "litellm-types",
  "mime_guess",
@@ -2114,12 +2104,22 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "litellm-host"
+version = "0.1.0"
+dependencies = [
+ "litellm-auth",
+ "rstest",
+ "serde_json",
+ "tokio",
+]
+
 [[package]]
 name = "litellm-host-python"
 version = "0.1.0"
 dependencies = [
  "futures-util",
- "litellm-callbacks",
+ "litellm-host",
  "pyo3",
  "pyo3-async-runtimes",
  "pythonize",
@@ -2143,9 +2143,9 @@ dependencies = [
  "litellm-auth-aws",
  "litellm-auth-azure",
  "litellm-auth-gcp",
- "litellm-callbacks",
  "litellm-core-utils",
  "litellm-framing",
+ "litellm-host",
  "litellm-types",
  "reqwest 0.12.28",
  "rstest",

litellm-rust/Cargo.toml

@@ -10,7 +10,7 @@ repository = "https://github.com/BerriAI/litellm"
 
 [workspace.dependencies]
 litellm-core = { path = "crates/core" }
-litellm-callbacks = { path = "crates/callbacks" }
+litellm-host = { path = "crates/host" }
 litellm-callbacks-legacy = { path = "crates/callbacks-legacy" }
 litellm-framing = { path = "crates/framer" }
 litellm-auth = { path = "crates/auth" }

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

@@ -11,7 +11,7 @@
   - Retain complete boundary arguments, opaque unknown values, aliases, omitted/default distinctions and deliberate copies; preserve the established deployment-hook kwargs view
   - Before `pre_call`, re-alias every body key whose value equals the caller's argument to the caller's own object; this crate compares the two itself, and the argument is resolved by `litellm_host_python::lookup`
   - 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 fact that crosses from the route is the prepared keyword view
+  - A later kind of callback host (WASM, in-process Rust) has none of these obligations, so they stay out of `litellm-host`, `litellm-host-python` and the bridge; the only fact that crosses from the route is the prepared keyword view
 - 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

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

@@ -7,7 +7,7 @@ repository.workspace = true
 autotests = false
 
 [dependencies]
-litellm-callbacks.workspace = true
+litellm-host.workspace = true
 litellm-host-python.workspace = true
 
 pyo3.workspace = true

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

@@ -2,7 +2,7 @@
 //! raises is answered with the same `Logging` calls, in the same order, as the Python
 //! `@client` path makes them.
 
-use litellm_callbacks::event::{
+use litellm_host::event::{
     FailureOrigin, MachineEvent, RequestContext, Timing, WireRequest, epoch_seconds,
 };
 use litellm_host_python::{

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

@@ -3,7 +3,7 @@
 //! 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::{machine::Machine, route::Route};
 use litellm_host_python::{RouteHost, lookup, run_call};
 use pyo3::{
     gc::{PyTraverseError, PyVisit},

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

@@ -2,7 +2,7 @@
 //! 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::event::{RequestContext, WireRequest};
 use litellm_host_python::to_py;
 use pyo3::{exceptions::PyBaseException, prelude::*, types::PyDict};
 

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

@@ -1,6 +1,6 @@
 use std::ffi::CStr;
 
-use litellm_callbacks::event::{FailureOrigin, Timing};
+use litellm_host::event::{FailureOrigin, Timing};
 use litellm_host_python::{LifecycleEvent, LifecycleStep, PythonLifecycle};
 use pyo3::exceptions::asyncio::CancelledError;
 use pyo3::prelude::*;

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

@@ -1,7 +1,7 @@
 use std::ffi::CStr;
 
 use litellm_auth::SecretValue;
-use litellm_callbacks::event::{MachineEvent, RawResponse, RequestContext, WireRequest};
+use litellm_host::event::{MachineEvent, RawResponse, RequestContext, WireRequest};
 use litellm_host_python::{LifecycleEvent, LifecycleStep, PythonLifecycle, to_py};
 use proptest::prelude::*;
 use pyo3::prelude::*;

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

@@ -1,6 +1,6 @@
 use std::ffi::CStr;
 
-use litellm_callbacks::event::{FailureOrigin, Timing};
+use litellm_host::event::{FailureOrigin, Timing};
 use litellm_host_python::{LifecycleEvent, LifecycleStep, PythonLifecycle};
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::exceptions::asyncio::CancelledError;

litellm-rust/crates/core/Cargo.toml

@@ -9,7 +9,7 @@ autotests = false
 [dependencies]
 litellm-types.workspace = true
 litellm-core-utils.workspace = true
-litellm-callbacks.workspace = true
+litellm-host.workspace = true
 bytes.workspace = true
 futures-util.workspace = true
 base64.workspace = true

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use litellm_auth::{Error, ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
-use litellm_callbacks::route::Route;
+use litellm_host::route::Route;
 
 use super::{HostChannel, MachineFault};
 

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

@@ -7,7 +7,7 @@ mod auth;
 use std::{future::Future, pin::Pin};
 
 pub use auth::{HostTokenProvider, TokenRoute};
-use litellm_callbacks::{
+use litellm_host::{
     event::{MachineEvent, RequestContext, WireRequest},
     host::{Demand, HostOp, HostResult},
     machine::{HostFailure, Interrupted, Machine, MachineStep, Step},

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

@@ -33,7 +33,7 @@ pub async fn messages(request: MessagesRequest<'_>) -> Result<AnthropicMessagesR
         extra_headers: request.extra_headers,
         timeout: request.timeout,
     };
-    match litellm_callbacks::run::run(messages_machine(), &LocalMessagesHost::new(call)).await? {
+    match litellm_host::run::run(messages_machine(), &LocalMessagesHost::new(call)).await? {
         MessagesOutput::Message(message) => Ok(message),
         MessagesOutput::Streamed => Err(Error::Unsupported(
             "streamed responses need a streaming host",

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

@@ -2,12 +2,12 @@ use std::{sync::Mutex, time::Duration};
 
 use bytes::Bytes;
 use litellm_auth::SecretValue;
-use litellm_callbacks::{
+use litellm_core_utils::get_llm_provider_logic::get_custom_llm_provider;
+use litellm_host::{
     event::{MachineEvent, RawResponse, RequestContext, WireRequest},
     host::{Demand, Host},
     route::Route,
 };
-use litellm_core_utils::get_llm_provider_logic::get_custom_llm_provider;
 use litellm_types::llms::anthropic_messages::anthropic_response::AnthropicMessagesResponse;
 use serde_json::{Map, Value};
 

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

@@ -12,7 +12,7 @@ pub async fn perform(
     client: &OcrClient,
     request: LiteLLMOcrRequest,
 ) -> Result<LiteLLMOcrResponse, Error> {
-    litellm_callbacks::run::run(ocr_machine(client.clone()), &LocalOcrHost::new(request)).await
+    litellm_host::run::run(ocr_machine(client.clone()), &LocalOcrHost::new(request)).await
 }
 
 pub async fn ocr(request: LiteLLMOcrRequest) -> Result<LiteLLMOcrResponse, Error> {

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

@@ -1,6 +1,6 @@
 use futures_util::future::BoxFuture;
 use litellm_auth::SecretValue;
-use litellm_callbacks::event::{MachineEvent, RawResponse, RequestContext, WireRequest};
+use litellm_host::event::{MachineEvent, RawResponse, RequestContext, WireRequest};
 use litellm_llms::{
     base_llm::ocr::{
         error::Error,

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

@@ -1,7 +1,7 @@
 use std::sync::{Arc, Mutex};
 
 use litellm_auth::ResolvedCredential;
-use litellm_callbacks::{
+use litellm_host::{
     event::{CallEvent, RequestContext, WireRequest},
     route::Route,
 };
@@ -175,7 +175,7 @@ impl LocalOcrHost {
     }
 }
 
-impl litellm_callbacks::host::Host<Ocr> for LocalOcrHost {
+impl litellm_host::host::Host<Ocr> for LocalOcrHost {
     async fn route(&self, op: OcrOp) -> Result<OcrOpResult, Error> {
         match op {
             OcrOp::ProjectRequest => self

litellm-rust/crates/core/tests/azure_document_intelligence_ocr.rs

@@ -1,4 +1,4 @@
-use litellm_callbacks::event::{CallEvent, MachineEvent};
+use litellm_host::event::{CallEvent, MachineEvent};
 use litellm_llms::base_llm::ocr::error::Error;
 use rstest::rstest;
 use serde_json::{Value, json};
@@ -466,7 +466,7 @@ async fn model_id_is_encoded_and_dot_segments_are_rejected() {
 mod transformation {
     use std::sync::{Arc, Mutex};
 
-    use litellm_callbacks::event::{CallEvent, MachineEvent};
+    use litellm_host::event::{CallEvent, MachineEvent};
     use litellm_llms::base_llm::ocr::transformation::OcrDocument;
     use serde_json::{Value, json};
 

litellm-rust/crates/core/tests/ocr.rs

@@ -1,6 +1,6 @@
 use std::sync::{Arc, Mutex};
 
-use litellm_callbacks::{
+use litellm_host::{
     event::{CallEvent, MachineEvent, WireRequest},
     host::{Host, HostOp, HostResult},
     machine::{HostFailure, Machine, MachineStep},
@@ -820,7 +820,7 @@ impl Host<crate::ocr::route::Ocr> for CallerTokenHost {
     async fn before_send(
         &self,
         wire: WireRequest,
-        _: &litellm_callbacks::event::RequestContext,
+        _: &litellm_host::event::RequestContext,
     ) -> Result<WireRequest, OcrError> {
         let is_authorization = |name: &str| name.eq_ignore_ascii_case("authorization");
         let authorization = wire
@@ -855,7 +855,7 @@ async fn the_callers_azure_token_is_acquired_before_before_send_which_can_still_
         trace: Mutex::new(Vec::new()),
     };
 
-    litellm_callbacks::run::run(ocr_machine(ocr_client()), &host)
+    litellm_host::run::run(ocr_machine(ocr_client()), &host)
         .await
         .unwrap();
     server.await.unwrap();

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

@@ -1,4 +1,4 @@
-use litellm_callbacks::event::WireRequest;
+use litellm_host::event::WireRequest;
 use litellm_llms::base_llm::ocr::error::Error;
 use rstest::rstest;
 use serde_json::{Value, json};

litellm-rust/crates/core/tests/ocr/support.rs

@@ -1,7 +1,7 @@
 use std::sync::{Arc, Mutex};
 
 use futures_util::future::BoxFuture;
-use litellm_callbacks::event::WireRequest;
+use litellm_host::event::WireRequest;
 use litellm_llms::{
     base_llm::ocr::{error::Error, transformation::LiteLLMOcrResponse},
     custom_httpx::llm_http_handler::{CallHooks, OcrClient},
@@ -45,7 +45,7 @@ pub(crate) async fn perform_ocr(request: LiteLLMOcrRequest) -> Result<LiteLLMOcr
 }
 
 pub(crate) async fn perform_ocr_with(host: LocalOcrHost) -> Result<LiteLLMOcrResponse, Error> {
-    litellm_callbacks::run::run(ocr_machine(ocr_client()), &host).await
+    litellm_host::run::run(ocr_machine(ocr_client()), &host).await
 }
 
 pub(crate) fn wire_request(model: &str, base: &str, options: Value) -> LiteLLMOcrRequest {

litellm-rust/crates/core/tests/reducto_ocr.rs

@@ -1,4 +1,4 @@
-use litellm_callbacks::event::{CallEvent, MachineEvent, WireRequest};
+use litellm_host::event::{CallEvent, MachineEvent, WireRequest};
 use litellm_llms::base_llm::ocr::{error::Error, transformation::OcrDocument};
 use rstest::rstest;
 use serde_json::{Value, json};
@@ -351,7 +351,7 @@ async fn guardrail_rewrites_document_before_upload() {
 }
 
 mod transformation {
-    use litellm_callbacks::event::{CallEvent, MachineEvent, WireRequest};
+    use litellm_host::event::{CallEvent, MachineEvent, WireRequest};
     use litellm_llms::{
         base_llm::ocr::transformation::{BaseOcrConfig, OcrConnection, OcrRequestContext},
         reducto::ocr::transformation::*,

litellm-rust/crates/host-python/AGENTS.md

@@ -1,9 +1,9 @@
 - Target invariants; implementation and runtime validation may lag these rules
 - Keep this crate the CPython runtime adapter and nothing more: Serde marshalling, interpreter detachment, tokio/asyncio glue, the `Execution` handle, the call driver and the `PythonLifecycle`/`RouteHost` traits
-  - No LiteLLM domain dependencies beyond `litellm-callbacks`: no route types, no `Logging` policy, no public API registration, no cdylib build features
+  - No LiteLLM domain dependencies beyond `litellm-host`: no route types, no `Logging` policy, no public API registration, no cdylib build features
   - The driver emits `Succeeded` or `Failed` exactly once and never dispatches after a cancellation; which Python objects consume those events is the adapter's business
   - `RouteHost::invoke` receives the keyword view the adapter's `begin` returned, not the caller's dict; a route host that projects from it inherits that adapter's rewrites (for the legacy adapter: setup, deployment hooks, credential inheritance)
-  - A native failure, including one a host op returns as `HostOpError::Native`, is classified exactly once through the route's `classify`; a Python exception raised inside the call, and a failure in `begin` or `after_success`, is raised as is
+  - A native failure, including one a host op returns as `InvokeError::Native`, is classified exactly once through the route's `classify`; a Python exception raised inside the call, and a failure in `begin` or `after_success`, is raised as is
   - A failing `classify` is raised with the native error's text as its `__context__`, never swallowed
 - Use standard PyO3 ownership and conversion APIs
   - Prefer `Bound<'py, T>` for attached operations/results, `Py<T>` for retention; binding/unbinding does not copy payloads

litellm-rust/crates/host-python/Cargo.toml

@@ -7,7 +7,7 @@ repository.workspace = true
 
 [dependencies]
 futures-util.workspace = true
-litellm-callbacks.workspace = true
+litellm-host.workspace = true
 pyo3.workspace = true
 pyo3-async-runtimes.workspace = true
 pythonize.workspace = true

litellm-rust/crates/host-python/src/adapter.rs

@@ -1,5 +1,5 @@
-use litellm_callbacks::event::{FailureOrigin, MachineEvent, RequestContext, Timing, WireRequest};
-use litellm_callbacks::route::Route;
+use litellm_host::event::{FailureOrigin, MachineEvent, RequestContext, Timing, WireRequest};
+use litellm_host::route::Route;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::gc::{PyTraverseError, PyVisit};
 use pyo3::prelude::*;
@@ -89,12 +89,12 @@ pub trait PythonLifecycle: Send + Sync {
 /// rejected it, which the route classifies like any other native failure, or Python code
 /// raised, which reaches the caller as it was raised.
 #[derive(Debug)]
-pub enum HostOpError<E> {
+pub enum InvokeError<E> {
     Native(E),
     Python(PyErr),
 }
 
-impl<E> From<PyErr> for HostOpError<E> {
+impl<E> From<PyErr> for InvokeError<E> {
     fn from(error: PyErr) -> Self {
         Self::Python(error)
     }
@@ -117,7 +117,7 @@ pub trait RouteHost: Send + Sync {
         py: Python<'_>,
         arguments: &Bound<'_, PyDict>,
         op: <Self::Route as Route>::Op,
-    ) -> Result<<Self::Route as Route>::OpResult, HostOpError<<Self::Route as Route>::Error>>;
+    ) -> Result<<Self::Route as Route>::OpResult, InvokeError<<Self::Route as Route>::Error>>;
 
     fn complete(
         &mut self,

litellm-rust/crates/host-python/src/driver.rs

@@ -2,10 +2,10 @@ use std::sync::Arc;
 use std::task::Poll;
 
 use futures_util::future::{AbortHandle, Abortable};
-use litellm_callbacks::event::{FailureOrigin, Timing, epoch_seconds};
-use litellm_callbacks::host::{Demand, HostOp, HostResult, HostStep};
-use litellm_callbacks::machine::{HostFailure, Machine, MachineStep};
-use litellm_callbacks::route::Route;
+use litellm_host::event::{FailureOrigin, Timing, epoch_seconds};
+use litellm_host::host::{Demand, HostOp, HostResult, HostStep};
+use litellm_host::machine::{HostFailure, Machine, MachineStep};
+use litellm_host::route::Route;
 use pyo3::exceptions::{PyBaseException, PyException, PyRuntimeError};
 use pyo3::gc::{PyTraverseError, PyVisit};
 use pyo3::prelude::*;
@@ -13,7 +13,7 @@ use pyo3::types::PyDict;
 use tokio::sync::Mutex;
 
 use crate::adapter::{
-    HostOpError, LifecycleEvent, LifecycleStep, PythonLifecycle, RouteHost, missing_state,
+    InvokeError, LifecycleEvent, LifecycleStep, PythonLifecycle, RouteHost, missing_state,
 };
 use crate::execution::{poll_async_value, run_async_value, run_sync_value};
 use crate::handle::{Execution, ExecutionBody, ExecutionStep};
@@ -282,12 +282,12 @@ where
                 let arguments = self.arguments.as_ref().ok_or_else(missing_state)?;
                 match self.route.invoke(py, arguments.bind(py), op) {
                     Ok(result) => Ok(HostResult::Route(result)),
-                    Err(HostOpError::Native(error)) => {
+                    Err(InvokeError::Native(error)) => {
                         return self
                             .resume_core(py, Some(Err(HostFailure::Error(error))))
                             .map(Next::Continue);
                     }
-                    Err(HostOpError::Python(error)) => Err(error),
+                    Err(InvokeError::Python(error)) => Err(error),
                 }
             }
             HostOp::BeforeSend { wire, context } => {
@@ -534,8 +534,8 @@ where
 mod tests {
     use std::sync::{Arc, Mutex};
 
-    use litellm_callbacks::event::{MachineEvent, RequestContext, WireRequest};
-    use litellm_callbacks::machine::{Interrupted, Step};
+    use litellm_host::event::{MachineEvent, RequestContext, WireRequest};
+    use litellm_host::machine::{Interrupted, Step};
     use pyo3::exceptions::{PyBaseException, PyValueError};
     use pyo3::types::PyDict;
 
@@ -692,12 +692,12 @@ sys.modules.setdefault('litellm.rust_bridge', types.ModuleType('litellm.rust_bri
             _: Python<'_>,
             arguments: &Bound<'_, PyDict>,
             op: &'static str,
-        ) -> Result<String, HostOpError<Error>> {
+        ) -> Result<String, InvokeError<Error>> {
             self.log.push(format!("route:{op}"));
             match self.op {
                 OpScript::Answer => Ok(format!("{op}:{}", arguments.len())),
                 OpScript::RaisePython => Err(PyValueError::new_err("op failed").into()),
-                OpScript::RejectNatively => Err(HostOpError::Native(Error("op rejected".into()))),
+                OpScript::RejectNatively => Err(InvokeError::Native(Error("op rejected".into()))),
             }
         }
 
@@ -899,7 +899,7 @@ sys.modules.setdefault('litellm.rust_bridge', types.ModuleType('litellm.rust_bri
                     context: Box::new(context()),
                 },
                 HostOp::Emit(MachineEvent::ResponseReceived {
-                    raw: litellm_callbacks::event::RawResponse { body: "raw".into() },
+                    raw: litellm_host::event::RawResponse { body: "raw".into() },
                 }),
             ],
             outcome: Some(Ok("done".into())),
@@ -1189,7 +1189,7 @@ sys.modules.setdefault('litellm.rust_bridge', types.ModuleType('litellm.rust_bri
                     py: Python<'_>,
                     _: &Bound<'_, PyDict>,
                     _: &'static str,
-                ) -> Result<String, HostOpError<Error>> {
+                ) -> Result<String, InvokeError<Error>> {
                     self.0.push("route");
                     Err(PyErr::from_value(
                         py.import("asyncio")

litellm-rust/crates/host-python/src/lib.rs

@@ -1,5 +1,5 @@
 //! The CPython runtime adapter: value marshalling, interpreter detachment, the tokio and
-//! asyncio glue, and the driver that runs a native [`Machine`](litellm_callbacks::machine::Machine)
+//! asyncio glue, and the driver that runs a native [`Machine`](litellm_host::machine::Machine)
 //! against a Python route host and a Python lifecycle. Everything here is Python-specific by
 //! construction; another host language gets its own crate of the same shape.
 
@@ -13,7 +13,7 @@ mod handle;
 mod marshal;
 
 pub use adapter::{
-    HostOpError, LifecycleEvent, LifecycleStep, PythonLifecycle, RouteHost, missing_state,
+    InvokeError, LifecycleEvent, LifecycleStep, PythonLifecycle, RouteHost, missing_state,
 };
 pub use argument::lookup;
 pub use callable::wrap_failure;

litellm-rust/crates/host/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "litellm-callbacks"
+name = "litellm-host"
 version = "0.1.0"
 edition.workspace = true
 license.workspace = true

litellm-rust/crates/llms/Cargo.toml

@@ -15,7 +15,7 @@ litellm-auth.workspace = true
 litellm-auth-aws.workspace = true
 litellm-auth-azure.workspace = true
 litellm-auth-gcp.workspace = true
-litellm-callbacks.workspace = true
+litellm-host.workspace = true
 litellm-framing.workspace = true
 base64.workspace = true
 bytes.workspace = true

litellm-rust/crates/llms/src/custom_httpx/llm_http_handler.rs

@@ -3,7 +3,7 @@ use std::{sync::OnceLock, time::Duration};
 use bytes::{Bytes, BytesMut};
 use futures_util::future::BoxFuture;
 use litellm_auth_gcp::VertexAuth;
-use litellm_callbacks::event::WireRequest;
+use litellm_host::event::WireRequest;
 use serde::{Serialize, de::DeserializeOwned};
 use serde_json::Value;
 

litellm-rust/crates/python-bridge/src/routes/messages/host.rs

@@ -3,7 +3,7 @@ use litellm_core::messages::{
     Error,
     route::{Messages, MessagesCall, MessagesOp, MessagesOpResult, MessagesOutput},
 };
-use litellm_host_python::{HostOpError, RouteHost, from_py, lookup, to_py};
+use litellm_host_python::{InvokeError, RouteHost, from_py, lookup, to_py};
 use litellm_llms::custom_httpx::transport::Error as TransportError;
 use pyo3::{
     exceptions::{PyException, PyValueError},
@@ -136,12 +136,12 @@ impl RouteHost for MessagesRouteHost {
         py: Python<'_>,
         arguments: &Bound<'_, PyDict>,
         op: MessagesOp,
-    ) -> Result<MessagesOpResult, HostOpError<Error>> {
+    ) -> Result<MessagesOpResult, InvokeError<Error>> {
         match op {
             MessagesOp::ProjectRequest => self
                 .project(py, arguments)
                 .map(|call| MessagesOpResult::Request(Box::new(call)))
-                .map_err(|error| HostOpError::Python(self.map_failure(py, error))),
+                .map_err(|error| InvokeError::Python(self.map_failure(py, error))),
         }
     }
 

litellm-rust/crates/python-bridge/src/routes/ocr/host.rs

@@ -1,6 +1,6 @@
 use litellm_auth::ResolvedCredential;
 use litellm_core::ocr::route::{Ocr, OcrOp, OcrOpResult};
-use litellm_host_python::{HostOpError, RouteHost, missing_state, to_py};
+use litellm_host_python::{InvokeError, RouteHost, missing_state, to_py};
 use litellm_llms::base_llm::ocr::{error::Error, transformation::LiteLLMOcrResponse};
 use pyo3::{
     exceptions::{PyBaseException, PyException},
@@ -113,9 +113,9 @@ impl RouteHost for OcrRouteHost {
         py: Python<'_>,
         arguments: &Bound<'_, PyDict>,
         op: OcrOp,
-    ) -> Result<OcrOpResult, HostOpError<Error>> {
+    ) -> Result<OcrOpResult, InvokeError<Error>> {
         self.answer(py, arguments, op)
-            .map_err(|error| HostOpError::Python(self.map_failure(py, error)))
+            .map_err(|error| InvokeError::Python(self.map_failure(py, error)))
     }
 
     fn complete(&mut self, py: Python<'_>, response: LiteLLMOcrResponse) -> PyResult<Py<PyAny>> {