@google/adk 2.3.0 → 2.5.0

package/dist/esm/tools/openapi_tool/openapi_toolset.js

@@ -16,7 +16,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import { experimental } from "../../utils/experimental.js";
 import { logger } from "../../utils/logger.js";
 import { BaseToolset } from "../base_toolset.js";
@@ -40,7 +40,8 @@ let OpenAPIToolset = class extends BaseToolset {
       throw new Error("Either specDict or specStr must be provided.");
     }
     const parser = new OpenApiSpecParser({
-      preservePropertyNames: options.preservePropertyNames
+      preservePropertyNames: options.preservePropertyNames,
+      unconstrainedObjectBodyAsParameter: options.unconstrainedObjectBodyAsParameter
     });
     const parsedOperations = parser.parse(spec);
     for (const op of parsedOperations) {
@@ -61,7 +62,8 @@ let OpenAPIToolset = class extends BaseToolset {
         {
           preservePropertyNames: options.preservePropertyNames,
           headerProvider: options.headerProvider,
-          credentialKey: options.credentialKey
+          credentialKey: options.credentialKey,
+          unconstrainedObjectBodyAsParameter: options.unconstrainedObjectBodyAsParameter
         }
       );
       this.tools.push(tool);
@@ -76,15 +78,7 @@ let OpenAPIToolset = class extends BaseToolset {
     }
   }
   async getTools(context) {
-    return this.tools.filter((tool) => {
-      if (Array.isArray(this.toolFilter) && this.toolFilter.length > 0) {
-        return this.toolFilter.includes(tool.name);
-      }
-      if (context) {
-        return this.isToolSelected(tool, context);
-      }
-      return true;
-    });
+    return this.tools.filter((tool) => this.isToolSelected(tool, context));
   }
   getTool(toolName) {
     return this.tools.find((tool) => tool.name === toolName);

package/dist/esm/tools/openapi_tool/rest_api_tool.js

@@ -176,6 +176,32 @@ function encodePathParamValue(name, value) {
   return encodeURIComponent(value);
 }
 __name(encodePathParamValue, "encodePathParamValue");
+function toParamString(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== void 0 && item !== null).map(toParamString).join(",");
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.entries(value).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${k},${toParamString(v)}`).join(",");
+  }
+  return String(value);
+}
+__name(toParamString, "toParamString");
+function serializeQueryValue(value) {
+  return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+}
+__name(serializeQueryValue, "serializeQueryValue");
+function appendParamValue(target, name, value) {
+  if (!Array.isArray(value)) {
+    target.append(name, serializeQueryValue(value));
+    return;
+  }
+  for (const item of value) {
+    if (item !== void 0 && item !== null) {
+      target.append(name, serializeQueryValue(item));
+    }
+  }
+}
+__name(appendParamValue, "appendParamValue");
 function prepareRequestParams(endpoint, parameters, args) {
   const headers = {};
   const queryParams = new URLSearchParams();
@@ -190,18 +216,24 @@ function prepareRequestParams(endpoint, parameters, args) {
     const originalName = param.originalName;
     const location = param.paramLocation;
     if (location === "path") {
-      pathParams[originalName] = encodePathParamValue(
-        originalName,
-        String(argValue)
-      );
+      if (argValue !== void 0 && argValue !== null) {
+        pathParams[originalName] = encodePathParamValue(
+          originalName,
+          toParamString(argValue)
+        );
+      }
     } else if (location === "query") {
       if (argValue !== void 0 && argValue !== null && argValue !== "") {
-        queryParams.append(originalName, String(argValue));
+        appendParamValue(queryParams, originalName, argValue);
       }
     } else if (location === "header") {
-      headers[originalName] = String(argValue);
+      if (argValue !== void 0 && argValue !== null) {
+        headers[originalName] = toParamString(argValue);
+      }
     } else if (location === "cookie") {
-      cookies[originalName] = String(argValue);
+      if (argValue !== void 0 && argValue !== null) {
+        cookies[originalName] = toParamString(argValue);
+      }
     } else if (location === "body") {
       if (originalName === "body" || originalName === "array" || originalName === "") {
         body = argValue;
@@ -235,6 +267,18 @@ function isRawBody(value) {
   return typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Blob;
 }
 __name(isRawBody, "isRawBody");
+function isFormFields(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isFormFields, "isFormFields");
+function appendFormFields(target, fields) {
+  for (const [name, value] of Object.entries(fields)) {
+    if (value !== void 0 && value !== null) {
+      appendParamValue(target, name, value);
+    }
+  }
+}
+__name(appendFormFields, "appendFormFields");
 function prepareRequestBody(requestBody, body, bodyData, headers) {
   const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
   if (requestBody && "content" in requestBody) {
@@ -245,13 +289,16 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
         headers["Content-Type"] = mimeType;
         return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
       } else if (mimeType === "application/x-www-form-urlencoded") {
+        if (isFormFields(finalData)) {
+          const formParams = new URLSearchParams();
+          appendFormFields(formParams, finalData);
+          return formParams;
+        }
         return new URLSearchParams(finalData);
       } else if (mimeType === "multipart/form-data") {
         const formData = new FormData();
         if (typeof finalData === "object" && finalData !== null) {
-          for (const [key, value] of Object.entries(finalData)) {
-            formData.append(key, String(value));
-          }
+          appendFormFields(formData, finalData);
         }
         return formData;
       } else if (mimeType === "application/octet-stream") {

package/dist/esm/tools/skill/load_skill_resource_tool.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { Type } from "@google/genai";
 import path from "node:path";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import { guessMimeType } from "../../utils/file_utils.js";
 import {
@@ -72,6 +73,11 @@ let LoadSkillResourceTool = class extends BaseTool {
       };
     }
     resourcePath = path.posix.normalize(resourcePath);
+    const skillActivity = recordSkillActivity({
+      kind: "resource",
+      skillName,
+      resourcePath
+    });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -90,6 +96,7 @@ let LoadSkillResourceTool = class extends BaseTool {
         error_code: "SKILL_NOT_FOUND"
       };
     }
+    skillActivity.recordSkill(skill);
     let content;
     const skillResources = skill.resources || {};
     if (resourcePath.startsWith("references/")) {

package/dist/esm/tools/skill/load_skill_tool.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { Type } from "@google/genai";
 import { requireAgent } from "../../agents/invocation_context.js";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import { BaseTool } from "../base_tool.js";
 let LoadSkillTool = class extends BaseTool {
@@ -55,6 +56,7 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "MISSING_SKILL_NAME"
       };
     }
+    const skillActivity = recordSkillActivity({ kind: "load", skillName });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -73,6 +75,7 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "SKILL_NOT_FOUND"
       };
     }
+    skillActivity.recordSkill(skill);
     const agentName = requireAgent(toolContext.invocationContext).name;
     const stateKey = `_adk_activated_skill_${agentName}`;
     const currentActivated = toolContext.state.get(stateKey) || [];

package/dist/esm/tools/skill/run_skill_script_tool.js

@@ -22,6 +22,7 @@ import { isLlmAgent } from "../../agents/llm_agent.js";
 import {
   CodeExecutionLanguage
 } from "../../code_executors/code_execution_utils.js";
+import { recordSkillActivity } from "../../telemetry/api/instrumentation.js";
 import { experimental } from "../../utils/experimental.js";
 import {
   getMimeTypeAndEncoding,
@@ -81,6 +82,11 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "MISSING_SCRIPT_PATH"
       };
     }
+    const skillActivity = recordSkillActivity({
+      kind: "script",
+      skillName,
+      scriptPath
+    });
     let skill;
     try {
       skill = await this.toolset.getOrFetchSkill(
@@ -99,9 +105,11 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "SKILL_NOT_FOUND"
       };
     }
-    const relScriptPath = scriptPath.startsWith("scripts/") ? scriptPath.substring("scripts/".length) : scriptPath;
+    skillActivity.recordSkill(skill);
+    let relScriptPath = scriptPath.startsWith("scripts/") ? scriptPath.substring("scripts/".length) : scriptPath;
     let script = (_b = (_a = skill.resources) == null ? void 0 : _a.scripts) == null ? void 0 : _b[relScriptPath];
     if (!script) {
+      relScriptPath = scriptPath;
       script = (_d = (_c = skill.resources) == null ? void 0 : _c.scripts) == null ? void 0 : _d[scriptPath];
     }
     if (!script) {
@@ -128,7 +136,9 @@ let RunSkillScriptTool = class extends BaseTool {
       const result = await codeExecutor.executeCode({
         invocationContext: toolContext.invocationContext,
         codeExecutionInput: {
-          code: buildWrapperCode(scriptPath, language),
+          // Scripts are always written under scripts/ (see
+          // getSkillResourceFiles), with or without the prefix in script_path.
+          code: buildWrapperCode(`scripts/${relScriptPath}`, language),
           inputFiles: getSkillResourceFiles(skill),
           language,
           args: scriptArgs

package/dist/esm/tools/toolbox_toolset.js

@@ -0,0 +1,167 @@
+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
+ */
+var _a, _b;
+import { isBaseTool } from "./base_tool.js";
+import { BaseToolset } from "./base_toolset.js";
+import {
+  FunctionTool
+} from "./function_tool.js";
+const TOOLBOX_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.toolboxToolset"
+);
+function isToolboxToolset(obj) {
+  return typeof obj === "object" && obj !== null && TOOLBOX_TOOLSET_SIGNATURE_SYMBOL in obj && obj[TOOLBOX_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isToolboxToolset, "isToolboxToolset");
+function createUnconfiguredToolboxToolsetClient(serverUrl) {
+  const throwMissingClient = /* @__PURE__ */ __name(() => {
+    throw new Error(
+      `ToolboxToolset requires a ToolboxToolsetClientLike instance (for endpoint "${serverUrl}"). Pass {serverUrl, client} to the ToolboxToolset constructor.`
+    );
+  }, "throwMissingClient");
+  return {
+    loadTool: throwMissingClient,
+    loadToolset: throwMissingClient,
+    close: /* @__PURE__ */ __name(() => {
+    }, "close")
+  };
+}
+__name(createUnconfiguredToolboxToolsetClient, "createUnconfiguredToolboxToolsetClient");
+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 (isBaseTool(rawTool)) {
+    const name = prefix ? `${prefix}_${rawTool.name}` : rawTool.name;
+    if (name === rawTool.name) {
+      return rawTool;
+    }
+    return wrapPrefixedBaseTool(rawTool, name);
+  }
+  if (typeof rawTool === "function") {
+    const fn = rawTool;
+    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 = typeof fn.getDescription === "function" ? fn.getDescription() : (_a2 = fn.description) != null ? _a2 : "";
+    const parameters = typeof fn.getParamSchema === "function" ? fn.getParamSchema() : fn.parameters;
+    return new FunctionTool({
+      name,
+      description,
+      parameters,
+      execute: fn
+    });
+  }
+  if (isToolOptionsObject(rawTool)) {
+    const baseTool = new FunctionTool(rawTool);
+    if (!prefix) {
+      return baseTool;
+    }
+    return new FunctionTool({
+      ...rawTool,
+      name: `${prefix}_${baseTool.name}`
+    });
+  }
+  throw new TypeError(
+    "Unsupported Toolbox tool shape: expected a BaseTool, ToolOptions object, or function."
+  );
+}
+__name(wrapLoadedTool, "wrapLoadedTool");
+const _ToolboxToolset = class _ToolboxToolset extends (_b = BaseToolset, _a = TOOLBOX_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  constructor(serverUrlOrOptions, extraOptions) {
+    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((_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 = (_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;
+    const tools = [];
+    if (this.toolsetName) {
+      const loader = (_a2 = this.toolboxClient.loadToolset) == null ? void 0 : _a2.bind(this.toolboxClient);
+      if (!loader) {
+        throw new Error("ToolboxClient does not implement loadToolset.");
+      }
+      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 = (_b2 = this.toolboxClient.loadTool) == null ? void 0 : _b2.bind(this.toolboxClient);
+      if (!loader) {
+        throw new Error("ToolboxClient does not implement loadTool.");
+      }
+      const loadedSingleTools = await Promise.all(
+        this.toolNames.map(
+          (toolName) => loader(toolName, this.authTokenGetters, this.boundParams)
+        )
+      );
+      for (const rawTool of loadedSingleTools) {
+        tools.push(wrapLoadedTool(rawTool, this.prefix));
+      }
+    }
+    return tools.filter((tool) => this.isToolSelected(tool, context));
+  }
+  /**
+   * Closes the underlying Toolbox client.
+   */
+  async close() {
+    var _a2, _b2;
+    await ((_b2 = (_a2 = this.toolboxClient).close) == null ? void 0 : _b2.call(_a2));
+  }
+};
+__name(_ToolboxToolset, "ToolboxToolset");
+let ToolboxToolset = _ToolboxToolset;
+export {
+  ToolboxToolset,
+  isToolboxToolset
+};

package/dist/esm/tools/webmcp/webmcp_toolset.js

@@ -41,20 +41,7 @@ const _WebMCPToolset = class _WebMCPToolset extends BaseToolset {
         document: this.doc
       })
     );
-    const filter = this.toolFilter;
-    if (!filter || Array.isArray(filter) && filter.length === 0) {
-      return tools;
-    }
-    if (Array.isArray(filter)) {
-      return tools.filter((tool) => filter.includes(tool.name));
-    }
-    if (context) {
-      return tools.filter((tool) => filter(tool, context));
-    }
-    logger.warn(
-      "WebMCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
-    );
-    return tools;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Subscribes to the WebMCP `toolchange` event, which fires when the page

package/dist/esm/utils/async_queue.js

@@ -26,14 +26,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`.
@@ -43,6 +72,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);
     }
