Struct AgentRuntime 

pub struct AgentRuntime<H, S> { /* private fields */ }

Agent runtime that manages the server lifecycle

Implementations

impl<H, S> AgentRuntime<H, S>

where H: AsyncMessageHandler + Clone + Send + Sync + 'static, S: AsyncTaskManager + AsyncNotificationManager + Clone + Send + Sync + 'static,

pub fn new(config: AgentConfig, handler: Arc<H>, storage: Arc<S>) -> Self

Create a new runtime

pub async fn start_http(&self) -> Result<(), RuntimeError>

Start HTTP server

pub async fn start_websocket(&self) -> Result<(), RuntimeError>

where S: AsyncStreamingHandler,

Start WebSocket server

pub async fn start_all(&self) -> Result<(), RuntimeError>

where S: AsyncStreamingHandler,

Start both HTTP and WebSocket servers

pub async fn run(self) -> Result<(), RuntimeError>

where S: AsyncStreamingHandler,

Start the appropriate server(s) based on configuration

Examples found in repository

examples/minimal_agent.rs (line 88)

async fn main() -> Result<(), BuildError> {
    // Initialize logging
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive(tracing::Level::INFO.into()),
        )
        .init();

    println!("🚀 Starting Echo Agent with declarative configuration");
    println!();

    // Build and run the agent from configuration file
    // This is all you need - the rest is handled by the framework!
    AgentBuilder::from_file("examples/minimal_agent.toml")?
        .with_handler(EchoHandler)
        .with_storage(InMemoryTaskStorage::new())
        .build()?
        .run()
        .await
        .map_err(|e| BuildError::RuntimeError(e.to_string()))?;

    Ok(())
}

examples/auto_storage_agent.rs (line 92)

async fn main() -> Result<(), BuildError> {
    // Initialize logging
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive(tracing::Level::INFO.into()),
        )
        .init();

    println!("🚀 Starting agent with automatic storage creation");
    println!("   Storage type is configured in auto_storage.toml");
    println!();

    // This is ALL you need! The builder:
    // 1. Reads the TOML config
    // 2. Creates the appropriate storage (in-memory or SQLx)
    // 3. Wires everything together
    // 4. Starts the servers
    //
    // No manual storage creation, no boilerplate!
    AgentBuilder::from_file("examples/auto_storage.toml")?
        .with_handler(EchoHandler)
        .build_with_auto_storage() // <- Magic happens here!
        .await?
        .run()
        .await
        .map_err(|e| BuildError::RuntimeError(e.to_string()))?;

    Ok(())
}

examples/auto_storage_sqlx.rs (line 113)

async fn main() -> Result<(), BuildError> {
    // Load .env file if present
    dotenvy::dotenv().ok();

    // Initialize logging
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive(tracing::Level::INFO.into()),
        )
        .init();

    println!("🚀 Starting agent with automatic SQLx storage");
    println!("   Database URL from config: ${{DATABASE_URL}}");
    println!("   Migrations will be run automatically");
    println!();

    // Optional: define custom migrations for your agent
    // These will be run automatically before the agent starts
    let migrations = &[
        // Example migration - you can add agent-specific tables here
        r#"
        CREATE TABLE IF NOT EXISTS echo_stats (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            message_count INTEGER NOT NULL DEFAULT 0,
            last_echo TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
        )
        "#,
    ];

    // The builder:
    // 1. Reads TOML config (including database URL from env)
    // 2. Creates SQLx connection pool
    // 3. Runs all migrations (framework + your custom ones)
    // 4. Wires storage with push notification support
    // 5. Starts the servers
    //
    // All from configuration!
    AgentBuilder::from_file("examples/auto_storage_sqlx.toml")?
        .with_handler(PersistentEchoHandler)
        .build_with_auto_storage_and_migrations(migrations)
        .await?
        .run()
        .await
        .map_err(|e| BuildError::RuntimeError(e.to_string()))?;

    Ok(())
}

examples/reimbursement_builder.rs (line 62)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load environment variables from .env file
    dotenvy::dotenv().ok();

    // Initialize logging
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::from_default_env()
                .add_directive(tracing::Level::INFO.into()),
        )
        .init();

    println!("🚀 Starting Reimbursement Agent with Builder API");
    println!();

    // Get database URL from environment or use default
    let database_url =
        env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite:reimbursement_tasks.db".to_string());

    // Create storage with custom migrations
    let migrations = &[include_str!("../migrations/001_create_reimbursements.sql")];
    let storage = SqlxTaskStorage::with_migrations(&database_url, migrations)
        .await
        .map_err(|e| format!("Failed to create storage: {}", e))?;

    // Create the handler
    let handler = ReimbursementHandler::new(storage.clone());

    // Build and run the agent - this is where the magic happens!
    // The configuration file defines all the metadata, skills, and features
    // The builder wires everything together automatically
    AgentBuilder::from_file("reimbursement.toml")?
        .with_config(|config| {
            // Override config from environment if needed
            if let Ok(port) = env::var("HTTP_PORT") {
                if let Ok(port_num) = port.parse() {
                    config.server.http_port = port_num;
                }
            }
            if let Ok(port) = env::var("WS_PORT") {
                if let Ok(port_num) = port.parse() {
                    config.server.ws_port = port_num;
                }
            }
        })
        .with_handler(handler)
        .with_storage(storage)
        .build()?
        .run()
        .await
        .map_err(|e| BuildError::RuntimeError(e.to_string()))?;

    Ok(())
}