ADK Rust

https://docs.rs/adk-rust/latest/adk_rust
Admin
ADK Rust is a flexible and modular framework for developing and deploying AI agents in Rust,...
Tokens:2,146,518
Snippets:22,751
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Create and Initialize SandboxTool

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/struct.SandboxTool.html

Instantiate a SandboxTool by providing a SandboxBackend. This example demonstrates basic setup and assertion of the tool's name.

```rust
use adk_sandbox::{SandboxTool, ProcessBackend};
use std::sync::Arc;

let backend = Arc::new(ProcessBackend::default());
let tool = SandboxTool::new(backend);
assert_eq!(tool.name(), "sandbox_exec");
```

--------------------------------

### BrowserSessionPool Initialization and Usage Example

Source: https://docs.rs/adk-rust/latest/adk_rust/browser/prelude/struct.BrowserSessionPool.html

Demonstrates how to create a BrowserSessionPool, get or create a session for a user, navigate to a URL, and clean up all sessions.

```rust
use adk_browser::{BrowserConfig, BrowserSessionPool};

let pool = BrowserSessionPool::new(BrowserConfig::default(), 10);

// In a tool's execute(), resolve session from user context:
let session = pool.get_or_create("user_123").await?;
session.navigate("https://example.com").await?;

// On shutdown:
pool.cleanup_all().await;
```

--------------------------------

### ServerRetryHint Example

Source: https://docs.rs/adk-rust/latest/adk_rust/model/struct.ServerRetryHint.html

Example demonstrating how to create and use the ServerRetryHint struct.

```APIDOC
## Example
```rust
use adk_model::retry::ServerRetryHint;
use std::time::Duration;

let hint = ServerRetryHint { retry_after: Some(Duration::from_secs(30)) };
assert_eq!(hint.retry_after, Some(Duration::from_secs(30)));
```
```

--------------------------------

### NetworkRule Example

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/sandbox/struct.NetworkRule.html

Example of how to create a NetworkRule instance.

```APIDOC
## Example

```rust
use adk_sandbox::sandbox::NetworkRule;

let rule = NetworkRule {
    domain: "api.openai.com".to_string(),
    ports: vec![443],
};
```
```

--------------------------------

### Example Implementation of SandboxBackend

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/trait.SandboxBackend.html

An example demonstrating how to implement the SandboxBackend trait for a custom backend.

```APIDOC
## Example
```rust
use adk_sandbox::{SandboxBackend, ExecRequest, ExecResult, SandboxError};

struct MyBackend;

#[async_trait::async_trait]
impl SandboxBackend for MyBackend {
    fn name(&self) -> &str { "my-backend" }
    fn capabilities(&self) -> BackendCapabilities { /* ... */ }
    async fn execute(&self, request: ExecRequest) -> Result<ExecResult, SandboxError> {
        // Execute code in isolation
        todo!()
    }
}
```
```

--------------------------------

### ToolParam Example

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/struct.ToolParam.html

Example of creating and configuring a ToolParam.

```APIDOC
## Example
```rust
use serde_json::json;
use adk_anthropic::ToolParam;

let tool = ToolParam::new(
    "get_weather".to_string(),
    json!({
        "type": "object",
        "properties": {
            "location": { "type": "string" },
            "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] }
        },
        "required": ["location"],
        "additionalProperties": false
    })
)
.with_strict(true);
```
```

--------------------------------

### Example Usage of RealtimeModel

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/trait.RealtimeModel.html

This example demonstrates how to instantiate a `RealtimeModel` (specifically `OpenAIRealtimeModel`), configure a `RealtimeConfig`, and establish a real-time session using the `connect` method.

```APIDOC
## §Example
ⓘ```rust
use adk_realtime::{RealtimeModel, RealtimeConfig};
use adk_realtime::openai::OpenAIRealtimeModel;

#[tokio::main]
async fn main() -> Result<()>
{
    let model = OpenAIRealtimeModel::new(api_key, "gpt-4o-realtime-preview-2024-12-17");

    let config = RealtimeConfig::default()
        .with_instruction("You are a helpful assistant.")
        .with_voice("alloy");

    let session = model.connect(config).await?;

    // Use the session...

    session.close().await?;
    Ok(())
}
```
```

--------------------------------

### FileDataPart Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/struct.FileDataPart.html

An example demonstrating how to create and initialize a FileDataPart instance.

```APIDOC
## Example
```rust
use adk_core::FileDataPart;

let part = FileDataPart {
    mime_type: "application/pdf".to_string(),
    file_uri: "gs://my-bucket/report.pdf".to_string(),
};
```
```

--------------------------------

### AudioFrame Example

Source: https://docs.rs/adk-rust/latest/adk_rust/audio/struct.AudioFrame.html

An example demonstrating how to create and use an AudioFrame.

```APIDOC
## §Example
```
use adk_audio::AudioFrame;

let silence = AudioFrame::silence(16000, 1, 100);
assert_eq!(silence.sample_rate, 16000);
assert_eq!(silence.channels, 1);
assert_eq!(silence.duration_ms, 100);
```
```

--------------------------------

### WorkspaceMetadata Example

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.WorkspaceMetadata.html

An example demonstrating how to create and use a WorkspaceMetadata instance.

```APIDOC
## §Example
```rust
use adk_code::WorkspaceMetadata;

let meta = WorkspaceMetadata {
    project_name: "demo".to_string(),
    session_id: Some("sess-1".to_string()),
    created_at: Some(1719000000),
};
assert_eq!(meta.project_name, "demo");
```
```

--------------------------------

### InlineDataPart Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/struct.InlineDataPart.html

An example demonstrating how to create an instance of InlineDataPart.

```APIDOC
## Example
```rust
use adk_core::InlineDataPart;

let part = InlineDataPart {
    mime_type: "image/png".to_string(),
    data: vec![0x89, 0x50, 0x4E, 0x47],
};
```
```

--------------------------------

### Example Usage of RealtimeSession

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/trait.RealtimeSession.html

Demonstrates how to send audio and handle server events within a real-time session. This example shows sending audio, processing incoming audio deltas, and responding to function calls.

