@google/adk 1.5.0 → 2.0.0

package/dist/cjs/tools/function_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -46,17 +47,19 @@ function toSchema(parameters) {
   }
   return parameters;
 }
+__name(toSchema, "toSchema");
 const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
 function isFunctionTool(obj) {
   return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
 }
-class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
+__name(isFunctionTool, "isFunctionTool");
+const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
   /**
    * The constructor acts as the user-friendly factory.
    * @param options The configuration for the tool.
    */
   constructor(options) {
-    var _a2;
+    var _a2, _b2;
     const name = (_a2 = options.name) != null ? _a2 : options.execute.name;
     if (!name) {
       throw new Error(
@@ -72,6 +75,7 @@ class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_S
     this[_a] = true;
     this.execute = options.execute;
     this.parameters = options.parameters;
+    this.requireConfirmation = (_b2 = options.requireConfirmation) != null ? _b2 : false;
   }
   /**
    * Returns the function declaration derived from the tool's name, description,
@@ -93,20 +97,81 @@ class FunctionTool extends (_b = import_base_tool.BaseTool, _a = FUNCTION_TOOL_S
    */
   async runAsync(req) {
     try {
-      let validatedArgs = req.args;
-      if ((0, import_simple_zod_to_json.isZodObject)(this.parameters)) {
-        validatedArgs = this.parameters.parse(req.args);
-      }
-      return await this.execute(
+      const validatedArgs = this.validateArgs(req.args);
+      const pending = await this.checkConfirmation(
         validatedArgs,
         req.toolContext
       );
+      if (pending !== void 0) {
+        return pending;
+      }
+      return await this.execute(validatedArgs, req.toolContext);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Error in tool '${this.name}': ${errorMessage}`);
     }
   }
-}
+  /**
+   * Whether this call is gated on human approval — the static flag, or the
+   * predicate evaluated against the validated arguments.
+   *
+   * @param args The arguments the tool would run with.
+   * @param toolContext The context of the call, when there is one.
+   * @return Whether the call requires confirmation.
+   */
+  async checkRequireConfirmation(args, toolContext) {
+    if (typeof this.requireConfirmation !== "function") {
+      return this.requireConfirmation;
+    }
+    return this.requireConfirmation(this.validateArgs(args), toolContext);
+  }
+  /** Parses `args` against the parameter schema, when one is declared. */
+  validateArgs(args) {
+    if ((0, import_simple_zod_to_json.isZodObject)(this.parameters)) {
+      return this.parameters.parse(args);
+    }
+    return args;
+  }
+  /** Resolves `requireConfirmation`, which may be a flag or a predicate. */
+  async evaluateRequireConfirmation(input, toolContext) {
+    return typeof this.requireConfirmation === "function" ? this.requireConfirmation(input, toolContext) : this.requireConfirmation;
+  }
+  /**
+   * Evaluates the confirmation gate. Returns `undefined` if the tool may
+   * proceed; otherwise returns the function response payload to surface instead
+   * of running (a request-for-confirmation on the first pass, or a rejection
+   * once the user declined).
+   */
+  async checkConfirmation(input, toolContext) {
+    const requireConfirmation = await this.evaluateRequireConfirmation(
+      input,
+      toolContext
+    );
+    if (!requireConfirmation) {
+      return void 0;
+    }
+    if (!toolContext) {
+      throw new Error(
+        `Tool '${this.name}' requires confirmation but no tool context was provided.`
+      );
+    }
+    if (!toolContext.toolConfirmation) {
+      toolContext.requestConfirmation({
+        hint: `Please approve or reject the tool call ${this.name}() by responding with a FunctionResponse with an expected ToolConfirmation payload.`
+      });
+      toolContext.actions.skipSummarization = true;
+      return {
+        error: "This tool call requires confirmation, please approve or reject."
+      };
+    }
+    if (!toolContext.toolConfirmation.confirmed) {
+      return { error: "This tool call is rejected." };
+    }
+    return void 0;
+  }
+};
+__name(_FunctionTool, "FunctionTool");
+let FunctionTool = _FunctionTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FunctionTool,

package/dist/cjs/tools/get_user_choice_tool.js

@@ -0,0 +1,54 @@
+/**
+  * @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 get_user_choice_tool_exports = {};
+__export(get_user_choice_tool_exports, {
+  getUserChoiceTool: () => getUserChoiceTool
+});
+module.exports = __toCommonJS(get_user_choice_tool_exports);
+var import_zod = require("zod");
+var import_long_running_tool = require("./long_running_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const getUserChoiceTool = new import_long_running_tool.LongRunningFunctionTool({
+  name: "get_user_choice",
+  description: "Presents a list of options to the user and awaits their selection.",
+  parameters: import_zod.z.object({
+    options: import_zod.z.array(import_zod.z.string()).describe("List of options to present to the user.")
+  }),
+  execute: /* @__PURE__ */ __name(async (input, context) => {
+    if (context) {
+      context.actions.skipSummarization = true;
+    }
+    return null;
+  }, "execute")
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUserChoiceTool
+});

package/dist/cjs/tools/google_maps_grounding_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -58,7 +59,8 @@ function applyGoogleMapsGrounding(llmRequest) {
     `Google maps tool is not supported for model ${llmRequest.model}`
   );
 }
-class GoogleMapsGroundingTool extends import_base_tool.BaseTool {
+__name(applyGoogleMapsGrounding, "applyGoogleMapsGrounding");
+const _GoogleMapsGroundingTool = class _GoogleMapsGroundingTool extends import_base_tool.BaseTool {
   constructor() {
     super({ name: "google_maps", description: "Google Maps Grounding Tool" });
   }
@@ -70,7 +72,9 @@ class GoogleMapsGroundingTool extends import_base_tool.BaseTool {
   }) {
     applyGoogleMapsGrounding(llmRequest);
   }
-}
+};
+__name(_GoogleMapsGroundingTool, "GoogleMapsGroundingTool");
+let GoogleMapsGroundingTool = _GoogleMapsGroundingTool;
 const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/google_search_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -35,7 +36,7 @@ var import_base_tool = require("./base_tool.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class GoogleSearchTool extends import_base_tool.BaseTool {
+const _GoogleSearchTool = class _GoogleSearchTool extends import_base_tool.BaseTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
   }
@@ -71,7 +72,9 @@ class GoogleSearchTool extends import_base_tool.BaseTool {
       `Google search tool is not supported for model ${llmRequest.model}`
     );
   }
-}
+};
+__name(_GoogleSearchTool, "GoogleSearchTool");
+let GoogleSearchTool = _GoogleSearchTool;
 const GOOGLE_SEARCH = new GoogleSearchTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/load_artifacts_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -51,6 +52,7 @@ function normalizeMimeType(mimeType) {
   }
   return mimeType.split(";")[0].trim();
 }
+__name(normalizeMimeType, "normalizeMimeType");
 function isInlineMimeTypeSupported(mimeType) {
   const normalized = normalizeMimeType(mimeType);
   if (!normalized) {
@@ -60,6 +62,7 @@ function isInlineMimeTypeSupported(mimeType) {
     (prefix) => normalized.startsWith(prefix)
   ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
 }
+__name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
 function asSafePartForLlm(artifact, artifactName) {
   const inlineData = artifact.inlineData;
   if (!inlineData) {
@@ -89,7 +92,8 @@ function asSafePartForLlm(artifact, artifactName) {
     text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
   };
 }
-class LoadArtifactsTool extends import_base_tool.BaseTool {
+__name(asSafePartForLlm, "asSafePartForLlm");
+const _LoadArtifactsTool = class _LoadArtifactsTool extends import_base_tool.BaseTool {
   constructor() {
     super({
       name: "load_artifacts",
@@ -179,7 +183,9 @@ NOTE: Call when you need access to artifacts (for example, uploads saved by the
       }
     }
   }
-}
+};
+__name(_LoadArtifactsTool, "LoadArtifactsTool");
+let LoadArtifactsTool = _LoadArtifactsTool;
 const LOAD_ARTIFACTS = new LoadArtifactsTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/load_memory_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -36,7 +37,7 @@ var import_base_tool = require("./base_tool.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class LoadMemoryTool extends import_base_tool.BaseTool {
+const _LoadMemoryTool = class _LoadMemoryTool extends import_base_tool.BaseTool {
   constructor() {
     super({
       name: "load_memory",
@@ -98,7 +99,9 @@ class LoadMemoryTool extends import_base_tool.BaseTool {
 you to look up the memory, you should call load_memory function with a query.`
     ]);
   }
-}
+};
+__name(_LoadMemoryTool, "LoadMemoryTool");
+let LoadMemoryTool = _LoadMemoryTool;
 const LOAD_MEMORY = new LoadMemoryTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/load_web_page.js

