@google/adk 2.2.1 → 2.4.0

package/dist/types/tools/google_api_tool/googleapi_to_openapi_converter.d.ts

@@ -0,0 +1,165 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+/**
+ * Scope metadata in a Google API Discovery document.
+ */
+export interface GoogleApiOAuth2Scope {
+    description?: string;
+}
+/**
+ * Parameter metadata in a Google API Discovery document.
+ */
+export interface GoogleApiParameter {
+    type?: string;
+    description?: string;
+    required?: boolean;
+    location?: string;
+    format?: string;
+    enum?: string[];
+    default?: unknown;
+    pattern?: string;
+    minimum?: string;
+    maximum?: string;
+}
+/**
+ * Schema definition in a Google API Discovery document.
+ */
+export interface GoogleApiSchema {
+    type?: string;
+    description?: string;
+    format?: string;
+    enum?: string[];
+    pattern?: string;
+    default?: unknown;
+    required?: boolean;
+    $ref?: string;
+    properties?: Record<string, GoogleApiSchema>;
+    items?: GoogleApiSchema;
+    minimum?: string;
+    maximum?: string;
+    location?: string;
+}
+/**
+ * Method definition in a Google API Discovery document.
+ */
+export interface GoogleApiMethod {
+    id?: string;
+    path?: string;
+    flatPath?: string;
+    httpMethod?: string;
+    description?: string;
+    parameters?: Record<string, GoogleApiParameter>;
+    request?: {
+        $ref?: string;
+    };
+    response?: {
+        $ref?: string;
+    };
+    scopes?: string[];
+}
+/**
+ * Resource definition in a Google API Discovery document.
+ */
+export interface GoogleApiResource {
+    methods?: Record<string, GoogleApiMethod>;
+    resources?: Record<string, GoogleApiResource>;
+}
+/**
+ * Root structure of a Google API Discovery REST specification.
+ */
+export interface GoogleApiSpec {
+    kind?: string;
+    id?: string;
+    name?: string;
+    version?: string;
+    title?: string;
+    description?: string;
+    documentationLink?: string;
+    protocol?: string;
+    rootUrl?: string;
+    servicePath?: string;
+    auth?: {
+        oauth2?: {
+            scopes?: Record<string, GoogleApiOAuth2Scope>;
+        };
+    };
+    schemas?: Record<string, GoogleApiSchema>;
+    resources?: Record<string, GoogleApiResource>;
+    methods?: Record<string, GoogleApiMethod>;
+}
+/**
+ * Converts a Google Discovery schema reference (`#Name` or `Name`) to an
+ * OpenAPI v3 component schema reference (`#/components/schemas/Name`).
+ */
+export declare function normalizeGoogleSchemaRef(ref: string): string;
+/**
+ * Populates the OpenAPI `info` and optional `externalDocs` sections from a
+ * Google API Discovery document.
+ */
+export declare function convertInfo(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document, apiName: string, apiVersion: string): void;
+/**
+ * Populates the OpenAPI `servers` list from the Google Discovery `rootUrl` and
+ * `servicePath`.
+ */
+export declare function convertServers(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document, apiName: string, apiVersion: string): void;
+/**
+ * Populates `components.securitySchemes` and top-level `security` from a
+ * Google API Discovery document.
+ */
+export declare function convertSecuritySchemes(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Recursively converts a Google API Discovery schema object to an OpenAPI v3
+ * schema or reference object.
+ */
+export declare function convertSchemaObject(schemaDef: GoogleApiSchema): OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+/**
+ * Populates `components.schemas` from a Google API Discovery document.
+ */
+export declare function convertSchemas(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Extracts `{param}` and `{+param}` placeholder names from a URL path.
+ */
+export declare function extractPathParameters(path: string): string[];
+/**
+ * Converts a Google API parameter definition into an OpenAPI parameter schema.
+ */
+export declare function convertParameterSchema(paramData: GoogleApiParameter): OpenAPIV3.SchemaObject;
+/**
+ * Converts a Google API method definition into an OpenAPI operation object.
+ */
+export declare function convertOperation(methodData: GoogleApiMethod, pathParams: string[]): OpenAPIV3.OperationObject;
+/**
+ * Converts a dictionary of Google API methods into OpenAPI path operations.
+ */
+export declare function convertMethods(methods: Record<string, GoogleApiMethod>, _resourcePath: string, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Recursively converts nested Google API resources and their methods into
+ * OpenAPI paths.
+ */
+export declare function convertResources(resources: Record<string, GoogleApiResource>, openapiSpec: OpenAPIV3.Document, parentPath?: string): void;
+/**
+ * Converts Google API Discovery documents into OpenAPI v3.0.0 specifications.
+ */
+export declare class GoogleApiToOpenApiConverter {
+    private readonly apiName;
+    private readonly apiVersion;
+    private googleApiSpec;
+    private openapiSpec;
+    constructor(apiName: string, apiVersion: string);
+    /**
+     * Fetches the Google API specification from the Google Discovery service.
+     */
+    fetchGoogleApiSpec(): Promise<void>;
+    /**
+     * Converts the Google API specification into OpenAPI v3 format.
+     */
+    convert(): Promise<OpenAPIV3.Document>;
+    /**
+     * Saves the converted OpenAPI specification to a JSON file.
+     */
+    saveOpenapiSpec(outputPath: string): void;
+}

package/dist/types/tools/google_api_tool/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { GoogleApiTool, isGoogleApiTool } from './google_api_tool.js';
+export type { GoogleApiToolOptions } from './google_api_tool.js';
+export { GoogleApiToolset, isGoogleApiToolset } from './google_api_toolset.js';
+export type { GoogleApiToolsetOptions } from './google_api_toolset.js';
+export { BigQueryToolset, CalendarToolset, DocsToolset, GmailToolset, SheetsToolset, SlidesToolset, YoutubeToolset, } from './google_api_toolsets.js';

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

@@ -3,8 +3,21 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { FunctionDeclaration } from '@google/genai';
+import { FunctionDeclaration, Part } from '@google/genai';
 import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * Returns a part that the model can read for the given artifact.
+ *
+ * Parts without inline data, and inline data that Gemini accepts (images,
+ * audio, video and PDF), are returned as they are. Other inline data becomes a
+ * text part: the decoded content for text-like types, and a placeholder for
+ * binary or missing data.
+ *
+ * @param artifact The artifact to convert.
+ * @param artifactName The artifact name used in the placeholder text.
+ * @return The artifact itself, or a text part that replaces it.
+ */
+export declare function asSafePartForLlm(artifact: Part, artifactName: string): Part;
 /**
  * A tool that loads the artifacts and adds them to the session.
  */

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

@@ -4,14 +4,36 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FunctionDeclaration } from '@google/genai';
+import type { MemoryEntry } from '../memory/memory_entry.js';
 import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * Configuration options for {@link LoadMemoryTool}.
+ */
+export interface LoadMemoryToolOptions {
+    /**
+     * Whether to flatten memory content into space-separated text strings.
+     *
+     * @deprecated Set `textOnlyContent: true` only to retain legacy string content. The default is `false`, returning complete {@link MemoryEntry} objects. This option will be removed in a future release.
+     */
+    readonly textOnlyContent?: boolean;
+}
+/**
+ * Response returned by {@link LoadMemoryTool}.
+ *
+ * When {@link LoadMemoryToolOptions.textOnlyContent} is enabled, entries contain
+ * string content instead of a `Content` object.
+ */
+export interface LoadMemoryResponse {
+    memories: MemoryEntry[];
+}
 /**
  * A tool that loads the memory for the current user.
  *
  * NOTE: Currently this tool only uses text part from the memory.
  */
 export declare class LoadMemoryTool extends BaseTool {
-    constructor();
+    private readonly textOnlyContent;
+    constructor(options?: LoadMemoryToolOptions);
     _getDeclaration(): FunctionDeclaration | undefined;
     runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
     processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;

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

@@ -7,6 +7,9 @@
  * `@google/adk/tools/mcp` subpath: the MCP tools only, without the full ADK
  * barrel. Also re-exported from `@google/adk`.
  */
+export { toGeminiSchema } from '../../utils/gemini_schema_util.js';
+export type { MCPToolSchema } from '../../utils/gemini_schema_util.js';
+export { genaiSchemaToJsonSchema } from '../../utils/genai_schema_to_json.js';
 export * from './load_mcp_resource_tool.js';
 export * from './mcp_session_manager.js';
 export * from './mcp_tool.js';

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

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import type { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 /**
@@ -40,10 +41,42 @@ export interface StreamableHTTPConnectionParams {
     terminateOnClose?: boolean;
     transportOptions?: StreamableHTTPClientTransportOptions;
 }
+/**
+ * Defines the parameters for establishing a connection to an MCP server over
+ * the HTTP+SSE transport.
+ *
+ * Usage:
+ *  const connectionParams: SseConnectionParams = {
+ *    type: 'SseConnectionParams',
+ *    url: 'http://localhost:8090/sse'
+ *  };
+ */
+export interface SseConnectionParams {
+    type: 'SseConnectionParams';
+    url: string;
+    /**
+     * @deprecated
+     * Use transportOptions.requestInit.headers instead.
+     * This field will be ignored if transportOptions is provided even if no headers are specified in transportOptions.
+     */
+    header?: Record<string, unknown>;
+    /**
+     * HTTP headers to send with the SSE and POST requests when
+     * `transportOptions.requestInit` is not provided.
+     */
+    headers?: Record<string, unknown>;
+    timeout?: number;
+    sseReadTimeout?: number;
+    transportOptions?: SSEClientTransportOptions;
+}
+/**
+ * Alias for {@link SseConnectionParams}.
+ */
+export type SseServerParams = SseConnectionParams;
 /**
  * A union of all supported MCP connection parameter types.
  */
-export type MCPConnectionParams = StdioConnectionParams | StreamableHTTPConnectionParams;
+export type MCPConnectionParams = StdioConnectionParams | SseConnectionParams | StreamableHTTPConnectionParams;
 /**
  * Manages Model Context Protocol (MCP) client sessions.
  *

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

@@ -8,6 +8,7 @@ import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset, ToolPredicate } from '../base_toolset.js';
 import { MCPConnectionParams } from './mcp_session_manager.js';
+export type { SseConnectionParams, SseServerParams, } from './mcp_session_manager.js';
 /**
  * A toolset that dynamically discovers and provides tools from a Model Context
  * Protocol (MCP) server.
@@ -37,6 +38,20 @@ import { MCPConnectionParams } from './mcp_session_manager.js';
  * const mcpToolset = new MCPToolset(connectionParams);
  * const tools = await mcpToolset.getTools();
  * ```
+ *
+ * @example
+ * ```ts
+ * import {MCPToolset} from '@google/adk';
+ * import type {SseConnectionParams} from '@google/adk';
+ *
+ * const sseParams: SseConnectionParams = {
+ *   type: 'SseConnectionParams',
+ *   url: 'http://localhost:8090/sse',
+ * };
+ *
+ * const sseToolset = new MCPToolset(sseParams);
+ * const sseTools = await sseToolset.getTools();
+ * ```
  */
 export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;

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

@@ -12,6 +12,25 @@ import { ApiParameter } from '../openapi_spec_parser/operation_parser.js';
  * model-supplied.
  */
 export declare const INTERNAL_AUTH_PREFIX = "_auth_prefix_vaf_";
+/**
+ * The client settings an application registers with an OpenID Connect
+ * provider.
+ */
+export interface OpenIdConfig {
+    /** The client ID the provider issued to the application. */
+    clientId: string;
+    /** The provider's authorization endpoint. */
+    authUri: string;
+    /** The provider's token endpoint. */
+    tokenUri: string;
+    /** The client secret the provider issued to the application. */
+    clientSecret: string;
+    /**
+     * Where the provider sends the user after sign-in. When unset, the provider
+     * uses the redirect URI registered for the client.
+     */
+    redirectUri?: string;
+}
 /**
  * Applies the given credential to the request headers and URL.
  *

package/dist/types/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.d.ts

@@ -31,13 +31,30 @@ export type CustomCredentialExchangers = Partial<Record<AuthCredentialTypes, Bas
  * });
  */
 export declare class AutoAuthCredentialExchanger implements BaseCredentialExchanger {
-    private exchangers;
+    /**
+     * The exchanger used for each auth credential type.
+     *
+     * By default `OAUTH2` and `OPEN_ID_CONNECT` run
+     * {@link OAuth2CredentialExchanger} and convert any access token with
+     * {@link generateAuthToken}, and `SERVICE_ACCOUNT` maps to a
+     * {@link ServiceAccountCredentialExchanger}, with any custom exchangers from
+     * the constructor merged over them. The map is live: an entry added or
+     * replaced after construction is used by the next {@link exchange} call.
+     */
+    readonly exchangers: Map<AuthCredentialTypes, BaseCredentialExchanger>;
     /**
      * @param customExchangers - Optional exchangers that add to or override the
      *   built-in ones. The key is the auth credential type; the value is the
      *   exchanger instance to use for that type.
      */
     constructor(customExchangers?: CustomCredentialExchangers);
+    /**
+     * Exchanges the credential with the exchanger registered for its type.
+     *
+     * @returns The credential unchanged, with `wasExchanged: false`, when no
+     *     exchanger is registered for its type. Otherwise the delegate's result,
+     *     or `null` when there is no credential at all.
+     */
     exchange(params: {
         authScheme?: AuthScheme;
         authCredential: AuthCredential;

package/dist/types/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.d.ts

@@ -28,8 +28,20 @@ export interface ParsedOperation {
 }
 export declare class OpenApiSpecParser {
     private preservePropertyNames;
+    private unconstrainedObjectBodyAsParameter;
+    /**
+     * @param options.preservePropertyNames Keeps the original parameter and
+     *     function names instead of converting them to snake_case.
+     * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+     *     parameter named `body` when an object request body schema has no
+     *     properties. Defaults to `false`.
+     *     @deprecated Retained for backwards compatibility; empty object schemas
+     *     produce no parameters by default. This option will be removed in a
+     *     future release.
+     */
     constructor(options?: {
         preservePropertyNames?: boolean;
+        unconstrainedObjectBodyAsParameter?: boolean;
     });
     /**
      * Parses an OpenAPI specification document and extracts a list of operations.

package/dist/types/tools/openapi_tool/openapi_spec_parser/operation_parser.d.ts

@@ -22,6 +22,7 @@ export declare class OperationParser {
     private params;
     private returnValue?;
     private preservePropertyNames;
+    private unconstrainedObjectBodyAsParameter;
     private readonly operation;
     /**
      * @param operation The operation to parse. A string is parsed as JSON, and a
@@ -30,10 +31,17 @@ export declare class OperationParser {
      *     function names instead of converting them to snake_case.
      * @param options.shouldParse Whether to parse the operation during
      *     construction. Defaults to `true`.
+     * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+     *     parameter named `body` when an object request body schema has no
+     *     properties. Defaults to `false`.
+     *     @deprecated Retained for backwards compatibility; empty object schemas
+     *     produce no parameters by default. This option will be removed in a
+     *     future release.
      */
     constructor(operation: OpenAPIV3.OperationObject | Record<string, unknown> | string, options?: {
         preservePropertyNames?: boolean;
         shouldParse?: boolean;
+        unconstrainedObjectBodyAsParameter?: boolean;
     });
     /**
      * Builds a parser from parameters that were already parsed, without walking

package/dist/types/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.d.ts

@@ -71,7 +71,8 @@ export declare class ToolAuthHandler {
     static fromToolContext(context: Context, authScheme?: AuthScheme, authCredential?: AuthCredential, options?: ToolAuthHandlerOptions): ToolAuthHandler;
     prepareAuthCredentials(): Promise<AuthPreparationResult>;
     /**
-     * Exchanges `credential`, or returns `undefined` when the exchange failed.
+     * Exchanges `credential`, or returns `undefined` when the exchange failed or
+     * produced an interactive credential that still holds no token.
      *
      * An exchange failure is transient far more often than it is fatal, so it
      * becomes a `pending` result the client can resume from rather than an

package/dist/types/tools/openapi_tool/openapi_toolset.d.ts

@@ -22,6 +22,11 @@ export declare class OpenAPIToolset extends BaseToolset {
         authCredential?: AuthCredential;
         credentialKey?: string;
         headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+        /**
+         * @deprecated Emits a whole-body parameter for unconstrained object schemas.
+         * Will be removed in a future release.
+         */
+        unconstrainedObjectBodyAsParameter?: boolean;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     /**

package/dist/types/tools/openapi_tool/rest_api_tool.d.ts

@@ -41,6 +41,11 @@ export declare class RestApiTool extends BaseTool {
         headerProvider?: (context: ReadonlyContext) => Record<string, string>;
         credentialKey?: string;
         operationParser?: OperationParser;
+        /**
+         * @deprecated Emits a whole-body parameter for unconstrained object schemas.
+         * Will be removed in a future release.
+         */
+        unconstrainedObjectBodyAsParameter?: boolean;
     });
     configureAuthScheme(authScheme: OpenAPIV3.SecuritySchemeObject): void;
     configureAuthCredential(authCredential: AuthCredential): void;
@@ -69,6 +74,11 @@ export declare function createRestApiTool(parsed: ParsedOperationInput, options?
     preservePropertyNames?: boolean;
     headerProvider?: (context: ReadonlyContext) => Record<string, string>;
     credentialKey?: string;
+    /**
+     * @deprecated Emits a whole-body parameter for unconstrained object schemas.
+     * Will be removed in a future release.
+     */
+    unconstrainedObjectBodyAsParameter?: boolean;
 }): RestApiTool;
 /**
  * Builds a `RestApiTool` from the JSON string form of a parsed operation.

package/dist/types/tools/retrieval/base_retrieval_tool.d.ts

@@ -5,6 +5,18 @@
  */
 import { FunctionDeclaration } from '@google/genai';
 import { BaseTool } from '../base_tool.js';
+/**
+ * Unique symbol to identify `BaseRetrievalTool` classes.
+ * Defined once and shared by all `BaseRetrievalTool` instances.
+ */
+declare const BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of `BaseRetrievalTool`.
+ *
+ * @param obj The object to check.
+ * @returns True if the object is an instance of `BaseRetrievalTool`, false otherwise.
+ */
+export declare function isBaseRetrievalTool(obj: unknown): obj is BaseRetrievalTool;
 /**
  * The base class for tools that answer a single natural-language query by
  * retrieving text the framework fetches itself.
@@ -17,5 +29,8 @@ import { BaseTool } from '../base_tool.js';
  * `src/google/adk/tools/retrieval/base_retrieval_tool.py` at ref `v0.1.0`.
  */
 export declare abstract class BaseRetrievalTool extends BaseTool {
+    /** Unique symbol to identify `BaseRetrievalTool` class. */
+    readonly [BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL] = true;
     _getDeclaration(): FunctionDeclaration;
 }
+export {};

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

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { BaseTool } from './base_tool.js';
+import { BaseToolset, ToolPredicate } from './base_toolset.js';
+import { ToolInputParameters } from './function_tool.js';
+/**
+ * Structural interface for a tool loaded from a Toolbox client.
+ */
+export interface ToolboxToolLike {
+    /**
+     * The name of the tool.
+     */
+    name?: string;
+    /**
+     * The description of the tool.
+     */
+    description?: string;
+    /**
+     * Optional parameter schema for the tool.
+     */
+    parameters?: ToolInputParameters;
+    /**
+     * Executes the tool with the given arguments.
+     */
+    execute?(...args: never[]): unknown | Promise<unknown>;
+}
+/**
+ * Options forwarded to a Toolbox client when loading a tool or toolset.
+ */
+export interface ToolboxLoadOptions {
+    /**
+     * Mapping of authentication service names to callables that return the
+     * corresponding authentication token.
+     */
+    authTokenGetters?: Record<string, () => string | Promise<string>>;
+    /**
+     * Mapping of parameter names to bind to fixed values or callables that
+     * produce values as needed.
+     */
+    boundParams?: Record<string, unknown>;
+}
+/**
+ * Structural interface for an asynchronous or synchronous Toolbox client
+ * instance used by {@link ToolboxToolset}.
+ */
+export interface ToolboxToolsetClientLike {
+    /**
+     * Loads a single tool by name (camelCase convention).
+     */
+    loadTool?: (toolName: string, options?: ToolboxLoadOptions) => BaseTool | ToolboxToolLike | ((...args: never[]) => unknown) | Promise<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>;
+    /**
+     * Loads a single tool by name (snake_case convention).
+     */
+    load_tool?: (toolName: string, options?: ToolboxLoadOptions) => BaseTool | ToolboxToolLike | ((...args: never[]) => unknown) | Promise<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>;
+    /**
+     * Loads a toolset by name (camelCase convention).
+     */
+    loadToolset?: (toolsetName: string, options?: ToolboxLoadOptions) => Array<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)> | Promise<Array<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>>;
+    /**
+     * Loads a toolset by name (snake_case convention).
+     */
+    load_toolset?: (toolsetName: string, options?: ToolboxLoadOptions) => Array<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)> | Promise<Array<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>>;
+    /**
+     * Closes the underlying client resources.
+     */
+    close?: () => void | Promise<void>;
+}
+/**
+ * Configuration options for {@link ToolboxToolset}.
+ */
+export interface ToolboxToolsetOptions {
+    /**
+     * The URL of the Toolbox server.
+     */
+    serverUrl: string;
+    /**
+     * The name of the Toolbox toolset to load.
+     */
+    toolsetName?: string;
+    /**
+     * The names of the individual tools to load.
+     */
+    toolNames?: readonly string[];
+    /**
+     * Mapping of authentication service names to callables that return the
+     * corresponding authentication token.
+     */
+    authTokenGetters?: Record<string, () => string | Promise<string>>;
+    /**
+     * Mapping of parameter names to bind to fixed values or callables that
+     * produce values as needed.
+     */
+    boundParams?: Record<string, unknown>;
+    /**
+     * Optional pre-configured Toolbox client instance.
+     */
+    client?: ToolboxToolsetClientLike;
+    /**
+     * Optional filter to select which tools are exposed to the LLM.
+     */
+    toolFilter?: ToolPredicate | string[];
+    /**
+     * Optional prefix prepended (`${prefix}_`) to loaded tool names.
+     */
+    prefix?: string;
+}
+declare const TOOLBOX_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link ToolboxToolset}.
+ */
+export declare function isToolboxToolset(obj: unknown): obj is ToolboxToolset;
+/**
+ * Provides asynchronous access to Toolbox tools and toolsets as a
+ * {@link BaseToolset}.
+ */
+export declare class ToolboxToolset extends BaseToolset {
+    /** A unique symbol to identify ADK ToolboxToolset class. */
+    readonly [TOOLBOX_TOOLSET_SIGNATURE_SYMBOL] = true;
+    /**
+     * The URL of the Toolbox server.
+     */
+    readonly serverUrl: string;
+    /**
+     * The name of the Toolbox toolset to load, if configured.
+     */
+    readonly toolsetName?: string;
+    /**
+     * The names of the individual tools to load, if configured.
+     */
+    readonly toolNames?: readonly string[];
+    /**
+     * Mapping of authentication service names to token getters.
+     */
+    readonly authTokenGetters: Record<string, () => string | Promise<string>>;
+    /**
+     * Mapping of parameter names to bound values or value getters.
+     */
+    readonly boundParams: Record<string, unknown>;
+    /**
+     * The underlying Toolbox client instance.
+     */
+    readonly toolboxClient: ToolboxToolsetClientLike;
+    constructor(options: ToolboxToolsetOptions);
+    constructor(serverUrl: string, options: Omit<ToolboxToolsetOptions, 'serverUrl'>);
+    /**
+     * Loads the configured toolset and/or individual tools from the Toolbox
+     * client and returns the selected {@link BaseTool} instances.
+     */
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Closes the underlying Toolbox client.
+     */
+    close(): Promise<void>;
+}
+export {};