@google/adk 2.3.0 → 2.5.0

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,10 +242,8 @@ const GEMINI_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
 ]);
 const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "title",
-  "default",
-  "format"
+  "default"
 ]);
-const EMPTY_OBJECT_PLACEHOLDER = "dummy_DO_NOT_GENERATE";
 function toGeminiSchemaField(key) {
   return toSnakeCaseName(key).replace(
     /_([a-z0-9])/g,
@@ -189,6 +255,23 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isPlainObject, "isPlainObject");
+function normalizeJsonSchemaType(jsonSchemaType) {
+  if (typeof jsonSchemaType === "string") {
+    if (jsonSchemaType === "null") {
+      return [void 0, true];
+    }
+    return [jsonSchemaType, false];
+  }
+  if (Array.isArray(jsonSchemaType)) {
+    const nullable = jsonSchemaType.includes("null");
+    const nonNullTypes = jsonSchemaType.filter(
+      (t) => typeof t === "string" && t !== "null"
+    );
+    return [nonNullTypes[0], nullable];
+  }
+  return [void 0, false];
+}
+__name(normalizeJsonSchemaType, "normalizeJsonSchemaType");
 function convertSchemaField(field, value) {
   if (field === "type") {
     return toGeminiType(typeof value === "string" ? value : void 0);
@@ -204,40 +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 };
-  if (!source["type"]) {
-    source["type"] = "object";
+  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 properties = source["properties"];
-  const hasProperties = isPlainObject(properties) && Object.keys(properties).length > 0;
-  if (source["type"] === "object" && !hasProperties) {
-    source["properties"] = { [EMPTY_OBJECT_PLACEHOLDER]: { type: "string" } };
+  const [schemaType, typeNullable] = normalizeJsonSchemaType(source["type"]);
+  source["type"] = schemaType;
+  if (typeNullable || unionNullable) {
+    source["nullable"] = true;
+  }
+  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 {
+  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/logger_node.js

@@ -25,6 +25,10 @@ const _WinstonLogger = class _WinstonLogger {
         "warn": LogLevel.WARN,
         "error": LogLevel.ERROR
       },
+      // `levels` above inverts winston's npm ordering, so `error` (3) is the
+      // most permissive and leaves winston pass-through. Every method already
+      // gates on `this.logLevel`; a lower value here would double-gate and
+      // drop records.
       level: "error",
       format: winston.format.combine(
         winston.format.label({ label: "ADK" }),

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/output_schema_utils.js

@@ -7,10 +7,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { isGemini } from "../models/google_llm.js";
 import { isGemini2OrAbove } from "./model_name.js";
 import { getGoogleLlmVariant, GoogleLLMVariant } from "./variant_utils.js";
-function canUseOutputSchemaWithTools(modelString) {
-  return getGoogleLlmVariant() === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
+function canUseOutputSchemaWithTools(model) {
+  const modelString = typeof model === "string" ? model : model.model;
+  const variant = isGemini(model) ? model.apiBackend : getGoogleLlmVariant();
+  return variant === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
 }
 __name(canUseOutputSchemaWithTools, "canUseOutputSchemaWithTools");
 export {

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/utils/task.js

@@ -16,7 +16,7 @@ const _Task = class _Task {
       this.isDone = true;
     }, "markDone");
     this.promise = executable(this.abortController.signal);
-    this.promise.then(markDone).catch(markDone);
+    this.promise.then(markDone, markDone);
   }
   /**
    * Cancels the task execution.

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.3.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,