@@ -58,6 +88,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 });
     }
@@ -65,8 +96,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/esm/utils/client_labels.js

@@ -99,7 +99,8 @@ function headerEntries(headers) {
 __name(headerEntries, "headerEntries");
 function mergeTrackingHeaders(headers) {
   var _a, _b;
-  const merged = {};
+  const otherHeaders = new Headers();
+  const originalNames = /* @__PURE__ */ new Map();
   const callerValues = /* @__PURE__ */ new Map();
   for (const [name, value] of headerEntries(headers)) {
     const lowerName = name.toLowerCase();
@@ -109,9 +110,23 @@ function mergeTrackingHeaders(headers) {
         value
       ]);
     } else {
-      merged[name] = value;
+      if (!originalNames.has(lowerName)) {
+        originalNames.set(lowerName, name);
+      }
+      otherHeaders.append(name, value);
     }
   }
+  const mergedEntries = /* @__PURE__ */ new Map();
+  otherHeaders.forEach((value, name) => {
+    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(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/esm/utils/env_aware_utils.js

@@ -65,11 +65,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");
@@ -83,9 +88,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.`
@@ -106,6 +110,7 @@ export {
   base64Decode,
   base64Encode,
   getBooleanEnvVar,
+  getEnvVar,
   isBase64Encoded,
   isBrowser,
   isEnterpriseModeEnabled,

package/dist/esm/utils/error_utils.js

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

package/dist/esm/utils/failover_utils.js

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