Struct DeepAgent

pub struct DeepAgent { /* private fields */ }

Core Deep Agent runtime implementation

This struct contains all the runtime state and behavior for a Deep Agent, including middleware management, tool execution, HITL support, and state persistence.

Implementations

impl DeepAgent

pub async fn save_state(&self, thread_id: &ThreadId) -> Result<()>

Save the current agent state to the configured checkpointer.

pub async fn load_state(&self, thread_id: &ThreadId) -> Result<bool>

Load agent state from the configured checkpointer.

pub async fn delete_thread(&self, thread_id: &ThreadId) -> Result<()>

Delete saved state for the specified thread.

pub async fn list_threads(&self) -> Result<Vec<ThreadId>>

List all threads with saved state.

pub fn current_interrupt(&self) -> Option<AgentInterrupt>

Get the current pending interrupt, if any.

pub fn add_broadcaster(&self, broadcaster: Arc<dyn EventBroadcaster>)

Add a broadcaster dynamically to the agent’s event dispatcher.

Add a single broadcaster dynamically after the agent is built.

This is useful for per-conversation or per-customer broadcasters.

Example

use std::sync::Arc;
// agent.add_broadcaster(Arc::new(MyBroadcaster::new()));

pub fn add_broadcasters(&self, broadcasters: Vec<Arc<dyn EventBroadcaster>>)

Add multiple broadcasters at once.

This is useful when you need to add several broadcasters for a conversation (e.g., WhatsApp, SSE, DynamoDB).

Example

use std::sync::Arc;
// agent.add_broadcasters(vec![
//     Arc::new(WhatsAppBroadcaster::new(phone)),
//     Arc::new(SseBroadcaster::new(channel)),
//     Arc::new(DynamoDbBroadcaster::new(table)),
// ]);

pub async fn resume_with_approval( &self, action: HitlAction, ) -> Result<AgentMessage>

Resume execution after human approval of an interrupt.

pub async fn handle_message( &self, input: impl AsRef<str>, state: Arc<AgentStateSnapshot>, ) -> Result<AgentMessage>

Handle message from string input - converts string to AgentMessage internally

pub async fn handle_message_with_metadata( &self, input: impl AsRef<str>, metadata: Option<MessageMetadata>, state: Arc<AgentStateSnapshot>, ) -> Result<AgentMessage>

Handle message from string input with metadata - converts string to AgentMessage internally

Trait Implementations

impl AgentHandle for DeepAgent

fn describe<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = AgentDescriptor> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn handle_message<'life0, 'async_trait>( &'life0 self, input: AgentMessage, _state: Arc<AgentStateSnapshot>, ) -> Pin<Box<dyn Future<Output = Result<AgentMessage>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn handle_message_stream<'life0, 'async_trait>( &'life0 self, input: AgentMessage, _state: Arc<AgentStateSnapshot>, ) -> Pin<Box<dyn Future<Output = Result<AgentStream>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle a message with streaming response Default implementation falls back to non-streaming handle_message()

fn current_interrupt<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<AgentInterrupt>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the current pending interrupt if any Returns None if no interrupts are pending

fn resume_with_approval<'life0, 'async_trait>( &'life0 self, action: HitlAction, ) -> Pin<Box<dyn Future<Output = Result<AgentMessage>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Resume execution after human approval of an interrupt