@google/adk 1.4.0 → 1.5.0

package/dist/esm/context/token_based_context_compactor.js

@@ -7,6 +7,7 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { getContents } from "../agents/processors/content_processor_utils.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
+import { calculateRetainStartIndex } from "./compaction_utils.js";
 const CHARS_PER_TOKEN = 4;
 class TokenBasedContextCompactor {
   constructor(options) {
@@ -39,6 +40,13 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
     }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return false;
+    }
     const promptTokenCount = latestPromptTokenCount(
       activeEvents,
       invocationContext
@@ -55,19 +63,10 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
     }
-    let retainStartIndex = Math.max(
-      0,
-      rawEvents.length - this.eventRetentionSize
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
     );
-    while (retainStartIndex > 0) {
-      const eventToRetain = rawEvents[retainStartIndex];
-      const previousEvent = rawEvents[retainStartIndex - 1];
-      if (hasFunctionResponse(eventToRetain) && hasFunctionCall(previousEvent)) {
-        retainStartIndex--;
-      } else {
-        break;
-      }
-    }
     if (retainStartIndex === 0) {
       return;
     }
@@ -122,18 +121,6 @@ function estimatePromptTokenCount(activeEvents, invocationContext) {
   }
   return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
-function hasFunctionCall(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionCall !== void 0
-  ));
-}
-function hasFunctionResponse(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionResponse !== void 0
-  ));
-}
 export {
   TokenBasedContextCompactor
 };

package/dist/esm/events/compacted_event.js

@@ -9,16 +9,21 @@ import { createEvent } from "./event.js";
 function isCompactedEvent(event) {
   return "isCompacted" in event && event.isCompacted === true;
 }
+function isScratchpadEvent(event) {
+  return isCompactedEvent(event) && event.isScratchpad === true;
+}
 function createCompactedEvent(params = {}) {
   return {
     ...createEvent(params),
     isCompacted: params.isCompacted || true,
     startTime: params.startTime,
     endTime: params.endTime,
-    compactedContent: params.compactedContent
+    compactedContent: params.compactedContent,
+    isScratchpad: params.isScratchpad
   };
 }
 export {
   createCompactedEvent,
-  isCompactedEvent
+  isCompactedEvent,
+  isScratchpadEvent
 };

package/dist/esm/events/event.js

@@ -5,6 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { randomUUID } from "../utils/env_aware_utils.js";
 import { toCamelCase, toSnakeCase } from "../utils/object_notation_utils.js";
 import { createEventActions } from "./event_actions.js";
 function createEvent(params = {}) {
@@ -36,6 +37,17 @@ function getFunctionCalls(event) {
   }
   return funcCalls;
 }
