Struct ConfigurableAgentBuilder 

pub struct ConfigurableAgentBuilder { /* private fields */ }

Builder API to assemble a DeepAgent in a single fluent flow, mirroring the Python create_configurable_agent experience. Prefer this for ergonomic construction.

Implementations

impl ConfigurableAgentBuilder

pub fn new(instructions: impl Into<String>) -> Self

pub fn with_model(self, model: Arc<dyn LanguageModel>) -> Self

Set the language model for the agent (mirrors Python’s model parameter)

pub fn with_planner(self, planner: Arc<dyn PlannerHandle>) -> Self

Low-level planner API (for advanced use cases)

pub fn with_tool(self, tool: ToolBox) -> Self

Add a tool to the agent

pub fn with_tools<I>(self, tools: I) -> Self

where I: IntoIterator<Item = ToolBox>,

Add multiple tools

pub fn with_subagent_config<I>(self, cfgs: I) -> Self

where I: IntoIterator<Item = SubAgentConfig>,

pub fn with_subagent_tools<I>(self, tools: I) -> Self

where I: IntoIterator<Item = ToolBox>,

Convenience method: automatically create subagents from a list of tools. Each tool becomes a specialized subagent with that single tool.

pub fn with_summarization(self, config: SummarizationConfig) -> Self

pub fn with_tool_interrupt( self, tool_name: impl Into<String>, policy: HitlPolicy, ) -> Self

pub fn with_builtin_tools<I, S>(self, names: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

pub fn with_auto_general_purpose(self, enabled: bool) -> Self

pub fn with_prompt_caching(self, enabled: bool) -> Self

pub fn with_checkpointer(self, checkpointer: Arc<dyn Checkpointer>) -> Self

pub fn with_event_broadcaster( self, broadcaster: Arc<dyn EventBroadcaster>, ) -> Self

Add a single event broadcaster to the agent

Example:

builder.with_event_broadcaster(console_broadcaster)

pub fn with_event_broadcasters( self, broadcasters: Vec<Arc<dyn EventBroadcaster>>, ) -> Self

Add multiple event broadcasters at once (cleaner API)

Example:

builder.with_event_broadcasters(vec![
    console_broadcaster,
    whatsapp_broadcaster,
    dynamodb_broadcaster,
])

pub fn with_event_dispatcher(self, dispatcher: Arc<EventDispatcher>) -> Self

Set the event dispatcher directly (replaces any existing dispatcher)

pub fn with_pii_sanitization(self, enabled: bool) -> Self

Enable or disable PII sanitization in event data.

Enabled by default for security.

When enabled (default):

• Message previews are truncated to 100 characters
• Sensitive fields (passwords, tokens, api_keys, etc.) are redacted
• PII patterns (emails, phones, credit cards) are removed

Disable only if you need raw data and have other security measures in place.

Example

// Keep default (enabled)
let agent = DeepAgentBuilder::new("instructions")
    .with_model(model)
    .build()?;

// Explicitly disable (not recommended for production)
let agent = DeepAgentBuilder::new("instructions")
    .with_model(model)
    .with_pii_sanitization(false)
    .build()?;

pub fn with_token_tracking(self, enabled: bool) -> Self

Enable token tracking for monitoring LLM usage and costs.

This enables tracking of token usage, costs, and performance metrics across all LLM requests made by the agent.

Example

// Enable token tracking with default settings
let agent = ConfigurableAgentBuilder::new("instructions")
    .with_model(model)
    .with_token_tracking(true)
    .build()?;

// Enable with custom configuration
let config = TokenTrackingConfig {
    enabled: true,
    emit_events: true,
    log_usage: true,
    custom_costs: Some(TokenCosts::openai_gpt4o_mini()),
};
let agent = ConfigurableAgentBuilder::new("instructions")
    .with_model(model)
    .with_token_tracking_config(config)
    .build()?;

pub fn with_token_tracking_config(self, config: TokenTrackingConfig) -> Self

Configure token tracking with custom settings.

This allows fine-grained control over token tracking behavior, including custom cost models and event emission settings.

Example

let config = TokenTrackingConfig {
    enabled: true,
    emit_events: true,
    log_usage: false, // Don't log to console
    custom_costs: Some(TokenCosts::openai_gpt4o_mini()),
};
let agent = ConfigurableAgentBuilder::new("instructions")
    .with_model(model)
    .with_token_tracking_config(config)
    .build()?;

pub fn with_max_iterations(self, max_iterations: usize) -> Self

Set the maximum number of ReAct loop iterations before stopping.

The agent uses a ReAct loop (Reasoning and Acting) to iteratively process user requests, calling tools and reasoning about the results. This setting controls how many iterations the agent can perform before it stops.

Note: max_iterations must be greater than 0. Passing 0 will result in a panic.

Default

Defaults to 10 iterations if not specified.

Panics

Panics if max_iterations is 0.

Example

let agent = ConfigurableAgentBuilder::new("instructions")
    .with_model(model)
    .with_max_iterations(30)
    .build()?;

pub fn build(self) -> Result<DeepAgent>

pub fn build_async(self) -> Result<DeepAgent>

Build an agent using the async constructor alias. This mirrors the Python async_create_deep_agent entry point, while reusing the same runtime internals.