@google/adk 1.6.0 → 2.1.0

package/dist/cjs/utils/schema.js

@@ -0,0 +1,178 @@
+/**
+  * @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 schema_exports = {};
+__export(schema_exports, {
+  compileJsonSchema: () => compileJsonSchema,
+  objectSchemaFields: () => objectSchemaFields,
+  parseWithSchema: () => parseWithSchema,
+  toJsonSchema: () => toJsonSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_v4 = require("zod/v4");
+var import_genai_schema_to_json = require("./genai_schema_to_json.js");
+var import_simple_zod_to_json = require("./simple_zod_to_json.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const genaiValidators = /* @__PURE__ */ new WeakMap();
+function genaiSchemaValidator(schema) {
+  const cached = genaiValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let validator = null;
+  try {
+    validator = import_v4.z.fromJSONSchema(
+      (0, import_genai_schema_to_json.genaiSchemaToJsonSchema)(schema)
+    );
+  } catch {
+    validator = null;
+  }
+  genaiValidators.set(schema, validator);
+  return validator != null ? validator : void 0;
+}
+__name(genaiSchemaValidator, "genaiSchemaValidator");
+function parseWithSchema(schema, value) {
+  if (schema === void 0) {
+    return value;
+  }
+  if ((0, import_simple_zod_to_json.isZodSchema)(schema)) {
+    return schema.parse(value);
+  }
+  const validator = genaiSchemaValidator(schema);
+  return validator ? validator.parse(value) : value;
+}
+__name(parseWithSchema, "parseWithSchema");
+function toJsonSchema(schema) {
+  if ((0, import_simple_zod_to_json.isZodV4Schema)(schema)) {
+    return (0, import_v4.toJSONSchema)(schema);
+  }
+  if ((0, import_simple_zod_to_json.isZodV3Schema)(schema)) {
+    return (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
+  }
+  return (0, import_genai_schema_to_json.genaiSchemaToJsonSchema)(schema);
+}
+__name(toJsonSchema, "toJsonSchema");
+function compileJsonSchema(jsonSchema) {
+  if (jsonSchema === null || typeof jsonSchema !== "object") {
+    return void 0;
+  }
+  try {
+    return import_v4.z.fromJSONSchema(jsonSchema);
+  } catch {
+    return void 0;
+  }
+}
+__name(compileJsonSchema, "compileJsonSchema");
+const objectFieldValidators = /* @__PURE__ */ new WeakMap();
+function objectSchemaFields(schema) {
+  const cached = objectFieldValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let fields = null;
+  try {
+    const document = toJsonSchema(schema);
+    const properties = document["properties"];
+    if (properties && typeof properties === "object") {
+      fields = new Map(
+        Object.entries(properties).map(
+          ([name, fieldSchema]) => [name, compileField(fieldSchema, document)]
+        )
+      );
+    }
+  } catch {
+    fields = null;
+  }
+  objectFieldValidators.set(schema, fields);
+  return fields != null ? fields : void 0;
+}
+__name(objectSchemaFields, "objectSchemaFields");
+const UNRESOLVABLE_REF = /* @__PURE__ */ Symbol("unresolvable-ref");
+function compileField(fieldSchema, document) {
+  try {
+    return compileJsonSchema(inlineRefs(fieldSchema, document));
+  } catch {
+    return void 0;
+  }
+}
+__name(compileField, "compileField");
+function resolvePointer(document, ref) {
+  if (!ref.startsWith("#")) {
+    throw UNRESOLVABLE_REF;
+  }
+  let node = document;
+  for (const rawSegment of ref.slice(1).split("/").filter(Boolean)) {
+    const segment = decodeURIComponent(rawSegment).replaceAll("~1", "/").replaceAll("~0", "~");
+    if (node === null || typeof node !== "object") {
+      throw UNRESOLVABLE_REF;
+    }
+    node = node[segment];
+  }
+  if (node === void 0) {
+    throw UNRESOLVABLE_REF;
+  }
+  return node;
+}
+__name(resolvePointer, "resolvePointer");
+function inlineRefs(node, document, seen = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    return node.map((item) => inlineRefs(item, document, seen));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const entries = Object.entries(node);
+  const ref = node["$ref"];
+  if (typeof ref === "string") {
+    if (seen.has(ref)) {
+      throw UNRESOLVABLE_REF;
+    }
+    const target = inlineRefs(
+      resolvePointer(document, ref),
+      document,
+      /* @__PURE__ */ new Set([...seen, ref])
+    );
+    const siblings = Object.fromEntries(
+      entries.filter(([key]) => key !== "$ref")
+    );
+    return { ...target, ...siblings };
+  }
+  return Object.fromEntries(
+    entries.map(([key, value]) => [key, inlineRefs(value, document, seen)])
+  );
+}
+__name(inlineRefs, "inlineRefs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileJsonSchema,
+  objectSchemaFields,
+  parseWithSchema,
+  toJsonSchema
+});

