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 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.