```rust
use adk_realtime::{RealtimeSession, ServerEvent};

async fn handle_session(session: &dyn RealtimeSession) -> Result<()> {
    // Send audio
    session.send_audio(audio_chunk).await?;

    // Receive events
    while let Some(event) = session.next_event().await {
        match event? {
            ServerEvent::AudioDelta { delta, .. } => { /* play audio */ } 
            ServerEvent::FunctionCallDone { name, arguments, call_id, .. } => {
                // Execute tool and respond
                let result = execute_tool(&name, &arguments);
                session.send_tool_response(call_id, result).await?;
            }
            _ => {} 
        }
    }
    Ok(())
}
```

--------------------------------

### Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/code/enum.ExecutionLanguage.html

An example demonstrating how to use the ExecutionLanguage enum.

```APIDOC
## §Example

```rust
use adk_code::ExecutionLanguage;

let lang = ExecutionLanguage::Rust;
assert_eq!(lang, ExecutionLanguage::Rust);
```
```

--------------------------------

### RustSandboxExecutor::start

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.RustSandboxExecutor.html

Starts the execution environment, such as creating and starting a container.

```APIDOC
## RustSandboxExecutor::start

### Description
Start the execution environment (e.g., create and start a container).

### Signature
`fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ExecutionError>> + Send + 'async_trait>> where 'life0: 'async_trait, Self: 'async_trait,`
```

--------------------------------

### LlmUsage Example

Source: https://docs.rs/adk-rust/latest/adk_rust/telemetry/spans/struct.LlmUsage.html

An example demonstrating how to create an instance of the LlmUsage struct.

```APIDOC
## Example

```rust
use adk_telemetry::LlmUsage;

let usage = LlmUsage {
    input_tokens: 100,
    output_tokens: 50,
    total_tokens: 150,
    ..Default::default()
};
```
```

--------------------------------

### AllowedPath Example

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/sandbox/struct.AllowedPath.html

Demonstrates how to create and use an AllowedPath instance.

```APIDOC
## §Example

```rust
use std::path::PathBuf;
use adk_sandbox::sandbox::{AllowedPath, AccessMode};

let entry = AllowedPath {
    path: PathBuf::from("/tmp"),
    mode: AccessMode::ReadOnly,
};
assert_eq!(entry.mode, AccessMode::ReadOnly);
```
```

--------------------------------

### run

Source: https://docs.rs/adk-rust/latest/adk_rust/fn.run.html

High-level single-turn agent invocation. Creates an agent with the given instructions, sends the input, and returns the text response. Uses `provider_from_env` to auto-detect the LLM provider. This is the fastest way to get started with ADK — a single function call that handles provider selection, session creation, agent building, and execution.

```APIDOC
## Function run

### Signature
```rust
pub async fn run(instructions: &str, input: &str) -> Result<String>
```

### Description
High-level single-turn agent invocation. Creates an agent with the given instructions, sends the input, and returns the text response. Uses `provider_from_env` to auto-detect the LLM provider.
This is the fastest way to get started with ADK — a single function call that handles provider selection, session creation, agent building, and execution.

### Arguments
* `instructions` - System instructions for the agent
* `input` - User input to send to the agent

### Returns
The agent’s text response as a `String`.

### Errors
Returns `AdkError` when no supported environment variable is set, or when agent execution fails.

### Example
```rust
use adk_rust::run;

let response = run("You are a helpful assistant.", "What is 2 + 2?").await?;
println!("{response}");
```
```

--------------------------------

### ExecutionPayload Example

Source: https://docs.rs/adk-rust/latest/adk_rust/code/enum.ExecutionPayload.html

An example demonstrating how to create an ExecutionPayload with inline source code.

```APIDOC
## Example

```rust
use adk_code::ExecutionPayload;

let payload = ExecutionPayload::Source {
    code: "fn run(input: serde_json::Value) -> serde_json::Value { input }".to_string(),
};
```
```

--------------------------------

### Example of FunctionTool with scopes

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/struct.FunctionTool.html

Demonstrates how to create a FunctionTool and apply required scopes for authorization. This example sets 'finance:write' and 'verified' as necessary scopes.

```rust
let tool = FunctionTool::new("transfer", "Transfer funds", handler)
    .with_scopes(&["finance:write", "verified"]);
```

--------------------------------

### RequestContext Example

Source: https://docs.rs/adk-rust/latest/adk_rust/server/struct.RequestContext.html

An example demonstrating how to create and use a RequestContext instance.

```APIDOC
## §Example
```rust
use adk_core::RequestContext;

let ctx = RequestContext {
    user_id: "user-123".to_string(),
    scopes: vec!["read".to_string(), "write".to_string],
    metadata: [("tenant".to_string(), "acme".to_string())].into(),
};
assert_eq!(ctx.user_id, "user-123");
assert_eq!(ctx.scopes.len(), 2);
```
```

--------------------------------

### ExecutionMetadata Example

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.ExecutionMetadata.html

An example demonstrating how to create and use an ExecutionMetadata instance.

```APIDOC
## Example
```rust
use adk_code::{ExecutionMetadata, ExecutionLanguage, ExecutionStatus, ExecutionIsolation};

let meta = ExecutionMetadata {
    backend_name: "rust-sandbox".to_string(),
    language: ExecutionLanguage::Rust,
    isolation: ExecutionIsolation::HostLocal,
    status: ExecutionStatus::Success,
    duration_ms: 42,
    identity: Some("inv-123".to_string()),
    artifact_refs: vec![],
};
assert_eq!(meta.backend_name, "rust-sandbox");
```
```

--------------------------------

### RagPipelineBuilder Example

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/pipeline/struct.RagPipelineBuilder.html

An example demonstrating how to use the RagPipelineBuilder to create a RagPipeline instance.

```APIDOC
## Example Usage

```rust
let pipeline = RagPipeline::builder()
    .config(RagConfig::default())
    .embedding_provider(Arc::new(embedder))
    .vector_store(Arc::new(store))
    .chunker(Arc::new(chunker))
    .reranker(Arc::new(reranker))  // optional
    .build()?;
```
```

--------------------------------

### Payment Toolset Builder Example

Source: https://docs.rs/adk-rust/latest/adk_rust/payment/tools/index.html

Example of how to build and obtain the payment tools using `PaymentToolsetBuilder`.

```APIDOC
## Example Usage

```rust
use adk_payments::tools::PaymentToolsetBuilder;

// Assuming checkout_service, transaction_store, and intervention_service are already initialized
let toolset = PaymentToolsetBuilder::new(checkout_service, transaction_store)
    .with_intervention_service(intervention_service)
    .build();

let tools = toolset.tools();
// Now you can use the 'tools' object to access payment operations.
```
```

--------------------------------

### BrowserSession::new

Source: https://docs.rs/adk-rust/latest/adk_rust/browser/struct.BrowserSession.html

Creates a new BrowserSession with the specified configuration. The browser is not started immediately; call `start()` to initialize the WebDriver connection.

```APIDOC
## BrowserSession::new

### Description
Create a new browser session with the given configuration.
Note: This does not start the browser immediately. Call `start()` to initialize the WebDriver connection.

### Signature
```rust
pub fn new(config: BrowserConfig) -> BrowserSession
```
```

--------------------------------

### Add Npm Install Command to DockerConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.DockerConfig.html

Appends an npm install command to the setup commands. This is specific to Node.js environments for managing package dependencies.

```rust
pub fn npm_install(self, packages: &[&str]) -> DockerConfig
```

--------------------------------

### Quick Start

Source: https://docs.rs/adk-rust/latest/adk_rust/model/anthropic/index.html

Initialize the Anthropic client with your API key and a model name.

```APIDOC
## Quick Start

Initialize the Anthropic client with your API key and a model name.

```rust
use adk_model::anthropic::{AnthropicClient, AnthropicConfig};

let client = AnthropicClient::new(AnthropicConfig::new(
    std::env::var("ANTHROPIC_API_KEY").unwrap(),
    "claude-sonnet-4-5-20250929",
))?;
```
```

--------------------------------

### Add Pip Install Command to DockerConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.DockerConfig.html

Appends a pip install command to the setup commands. This is specific to Python environments and simplifies dependency management.

```rust
pub fn pip_install(self, packages: &[&str]) -> DockerConfig
```

--------------------------------

### PluginBuilder::before_run

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/struct.PluginBuilder.html

Sets the callback invoked before the agent run starts. Useful for setup, validation, or early exit.

```APIDOC
## PluginBuilder::before_run

### Description
Set the callback invoked before the agent run starts.
Use this for setup, validation, or early exit. Return `Ok(Some(content))` to skip the run entirely and return that content, or `Ok(None)` to proceed normally.

### Signature
`pub fn before_run( self, callback: Box<dyn Fn(Arc<dyn InvocationContext>) -> Pin<Box<dyn Future<Output = Result<Option<Content>, AdkError>> + Send>> + Sync + Send>, ) -> PluginBuilder`

### Example
```
builder.before_run(Box::new(|ctx| {
    Box::pin(async move {
        tracing::info!("run starting");
        Ok(None) // continue with the run
    })
}))
```
```

--------------------------------

### Example Usage of DockerConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.DockerConfig.html

Demonstrates how to create a DockerConfig instance using a preset and assert its initial values. Requires the `code` feature.

```rust
use adk_code::DockerConfig;

let config = DockerConfig::python();
assert_eq!(config.image, "python:3.12-slim");
assert_eq!(config.work_dir, "/workspace");
```

--------------------------------

### Add Setup Command to DockerConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.DockerConfig.html

Adds a command to be executed after the container is created. Useful for installing dependencies or setting up the environment.

```rust
pub fn setup_command(self, cmd: impl Into<String>) -> DockerConfig
```

--------------------------------

### Initialize and Run RealtimeRunner

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/struct.RealtimeRunner.html

Demonstrates how to set up and start a RealtimeRunner with a specific model, instructions, voice, and a tool definition. Requires the 'realtime' feature flag.

```rust
use adk_realtime::{RealtimeRunner, RealtimeConfig, ToolDefinition};
use adk_realtime::openai::OpenAIRealtimeModel;

#[tokio::main]
async fn main() -> Result<()> {
    let model = OpenAIRealtimeModel::new(api_key, "gpt-4o-realtime-preview-2024-12-17");

    let runner = RealtimeRunner::builder()
        .model(Box::new(model))
        .instruction("You are a helpful voice assistant.")
        .voice("alloy")
        .tool_fn(
            ToolDefinition::new("get_weather")
                .with_description("Get weather for a location"),
            |call| {
                Ok(serde_json::json!({"temperature": 72, "condition": "sunny"}))
            }
        )
        .build()?;

    runner.connect().await?;
    runner.run().await?;

    Ok(())
}
```

--------------------------------

### End-to-End PluginBuilder Example

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/struct.PluginBuilder.html

Demonstrates the creation of a plugin named 'audit-trail' with multiple lifecycle callbacks including before/after agent, before/after tool, before/after model, and a close function. This example showcases the fluent API for configuring plugin behavior.

```rust
use adk_plugin::PluginBuilder;
use std::sync::Arc;

let plugin = PluginBuilder::new("audit-trail")
    .before_agent(Box::new(|ctx| {
        Box::pin(async move {
            tracing::info!("agent starting");
            Ok(())
        })
    }))
    .after_agent(Box::new(|ctx| {
        Box::pin(async move {
            tracing::info!("agent finished");
            Ok(())
        })
    }))
    .before_tool(Box::new(|ctx| {
        Box::pin(async move {
            if let Some(name) = ctx.tool_name() {
                tracing::info!(tool = name, "tool invoked");
            }
            Ok(())
        })
    }))
    .after_tool(Box::new(|ctx| {
        Box::pin(async move {
            tracing::info!("tool completed");
            Ok(())
        })
    }))
    .before_model(Box::new(|ctx, request| {
        Box::pin(async move {
            tracing::debug!(model = ?request.model, "sending request to model");
            Ok(request)
        })
    }))
    .after_model(Box::new(|ctx, response| {
        Box::pin(async move {
            tracing::debug!("model responded");
            Ok(None)
        })
    }))
    .close_fn(|| Box::pin(async { tracing::info!("plugin closed") }))
    .build();

assert_eq!(plugin.name(), "audit-trail");

```