package/dist/cjs/utils/simple_zod_to_json.js

@@ -9,6 +9,7 @@ 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 });
@@ -25,6 +26,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var simple_zod_to_json_exports = {};
 __export(simple_zod_to_json_exports, {
   isZodObject: () => isZodObject,
+  isZodSchema: () => isZodSchema,
+  isZodV3Schema: () => isZodV3Schema,
+  isZodV4Schema: () => isZodV4Schema,
   zodObjectToSchema: () => zodObjectToSchema
 });
 module.exports = __toCommonJS(simple_zod_to_json_exports);
@@ -39,12 +43,15 @@ var import_v4 = require("zod/v4");
 function isZodSchema(obj) {
   return obj !== null && typeof obj === "object" && "parse" in obj && typeof obj.parse === "function" && "safeParse" in obj && typeof obj.safeParse === "function";
 }
+__name(isZodSchema, "isZodSchema");
 function isZodV3Schema(obj) {
   return isZodSchema(obj) && !("_zod" in obj);
 }
+__name(isZodV3Schema, "isZodV3Schema");
 function isZodV4Schema(obj) {
   return isZodSchema(obj) && "_zod" in obj;
 }
+__name(isZodV4Schema, "isZodV4Schema");
 function getZodTypeName(schema) {
   var _a, _b;
   const schemaAny = schema;
@@ -57,9 +64,11 @@ function getZodTypeName(schema) {
   }
   return void 0;
 }
+__name(getZodTypeName, "getZodTypeName");
 function isZodObject(obj) {
   return isZodSchema(obj) && getZodTypeName(obj) === "ZodObject";
 }
