@google/adk 2.1.0 → 2.2.0

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

@@ -35,11 +35,13 @@ var rest_api_tool_exports = {};
 __export(rest_api_tool_exports, {
   RestApiTool: () => RestApiTool,
   createRestApiTool: () => createRestApiTool,
+  createRestApiToolFromJson: () => createRestApiToolFromJson,
   prepareRequestBody: () => prepareRequestBody,
   prepareRequestParams: () => prepareRequestParams
 });
 module.exports = __toCommonJS(rest_api_tool_exports);
 var import_experimental = require("../../utils/experimental.js");
+var import_gemini_schema_util = require("../../utils/gemini_schema_util.js");
 var import_base_tool = require("../base_tool.js");
 var import_auth_helpers = require("./auth/auth_helpers.js");
 var import_operation_parser = require("./openapi_spec_parser/operation_parser.js");
@@ -49,9 +51,30 @@ var import_tool_auth_handler = require("./openapi_spec_parser/tool_auth_handler.
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const MAX_TOOL_NAME_LENGTH = 60;
+const SECURITY_SCHEME_TYPES = [
+  "apiKey",
+  "http",
+  "oauth2",
+  "openIdConnect"
+];
+function readSchemeType(value) {
+  return typeof value === "object" && value !== null && "type" in value ? value.type : void 0;
+}
+__name(readSchemeType, "readSchemeType");
+function isSecurityScheme(value) {
+  const type = readSchemeType(value);
+  return typeof type === "string" && SECURITY_SCHEME_TYPES.includes(type);
+}
+__name(isSecurityScheme, "isSecurityScheme");
+function serializeCookieHeader(cookies) {
+  return Object.entries(cookies).map(([name, value]) => `${name}=${encodeURIComponent(value)}`).join("; ");
+}
+__name(serializeCookieHeader, "serializeCookieHeader");
 let RestApiTool = class extends import_base_tool.BaseTool {
   constructor(name, description, endpoint, operation, authScheme, authCredential, options = {}) {
-    super({ name, description });
+    var _a;
+    super({ name: name.slice(0, MAX_TOOL_NAME_LENGTH), description });
     this.endpoint = endpoint;
     this.operation = operation;
     this.authScheme = authScheme;
@@ -60,7 +83,7 @@ let RestApiTool = class extends import_base_tool.BaseTool {
     this.authCredential = authCredential;
     this.headerProvider = options.headerProvider;
     this.credentialKey = options.credentialKey;
-    this.operationParser = new import_operation_parser.OperationParser(operation, options);
+    this.operationParser = (_a = options.operationParser) != null ? _a : new import_operation_parser.OperationParser(operation, options);
   }
   configureAuthScheme(authScheme) {
     this.authScheme = authScheme;
@@ -72,14 +95,16 @@ let RestApiTool = class extends import_base_tool.BaseTool {
     this.credentialKey = credentialKey;
   }
   _getDeclaration() {
-    const schema = this.operationParser.getJsonSchema();
     return {
       name: this.name,
       description: this.description,
-      parameters: schema
+      parameters: (0, import_gemini_schema_util.openApiSchemaToGeminiSchema)(
+        this.operationParser.getJsonSchema()
+      )
     };
   }
   async runAsync(request) {
+    var _a;
     const context = request.toolContext;
     const args = request.args;
     const authHandler = import_tool_auth_handler.ToolAuthHandler.fromToolContext(
@@ -101,7 +126,8 @@ let RestApiTool = class extends import_base_tool.BaseTool {
       url: initialUrl,
       headers,
       body: parsedBody,
-      bodyData
+      bodyData,
+      cookies
     } = prepareRequestParams(
       this.endpoint,
       this.operationParser.getParameters(),
@@ -117,30 +143,36 @@ let RestApiTool = class extends import_base_tool.BaseTool {
       initialUrl,
       headers,
       credential,
-      this.authScheme
+      (_a = authResult.authScheme) != null ? _a : this.authScheme
     );
     if (this.headerProvider) {
       const providerHeaders = this.headerProvider(context);
       Object.assign(headers, providerHeaders);
     }
-    try {
-      const response = await globalThis.fetch(url, {
-        method,
-        headers,
-        // eslint-disable-next-line no-undef
-        body
-      });
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        return await response.json();
-      } else {
-        return await response.text();
-      }
-    } catch (error) {
+    const hasCookieHeader = Object.keys(headers).some(
+      (header) => header.toLowerCase() === "cookie"
+    );
+    if (Object.keys(cookies).length > 0 && !hasCookieHeader) {
+      headers["Cookie"] = serializeCookieHeader(cookies);
+    }
+    const response = await globalThis.fetch(url, {
+      method,
+      headers,
+      // eslint-disable-next-line no-undef
+      body
+    });
+    if (response.status >= 400) {
+      const errorDetails = await response.text();
       return {
-        error: `Failed to execute API call: ${error.message}`
+        error: `Tool ${this.name} execution failed. Analyze this execution error and your inputs. Retry with adjustments if applicable. But make sure don't retry more than 3 times. Execution Error: ${errorDetails}`
       };
     }
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { text };
+    }
   }
 };
 __name(RestApiTool, "RestApiTool");
@@ -174,6 +206,7 @@ __name(encodePathParamValue, "encodePathParamValue");
 function prepareRequestParams(endpoint, parameters, args) {
   const headers = {};
   const queryParams = new URLSearchParams();
+  const cookies = {};
   let body = void 0;
   const paramsMap = new Map(parameters.map((p) => [p.name, p]));
   const pathParams = {};
@@ -189,9 +222,13 @@ function prepareRequestParams(endpoint, parameters, args) {
         String(argValue)
       );
     } else if (location === "query") {
-      queryParams.append(originalName, String(argValue));
+      if (argValue !== void 0 && argValue !== null && argValue !== "") {
+        queryParams.append(originalName, String(argValue));
+      }
     } else if (location === "header") {
       headers[originalName] = String(argValue);
+    } else if (location === "cookie") {
+      cookies[originalName] = String(argValue);
     } else if (location === "body") {
       if (originalName === "body" || originalName === "array" || originalName === "") {
         body = argValue;
@@ -204,7 +241,8 @@ function prepareRequestParams(endpoint, parameters, args) {
     /\{([^{}]+)\}/g,
     (placeholder, name) => Object.hasOwn(pathParams, name) ? pathParams[name] : placeholder
   );
-  let url = `${endpoint.baseUrl}${resolvedPath}`;
+  const baseUrl = endpoint.baseUrl.endsWith("/") ? endpoint.baseUrl.slice(0, -1) : endpoint.baseUrl;
+  let url = `${baseUrl}${resolvedPath}`;
   const urlParts = url.split("?");
   if (urlParts.length > 1) {
     const pathQueryParams = new URLSearchParams(urlParts[1]);
@@ -217,9 +255,13 @@ function prepareRequestParams(endpoint, parameters, args) {
   if (queryString) {
     url += `?${queryString}`;
   }
-  return { url, headers, body, bodyData };
+  return { url, headers, body, bodyData, cookies };
 }
 __name(prepareRequestParams, "prepareRequestParams");
+function isRawBody(value) {
+  return typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof Blob;
+}
+__name(isRawBody, "isRawBody");
 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) {
@@ -239,6 +281,9 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
           }
         }
         return formData;
+      } else if (mimeType === "application/octet-stream") {
+        headers["Content-Type"] = mimeType;
+        return isRawBody(finalData) ? finalData : String(finalData);
       } else if (mimeType === "text/plain") {
         headers["Content-Type"] = mimeType;
         return String(finalData);
@@ -252,21 +297,38 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
 }
 __name(prepareRequestBody, "prepareRequestBody");
 function createRestApiTool(parsed, options = {}) {
+  var _a, _b;
+  const operationParser = parsed.parameters ? import_operation_parser.OperationParser.load(
+    parsed.operation,
+    parsed.parameters,
+    parsed.returnValue
+  ) : new import_operation_parser.OperationParser(parsed.operation, options);
   return new RestApiTool(
-    parsed.name,
-    parsed.description,
+    (_a = parsed.name) != null ? _a : operationParser.getFunctionName(),
+    (_b = parsed.description) != null ? _b : operationParser.getDescription(),
     parsed.endpoint,
     parsed.operation,
     parsed.authScheme,
-    void 0,
-    options
+    parsed.authCredential,
+    { ...options, operationParser }
   );
 }
 __name(createRestApiTool, "createRestApiTool");
+function createRestApiToolFromJson(parsedOperationJson) {
+  const parsed = JSON.parse(parsedOperationJson);
+  if (parsed.authScheme && !isSecurityScheme(parsed.authScheme)) {
+    throw new Error(
+      `Unsupported security scheme type: ${JSON.stringify(readSchemeType(parsed.authScheme))}. Expected one of: ${SECURITY_SCHEME_TYPES.join(", ")}.`
+    );
+  }
+  return createRestApiTool(parsed);
+}
+__name(createRestApiToolFromJson, "createRestApiToolFromJson");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RestApiTool,
   createRestApiTool,
+  createRestApiToolFromJson,
   prepareRequestBody,
   prepareRequestParams
 });

package/dist/cjs/tools/skill/skill_toolset.js

@@ -109,7 +109,9 @@ let SkillToolset = class extends import_base_toolset.BaseToolset {
     return [...this.tools, ...dynamicTools];
   }
   async close() {
+    var _a, _b;
     this.fetchedSkillCache.clear();
+    await ((_b = (_a = this.registry) == null ? void 0 : _a.close) == null ? void 0 : _b.call(_a));
   }
   getSkill(name) {
     return this.skills[name];

package/dist/cjs/tools/tool_context.js

@@ -0,0 +1,41 @@
+/**
+  * @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 __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 tool_context_exports = {};
+__export(tool_context_exports, {
+  CallbackContext: () => import_context.Context,
+  ToolContext: () => import_context.Context
+});
+module.exports = __toCommonJS(tool_context_exports);
+var import_context = require("../agents/context.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallbackContext,
+  ToolContext
+});

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
+});