--------------------------------

### Example PluginConfig Initialization

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/struct.PluginConfig.html

Demonstrates how to initialize a PluginConfig with a name and an optional user message callback. Uses Default::default() for other fields.

```rust
let config = PluginConfig {
    name: "my-plugin".to_string(),
    on_user_message: Some(Box::new(|ctx, content| {
        Box::pin(async move {
            // Process user message
            Ok(None)
        })
    })),
    ..Default::default()
};

```

--------------------------------

### Get Page Count for Citation

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/struct.CitationPageLocation.html

Calculates and returns the total number of pages covered by the citation span, including both the start and end pages.

```rust
pub fn page_count(&self) -> i32
```

--------------------------------

### Share immutable data between threads

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/struct.Arc.html

Example of sharing an immutable integer across multiple threads using Arc. Each thread gets a cloned Arc pointer to the shared data.

```rust
use std::sync::Arc;
use std::thread;

let five = Arc::new(5);

for _ in 0..10 {
    let five = Arc::clone(&five);

    thread::spawn(move || {
        println!("{five:?}");
    });
}
```

--------------------------------

### Example Usage of BackendCapabilities

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.BackendCapabilities.html

Demonstrates how to instantiate and use the BackendCapabilities struct. Ensure the `code` feature is enabled.

```rust
use adk_code::{BackendCapabilities, ExecutionIsolation};

let caps = BackendCapabilities {
    isolation: ExecutionIsolation::ContainerEphemeral,
    enforce_network_policy: true,
    enforce_filesystem_policy: true,
    enforce_environment_policy: true,
    enforce_timeout: true,
    supports_structured_output: true,
    supports_process_execution: false,
    supports_persistent_workspace: false,
    supports_interactive_sessions: false,
};
assert!(caps.enforce_network_policy);
```

--------------------------------

### Handling File Metadata with `and_then`

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/type.Result.html

Shows how to use `and_then` to chain fallible operations when working with file system metadata. This example retrieves metadata and then attempts to get the modification time.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Instantiate BackendCapabilities

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/backend/struct.BackendCapabilities.html

Example of creating a BackendCapabilities instance with specific supported languages, isolation class, and enforced limits. This demonstrates how to populate the struct for use.

```rust
use adk_sandbox::{BackendCapabilities, EnforcedLimits, Language};

let caps = BackendCapabilities {
    supported_languages: vec![Language::Python, Language::JavaScript],
    isolation_class: "process".to_string(),
    enforced_limits: EnforcedLimits {
        timeout: true,
        memory: false,
        network_isolation: false,
        filesystem_isolation: false,
        environment_isolation: true,
    },
};
assert!(caps.enforced_limits.timeout);
```

--------------------------------

### Build Axum Server with Custom Routes

Source: https://docs.rs/adk-rust/latest/adk_rust/server/rest/struct.ServerBuilder.html

Constructs an ADK server, adding custom API routes and enabling A2A protocol support. This example demonstrates the primary usage of ServerBuilder for a complete server setup.

```rust
use adk_server::{ServerBuilder, ServerConfig};
use axum::{Router, routing::get};

let config = ServerConfig::new(agent, session_service);

let app = ServerBuilder::new(config)
    .add_api_routes(
        Router::new()
            .route("/projects", get(list_projects))
            .route("/projects/{id}", get(get_project))
    )
    .add_api_routes(
        Router::new()
            .route("/automations", get(list_automations))
    )
    .with_a2a("http://localhost:8080")
    .build();

let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await?;
axum::serve(listener, app).await?;
```

--------------------------------

### BeforeRunCallback Definition

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/type.BeforeRunCallback.html

Callback invoked before the agent run starts. Can perform setup, validation, or early exit. Return `Ok(Some(content))` to skip the run and return this content. Return `Ok(None)` to continue with the run.

```APIDOC
## Type Alias BeforeRunCallback

Available on **crate feature `plugin`** only.

### Summary
```rust
pub type BeforeRunCallback = Box<dyn Fn(Arc<dyn InvocationContext>) -> Pin<Box<dyn Future<Output = Result<Option<Content>, AdkError>> + Send>> + Sync + Send>;
```

### Description
Callback invoked before the agent run starts. Can perform setup, validation, or early exit. Return `Ok(Some(content))` to skip the run and return this content. Return `Ok(None)` to continue with the run.
```

--------------------------------

### Example Usage of ContextCacheConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/runner/struct.ContextCacheConfig.html

Demonstrates how to create and initialize a ContextCacheConfig. Ensure the `runner` feature is enabled.

```rust
use adk_core::ContextCacheConfig;

let config = ContextCacheConfig {
    min_tokens: 4096,
    ttl_seconds: 600,
    cache_intervals: 3,
};
assert_eq!(config.min_tokens, 4096);
```

--------------------------------

### BrowserSessionPool::get_or_create - Get or create a user session

Source: https://docs.rs/adk-rust/latest/adk_rust/browser/prelude/struct.BrowserSessionPool.html

Retrieves an existing browser session for a given user ID or creates a new one if it doesn't exist. Automatically starts the session if newly created, and attempts to reconnect if stale.

```rust
pub async fn get_or_create( &self, user_id: &str, ) -> Result<Arc<BrowserSession>, AdkError>
```

--------------------------------

### BeforeRunCallback Type Alias Definition

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/type.BeforeRunCallback.html

Defines the BeforeRunCallback type alias, which is a boxed trait object for a function that takes an InvocationContext and returns a Future. This callback is invoked before the agent run starts and can be used for setup, validation, or early exit.

```rust
pub type BeforeRunCallback = Box<dyn Fn(Arc<dyn InvocationContext>) -> Pin<Box<dyn Future<Output = Result<Option<Content>, AdkError>> + Send>> + Sync + Send>;
```

--------------------------------

### Example Usage of OpenAIRealtimeModel

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/trait.RealtimeModel.html

Demonstrates how to instantiate an OpenAIRealtimeModel, configure a RealtimeConfig with instructions and voice, and establish a real-time session. Ensure the 'realtime' feature is enabled and necessary API keys are provided.

