@google/adk 2.2.1 → 2.4.0

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js

@@ -19,6 +19,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
+import { AuthSchemeType } from "../../../../auth/auth_schemes.js";
 import { experimental } from "../../../../utils/experimental.js";
 function checkSchemeCredentialType(authScheme, authCredential) {
   if (!authCredential) {
@@ -26,7 +27,7 @@ function checkSchemeCredentialType(authScheme, authCredential) {
       "auth_credential is empty. Please create AuthCredential using OAuth2Auth."
     );
   }
-  if (authScheme.type !== "openIdConnect" && authScheme.type !== "oauth2") {
+  if (authScheme.type !== AuthSchemeType.OPEN_ID_CONNECT && authScheme.type !== AuthSchemeType.OAUTH2) {
     throw new Error(
       `Invalid security scheme, expect AuthSchemeType.openIdConnect or AuthSchemeType.oauth2 auth scheme, but got ${authScheme.type}`
     );
@@ -54,12 +55,12 @@ function generateAuthToken(authCredential) {
 }
 __name(generateAuthToken, "generateAuthToken");
 function exchangeCredential(authScheme, authCredential) {
-  var _a, _b;
+  var _a;
   checkSchemeCredentialType(authScheme, authCredential);
   if (authCredential.http) {
     return authCredential;
   }
-  if (((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) || ((_b = authCredential.oauth2) == null ? void 0 : _b.refreshToken)) {
+  if ((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) {
     return generateAuthToken(authCredential);
   }
   return null;

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js

@@ -17,6 +17,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { GoogleAuth, JWT } from "google-auth-library";
+import { createSign } from "node:crypto";
 import {
   AuthCredentialTypes
 } from "../../../../auth/auth_credential.js";
@@ -24,6 +25,83 @@ import { experimental } from "../../../../utils/experimental.js";
 import { AuthCredentialMissingError } from "./base_auth_credential_exchanger.js";
 const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
 const MISSING_SERVICE_ACCOUNT_CREDENTIALS = "Service account credentials are missing. Please provide them, or set `useDefaultCredential: true` to use application default credentials in a hosted service like Cloud Run.";
+const GOOGLE_TOKEN_URI = "https://oauth2.googleapis.com/token";
+const JWT_BEARER_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:jwt-bearer";
+const ASSERTION_LIFETIME_SECONDS = 3600;
+const TOKEN_REQUEST_TIMEOUT_MS = 3e4;
+function hasCustomTokenUri(creds) {
+  return !!creds.tokenUri && creds.tokenUri !== GOOGLE_TOKEN_URI;
+}
+__name(hasCustomTokenUri, "hasCustomTokenUri");
+function base64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+__name(base64UrlJson, "base64UrlJson");
+function signJwtBearerAssertion(creds, scopes, issuedAt) {
+  const header = {
+    alg: "RS256",
+    typ: "JWT",
+    ...creds.privateKeyId ? { kid: creds.privateKeyId } : {}
+  };
+  const payload = {
+    iss: creds.clientEmail,
+    scope: scopes.join(" "),
+    aud: GOOGLE_TOKEN_URI,
+    iat: issuedAt,
+    exp: issuedAt + ASSERTION_LIFETIME_SECONDS
+  };
+  const signingInput = `${base64UrlJson(header)}.${base64UrlJson(payload)}`;
+  const signature = createSign("RSA-SHA256").update(signingInput).sign(creds.privateKey, "base64url");
+  return `${signingInput}.${signature}`;
+}
+__name(signJwtBearerAssertion, "signJwtBearerAssertion");
+async function readTokenErrorDetail(response) {
+  try {
+    const body = await response.json();
+    if (typeof body !== "object" || body === null) {
+      return void 0;
+    }
+    const parts = [];
+    if ("error" in body && typeof body.error === "string" && body.error.length > 0) {
+      parts.push(body.error);
+    }
+    if ("error_description" in body && typeof body.error_description === "string" && body.error_description.length > 0) {
+      parts.push(body.error_description);
+    }
+    return parts.length > 0 ? parts.join(": ") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readTokenErrorDetail, "readTokenErrorDetail");
+async function requestJwtBearerToken(creds, scopes) {
+  const assertion = signJwtBearerAssertion(
+    creds,
+    scopes,
+    Math.floor(Date.now() / 1e3)
+  );
+  const response = await fetch(creds.tokenUri, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: JWT_BEARER_GRANT_TYPE,
+      assertion
+    }),
+    signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const detail = await readTokenErrorDetail(response);
+    throw new Error(
+      detail ? `Token endpoint responded with HTTP ${response.status}: ${detail}` : `Token endpoint responded with HTTP ${response.status}`
+    );
+  }
+  const body = await response.json();
+  if (typeof body === "object" && body !== null && "access_token" in body && typeof body.access_token === "string") {
+    return body.access_token;
+  }
+  return void 0;
+}
+__name(requestJwtBearerToken, "requestJwtBearerToken");
 let ServiceAccountCredentialExchanger = class {
   async exchange(params) {
     const { authCredential } = params;
@@ -64,21 +142,27 @@ let ServiceAccountCredentialExchanger = class {
     }
   }
   async exchangeForExplicitCredential(saConfig) {
+    var _a;
     const creds = saConfig.serviceAccountCredential;
     if (!creds) {
       throw new AuthCredentialMissingError(MISSING_SERVICE_ACCOUNT_CREDENTIALS);
     }
     try {
-      const client = new JWT({
-        email: creds.clientEmail,
-        key: creds.privateKey,
-        keyId: creds.privateKeyId,
-        projectId: creds.projectId,
-        universeDomain: creds.universeDomain,
-        scopes: saConfig.scopes
-      });
-      const tokens = await client.authorize();
-      const token = tokens.access_token;
+      let token;
+      if (hasCustomTokenUri(creds)) {
+        token = await requestJwtBearerToken(creds, (_a = saConfig.scopes) != null ? _a : []);
+      } else {
+        const client = new JWT({
+          email: creds.clientEmail,
+          key: creds.privateKey,
+          keyId: creds.privateKeyId,
+          projectId: creds.projectId,
+          universeDomain: creds.universeDomain,
+          scopes: saConfig.scopes
+        });
+        const tokens = await client.authorize();
+        token = tokens.access_token;
+      }
       if (!token) {
         throw new Error("Failed to get access token from explicit credentials");
       }

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

@@ -29,15 +29,27 @@ const VALID_SCHEMA_TYPES = /* @__PURE__ */ new Set([
   "string"
 ]);
 let OpenApiSpecParser = class {
+  /**
+   * @param options.preservePropertyNames Keeps the original parameter and
+   *     function names instead of converting them to snake_case.
+   * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+   *     parameter named `body` when an object request body schema has no
+   *     properties. Defaults to `false`.
+   *     @deprecated Retained for backwards compatibility; empty object schemas
+   *     produce no parameters by default. This option will be removed in a
+   *     future release.
+   */
   constructor(options = {}) {
-    var _a;
+    var _a, _b;
     this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+    this.unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
   }
   parse(openapiSpec) {
     const resolvedSpec = resolveReferences(openapiSpec);
     const sanitizedSpec = sanitizeSchemaTypes(resolvedSpec);
     return collectOperations(sanitizedSpec, {
-      preservePropertyNames: this.preservePropertyNames
+      preservePropertyNames: this.preservePropertyNames,
+      unconstrainedObjectBodyAsParameter: this.unconstrainedObjectBodyAsParameter
     });
   }
 };
@@ -172,17 +184,18 @@ function resolveServerUrl(server) {
 }
 __name(resolveServerUrl, "resolveServerUrl");
 function collectOperations(spec, options = {}) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  const unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
   const operations = [];
-  const server = (_b = spec.servers) == null ? void 0 : _b[0];
+  const server = (_c = spec.servers) == null ? void 0 : _c[0];
   const baseUrl = server ? resolveServerUrl(server) : "";
   const globalSecurity = spec.security || [];
   let globalSchemeName;
   if (globalSecurity.length > 0) {
     globalSchemeName = Object.keys(globalSecurity[0])[0];
   }
-  const authSchemes = ((_c = spec.components) == null ? void 0 : _c.securitySchemes) || {};
+  const authSchemes = ((_d = spec.components) == null ? void 0 : _d.securitySchemes) || {};
   for (const [path, pathItem] of Object.entries(spec.paths || {})) {
     if (!pathItem) continue;
     const methods = [
@@ -205,7 +218,8 @@ function collectOperations(spec, options = {}) {
         operation.operationId = toSnakeCaseName(`${path}_${method}`);
       }
       const parser = new OperationParser(operation, {
-        preservePropertyNames
+        preservePropertyNames,
+        unconstrainedObjectBodyAsParameter
       });
       let authSchemeName;
       if (operation.security && operation.security.length > 0) {

package/dist/esm/tools/openapi_tool/openapi_spec_parser/operation_parser.js

@@ -34,13 +34,20 @@ let OperationParser = class {
    *     function names instead of converting them to snake_case.
    * @param options.shouldParse Whether to parse the operation during
    *     construction. Defaults to `true`.
+   * @param options.unconstrainedObjectBodyAsParameter Emits a whole-body
+   *     parameter named `body` when an object request body schema has no
+   *     properties. Defaults to `false`.
+   *     @deprecated Retained for backwards compatibility; empty object schemas
+   *     produce no parameters by default. This option will be removed in a
+   *     future release.
    */
   constructor(operation, options = {}) {
     this.params = [];
-    var _a, _b;
+    var _a, _b, _c;
     this.operation = typeof operation === "string" ? JSON.parse(operation) : operation;
     this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
-    if ((_b = options.shouldParse) != null ? _b : true) {
+    this.unconstrainedObjectBodyAsParameter = (_b = options.unconstrainedObjectBodyAsParameter) != null ? _b : false;
+    if ((_c = options.shouldParse) != null ? _c : true) {
       this.processOperationParameters();
       this.processRequestBody();
       this.returnValue = this.processReturnValue();
@@ -60,6 +67,7 @@ let OperationParser = class {
     return renameReservedKeywords(toSnakeCaseName(originalName));
   }
   processOperationParameters() {
+    var _a;
     const parameters = this.operation.parameters || [];
     for (const param of parameters) {
       if ("name" in param) {
@@ -70,9 +78,12 @@ let OperationParser = class {
         this.params.push({
           originalName,
           paramLocation: location,
-          paramSchema: schema,
+          paramSchema: {
+            ...schema,
+            description: schema.description || description || void 0
+          },
           description,
-          required: param.required || false,
+          required: (_a = param.required) != null ? _a : false,
           name: this.getParamName(originalName)
         });
       }
@@ -108,7 +119,7 @@ let OperationParser = class {
               });
             }
           }
-        } else {
+        } else if (this.unconstrainedObjectBodyAsParameter) {
           this.params.push({
             originalName: "",
             paramLocation: "body",
@@ -129,7 +140,7 @@ let OperationParser = class {
         });
       } else {
         this.params.push({
-          originalName: "body",
+          originalName: "",
           paramLocation: "body",
           paramSchema: schema,
           description,

package/dist/esm/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
  */
 import { cloneDeep } from "lodash-es";
 import {
+  AuthCredentialTypes,
   isAuthCredential
 } from "../../../auth/auth_credential.js";
 import { experimental } from "../../../utils/experimental.js";
@@ -26,6 +27,16 @@ import { logger } from "../../../utils/logger.js";
 import { AutoAuthCredentialExchanger } from "../auth/credential_exchangers/auto_auth_credential_exchanger.js";
 import { AuthCredentialMissingError } from "../auth/credential_exchangers/base_auth_credential_exchanger.js";
 const DEFAULT_CREDENTIAL_KEY = "default_openapi_key";
+const INTERACTIVE_CREDENTIAL_TYPES = /* @__PURE__ */ new Set([
+  AuthCredentialTypes.OAUTH2,
+  AuthCredentialTypes.OPEN_ID_CONNECT
+]);
+function isMissingInteractiveToken(result) {
+  var _a, _b;
+  const { credential, wasExchanged } = result;
+  return !wasExchanged && INTERACTIVE_CREDENTIAL_TYPES.has(credential.authType) && !credential.http && !((_a = credential.oauth2) == null ? void 0 : _a.accessToken) && !((_b = credential.oauth2) == null ? void 0 : _b.refreshToken);
+}
+__name(isMissingInteractiveToken, "isMissingInteractiveToken");
 const _ToolContextCredentialStore = class _ToolContextCredentialStore {
   constructor(context) {
     this.context = context;
@@ -141,7 +152,8 @@ let ToolAuthHandler = class {
     };
   }
   /**
-   * Exchanges `credential`, or returns `undefined` when the exchange failed.
+   * Exchanges `credential`, or returns `undefined` when the exchange failed or
+   * produced an interactive credential that still holds no token.
    *
    * An exchange failure is transient far more often than it is fatal, so it
    * becomes a `pending` result the client can resume from rather than an
@@ -151,10 +163,11 @@ let ToolAuthHandler = class {
     var _a;
     const exchanger = (_a = this.credentialExchanger) != null ? _a : new AutoAuthCredentialExchanger();
     try {
-      return await exchanger.exchange({
+      const result = await exchanger.exchange({
         authScheme: this.authScheme,
         authCredential: credential
       });
+      return isMissingInteractiveToken(result) ? void 0 : result;
     } catch (e) {
       logger.error(
         `Failed to exchange credential: ${e instanceof Error ? e.message : e}`

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,22 @@ function encodePathParamValue(name, value) {
   return encodeURIComponent(value);
 }
 __name(encodePathParamValue, "encodePathParamValue");
+function serializeQueryValue(value) {
+  return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+}
+__name(serializeQueryValue, "serializeQueryValue");
+function appendQueryParam(queryParams, name, value) {
+  if (!Array.isArray(value)) {
+    queryParams.append(name, serializeQueryValue(value));
+    return;
+  }
+  for (const item of value) {
+    if (item !== void 0 && item !== null) {
+      queryParams.append(name, serializeQueryValue(item));
+    }
+  }
+}
+__name(appendQueryParam, "appendQueryParam");
 function prepareRequestParams(endpoint, parameters, args) {
   const headers = {};
   const queryParams = new URLSearchParams();
@@ -196,7 +212,7 @@ function prepareRequestParams(endpoint, parameters, args) {
       );
     } else if (location === "query") {
       if (argValue !== void 0 && argValue !== null && argValue !== "") {
-        queryParams.append(originalName, String(argValue));
+        appendQueryParam(queryParams, originalName, argValue);
       }
     } else if (location === "header") {
       headers[originalName] = String(argValue);

package/dist/esm/tools/retrieval/base_retrieval_tool.js

@@ -7,9 +7,22 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a, _b;
 import { Type } from "@google/genai";
 import { BaseTool } from "../base_tool.js";
-const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
+const BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.baseRetrievalTool"
+);
+function isBaseRetrievalTool(obj) {
+  return typeof obj === "object" && obj !== null && BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL] === true;
+}
+__name(isBaseRetrievalTool, "isBaseRetrievalTool");
+const _BaseRetrievalTool = class _BaseRetrievalTool extends (_b = BaseTool, _a = BASE_RETRIEVAL_TOOL_SIGNATURE_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /** Unique symbol to identify `BaseRetrievalTool` class. */
+    this[_a] = true;
+  }
   _getDeclaration() {
     return {
       name: this.name,
@@ -29,5 +42,6 @@ const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
 __name(_BaseRetrievalTool, "BaseRetrievalTool");
 let BaseRetrievalTool = _BaseRetrievalTool;
 export {
-  BaseRetrievalTool
+  BaseRetrievalTool,
+  isBaseRetrievalTool
 };

package/dist/esm/tools/toolbox_toolset.js

@@ -0,0 +1,148 @@
+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 wrapLoadedTool(rawTool, prefix) {
+  var _a2;
+  if (isBaseTool(rawTool)) {
+    if (!prefix) {
+      return rawTool;
+    }
+    return Object.assign(
+      Object.create(Object.getPrototypeOf(rawTool)),
+      rawTool,
+      { name: `${prefix}_${rawTool.name}` }
+    );
+  }
+  if (typeof rawTool === "function") {
+    const fn = rawTool;
+    const baseName = fn.name || "toolbox_tool";
+    const name = prefix ? `${prefix}_${baseName}` : baseName;
+    const description = (_a2 = fn.description) != null ? _a2 : "";
+    return new FunctionTool({
+      name,
+      description,
+      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;
+    const options = typeof serverUrlOrOptions === "string" ? { serverUrl: serverUrlOrOptions, ...extraOptions } : serverUrlOrOptions;
+    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);
+    /** 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);
+  }
+  /**
+   * 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
+    };
+    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);
+      if (!loader) {
+        throw new Error(
+          "ToolboxClient does not implement loadToolset or load_toolset."
+        );
+      }
+      const loadedToolset = await loader(this.toolsetName, loadOptions);
+      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);
+      if (!loader) {
+        throw new Error(
+          "ToolboxClient does not implement loadTool or load_tool."
+        );
+      }
+      const loadedSingleTools = await Promise.all(
+        this.toolNames.map((toolName) => loader(toolName, loadOptions))
+      );
+      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/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,25 @@ function mergeTrackingHeaders(headers) {
         value
       ]);
     } else {
-      merged[name] = value;
+      if (!originalNames.has(lowerName)) {
+        originalNames.set(lowerName, name);
+      }
+      otherHeaders.append(name, value);
     }
   }
+  const normalizedEntries = [];
+  otherHeaders.forEach((value, name) => {
+    normalizedEntries.push([name, value]);
+  });
+  const merged = Object.fromEntries(
+    normalizedEntries.map(([name, value]) => {
+      var _a2;
+      return [
+        (_a2 = originalNames.get(name)) != null ? _a2 : name,
+        value
+      ];
+    })
+  );
   for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
     const tokens = trackingValue.split(" ");
     for (const value of (_b = callerValues.get(name)) != null ? _b : []) {