adk-runner

Agent execution runtime for ADK-Rust.

Overview

adk-runner provides the execution runtime for ADK-Rust:

• Runner - Manages agent execution with full context
• Session Integration - Automatic session creation and state management
• Memory Injection - Retrieves and injects relevant memories
• Artifact Handling - Manages binary artifacts during execution
• Event Streaming - Streams agent events with state propagation
• Agent Transfer - Automatic handling of agent-to-agent transfers

Installation

[dependencies]
adk-runner = "0.1"

Or use the meta-crate:

[dependencies]
adk-rust = { version = "0.1", features = ["runner"] }

Quick Start

use adk_runner::{Runner, RunnerConfig};
use adk_session::InMemorySessionService;
use adk_artifact::InMemoryArtifactService;
use adk_core::Content;
use std::sync::Arc;

// Create services
let sessions = Arc::new(InMemorySessionService::new());
let artifacts = Arc::new(InMemoryArtifactService::new());

// Configure runner with agent
let config = RunnerConfig {
    app_name: "my_app".to_string(),
    agent: my_agent,  // Arc<dyn Agent>
    session_service: sessions,
    artifact_service: Some(artifacts),
    memory_service: None,
    run_config: None,  // Uses default SSE streaming
};

// Create runner
let runner = Runner::new(config)?;

// Run agent for a user/session
let mut stream = runner.run(
    "user_123".to_string(),
    "session_456".to_string(),
    Content::new("user").with_text("Hello!"),
).await?;

// Process events
use futures::StreamExt;
while let Some(event) = stream.next().await {
    match event {
        Ok(e) => println!("Event: {:?}", e.content()),
        Err(e) => eprintln!("Error: {}", e),
    }
}

RunnerConfig

Runner vs Direct Agent Execution

Use Runner for production; direct execution for testing.

Agent Transfers

Runner automatically handles agent-to-agent transfers:

// When an agent sets transfer_to_agent in EventActions,
// Runner automatically:
// 1. Finds the target agent in the agent tree
// 2. Creates a new invocation context
// 3. Preserves session state across the transfer
// 4. Continues streaming events from the new agent

State Propagation

Runner applies state changes immediately:

// When an agent emits an event with state_delta,
// Runner applies it to the mutable session so
// downstream agents can read the updated state.

Related Crates

• adk-rust - Meta-crate with all components
• adk-core - Core traits
• adk-session - Session storage
• adk-artifact - Artifact storage
• adk-cli - CLI using runner

License

Apache-2.0

Part of ADK-Rust

This crate is part of the ADK-Rust framework for building AI agents in Rust.