@google/adk 2.3.0 → 2.5.0

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,6 +9,31 @@ export type MCPToolSchema = {
     properties?: Record<string, unknown>;
     required?: string[];
 };
+/**
+ * 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.
+ *
+ * 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 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`.
@@ -18,6 +43,10 @@ export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | unde
  * 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/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/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.3.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 {};