@google/adk 2.3.0 → 2.5.0

package/dist/cjs/utils/gemini_schema_util.js

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var gemini_schema_util_exports = {};
 __export(gemini_schema_util_exports, {
+  copySchemaConstraints: () => copySchemaConstraints,
   openApiSchemaToGeminiSchema: () => openApiSchemaToGeminiSchema,
   toGeminiSchema: () => toGeminiSchema
 });
@@ -66,6 +67,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;
@@ -110,6 +171,7 @@ function toGeminiSchema(mcpSchema) {
         mcp = { ...rest, anyOf: anyOfItems };
       }
     }
+    const declaredType = mcp.type;
     if (!mcp.type) {
       if (mcp.properties || mcp.$ref) {
         mcp.type = "object";
@@ -146,6 +208,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);
     }
@@ -169,6 +234,10 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }
+    copySchemaConstraints(
+      mcp,
+      geminiSchema
+    );
     return geminiSchema;
   }
   __name(recursiveConvert, "recursiveConvert");
@@ -201,10 +270,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 (0, import_case_utils.toSnakeCaseName)(key).replace(
     /_([a-z0-9])/g,
@@ -216,6 +283,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);
@@ -231,41 +315,88 @@ 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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  copySchemaConstraints,
   openApiSchemaToGeminiSchema,
   toGeminiSchema
 });

package/dist/cjs/utils/id_provider.js

@@ -0,0 +1,63 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var id_provider_exports = {};
+__export(id_provider_exports, {
+  newId: () => newId,
+  newIdOr: () => newIdOr,
+  resetIdProvider: () => resetIdProvider,
+  setIdProvider: () => setIdProvider
+});
+module.exports = __toCommonJS(id_provider_exports);
+var import_env_aware_utils = require("./env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let idProvider;
+function setIdProvider(provider) {
+  idProvider = provider;
+}
+__name(setIdProvider, "setIdProvider");
+function resetIdProvider() {
+  idProvider = void 0;
+}
+__name(resetIdProvider, "resetIdProvider");
+function newId() {
+  return newIdOr(import_env_aware_utils.randomUUID);
+}
+__name(newId, "newId");
+function newIdOr(fallback) {
+  return idProvider ? idProvider() : fallback();
+}
+__name(newIdOr, "newIdOr");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  newId,
+  newIdOr,
+  resetIdProvider,
+  setIdProvider
+});

package/dist/cjs/utils/logger_node.js