```rust
use adk_realtime::{RealtimeModel, RealtimeConfig};
use adk_realtime::openai::OpenAIRealtimeModel;

#[tokio::main]
async fn main() -> Result<()> {
    let model = OpenAIRealtimeModel::new(api_key, "gpt-4o-realtime-preview-2024-12-17");

    let config = RealtimeConfig::default()
        .with_instruction("You are a helpful assistant.")
        .with_voice("alloy");

    let session = model.connect(config).await?;

    // Use the session...

    session.close().await?;
    Ok(())
}
```

--------------------------------

### RustSandboxExecutor CodeExecutor Trait: start

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.RustSandboxExecutor.html

Starts the execution environment, such as creating and starting a container. This is an asynchronous operation.

```rust
fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ExecutionError>> + Send + 'async_trait>>
where 'life0: 'async_trait,
Self: 'async_trait,
```

--------------------------------

### Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/instruction_template/fn.inject_session_state.html

Demonstrates how to use the inject_session_state function with a sample template and expected output.

```APIDOC
## Example
```rust
let template = "Hello {user_name}, your score is {score}";
let result = inject_session_state(ctx, template).await?;
// Result: "Hello Alice, your score is 100"
```
```

--------------------------------

### Create and Use FxChain

Source: https://docs.rs/adk-rust/latest/adk_rust/audio/struct.FxChain.html

Demonstrates creating a new FxChain, adding processing stages using `push`, and then processing an audio frame. Ensure the 'audio' feature is enabled for FxChain.

```rust
let chain = FxChain::new()
    .push(normalizer)
    .push(resampler);
let output = chain.process(&input).await?;
```

--------------------------------

### AccessMode Example

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/sandbox/enum.AccessMode.html

Example demonstrating the usage of the AccessMode enum.

```APIDOC
## §Example
```
use adk_sandbox::sandbox::AccessMode;

let mode = AccessMode::ReadOnly;
assert_ne!(mode, AccessMode::ReadWrite);
```
```

--------------------------------

### Example Usage of AudioPipelineBuilder

Source: https://docs.rs/adk-rust/latest/adk_rust/audio/pipeline/builder/struct.AudioPipelineBuilder.html

Demonstrates how to chain builder methods to configure and build a voice agent pipeline. Requires TTS, STT, VAD, and agent providers to be set.

```rust
let handle = AudioPipelineBuilder::new()
    .tts(my_tts)
    .stt(my_stt)
    .vad(my_vad)
    .agent(my_agent)
    .build_voice_agent()?;

```

--------------------------------

### Browser Toolset Initialization

Source: https://docs.rs/adk-rust/latest/adk_rust/browser/prelude/struct.BrowserToolset.html

Demonstrates how to create a BrowserToolset instance using different initialization methods.

```APIDOC
## Browser Toolset Initialization

### Description
Methods for creating and configuring a `BrowserToolset`.

### Methods

#### `new(browser: Arc<BrowserSession>) -> BrowserToolset`
Create a new toolset with all tools enabled.

#### `with_pool(pool: Arc<BrowserSessionPool>) -> BrowserToolset`
Create a pool-backed toolset with all tools enabled. Sessions are resolved per-user at runtime.

##### Example
```rust
use adk_browser::{BrowserToolset, BrowserSessionPool, BrowserConfig};
use std::sync::Arc;

let pool = Arc::new(BrowserSessionPool::new(BrowserConfig::default()));
let toolset = BrowserToolset::with_pool(pool);
```

#### `with_pool_and_profile(pool: Arc<BrowserSessionPool>, profile: BrowserProfile) -> BrowserToolset`
Create a pool-backed toolset with a pre-configured profile.

##### Example
```rust
use adk_browser::{BrowserToolset, BrowserProfile, BrowserSessionPool, BrowserConfig};
use std::sync::Arc;

let pool = Arc::new(BrowserSessionPool::new(BrowserConfig::default()));
let toolset = BrowserToolset::with_pool_and_profile(pool, BrowserProfile::Minimal);
```

#### `with_profile(browser: Arc<BrowserSession>, profile: BrowserProfile) -> BrowserToolset`
Create a toolset with a pre-configured profile. This is the recommended way for most agents.

```

--------------------------------

### Initialize OpenAIClient with Configuration

Source: https://docs.rs/adk-rust/latest/adk_rust/model/openai/struct.OpenAIClient.html

Use this function to create a new OpenAI client with a provided configuration. Requires the `models` and `openai` crate features.

```rust
pub fn new(config: OpenAIConfig) -> Result<OpenAIClient, AdkError>
```

--------------------------------

### Initialize and Run PromptOptimizer

Source: https://docs.rs/adk-rust/latest/adk_rust/eval/optimizer/index.html

Instantiates a PromptOptimizer with an LLM, evaluator, and configuration, then initiates the optimization process against an evaluation set. The final score is printed upon completion.

```rust
use adk_eval::optimizer::{PromptOptimizer, OptimizerConfig};
use std::sync::Arc;

let optimizer = PromptOptimizer::new(
    optimizer_llm,
    evaluator,
    OptimizerConfig::default(),
);
let result = optimizer.optimize(agent, &eval_set).await?;
println!("Final score: {}", result.final_score);
```

--------------------------------

### Initialize PluginManager with Plugins

Source: https://docs.rs/adk-rust/latest/adk_rust/plugin/struct.PluginManager.html

Demonstrates how to create a new PluginManager instance by providing a vector of Plugin objects. Each plugin is configured with its name and specific callback functions.

```rust
use adk_plugin::{Plugin, PluginManager, PluginConfig};

let plugins = vec![
    Plugin::new(PluginConfig {
        name: "logging".to_string(),
        on_event: Some(log_events()),
        ..Default::default()
    }),
    Plugin::new(PluginConfig {
        name: "metrics".to_string(),
        before_run: Some(start_timer()),
        after_run: Some(stop_timer()),
        ..Default::default()
    }),
];

let manager = PluginManager::new(plugins);
```

--------------------------------

### SandboxPolicy Example

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/struct.SandboxPolicy.html

An example demonstrating how to construct a SandboxPolicy using SandboxPolicyBuilder.

