@google/adk 1.6.0 → 2.0.0

package/dist/cjs/tools/example_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 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class ExampleTool extends import_base_tool.BaseTool {
+const _ExampleTool = class _ExampleTool extends import_base_tool.BaseTool {
   constructor(examples) {
     super({
       // Name and description are not used because this tool only changes
@@ -61,7 +62,9 @@ class ExampleTool extends import_base_tool.BaseTool {
       (0, import_example_util.buildExampleSi)(this.examples, parts[0].text, llmRequest.model)
     ]);
   }
-}
+};
+__name(_ExampleTool, "ExampleTool");
+let ExampleTool = _ExampleTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ExampleTool

package/dist/cjs/tools/exit_loop_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 });
@@ -34,7 +35,7 @@ var import_base_tool = require("./base_tool.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class ExitLoopTool extends import_base_tool.BaseTool {
+const _ExitLoopTool = class _ExitLoopTool extends import_base_tool.BaseTool {
   /** Creates an ExitLoopTool with its fixed name and description. */
   constructor() {
     super({
@@ -63,7 +64,9 @@ class ExitLoopTool extends import_base_tool.BaseTool {
     toolContext.actions.skipSummarization = true;
     return "";
   }
-}
+};
+__name(_ExitLoopTool, "ExitLoopTool");
+let ExitLoopTool = _ExitLoopTool;
 const EXIT_LOOP = new ExitLoopTool();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/tools/finish_task_tool.js

@@ -0,0 +1,119 @@
+/**
+  * @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 finish_task_tool_exports = {};
+__export(finish_task_tool_exports, {
+  FINISH_TASK_SUCCESS_RESULT: () => FINISH_TASK_SUCCESS_RESULT,
+  FINISH_TASK_TOOL_NAME: () => FINISH_TASK_TOOL_NAME,
+  FinishTaskTool: () => FinishTaskTool
+});
+module.exports = __toCommonJS(finish_task_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const FINISH_TASK_TOOL_NAME = "finish_task";
+const FINISH_TASK_SUCCESS_RESULT = "Task completed.";
+const DEFAULT_TASK_OUTPUT_SCHEMA = {
+  type: import_genai.Type.OBJECT,
+  properties: {
+    result: {
+      type: import_genai.Type.STRING,
+      description: "A brief summary of what the agent accomplished."
+    }
+  },
+  required: ["result"]
+};
+const _FinishTaskTool = class _FinishTaskTool extends import_base_tool.BaseTool {
+  constructor(outputSchema) {
+    const schema = outputSchema != null ? outputSchema : DEFAULT_TASK_OUTPUT_SCHEMA;
+    let description = "Signal that this agent has completed its delegated task. Call this when you have finished your delegated task.";
+    if (outputSchema) {
+      description += " Pass the required output data in the parameters.";
+    }
+    super({ name: FINISH_TASK_TOOL_NAME, description });
+    this.outputSchema = schema;
+    this.wrapperKey = schema.type === import_genai.Type.OBJECT ? void 0 : "result";
+  }
+  _getDeclaration() {
+    const parameters = this.wrapperKey ? {
+      type: import_genai.Type.OBJECT,
+      properties: { [this.wrapperKey]: this.outputSchema },
+      required: [this.wrapperKey]
+    } : this.outputSchema;
+    return { name: this.name, description: this.description, parameters };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    (0, import_llm_request.appendInstructions)(request.llmRequest, [
+      "Do NOT call `finish_task` prematurely. Use your available tools to fully complete every aspect of the task first. If the task is unclear, ask the user for clarification before proceeding. Once the task is fully complete, call `finish_task` by itself with no accompanying text output."
+    ]);
+  }
+  /**
+   * Extracts the task output from a `finish_task` call's arguments, applying the
+   * wrapper-key unwrapping when the schema is a non-object.
+   */
+  extractOutput(args) {
+    if (this.wrapperKey) {
+      return args[this.wrapperKey];
+    }
+    return args;
+  }
+  async runAsync({ args }) {
+    const value = this.wrapperKey ? args[this.wrapperKey] : args;
+    const missing = this.missingRequiredKeys(value);
+    if (missing.length > 0) {
+      return {
+        error: `Invoking \`${this.name}()\` failed due to missing required parameters: ${missing.join(", ")}. You could retry calling this tool, but it is IMPORTANT for you to provide all the mandatory parameters with correct types.`
+      };
+    }
+    return FINISH_TASK_SUCCESS_RESULT;
+  }
+  /** Returns any `required` keys the schema declares that are absent. */
+  missingRequiredKeys(value) {
+    var _a;
+    const required = this.wrapperKey ? value === void 0 || value === null ? [this.wrapperKey] : [] : (_a = this.outputSchema.required) != null ? _a : [];
+    if (this.wrapperKey) {
+      return required;
+    }
+    if (typeof value !== "object" || value === null) {
+      return required;
+    }
+    const obj = value;
+    return required.filter((key) => obj[key] === void 0);
+  }
+};
+__name(_FinishTaskTool, "FinishTaskTool");
+let FinishTaskTool = _FinishTaskTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FINISH_TASK_SUCCESS_RESULT,
+  FINISH_TASK_TOOL_NAME,
+  FinishTaskTool
+});

package/dist/cjs/tools/forwarding_artifact_service.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 });
@@ -32,7 +33,7 @@ module.exports = __toCommonJS(forwarding_artifact_service_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-class ForwardingArtifactService {
+const _ForwardingArtifactService = class _ForwardingArtifactService {
   constructor(toolContext) {
     this.toolContext = toolContext;
     this.invocationContext = toolContext.invocationContext;
@@ -68,7 +69,9 @@ class ForwardingArtifactService {
       version: request.version
     });
   }
-}
+};
+__name(_ForwardingArtifactService, "ForwardingArtifactService");
+let ForwardingArtifactService = _ForwardingArtifactService;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ForwardingArtifactService

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

@@ -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 });
@@ -40,12 +41,12 @@ const getUserChoiceTool = new import_long_running_tool.LongRunningFunctionTool({
   parameters: import_zod.z.object({
     options: import_zod.z.array(import_zod.z.string()).describe("List of options to present to the user.")
   }),
-  execute: async (input, context) => {
+  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 = {

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