@google/adk 1.3.0 → 1.5.0

package/dist/cjs/tools/consolidate_context_tool.js

@@ -0,0 +1,79 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consolidate_context_tool_exports = {};
+__export(consolidate_context_tool_exports, {
+  ConsolidateContextTool: () => ConsolidateContextTool
+});
+module.exports = __toCommonJS(consolidate_context_tool_exports);
+var import_genai = require("@google/genai");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ConsolidateContextTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "consolidate_context",
+      description: "Requests context consolidation (compaction) to manage history size. Use this when a subtask is complete and you want to summarize progress and clear detailed history."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          detail: {
+            type: import_genai.Type.STRING,
+            description: "Optional description of what has been accomplished so far. This detail will be used to guide the summarization of the history."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    toolContext.state.set("temp:consolidate_context", true);
+    if (args["detail"] !== void 0) {
+      toolContext.state.set(
+        "temp:consolidate_context_detail",
+        args["detail"]
+      );
+    }
+    return {
+      status: "success",
+      message: "Context consolidation requested."
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsolidateContextTool
+});

package/dist/cjs/tools/enterprise_web_search_tool.js

@@ -0,0 +1,81 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var enterprise_web_search_tool_exports = {};
+__export(enterprise_web_search_tool_exports, {
+  ENTERPRISE_WEB_SEARCH: () => ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool: () => EnterpriseWebSearchTool,
+  applyEnterpriseWebSearch: () => applyEnterpriseWebSearch
+});
+module.exports = __toCommonJS(enterprise_web_search_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyEnterpriseWebSearch(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = (0, import_model_name.isGeminiModelIdCheckDisabled)();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if ((0, import_model_name.isGeminiModel)(llmRequest.model) || modelCheckDisabled) {
+    if ((0, import_model_name.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 import_base_tool.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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool,
+  applyEnterpriseWebSearch
+});

package/dist/cjs/tools/example_tool.js

@@ -0,0 +1,68 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var example_tool_exports = {};
+__export(example_tool_exports, {
+  ExampleTool: () => ExampleTool
+});
+module.exports = __toCommonJS(example_tool_exports);
+var import_example_util = require("../examples/example_util.js");
+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
+ */
+class ExampleTool extends import_base_tool.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;
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      (0, import_example_util.buildExampleSi)(this.examples, parts[0].text, llmRequest.model)
+    ]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExampleTool
+});

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -37,48 +37,36 @@ class ForwardingArtifactService {
     this.toolContext = toolContext;
     this.invocationContext = toolContext.invocationContext;
   }
-  // TODO - b/425992518: Remove unnecessary parameters. We should rethink the
-  // abstraction layer to make it more clear.
   async saveArtifact(request) {
     return this.toolContext.saveArtifact(request.filename, request.artifact);
   }
   async loadArtifact(request) {
     return this.toolContext.loadArtifact(request.filename, request.version);
   }