```APIDOC
## Example

```rust
use adk_sandbox::sandbox::SandboxPolicyBuilder;

// Allow only OpenAI API access
let policy = SandboxPolicyBuilder::new()
    .allow_read("/usr/lib")
    .allow_domain("api.openai.com", &[443])
    .allow_domain("cdn.openai.com", &[443])
    .env("PATH", "/usr/bin")
    .build();

assert!(!policy.allow_network); // full network is denied
assert_eq!(policy.network_rules.len(), 2); // but 2 domains are allowed
```
```

--------------------------------

### FixedSizeChunker Example

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/struct.FixedSizeChunker.html

Example usage of FixedSizeChunker to create chunks from a document.

```APIDOC
## Example
```rust
use adk_rag::FixedSizeChunker;

let chunker = FixedSizeChunker::new(256, 50);
let chunks = chunker.chunk(&document);
```
```

--------------------------------

### ProcessBackend Default Initialization

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/process/struct.ProcessBackend.html

Demonstrates how to create a default ProcessBackend instance and verify its name. This is the basic setup for using the process-based sandbox.

```rust
use adk_sandbox::{ProcessBackend, SandboxBackend};

let backend = ProcessBackend::default();
assert_eq!(backend.name(), "process");
```

--------------------------------

### RecursiveChunker Example

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/chunking/struct.RecursiveChunker.html

Example usage of the RecursiveChunker to create chunks from a document.

```APIDOC
```rust
use adk_rag::RecursiveChunker;

let chunker = RecursiveChunker::new(512, 100);
let chunks = chunker.chunk(&document);
```
```

--------------------------------

### Initialize RealtimeAgent with OpenAI Model

Source: https://docs.rs/adk-rust/latest/adk_rust/realtime/agent/index.html

Demonstrates how to create a RealtimeAgent using an OpenAI model. Requires API key and specifies model, instructions, voice, and tools. The agent can also be configured with callbacks.

```rust
use adk_realtime::RealtimeAgent;
use adk_realtime::openai::OpenAIRealtimeModel;

let model = OpenAIRealtimeModel::new(api_key, "gpt-4o-realtime-preview-2024-12-17");

let agent = RealtimeAgent::builder("voice_assistant")
    .model(Box::new(model))
    .instruction("You are a helpful voice assistant.")
    .voice("alloy")
    .tool(Arc::new(weather_tool))
    .before_agent_callback(|ctx| async move {
        println!("Starting voice session for user: {}", ctx.user_id());
        Ok(None)
    })
    .build()?;

// Run through standard ADK runner
let runner = Runner::new(agent);
runner.run(session, user_content).await?;
```

--------------------------------

### Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/model/tool_call_parser/struct.ToolCallBuffer.html

Example of how to use ToolCallBuffer in a streaming response handler.

```APIDOC
## Example Usage

```rust
let mut buffer = ToolCallBuffer::new();

for chunk in stream {
    match buffer.push(&chunk.text) {
        BufferAction::Emit(parts) => {
            for part in parts { yield part; }
        }
        BufferAction::Buffering => { /* still accumulating */ }
    }
}
// Flush any remaining content at end of stream
for part in buffer.flush() { yield part; }
```
```

--------------------------------

### ExecutionIdentity Example

Source: https://docs.rs/adk-rust/latest/adk_rust/identity/struct.ExecutionIdentity.html

An example demonstrating how to create and use an ExecutionIdentity instance.

```APIDOC
## §Examples
```rust
use adk_core::identity::{
    AdkIdentity,
    AppName,
    ExecutionIdentity,
    InvocationId,
    SessionId,
    UserId,
};

let exec = ExecutionIdentity {
    adk: AdkIdentity::new(
        AppName::try_from("my-app").unwrap(),
        UserId::try_from("user-1").unwrap(),
        SessionId::try_from("sess-1").unwrap(),
    ),
    invocation_id: InvocationId::generate(),
    branch: String::new(),
    agent_name: "root".to_string(),
};

assert_eq!(exec.adk.app_name.as_ref(), "my-app");
```
```

--------------------------------

### Create and Configure Workspace

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.Workspace.html

Use `Workspace::new` to get a `WorkspaceBuilder` for ergonomic construction. Configure project name and session ID before building.

```rust
use adk_code::Workspace;

let workspace = Workspace::new("./my-project")
    .project_name("my-project")
    .session_id("sess-abc")
    .build();

assert_eq!(workspace.root(), &std::path::PathBuf::from("./my-project"));
assert_eq!(workspace.metadata().project_name, "my-project");
assert_eq!(workspace.metadata().session_id.as_deref(), Some("sess-abc"));
```

--------------------------------

### Initialize OpenAIMcpTool with URL

Source: https://docs.rs/adk-rust/latest/adk_rust/tool/builtin/struct.OpenAIMcpTool.html

Creates a new instance of OpenAIMcpTool using a server label and a server URL. Ensure the 'tools' feature is enabled.

```rust
pub fn new_with_url( server_label: impl Into<String>, server_url: impl Into<String>, ) -> OpenAIMcpTool
```

--------------------------------

### Example Usage of OpenAIResponsesConfig

Source: https://docs.rs/adk-rust/latest/adk_rust/model/openai/struct.OpenAIResponsesConfig.html

Demonstrates how to create and configure an OpenAIResponsesConfig instance with specific reasoning settings.

```rust
use adk_model::openai::{OpenAIResponsesConfig, ReasoningEffort, ReasoningSummary};

let config = OpenAIResponsesConfig::new("sk- ...", "o3")
    .with_reasoning_effort(ReasoningEffort::High)
    .with_reasoning_summary(ReasoningSummary::Concise);
```

--------------------------------

### Initialize Workspace

Source: https://docs.rs/adk-rust/latest/adk_rust/code/struct.Workspace.html

Start building a new workspace rooted at the given path. Returns a `WorkspaceBuilder` for fluent configuration.

```rust
use adk_code::Workspace;

let ws = Workspace::new("/tmp/project").build();
assert_eq!(ws.root(), &std::path::PathBuf::from("/tmp/project"));
```

--------------------------------

### ToolSearchConfig Example

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/struct.ToolSearchConfig.html

