@google/adk 2.3.0 → 2.4.0

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

@@ -0,0 +1,55 @@
+/**
+ * @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[];
+}
+/**
+ * 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;
+    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,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/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_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,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 {};

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.
  *

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

@@ -10,6 +10,14 @@ export type MCPToolSchema = {
     required?: string[];
 };
 export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
+/**
+ * Normalizes a JSON Schema `type` value into a single non-null type name and a
+ * `nullable` flag.
+ *
+ * When `type` is an array containing multiple non-null types, the first
+ * non-null entry is selected as the primary Gemini schema type.
+ */
+export declare function normalizeJsonSchemaType(jsonSchemaType?: unknown): [string | undefined, boolean];
 /**
  * Converts an OpenAPI schema to a Gemini `Schema`.
  *

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

@@ -3,6 +3,7 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { BaseLlm } from '../models/base_llm.js';
 /**
  * Returns whether the model can natively accept an output schema at the same
  * time as tools, which is strictly more reliable than the prompt-based
@@ -12,7 +13,7 @@
  * `false` for them even on Vertex AI, where they do support the capability.
  * That under-reporting is a known gap.
  *
- * @param modelString A simple or path-based model name.
+ * @param model A simple or path-based model name, or a `BaseLlm` instance.
  * @return True if the model supports an output schema alongside tools.
  */
-export declare function canUseOutputSchemaWithTools(modelString: string): boolean;
+export declare function canUseOutputSchemaWithTools(model: string | BaseLlm): boolean;

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

@@ -6,7 +6,7 @@
 import { Schema } from '@google/genai';
 import { z as z3 } from 'zod/v3';
 import { z as z4 } from 'zod/v4';
-type ZodSchema<T = unknown> = z3.ZodType<T> | z4.ZodType<T>;
+export type ZodSchema<T = unknown> = z3.ZodType<T> | z4.ZodType<T>;
 /** Returns true if the value is a Zod schema (v3 or v4). */
 export declare function isZodSchema(obj: unknown): obj is ZodSchema;
 /** Returns true if the value is a Zod v3 schema. */
@@ -18,4 +18,3 @@ export declare function isZodV4Schema(obj: unknown): obj is z4.ZodType;
  */
 export declare function isZodObject(obj: unknown): obj is z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>;
 export declare function zodObjectToSchema(schema: z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape>): Schema;
-export {};

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.3.0";
+export declare const version = "2.4.0";