@google/adk 2.0.0 → 2.2.0

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -33,10 +33,18 @@ module.exports = __toCommonJS(forwarding_artifact_service_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.sessionArtifactService"
+);
+_a = SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL;
 const _ForwardingArtifactService = class _ForwardingArtifactService {
   constructor(toolContext) {
     this.toolContext = toolContext;
-    this.invocationContext = toolContext.invocationContext;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    this[_a] = true;
   }
   async saveArtifact(request) {
     return this.toolContext.saveArtifact(request.filename, request.artifact);
@@ -44,30 +52,27 @@ const _ForwardingArtifactService = class _ForwardingArtifactService {
   async loadArtifact(request) {
     return this.toolContext.loadArtifact(request.filename, request.version);
   }
-  async listArtifactKeys(_request) {
+  async listArtifactKeys() {
     return this.toolContext.listArtifacts();
   }
   getArtifactService() {
-    const service = this.invocationContext.artifactService;
+    const service = this.toolContext.invocationContext.artifactService;
     if (!service) {
       throw new Error("Artifact service is not initialized.");
     }
     return service;
   }
-  async deleteArtifact(request) {
-    return this.getArtifactService().deleteArtifact(request.filename);
+  async deleteArtifact(filename) {
+    return this.getArtifactService().deleteArtifact(filename);
   }
-  async listVersions(request) {
-    return this.getArtifactService().listVersions(request.filename);
+  async listVersions(filename) {
+    return this.getArtifactService().listVersions(filename);
   }
-  async listArtifactVersions(request) {
-    return this.getArtifactService().listArtifactVersions(request.filename);
+  async listArtifactVersions(filename) {
+    return this.getArtifactService().listArtifactVersions(filename);
   }
   async getArtifactVersion(request) {
-    return this.getArtifactService().getArtifactVersion({
-      filename: request.filename,
-      version: request.version
-    });
+    return this.getArtifactService().getArtifactVersion(request);
   }
 };
 __name(_ForwardingArtifactService, "ForwardingArtifactService");

package/dist/cjs/tools/function_tool.js

@@ -48,7 +48,7 @@ function toSchema(parameters) {
   return parameters;
 }
 __name(toSchema, "toSchema");
-const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ 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;
 }
@@ -89,11 +89,14 @@ const _FunctionTool = class _FunctionTool extends (_b = import_base_tool.BaseToo
     };
   }
   /**
-   * Validates the model-provided arguments against the parameter schema and
-   * invokes the user-defined `execute` function.
+   * Invokes the user-defined `execute` function with the model-provided
+   * arguments, after parsing them when `parameters` is a Zod object schema.
+   * Any other `parameters` value is passed through unchecked.
    *
    * @param req The tool request containing arguments and tool context.
    * @returns A promise resolving to the function's return value.
+   * @throws {Error} Wrapped as `Error in tool '<name>': …` when a Zod
+   *     `parameters` schema rejects the arguments or `execute` throws.
    */
   async runAsync(req) {
     try {

package/dist/cjs/tools/google_maps_grounding_tool.js

@@ -31,7 +31,7 @@ __export(google_maps_grounding_tool_exports, {
 });
 module.exports = __toCommonJS(google_maps_grounding_tool_exports);
 var import_model_name = require("../utils/model_name.js");
-var import_base_tool = require("./base_tool.js");
+var import_built_in_tool = require("./built_in_tool.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -60,14 +60,11 @@ function applyGoogleMapsGrounding(llmRequest) {
   );
 }
 __name(applyGoogleMapsGrounding, "applyGoogleMapsGrounding");
-const _GoogleMapsGroundingTool = class _GoogleMapsGroundingTool extends import_base_tool.BaseTool {
+const _GoogleMapsGroundingTool = class _GoogleMapsGroundingTool extends import_built_in_tool.BuiltInTool {
   constructor() {
     super({ name: "google_maps", description: "Google Maps Grounding Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     applyGoogleMapsGrounding(llmRequest);

package/dist/cjs/tools/google_search_tool.js

@@ -30,20 +30,17 @@ __export(google_search_tool_exports, {
 });
 module.exports = __toCommonJS(google_search_tool_exports);
 var import_model_name = require("../utils/model_name.js");
-var import_base_tool = require("./base_tool.js");
+var import_built_in_tool = require("./built_in_tool.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const _GoogleSearchTool = class _GoogleSearchTool extends import_base_tool.BaseTool {
+const _GoogleSearchTool = class _GoogleSearchTool extends import_built_in_tool.BuiltInTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     if (!llmRequest.model) {

package/dist/cjs/tools/load_artifacts_tool.js

@@ -38,7 +38,6 @@ var import_base_tool = require("./base_tool.js");
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const logger = (0, import_logger.getLogger)();
 const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
 const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
 const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
@@ -135,6 +134,7 @@ NOTE: Call when you need access to artifacts (for example, uploads saved by the
     );
   }
   async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    var _a, _b;
     if (!toolContext.invocationContext.artifactService) {
       return;
     }
@@ -155,33 +155,57 @@ NOTE: Call when you need access to artifacts (for example, uploads saved by the
   artifacts.`
     ]);
     const contents = llmRequest.contents;
-    if (contents && contents.length > 0) {
-      const lastContent = contents[contents.length - 1];
-      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
-        const functionResponsePart = lastContent.parts[0];
-        const functionResponse = functionResponsePart.functionResponse;
-        if (functionResponse && functionResponse.name === "load_artifacts") {
-          const response = functionResponse.response || {};
-          const namesToLoad = response["artifact_names"] || [];
-          for (const artifactName of namesToLoad) {
-            let artifact = await toolContext.loadArtifact(artifactName);
-            if (!artifact && !artifactName.startsWith("user:")) {
-              const prefixedName = `user:${artifactName}`;
-              artifact = await toolContext.loadArtifact(prefixedName);
-            }
-            if (!artifact) {
-              logger.warn(`Artifact "${artifactName}" not found, skipping`);
-              continue;
+    if (!contents || contents.length === 0) {
+      return;
+    }
+    let startIndex = 0;
+    for (let i = contents.length - 1; i >= 0; i--) {
+      const content = contents[i];
+      const hasFunctionResponse = (_a = content.parts) == null ? void 0 : _a.some(
+        (part) => part.functionResponse !== void 0
+      );
+      const hasFunctionCall = (_b = content.parts) == null ? void 0 : _b.some(
+        (part) => part.functionCall !== void 0
+      );
+      if (content.role === "model" && !hasFunctionCall || content.role === "user" && !hasFunctionResponse) {
+        startIndex = i;
+        break;
+      }
+    }
+    const namesToLoad = [];
+    for (let i = startIndex; i < contents.length; i++) {
+      const content = contents[i];
+      if (content.role === "user" && content.parts) {
+        for (const part of content.parts) {
+          const functionResponse = part.functionResponse;
+          if (functionResponse && functionResponse.name === this.name) {
+            const response = functionResponse.response || {};
+            const artifactNames2 = response["artifact_names"] || [];
+            for (const name of artifactNames2) {
+              if (name && !namesToLoad.includes(name)) {
+                namesToLoad.push(name);
+              }
             }
-            const artifactPart = asSafePartForLlm(artifact, artifactName);
-            llmRequest.contents.push({
-              role: "user",
-              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
-            });
           }
         }
       }
     }
+    for (const artifactName of namesToLoad) {
+      let artifact = await toolContext.loadArtifact(artifactName);
+      if (!artifact && !artifactName.startsWith("user:")) {
+        const prefixedName = `user:${artifactName}`;
+        artifact = await toolContext.loadArtifact(prefixedName);
+      }
+      if (!artifact) {
+        import_logger.logger.warn(`Artifact "${artifactName}" not found, skipping`);
+        continue;
+      }
+      const artifactPart = asSafePartForLlm(artifact, artifactName);
+      llmRequest.contents.push({
+        role: "user",
+        parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+      });
+    }
   }
 };
 __name(_LoadArtifactsTool, "LoadArtifactsTool");

package/dist/cjs/tools/load_web_page.js

@@ -29,199 +29,33 @@ __export(load_web_page_exports, {
   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_ssrf_guard = require("../utils/ssrf_guard.js");
 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}`;
 }
 __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) {
-    return null;
-  }
-  const octets = match.slice(1).map(Number);
-  if (octets.some((octet) => octet > 255)) {
-    return null;
-  }
-  return octets;
-}
-__name(parseIpv4, "parseIpv4");
-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];
-}
-__name(parseIpv6, "parseIpv6");
-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;
-}
-__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) {
-    value = value << 16n | BigInt(hextet);
-  }
-  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) {
-    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)
-  );
-}
-__name(isBlockedIpv6, "isBlockedIpv6");
-function isBlockedAddress(address) {
-  const octets = parseIpv4(address);
-  if (octets) {
-    return isBlockedIpv4(octets);
-  }
-  const hextets = parseIpv6(address);
-  if (hextets) {
-    return isBlockedIpv6(hextets);
-  }
-  return true;
-}
-__name(isBlockedAddress, "isBlockedAddress");
-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;
-}
-__name(resolveHostAddresses, "resolveHostAddresses");
 function assertUrlAllowed(url) {
   const parsed = new URL(url);
-  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+  if (!(0, import_ssrf_guard.isHttpUrl)(parsed)) {
     throw new Error(`Unsupported url scheme: ${url}`);
   }
-  if (isBlockedHostname(parsed.hostname)) {
+  if ((0, import_ssrf_guard.isLocalhostHostname)(parsed.hostname)) {
     throw new Error(`Blocked host: ${parsed.hostname}`);
   }
   return parsed;
 }
 __name(assertUrlAllowed, "assertUrlAllowed");
 async function validateResolvedAddresses(hostname) {
-  const addresses = await resolveHostAddresses(hostname);
-  if (addresses.some(isBlockedAddress)) {
+  const addresses = await (0, import_ssrf_guard.resolveHostAddresses)(hostname);
+  if (addresses.some(import_ssrf_guard.isNonGlobalAddress)) {
     throw new Error(`Blocked host: ${hostname}`);
   }
 }
@@ -241,7 +75,7 @@ async function loadWebPage(url, options) {
   const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
   try {
     const parsed = assertUrlAllowed(url);
-    await validateResolvedAddresses(normalizeHost(parsed.hostname));
+    await validateResolvedAddresses((0, import_ssrf_guard.normalizeHost)(parsed.hostname));
     const response = await fetch(url, {
       redirect: "manual",
       signal: AbortSignal.timeout(timeoutMs)

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

@@ -95,13 +95,42 @@ 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) {
+    const contents = llmRequest.contents;
+    if (!contents || contents.length === 0) {
       return;
     }
-    const response = functionResponse.response || {};
-    const requestedResourceNames = response["resource_names"] || [];
+    let startIndex = 0;
+    for (let i = contents.length - 1; i >= 0; i--) {
+      const content = contents[i];
+      const hasFunctionResponse = (_a = content.parts) == null ? void 0 : _a.some(
+        (part) => part.functionResponse !== void 0
+      );
+      const hasFunctionCall = (_b = content.parts) == null ? void 0 : _b.some(
+        (part) => part.functionCall !== void 0
+      );
+      if (content.role === "model" && !hasFunctionCall || content.role === "user" && !hasFunctionResponse) {
+        startIndex = i;
+        break;
+      }
+    }
+    const requestedResourceNames = [];
+    for (let i = startIndex; i < contents.length; i++) {
+      const content = contents[i];
+      if (content.role === "user" && content.parts) {
+        for (const part of content.parts) {
+          const functionResponse = part.functionResponse;
+          if (functionResponse && functionResponse.name === this.name) {
+            const response = functionResponse.response || {};
+            const names = response["resource_names"] || [];
+            for (const name of names) {
+              if (name && !requestedResourceNames.includes(name)) {
+                requestedResourceNames.push(name);
+              }
+            }
+          }
+        }
+      }
+    }
     for (const resourceName of requestedResourceNames) {
       try {
         const resourceContents = await this.mcpToolset.readResource(resourceName);

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

@@ -38,6 +38,7 @@ __export(mcp_session_manager_exports, {
   MCPSessionManager: () => MCPSessionManager
 });
 module.exports = __toCommonJS(mcp_session_manager_exports);
+var import_client_labels = require("../../utils/client_labels.js");
 var import_error_utils = require("../../utils/error_utils.js");
 var import_logger = require("../../utils/logger.js");
 var import_optional_peer = require("../../utils/optional_peer.js");
@@ -54,13 +55,24 @@ function logTransportError(err) {
   import_logger.logger.error("MCP transport error: " + (0, import_error_utils.formatError)(err));
 }
 __name(logTransportError, "logTransportError");
+function buildTransportOptions(params) {
+  const { transportOptions, header } = params;
+  const callerHeaders = (transportOptions == null ? void 0 : transportOptions.requestInit) === void 0 ? header : transportOptions.requestInit.headers;
+  return {
+    ...transportOptions,
+    requestInit: {
+      ...transportOptions == null ? void 0 : transportOptions.requestInit,
+      headers: (0, import_client_labels.mergeTrackingHeaders)(callerHeaders)
+    }
+  };
+}
+__name(buildTransportOptions, "buildTransportOptions");
 const _MCPSessionManager = class _MCPSessionManager {
   constructor(connectionParams) {
     this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
   async createSession() {
-    var _a;
     const { Client } = await (0, import_optional_peer.loadOptionalPeer)(
       MCP_SDK,
       () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/index.js"), 1))
@@ -81,19 +93,13 @@ const _MCPSessionManager = class _MCPSessionManager {
           break;
         }
         case "StreamableHTTPConnectionParams": {
-          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-          if (!options.requestInit && this.connectionParams.header !== void 0) {
-            options.requestInit = {
-              headers: this.connectionParams.header
-            };
-          }
           const { StreamableHTTPClientTransport } = await (0, import_optional_peer.loadOptionalPeer)(
             MCP_SDK,
             () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/streamableHttp.js"), 1))
           );
           const transport = new StreamableHTTPClientTransport(
             new URL(this.connectionParams.url),
-            options
+            buildTransportOptions(this.connectionParams)
           );
           transport.onerror = logTransportError;
           await client.connect(transport);