Example usage of ToolSearchConfig to create and test a configuration.

```APIDOC
## §Example

```rust
use adk_anthropic::ToolSearchConfig;

let config = ToolSearchConfig::new("^(search|fetch)_.*");
assert!(config.matches("search_web").unwrap());
assert!(!config.matches("delete_all").unwrap());
```
```

--------------------------------

### PrefixedToolset Example

Source: https://docs.rs/adk-rust/latest/adk_rust/tool/struct.PrefixedToolset.html

Example demonstrating how to use PrefixedToolset to namespace tool names.

```APIDOC
## Example Usage

```rust
use adk_tool::toolset::PrefixedToolset;

// Assuming BrowserToolset is defined elsewhere and has a ::new method
// let session = ...; // Obtain a session context
// let browser = BrowserToolset::new(session);
// let prefixed = PrefixedToolset::new(Arc::new(browser), "browser");
// Tools from the inner toolset will now be prefixed, e.g., "browser_navigate", "browser_click".
```
```

--------------------------------

### Example Usage of AllowedPath

Source: https://docs.rs/adk-rust/latest/adk_rust/sandbox/sandbox/struct.AllowedPath.html

Demonstrates how to create an AllowedPath instance with a specific path and access mode, and asserts the access mode. Requires importing PathBuf, AllowedPath, and AccessMode.

```rust
use std::path::PathBuf;
use adk_sandbox::sandbox::{AllowedPath, AccessMode};

let entry = AllowedPath {
    path: PathBuf::from("/tmp"),
    mode: AccessMode::ReadOnly,
};
assert_eq!(entry.mode, AccessMode::ReadOnly);
```

--------------------------------

### Example Usage of VectorStore

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/trait.VectorStore.html

Demonstrates basic operations of a VectorStore implementation, including creating a collection, upserting chunks, and performing a similarity search.

```rust
use adk_rag::{VectorStore, InMemoryVectorStore};

let store = InMemoryVectorStore::new();
store.create_collection("docs", 384).await?;
store.upsert("docs", &chunks).await?;
let results = store.search("docs", &query_embedding, 5).await?;
```

--------------------------------

### ExecutionIdentity Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/struct.ExecutionIdentity.html

An example demonstrating how to create and use an ExecutionIdentity instance.

```APIDOC
## §Examples

```rust
use adk_core::identity::{
    AdkIdentity,
    AppName,
    ExecutionIdentity,
    InvocationId,
    SessionId,
    UserId,
};

let exec = ExecutionIdentity {
    adk: AdkIdentity::new(
        AppName::try_from("my-app").unwrap(),
        UserId::try_from("user-1").unwrap(),
        SessionId::try_from("sess-1").unwrap(),
    ),
    invocation_id: InvocationId::generate(),
    branch: String::new(),
    agent_name: "root".to_string(),
};

assert_eq!(exec.adk.app_name.as_ref(), "my-app");
```
```

--------------------------------

### Example Usage of NoOpReranker

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/reranker/struct.NoOpReranker.html

Demonstrates how to instantiate and use the NoOpReranker. The rerank method is called with a query and results, and it's noted that the output will be identical to the input results in terms of order and scores.

```rust
use adk_rag::NoOpReranker;

let reranker = NoOpReranker;
let reranked = reranker.rerank("query", results).await?;
// reranked == results (same order, same scores)
```

--------------------------------

### RagPipelineBuilder Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/struct.RagPipelineBuilder.html

An example demonstrating how to use the RagPipelineBuilder to construct a RagPipeline.

```APIDOC
## Example

```rust
let pipeline = RagPipeline::builder()
    .config(RagConfig::default())
    .embedding_provider(Arc::new(embedder))
    .vector_store(Arc::new(store))
    .chunker(Arc::new(chunker))
    .reranker(Arc::new(reranker))  // optional
    .build()?;
```
```

--------------------------------

### AppName Examples

Source: https://docs.rs/adk-rust/latest/adk_rust/struct.AppName.html

Illustrates how to create and use the AppName struct, including validation checks.

```APIDOC
## Examples

```rust
use adk_core::identity::AppName;

let app: AppName = "my-app".parse().unwrap();
assert_eq!(app.as_ref(), "my-app");

// Empty values are rejected
assert!(AppName::try_from("").is_err());
```
```

--------------------------------

### OpenAIClient Initialization

Source: https://docs.rs/adk-rust/latest/adk_rust/model/openai/index.html

Example of how to initialize the OpenAIClient with configuration, including API key and model selection. This client can be used for standard OpenAI API and OpenAI-compatible APIs.

```APIDOC
## Example
ⓘ
```rust
use adk_model::openai::{OpenAIClient, OpenAIConfig};

let client = OpenAIClient::new(OpenAIConfig {
    api_key: std::env::var("OPENAI_API_KEY").unwrap(),
    model: "gpt-4o-mini".to_string(),
    ..Default::default()
})?;
```
```

--------------------------------

### PaymentOperation Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/payment/auth/enum.PaymentOperation.html

Example demonstrating how to check payment operation scopes.

```APIDOC
## §Example
```rust
use adk_payments::auth::{PaymentOperation, check_payment_operation_scopes};

let granted = vec!["payments:checkout:create".to_string()];
check_payment_operation_scopes(PaymentOperation::CreateCheckout, &granted).unwrap();
```
```

--------------------------------

### Initialize OpenAIClient for Compatible APIs

Source: https://docs.rs/adk-rust/latest/adk_rust/model/openai/struct.OpenAIClient.html

Create a client for an OpenAI-compatible API by providing the API key, base URL, and model name. Requires the `models` and `openai` crate features.

```rust
pub fn compatible( api_key: impl Into<String>, base_url: impl Into<String>, model: impl Into<String>, ) -> Result<OpenAIClient, AdkError>
```

--------------------------------

### AppendEventRequest Example

Source: https://docs.rs/adk-rust/latest/adk_rust/session/struct.AppendEventRequest.html

An example demonstrating how to create an instance of AppendEventRequest with a specific identity and event.

```APIDOC
## Example
```rust
use adk_core::identity::{AdkIdentity, AppName, SessionId, UserId};
use adk_session::AppendEventRequest;
use adk_session::Event;

