@google/adk 2.0.0 → 2.2.0

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

@@ -0,0 +1,37 @@
+/**
+  * @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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webmcp_exports = {};
+module.exports = __toCommonJS(webmcp_exports);
+__reExport(webmcp_exports, require("./webmcp_tool.js"), module.exports);
+__reExport(webmcp_exports, require("./webmcp_toolset.js"), module.exports);
+__reExport(webmcp_exports, require("./webmcp_types.js"), module.exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./webmcp_tool.js"),
+  ...require("./webmcp_toolset.js"),
+  ...require("./webmcp_types.js")
+});

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

@@ -0,0 +1,156 @@
+/**
+  * @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 webmcp_tool_exports = {};
+__export(webmcp_tool_exports, {
+  WebMCPTool: () => WebMCPTool
+});
+module.exports = __toCommonJS(webmcp_tool_exports);
+var import_genai = require("@google/genai");
+var import_gemini_schema_util = require("../../utils/gemini_schema_util.js");
+var import_logger = require("../../utils/logger.js");
+var import_base_tool = require("../base_tool.js");
+var import_webmcp_types = require("./webmcp_types.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const argEncodingByContext = /* @__PURE__ */ new WeakMap();
+function isArgParseFailure(value) {
+  var _a, _b;
+  let text = "";
+  if (typeof value === "string") {
+    text = value;
+  } else if (value && typeof value === "object") {
+    const candidate = value;
+    text = String((_b = (_a = candidate.error) != null ? _a : candidate.message) != null ? _b : "");
+  }
+  return /failed to parse input arguments|could not parse .*arguments/i.test(
+    text
+  );
+}
+__name(isArgParseFailure, "isArgParseFailure");
+const _WebMCPTool = class _WebMCPTool extends import_base_tool.BaseTool {
+  constructor(params) {
+    var _a, _b;
+    super({
+      name: (_a = params.name) != null ? _a : params.tool.name,
+      description: (_b = params.tool.description) != null ? _b : ""
+    });
+    this.webmcpTool = params.tool;
+    this.doc = params.document;
+  }
+  /**
+   * The tool's JSON Schema as an object.
+   *
+   * `inputSchema` is specified as an object, but a browser handing back a JSON
+   * string would otherwise convert to a parameterless declaration, leaving the
+   * model no argument names to fill in — it then calls the tool with `{}`.
+   */
+  resolveInputSchema() {
+    const raw = this.webmcpTool.inputSchema;
+    if (raw == null) return void 0;
+    if (typeof raw === "string") {
+      try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+      } catch {
+        import_logger.logger.warn(
+          `WebMCP tool '${this.webmcpTool.name}' has an inputSchema string that is not valid JSON; exposing it with no parameters.`
+        );
+        return void 0;
+      }
+    }
+    if (typeof raw === "object") return raw;
+    return void 0;
+  }
+  _getDeclaration() {
+    var _a;
+    const schema = this.resolveInputSchema();
+    const parameters = schema ? (_a = (0, import_gemini_schema_util.toGeminiSchema)(schema)) != null ? _a : { type: import_genai.Type.OBJECT, properties: {} } : { type: import_genai.Type.OBJECT, properties: {} };
+    if (schema && !parameters.properties) {
+      import_logger.logger.warn(
+        `WebMCP tool '${this.webmcpTool.name}' declared an inputSchema that produced no parameters; the model will be unable to pass arguments.`
+      );
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      parameters
+    };
+  }
+  async checkRequireConfirmation() {
+    var _a;
+    return !!((_a = this.webmcpTool.annotations) == null ? void 0 : _a.consequentialHint);
+  }
+  async runAsync(request) {
+    var _a, _b;
+    const modelContext = (0, import_webmcp_types.getModelContext)(this.doc);
+    if (!modelContext) {
+      throw new Error(
+        "document.modelContext is unavailable, so WebMCP tools cannot be executed. WebMCP requires a browser with the API enabled."
+      );
+    }
+    const args = (_a = request.args) != null ? _a : {};
+    const signal = (_b = request.toolContext) == null ? void 0 : _b.abortSignal;
+    const options = signal ? { signal } : void 0;
+    const invoke = /* @__PURE__ */ __name((encoding) => modelContext.executeTool(
+      this.webmcpTool,
+      encoding === "json-string" ? JSON.stringify(args) : args,
+      options
+    ), "invoke");
+    const known = argEncodingByContext.get(modelContext);
+    if (known) {
+      return await invoke(known);
+    }
+    let firstResult;
+    try {
+      firstResult = await invoke("object");
+      if (!isArgParseFailure(firstResult)) {
+        argEncodingByContext.set(modelContext, "object");
+        return firstResult;
+      }
+    } catch (err) {
+      if (!isArgParseFailure(err)) throw err;
+      firstResult = err;
+    }
+    const retried = await invoke("json-string");
+    if (isArgParseFailure(retried)) {
+      return firstResult;
+    }
+    argEncodingByContext.set(modelContext, "json-string");
+    import_logger.logger.debug(
+      "This browser expects JSON-string WebMCP tool arguments; using that encoding."
+    );
+    return retried;
+  }
+};
+__name(_WebMCPTool, "WebMCPTool");
+let WebMCPTool = _WebMCPTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebMCPTool
+});

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

