@google/adk 2.2.0 → 2.3.0

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

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LangchainTool, LangchainToolLike } from './langchain_tool.js';
+/**
+ * Structural interface for a Toolbox client instance.
+ */
+export interface ToolboxClientLike {
+    /**
+     * Loads a single tool by name (camelCase convention).
+     */
+    loadTool?: (toolName: string) => LangchainToolLike;
+    /**
+     * Loads a single tool by name (snake_case convention).
+     */
+    load_tool?: (toolName: string) => LangchainToolLike;
+    /**
+     * Loads a toolset by name (camelCase convention).
+     */
+    loadToolset?: (toolsetName: string) => LangchainToolLike[];
+    /**
+     * Loads a toolset by name (snake_case convention).
+     */
+    load_toolset?: (toolsetName: string) => LangchainToolLike[];
+}
+/**
+ * Configuration options for {@link ToolboxTool}.
+ */
+export interface ToolboxToolOptions {
+    /**
+     * The URL of the Toolbox server.
+     */
+    url?: string;
+    /**
+     * Optional pre-configured Toolbox client instance.
+     */
+    client?: ToolboxClientLike;
+}
+declare const TOOLBOX_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link ToolboxTool}.
+ */
+export declare function isToolboxTool(obj: unknown): obj is ToolboxTool;
+/**
+ * Provides access to Toolbox tools and toolsets wrapped as {@link LangchainTool}
+ * instances.
+ */
+export declare class ToolboxTool {
+    /** A unique symbol to identify ADK ToolboxTool class. */
+    readonly [TOOLBOX_TOOL_SIGNATURE_SYMBOL] = true;
+    /**
+     * The URL of the Toolbox server, if provided.
+     */
+    readonly url?: string;
+    /**
+     * The underlying Toolbox client.
+     */
+    readonly toolboxClient: ToolboxClientLike;
+    constructor(urlOrOptions: string | ToolboxToolOptions);
+    /**
+     * Loads a single tool from the Toolbox client and wraps it in a
+     * {@link LangchainTool}.
+     */
+    getTool(toolName: string): LangchainTool;
+    /**
+     * Loads a toolset from the Toolbox client and wraps each tool in a
+     * {@link LangchainTool}.
+     */
+    getToolset(toolsetName: string): LangchainTool[];
+}
+export {};

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

@@ -34,15 +34,31 @@ export declare function randomUUID(): string;
 /**
  * Encodes the given string or Uint8Array to base64.
  *
+ * `window.btoa` is byte-oriented and throws on any code unit above `U+00FF`,
+ * so a string is first encoded to UTF-8 bytes. Node's `Buffer` encodes a
+ * string as UTF-8 too, which keeps both environments on one contract and lets
+ * `base64Decode` round-trip its output.
+ *
  * @param data The data to encode.
  * @return The base64-encoded string.
  */
 export declare function base64Encode(data: string | Uint8Array): string;
 /**
- * Decodes the given base64 string to a string.
+ * Decodes the given base64 string to UTF-8 text.
+ *
+ * `window.atob` is byte-oriented: it returns a latin1 "binary string" with one
+ * code unit per decoded byte, so a multi-byte UTF-8 sequence surfaces as
+ * mojibake. Node's `Buffer` decodes the same bytes as UTF-8, so the browser
+ * branch recovers the bytes from `atob` and decodes them explicitly. That keeps
+ * both environments on the single contract `File.content` and
+ * `materializeFiles` already assume.
+ *
+ * `ignoreBOM` keeps a leading byte order mark as `U+FEFF`, which is what
+ * `Buffer` does. `TextDecoder` strips it by default, so a spreadsheet CSV
+ * exported as UTF-8 with a BOM would otherwise lose a character.
  *
  * @param data The base64-encoded string.
- * @return The decoded string.
+ * @return The decoded UTF-8 string.
  */
 export declare function base64Decode(data: string): string;
 /**

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

@@ -3,6 +3,13 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * Returns the plain, non-recursive message for a single thrown value.
+ *
+ * Reads `.message` from any object that carries a string `message` property,
+ * and falls back to `String(err)` for primitives and other values.
+ */
+export declare function getErrorMessage(err: unknown): string;
 /**
  * Formats an arbitrary thrown value into a readable, root-cause message.
  *

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

@@ -17,5 +17,10 @@ import { File } from '../code_executors/code_execution_utils.js';
  * @param dir The directory to materialize the files into.
  */
 export declare function materializeFiles(files: File[], dir: string): Promise<File[]>;
-export declare const EXTENSION_TO_MIME_TYPE: Record<string, string>;
+/**
+ * Guesses the MIME type of a file from its extension.
+ * @param filePath A file name or path.
+ * @returns The MIME type, or 'application/octet-stream' if the extension is
+ *     unknown or absent.
+ */
 export declare function guessMimeType(filePath: string): string;

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Schema } from '@google/genai';
-type MCPToolSchema = {
+export type MCPToolSchema = {
     type: 'object';
     properties?: Record<string, unknown>;
     required?: string[];
@@ -23,4 +23,3 @@ export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | unde
  * @throws {TypeError} If the input is neither an object nor nullish.
  */
 export declare function openApiSchemaToGeminiSchema(openApiSchema?: unknown): Schema | undefined;
-export {};

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** A JSON object keyed by string. */
+export type JsonObject = Record<string, unknown>;
+/** Narrows an arbitrary value to a plain JSON object (non-null, non-array). */
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/** Returns `value` when it is a JSON object, or `{}` otherwise. */
+export declare function toJsonObject(value: unknown): JsonObject;

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

@@ -19,3 +19,10 @@ export declare function toCamelCase(obj: unknown, preserveKeys?: string[]): unkn
  * @returns The object with snake_case keys.
  */
 export declare function toSnakeCase(obj: unknown, preserveKeys?: string[]): unknown;
+/**
+ * Converts a camelCase, PascalCase, or hyphenated key to snake_case.
+ *
+ * @param key The key to convert.
+ * @returns The snake_case key.
+ */
+export declare const toSnakeCaseKey: (key: string) => string;

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

@@ -5,14 +5,21 @@
  */
 import { GenerateContentResponse, Part } from '@google/genai';
 import { LlmResponse } from '../models/llm_response.js';
+/** Options for {@link GeminiStreamingResponseAggregator}. */
+export interface GeminiStreamingResponseAggregatorOptions {
+    /**
+     * Whether to flush parts as they arrive. Defaults to the
+     * PROGRESSIVE_SSE_STREAMING feature flag.
+     */
+    isProgressiveMode?: boolean;
+}
 /**
- * Aggregates partial streaming responses.
+ * Aggregates partial Gemini streaming responses.
  *
  * It aggregates content from partial responses, and generates LlmResponses for
  * individual (partial) model responses, as well as for aggregated content.
  */
-export declare class StreamingResponseAggregator {
-    private readonly isProgressiveMode;
+export declare class GeminiStreamingResponseAggregator {
     private usageMetadata?;
     private groundingMetadata?;
     private citationMetadata?;
@@ -20,7 +27,7 @@ export declare class StreamingResponseAggregator {
     private finishReason?;
     private lastThoughtSignature;
     private readonly strategy;
-    constructor(isProgressiveMode?: boolean);
+    constructor({ isProgressiveMode, }?: GeminiStreamingResponseAggregatorOptions);
     processResponse(response: GenerateContentResponse): AsyncGenerator<LlmResponse, void, void>;
     close(): LlmResponse | undefined;
 }

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "2.2.0";
+export declare const version = "2.3.0";