@google/adk 2.3.0 → 2.5.0

package/dist/cjs/tools/toolbox_toolset.js

@@ -0,0 +1,193 @@
+/**
+  * @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 toolbox_toolset_exports = {};
+__export(toolbox_toolset_exports, {
+  ToolboxToolset: () => ToolboxToolset,
+  isToolboxToolset: () => isToolboxToolset
+});
+module.exports = __toCommonJS(toolbox_toolset_exports);
+var import_base_tool = require("./base_tool.js");
+var import_base_toolset = require("./base_toolset.js");
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+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 ((0, import_base_tool.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 import_function_tool.FunctionTool({
+      name,
+      description,
+      parameters,
+      execute: fn
+    });
+  }
+  if (isToolOptionsObject(rawTool)) {
+    const baseTool = new import_function_tool.FunctionTool(rawTool);
+    if (!prefix) {
+      return baseTool;
+    }
+    return new import_function_tool.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 = import_base_toolset.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolboxToolset,
+  isToolboxToolset
+});

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

@@ -67,20 +67,7 @@ const _WebMCPToolset = class _WebMCPToolset extends import_base_toolset.BaseTool
         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));
-    }
-    import_logger.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/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

@@ -129,7 +129,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();
@@ -139,9 +140,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/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,15 +41,12 @@ 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) {
-    const generatorOrPromise = runFn(selectedItem);
     let firstYielded = false;
     try {
+      const generatorOrPromise = runFn(selectedItem);
       if (isAsyncGenerator(generatorOrPromise)) {
         for await (const result2 of generatorOrPromise) {
           yield result2;
@@ -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: