@google/adk 2.4.0 → 2.5.0

package/dist/esm/utils/error_utils.js

@@ -16,6 +16,40 @@ function asRecord(value) {
   return value !== null && typeof value === "object" ? value : void 0;
 }
 __name(asRecord, "asRecord");
+function toError(error) {
+  return error instanceof Error ? error : new Error("Execution threw a non-Error value.", { cause: error });
+}
+__name(toError, "toError");
+function isInvocationCancellation(error, signal) {
+  if (!(signal == null ? void 0 : signal.aborted)) {
+    return false;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 32 && !seen.has(error); depth++) {
+    if (Object.is(error, signal.reason)) {
+      return true;
+    }
+    seen.add(error);
+    const record = asRecord(error);
+    if (!record) {
+      return false;
+    }
+    try {
+      const name = record["name"];
+      if (name === "AbortError" || name === "InvocationAbortedError") {
+        return true;
+      }
+      if (!("cause" in record)) {
+        return false;
+      }
+      error = record["cause"];
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+__name(isInvocationCancellation, "isInvocationCancellation");
 function firstString(...values) {
   for (const value of values) {
     if (typeof value === "string") {
@@ -96,5 +130,7 @@ function formatError(err) {
 __name(formatError, "formatError");
 export {
   formatError,
-  getErrorMessage
+  getErrorMessage,
+  isInvocationCancellation,
+  toError
 };

package/dist/esm/utils/failover_utils.js

@@ -15,10 +15,7 @@ async function* runWithRouting(items, context, router, runFn) {
   }
   let selectedKey = initialKey;
   logger.debug(`Router selected initial key: ${selectedKey}`);
-  let selectedItem = items[selectedKey];
-  if (!selectedItem) {
-    throw new Error(`Item not found for key: ${selectedKey}`);
-  }
+  let selectedItem = getSelectedItem(items, selectedKey);
   const triedKeys = /* @__PURE__ */ new Set([selectedKey]);
   while (true) {
     let firstYielded = false;
@@ -48,10 +45,7 @@ async function* runWithRouting(items, context, router, runFn) {
           throw error;
         }
         selectedKey = nextKey;
-        selectedItem = items[selectedKey];
-        if (!selectedItem) {
-          throw new Error(`Item not found for key: ${selectedKey}`);
-        }
+        selectedItem = getSelectedItem(items, selectedKey);
         triedKeys.add(selectedKey);
       } else {
         throw error;
@@ -60,8 +54,15 @@ async function* runWithRouting(items, context, router, runFn) {
   }
 }
 __name(runWithRouting, "runWithRouting");
+function getSelectedItem(items, key) {
+  if (!Object.hasOwn(items, key) || items[key] === void 0) {
+    throw new Error(`Item not found for key: ${key}`);
+  }
+  return items[key];
+}
+__name(getSelectedItem, "getSelectedItem");
 function isAsyncGenerator(obj) {
-  return typeof obj === "object" && typeof obj[Symbol.asyncIterator] === "function";
+  return typeof obj === "object" && obj !== null && typeof obj[Symbol.asyncIterator] === "function";
 }
 __name(isAsyncGenerator, "isAsyncGenerator");
 export {

package/dist/esm/utils/gemini_schema_util.js

@@ -39,6 +39,66 @@ const getTypeFromArrayItem = /* @__PURE__ */ __name((mcpType) => {
   }
   return (_b = (_a = mcpType == null ? void 0 : mcpType.type) == null ? void 0 : _a.toLowerCase) == null ? void 0 : _b.call(_a);
 }, "getTypeFromArrayItem");
+const STRINGIFIED_CONSTRAINT_FIELDS = [
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minItems",
+  "minLength",
+  "minProperties"
+];
+const NUMERIC_CONSTRAINT_FIELDS = ["maximum", "minimum"];
+const PATTERN_REDUNDANT_FORMATS = /* @__PURE__ */ new Set([
+  "email",
+  "uuid"
+]);
+const GEMINI_INTEGER_NUMBER_FORMATS = /* @__PURE__ */ new Set([
+  "int32",
+  "int64"
+]);
+const GEMINI_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "enum"
+]);
+function keepsGeminiFormat(type, format) {
+  if (typeof type !== "string" || typeof format !== "string") {
+    return false;
+  }
+  if (type === "integer" || type === "number") {
+    return GEMINI_INTEGER_NUMBER_FORMATS.has(format);
+  }
+  if (type === "string") {
+    return GEMINI_STRING_FORMATS.has(format);
+  }
+  return false;
+}
+__name(keepsGeminiFormat, "keepsGeminiFormat");
+function copySchemaConstraints(source, target) {
+  for (const field of STRINGIFIED_CONSTRAINT_FIELDS) {
+    const value = source[field];
+    if (typeof value === "number" || typeof value === "string") {
+      target[field] = String(value);
+    }
+  }
+  for (const field of NUMERIC_CONSTRAINT_FIELDS) {
+    const value = source[field];
+    if (typeof value === "number") {
+      target[field] = value;
+    } else if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) {
+      target[field] = Number(value);
+    }
+  }
+  const pattern = source["pattern"];
+  const format = source["format"];
+  if (typeof pattern === "string") {
+    if (typeof format === "string" && PATTERN_REDUNDANT_FORMATS.has(format)) {
+      delete target["pattern"];
+    } else {
+      target["pattern"] = pattern;
+    }
+  }
+}
+__name(copySchemaConstraints, "copySchemaConstraints");
 function toGeminiSchema(mcpSchema) {
   if (!mcpSchema) {
     return void 0;
@@ -83,6 +143,7 @@ function toGeminiSchema(mcpSchema) {
         mcp = { ...rest, anyOf: anyOfItems };
       }
     }
+    const declaredType = mcp.type;
     if (!mcp.type) {
       if (mcp.properties || mcp.$ref) {
         mcp.type = "object";
@@ -119,6 +180,9 @@ function toGeminiSchema(mcpSchema) {
     if (mcp.description) {
       geminiSchema.description = mcp.description;
     }
+    if (keepsGeminiFormat(declaredType, mcp.format)) {
+      geminiSchema.format = mcp.format;
+    }
     if (mcp.enum) {
       geminiSchema.enum = mcp.enum.filter((v) => v != null).map(String);
     }
@@ -142,6 +206,10 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }
+    copySchemaConstraints(
+      mcp,
+      geminiSchema
+    );
     return geminiSchema;
   }
   __name(recursiveConvert, "recursiveConvert");
@@ -174,8 +242,7 @@ const GEMINI_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
 ]);
 const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "title",
-  "default",
-  "format"
+  "default"
 ]);
 function toGeminiSchemaField(key) {
   return toSnakeCaseName(key).replace(
@@ -220,41 +287,87 @@ function convertSchemaField(field, value) {
   if (field === "items" && isPlainObject(value)) {
     return openApiSchemaToGeminiSchema(value);
   }
-  if (field === "anyOf" && Array.isArray(value)) {
-    return value.map((item) => openApiSchemaToGeminiSchema(item));
-  }
   return value;
 }
 __name(convertSchemaField, "convertSchemaField");
+function isNullSchema(value) {
+  return isPlainObject(value) && value["type"] === "null";
+}
+__name(isNullSchema, "isNullSchema");
+function takeUnionBranches(schema) {
+  let branches;
+  for (const [key, value] of Object.entries(schema)) {
+    const field = toGeminiSchemaField(key);
+    if (field !== "anyOf" && field !== "oneOf") {
+      continue;
+    }
+    delete schema[key];
+    if (Array.isArray(value)) {
+      branches = [...branches != null ? branches : [], ...value];
+    }
+  }
+  return branches;
+}
+__name(takeUnionBranches, "takeUnionBranches");
 function openApiSchemaToGeminiSchema(openApiSchema) {
   if (openApiSchema === void 0 || openApiSchema === null) {
     return void 0;
   }
   if (!isPlainObject(openApiSchema)) {
-    throw new TypeError("openapi_schema must be a dictionary");
+    throw new TypeError("openApiSchema must be a plain object");
   }
   const source = { ...openApiSchema };
-  const [schemaType, nullable] = normalizeJsonSchemaType(source["type"]);
+  let unionNullable = false;
+  let anyOf;
+  const branches = takeUnionBranches(source);
+  if (branches) {
+    const nonNullBranches = branches.filter((branch) => !isNullSchema(branch));
+    unionNullable = nonNullBranches.length !== branches.length;
+    if (nonNullBranches.length === 1 && isPlainObject(nonNullBranches[0])) {
+      const merged = openApiSchemaToGeminiSchema({
+        ...nonNullBranches[0],
+        ...source
+      });
+      if (unionNullable) {
+        merged.nullable = true;
+      }
+      return merged;
+    } else if (nonNullBranches.length > 0) {
+      anyOf = nonNullBranches.map(
+        (branch) => openApiSchemaToGeminiSchema(branch)
+      );
+    }
+  }
+  const [schemaType, typeNullable] = normalizeJsonSchemaType(source["type"]);
   source["type"] = schemaType;
-  if (nullable) {
+  if (typeNullable || unionNullable) {
     source["nullable"] = true;
   }
-  if (!source["type"]) {
+  if (!source["type"] && !anyOf) {
     source["type"] = "object";
   }
   const converted = {};
   for (const [key, value] of Object.entries(source)) {
     const field = toGeminiSchemaField(key);
-    if (!GEMINI_SCHEMA_FIELDS.has(field) || GEMINI_REJECTED_SCHEMA_FIELDS.has(field)) {
+    if (value === void 0 || !GEMINI_SCHEMA_FIELDS.has(field) || GEMINI_REJECTED_SCHEMA_FIELDS.has(field)) {
+      continue;
+    }
+    if (field === "format") {
+      if (keepsGeminiFormat(schemaType, value)) {
+        converted[field] = value;
+      }
       continue;
     }
     converted[field] = convertSchemaField(field, value);
   }
+  if (anyOf) {
+    converted["anyOf"] = anyOf;
+  }
   return converted;
 }
 __name(openApiSchemaToGeminiSchema, "openApiSchemaToGeminiSchema");
 export {
-  normalizeJsonSchemaType,
+  copySchemaConstraints,
   openApiSchemaToGeminiSchema,
   toGeminiSchema
 };

package/dist/esm/utils/id_provider.js

@@ -0,0 +1,33 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { randomUUID } from "./env_aware_utils.js";
+let idProvider;
+function setIdProvider(provider) {
+  idProvider = provider;
+}
+__name(setIdProvider, "setIdProvider");
+function resetIdProvider() {
+  idProvider = void 0;
+}
+__name(resetIdProvider, "resetIdProvider");
+function newId() {
+  return newIdOr(randomUUID);
+}
+__name(newId, "newId");
+function newIdOr(fallback) {
+  return idProvider ? idProvider() : fallback();
+}
+__name(newIdOr, "newIdOr");
+export {
+  newId,
+  newIdOr,
+  resetIdProvider,
+  setIdProvider
+};

package/dist/esm/utils/model_name.js

@@ -35,6 +35,19 @@ function parseVersion(versionString) {
   };
 }
 __name(parseVersion, "parseVersion");
+function getGeminiMajorVersion(modelString) {
+  if (!modelString) {
+    return void 0;
+  }
+  const modelName = extractModelName(modelString);
+  if (!modelName.startsWith("gemini-")) {
+    return void 0;
+  }
+  const versionString = modelName.slice("gemini-".length).split("-", 1)[0];
+  const parsedVersion = parseVersion(versionString);
+  return parsedVersion.valid ? parsedVersion.major : void 0;
+}
+__name(getGeminiMajorVersion, "getGeminiMajorVersion");
 function isGemini1Model(modelString) {
   const modelName = extractModelName(modelString);
   return modelName.startsWith("gemini-1");
@@ -78,6 +91,7 @@ function isGeminiModelIdCheckDisabled() {
 __name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
 export {
   extractModelName,
+  getGeminiMajorVersion,
   isGemini1Model,
   isGemini2OrAbove,
   isGemini35LiveTranslate,

package/dist/esm/utils/simple_zod_to_json.js

@@ -12,6 +12,7 @@ import {
   zodToJsonSchema as toJSONSchemaV3
 } from "zod-to-json-schema";
 import { toJSONSchema as toJSONSchemaV4 } from "zod/v4";
+import { copySchemaConstraints } from "./gemini_schema_util.js";
 function isZodSchema(obj) {
   return obj !== null && typeof obj === "object" && "parse" in obj && typeof obj.parse === "function" && "safeParse" in obj && typeof obj.safeParse === "function";
 }
@@ -58,21 +59,10 @@ function zodObjectToSchema(schema) {
         if (jsonSchema.readOnly !== void 0) {
           delete jsonSchema.readOnly;
         }
-        if (jsonSchema.maxItems !== void 0) {
-          jsonSchema.maxItems = jsonSchema.maxItems.toString();
-        }
-        if (jsonSchema.format === "email" || jsonSchema.format === "uuid") {
-          delete jsonSchema.pattern;
-        }
-        if (jsonSchema.minItems !== void 0) {
-          jsonSchema.minItems = jsonSchema.minItems.toString();
-        }
-        if (jsonSchema.minLength !== void 0) {
-          jsonSchema.minLength = jsonSchema.minLength.toString();
-        }
-        if (jsonSchema.maxLength !== void 0) {
-          jsonSchema.maxLength = jsonSchema.maxLength.toString();
-        }
+        copySchemaConstraints(
+          jsonSchema,
+          jsonSchema
+        );
         if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === null) {
           jsonSchema.type = Type.NULL;
           delete jsonSchema.enum;
@@ -93,32 +83,24 @@ function zodObjectToSchema(schema) {
       $refStrategy: "none",
       emailStrategy: "format:email",
       postProcess: /* @__PURE__ */ __name((jsonSchema) => {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c;
         if (!jsonSchema) {
           return;
         }
         if (jsonSchema.additionalProperties !== void 0) {
           delete jsonSchema.additionalProperties;
         }
-        if (jsonSchema.maxItems !== void 0) {
-          jsonSchema.maxItems = (_a = jsonSchema.maxItems) == null ? void 0 : _a.toString();
-        }
-        if (jsonSchema.minItems !== void 0) {
-          jsonSchema.minItems = (_b = jsonSchema.minItems) == null ? void 0 : _b.toString();
-        }
-        if (jsonSchema.minLength !== void 0) {
-          jsonSchema.minLength = (_c = jsonSchema.minLength) == null ? void 0 : _c.toString();
-        }
-        if (jsonSchema.maxLength !== void 0) {
-          jsonSchema.maxLength = (_d = jsonSchema.maxLength) == null ? void 0 : _d.toString();
-        }
-        if (((_e = jsonSchema.enum) == null ? void 0 : _e.length) === 1 && jsonSchema.enum[0] === "null") {
+        copySchemaConstraints(
+          jsonSchema,
+          jsonSchema
+        );
+        if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === "null") {
           jsonSchema.type = Type.NULL;
           delete jsonSchema.enum;
         }
         if (jsonSchema.type === "integer" && jsonSchema.format !== "int64") {
-          (_f = jsonSchema.minimum) != null ? _f : jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
-          (_g = jsonSchema.maximum) != null ? _g : jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
+          (_b = jsonSchema.minimum) != null ? _b : jsonSchema.minimum = Number.MIN_SAFE_INTEGER;
+          (_c = jsonSchema.maximum) != null ? _c : jsonSchema.maximum = Number.MAX_SAFE_INTEGER;
         }
         if (jsonSchema.type !== void 0) {
           jsonSchema.type = jsonSchema.type.toUpperCase();

package/dist/esm/utils/ssrf_guard.js

@@ -1,14 +1,35 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { lookup } from "node:dns/promises";
-import { isIP } from "node:net";
+const DNS_MODULE = "node:dns/promises";
+const IPV6_CHARACTERS = /^[0-9a-f:.]+$/i;
 const HTTP_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
 const NON_GLOBAL_IPV4_CIDRS = [
   "0.0.0.0/8",
@@ -87,10 +108,15 @@ function isLinkLocalAddress(address) {
   return classifyAddress(address, isLinkLocalIpv4, isLinkLocalIpv6);
 }
 __name(isLinkLocalAddress, "isLinkLocalAddress");
+function isIpAddress(address) {
+  return parseIpv4(address) !== null || isIpv6Literal(address);
+}
+__name(isIpAddress, "isIpAddress");
 async function resolveHostAddresses(hostname) {
-  if (isIP(hostname) !== 0) {
+  if (isIpAddress(hostname)) {
     return [hostname];
   }
+  const { lookup } = await Promise.resolve().then(() => __toESM(require(DNS_MODULE)));
   const records = await lookup(hostname, { all: true });
   const addresses = [...new Set(records.map((record) => record.address))];
   if (addresses.length === 0) {
@@ -123,8 +149,20 @@ function parseIpv4(address) {
   return octets;
 }
 __name(parseIpv4, "parseIpv4");
+function isIpv6Literal(address) {
+  if (!address.includes(":") || !IPV6_CHARACTERS.test(address)) {
+    return false;
+  }
+  try {
+    new URL(`http://[${address}]/`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isIpv6Literal, "isIpv6Literal");
 function parseIpv6(address) {
-  if (isIP(address) !== 6) {
+  if (!isIpv6Literal(address)) {
     return null;
   }
   const [head, tail] = address.split("::");
@@ -151,14 +189,6 @@ function ipv4ToInt(octets) {
   return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
 }
 __name(ipv4ToInt, "ipv4ToInt");
-function hextetsToBigInt(hextets) {
-  let value = 0n;
-  for (const hextet of hextets) {
-    value = value << 16n | BigInt(hextet);
-  }
-  return value;
-}
-__name(hextetsToBigInt, "hextetsToBigInt");
 function parseIpv4Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
   const mask = 4294967295 << 32 - Number(prefix) >>> 0;
@@ -167,7 +197,7 @@ function parseIpv4Cidr(cidr) {
 __name(parseIpv4Cidr, "parseIpv4Cidr");
 function parseIpv6Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
-  return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
+  return { base: parseIpv6(address), prefix: Number(prefix) };
 }
 __name(parseIpv6Cidr, "parseIpv6Cidr");
 function matchesIpv4Cidr(octets, { base, mask }) {
@@ -175,8 +205,17 @@ function matchesIpv4Cidr(octets, { base, mask }) {
 }
 __name(matchesIpv4Cidr, "matchesIpv4Cidr");
 function matchesIpv6Cidr(hextets, { base, prefix }) {
-  const shift = BigInt(128 - prefix);
-  return hextetsToBigInt(hextets) >> shift === base >> shift;
+  for (let i = 0; i < base.length; i++) {
+    const bits = Math.min(16, prefix - i * 16);
+    if (bits <= 0) {
+      return true;
+    }
+    const mask = 65535 << 16 - bits & 65535;
+    if ((hextets[i] & mask) !== (base[i] & mask)) {
+      return false;
+    }
+  }
+  return true;
 }
 __name(matchesIpv6Cidr, "matchesIpv6Cidr");
 function embeddedIpv4(hextets) {
@@ -222,6 +261,7 @@ function isLinkLocalIpv6(hextets) {
 __name(isLinkLocalIpv6, "isLinkLocalIpv6");
 export {
   isHttpUrl,
+  isIpAddress,
   isLinkLocalAddress,
   isLocalhostHostname,
   isNonGlobalAddress,

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.4.0";
+const version = "2.5.0";
 export {
   version
 };

package/dist/esm/workflow/index.js

@@ -16,7 +16,7 @@ import { WorkflowNode, node } from "./node.js";
 import { FunctionNode } from "./nodes/function_node.js";
 import { JoinNode } from "./nodes/join_node.js";
 import { NodeTool } from "./nodes/node_tool.js";
-import { ParallelWorker } from "./nodes/parallel_worker.js";
+import { ParallelWorker, isParallelWorker } from "./nodes/parallel_worker.js";
 import { ToolNode } from "./nodes/tool_node.js";
 import { DEFAULT_ROUTE, Edge, Graph } from "./graph.js";
 import { BranchPath, commonPrefixOf, createSubBranch } from "./branch_path.js";
@@ -70,6 +70,7 @@ export {
   isNodeSchemaValidationError,
   isNodeState,
   isNodeTimeoutError,
+  isParallelWorker,
   isRequestInput,
   isRunnableRoot,
   isWorkflow,