@google/adk 2.4.0 → 2.5.0

package/dist/cjs/tools/toolbox_toolset.js

@@ -63,26 +63,43 @@ function isToolOptionsObject(value) {
   return typeof value === "object" && value !== null && "execute" in value && typeof value.execute === "function";
 }
 __name(isToolOptionsObject, "isToolOptionsObject");
+function wrapPrefixedBaseTool(rawTool, name) {
+  return new Proxy(rawTool, {
+    get(target, prop, receiver) {
+      if (prop === "name") {
+        return name;
+      }
+      if (prop === "_getDeclaration") {
+        return () => {
+          const declaration = target._getDeclaration();
+          return declaration ? { ...declaration, name } : void 0;
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+__name(wrapPrefixedBaseTool, "wrapPrefixedBaseTool");
 function wrapLoadedTool(rawTool, prefix) {
   var _a2;
   if ((0, import_base_tool.isBaseTool)(rawTool)) {
-    if (!prefix) {
+    const name = prefix ? `${prefix}_${rawTool.name}` : rawTool.name;
+    if (name === rawTool.name) {
       return rawTool;
     }
-    return Object.assign(
-      Object.create(Object.getPrototypeOf(rawTool)),
-      rawTool,
-      { name: `${prefix}_${rawTool.name}` }
-    );
+    return wrapPrefixedBaseTool(rawTool, name);
   }
   if (typeof rawTool === "function") {
     const fn = rawTool;
-    const baseName = fn.name || "toolbox_tool";
+    const baseName = typeof fn.getName === "function" ? fn.getName() : fn.toolName || (fn.name && fn.name !== "callable" ? fn.name : void 0) || "toolbox_tool";
     const name = prefix ? `${prefix}_${baseName}` : baseName;
-    const description = (_a2 = fn.description) != null ? _a2 : "";
+    const description = typeof fn.getDescription === "function" ? fn.getDescription() : (_a2 = fn.description) != null ? _a2 : "";
+    const parameters = typeof fn.getParamSchema === "function" ? fn.getParamSchema() : fn.parameters;
     return new import_function_tool.FunctionTool({
       name,
       description,
+      parameters,
       execute: fn
     });
   }
@@ -103,53 +120,55 @@ function wrapLoadedTool(rawTool, prefix) {
 __name(wrapLoadedTool, "wrapLoadedTool");
 const _ToolboxToolset = class _ToolboxToolset extends (_b = import_base_toolset.BaseToolset, _a = TOOLBOX_TOOLSET_SIGNATURE_SYMBOL, _b) {
   constructor(serverUrlOrOptions, extraOptions) {
-    var _a2, _b2, _c, _d;
+    var _a2, _b2, _c, _d, _e;
     const options = typeof serverUrlOrOptions === "string" ? { serverUrl: serverUrlOrOptions, ...extraOptions } : serverUrlOrOptions;
+    const normalizedServerUrl = (_a2 = options.serverUrl) == null ? void 0 : _a2.trim();
+    if (!options.client && !normalizedServerUrl) {
+      throw new Error("Either client or a non-empty serverUrl is required.");
+    }
     if ((!options.toolNames || options.toolNames.length === 0) && !options.toolsetName) {
       throw new Error("toolNames and toolsetName cannot both be undefined.");
     }
-    super((_a2 = options.toolFilter) != null ? _a2 : [], options.prefix);
+    super((_b2 = options.toolFilter) != null ? _b2 : [], options.prefix);
     /** A unique symbol to identify ADK ToolboxToolset class. */
     this[_a] = true;
     this.serverUrl = options.serverUrl;
     this.toolsetName = options.toolsetName;
     this.toolNames = options.toolNames;
-    this.authTokenGetters = (_b2 = options.authTokenGetters) != null ? _b2 : {};
-    this.boundParams = (_c = options.boundParams) != null ? _c : {};
-    this.toolboxClient = (_d = options.client) != null ? _d : createUnconfiguredToolboxToolsetClient(this.serverUrl);
+    this.authTokenGetters = (_c = options.authTokenGetters) != null ? _c : {};
+    this.boundParams = (_d = options.boundParams) != null ? _d : {};
+    this.toolboxClient = (_e = options.client) != null ? _e : createUnconfiguredToolboxToolsetClient(normalizedServerUrl != null ? normalizedServerUrl : "");
   }
   /**
    * Loads the configured toolset and/or individual tools from the Toolbox
    * client and returns the selected {@link BaseTool} instances.
    */
   async getTools(context) {
-    var _a2, _b2, _c, _d, _e, _f;
-    const loadOptions = {
-      authTokenGetters: this.authTokenGetters,
-      boundParams: this.boundParams
-    };
+    var _a2, _b2;
     const tools = [];
     if (this.toolsetName) {
-      const loader = (_c = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient)) != null ? _c : (_b2 = this.toolboxClient.load_toolset) == null ? void 0 : _b2.bind(this.toolboxClient);
+      const loader = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient);
       if (!loader) {
-        throw new Error(
-          "ToolboxClient does not implement loadToolset or load_toolset."
-        );
+        throw new Error("ToolboxClient does not implement loadToolset.");
       }
-      const loadedToolset = await loader(this.toolsetName, loadOptions);
+      const loadedToolset = await loader(
+        this.toolsetName,
+        this.authTokenGetters,
+        this.boundParams
+      );
       for (const rawTool of loadedToolset) {
         tools.push(wrapLoadedTool(rawTool, this.prefix));
       }
     }
     if (this.toolNames && this.toolNames.length > 0) {
-      const loader = (_f = (_d = this.toolboxClient.loadTool) == null ? void 0 : _d.bind(this.toolboxClient)) != null ? _f : (_e = this.toolboxClient.load_tool) == null ? void 0 : _e.bind(this.toolboxClient);
+      const loader = (_b2 = this.toolboxClient.loadTool) == null ? void 0 : _b2.bind(this.toolboxClient);
       if (!loader) {
-        throw new Error(
-          "ToolboxClient does not implement loadTool or load_tool."
-        );
+        throw new Error("ToolboxClient does not implement loadTool.");
       }
       const loadedSingleTools = await Promise.all(
-        this.toolNames.map((toolName) => loader(toolName, loadOptions))
+        this.toolNames.map(
+          (toolName) => loader(toolName, this.authTokenGetters, this.boundParams)
+        )
       );
       for (const rawTool of loadedSingleTools) {
         tools.push(wrapLoadedTool(rawTool, this.prefix));

package/dist/cjs/utils/async_queue.js

@@ -52,14 +52,43 @@ const _AsyncQueue = class _AsyncQueue {
    * immediately; otherwise the value is buffered. No-op once closed/failed.
    */
   push(value) {
-    if (this.closed) return;
+    this.enqueue(value);
+  }
+  /**
+   * Enqueues a value like {@link push}, and resolves once the consumer has
+   * finished with it: when it asks for the next item, or when the queue closes
+   * or fails. Resolves at once if the queue is already closed.
+   */
+  pushAndWait(value) {
+    return new Promise((resolve) => this.enqueue(value, resolve));
+  }
+  enqueue(value, ack) {
+    if (this.closed) {
+      ack == null ? void 0 : ack();
+      return;
+    }
     const resolver = this.resolvers.shift();
     if (resolver) {
+      this.deliveredAck = ack;
       resolver.resolve({ value, done: false });
     } else {
-      this.queue.push(value);
+      this.queue.push({ value, ack });
+    }
+  }
+  /** Releases every producer still waiting in {@link pushAndWait}. */
+  releaseAll() {
+    var _a;
+    this.releaseDelivered();
+    for (const item of this.queue) {
+      (_a = item.ack) == null ? void 0 : _a.call(item);
+      item.ack = void 0;
     }
   }
+  releaseDelivered() {
+    const ack = this.deliveredAck;
+    this.deliveredAck = void 0;
+    ack == null ? void 0 : ack();
+  }
   /**
    * Signals that production failed. Buffered items are still delivered first;
    * once the buffer drains, the consumer's next `next()` rejects with `error`.
@@ -69,6 +98,7 @@ const _AsyncQueue = class _AsyncQueue {
     if (this.failure) return;
     this.failure = { error };
     this.closed = true;
+    this.releaseAll();
     while (this.resolvers.length > 0) {
       this.resolvers.shift().reject(error);
     }
@@ -84,6 +114,7 @@ const _AsyncQueue = class _AsyncQueue {
   close() {
     if (this.closed) return;
     this.closed = true;
+    this.releaseAll();
     while (this.resolvers.length > 0) {
       this.resolvers.shift().resolve({ value: void 0, done: true });
     }
@@ -91,8 +122,11 @@ const _AsyncQueue = class _AsyncQueue {
   [Symbol.asyncIterator]() {
     return {
       next: /* @__PURE__ */ __name(() => {
+        this.releaseDelivered();
         if (this.queue.length > 0) {
-          return Promise.resolve({ value: this.queue.shift(), done: false });
+          const item = this.queue.shift();
+          this.deliveredAck = item.ack;
+          return Promise.resolve({ value: item.value, done: false });
         }
         if (this.failure) {
           return Promise.reject(this.failure.error);

package/dist/cjs/utils/client_labels.js

@@ -146,19 +146,17 @@ function mergeTrackingHeaders(headers) {
       otherHeaders.append(name, value);
     }
   }
-  const normalizedEntries = [];
+  const mergedEntries = /* @__PURE__ */ new Map();
   otherHeaders.forEach((value, name) => {
-    normalizedEntries.push([name, value]);
+    var _a2;
+    const key = (_a2 = originalNames.get(name)) != null ? _a2 : name;
+    const existing = mergedEntries.get(key);
+    mergedEntries.set(
+      key,
+      existing !== void 0 ? `${existing}, ${value}` : value
+    );
   });
-  const merged = Object.fromEntries(
-    normalizedEntries.map(([name, value]) => {
-      var _a2;
-      return [
-        (_a2 = originalNames.get(name)) != null ? _a2 : name,
-        value
-      ];
-    })
-  );
+  const merged = Object.fromEntries(mergedEntries);
   for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
     const tokens = trackingValue.split(" ");
     for (const value of (_b = callerValues.get(name)) != null ? _b : []) {

package/dist/cjs/utils/env_aware_utils.js

@@ -28,6 +28,7 @@ __export(env_aware_utils_exports, {
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
   getBooleanEnvVar: () => getBooleanEnvVar,
+  getEnvVar: () => getEnvVar,
   isBase64Encoded: () => isBase64Encoded,
   isBrowser: () => isBrowser,
   isEnterpriseModeEnabled: () => isEnterpriseModeEnabled,
@@ -97,11 +98,16 @@ function isBase64Encoded(data) {
   }
 }
 __name(isBase64Encoded, "isBase64Encoded");
-function getBooleanEnvVar(envVar) {
-  if (!process.env) {
-    return false;
+function getEnvVar(envVar) {
+  var _a;
+  if (typeof process === "undefined") {
+    return void 0;
   }
-  const envVarValue = (process.env[envVar] || "").toLowerCase();
+  return (_a = process.env) == null ? void 0 : _a[envVar];
+}
+__name(getEnvVar, "getEnvVar");
+function getBooleanEnvVar(envVar) {
+  const envVarValue = (getEnvVar(envVar) || "").toLowerCase();
   return ["true", "1"].includes(envVarValue);
 }
 __name(getBooleanEnvVar, "getBooleanEnvVar");
@@ -115,9 +121,8 @@ function warnDeprecatedEnterpriseModeEnvVar(message) {
 }
 __name(warnDeprecatedEnterpriseModeEnvVar, "warnDeprecatedEnterpriseModeEnvVar");
 function isEnterpriseModeEnabled() {
-  var _a, _b;
-  const deprecatedIsSet = ((_a = process.env) == null ? void 0 : _a[DEPRECATED_ENTERPRISE_MODE_ENV_VAR]) !== void 0;
-  if (((_b = process.env) == null ? void 0 : _b[ENTERPRISE_MODE_ENV_VAR]) !== void 0) {
+  const deprecatedIsSet = getEnvVar(DEPRECATED_ENTERPRISE_MODE_ENV_VAR) !== void 0;
+  if (getEnvVar(ENTERPRISE_MODE_ENV_VAR) !== void 0) {
     if (deprecatedIsSet) {
       warnDeprecatedEnterpriseModeEnvVar(
         `${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is set but ignored because ${ENTERPRISE_MODE_ENV_VAR} takes precedence. ${DEPRECATED_ENTERPRISE_MODE_ENV_VAR} is deprecated, please use ${ENTERPRISE_MODE_ENV_VAR} instead.`
@@ -139,6 +144,7 @@ __name(isEnterpriseModeEnabled, "isEnterpriseModeEnabled");
   base64Decode,
   base64Encode,
   getBooleanEnvVar,
+  getEnvVar,
   isBase64Encoded,
   isBrowser,
   isEnterpriseModeEnabled,

package/dist/cjs/utils/error_utils.js

@@ -26,7 +26,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var error_utils_exports = {};
 __export(error_utils_exports, {
   formatError: () => formatError,
-  getErrorMessage: () => getErrorMessage
+  getErrorMessage: () => getErrorMessage,
+  isInvocationCancellation: () => isInvocationCancellation,
+  toError: () => toError
 });
 module.exports = __toCommonJS(error_utils_exports);
 /**
@@ -43,6 +45,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") {
@@ -124,5 +160,7 @@ __name(formatError, "formatError");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   formatError,
-  getErrorMessage
+  getErrorMessage,
+  isInvocationCancellation,
+  toError
 });

package/dist/cjs/utils/failover_utils.js

@@ -41,10 +41,7 @@ async function* runWithRouting(items, context, router, runFn) {
   }
   let selectedKey = initialKey;
   import_logger.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;
@@ -74,10 +71,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;
@@ -86,8 +80,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");
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/utils/gemini_schema_util.js

@@ -25,7 +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, {
-  normalizeJsonSchemaType: () => normalizeJsonSchemaType,
+  copySchemaConstraints: () => copySchemaConstraints,
   openApiSchemaToGeminiSchema: () => openApiSchemaToGeminiSchema,
   toGeminiSchema: () => toGeminiSchema
 });
@@ -67,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;
@@ -111,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";
@@ -147,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);
     }
@@ -170,6 +234,10 @@ function toGeminiSchema(mcpSchema) {
         geminiSchema.items = recursiveConvert(mcp.items);
       }
     }
+    copySchemaConstraints(
+      mcp,
+      geminiSchema
+    );
     return geminiSchema;
   }
   __name(recursiveConvert, "recursiveConvert");
@@ -202,8 +270,7 @@ const GEMINI_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
 ]);
 const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "title",
-  "default",
-  "format"
+  "default"
 ]);
 function toGeminiSchemaField(key) {
   return (0, import_case_utils.toSnakeCaseName)(key).replace(
@@ -248,42 +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 };
-  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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  normalizeJsonSchemaType,
+  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
+});