@softactivate/adk 1.1.0 → 1.2.0

package/dist/types/index.d.ts

@@ -11,16 +11,22 @@ export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, Bef
 export { toA2a } from './a2a/agent_to_a2a.js';
 export type { ToA2aOptions } from './a2a/agent_to_a2a.js';
 export type { ExecutorContext } from './a2a/executor_context.js';
+export { InvocationContext } from './agents/invocation_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
 export { GcsArtifactService } from './artifacts/gcs_artifact_service.js';
 export { getArtifactServiceFromUri } from './artifacts/registry.js';
+export { AgentEngineSandboxCodeExecutor, type AgentEngineSandboxCodeExecutorOptions, } from './code_executors/agent_engine_sandbox_code_executor.js';
+export { CodeExecutionLanguage } from './code_executors/code_execution_utils.js';
 export { UnsafeLocalCodeExecutor, type UnsafeLocalCodeExecutorOptions, } from './code_executors/unsafe_local_code_executor.js';
 export * from './common.js';
 export { DatabaseSessionService } from './sessions/database_session_service.js';
 export { getSessionServiceFromUri } from './sessions/registry.js';
+export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
+export type { VertexAiSessionServiceOptions } from './sessions/vertex_ai_session_service.js';
 export { loadAllSkillsInDir, loadSkillFromDir, validateSkillDir, } from './skills/loader.js';
 export { RunSkillInlineScriptTool } from './tools/skill/run_skill_inline_script_tool.js';
 export { RunSkillScriptTool } from './tools/skill/run_skill_script_tool.js';
+export * from './integrations/agent_registry/agent_registry.js';
 export * from './telemetry/google_cloud.js';
 export * from './telemetry/setup.js';
 export * from './tools/mcp/mcp_session_manager.js';