@@ -9,6 +9,7 @@ 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 });
@@ -92,13 +93,16 @@ const BLOCKED_IPV6_CIDRS = [
 function failedToFetchMessage(url) {
   return `Failed to fetch url: ${url}`;
 }
+__name(failedToFetchMessage, "failedToFetchMessage");
 function isBlockedHostname(hostname) {
   const normalized = hostname.replace(/\.+$/, "").toLowerCase();
   return normalized === "localhost" || normalized.endsWith(".localhost");
 }
+__name(isBlockedHostname, "isBlockedHostname");
 function normalizeHost(hostname) {
   return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
 }
+__name(normalizeHost, "normalizeHost");
 function parseIpv4(address) {
   const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
   if (!match) {
@@ -110,6 +114,7 @@ function parseIpv4(address) {
   }
   return octets;
 }
+__name(parseIpv4, "parseIpv4");
 function parseIpv6(address) {
   if ((0, import_node_net.isIP)(address) !== 6) {
     return null;
@@ -120,6 +125,7 @@ function parseIpv6(address) {
   const compressed = address.includes("::") ? new Array(8 - highGroups.length - lowGroups.length).fill(0) : [];
   return [...highGroups, ...compressed, ...lowGroups];
 }
+__name(parseIpv6, "parseIpv6");
 function expandHextets(fragment) {
   const hextets = [];
   for (const group of fragment.split(":")) {
@@ -132,9 +138,11 @@ function expandHextets(fragment) {
   }
   return hextets;
 }
+__name(expandHextets, "expandHextets");
 function ipv4ToInt(octets) {
   return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
 }
+__name(ipv4ToInt, "ipv4ToInt");
 function hextetsToBigInt(hextets) {
   let value = 0n;
   for (const hextet of hextets) {
@@ -142,21 +150,25 @@ function hextetsToBigInt(hextets) {
   }
   return value;
 }
+__name(hextetsToBigInt, "hextetsToBigInt");
 function parseIpv4Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
   const mask = 4294967295 << 32 - Number(prefix) >>> 0;
   return { base: (ipv4ToInt(parseIpv4(address)) & mask) >>> 0, mask };
 }
+__name(parseIpv4Cidr, "parseIpv4Cidr");
 function parseIpv6Cidr(cidr) {
   const [address, prefix] = cidr.split("/");
   return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
 }
+__name(parseIpv6Cidr, "parseIpv6Cidr");
 function isBlockedIpv4(octets) {
   const value = ipv4ToInt(octets);
   return BLOCKED_IPV4_CIDRS.some(
     ({ base, mask }) => (value & mask) >>> 0 === base
   );
 }
+__name(isBlockedIpv4, "isBlockedIpv4");
 function isBlockedIpv6(hextets) {
   const value = hextetsToBigInt(hextets);
   if (value >> 32n === 0xffffn) {
@@ -171,6 +183,7 @@ function isBlockedIpv6(hextets) {
     ({ base, prefix }) => value >> BigInt(128 - prefix) === base >> BigInt(128 - prefix)
   );
 }
+__name(isBlockedIpv6, "isBlockedIpv6");
 function isBlockedAddress(address) {
   const octets = parseIpv4(address);
   if (octets) {
@@ -182,6 +195,7 @@ function isBlockedAddress(address) {
   }
   return true;
 }
+__name(isBlockedAddress, "isBlockedAddress");
 async function resolveHostAddresses(hostname) {
   if ((0, import_node_net.isIP)(hostname) !== 0) {
     return [hostname];
@@ -193,6 +207,7 @@ async function resolveHostAddresses(hostname) {
   }
   return addresses;
 }
+__name(resolveHostAddresses, "resolveHostAddresses");
 function assertUrlAllowed(url) {
   const parsed = new URL(url);
   if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
@@ -203,20 +218,24 @@ function assertUrlAllowed(url) {
   }
   return parsed;
 }
+__name(assertUrlAllowed, "assertUrlAllowed");
 async function validateResolvedAddresses(hostname) {
   const addresses = await resolveHostAddresses(hostname);
   if (addresses.some(isBlockedAddress)) {
     throw new Error(`Blocked host: ${hostname}`);
   }
 }
+__name(validateResolvedAddresses, "validateResolvedAddresses");
 function decodeHtmlEntities(text) {
   return text.replace(/&nbsp;/g, " ").replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
 }
+__name(decodeHtmlEntities, "decodeHtmlEntities");
 function htmlToText(html) {
   const withoutCode = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ");
   const text = decodeHtmlEntities(withoutCode.replace(/<[^>]+>/g, "\n"));
   return text.split("\n").map((line) => line.trim()).filter((line) => line.split(/\s+/).filter(Boolean).length > 3).join("\n");
 }
+__name(htmlToText, "htmlToText");
 async function loadWebPage(url, options) {
   var _a;
   const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
@@ -235,13 +254,14 @@ async function loadWebPage(url, options) {
     return failedToFetchMessage(url);
   }
 }
+__name(loadWebPage, "loadWebPage");
 const LOAD_WEB_PAGE = new import_function_tool.FunctionTool({
   name: "load_web_page",
   description: "Fetches the content at the given URL and returns the readable text extracted from the page.",
   parameters: import_zod.z.object({
     url: import_zod.z.string().describe("The URL to fetch and extract text from.")
   }),
-  execute: ({ url }) => loadWebPage(url)
+  execute: /* @__PURE__ */ __name(({ url }) => loadWebPage(url), "execute")
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/long_running_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -36,7 +37,7 @@ var import_function_tool = require("./function_tool.js");
 const LONG_RUNNING_INSTRUCTION = `
 
 NOTE: This is a long-running operation. Do not call this tool again if it has already returned some intermediate or pending status.`;
-class LongRunningFunctionTool extends import_function_tool.FunctionTool {
+const _LongRunningFunctionTool = class _LongRunningFunctionTool extends import_function_tool.FunctionTool {
   /**
    * The constructor acts as the user-friendly factory.
    * @param options The configuration for the tool.
@@ -57,7 +58,9 @@ class LongRunningFunctionTool extends import_function_tool.FunctionTool {
     }
     return declaration;
   }
-}
+};
+__name(_LongRunningFunctionTool, "LongRunningFunctionTool");
+let LongRunningFunctionTool = _LongRunningFunctionTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LongRunningFunctionTool

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

@@ -0,0 +1,39 @@
+/**
+  * @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 mcp_exports = {};
+module.exports = __toCommonJS(mcp_exports);
+__reExport(mcp_exports, require("./load_mcp_resource_tool.js"), module.exports);
+__reExport(mcp_exports, require("./mcp_session_manager.js"), module.exports);
+__reExport(mcp_exports, require("./mcp_tool.js"), module.exports);
+__reExport(mcp_exports, require("./mcp_toolset.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("./load_mcp_resource_tool.js"),
+  ...require("./mcp_session_manager.js"),
+  ...require("./mcp_tool.js"),
+  ...require("./mcp_toolset.js")
+});

package/dist/cjs/tools/mcp/load_mcp_resource_tool.js

@@ -9,6 +9,7 @@ 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 });
@@ -36,7 +37,7 @@ var import_base_tool = require("../base_tool.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class LoadMcpResourceTool extends import_base_tool.BaseTool {
+const _LoadMcpResourceTool = class _LoadMcpResourceTool extends import_base_tool.BaseTool {
   constructor(mcpToolset) {
     super({
       name: "load_mcp_resource",
@@ -133,7 +134,9 @@ before answering questions related to the resources.`
     }
     return { text: `[Unknown content type for ${resourceName}]` };
   }
-}
+};
+__name(_LoadMcpResourceTool, "LoadMcpResourceTool");
+let LoadMcpResourceTool = _LoadMcpResourceTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LoadMcpResourceTool