Struct Hanzo 

pub struct Hanzo { /* private fields */ }

The Hanzo struct handles sending requests to multiple engines. It is the core multi-threaded component of hanzo, and uses mpsc Sender and Receiver primitives to send and receive requests to the appropriate engine based on model ID.

Lock Ordering Convention

This struct uses multiple RwLocks. To prevent deadlocks, locks must be acquired in this order:

1. reloading_models
2. engines
3. unloaded_models
4. default_engine_id
5. model_aliases

Use scope-based lock management and explicit drop() calls.

Implementations

impl Hanzo

pub fn get_sender( &self, model_id: Option<&str>, ) -> Result<Sender<Request>, HanzoError>

Get sender for a specific model. If model_id is None, uses default engine. If the model is unloaded, it will be automatically reloaded before returning the sender.

pub fn find_file(&self, id: &str) -> Option<Arc<File>>

Look up a file across all loaded engines. None if missing or expired.

pub fn list_files(&self) -> Vec<Arc<File>>

Every non-expired file across all loaded engines, including session-less runs. Order unspecified.

pub fn remove_file(&self, id: &str) -> bool

Returns whether the file existed.

pub fn get_session_store( &self, model_id: Option<&str>, ) -> Result<Arc<Mutex<AgenticSessionStore>>, HanzoError>

Agentic session store for model_id (or the default model). Returns an Arc to lock for inspect/mutate.

pub fn export_session( &self, model_id: Option<&str>, session_id: &str, ) -> Result<Option<SerializedSession>, HanzoError>

Export an agentic session by ID. Bundles the session’s files (full bodies). None if missing.

pub fn import_session( &self, model_id: Option<&str>, session_id: String, session: SerializedSession, ) -> Result<(), HanzoError>

Replaces any existing session with the same ID. Restores its files into the file store.

pub fn fork_session( &self, model_id: Option<&str>, src_session_id: &str, dest_session_id: String, num_turns: usize, ) -> Result<(), HanzoError>

Clone the first num_turns complete turns from src into dest. A turn ends at the first assistant message without tool_calls. Used for branching: the new session diverges cleanly from the truncated prefix, so the branch’s later edits don’t bleed back.

pub fn delete_session( &self, model_id: Option<&str>, session_id: &str, ) -> Result<bool, HanzoError>

Delete an agentic session. Returns whether the session existed.

pub fn list_session_ids( &self, model_id: Option<&str>, ) -> Result<Vec<String>, HanzoError>

All stored session IDs. SDK-only, not exposed via HTTP.

pub fn get_id(&self) -> String

pub fn get_creation_time(&self) -> u64

pub fn register_model_alias( &self, alias: impl Into<String>, model_id: &str, ) -> Result<(), String>

Register an alternate model ID that resolves to an existing model.

pub fn model_exists(&self, model_id: &str) -> Result<bool, HanzoError>

Check if a model is known (loaded, unloaded, or reloading), resolving aliases if needed.

pub fn get_logger( &self, model_id: Option<&str>, ) -> Result<Arc<IntervalLogger>, HanzoError>

Get the interval logger for a specific model. If model_id is None, uses default engine.

pub fn get_model_category( &self, model_id: Option<&str>, ) -> Result<ModelCategory, HanzoError>

Get model category for a specific model. If model_id is None, uses default engine.

pub fn max_sequence_length( &self, model_id: Option<&str>, ) -> Result<Option<usize>, HanzoError>

Get the maximum supported sequence length for a model, if applicable.

pub fn next_request_id(&self) -> usize

pub async fn add_model( &self, model_id: String, pipeline: Arc<Mutex<dyn Pipeline>>, method: SchedulerConfig, config: AddModelConfig, ) -> Result<(), String>

Add a new model engine to the Hanzo instance

pub fn remove_model(&self, model_id: &str) -> Result<(), String>

Remove a model engine from the Hanzo instance

pub fn list_models(&self) -> Result<Vec<String>, String>

List all available model IDs

pub fn get_default_model_id(&self) -> Result<Option<String>, String>

Get the current default model ID

pub fn set_default_model_id(&self, model_id: &str) -> Result<(), String>

Set the default model ID

pub fn send_request(&self, request: Request) -> Result<(), HanzoError>

Dispatch a request to the appropriate engine based on the model_id in the request

pub fn maybe_log_request(this: Arc<Self>, repr: String)

pub fn maybe_log_response<T: Serialize>(this: Arc<Self>, resp: &T)

pub fn maybe_log_error(this: Arc<Self>, err: &dyn Error)

pub fn get_tools_count(&self, model_id: Option<&str>) -> Result<usize, String>

Get the number of tools available for a specific model (including MCP tools)

pub fn list_mcp_tools( &self, model_id: Option<&str>, ) -> Result<Vec<(String, Option<String>)>, String>

MCP-provided tools registered for model_id. Excludes built-ins (web search, code exec). Returns (name, description) per tool.

pub fn has_mcp_client(&self, model_id: Option<&str>) -> Result<bool, String>

Check if MCP client is configured for a specific model

pub fn config(&self, model_id: Option<&str>) -> Result<HanzoConfig, String>

Get config for a specific model

pub fn unload_model(&self, model_id: &str) -> Result<(), HanzoError>

Unload a model from memory while preserving its configuration for later reload. The model can be reloaded automatically when a request is sent to it, or manually using reload_model().

Note: The model must have been added with a ModelLoaderConfig for auto-reload to work. Models added via HanzoBuilder without explicit loader config cannot be reloaded.

pub async fn reload_model(&self, model_id: &str) -> Result<(), HanzoError>

Manually reload a previously unloaded model. This is also called automatically by get_sender() when a request targets an unloaded model.

pub fn reload_model_blocking(&self, model_id: &str) -> Result<(), HanzoError>

Synchronous version of reload_model for use in non-async contexts.

This method handles different runtime contexts appropriately:

• If called from a multi-threaded tokio runtime, uses block_in_place
• If called from a single-threaded runtime, returns an error (use reload_model() instead)
• If called outside any runtime, creates a temporary runtime

pub fn list_unloaded_models(&self) -> Result<Vec<String>, HanzoError>

List all unloaded model IDs

pub fn is_model_loaded(&self, model_id: &str) -> Result<bool, HanzoError>

Check if a model is currently loaded (as opposed to unloaded)

pub fn get_model_status( &self, model_id: &str, ) -> Result<Option<ModelStatus>, HanzoError>

Get the status of a model, or None if not found

pub fn list_models_with_status( &self, ) -> Result<Vec<(String, ModelStatus)>, HanzoError>

List all models with their status

Trait Implementations

impl Drop for Hanzo

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.