package/dist/types/integrations/agent_registry/agent_registry.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client, ClientFactory } from '@a2a-js/sdk/client';
+import { RemoteA2AAgent } from '../../a2a/a2a_remote_agent.js';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { AgentRegistrySingleMCPToolset } from './agent_registry_mcp_toolset.js';
+import { AgentInfo, ConnectionUriFilter, ConnectionUriResult, Endpoint, ListAgentsResponse, ListEndpointsResponse, ListMcpServersResponse, McpServer, ProtocolType } from './types.js';
+export * from './agent_registry_mcp_toolset.js';
+export * from './helpers.js';
+export * from './types.js';
+/**
+ * Client for interacting with the Google Cloud Agent Registry service.
+ *
+ * Unlike a standard REST client library, this class provides higher-level
+ * abstractions for ADK integration. It surfaces the agent registry service
+ * methods along with helper methods like `getMcpToolset` and
+ * `getRemoteA2AAgent` that automatically resolve connection details,
+ * manage OAuth authentication schemes, and handle GCP credentials to produce
+ * ready-to-use ADK components.
+ */
+export declare class AgentRegistry {
+    readonly projectId: string;
+    readonly location: string;
+    private readonly basePath;
+    private readonly headerProvider?;
+    private readonly auth;
+    constructor(options: {
+        projectId?: string | null;
+        location?: string | null;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    });
+    /**
+     * Resolves default Google Cloud credentials and returns standard headers.
+     * Automatically caches, fetches, and handles refreshing expired OAuth tokens.
+     * Injects the billing/quota project identifier `x-goog-user-project` if present.
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Helper function to execute HTTP GET requests against the Agent Registry API.
+     * Handles path resolution, search query params compilation, and auth headers fetching.
+     */
+    makeRequest<T = unknown>(path: string, params?: Record<string, string>): Promise<T>;
+    /**
+     * Parses connection interfaces list from registry metadata and returns the first match
+     * corresponding to requested protocol types and binding options.
+     */
+    getConnectionUri(resourceDetails: {
+        interfaces?: Array<{
+            url?: string;
+            protocolBinding?: string;
+        }>;
+        protocols?: Array<{
+            type?: ProtocolType;
+            protocolVersion?: string;
+            interfaces?: Array<{
+                url?: string;
+                protocolBinding?: string;
+            }>;
+        }>;
+    }, filters?: ConnectionUriFilter): ConnectionUriResult;
+    listMcpServers(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListMcpServersResponse>;
+    getMcpServer(name: string): Promise<McpServer>;
+    getMcpToolset(mcpServerName: string, options?: {
+        authScheme?: AuthScheme;
+        authCredential?: AuthCredential;
+        continueUri?: string;
+    }): Promise<AgentRegistrySingleMCPToolset>;
+    listEndpoints(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListEndpointsResponse>;
+    getEndpoint(name: string): Promise<Endpoint>;
+    getModelName(endpointName: string): Promise<string>;
+    listAgents(options?: {
+        filterStr?: string;
+        pageSize?: number;
+        pageToken?: string;
+    }): Promise<ListAgentsResponse>;
+    getAgentInfo(name: string): Promise<AgentInfo>;
+    getRemoteA2AAgent(agentName: string, options?: {
+        client?: Client;
+        clientFactory?: ClientFactory;
+    }): Promise<RemoteA2AAgent>;
+}

package/dist/types/integrations/agent_registry/agent_registry_mcp_toolset.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { BaseTool } from '../../tools/base_tool.js';
+import { BaseToolset, ToolPredicate } from '../../tools/base_toolset.js';
+import { StreamableHTTPConnectionParams } from '../../tools/mcp/mcp_session_manager.js';
+/**
+ * A specialized BaseToolset subclass designed to represent a single registered MCP server.
+ *
+ * Unlike a standard MCPToolset, this class:
+ * 1. Supports a dynamic `headerProvider` to fetch/refresh authorization and custom headers
+ *    immediately before establishing the MCP connection session.
+ * 2. Automatically injects the special `gcp.mcp.server.destination.id` telemetry metadata
+ *    identifier into all resolved tools' custom metadata, allowing downstream execute_tool
+ *    traces to be correctly attributed.
+ */
+export declare class AgentRegistrySingleMCPToolset extends BaseToolset {
+    readonly destinationResourceId?: string;
+    readonly connectionParams: StreamableHTTPConnectionParams;
+    readonly headerProvider?: (context?: ReadonlyContext) => Promise<Record<string, string>> | Record<string, string>;
+    readonly authScheme?: AuthScheme;
+    readonly authCredential?: AuthCredential;
+    constructor(options: {
+        destinationResourceId?: string;
+        connectionParams: StreamableHTTPConnectionParams;
+        toolFilter?: ToolPredicate | string[];
+        prefix?: string;
+        headerProvider?: (context?: ReadonlyContext) => Promise<Record<string, string>> | Record<string, string>;
+        authScheme?: AuthScheme;
+        authCredential?: AuthCredential;
+    });
+    /**
+     * Connects to the underlying MCP server, retrieves tool definitions, prefixes tool names,
+     * and injects destination telemetry metadata.
+     */
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

package/dist/types/integrations/agent_registry/helpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function isGoogleApi(url: string): boolean;
+export declare function cleanName(name: string): string;

package/dist/types/integrations/agent_registry/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AgentCard, TransportProtocol } from '@a2a-js/sdk';
+export declare const AGENT_REGISTRY_BASE_URL = "https://agentregistry.googleapis.com/v1alpha";
+export declare const GCP_MCP_SERVER_DESTINATION_ID = "gcp.mcp.server.destination.id";
+export declare enum ProtocolType {
+    TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
+    A2A_AGENT = "A2A_AGENT",
+    CUSTOM = "CUSTOM"
+}
+export interface Interface {
+    url?: string;
+    protocolBinding?: string;
+}
+export interface Endpoint {
+    name?: string;
+    endpointId?: string;
+    displayName?: string;
+    description?: string;
+    interfaces?: Interface[];
+    createTime?: string;
+    updateTime?: string;
+    attributes?: Record<string, unknown>;
+}
+export interface GcpAuthProviderScheme {
+    type: 'gcpAuthProviderScheme';
+    name: string;
+    scopes?: string[];
+    continueUri?: string;
+}
+export interface McpServer {
+    name?: string;
+    displayName?: string;
+    mcpServerId?: string;
+    interfaces?: Interface[];
+    protocols?: Array<{
+        type?: ProtocolType;
+        protocolVersion?: string;
+        interfaces?: Interface[];
+    }>;
+    [key: string]: unknown;
+}
+export interface Binding {
+    target?: {
+        identifier?: string;
+    };
+    authProviderBinding?: {
+        authProvider?: string;
+    };
+}
+export interface ListBindingsResponse {
+    bindings?: Binding[];
+}
+export interface ListMcpServersResponse {
+    mcpServers?: Array<Record<string, unknown>>;
+    nextPageToken?: string;
+}
+export interface ListEndpointsResponse {
+    endpoints?: Array<Endpoint>;
+    nextPageToken?: string;
+}
+export interface ListAgentsResponse {
+    agents?: Array<Record<string, unknown>>;
+    nextPageToken?: string;
+}
+export interface AgentSkillMetadata {
+    id?: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    examples?: unknown[];
+}
+export interface AgentInfo {
+    displayName?: string;
+    description?: string;
+    version?: string;
+    card?: {
+        type?: string;
+        content?: AgentCard;
+    };
+    interfaces?: Interface[];
+    protocols?: Array<{
+        type?: ProtocolType;
+        protocolVersion?: string;
+        interfaces?: Interface[];
+    }>;
+    skills?: AgentSkillMetadata[];
+    [key: string]: unknown;
+}
+export interface ConnectionUriFilter {
+    protocolType?: ProtocolType;
+    protocolBinding?: string;
+}
+export interface ConnectionUriResult {
+    url?: string;
+    protocolVersion?: string;
+    protocolBinding?: TransportProtocol;
+}

package/dist/types/memory/vertex_ai_memory_bank_service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from '@google-cloud/vertexai';
+import { Event } from '../events/event.js';
+import { Session } from '../sessions/session.js';
+import { BaseMemoryService, SearchMemoryRequest, SearchMemoryResponse } from './base_memory_service.js';
+import { MemoryEntry } from './memory_entry.js';
+export interface VertexAiMemoryBankServiceOptions {
+    projectId?: string;
+    location?: string;
+    agentEngineId: string;
+    expressModeApiKey?: string;
+    client?: Client;
+}
+/**
+ * Implementation of the BaseMemoryService using Vertex AI Memory Bank.
+ */
+export declare class VertexAiMemoryBankService implements BaseMemoryService {
+    private readonly projectId?;
+    private readonly location?;
+    private readonly agentEngineId;
+    private readonly expressModeApiKey?;
+    private readonly memories;
+    constructor(options: VertexAiMemoryBankServiceOptions);
+    addSessionToMemory(session: Session): Promise<void>;
+    /**
+     * Adds events to Vertex AI Memory Bank via memories.generate.
+     */
+    addEventsToMemory(request: {
+        appName: string;
+        userId: string;
+        events: Event[];
+        sessionId?: string;
+        customMetadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Adds explicit memory items using Vertex Memory Bank.
+     */
+    addMemory(request: {
+        appName: string;
+        userId: string;
+        memories: MemoryEntry[];
+        customMetadata?: Record<string, unknown>;
+    }): Promise<void>;
+    searchMemory(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
+    private addEventsToMemoryFromEvents;
+    private addMemoriesViaCreate;
+    private addMemoriesViaGenerateDirectMemoriesSource;
+}

package/dist/types/runner/in_memory_runner.d.ts

@@ -6,8 +6,35 @@
 import { BaseAgent } from '../agents/base_agent.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { Runner } from './runner.js';
+/**
+ * A {@link Runner} pre-configured with in-memory services.
+ *
+ * Suitable for local development, testing, and prototyping. All session,
+ * artifact, and memory data is stored in-process and is not persisted between
+ * runs.
+ *
+ * Example:
+ * ```typescript
+ * const runner = new InMemoryRunner({agent: myAgent});
+ *
+ * for await (const event of runner.runEphemeral({
+ *   userId: 'user1',
+ *   newMessage: {parts: [{text: 'Hello'}]},
+ * })) {
+ *   console.log(event);
+ * }
+ * ```
+ */
 export declare class InMemoryRunner extends Runner {
-    constructor({ agent, appName, plugins, }: {
+    /**
+     * Creates a new InMemoryRunner instance.
+     *
+     * @param params The configuration for the runner.
+     * @param params.agent The root agent to run.
+     * @param params.appName The application name. Defaults to `'InMemoryRunner'`.
+     * @param params.plugins An optional list of plugins.
+     */
+    constructor(params: {
         agent: BaseAgent;
         appName?: string;
         plugins?: BasePlugin[];

package/dist/types/runner/runner.d.ts

@@ -25,10 +25,25 @@ export interface RunnerConfig {
      * The agent to run.
      */
     agent: BaseAgent;
+    /**
+     * An optional list of plugins to apply globally across all agents.
+     */
     plugins?: BasePlugin[];
+    /**
+     * An optional service for storing and retrieving artifacts.
+     */
     artifactService?: BaseArtifactService;
+    /**
+     * The service for managing sessions.
+     */
     sessionService: BaseSessionService;
+    /**
+     * An optional service for storing and querying agent memory.
+     */
     memoryService?: BaseMemoryService;
+    /**
+     * An optional service for managing authentication credentials.
+     */
     credentialService?: BaseCredentialService;
 }
 /**
@@ -42,6 +57,31 @@ declare const RUNNER_SIGNATURE_SYMBOL: unique symbol;
  * @returns True if the object is an instance of Runner, false otherwise.
  */
 export declare function isRunner(obj: unknown): obj is Runner;
+/**
+ * Orchestrates agent execution for a given application.
+ *
+ * The Runner manages the full lifecycle of an agent invocation: it loads the
+ * session, invokes plugin callbacks, runs the root agent, and yields the
+ * resulting events. Use {@link InMemoryRunner} for quick prototyping without
+ * external services.
+ *
+ * Example:
+ * ```typescript
+ * const runner = new Runner({
+ *   appName: 'my_app',
+ *   agent: myAgent,
+ *   sessionService: new InMemorySessionService(),
+ * });
+ *
+ * for await (const event of runner.runAsync({
+ *   userId: 'user1',
+ *   sessionId: 'session1',
+ *   newMessage: {parts: [{text: 'Hello'}]},
+ * })) {
+ *   console.log(event);
+ * }
+ * ```
+ */
 export declare class Runner {
     readonly [RUNNER_SIGNATURE_SYMBOL] = true;
     readonly appName: string;
@@ -51,6 +91,11 @@ export declare class Runner {
     readonly sessionService: BaseSessionService;
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
+    /**
+     * Creates a new Runner instance.
+     *
+     * @param input The configuration for the runner.
+     */
     constructor(input: RunnerConfig);
     /**
      * Runs the agent with a new, ephemeral session.
@@ -66,6 +111,7 @@ export declare class Runner {
         newMessage: Content;
         stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
+        customMetadata?: Record<string, unknown>;
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Runs the agent with the given message, and returns an async generator of
@@ -85,6 +131,7 @@ export declare class Runner {
         stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
         abortSignal?: AbortSignal;
+        customMetadata?: Record<string, unknown>;
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Saves artifacts from the message parts and replaces the inline data with

package/dist/types/sessions/base_session_service.d.ts

@@ -48,6 +48,14 @@ export interface ListSessionsRequest {
     appName: string;
     /** The ID of the user. */
     userId: string;
+    /** Maximum number of sessions to return. */
+    limit?: number;
+    /** Zero-based index of the first session to return. Ignored if `page` is set. */
+    offset?: number;
+    /** 1-based page number. Requires `limit`. Takes precedence over `offset`. */
+    page?: number;
+    /** Sort direction by last update time. No ordering is applied if omitted. */
+    order?: 'asc' | 'desc';
 }
 /**
  * The parameters for `deleteSession`.
@@ -73,10 +81,20 @@ export interface AppendEventRequest {
  * The response of listing sessions.
  *
  * The events and states are not set within each Session object.
+ * When no pagination params were requested, `page` is 1, `limit` equals
+ * `totalItems`, and `totalPages` is 1 (or 0 when there are no sessions).
  */
 export interface ListSessionsResponse {
     /** A list of sessions. */
     sessions: Session[];
+    /** Current page number (1-based). */
+    page: number;
+    /** Page size used. Equals `totalItems` when no limit was requested. */
+    limit: number;
+    /** Total number of sessions matching the request. */
+    totalItems: number;
+    /** Total number of pages. */
+    totalPages: number;
 }
 /**
  * Base class for session services.

package/dist/types/sessions/database_session_service.d.ts

@@ -26,7 +26,7 @@ export declare class DatabaseSessionService extends BaseSessionService {
     init(): Promise<void>;
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
     appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }

package/dist/types/sessions/in_memory_session_service.d.ts

@@ -24,7 +24,7 @@ export declare class InMemorySessionService extends BaseSessionService {
     private appState;
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
     getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
     deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
     appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }

package/dist/types/sessions/vertex_ai_session_service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Sessions } from '@google-cloud/vertexai/build/src/genai/sessions.js';
+import { Event } from '../events/event.js';
+import { AppendEventRequest, BaseSessionService, CreateSessionRequest, DeleteSessionRequest, GetSessionRequest, ListSessionsRequest, ListSessionsResponse } from './base_session_service.js';
+import { Session } from './session.js';
+/**
+ * Checks if the given URI is a Vertex AI session service URI.
+ */
+export declare function isVertexAiConnectionString(uri?: string): boolean;
+export interface VertexAiSessionServiceOptions {
+    projectId?: string;
+    location?: string;
+    agentEngineId?: string;
+    expressModeApiKey?: string;
+    sessions?: Sessions;
+}
+/**
+ * A session service implementation that integrates with Vertex AI Agent Engine Sessions.
+ */
+export declare class VertexAiSessionService extends BaseSessionService {
+    private sessions;
+    private agentEngineId?;
+    private expressModeApiKey?;
+    private projectId?;
+    private location?;
+    constructor(options: VertexAiSessionServiceOptions);
+    private getReasoningEngineId;
+    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    deleteSession({ appName, userId: _userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
+}

package/dist/types/tools/exit_loop_tool.d.ts

@@ -14,8 +14,17 @@ import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
  *
  */
 export declare class ExitLoopTool extends BaseTool {
+    /** Creates an ExitLoopTool with its fixed name and description. */
     constructor();
+    /** Returns the function declaration for this tool. */
     _getDeclaration(): FunctionDeclaration;
+    /**
+     * Sets `escalate` and `skipSummarization` on the event actions, signalling
+     * the {@link LoopAgent} to stop iterating.
+     *
+     * @param request The tool request containing the current tool context.
+     * @returns An empty string response.
+     */
     runAsync({ toolContext, }: RunAsyncToolRequest): Promise<unknown>;
 }
 /**

package/dist/types/tools/function_tool.d.ts

@@ -12,7 +12,14 @@ import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
  * Input parameters of the function tool.
  */
 export type ToolInputParameters = z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape> | Schema | undefined;
+/**
+ * The arguments passed to the function tool's `execute` callback, inferred
+ * from the `parameters` schema type.
+ */
 export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends z3.ZodObject<infer T, infer U, infer V> ? z3.infer<z3.ZodObject<T, U, V>> : TParameters extends z4.ZodObject<infer T> ? z4.infer<z4.ZodObject<T>> : TParameters extends Schema ? unknown : string;
+/**
+ * The signature of the user-provided function executed by a {@link FunctionTool}.
+ */
 export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: Context) => Promise<unknown> | unknown;
 /**
  * The configuration options for creating a function-based tool.
@@ -40,6 +47,14 @@ declare const FUNCTION_TOOL_SIGNATURE_SYMBOL: unique symbol;
  * @returns True if the object is an instance of BaseTool, false otherwise.
  */
 export declare function isFunctionTool(obj: unknown): obj is FunctionTool;
+/**
+ * A tool that wraps a user-defined function, making it callable by an LLM.
+ *
+ * The function's name, description, and parameter schema are exposed to the
+ * model as a function declaration. When the model requests a call, the
+ * framework validates the arguments and invokes the user-provided `execute`
+ * callback.
+ */
 export declare class FunctionTool<TParameters extends ToolInputParameters = undefined> extends BaseTool {
     /** A unique symbol to identify ADK function tool class. */
     readonly [FUNCTION_TOOL_SIGNATURE_SYMBOL] = true;
@@ -51,11 +66,16 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      */
     constructor(options: ToolOptions<TParameters>);
     /**
-     * Provide a schema for the function.
+     * Returns the function declaration derived from the tool's name, description,
+     * and parameter schema.
      */
     _getDeclaration(): FunctionDeclaration;
     /**
-     * Logic for running the tool.
+     * Validates the model-provided arguments against the parameter schema and
+     * invokes the user-defined `execute` function.
+     *
+     * @param req The tool request containing arguments and tool context.
+     * @returns A promise resolving to the function's return value.
      */
     runAsync(req: RunAsyncToolRequest): Promise<unknown>;
 }

package/dist/types/tools/long_running_tool.d.ts

@@ -5,6 +5,15 @@
  */
 import { FunctionDeclaration } from '@google/genai';
 import { FunctionTool, ToolInputParameters, ToolOptions } from './function_tool.js';
+/**
+ * A {@link FunctionTool} for long-running operations whose result is returned
+ * asynchronously.
+ *
+ * The framework invokes the user-provided function and delivers the response
+ * back to the model once it completes, identified by the `function_call_id`.
+ * The model is also instructed not to re-invoke the tool while a call is
+ * already in flight.
+ */
 export declare class LongRunningFunctionTool<TParameters extends ToolInputParameters = undefined> extends FunctionTool<TParameters> {
     /**
      * The constructor acts as the user-friendly factory.
@@ -12,7 +21,8 @@ export declare class LongRunningFunctionTool<TParameters extends ToolInputParame
      */
     constructor(options: ToolOptions<TParameters>);
     /**
-     * Provide a schema for the function.
+     * Returns the function declaration with an appended instruction warning the
+     * model not to re-invoke the tool while it is still running.
      */
     _getDeclaration(): FunctionDeclaration;
 }

package/dist/types/tools/mcp/mcp_session_manager.d.ts

@@ -59,6 +59,9 @@ export type MCPConnectionParams = StdioConnectionParams | StreamableHTTPConnecti
  */
 export declare class MCPSessionManager {
     private readonly connectionParams;
+    private readonly activeSessions;
     constructor(connectionParams: MCPConnectionParams);
     createSession(): Promise<Client>;
+    closeSession(client: Client): Promise<void>;
+    getActiveSessions(): Client[];
 }

package/dist/types/tools/openapi_tool/auth/auth_helpers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { AuthCredential } from '../../../auth/auth_credential.js';
+/**
+ * Applies the given credential to the request headers and URL.
+ *
+ * @param url The target URL.
+ * @param headers The request headers.
+ * @param credential The auth credential.
+ * @param authScheme The auth scheme from OpenAPI spec.
+ * @returns The updated URL (if modified by query params).
+ */
+export declare function applyCredential(url: string, headers: Record<string, string>, credential?: AuthCredential, authScheme?: OpenAPIV3.SecuritySchemeObject): string;
+/**
+ * Helper to create a simple API Key auth scheme.
+ */
+export declare function createApiKeyScheme(name: string, inLocation: 'header' | 'query' | 'cookie'): OpenAPIV3.SecuritySchemeObject;
+/**
+ * Helper to create a simple Bearer Token auth scheme.
+ */
+export declare function createBearerScheme(): OpenAPIV3.SecuritySchemeObject;