@google/adk 2.2.1 → 2.3.0

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

@@ -0,0 +1,164 @@
+/**
+ * @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;
+    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 {
+    readonly apiName: string;
+    readonly apiVersion: string;
+    googleApiSpec: GoogleApiSpec | null;
+    openapiSpec: OpenAPIV3.Document;
+    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,11 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * 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';

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

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { SchemaLike } from '../utils/schema.js';
+import { FunctionTool, ToolInputParameters } from './function_tool.js';
+/**
+ * Schema formats accepted on a wrapped LangChain tool.
+ */
+export type LangchainSchemaLike = SchemaLike | {
+    jsonSchema: () => Record<string, unknown>;
+} | {
+    modelJsonSchema: () => Record<string, unknown>;
+} | Record<string, unknown>;
+/**
+ * Structural interface for a LangChain tool instance.
+ */
+export interface LangchainToolLike {
+    /**
+     * The name of the LangChain tool.
+     */
+    name?: string;
+    /**
+     * The description of the LangChain tool.
+     */
+    description?: string;
+    /**
+     * Optional parameter schema (`argsSchema`).
+     */
+    argsSchema?: LangchainSchemaLike;
+    /**
+     * Optional parameter schema (`StructuredTool.schema`).
+     */
+    schema?: LangchainSchemaLike;
+    /**
+     * Optional raw parameter properties map (`BaseTool.args`).
+     */
+    args?: Record<string, unknown>;
+    /**
+     * Executes the tool (`BaseTool._run`).
+     */
+    _run?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes the tool (`StructuredTool._call`).
+     */
+    _call?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes the tool (`Runnable.invoke`).
+     */
+    invoke?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes a simple convention-based tool (`tool.run`).
+     */
+    run?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+}
+/**
+ * Configuration options for {@link LangchainTool}.
+ */
+export interface LangchainToolConfig {
+    /**
+     * The wrapped LangChain tool instance.
+     */
+    tool: LangchainToolLike;
+    /**
+     * Optional custom name override.
+     */
+    name?: string;
+    /**
+     * Optional custom description override.
+     */
+    description?: string;
+}
+declare const LANGCHAIN_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link LangchainTool}.
+ */
+export declare function isLangchainTool(obj: unknown): obj is LangchainTool;
+/**
+ * Wrapper class that adapts a LangChain tool for use in ADK.
+ *
+ * If the original tool name and description are not suitable, you can override
+ * them in the constructor.
+ */
+export declare class LangchainTool extends FunctionTool<ToolInputParameters> {
+    /** A unique symbol to identify ADK LangchainTool class. */
+    readonly [LANGCHAIN_TOOL_SIGNATURE_SYMBOL] = true;
+    /**
+     * The wrapped LangChain tool.
+     */
+    readonly tool: LangchainToolLike;
+    constructor(toolOrConfig: LangchainToolConfig | LangchainToolLike, options?: {
+        name?: string;
+        description?: string;
+    });
+    /**
+     * Builds the `FunctionDeclaration` for the wrapped LangChain tool.
+     */
+    _getDeclaration(): FunctionDeclaration;
+}
+export {};

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/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;
 }