@@ -0,0 +1,116 @@
+/**
+  * @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 webmcp_toolset_exports = {};
+__export(webmcp_toolset_exports, {
+  WebMCPToolset: () => WebMCPToolset
+});
+module.exports = __toCommonJS(webmcp_toolset_exports);
+var import_logger = require("../../utils/logger.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_webmcp_tool = require("./webmcp_tool.js");
+var import_webmcp_types = require("./webmcp_types.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const _WebMCPToolset = class _WebMCPToolset extends import_base_toolset.BaseToolset {
+  constructor(options = {}) {
+    var _a;
+    super((_a = options.toolFilter) != null ? _a : [], options.prefix);
+    this.changeListeners = /* @__PURE__ */ new Set();
+    this.doc = options.document;
+    this.fromOrigins = options.fromOrigins;
+  }
+  /** Whether this document exposes WebMCP. */
+  isSupported() {
+    return !!(0, import_webmcp_types.getModelContext)(this.doc);
+  }
+  async getTools(context) {
+    const modelContext = (0, import_webmcp_types.getModelContext)(this.doc);
+    if (!modelContext) {
+      import_logger.logger.debug(
+        "document.modelContext is unavailable; WebMCPToolset is exposing no tools."
+      );
+      return [];
+    }
+    const registered = await modelContext.getTools(
+      this.fromOrigins ? { fromOrigins: this.fromOrigins } : void 0
+    );
+    const tools = registered.map(
+      (tool) => new import_webmcp_tool.WebMCPTool({
+        tool,
+        name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name,
+        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;
+  }
+  /**
+   * Subscribes to the WebMCP `toolchange` event, which fires when the page
+   * registers or removes tools. Returns an unsubscribe function.
+   */
+  onToolChange(listener) {
+    const modelContext = (0, import_webmcp_types.getModelContext)(this.doc);
+    if (!modelContext) return () => {
+    };
+    const handler = /* @__PURE__ */ __name(() => listener(), "handler");
+    this.changeListeners.add(handler);
+    modelContext.addEventListener("toolchange", handler);
+    return () => {
+      modelContext.removeEventListener("toolchange", handler);
+      this.changeListeners.delete(handler);
+    };
+  }
+  async close() {
+    const modelContext = (0, import_webmcp_types.getModelContext)(this.doc);
+    if (modelContext) {
+      for (const handler of this.changeListeners) {
+        modelContext.removeEventListener("toolchange", handler);
+      }
+    }
+    this.changeListeners.clear();
+  }
+};
+__name(_WebMCPToolset, "WebMCPToolset");
+let WebMCPToolset = _WebMCPToolset;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebMCPToolset
+});

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