let identity = AdkIdentity::new(
    AppName::try_from("weather-app").unwrap(),
    UserId::try_from("user-123").unwrap(),
    SessionId::try_from("session-456").unwrap(),
);

let event = Event::new("inv-001");
let req = AppendEventRequest { identity, event };
```
```

--------------------------------

### Example: Update Instruction Mid-Session

Source: https://docs.rs/adk-rust/latest/adk_rust/realtime/config/struct.SessionUpdateConfig.html

Demonstrates how to create a SessionUpdateConfig to update only the instruction field during an active session. This is useful for persona shifts or tool swaps without dropping the audio connection.

```rust
use adk_realtime::config::{SessionUpdateConfig, RealtimeConfig};

// Update *only* the instruction mid-session.
let delta = SessionUpdateConfig(
    RealtimeConfig::default().with_instruction("You are now a travel agent.")
);
```

--------------------------------

### Initialize LlmAgentBuilder

Source: https://docs.rs/adk-rust/latest/adk_rust/prelude/struct.LlmAgentBuilder.html

Start building an LLM agent by providing its unique name. This is the initial step in configuring the agent.

```rust
pub fn new(name: impl Into<String>) -> LlmAgentBuilder
```

--------------------------------

### IdentityError Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/enum.IdentityError.html

An example demonstrating how to catch and identify an IdentityError::Empty variant.

```APIDOC
## §Examples

```rust
use adk_core::identity::{AppName, IdentityError};

let err = AppName::try_from("").unwrap_err();
assert!(matches!(err, IdentityError::Empty { .. }));
```
```

--------------------------------

### FileLogger Example Implementation

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/trait.ClientLogger.html

An example implementation of the ClientLogger trait that logs messages to a file.

```APIDOC
## §Example

```rust
use adk_anthropic::{ClientLogger, Message, MessageStreamEvent};
use std::sync::Mutex;

struct FileLogger {
    file: Mutex<std::fs::File>,
}

impl ClientLogger for FileLogger {
    fn log_response(&self, message: &Message) {
        let mut file = self.file.lock().unwrap();
        writeln!(file, "Response: {}", serde_json::to_string(message).unwrap()).unwrap();
    }

    fn log_stream_event(&self, event: &MessageStreamEvent) {
        let mut file = self.file.lock().unwrap();
        writeln!(file, "Stream event: {}", serde_json::to_string(event).unwrap()).unwrap();
    }

    fn log_stream_message(&self, message: &Message) {
        let mut file = self.file.lock().unwrap();
        writeln!(file, "Stream complete: {}", serde_json::to_string(message).unwrap()).unwrap();
    }
}
```
```

--------------------------------

### AdkIdentity Example Usage

Source: https://docs.rs/adk-rust/latest/adk_rust/identity/struct.AdkIdentity.html

Demonstrates how to create and use an AdkIdentity object.

```APIDOC
## Examples
```rust
use adk_core::identity::{AdkIdentity, AppName, SessionId, UserId};

let identity = AdkIdentity::new(
    AppName::try_from("weather-app").unwrap(),
    UserId::try_from("alice").unwrap(),
    SessionId::try_from("sess-1").unwrap(),
);

assert_eq!(identity.app_name.as_ref(), "weather-app");
assert_eq!(identity.user_id.as_ref(), "alice");
assert_eq!(identity.session_id.as_ref(), "sess-1");
```
```

--------------------------------

### AnthropicClient::get_model

Source: https://docs.rs/adk-rust/latest/adk_rust/model/anthropic/struct.AnthropicClient.html

Get details for a specific model. Calls `GET /v1/models/{model_id}`.

```APIDOC
## AnthropicClient::get_model

### Description
Get details for a specific model. Calls `GET /v1/models/{model_id}` and returns the model descriptor.

### Parameters
#### Path Parameters
- **model_id** (&str) - The ID of the model to retrieve.

### Errors
Returns `AdkError::Model` with structured error context if the API returns an error (e.g., model not found).

### Returns
- Result<ModelInfo, AdkError> - The model information or an error.
```

--------------------------------

### SystemPrompt Implementations

Source: https://docs.rs/adk-rust/latest/adk_rust/anthropic_client/enum.SystemPrompt.html

Provides methods for creating and interacting with SystemPrompt instances.

```APIDOC
### Method: `from_string`

```rust
pub fn from_string(content: String) -> SystemPrompt
```

Create a new SystemPrompt from a string.
```

```APIDOC
### Method: `from_blocks`

```rust
pub fn from_blocks(blocks: Vec<TextBlock>) -> SystemPrompt
```

Create a new SystemPrompt from text blocks.
```

--------------------------------

### RagPipeline Usage Example

Source: https://docs.rs/adk-rust/latest/adk_rust/rag/pipeline/index.html

This example demonstrates how to build and use the RagPipeline for document ingestion and querying.

```APIDOC
## RagPipeline Usage Example

### Description
This example demonstrates how to build and use the RagPipeline for document ingestion and querying.

### Method
```rust
use adk_rag::{RagPipeline, RagConfig, InMemoryVectorStore, FixedSizeChunker};

// Assume my_embedder and document are defined elsewhere
// let my_embedder = ...;
// let document = ...;

let pipeline = RagPipeline::builder()
    .config(RagConfig::default())
    .embedding_provider(Arc::new(my_embedder))
    .vector_store(Arc::new(InMemoryVectorStore::new()))
    .chunker(Arc::new(FixedSizeChunker::new(512, 100)))
    .build()?;

pipeline.create_collection("docs").await?;
pipeline.ingest("docs", &document).await?;
let results = pipeline.query("docs", "search query").await?;
```

### Notes
- This code requires the `rag` feature flag to be enabled.
- Ensure that `my_embedder` and `document` are properly initialized before use.
```

--------------------------------

### Create New RealtimeConfigBuilder

Source: https://docs.rs/adk-rust/latest/adk_rust/realtime/config/struct.RealtimeConfigBuilder.html

Initializes a new instance of the RealtimeConfigBuilder. This is the starting point for configuring realtime settings.

```rust
pub fn new() -> RealtimeConfigBuilder
```
Tokens:
Raw