-  async listArtifactKeys() {
+  async listArtifactKeys(_request) {
     return this.toolContext.listArtifacts();
   }
-  async deleteArtifact(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
+  getArtifactService() {
+    const service = this.invocationContext.artifactService;
+    if (!service) {
       throw new Error("Artifact service is not initialized.");
     }
-    return this.toolContext.invocationContext.artifactService.deleteArtifact(
-      request
-    );
+    return service;
+  }
+  async deleteArtifact(request) {
+    return this.getArtifactService().deleteArtifact(request.filename);
   }
   async listVersions(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.listVersions(
-      request
-    );
+    return this.getArtifactService().listVersions(request.filename);
   }
-  listArtifactVersions(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.listArtifactVersions(
-      request
-    );
+  async listArtifactVersions(request) {
+    return this.getArtifactService().listArtifactVersions(request.filename);
   }
-  getArtifactVersion(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.getArtifactVersion(
-      request
-    );
+  async getArtifactVersion(request) {
+    return this.getArtifactService().getArtifactVersion({
+      filename: request.filename,
+      version: request.version
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/tools/load_web_page.js

@@ -0,0 +1,250 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var load_web_page_exports = {};
+__export(load_web_page_exports, {
+  LOAD_WEB_PAGE: () => LOAD_WEB_PAGE,
+  loadWebPage: () => loadWebPage
+});
+module.exports = __toCommonJS(load_web_page_exports);
+var import_promises = require("node:dns/promises");
+var import_node_net = require("node:net");
+var import_zod = require("zod");
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 ((0, import_node_net.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 ((0, import_node_net.isIP)(hostname) !== 0) {
+    return [hostname];
+  }
+  const records = await (0, import_promises.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 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)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_WEB_PAGE,
+  loadWebPage
+});

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

@@ -0,0 +1,140 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var load_mcp_resource_tool_exports = {};
+__export(load_mcp_resource_tool_exports, {
+  LoadMcpResourceTool: () => LoadMcpResourceTool
+});
+module.exports = __toCommonJS(load_mcp_resource_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../../models/llm_request.js");
+var import_logger = require("../../utils/logger.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class LoadMcpResourceTool extends import_base_tool.BaseTool {
+  constructor(mcpToolset) {
+    super({
+      name: "load_mcp_resource",
+      description: `Loads resources from the MCP server.
+
+NOTE: Call when you need access to resources.`
+    });
+    this.mcpToolset = mcpToolset;
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          resource_names: {
+            type: import_genai.Type.ARRAY,
+            items: {
+              type: import_genai.Type.STRING
+            },
+            description: "The names of the MCP resources to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const resourceNames = args["resource_names"] || [];
+    return {
+      resource_names: resourceNames,
+      status: "resource contents temporarily inserted and removed. to access these resources, call load_mcp_resource tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendResourcesToLlmRequest(request.llmRequest);
+  }
+  async appendResourcesToLlmRequest(llmRequest) {
+    var _a, _b;
+    try {
+      const availableResourceNames = await this.mcpToolset.listResources();
+      if (availableResourceNames.length > 0) {
+        (0, import_llm_request.appendInstructions)(llmRequest, [
+          `You have a list of MCP resources:
+${JSON.stringify(
+            availableResourceNames
+          )}
+
+When the user asks questions about any of the resources, you should call the
+\`load_mcp_resource\` function to load the resource. Always call load_mcp_resource
+before answering questions related to the resources.`
+        ]);
+      }
+    } catch (e) {
+      import_logger.logger.warn(`Failed to list MCP resources: ${e}`);
+    }
+    const lastContent = llmRequest.contents.at(-1);
+    const functionResponse = (_b = (_a = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a[0]) == null ? void 0 : _b.functionResponse;
+    if (!functionResponse || functionResponse.name !== this.name) {
+      return;
+    }
+    const response = functionResponse.response || {};
+    const requestedResourceNames = response["resource_names"] || [];
+    for (const resourceName of requestedResourceNames) {
+      try {
+        const resourceContents = await this.mcpToolset.readResource(resourceName);
+        for (const content of resourceContents) {
+          llmRequest.contents.push({
+            role: "user",
+            parts: [
+              { text: `Resource ${resourceName} is:` },
+              this.mcpContentToPart(content, resourceName)
+            ]
+          });
+        }
+      } catch (e) {
+        import_logger.logger.warn(`Failed to read MCP resource '${resourceName}': ${e}`);
+      }
+    }
+  }
+  mcpContentToPart(content, resourceName) {
+    var _a;
+    if ("text" in content) {
+      return { text: content.text };
+    }
+    if ("blob" in content) {
+      return {
+        inlineData: {
+          data: content.blob,
+          mimeType: (_a = content.mimeType) != null ? _a : "application/octet-stream"
+        }
+      };
+    }
+    return { text: `[Unknown content type for ${resourceName}]` };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadMcpResourceTool
+});