@google/adk 2.0.0 → 2.2.0

package/dist/esm/tools/google_maps_grounding_tool.js

@@ -12,7 +12,7 @@ import {
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
+import { BuiltInTool } from "./built_in_tool.js";
 function applyGoogleMapsGrounding(llmRequest) {
   if (!llmRequest.model) {
     return;
@@ -36,14 +36,11 @@ function applyGoogleMapsGrounding(llmRequest) {
   );
 }
 __name(applyGoogleMapsGrounding, "applyGoogleMapsGrounding");
-const _GoogleMapsGroundingTool = class _GoogleMapsGroundingTool extends BaseTool {
+const _GoogleMapsGroundingTool = class _GoogleMapsGroundingTool extends BuiltInTool {
   constructor() {
     super({ name: "google_maps", description: "Google Maps Grounding Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     applyGoogleMapsGrounding(llmRequest);

package/dist/esm/tools/google_search_tool.js

@@ -8,15 +8,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { isGemini1Model, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-const _GoogleSearchTool = class _GoogleSearchTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _GoogleSearchTool = class _GoogleSearchTool extends BuiltInTool {
   constructor() {
     super({ name: "google_search", description: "Google Search Tool" });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     if (!llmRequest.model) {

package/dist/esm/tools/load_artifacts_tool.js

@@ -9,11 +9,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { Type } from "@google/genai";
 import { appendInstructions } from "../models/llm_request.js";
-import { getLogger } from "../utils/logger.js";
+import { logger } from "../utils/logger.js";
 import {
   BaseTool
 } from "./base_tool.js";
-const 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([
@@ -110,6 +109,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;
     }
@@ -130,33 +130,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) {
+        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/esm/tools/load_web_page.js

@@ -7,186 +7,26 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * 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 {
+  isHttpUrl,
+  isLocalhostHostname,
+  isNonGlobalAddress,
+  normalizeHost,
+  resolveHostAddresses
+} from "../utils/ssrf_guard.js";
 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}`;
 }
 __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 (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 (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;
-}
-__name(resolveHostAddresses, "resolveHostAddresses");
 function assertUrlAllowed(url) {
   const parsed = new URL(url);
-  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+  if (!isHttpUrl(parsed)) {
     throw new Error(`Unsupported url scheme: ${url}`);
   }
-  if (isBlockedHostname(parsed.hostname)) {
+  if (isLocalhostHostname(parsed.hostname)) {
     throw new Error(`Blocked host: ${parsed.hostname}`);
   }
   return parsed;
@@ -194,7 +34,7 @@ function assertUrlAllowed(url) {
 __name(assertUrlAllowed, "assertUrlAllowed");
 async function validateResolvedAddresses(hostname) {
   const addresses = await resolveHostAddresses(hostname);
-  if (addresses.some(isBlockedAddress)) {
+  if (addresses.some(isNonGlobalAddress)) {
     throw new Error(`Blocked host: ${hostname}`);
   }
 }

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

@@ -71,13 +71,42 @@ before answering questions related to the resources.`
     } catch (e) {
       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/esm/tools/mcp/mcp_session_manager.js

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { mergeTrackingHeaders } from "../../utils/client_labels.js";
 import { formatError } from "../../utils/error_utils.js";
 import { logger } from "../../utils/logger.js";
 import { loadOptionalPeer } from "../../utils/optional_peer.js";
@@ -39,13 +40,24 @@ function logTransportError(err) {
   logger.error("MCP transport error: " + 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: 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 loadOptionalPeer(
       MCP_SDK,
       () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/index.js"), 1))
@@ -66,19 +78,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 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);