@@ -62,6 +62,10 @@ const _WinstonLogger = class _WinstonLogger {
         "warn": import_logger.LogLevel.WARN,
         "error": import_logger.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/cjs/utils/model_name.js

@@ -26,6 +26,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var model_name_exports = {};
 __export(model_name_exports, {
   extractModelName: () => extractModelName,
+  getGeminiMajorVersion: () => getGeminiMajorVersion,
   isGemini1Model: () => isGemini1Model,
   isGemini2OrAbove: () => isGemini2OrAbove,
   isGemini35LiveTranslate: () => isGemini35LiveTranslate,
@@ -68,6 +69,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");
@@ -112,6 +126,7 @@ __name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   extractModelName,
+  getGeminiMajorVersion,
   isGemini1Model,
   isGemini2OrAbove,
   isGemini35LiveTranslate,

package/dist/cjs/utils/output_schema_utils.js

@@ -28,6 +28,7 @@ __export(output_schema_utils_exports, {
   canUseOutputSchemaWithTools: () => canUseOutputSchemaWithTools
 });
 module.exports = __toCommonJS(output_schema_utils_exports);
+var import_google_llm = require("../models/google_llm.js");
 var import_model_name = require("./model_name.js");
 var import_variant_utils = require("./variant_utils.js");
 /**
@@ -35,8 +36,10 @@ var import_variant_utils = require("./variant_utils.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-function canUseOutputSchemaWithTools(modelString) {
-  return (0, import_variant_utils.getGoogleLlmVariant)() === import_variant_utils.GoogleLLMVariant.VERTEX_AI && (0, import_model_name.isGemini2OrAbove)(modelString);
+function canUseOutputSchemaWithTools(model) {
+  const modelString = typeof model === "string" ? model : model.model;
+  const variant = (0, import_google_llm.isGemini)(model) ? model.apiBackend : (0, import_variant_utils.getGoogleLlmVariant)();
+  return variant === import_variant_utils.GoogleLLMVariant.VERTEX_AI && (0, import_model_name.isGemini2OrAbove)(modelString);
 }
 __name(canUseOutputSchemaWithTools, "canUseOutputSchemaWithTools");
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/utils/simple_zod_to_json.js

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(simple_zod_to_json_exports);
 var import_genai = require("@google/genai");
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var import_v4 = require("zod/v4");
+var import_gemini_schema_util = require("./gemini_schema_util.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -86,21 +87,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();
-        }
+        (0, import_gemini_schema_util.copySchemaConstraints)(
+          jsonSchema,
+          jsonSchema
+        );
         if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === null) {
           jsonSchema.type = import_genai.Type.NULL;
           delete jsonSchema.enum;
@@ -121,32 +111,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") {
+        (0, import_gemini_schema_util.copySchemaConstraints)(
+          jsonSchema,
+          jsonSchema
+        );
+        if (((_a = jsonSchema.enum) == null ? void 0 : _a.length) === 1 && jsonSchema.enum[0] === "null") {
           jsonSchema.type = import_genai.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/cjs/utils/ssrf_guard.js

@@ -5,9 +5,11 @@
   */
 
 "use strict";
+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 __export = (target, all) => {
@@ -22,10 +24,19 @@ var __copyProps = (to, from, except, desc) => {
   }
   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
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssrf_guard_exports = {};
 __export(ssrf_guard_exports, {
   isHttpUrl: () => isHttpUrl,
+  isIpAddress: () => isIpAddress,
   isLinkLocalAddress: () => isLinkLocalAddress,
   isLocalhostHostname: () => isLocalhostHostname,
   isNonGlobalAddress: () => isNonGlobalAddress,
@@ -33,13 +44,13 @@ __export(ssrf_guard_exports, {
   resolveHostAddresses: () => resolveHostAddresses
 });
 module.exports = __toCommonJS(ssrf_guard_exports);
-var import_promises = require("node:dns/promises");
-var import_node_net = require("node:net");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+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",
@@ -118,11 +129,16 @@ 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 ((0, import_node_net.isIP)(hostname) !== 0) {
+  if (isIpAddress(hostname)) {
     return [hostname];
   }
-  const records = await (0, import_promises.lookup)(hostname, { all: true });
+  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) {
     throw new Error(`Unable to resolve host: ${hostname}`);
@@ -154,8 +170,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 ((0, import_node_net.isIP)(address) !== 6) {
+  if (!isIpv6Literal(address)) {
     return null;
   }
   const [head, tail] = address.split("::");
@@ -182,14 +210,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;
@@ -198,7 +218,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 }) {
@@ -206,8 +226,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) {
@@ -254,6 +283,7 @@ __name(isLinkLocalIpv6, "isLinkLocalIpv6");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isHttpUrl,
+  isIpAddress,
   isLinkLocalAddress,
   isLocalhostHostname,
   isNonGlobalAddress,

package/dist/cjs/utils/task.js

@@ -42,7 +42,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/cjs/version.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(version_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.3.0";
+const version = "2.5.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/cjs/workflow/index.js

@@ -55,6 +55,7 @@ __export(workflow_exports, {
   isNodeSchemaValidationError: () => import_errors.isNodeSchemaValidationError,
   isNodeState: () => import_node_state.isNodeState,
   isNodeTimeoutError: () => import_errors.isNodeTimeoutError,
+  isParallelWorker: () => import_parallel_worker.isParallelWorker,
   isRequestInput: () => import_request_input.isRequestInput,
   isRunnableRoot: () => import_run_node_as_invocation.isRunnableRoot,
   isWorkflow: () => import_workflow.isWorkflow,
@@ -121,6 +122,7 @@ var import_node_error_event = require("./node_error_event.js");
   isNodeSchemaValidationError,
   isNodeState,
   isNodeTimeoutError,
+  isParallelWorker,
   isRequestInput,
   isRunnableRoot,
   isWorkflow,