+__name(isZodObject, "isZodObject");
 function zodObjectToSchema(schema) {
   if (!isZodObject(schema)) {
     throw new Error("Expected a Zod Object");
@@ -68,7 +77,7 @@ function zodObjectToSchema(schema) {
     return (0, import_v4.toJSONSchema)(schema, {
       target: "openapi-3.0",
       io: "input",
-      override: (ctx) => {
+      override: /* @__PURE__ */ __name((ctx) => {
         var _a;
         const { jsonSchema } = ctx;
         if (jsonSchema.additionalProperties !== void 0) {
@@ -99,14 +108,14 @@ function zodObjectToSchema(schema) {
         if (jsonSchema.type !== void 0) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
-      }
+      }, "override")
     });
   }
   if (isZodV3Schema(schema)) {
     return (0, import_zod_to_json_schema.zodToJsonSchema)(schema, {
       target: "openApi3",
       emailStrategy: "format:email",
-      postProcess: (jsonSchema) => {
+      postProcess: /* @__PURE__ */ __name((jsonSchema) => {
         var _a, _b, _c, _d, _e, _f, _g;
         if (!jsonSchema) {
           return;
@@ -138,13 +147,17 @@ function zodObjectToSchema(schema) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
         return jsonSchema;
-      }
+      }, "postProcess")
     });
   }
   throw new Error("Unsupported Zod schema version.");
 }
+__name(zodObjectToSchema, "zodObjectToSchema");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isZodObject,
+  isZodSchema,
+  isZodV3Schema,
+  isZodV4Schema,
   zodObjectToSchema
 });

package/dist/cjs/utils/ssrf_guard.js

@@ -0,0 +1,262 @@
+/**
+  * @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 ssrf_guard_exports = {};
+__export(ssrf_guard_exports, {
+  isHttpUrl: () => isHttpUrl,
+  isLinkLocalAddress: () => isLinkLocalAddress,
+  isLocalhostHostname: () => isLocalhostHostname,
+  isNonGlobalAddress: () => isNonGlobalAddress,
+  normalizeHost: () => normalizeHost,
+  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 HTTP_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+const NON_GLOBAL_IPV4_CIDRS = [
+  "0.0.0.0/8",
+  // "this host on this network"
+  "10.0.0.0/8",
+  // private
+  "100.64.0.0/10",
+  // shared address space / CGNAT
+  "127.0.0.0/8",
+  // loopback
+  "169.254.0.0/16",
+  // link-local (includes GCP metadata 169.254.169.254)
+  "172.16.0.0/12",
+  // private
+  "192.0.0.0/24",
+  // IETF protocol assignments
+  "192.0.2.0/24",
+  // TEST-NET-1 (documentation)
+  "192.88.99.0/24",
+  // 6to4 relay anycast (deprecated)
+  "192.168.0.0/16",
+  // private
+  "198.18.0.0/15",
+  // benchmarking
+  "198.51.100.0/24",
+  // TEST-NET-2 (documentation)
+  "203.0.113.0/24",
+  // TEST-NET-3 (documentation)
+  "224.0.0.0/4",
+  // multicast
+  "240.0.0.0/4"
+  // reserved / future use (includes 255.255.255.255)
+].map(parseIpv4Cidr);
+const NON_GLOBAL_IPV6_CIDRS = [
+  "::/128",
+  // unspecified
+  "::1/128",
+  // loopback
+  "64:ff9b:1::/48",
+  // local NAT64
+  "100::/64",
+  // discard-only
+  "2001:db8::/32",
+  // documentation
+  "fc00::/7",
+  // unique-local (ULA, private)
+  "fe80::/10",
+  // link-local
+  "ff00::/8"
+  // multicast
+].map(parseIpv6Cidr);
+const LINK_LOCAL_IPV4_CIDR = parseIpv4Cidr("169.254.0.0/16");
+const LINK_LOCAL_IPV6_CIDR = parseIpv6Cidr("fe80::/10");
+const IPV4_MAPPED_CIDR = parseIpv6Cidr("::ffff:0:0/96");
+const NAT64_CIDR = parseIpv6Cidr("64:ff9b::/96");
+const SIX_TO_FOUR_CIDR = parseIpv6Cidr("2002::/16");
+const IPV4_COMPATIBLE_CIDR = parseIpv6Cidr("::/96");
+function isHttpUrl(url) {
+  return HTTP_SCHEMES.has(url.protocol);
+}
+__name(isHttpUrl, "isHttpUrl");
+function isLocalhostHostname(hostname) {
+  const normalized = hostname.replace(/\.+$/, "").toLowerCase();
+  return normalized === "localhost" || normalized.endsWith(".localhost");
+}
+__name(isLocalhostHostname, "isLocalhostHostname");
+function normalizeHost(hostname) {
+  return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
+}
+__name(normalizeHost, "normalizeHost");
+function isNonGlobalAddress(address) {
+  return classifyAddress(address, isNonGlobalIpv4, isNonGlobalIpv6);
+}
+__name(isNonGlobalAddress, "isNonGlobalAddress");
+function isLinkLocalAddress(address) {
+  return classifyAddress(address, isLinkLocalIpv4, isLinkLocalIpv6);
+}
+__name(isLinkLocalAddress, "isLinkLocalAddress");
+async function resolveHostAddresses(hostname) {
+  if ((0, import_node_net.isIP)(hostname) !== 0) {
+    return [hostname];
+  }
+  const records = await (0, import_promises.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}`);
+  }
+  return addresses;
+}
+__name(resolveHostAddresses, "resolveHostAddresses");
+function classifyAddress(address, matchesIpv4, matchesIpv6) {
+  const octets = parseIpv4(address);
+  if (octets) {
+    return matchesIpv4(octets);
+  }
+  const hextets = parseIpv6(address);
+  if (hextets) {
+    return matchesIpv6(hextets);
+  }
+  return true;
+}
+__name(classifyAddress, "classifyAddress");
+function parseIpv4(address) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
+  if (!match) {
+    return null;
+  }
+  const octets = match.slice(1).map(Number);
+  if (octets.some((octet) => octet > 255)) {
+    return null;
+  }
+  return octets;
+}
+__name(parseIpv4, "parseIpv4");
+function parseIpv6(address) {
+  if ((0, import_node_net.isIP)(address) !== 6) {
+    return null;
+  }
+  const [head, tail] = address.split("::");
+  const highGroups = head ? expandHextets(head) : [];
+  const lowGroups = tail ? expandHextets(tail) : [];
+  const compressed = address.includes("::") ? new Array(8 - highGroups.length - lowGroups.length).fill(0) : [];
+  return [...highGroups, ...compressed, ...lowGroups];
+}
+__name(parseIpv6, "parseIpv6");
+function expandHextets(fragment) {
+  const hextets = [];
+  for (const group of fragment.split(":")) {
+    if (group.includes(".")) {
+      const octets = parseIpv4(group);
+      hextets.push(octets[0] << 8 | octets[1], octets[2] << 8 | octets[3]);
+    } else {
+      hextets.push(parseInt(group, 16));
+    }
+  }
+  return hextets;
+}
+__name(expandHextets, "expandHextets");
+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;
+  return { base: (ipv4ToInt(parseIpv4(address)) & mask) >>> 0, mask };
+}
+__name(parseIpv4Cidr, "parseIpv4Cidr");
+function parseIpv6Cidr(cidr) {
+  const [address, prefix] = cidr.split("/");
+  return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
+}
+__name(parseIpv6Cidr, "parseIpv6Cidr");
+function matchesIpv4Cidr(octets, { base, mask }) {
+  return (ipv4ToInt(octets) & mask) >>> 0 === base;
+}
+__name(matchesIpv4Cidr, "matchesIpv4Cidr");
+function matchesIpv6Cidr(hextets, { base, prefix }) {
+  const shift = BigInt(128 - prefix);
+  return hextetsToBigInt(hextets) >> shift === base >> shift;
+}
+__name(matchesIpv6Cidr, "matchesIpv6Cidr");
+function embeddedIpv4(hextets) {
+  if (matchesIpv6Cidr(hextets, SIX_TO_FOUR_CIDR)) {
+    return hextetsToOctets(hextets[1], hextets[2]);
+  }
+  if (matchesIpv6Cidr(hextets, IPV4_MAPPED_CIDR) || matchesIpv6Cidr(hextets, NAT64_CIDR)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
+  }
+  if (matchesIpv6Cidr(hextets, IPV4_COMPATIBLE_CIDR) && (hextets[6] !== 0 || hextets[7] > 1)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
+  }
+  return null;
+}
+__name(embeddedIpv4, "embeddedIpv4");
+function hextetsToOctets(high, low) {
+  return [high >> 8, high & 255, low >> 8, low & 255];
+}
+__name(hextetsToOctets, "hextetsToOctets");
+function isNonGlobalIpv4(octets) {
+  return NON_GLOBAL_IPV4_CIDRS.some((cidr) => matchesIpv4Cidr(octets, cidr));
+}
+__name(isNonGlobalIpv4, "isNonGlobalIpv4");
+function isNonGlobalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isNonGlobalIpv4(embedded);
+  }
+  return NON_GLOBAL_IPV6_CIDRS.some((cidr) => matchesIpv6Cidr(hextets, cidr));
+}
+__name(isNonGlobalIpv6, "isNonGlobalIpv6");
+function isLinkLocalIpv4(octets) {
+  return matchesIpv4Cidr(octets, LINK_LOCAL_IPV4_CIDR);
+}
+__name(isLinkLocalIpv4, "isLinkLocalIpv4");
+function isLinkLocalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isLinkLocalIpv4(embedded);
+  }
+  return matchesIpv6Cidr(hextets, LINK_LOCAL_IPV6_CIDR);
+}
+__name(isLinkLocalIpv6, "isLinkLocalIpv6");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isHttpUrl,
+  isLinkLocalAddress,
+  isLocalhostHostname,
+  isNonGlobalAddress,
+  normalizeHost,
+  resolveHostAddresses
+});

package/dist/cjs/utils/streaming_utils.js

@@ -9,6 +9,7 @@ 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 });
@@ -39,7 +40,7 @@ var import_llm_response = require("../models/llm_response.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-class ProgressiveStrategy {
+const _ProgressiveStrategy = class _ProgressiveStrategy {
   constructor() {
     this.partsSequence = [];
     this.currentTextBuffer = "";
@@ -221,8 +222,10 @@ class ProgressiveStrategy {
     }
     return finalParts;
   }
-}
-class NonProgressiveStrategy {
+};
+__name(_ProgressiveStrategy, "ProgressiveStrategy");
+let ProgressiveStrategy = _ProgressiveStrategy;
+const _NonProgressiveStrategy = class _NonProgressiveStrategy {
   constructor() {
     this.text = "";
     this.thoughtText = "";
@@ -296,8 +299,10 @@ class NonProgressiveStrategy {
     }
     return void 0;
   }
-}
-class StreamingResponseAggregator {
+};
+__name(_NonProgressiveStrategy, "NonProgressiveStrategy");
+let NonProgressiveStrategy = _NonProgressiveStrategy;
+const _StreamingResponseAggregator = class _StreamingResponseAggregator {
   constructor(isProgressiveMode = (0, import_feature_registry.isFeatureEnabled)(
     import_feature_registry.FeatureName.PROGRESSIVE_SSE_STREAMING
   )) {
@@ -375,10 +380,13 @@ class StreamingResponseAggregator {
       partial: false
     };
   }
-}
+};
+__name(_StreamingResponseAggregator, "StreamingResponseAggregator");
+let StreamingResponseAggregator = _StreamingResponseAggregator;
 function isEmptyContentPart(part) {
   return !part.functionCall && !part.functionResponse && !part.fileData && !part.inlineData && !part.executableCode && !part.codeExecutionResult && (!part.text || part.text === "");
 }
+__name(isEmptyContentPart, "isEmptyContentPart");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StreamingResponseAggregator,

package/dist/cjs/utils/task.js

@@ -9,6 +9,7 @@ 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 });
@@ -32,14 +33,14 @@ module.exports = __toCommonJS(task_exports);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class Task {
+const _Task = class _Task {
   constructor(executable) {
     this.executable = executable;
     this.isDone = false;
     this.abortController = new AbortController();
-    const markDone = () => {
+    const markDone = /* @__PURE__ */ __name(() => {
       this.isDone = true;
-    };
+    }, "markDone");
     this.promise = executable(this.abortController.signal);
     this.promise.then(markDone).catch(markDone);
   }