@@ -0,0 +1,50 @@
+/**
+  * @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 webmcp_types_exports = {};
+__export(webmcp_types_exports, {
+  getModelContext: () => getModelContext,
+  isWebMCPSupported: () => isWebMCPSupported
+});
+module.exports = __toCommonJS(webmcp_types_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getModelContext(doc) {
+  const target = doc != null ? doc : globalThis.document;
+  return target == null ? void 0 : target.modelContext;
+}
+__name(getModelContext, "getModelContext");
+function isWebMCPSupported(doc) {
+  return !!getModelContext(doc);
+}
+__name(isWebMCPSupported, "isWebMCPSupported");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModelContext,
+  isWebMCPSupported
+});

package/dist/cjs/utils/case_utils.js

@@ -25,7 +25,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var case_utils_exports = {};
 __export(case_utils_exports, {
-  camelCaseKeys: () => camelCaseKeys
+  camelCaseKeys: () => camelCaseKeys,
+  renameReservedKeywords: () => renameReservedKeywords,
+  toSnakeCaseName: () => toSnakeCaseName
 });
 module.exports = __toCommonJS(case_utils_exports);
 /**
@@ -49,7 +51,55 @@ function camelCaseKeys(val) {
   return val;
 }
 __name(camelCaseKeys, "camelCaseKeys");
+const PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+  "False",
+  "None",
+  "True",
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+const DEFAULT_RESERVED_WORD_PREFIX = "param_";
+function toSnakeCaseName(text) {
+  return text.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(toSnakeCaseName, "toSnakeCaseName");
+function renameReservedKeywords(s, prefix = DEFAULT_RESERVED_WORD_PREFIX) {
+  return PYTHON_KEYWORDS.has(s) ? prefix + s : s;
+}
+__name(renameReservedKeywords, "renameReservedKeywords");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  camelCaseKeys
+  camelCaseKeys,
+  renameReservedKeywords,
+  toSnakeCaseName
 });

package/dist/cjs/utils/client_labels.js

@@ -26,6 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var client_labels_exports = {};
 __export(client_labels_exports, {
   getClientLabels: () => getClientLabels,
+  getTrackingHeaders: () => getTrackingHeaders,
+  mergeTrackingHeaders: () => mergeTrackingHeaders,
   parseUserAgent: () => parseUserAgent,
   runWithClientLabel: () => runWithClientLabel
 });
@@ -42,6 +44,7 @@ const ADK_LABEL = "google-adk";
 const LANGUAGE_LABEL = "gl-typescript";
 const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
 const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+const TRACKING_HEADER_NAMES = ["x-goog-api-client", "user-agent"];
 const clientLabelLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
 const USER_AGENT_PATTERNS = [
   ["Edge", /(?:Edg|Edge|EdgA)\/([0-9.]+)/i],
@@ -91,9 +94,73 @@ function getClientLabels() {
   return labels;
 }
 __name(getClientLabels, "getClientLabels");
+function getTrackingHeaders() {
+  const headerValue = getClientLabels().join(" ");
+  return {
+    "x-goog-api-client": headerValue,
+    "user-agent": headerValue
+  };
+}
+__name(getTrackingHeaders, "getTrackingHeaders");
+function isTrackingHeaderName(name) {
+  return TRACKING_HEADER_NAMES.some((trackingName) => trackingName === name);
+}
+__name(isTrackingHeaderName, "isTrackingHeaderName");
+function isHeaders(headers) {
+  return typeof headers.forEach === "function";
+}
+__name(isHeaders, "isHeaders");
+function headerEntries(headers) {
+  if (!headers) {
+    return [];
+  }
+  if (Array.isArray(headers)) {
+    return headers.map(([name, value]) => [name, value]);
+  }
+  if (isHeaders(headers)) {
+    const entries = [];
+    headers.forEach((value, name) => {
+      entries.push([name, value]);
+    });
+    return entries;
+  }
+  return Object.entries(headers);
+}
+__name(headerEntries, "headerEntries");
+function mergeTrackingHeaders(headers) {
+  var _a, _b;
+  const merged = {};
+  const callerValues = /* @__PURE__ */ new Map();
+  for (const [name, value] of headerEntries(headers)) {
+    const lowerName = name.toLowerCase();
+    if (isTrackingHeaderName(lowerName)) {
+      callerValues.set(lowerName, [
+        ...(_a = callerValues.get(lowerName)) != null ? _a : [],
+        value
+      ]);
+    } else {
+      merged[name] = value;
+    }
+  }
+  for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
+    const tokens = trackingValue.split(" ");
+    for (const value of (_b = callerValues.get(name)) != null ? _b : []) {
+      for (const token of value.split(/\s+/)) {
+        if (token && !tokens.includes(token)) {
+          tokens.push(token);
+        }
+      }
+    }
+    merged[name] = tokens.join(" ");
+  }
+  return merged;
+}
+__name(mergeTrackingHeaders, "mergeTrackingHeaders");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getClientLabels,
+  getTrackingHeaders,
+  mergeTrackingHeaders,
   parseUserAgent,
   runWithClientLabel
 });

package/dist/cjs/utils/crypto_shim.js

@@ -25,6 +25,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var crypto_shim_exports = {};
 __export(crypto_shim_exports, {
+  createHash: () => createHash,
+  randomBytes: () => randomBytes,
   randomUUID: () => randomUUID
 });
 module.exports = __toCommonJS(crypto_shim_exports);
@@ -39,7 +41,21 @@ function randomUUID() {
   );
 }
 __name(randomUUID, "randomUUID");
+function createHash(_algorithm) {
+  throw new Error(
+    "createHash: PKCE code challenges require a synchronous SHA-256, which the Web Crypto API does not provide (crypto.subtle.digest is async)."
+  );
+}
+__name(createHash, "createHash");
+function randomBytes(_size) {
+  throw new Error(
+    "randomBytes: no cryptographically secure source of randomness is available in this environment."
+  );
+}
+__name(randomBytes, "randomBytes");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createHash,
+  randomBytes,
   randomUUID
 });