refactor(rust): move RouteMachine out of core into litellm-host next to the Machine trait

core/src/machine was route-neutral runtime code sitting among route surfaces, and the workspace had two modules named machine. It now lives in litellm-host beside the contract it implements, so core only holds routes. The OCR conversion from MachineFault moves to litellm-llms because the orphan rule no longer allows it in core

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

@@ -2,7 +2,6 @@ pub mod audio_transcription;
 pub mod chat_completions;
 pub mod constants;
 pub mod error;
-pub mod machine;
 pub mod messages;
 pub mod ocr;
 pub mod responses;

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

@@ -6,6 +6,7 @@ use litellm_core_utils::get_llm_provider_logic::get_custom_llm_provider;
 use litellm_host::{
     event::{MachineEvent, RawResponse, RequestContext, WireRequest},
     host::{Demand, Host},
+    machine::{HostChannel, MachineFault, RouteMachine},
     route::Route,
 };
 use litellm_types::llms::anthropic_messages::anthropic_response::AnthropicMessagesResponse;
@@ -18,10 +19,7 @@ use super::{
     prepare::prepare_provider_request,
     types::MessagesRequest,
 };
-use crate::{
-    constants::ANTHROPIC_MESSAGES_PROVIDER,
-    machine::{HostChannel, MachineFault, RouteMachine},
-};
+use crate::constants::ANTHROPIC_MESSAGES_PROVIDER;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum MessagesOp {

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

@@ -3,6 +3,7 @@ use std::sync::{Arc, Mutex};
 use litellm_auth::ResolvedCredential;
 use litellm_host::{
     event::{CallEvent, RequestContext, WireRequest},
+    machine::{HostChannel, HostTokenProvider, MachineFault, RouteMachine, TokenRoute},
     route::Route,
 };
 use litellm_llms::{
@@ -11,10 +12,7 @@ use litellm_llms::{
 };
 
 use super::handler::perform_ocr_request;
-use crate::{
-    machine::{HostChannel, HostTokenProvider, MachineFault, RouteMachine, TokenRoute},
-    ocr::types::{LiteLLMOcrRequest, OcrDocumentInput, OcrFileContent, ResolvedOcrRequest},
-};
+use crate::ocr::types::{LiteLLMOcrRequest, OcrDocumentInput, OcrFileContent, ResolvedOcrRequest};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum OcrOp {
@@ -56,16 +54,6 @@ impl TokenRoute for Ocr {
     }
 }
 
-impl From<MachineFault> for Error {
-    fn from(fault: MachineFault) -> Self {
-        Self::InvalidRequest(match fault {
-            MachineFault::Abandoned => "OCR host driver was abandoned".into(),
-            MachineFault::Protocol(message) => format!("OCR {message}"),
-            MachineFault::Mismatch => "invalid OCR host operation result".into(),
-        })
-    }
-}
-
 pub type OcrHost = HostChannel<Ocr>;
 pub type OcrMachine = RouteMachine<Ocr>;
 

litellm-rust/crates/host/Cargo.toml

@@ -8,7 +8,7 @@ repository.workspace = true
 [dependencies]
 litellm-auth.workspace = true
 serde_json.workspace = true
+tokio = { workspace = true, features = ["sync"] }
 
 [dev-dependencies]
 rstest.workspace = true
-tokio = { workspace = true, features = ["macros"] }

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

@@ -1,7 +1,7 @@
 //! 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
+//! another runtime later. Core runs each route on a [`machine::RouteMachine`] 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.
 

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

@@ -1,9 +1,8 @@
 use std::sync::Arc;
 
-use litellm_auth::{Error, ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
-use litellm_host::route::Route;
-
 use super::{HostChannel, MachineFault};
+use crate::route::Route;
+use litellm_auth::{Error, ResolvedCredential, TokenFuture, TokenProvider, TokenProviderHandle};
 
 /// A route whose host can mint credentials on the call's behalf.
 pub trait TokenRoute: Route {

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

@@ -1,6 +1,12 @@
+mod auth;
+mod route_machine;
+
 use std::future::Future;
 use std::pin::Pin;
 
+pub use auth::{HostTokenProvider, TokenRoute};
+pub use route_machine::{ExecuteFuture, HostChannel, MachineFault, RouteMachine};
+
 use crate::host::{HostOp, HostResult};
 use crate::route::Route;
 

litellm-rust/crates/host/src/machine/route_machine.rs

@@ -2,18 +2,16 @@
 //! 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_host::{
+use tokio::sync::{mpsc, oneshot};
+
+use super::{HostFailure, Interrupted, Machine, MachineStep, Step};
+use crate::{
     event::{MachineEvent, RequestContext, WireRequest},
     host::{Demand, 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)]

litellm-rust/crates/llms/src/base_llm/ocr/error.rs

@@ -102,6 +102,17 @@ pub enum Error {
     Headers(#[from] crate::custom_httpx::http_handler::HeaderError),
 }
 
+impl From<litellm_host::machine::MachineFault> for Error {
+    fn from(fault: litellm_host::machine::MachineFault) -> Self {
+        use litellm_host::machine::MachineFault;
+        Self::InvalidRequest(match fault {
+            MachineFault::Abandoned => "OCR host driver was abandoned".into(),
+            MachineFault::Protocol(message) => format!("OCR {message}"),
+            MachineFault::Mismatch => "invalid OCR host operation result".into(),
+        })
+    }
+}
+
 impl From<litellm_core_utils::call_arguments::ArgumentError> for Error {
     fn from(error: litellm_core_utils::call_arguments::ArgumentError) -> Self {
         Self::RequestField {