@@ -55,7 +56,9 @@ class Task {
   done() {
     return this.isDone;
   }
-}
+};
+__name(_Task, "Task");
+let Task = _Task;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Task

package/dist/cjs/utils/variant_utils.js

@@ -9,6 +9,7 @@ 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 });
@@ -40,8 +41,9 @@ var GoogleLLMVariant = /* @__PURE__ */ ((GoogleLLMVariant2) => {
   return GoogleLLMVariant2;
 })(GoogleLLMVariant || {});
 function getGoogleLlmVariant() {
-  return (0, import_env_aware_utils.getBooleanEnvVar)("GOOGLE_GENAI_USE_VERTEXAI") ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+  return (0, import_env_aware_utils.isEnterpriseModeEnabled)() ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
 }
+__name(getGoogleLlmVariant, "getGoogleLlmVariant");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GoogleLLMVariant,

package/dist/cjs/utils/vertex_ai_utils.js

@@ -9,6 +9,7 @@ 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 });
@@ -41,11 +42,12 @@ function getExpressModeApiKey(project, location, expressModeApiKey) {
       "Cannot specify project or location and expressModeApiKey. Either use project and location, or just the expressModeApiKey."
     );
   }
-  if ((0, import_env_aware_utils.getBooleanEnvVar)("GOOGLE_GENAI_USE_VERTEXAI")) {
+  if ((0, import_env_aware_utils.isEnterpriseModeEnabled)()) {
     return expressModeApiKey || process.env.GOOGLE_API_KEY;
   }
   return void 0;
 }
+__name(getExpressModeApiKey, "getExpressModeApiKey");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EXPRESS_MODE_UNSUPPORTED_MESSAGE,

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 = "1.6.0";
+const version = "2.1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version