@google/adk 2.3.0 → 2.5.0

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

@@ -7,6 +7,13 @@ import { FunctionDeclaration } from '@google/genai';
 import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
 import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
 declare const GOOGLE_API_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Options for constructing a {@link GoogleApiTool}.
+ */
+export interface GoogleApiToolOptions {
+    clientId?: string;
+    clientSecret?: string;
+}
 /**
  * Type guard to check if an object is an instance of {@link GoogleApiTool}.
  */
@@ -17,14 +24,14 @@ export declare function isGoogleApiTool(obj: unknown): obj is GoogleApiTool;
  */
 export declare class GoogleApiTool extends BaseTool {
     readonly [GOOGLE_API_TOOL_SIGNATURE_SYMBOL] = true;
-    readonly restApiTool: RestApiTool;
-    constructor(restApiTool: RestApiTool);
+    private readonly restApiTool;
+    constructor(restApiTool: RestApiTool, options?: GoogleApiToolOptions);
     _getDeclaration(): FunctionDeclaration;
     runAsync(request: RunAsyncToolRequest): Promise<unknown>;
     /**
      * Configures OpenID Connect OAuth2 client credentials on the underlying
      * {@link RestApiTool}.
      */
-    configureAuth(clientId: string, clientSecret: string): void;
+    configureAuth(clientId?: string, clientSecret?: string): void;
 }
 export {};

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

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { GoogleApiTool } from './google_api_tool.js';
+declare const GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Options for constructing a {@link GoogleApiToolset}.
+ */
+export interface GoogleApiToolsetOptions {
+    apiName?: string;
+    apiVersion?: string;
+    clientId?: string;
+    clientSecret?: string;
+    toolFilter?: ToolPredicate | string[];
+    scopes?: string[];
+}
+/**
+ * Type guard to check if an object is an instance of {@link GoogleApiToolset}.
+ */
+export declare function isGoogleApiToolset(obj: unknown): obj is GoogleApiToolset;
+/**
+ * Toolset that wraps Google Discovery API operations as {@link GoogleApiTool}
+ * instances configured for Google OpenID Connect authentication.
+ */
+export declare class GoogleApiToolset extends BaseToolset {
+    readonly [GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL] = true;
+    toolFilter: ToolPredicate | string[];
+    readonly apiName?: string;
+    readonly apiVersion?: string;
+    readonly scopes?: string[];
+    private clientId?;
+    private clientSecret?;
+    private openapiToolset?;
+    private loadingPromise?;
+    private tools;
+    constructor(options?: GoogleApiToolsetOptions);
+    private loadToolsetWithOidcAuth;
+    private ensureToolsLoaded;
+    /**
+     * Returns all tools in the toolset matching the active `toolFilter`.
+     */
+    getTools(context?: ReadonlyContext): Promise<GoogleApiTool[]>;
+    /**
+     * Updates the tool filter used by {@link getTools}.
+     */
+    setToolFilter(toolFilter: ToolPredicate | string[]): void;
+    /**
+     * Configures OAuth2 client ID and secret across all tools in the toolset.
+     */
+    configureAuth(clientId?: string, clientSecret?: string): void;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GoogleApiToolset, type GoogleApiToolsetOptions } from './google_api_toolset.js';
+/**
+ * Toolset for the Google BigQuery v2 API.
+ */
+export declare class BigQueryToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Calendar v3 API.
+ */
+export declare class CalendarToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Gmail v1 API.
+ */
+export declare class GmailToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the YouTube Data v3 API.
+ */
+export declare class YoutubeToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Slides v1 API.
+ */
+export declare class SlidesToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Sheets v4 API.
+ */
+export declare class SheetsToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}
+/**
+ * Toolset for the Google Docs v1 API.
+ */
+export declare class DocsToolset extends GoogleApiToolset {
+    constructor(options?: GoogleApiToolsetOptions);
+}

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