+const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+function generateClientFunctionCallId() {
+  return `${AF_FUNCTION_CALL_ID_PREFIX}${randomUUID()}`;
+}
+function populateClientFunctionCallId(modelResponseEvent) {
+  for (const functionCall of getFunctionCalls(modelResponseEvent)) {
+    if (!functionCall.id) {
+      functionCall.id = generateClientFunctionCallId();
+    }
+  }
+}
 function getFunctionResponses(event) {
   const funcResponses = [];
   if (event.content && event.content.parts) {
@@ -65,6 +77,14 @@ function stringifyContent(event) {
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
 }
+function getEventTokens(event) {
+  var _a;
+  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
+    return event.usageMetadata.promptTokenCount;
+  }
+  const contentStr = stringifyContent(event);
+  return Math.ceil(contentStr.length / 4);
+}
 function hasThoughts(event) {
   var _a, _b;
   return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some((part) => part.thought === true));
@@ -120,13 +140,17 @@ function transformToSnakeCaseEvent(event) {
   return toSnakeCase(event, PRESERVE_KEYS_CAMEL_CASE);
 }
 export {
+  AF_FUNCTION_CALL_ID_PREFIX,
   createEvent,
   createNewEventId,
+  generateClientFunctionCallId,
+  getEventTokens,
   getFunctionCalls,
   getFunctionResponses,
   hasThoughts,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
+  populateClientFunctionCallId,
   pruneThoughts,
   stringifyContent,
   transformToCamelCaseEvent,

package/dist/esm/index.js

@@ -29,11 +29,15 @@ import {
   loadSkillFromDir,
   validateSkillDir
 } from "./skills/loader.js";
-import { RunSkillInlineScriptTool } from "./tools/skill/run_skill_inline_script_tool.js";
+import {
+  RunSkillInlineScriptErrorCode,
+  RunSkillInlineScriptTool
+} from "./tools/skill/run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./tools/skill/run_skill_script_tool.js";
 export * from "./integrations/agent_registry/agent_registry.js";
 export * from "./telemetry/google_cloud.js";
 export * from "./telemetry/setup.js";
+export * from "./tools/mcp/load_mcp_resource_tool.js";
 export * from "./tools/mcp/mcp_session_manager.js";
 export * from "./tools/mcp/mcp_tool.js";
 export * from "./tools/mcp/mcp_toolset.js";
@@ -47,6 +51,7 @@ export {
   GcsArtifactService,
   InvocationContext,
   RemoteA2AAgent,
+  RunSkillInlineScriptErrorCode,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,

package/dist/esm/integrations/agent_registry/agent_registry_mcp_toolset.js

@@ -10,6 +10,7 @@ import {
   MCPSessionManager
 } from "../../tools/mcp/mcp_session_manager.js";
 import { MCPTool } from "../../tools/mcp/mcp_tool.js";
+import { logger } from "../../utils/logger.js";
 import { GCP_MCP_SERVER_DESTINATION_ID } from "./types.js";
 class AgentRegistrySingleMCPToolset extends BaseToolset {
   /**
@@ -65,7 +66,14 @@ class AgentRegistrySingleMCPToolset extends BaseToolset {
     };
     const sessionManager = new MCPSessionManager(connectionParamsCopy);
     const session = await sessionManager.createSession();
-    const listResult = await session.listTools();
+    let listResult;
+    try {
+      listResult = await session.listTools();
+    } finally {
+      await sessionManager.closeSession(session).catch((e) => {
+        logger.warn("Failed to close MCP discovery session", e);
+      });
+    }
     const tools = listResult.tools.map((tool) => {
       const prefixedName = this.prefix ? `${this.prefix}_${tool.name}` : tool.name;
       const mcpTool = new MCPTool(

package/dist/esm/plugins/global_instruction_plugin.js

@@ -0,0 +1,69 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { injectSessionState } from "../agents/instructions.js";
+import { ReadonlyContext } from "../agents/readonly_context.js";
+import { BasePlugin } from "./base_plugin.js";
+class GlobalInstructionPlugin extends BasePlugin {
+  /**
+   * Initializes the GlobalInstructionPlugin.
+   *
+   * @param globalInstruction The instruction to apply globally. Can be a string
+   *     or an InstructionProvider function that takes ReadonlyContext and
+   *     returns a string (sync or async).
+   * @param name The name of the plugin (defaults to 'global_instruction').
+   */
+  constructor(globalInstruction, name = "global_instruction") {
+    super(name);
+    this.globalInstruction = globalInstruction;
+  }
+  async beforeModelCallback(params) {
+    if (!this.globalInstruction) {
+      return;
+    }
+    const readonlyContext = new ReadonlyContext(
+      params.callbackContext.invocationContext
+    );
+    const finalGlobalInstruction = await this.resolveGlobalInstruction(readonlyContext);
+    if (!finalGlobalInstruction) {
+      return;
+    }
+    if (!params.llmRequest.config) {
+      params.llmRequest.config = {};
+    }
+    const existingInstruction = params.llmRequest.config.systemInstruction;
+    if (!existingInstruction || Array.isArray(existingInstruction) && existingInstruction.length === 0) {
+      params.llmRequest.config.systemInstruction = finalGlobalInstruction;
+      return;
+    }
+    if (typeof existingInstruction === "string") {
+      params.llmRequest.config.systemInstruction = `${finalGlobalInstruction}
+
+${existingInstruction}`;
+    } else if (Array.isArray(existingInstruction)) {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        ...existingInstruction
+      ];
+    } else {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        existingInstruction
+      ];
+    }
+    return;
+  }
+  async resolveGlobalInstruction(readonlyContext) {
+    if (typeof this.globalInstruction === "string") {
+      return await injectSessionState(this.globalInstruction, readonlyContext);
+    }
+    return await this.globalInstruction(readonlyContext);
+  }
+}
+export {
+  GlobalInstructionPlugin
+};

package/dist/esm/runner/runner.js

@@ -181,7 +181,7 @@ class Runner {
               throw new Error("No parts in the newMessage.");
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
-              await this.saveArtifacts(
+              newMessage = await this.saveArtifacts(
                 invocationContext.invocationId,
                 session.userId,
                 session.id,
@@ -269,7 +269,7 @@ class Runner {
   }
   /**
    * Saves artifacts from the message parts and replaces the inline data with
-   * a file name placeholder.
+   * a file name placeholder and optional file reference.
    *
    * @param invocationId The current invocation ID.
    * @param userId The user ID of the session.
@@ -279,28 +279,67 @@ class Runner {
   async saveArtifacts(invocationId, userId, sessionId, message) {
     var _a2;
     if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
-      return;
+      return message;
     }
     const sessionKey = {
       appName: this.appName,
       userId,
       sessionId
     };
+    const newParts = [];
+    let modified = false;
     for (let i = 0; i < message.parts.length; i++) {
       const part = message.parts[i];
       if (!part.inlineData) {
+        newParts.push(part);
         continue;
       }
-      const fileName = `artifact_${invocationId}_${i}`;
-      await this.artifactService.saveArtifact({
-        ...sessionKey,
-        filename: fileName,
-        artifact: part
-      });
-      message.parts[i] = createPartFromText(
-        `Uploaded file: ${fileName}. It is saved into artifacts`
-      );
+      try {
+        const inlineData = part.inlineData;
+        const fileName = inlineData.displayName || `artifact_${invocationId}_${i}`;
+        const version = await this.artifactService.saveArtifact({
+          ...sessionKey,
+          filename: fileName,
+          artifact: part
+        });
+        newParts.push(createPartFromText(`[Uploaded Artifact: "${fileName}"]`));
+        try {
+          const artifactVersion = await this.artifactService.getArtifactVersion(
+            {
+              ...sessionKey,
+              filename: fileName,
+              version
+            }
+          );
+          if ((artifactVersion == null ? void 0 : artifactVersion.canonicalUri) && /^(gs|https?):/i.test(artifactVersion.canonicalUri)) {
+            newParts.push({
+              fileData: {
+                fileUri: artifactVersion.canonicalUri,
+                mimeType: artifactVersion.mimeType || inlineData.mimeType || "",
+                displayName: fileName
+              }
+            });
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to resolve artifact version for ${fileName}:`,
+            error
+          );
+        }
+        modified = true;
+        logger.info(`Successfully saved artifact: ${fileName}`);
+      } catch (error) {
+        logger.error(`Failed to save artifact for part ${i}:`, error);
+        newParts.push(part);
+      }
+    }
+    if (!modified) {
+      return message;
     }
+    return {
+      ...message,
+      parts: newParts
+    };
   }
   /**
    * Determines the next agent to run to continue the session. This is primarily

package/dist/esm/tools/enterprise_web_search_tool.js

@@ -0,0 +1,55 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+function applyEnterpriseWebSearch(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
+    if (isGemini1Model(llmRequest.model) && llmRequest.config.tools.length > 0) {
+      throw new Error(
+        "Enterprise Web Search tool cannot be used with other tools in Gemini 1.x."
+      );
+    }
+    llmRequest.config.tools.push({ enterpriseWebSearch: {} });
+    return;
+  }
+  throw new Error(
+    `Enterprise Web Search tool is not supported for model ${llmRequest.model}`
+  );
+}
+class EnterpriseWebSearchTool extends BaseTool {
+  constructor() {
+    super({
+      name: "enterprise_web_search",
+      description: "Enterprise Web Search Tool"
+    });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyEnterpriseWebSearch(llmRequest);
+  }
+}
+const ENTERPRISE_WEB_SEARCH = new EnterpriseWebSearchTool();
+export {
+  ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool,
+  applyEnterpriseWebSearch
+};

package/dist/esm/tools/example_tool.js

@@ -0,0 +1,42 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildExampleSi } from "../examples/example_util.js";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class ExampleTool extends BaseTool {
+  constructor(examples) {
+    super({
+      // Name and description are not used because this tool only changes
+      // llmRequest.
+      name: "example_tool",
+      description: "example tool"
+    });
+    this.examples = examples;
+  }
+  async runAsync(_request) {
+    throw new Error("ExampleTool should not be called by model");
+  }
+  async processLlmRequest({
+    toolContext,
+    llmRequest
+  }) {
+    var _a, _b;
+    const parts = (_a = toolContext.userContent) == null ? void 0 : _a.parts;
+    if (!parts || !((_b = parts[0]) == null ? void 0 : _b.text)) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      buildExampleSi(this.examples, parts[0].text, llmRequest.model)
+    ]);
+  }
+}
+export {
+  ExampleTool
+};

package/dist/esm/tools/load_web_page.js

@@ -0,0 +1,221 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { z } from "zod";
+import { FunctionTool } from "./function_tool.js";
+const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+const DEFAULT_TIMEOUT_MS = 3e4;
+const BLOCKED_IPV4_CIDRS = [
+  "0.0.0.0/8",
+  // "this host on this network"
+  "10.0.0.0/8",
+  // private
+  "100.64.0.0/10",
+  // shared address space / CGNAT
+  "127.0.0.0/8",
+  // loopback
+  "169.254.0.0/16",
+  // link-local (includes GCP metadata 169.254.169.254)
+  "172.16.0.0/12",
+  // private
+  "192.0.0.0/24",
+  // IETF protocol assignments
+  "192.0.2.0/24",
+  // TEST-NET-1 (documentation)
+  "192.88.99.0/24",
+  // 6to4 relay anycast (deprecated)
+  "192.168.0.0/16",
+  // private
+  "198.18.0.0/15",
+  // benchmarking
+  "198.51.100.0/24",
+  // TEST-NET-2 (documentation)
+  "203.0.113.0/24",
+  // TEST-NET-3 (documentation)
+  "224.0.0.0/4",
+  // multicast
+  "240.0.0.0/4"
+  // reserved / future use (includes 255.255.255.255)
+].map(parseIpv4Cidr);
+const BLOCKED_IPV6_CIDRS = [
+  "::/128",
+  // unspecified
+  "::1/128",
+  // loopback
+  "64:ff9b:1::/48",
+  // local NAT64
+  "100::/64",
+  // discard-only
+  "2001:db8::/32",
+  // documentation
+  "fc00::/7",
+  // unique-local (ULA, private)
+  "fe80::/10",
+  // link-local
+  "ff00::/8"
+  // multicast
+].map(parseIpv6Cidr);
+function failedToFetchMessage(url) {
+  return `Failed to fetch url: ${url}`;
+}
+function isBlockedHostname(hostname) {
+  const normalized = hostname.replace(/\.+$/, "").toLowerCase();
+  return normalized === "localhost" || normalized.endsWith(".localhost");
+}
+function normalizeHost(hostname) {
+  return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
+}
+function parseIpv4(address) {
+  const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
+  if (!match) {
+    return null;
+  }
+  const octets = match.slice(1).map(Number);
+  if (octets.some((octet) => octet > 255)) {
+    return null;
+  }
+  return octets;
+}
+function parseIpv6(address) {
+  if (isIP(address) !== 6) {
+    return null;
+  }
+  const [head, tail] = address.split("::");
+  const highGroups = head ? expandHextets(head) : [];
+  const lowGroups = tail ? expandHextets(tail) : [];
+  const compressed = address.includes("::") ? new Array(8 - highGroups.length - lowGroups.length).fill(0) : [];
+  return [...highGroups, ...compressed, ...lowGroups];
+}
+function expandHextets(fragment) {
+  const hextets = [];
+  for (const group of fragment.split(":")) {
+    if (group.includes(".")) {
+      const octets = parseIpv4(group);
+      hextets.push(octets[0] << 8 | octets[1], octets[2] << 8 | octets[3]);
+    } else {
+      hextets.push(parseInt(group, 16));
+    }
+  }
+  return hextets;
+}
+function ipv4ToInt(octets) {
+  return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+}
+function hextetsToBigInt(hextets) {
+  let value = 0n;
+  for (const hextet of hextets) {
+    value = value << 16n | BigInt(hextet);
+  }
+  return value;
+}
+function parseIpv4Cidr(cidr) {
+  const [address, prefix] = cidr.split("/");
+  const mask = 4294967295 << 32 - Number(prefix) >>> 0;
+  return { base: (ipv4ToInt(parseIpv4(address)) & mask) >>> 0, mask };
+}
+function parseIpv6Cidr(cidr) {
+  const [address, prefix] = cidr.split("/");
+  return { base: hextetsToBigInt(parseIpv6(address)), prefix: Number(prefix) };
+}
+function isBlockedIpv4(octets) {
+  const value = ipv4ToInt(octets);
+  return BLOCKED_IPV4_CIDRS.some(
+    ({ base, mask }) => (value & mask) >>> 0 === base
+  );
+}
+function isBlockedIpv6(hextets) {
+  const value = hextetsToBigInt(hextets);
+  if (value >> 32n === 0xffffn) {
+    return isBlockedIpv4([
+      Number(value >> 24n & 0xffn),
+      Number(value >> 16n & 0xffn),
+      Number(value >> 8n & 0xffn),
+      Number(value & 0xffn)
+    ]);
+  }
+  return BLOCKED_IPV6_CIDRS.some(
+    ({ base, prefix }) => value >> BigInt(128 - prefix) === base >> BigInt(128 - prefix)
+  );
+}
+function isBlockedAddress(address) {
+  const octets = parseIpv4(address);
+  if (octets) {
+    return isBlockedIpv4(octets);
+  }
+  const hextets = parseIpv6(address);
+  if (hextets) {
+    return isBlockedIpv6(hextets);
+  }
+  return true;
+}
+async function resolveHostAddresses(hostname) {
+  if (isIP(hostname) !== 0) {
+    return [hostname];
+  }
+  const records = await lookup(hostname, { all: true });
+  const addresses = [...new Set(records.map((record) => record.address))];
+  if (addresses.length === 0) {
+    throw new Error(`Unable to resolve host: ${hostname}`);
+  }
+  return addresses;
+}
+function assertUrlAllowed(url) {
+  const parsed = new URL(url);
+  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+    throw new Error(`Unsupported url scheme: ${url}`);
+  }
+  if (isBlockedHostname(parsed.hostname)) {
+    throw new Error(`Blocked host: ${parsed.hostname}`);
+  }
+  return parsed;
+}
+async function validateResolvedAddresses(hostname) {
+  const addresses = await resolveHostAddresses(hostname);
+  if (addresses.some(isBlockedAddress)) {
+    throw new Error(`Blocked host: ${hostname}`);
+  }
+}
+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, "&");
+}
+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");
+}
+async function loadWebPage(url, options) {
+  var _a;
+  const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
+  try {
+    const parsed = assertUrlAllowed(url);
+    await validateResolvedAddresses(normalizeHost(parsed.hostname));
+    const response = await fetch(url, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (response.status !== 200) {
+      return failedToFetchMessage(url);
+    }
+    return htmlToText(await response.text());
+  } catch {
+    return failedToFetchMessage(url);
+  }
+}
+const LOAD_WEB_PAGE = new FunctionTool({
+  name: "load_web_page",
+  description: "Fetches the content at the given URL and returns the readable text extracted from the page.",
+  parameters: z.object({
+    url: z.string().describe("The URL to fetch and extract text from.")
+  }),
+  execute: ({ url }) => loadWebPage(url)
+});
+export {
+  LOAD_WEB_PAGE,
+  loadWebPage
+};