Trait ToolContext 

pub trait ToolContext: CallbackContext {
    // Required methods
    fn function_call_id(&self) -> &str;
    fn actions(&self) -> EventActions;
    fn set_actions(&self, actions: EventActions);
    fn search_memory<'life0, 'life1, 'async_trait>(
        &'life0 self,
        query: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, AdkError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;

    // Provided methods
    fn emit_progress<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _stream: &'life1 str,
        _chunk: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn user_scopes(&self) -> Vec<String> { ... }
    fn get_secret<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _name: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, AdkError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn get_secret_for_purpose<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        name: &'life1 str,
        purpose: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>, AdkError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             Self: Sync + 'async_trait { ... }
}

Core traits and types.

Always available regardless of feature flags. Includes:

• Agent - The fundamental trait for all agents
• Tool / Toolset - For extending agents with capabilities
• Session / State - For managing conversation context
• Event - For streaming agent responses
• AdkError / Result - Unified error handling Context available to tools during execution.

Extends CallbackContext with tool-specific operations like accessing the function call ID, managing event actions, and searching memory.

Required Methods

fn function_call_id(&self) -> &str

Returns the function call ID for this tool invocation.

fn actions(&self) -> EventActions

Get the current event actions. Returns an owned copy for thread safety.

fn set_actions(&self, actions: EventActions)

Set the event actions (e.g., to trigger escalation or skip summarization).

fn search_memory<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, AdkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Searches memory for entries matching the query.

Provided Methods

fn emit_progress<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _stream: &'life1 str, _chunk: &'life2 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Emit streaming progress output during long-running tool execution.

Tools call this to push intermediate stdout/stderr to the UI layer as it arrives, rather than waiting for the tool to finish. This enables streaming terminal output for shell commands, build logs, etc.

Arguments

• stream - The output stream: "stdout", "stderr", or a custom label
• chunk - The text chunk to emit

Example

// Inside a tool's execute() method:
ctx.emit_progress("stdout", "Compiling project...\n").await;
ctx.emit_progress("stdout", "Build successful!\n").await;
ctx.emit_progress("stderr", "warning: unused variable\n").await;

The default implementation is a no-op. Runners and UI layers that support streaming output override this to forward chunks to the client.

fn user_scopes(&self) -> Vec<String>

Returns the scopes granted to the current user for this invocation.

Implementations may resolve scopes from session state, JWT claims, or an external identity provider. The default returns an empty set (no scopes granted), which means scope-protected tools will be denied unless the implementation is overridden.

fn get_secret<'life0, 'life1, 'async_trait>( &'life0 self, _name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, AdkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Retrieve a secret by name from the configured secret provider.

Returns Ok(Some(value)) if a secret provider is configured and the secret exists, Ok(None) if no secret provider is configured, or an error if the provider fails.

Example

async fn use_secret(ctx: &dyn ToolContext) -> adk_core::Result<()> {
    if let Some(api_key) = ctx.get_secret("slack-bot-token").await? {
        // use the secret
    }
    Ok(())
}

fn get_secret_for_purpose<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, name: &'life1 str, purpose: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, AdkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Resolves a secret, stating why it is needed.

The tool identity is added by the framework, not taken from the tool, so a purpose is the only part a tool contributes. An authorizing SecretService sees both.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl ToolContext for SimpleToolContext