@google/adk 2.0.0 → 2.2.0

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

@@ -17,15 +17,37 @@ var __decorateClass = (decorators, target, key, kind) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { experimental } from "../../utils/experimental.js";
+import { openApiSchemaToGeminiSchema } from "../../utils/gemini_schema_util.js";
 import { BaseTool } from "../base_tool.js";
 import { applyCredential } from "./auth/auth_helpers.js";
 import {
   OperationParser
 } from "./openapi_spec_parser/operation_parser.js";
 import { ToolAuthHandler } from "./openapi_spec_parser/tool_auth_handler.js";
+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 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;
@@ -34,7 +56,7 @@ let RestApiTool = class extends BaseTool {
     this.authCredential = authCredential;
     this.headerProvider = options.headerProvider;
     this.credentialKey = options.credentialKey;
-    this.operationParser = new OperationParser(operation, options);
+    this.operationParser = (_a = options.operationParser) != null ? _a : new OperationParser(operation, options);
   }
   configureAuthScheme(authScheme) {
     this.authScheme = authScheme;
@@ -46,14 +68,16 @@ let RestApiTool = class extends BaseTool {
     this.credentialKey = credentialKey;
   }
   _getDeclaration() {
-    const schema = this.operationParser.getJsonSchema();
     return {
       name: this.name,
       description: this.description,
-      parameters: schema
+      parameters: openApiSchemaToGeminiSchema(
+        this.operationParser.getJsonSchema()
+      )
     };
   }
   async runAsync(request) {
+    var _a;
     const context = request.toolContext;
     const args = request.args;
     const authHandler = ToolAuthHandler.fromToolContext(
@@ -75,7 +99,8 @@ let RestApiTool = class extends BaseTool {
       url: initialUrl,
       headers,
       body: parsedBody,
-      bodyData
+      bodyData,
+      cookies
     } = prepareRequestParams(
       this.endpoint,
       this.operationParser.getParameters(),
@@ -91,30 +116,36 @@ let RestApiTool = class extends 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");
@@ -148,6 +179,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 = {};
@@ -163,9 +195,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;
@@ -178,7 +214,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]);
@@ -191,34 +228,39 @@ 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) {
     const content = requestBody.content;
-    for (const [mimeType, _mediaTypeObject] of Object.entries(content)) {
-      if (finalData !== void 0) {
-        if (mimeType === "application/json" || mimeType.endsWith("+json")) {
-          headers["Content-Type"] = mimeType;
-          return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
-        } else if (mimeType === "application/x-www-form-urlencoded") {
-          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));
-            }
+    const mimeType = Object.keys(content)[0];
+    if (mimeType && finalData !== void 0) {
+      if (mimeType === "application/json" || mimeType.endsWith("+json")) {
+        headers["Content-Type"] = mimeType;
+        return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
+      } else if (mimeType === "application/x-www-form-urlencoded") {
+        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));
           }
-          return formData;
-        } else if (mimeType === "text/plain") {
-          headers["Content-Type"] = mimeType;
-          return String(finalData);
         }
+        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);
       }
-      break;
     }
   } else if (finalData !== void 0) {
     headers["Content-Type"] = "application/json";
@@ -228,20 +270,37 @@ function prepareRequestBody(requestBody, body, bodyData, headers) {
 }
 __name(prepareRequestBody, "prepareRequestBody");
 function createRestApiTool(parsed, options = {}) {
+  var _a, _b;
+  const operationParser = parsed.parameters ? OperationParser.load(
+    parsed.operation,
+    parsed.parameters,
+    parsed.returnValue
+  ) : new 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");
 export {
   RestApiTool,
   createRestApiTool,
+  createRestApiToolFromJson,
   prepareRequestBody,
   prepareRequestParams
 };

package/dist/esm/tools/preload_memory_tool.js

@@ -16,7 +16,7 @@ const _PreloadMemoryTool = class _PreloadMemoryTool extends BaseTool {
   constructor() {
     super({
       // Name and description are not used because this tool only
-      // changes llm_request.
+      // changes the LlmRequest.
       name: "preload_memory",
       description: "preload_memory"
     });

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

@@ -0,0 +1,33 @@
+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
+ */
+import { Type } from "@google/genai";
+import { BaseTool } from "../base_tool.js";
+const _BaseRetrievalTool = class _BaseRetrievalTool extends BaseTool {
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to retrieve."
+          }
+        }
+      }
+    };
+  }
+};
+__name(_BaseRetrievalTool, "BaseRetrievalTool");
+let BaseRetrievalTool = _BaseRetrievalTool;
+export {
+  BaseRetrievalTool
+};

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

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../../utils/logger.js";
+import {
+  LlamaIndexRetrieval
+} from "./llama_index_retrieval.js";
+const LLAMA_INDEX_MODULE = "llamaindex";
+const DIRECTORY_READER_MODULE = "@llamaindex/readers/directory";
+async function importOptional(specifier) {
+  try {
+    return await Promise.resolve().then(() => __toESM(require(specifier)));
+  } catch (cause) {
+    throw new Error(
+      `FilesRetrieval needs the optional package '${specifier}', which is not installed. Install '${LLAMA_INDEX_MODULE}' and '@llamaindex/readers', or build the retriever yourself and pass it to LlamaIndexRetrieval.`,
+      { cause }
+    );
+  }
+}
+__name(importOptional, "importOptional");
+const _FilesRetrieval = class _FilesRetrieval extends LlamaIndexRetrieval {
+  constructor(params) {
+    super({
+      name: params.name,
+      description: params.description,
+      retriever: params.retriever
+    });
+    this.inputDir = params.inputDir;
+  }
+  /**
+   * Indexes every file under `inputDir` and returns a tool that retrieves
+   * from it.
+   *
+   * Requires the optional `llamaindex` and `@llamaindex/readers` packages,
+   * and a configured LlamaIndex embedding model.
+   */
+  static async create(params) {
+    logger.info(`Loading data from ${params.inputDir}`);
+    const { SimpleDirectoryReader } = await importOptional(
+      DIRECTORY_READER_MODULE
+    );
+    const { VectorStoreIndex } = await importOptional(LLAMA_INDEX_MODULE);
+    const documents = await new SimpleDirectoryReader().loadData({
+      directoryPath: params.inputDir
+    });
+    const index = await VectorStoreIndex.fromDocuments(documents);
+    return new _FilesRetrieval({ ...params, retriever: index.asRetriever() });
+  }
+};
+__name(_FilesRetrieval, "FilesRetrieval");
+let FilesRetrieval = _FilesRetrieval;
+export {
+  FilesRetrieval
+};

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

