@google/adk 2.4.0 → 2.5.0

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

@@ -20,22 +20,28 @@ export interface LoadMemoryToolOptions {
 /**
  * Response returned by {@link LoadMemoryTool}.
  *
- * When {@link LoadMemoryToolOptions.textOnlyContent} is enabled, entries contain
- * string content instead of a `Content` object.
+ * 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 {
-    memories: MemoryEntry[];
+export interface LoadMemoryResponse<T = MemoryEntry> {
+    memories: T[];
 }
 /**
- * A tool that loads the memory for the current user.
+ * 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 {
     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/operation_parser.d.ts

@@ -104,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.
      */
@@ -112,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/toolbox_toolset.d.ts

@@ -33,12 +33,12 @@ export interface ToolboxToolLike {
  */
 export interface ToolboxLoadOptions {
     /**
-     * Mapping of authentication service names to callables that return the
+     * 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 callables that
+     * Mapping of parameter names to bind to fixed values or functions that
      * produce values as needed.
      */
     boundParams?: Record<string, unknown>;
@@ -49,21 +49,13 @@ export interface ToolboxLoadOptions {
  */
 export interface ToolboxToolsetClientLike {
     /**
-     * Loads a single tool by name (camelCase convention).
+     * Loads a single tool by name.
      */
-    loadTool?: (toolName: string, options?: ToolboxLoadOptions) => BaseTool | ToolboxToolLike | ((...args: never[]) => unknown) | Promise<BaseTool | ToolboxToolLike | ((...args: never[]) => unknown)>;
+    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 single tool by name (snake_case convention).
+     * Loads a toolset by name.
      */
-    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)>>;
+    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.
      */
@@ -74,9 +66,9 @@ export interface ToolboxToolsetClientLike {
  */
 export interface ToolboxToolsetOptions {
     /**
-     * The URL of the Toolbox server.
+     * The URL of the Toolbox server. Required when `client` is not provided.
      */
-    serverUrl: string;
+    serverUrl?: string;
     /**
      * The name of the Toolbox toolset to load.
      */
@@ -86,12 +78,12 @@ export interface ToolboxToolsetOptions {
      */
     toolNames?: readonly string[];
     /**
-     * Mapping of authentication service names to callables that return the
+     * 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 callables that
+     * Mapping of parameter names to bind to fixed values or functions that
      * produce values as needed.
      */
     boundParams?: Record<string, unknown>;
@@ -121,9 +113,9 @@ 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.
+     * The URL of the Toolbox server, if configured.
      */
-    readonly serverUrl: string;
+    readonly serverUrl?: string;
     /**
      * The name of the Toolbox toolset to load, if configured.
      */
@@ -145,6 +137,9 @@ export declare class ToolboxToolset extends BaseToolset {
      */
     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

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

@@ -68,6 +68,17 @@ export declare function base64Decode(data: string): string;
  * @return True if the string is base64-encoded, false otherwise.
  */
 export declare function isBase64Encoded(data: string): boolean;
+/**
+ * Gets the value of the given environment variable.
+ *
+ * Browsers have no `process` global, and there even `process?.env` throws a
+ * ReferenceError, so this checks `typeof process` first and treats every
+ * variable as unset.
+ *
+ * @param envVar The environment variable to get the value of.
+ * @return The value of the environment variable, or undefined if it is unset.
+ */
+export declare function getEnvVar(envVar: string): string | undefined;
 /**
  * Gets the boolean value of the given environment variable.
  *

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

@@ -3,6 +3,10 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/** Normalizes a plugin notification without changing the caller's thrown value. */
+export declare function toError(error: unknown): Error;
+/** Recognizes cancellation within 32 cause levels, only after signal abort. */
+export declare function isInvocationCancellation(error: unknown, signal?: AbortSignal): boolean;
 /**
  * Returns the plain, non-recursive message for a single thrown value.
  *

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

@@ -9,15 +9,32 @@ export type MCPToolSchema = {
     properties?: Record<string, unknown>;
     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.
+ * Copies the constraint keywords a genai `Schema` declares from a JSON Schema
+ * node onto a `Schema` node, in the encoding the genai dialect expects.
+ *
+ * This is the one place that decides which constraints survive a conversion, so
+ * that both converters apply the same rules: `toGeminiSchema` for a JSON Schema
+ * (an MCP tool schema, or a serialized Zod response) and `zodObjectToSchema`
+ * for a Zod object. Without this, every nested `minItems`/`minLength`/`minimum`
+ * is silently dropped and the model is told an unconstrained schema.
+ *
+ * - `minItems`/`maxItems`, `minLength`/`maxLength` and
+ *   `minProperties`/`maxProperties` are counts and lengths, which the genai
+ *   `Schema` stores as strings.
+ * - `minimum`/`maximum` stay numbers, as `Schema` declares them.
+ * - `pattern` is already a string in both dialects, and survives unless it
+ *   merely restates an `email`/`uuid` format.
  *
- * When `type` is an array containing multiple non-null types, the first
- * non-null entry is selected as the primary Gemini schema type.
+ * Every other JSON Schema keyword (`title`, `default`, `example`,
+ * `exclusiveMinimum`, ...) and any unsupported `format` has no `Schema` field
+ * the backend accepts, so it is still dropped.
+ *
+ * @param source The JSON Schema node to read the constraints from.
+ * @param target The `Schema` node to write them to; may be `source` itself.
  */
-export declare function normalizeJsonSchemaType(jsonSchemaType?: unknown): [string | undefined, boolean];
+export declare function copySchemaConstraints(source: Record<string, unknown>, target: Record<string, unknown>): void;
+export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
 /**
  * Converts an OpenAPI schema to a Gemini `Schema`.
  *
@@ -26,6 +43,10 @@ export declare function normalizeJsonSchemaType(jsonSchemaType?: unknown): [stri
  * it likes, so a key the Gemini `Schema` does not declare is dropped instead of
  * being forwarded to a backend that rejects it.
  *
+ * `oneOf` branches are folded into `anyOf`. A `{type: 'null'}` branch is
+ * removed and marks the schema `nullable`. When only one branch remains, it is
+ * merged into the parent schema instead of being kept as a one-item `anyOf`.
+ *
  * @param openApiSchema The OpenAPI schema, which may be any value.
  * @returns The converted schema, or `undefined` when there is no input.
  * @throws {TypeError} If the input is neither an object nor nullish.

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

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns a new unique ID string.
+ */
+export type IdProvider = () => string;
+/**
+ * Sets the function used to generate event, invocation, session and
+ * function-call IDs. Without a provider, every ID keeps its default format.
+ *
+ * Useful when random IDs are not unique, e.g. runtimes restored from one
+ * memory snapshot share RNG state. Like adk-python's `set_id_provider`, but
+ * global instead of scoped to an async context.
+ *
+ * Each value must be a non-empty string that no other runtime produces.
+ * Session IDs come from it too, so the values should also be hard to guess.
+ *
+ * @param provider A function that returns a unique ID string.
+ */
+export declare function setIdProvider(provider: IdProvider): void;
+/**
+ * Removes the provider set with `setIdProvider`, so IDs go back to their
+ * default formats.
+ */
+export declare function resetIdProvider(): void;
+/**
+ * Returns a new unique ID from the provider set with `setIdProvider`, or a
+ * random v4 UUID when none is set.
+ */
+export declare function newId(): string;
+/**
+ * Returns a new unique ID from the provider set with `setIdProvider`, or from
+ * `fallback` when none is set.
+ *
+ * Internal to the framework: not part of the public API. For IDs whose default
+ * is not a random v4 UUID, such as event IDs.
+ *
+ * @param fallback A function that returns the default ID.
+ */
+export declare function newIdOr(fallback: IdProvider): string;

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

@@ -18,6 +18,14 @@ export declare function extractModelName(modelString: string): string;
  * @return true if it's a Gemini model, false otherwise.
  */
 export declare function isGeminiModel(modelString: string): boolean;
+/**
+ * Returns the major version of a `gemini-*` model.
+ *
+ * @param modelString Either a simple model name or path-based model name.
+ * @return The major version, or `undefined` when the model is not a Gemini
+ *     model or its version is not numeric (for example `gemini-flash-latest`).
+ */
+export declare function getGeminiMajorVersion(modelString: string | undefined): number | undefined;
 /**
  * Check if the model is a Gemini 1.x model using regex patterns.
  *

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

@@ -24,6 +24,8 @@ export declare function isNonGlobalAddress(address: string): boolean;
  * embeds a link-local IPv4. Unparseable input fails closed (blocked).
  */
 export declare function isLinkLocalAddress(address: string): boolean;
+/** Returns `true` when `address` is an IPv4 or IPv6 literal (without brackets). */
+export declare function isIpAddress(address: string): boolean;
 /**
  * Resolves `hostname` to a de-duplicated list of IP addresses. IP literals are
  * returned as-is; hostnames are resolved via DNS. Throws when resolution yields

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

package/dist/types/workflow/index.d.ts

@@ -21,7 +21,7 @@ export { FunctionNode } from './nodes/function_node.js';
 export type { FunctionNodeConfig, FunctionNodeHandler, FunctionNodeResult, } from './nodes/function_node.js';
 export { JoinNode } from './nodes/join_node.js';
 export { NodeTool } from './nodes/node_tool.js';
-export { ParallelWorker } from './nodes/parallel_worker.js';
+export { ParallelWorker, isParallelWorker } from './nodes/parallel_worker.js';
 export type { ParallelWorkerConfig } from './nodes/parallel_worker.js';
 export { ToolNode } from './nodes/tool_node.js';
 export type { ToolNodeConfig } from './nodes/tool_node.js';

package/dist/types/workflow/nodes/parallel_worker.d.ts

@@ -6,6 +6,7 @@
 import { BaseNode } from '../base_node.js';
 import { RunnableNode } from '../graph.js';
 import { NodeContext } from '../node_context.js';
+declare const PARALLEL_WORKER_SIGNATURE_SYMBOL: unique symbol;
 /** Options for a {@link ParallelWorker}. */
 export interface ParallelWorkerConfig {
     /**
@@ -48,8 +49,14 @@ export interface ParallelWorkerConfig {
  *   `ctx.runNode` has no way to forward a signal into a child run.
  */
 export declare class ParallelWorker extends BaseNode {
+    readonly [PARALLEL_WORKER_SIGNATURE_SYMBOL] = true;
     readonly maxParallelWorkers?: number;
-    private readonly inner;
+    readonly inner: BaseNode;
     constructor(inner: RunnableNode, config?: ParallelWorkerConfig);
     protected runImpl(ctx: NodeContext, input: unknown): AsyncGenerator<unknown, void, void>;
 }
+/**
+ * Type guard to check if an object is an instance of {@link ParallelWorker}.
+ */
+export declare function isParallelWorker(value: unknown): value is ParallelWorker;
+export {};