Struct T 

pub struct T;

The T namespace — static factory methods for tool composition.

Implementations

impl T

pub fn function(f: Arc<dyn ToolFunction>) -> ToolComposite

Register a function tool.

pub fn google_search() -> ToolComposite

Add Google Search built-in tool.

pub fn url_context() -> ToolComposite

Add URL context built-in tool.

pub fn code_execution() -> ToolComposite

Add code execution built-in tool.

pub fn simple<F, Fut>( name: impl Into<String>, description: impl Into<String>, f: F, ) -> ToolComposite

where F: Fn(Value) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Value, ToolError>> + Send + 'static,

A tool that takes no parameters, from a name, description, and async closure.

The declaration the model sees has no parameters, so the model calls it with {}. For a tool with arguments, use #[tool] on a documented async fn, or T::typed when the tool must capture something (a client, a pool) from its environment.

pub fn contextual<F, Fut>( name: impl Into<String>, description: impl Into<String>, f: F, ) -> ToolComposite

where F: Fn(Value, ToolContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Value, ToolError>> + Send + 'static,

A tool from a closure that also receives the call’s ToolContext: the session state, the call id, and a cancellation token that fires on barge-in.

use gemini_adk_fluent_rs::prelude::*;

let balance = T::contextual("balance", "The caller's balance", |_args, ctx| async move {
    let account: String = ctx.state.get("account_id").unwrap_or_default();
    Ok(serde_json::json!({ "account": account, "cents": 1200 }))
});

pub fn typed<A, F, Fut>( name: impl Into<String>, description: impl Into<String>, f: F, ) -> ToolComposite

where A: DeserializeOwned + JsonSchema + Send + Sync + 'static, F: Fn(A) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Value, ToolError>> + Send + 'static,

A tool whose arguments are the type A, from a closure.

A’s JSON Schema (through wire_schema) is the declaration, and doc comments on its fields describe the parameters. Reach for this over #[tool] when the tool needs state from its environment:

use gemini_adk_fluent_rs::prelude::*;
use std::sync::Arc;

#[derive(serde::Deserialize, schemars::JsonSchema)]
struct Lookup {
    /// The customer's account id.
    account: String,
}

let accounts = Arc::new(vec![("a-1".to_string(), 120)]);
let balance = T::typed("balance", "Look up an account balance", move |args: Lookup| {
    let accounts = accounts.clone();
    async move {
        let found = accounts.iter().find(|(id, _)| *id == args.account);
        Ok(serde_json::json!({ "balance": found.map(|(_, b)| *b) }))
    }
});
AgentBuilder::new("support").tools(balance);

pub fn fn_tool<F, Fut>( name: impl Into<String>, description: impl Into<String>, f: F, ) -> ToolComposite

where F: Fn(Value) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Value, ToolError>> + Send + 'static,

👎Deprecated since 2.1.0:

use T::simple (no parameters), T::typed or #[tool]

Alias for simple — matches upstream Python T.fn().

Named fn_tool because fn is a reserved keyword in Rust.

pub fn confirm(tool: impl Into<ToolComposite>, message: &str) -> ToolComposite

Require user confirmation before each function tool in the composite runs.

The confirmation flag is recorded on the tool’s ToolPolicy and surfaced to the runtime via PolicyTool::requires_confirmation — it is never silently dropped. The message becomes the confirmation hint. Built-in and placeholder entries are left unchanged.

pub fn timeout( tool: impl Into<ToolComposite>, duration: Duration, ) -> ToolComposite

Bound each function tool in the composite by a timeout.

At dispatch the tool’s future is raced against the duration; on elapse the call returns ToolError::Timeout. Built-in and placeholder entries are left unchanged.

pub fn cached(tool: impl Into<ToolComposite>) -> ToolComposite

Memoize each function tool’s successful results.

Results are cached by (tool name, canonical-JSON args); repeat calls with identical arguments return the cached value without re-invoking the tool. Errors are not cached. Built-in/placeholder entries are left unchanged.

pub fn toolset(tools: Vec<Arc<dyn ToolFunction>>) -> ToolComposite

Combine multiple tool functions into a single composite.

pub fn agent( name: impl Into<String>, description: impl Into<String>, agent: impl TextAgent + 'static, ) -> ToolComposite

Wrap a TextAgent as a tool (shorthand for creating an agent tool entry).

When invoked, the agent runs via BaseLlm::generate() and returns its text output as the tool result. State is shared with the parent session.

pub fn mcp(params: impl Into<String>) -> ToolComposite

Create an MCP (Model Context Protocol) toolset entry.

params is the connection string (e.g. a URL or command) used to establish the MCP session at runtime.

pub fn mock( name: impl Into<String>, description: impl Into<String>, response: Value, ) -> ToolComposite

Create a mock tool that returns a fixed response.

Useful for testing and prototyping without real tool implementations.

pub fn schema(name: impl Into<String>, schema: Value) -> ToolComposite

Create a schema-defined tool (placeholder/marker).

The tool’s parameters are defined by the given JSON Schema value.

pub fn transform<F, Fut>(tool: ToolComposite, f: F) -> ToolComposite

where F: Fn(Value) -> Fut + Send + Sync + 'static, Fut: Future<Output = Value> + Send + 'static,

Wrap each tool entry in a composite with a result transformer.

The transformer function is applied to the tool’s output value before it is returned to the model.