@@ -0,0 +1,30 @@
+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
+ */
+import { BaseRetrievalTool } from "./base_retrieval_tool.js";
+const _LlamaIndexRetrieval = class _LlamaIndexRetrieval extends BaseRetrievalTool {
+  constructor(params) {
+    super({ name: params.name, description: params.description });
+    this.retriever = params.retriever;
+  }
+  async runAsync({ args }) {
+    var _a;
+    const nodes = await this.retriever.retrieve(String((_a = args["query"]) != null ? _a : ""));
+    const top = nodes[0];
+    if (!top) {
+      throw new Error(`${this.name} retrieved no results for the query.`);
+    }
+    return top.node.text;
+  }
+};
+__name(_LlamaIndexRetrieval, "LlamaIndexRetrieval");
+let LlamaIndexRetrieval = _LlamaIndexRetrieval;
+export {
+  LlamaIndexRetrieval
+};

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

@@ -74,7 +74,9 @@ let SkillToolset = class extends 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/{web/context/base_context_compactor.js → esm/tools/tool_context.js}

@@ -5,3 +5,11 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import {
+  Context,
+  Context as Context2
+} from "../agents/context.js";
+export {
+  Context as CallbackContext,
+  Context2 as ToolContext
+};

package/dist/esm/tools/url_context_tool.js

@@ -8,15 +8,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { isGemini2OrAbove, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const _UrlContextTool = class _UrlContextTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _UrlContextTool = class _UrlContextTool extends BuiltInTool {
   constructor() {
     super({ name: "url_context", description: "URL Context Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     if (!llmRequest.model) {

package/dist/esm/tools/vertex_ai_search_tool.js

@@ -7,15 +7,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getLogger } from "../utils/logger.js";
+import { logger } from "../utils/logger.js";
 import {
   isGemini1Model,
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const logger = getLogger();
-const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _VertexAiSearchTool = class _VertexAiSearchTool extends BuiltInTool {
   constructor(params) {
     super({ name: "vertex_ai_search", description: "vertex_ai_search" });
     const {
@@ -43,9 +42,6 @@ const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
     this.maxResults = maxResults;
     this.bypassMultiToolsLimit = bypassMultiToolsLimit;
   }
-  runAsync() {
-    return Promise.resolve();
-  }
   /**
    * Builds the VertexAISearch configuration.
    *
@@ -62,7 +58,7 @@ const _VertexAiSearchTool = class _VertexAiSearchTool extends BaseTool {
       maxResults: this.maxResults
     };
   }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     toolContext,
     llmRequest
   }) {

package/dist/esm/tools/vertex_rag_retrieval_tool.js

@@ -7,8 +7,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { BaseTool } from "./base_tool.js";
-const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BuiltInTool {
   constructor(config) {
     super({
       name: "vertex_rag_retrieval",
@@ -16,14 +16,7 @@ const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BaseTool {
     });
     this.vertexRagStore = config;
   }
-  /**
-   * This tool is executed server-side by the Vertex AI RAG Engine.
-   * Local execution is not required.
-   */
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     llmRequest.config = llmRequest.config || {};

package/dist/{web/auth/base_auth_provider.js → esm/tools/webmcp/index.js}

@@ -5,3 +5,6 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+export * from "./webmcp_tool.js";
+export * from "./webmcp_toolset.js";
+export * from "./webmcp_types.js";

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

@@ -0,0 +1,131 @@
+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
+ */
+import { Type } from "@google/genai";
+import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
+import { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+import {
+  getModelContext
+} from "./webmcp_types.js";
+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 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 {
+        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 = toGeminiSchema(schema)) != null ? _a : { type: Type.OBJECT, properties: {} } : { type: Type.OBJECT, properties: {} };
+    if (schema && !parameters.properties) {
+      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 = 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");
+    logger.debug(
+      "This browser expects JSON-string WebMCP tool arguments; using that encoding."
+    );
+    return retried;
+  }
+};
+__name(_WebMCPTool, "WebMCPTool");
+let WebMCPTool = _WebMCPTool;
+export {
+  WebMCPTool
+};