@@ -49,6 +49,7 @@ export interface GoogleApiSchema {
 export interface GoogleApiMethod {
     id?: string;
     path?: string;
+    flatPath?: string;
     httpMethod?: string;
     description?: string;
     parameters?: Record<string, GoogleApiParameter>;
@@ -144,10 +145,10 @@ export declare function convertResources(resources: Record<string, GoogleApiReso
  * Converts Google API Discovery documents into OpenAPI v3.0.0 specifications.
  */
 export declare class GoogleApiToOpenApiConverter {
-    readonly apiName: string;
-    readonly apiVersion: string;
-    googleApiSpec: GoogleApiSpec | null;
-    openapiSpec: OpenAPIV3.Document;
+    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.

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

@@ -4,8 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 export { GoogleApiTool, isGoogleApiTool } from './google_api_tool.js';
-export { GoogleApiToolSet, isGoogleApiToolSet } from './google_api_tool_set.js';
-export type { GoogleApiToolSetOptions, LoadToolSetWithOidcAuthOptions, } from './google_api_tool_set.js';
-export { bigqueryToolSet, calendarToolSet, docsToolSet, gmailToolSet, sheetsToolSet, slidesToolSet, youtubeToolSet, } from './google_api_tool_sets.js';
-export { GoogleApiToOpenApiConverter } from './googleapi_to_openapi_converter.js';
-export type { GoogleApiMethod, GoogleApiOAuth2Scope, GoogleApiParameter, GoogleApiResource, GoogleApiSchema, GoogleApiSpec, } from './googleapi_to_openapi_converter.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,25 @@
  * 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.
+ * @param options Optional settings controlling how inline media and file
+ *   references are formatted.
+ * @return The artifact itself, or a text part that replaces it.
+ */
+export declare function asSafePartForLlm(artifact: Part, artifactName: string, options?: {
+    inlineMediaAsPlaceholder?: boolean;
+}): Part;
 /**
  * A tool that loads the artifacts and adds them to the session.
  */

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

@@ -4,16 +4,44 @@
  * 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';
 /**
- * A tool that loads the memory for the current user.
+ * 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}.
+ *
+ * By default, `memories` contains complete {@link MemoryEntry} objects.
+ * When {@link LoadMemoryToolOptions.textOnlyContent} is `true`, each entry
+ * contains a flattened `string` in `content` alongside `author` and
+ * `timestamp`.
+ */
+export interface LoadMemoryResponse<T = MemoryEntry> {
+    memories: T[];
+}
+/**
+ * A tool that loads memory entries for the current user.
  *
- * NOTE: Currently this tool only uses text part from the memory.
+ * By default, returns complete {@link MemoryEntry} objects.
  */
 export declare class LoadMemoryTool extends BaseTool {
-    constructor();
+    private readonly textOnlyContent;
+    constructor(options?: LoadMemoryToolOptions);
     _getDeclaration(): FunctionDeclaration | undefined;
-    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    runAsync({ args, toolContext }: RunAsyncToolRequest): Promise<LoadMemoryResponse<MemoryEntry | {
+        content: string;
+        author?: string;
+        timestamp?: string;
+    }>>;
     processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
 }
 /**

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

@@ -7,6 +7,7 @@ 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';
+import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
 /**
  * Defines the parameters for establishing a connection to an MCP server using
  * standard input/output (stdio). This is typically used for running MCP servers
@@ -15,6 +16,10 @@ import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol
 export interface StdioConnectionParams {
     type: 'StdioConnectionParams';
     serverParams: StdioServerParameters;
+    /**
+     * Request timeout in seconds for stdio MCP operations. When unset, the MCP
+     * SDK applies its own default request timeout.
+     */
     timeout?: number;
 }
 /**
@@ -94,6 +99,17 @@ export declare class MCPSessionManager {
     private readonly connectionParams;
     private readonly activeSessions;
     constructor(connectionParams: MCPConnectionParams);
+    /**
+     * Builds per-request options for MCP client operations.
+     *
+     * For a stdio connection with a configured `timeout`, the timeout is
+     * converted from seconds to milliseconds. Otherwise the MCP SDK applies its
+     * own default request timeout.
+     *
+     * @param signal Optional abort signal to attach to the request.
+     * @return The request options for the MCP SDK client.
+     */
+    getRequestOptions(signal?: AbortSignal): RequestOptions;
     createSession(): Promise<Client>;
     closeSession(client: Client): Promise<void>;
     getActiveSessions(): Client[];

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

@@ -86,7 +86,7 @@ export declare function tokenToSchemeCredential(tokenType: 'apikey' | 'oauth2Tok
  * @param scopes The scopes to request.
  * @returns A `[scheme, credential]` pair.
  */
-export declare function serviceAccountDictToSchemeCredential(config: Record<string, unknown>, scopes: string[]): [AuthScheme, AuthCredential];
+export declare function serviceAccountRecordToSchemeCredential(config: Record<string, unknown>, scopes: string[]): [AuthScheme, AuthCredential];
 /**
  * Creates a bearer scheme and a service-account credential from an already
  * built `ServiceAccount`.
@@ -99,16 +99,16 @@ export declare function serviceAccountSchemeCredential(config: ServiceAccount):
  * Builds an OpenID Connect scheme and credential from a configuration object
  * and a client-secret object.
  *
- * @param configDict An OpenID Connect configuration. Snake_case keys, as a
+ * @param configRecord An OpenID Connect configuration. Snake_case keys, as a
  *   discovery document delivers them, are accepted and normalized.
  * @param scopes The scopes to request.
- * @param credentialDict The Google OAuth client secret. Its keys stay
+ * @param credentialRecord The Google OAuth client secret. Its keys stay
  *   snake_case, because it is an on-disk wire format. A `{web: {…}}` or
  *   `{installed: {…}}` wrapper is unwrapped.
  * @returns A `[scheme, credential]` pair.
  * @throws Error When the configuration or the client secret is incomplete.
  */
-export declare function openidDictToSchemeCredential(configDict: Record<string, unknown>, scopes: string[], credentialDict: Record<string, unknown>): [OpenIdConnectWithConfig, AuthCredential];
+export declare function openidRecordToSchemeCredential(configRecord: Record<string, unknown>, scopes: string[], credentialRecord: Record<string, unknown>): [OpenIdConnectWithConfig, AuthCredential];
 /**
  * Fetches an OpenID Connect discovery document and pairs it with a client
  * secret.
@@ -118,12 +118,12 @@ export declare function openidDictToSchemeCredential(configDict: Record<string,
  *
  * @param openidUrl The OpenID Connect discovery URL.
  * @param scopes The scopes to request.
- * @param credentialDict The Google OAuth client secret, keyed snake_case.
+ * @param credentialRecord The Google OAuth client secret, keyed snake_case.
  * @returns A `[scheme, credential]` pair.
  * @throws Error When the request fails, the body is not a JSON object, or the
  *   configuration is incomplete.
  */
-export declare function openidUrlToSchemeCredential(openidUrl: string, scopes: string[], credentialDict: Record<string, unknown>): Promise<[OpenIdConnectWithConfig, AuthCredential]>;
+export declare function openidUrlToSchemeCredential(openidUrl: string, scopes: string[], credentialRecord: Record<string, unknown>): Promise<[OpenIdConnectWithConfig, AuthCredential]>;
 /**
  * Converts a scheme and credential into the tool parameter that carries the
  * credential, plus the value to send for it.
@@ -144,7 +144,7 @@ export declare function credentialToParam(authScheme: AuthScheme, authCredential
  * `AuthScheme`.
  *
  * @example
- * const scheme = dictToAuthScheme({
+ * const scheme = recordToAuthScheme({
  *   type: 'apiKey',
  *   in: 'header',
  *   name: 'X-API-Key',
@@ -155,4 +155,4 @@ export declare function credentialToParam(authScheme: AuthScheme, authCredential
  * @throws Error When `type` is missing or unrecognised, or the rest of the
  *   object does not match the shape that type requires.
  */
-export declare function dictToAuthScheme(data: Record<string, unknown>): AuthScheme;
+export declare function recordToAuthScheme(data: Record<string, unknown>): AuthScheme;

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
@@ -96,6 +104,9 @@ export declare class OperationParser {
     /**
      * Gets the Python-style type hint of the return value.
      *
+     * @deprecated Legacy Python type-hint helper retained for compatibility. In
+     *     `adk-js`, tool declarations pass the JSON schema from
+     *     {@link OperationParser.getJsonSchema} directly to the model.
      * @returns A type name such as `str`, or `Any` when the operation declares
      *     no typed 2xx response.
      */
@@ -104,9 +115,10 @@ export declare class OperationParser {
      * Generates a Python-style docstring describing the operation, every
      * parameter and the return value.
      *
-     * The type names inside it are Python's, because the artifact is a docstring
-     * in adk-python's format and the same text reaches the model in both SDKs.
-     *
+     * @deprecated Legacy Python docstring helper retained for compatibility. In
+     *     `adk-js`, tool declarations use {@link OperationParser.getDescription}
+     *     and {@link OperationParser.getJsonSchema} rather than sending a Python
+     *     docstring to the model.
      * @returns The generated docstring.
      */
     getPydocString(): string;

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/toolbox_toolset.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @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 functions that return the
+     * corresponding authentication token.
+     */
+    authTokenGetters?: Record<string, () => string | Promise<string>>;
+    /**
+     * Mapping of parameter names to bind to fixed values or functions 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.
+     */
+    loadTool?: (toolName: string, authTokenGetters?: Record<string, () => string | Promise<string>>, boundParams?: Record<string, unknown>) => BaseTool | ToolboxToolLike | ((...args: never[]) => unknown) | Promise<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>;
+    /**
+     * Loads a toolset by name.
+     */
+    loadToolset?: (toolsetName: string, authTokenGetters?: Record<string, () => string | Promise<string>>, boundParams?: Record<string, unknown>) => 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. Required when `client` is not provided.
+     */
+    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 functions that return the
+     * corresponding authentication token.
+     */
+    authTokenGetters?: Record<string, () => string | Promise<string>>;
+    /**
+     * Mapping of parameter names to bind to fixed values or functions 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, if configured.
+     */
+    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);
+    /**
+     * @deprecated Use `new ToolboxToolset({serverUrl, ...options})` instead.
+     */
+    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 {};

package/dist/types/utils/async_queue.d.ts

@@ -18,12 +18,16 @@
  *    queue, so a later `close()` can't discard the error.
  *  - {@link push} after close/fail is ignored (the producer has already
  *    signalled completion).
+ *  - {@link pushAndWait} resolves once the consumer has finished with the item:
+ *    when it asks for the next one, or when the queue closes or fails.
  */
 export declare class AsyncQueue<T> implements AsyncIterable<T> {
     private queue;
     private resolvers;
     private closed;
     private failure?;
+    /** Releases the producer of the item the consumer currently holds. */
+    private deliveredAck?;
     /** Whether the queue has been closed or failed. */
     get isClosed(): boolean;
     /** Number of items buffered and not yet consumed. */
@@ -33,6 +37,16 @@ export declare class AsyncQueue<T> implements AsyncIterable<T> {
      * immediately; otherwise the value is buffered. No-op once closed/failed.
      */
     push(value: T): void;
+    /**
+     * Enqueues a value like {@link push}, and resolves once the consumer has
+     * finished with it: when it asks for the next item, or when the queue closes
+     * or fails. Resolves at once if the queue is already closed.
+     */
+    pushAndWait(value: T): Promise<void>;
+    private enqueue;
+    /** Releases every producer still waiting in {@link pushAndWait}. */
+    private releaseAll;
+    private releaseDelivered;
     /**
      * Signals that production failed. Buffered items are still delivered first;
      * once the buffer drains, the consumer's next `next()` rejects with `error`.

package/dist/types/utils/client_labels.d.ts

@@ -41,7 +41,8 @@ export declare function getTrackingHeaders(): Record<string, string>;
  * single space, so the two differ only for values with repeated or non-space
  * whitespace. Commas are not treated as separators, so a `Headers` object that
  * joined two values of one header with `, ` keeps the comma on the first
- * token. All other headers keep the caller's name and value.
+ * token. Other repeated header names use the platform `Headers` semantics;
+ * for example, repeated `Cookie` values are joined with `; `.
  *
  * The input is never mutated.
  *