@google/adk 2.0.0 → 2.1.0

package/dist/esm/tools/vertex_rag_retrieval_tool.js

@@ -7,8 +7,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { BaseTool } from "./base_tool.js";
-const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BaseTool {
+import { BuiltInTool } from "./built_in_tool.js";
+const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BuiltInTool {
   constructor(config) {
     super({
       name: "vertex_rag_retrieval",
@@ -16,14 +16,7 @@ const _VertexRagRetrievalTool = class _VertexRagRetrievalTool extends BaseTool {
     });
     this.vertexRagStore = config;
   }
-  /**
-   * This tool is executed server-side by the Vertex AI RAG Engine.
-   * Local execution is not required.
-   */
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     llmRequest.config = llmRequest.config || {};

package/dist/esm/utils/crypto_shim.js

@@ -13,6 +13,20 @@ function randomUUID() {
   );
 }
 __name(randomUUID, "randomUUID");
+function createHash(_algorithm) {
+  throw new Error(
+    "createHash: PKCE code challenges require a synchronous SHA-256, which the Web Crypto API does not provide (crypto.subtle.digest is async)."
+  );
+}
+__name(createHash, "createHash");
+function randomBytes(_size) {
+  throw new Error(
+    "randomBytes: no cryptographically secure source of randomness is available in this environment."
+  );
+}
+__name(randomBytes, "randomBytes");
 export {
+  createHash,
+  randomBytes,
   randomUUID
 };

package/dist/esm/utils/gemini_schema_util.js

@@ -8,12 +8,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Type } from "@google/genai";
-import { z } from "zod";
-const MCPToolSchemaObject = z.object({
-  type: z.literal("object"),
-  properties: z.record(z.string(), z.unknown()).optional(),
-  required: z.string().array().optional()
-});
 function toGeminiType(mcpType) {
   if (!mcpType) return Type.TYPE_UNSPECIFIED;
   switch (mcpType.toLowerCase()) {

package/dist/esm/utils/logger.js

@@ -7,7 +7,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as winston from "winston";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -15,31 +14,15 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
+const CONSOLE_METHOD = {
+  [0 /* DEBUG */]: "debug",
+  [1 /* INFO */]: "info",
+  [2 /* WARN */]: "warn",
+  [3 /* ERROR */]: "error"
+};
 const _SimpleLogger = class _SimpleLogger {
   constructor() {
     this.logLevel = 1 /* INFO */;
-    this.logger = winston.createLogger({
-      levels: {
-        "debug": 0 /* DEBUG */,
-        "info": 1 /* INFO */,
-        "warn": 2 /* WARN */,
-        "error": 3 /* ERROR */
-      },
-      level: "error",
-      format: winston.format.combine(
-        winston.format.label({ label: "ADK" }),
-        winston.format((info) => {
-          info.level = info.level.toUpperCase();
-          return info;
-        })(),
-        winston.format.colorize(),
-        winston.format.timestamp(),
-        winston.format.printf((info) => {
-          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
-        })
-      ),
-      transports: [new winston.transports.Console()]
-    });
   }
   setLogLevel(level) {
     this.logLevel = level;
@@ -48,31 +31,21 @@ const _SimpleLogger = class _SimpleLogger {
     if (this.logLevel > level) {
       return;
     }
-    this.logger.log(level.toString(), messages.join(" "));
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `${LogLevel[level]}: [ADK] ${timestamp} ${messages.join(" ")}`;
+    console[CONSOLE_METHOD[level]](line);
   }
   debug(...messages) {
-    if (this.logLevel > 0 /* DEBUG */) {
-      return;
-    }
-    this.logger.debug(messages.join(" "));
+    this.log(0 /* DEBUG */, ...messages);
   }
   info(...messages) {
-    if (this.logLevel > 1 /* INFO */) {
-      return;
-    }
-    this.logger.info(messages.join(" "));
+    this.log(1 /* INFO */, ...messages);
   }
   warn(...messages) {
-    if (this.logLevel > 2 /* WARN */) {
-      return;
-    }
-    this.logger.warn(messages.join(" "));
+    this.log(2 /* WARN */, ...messages);
   }
   error(...messages) {
-    if (this.logLevel > 3 /* ERROR */) {
-      return;
-    }
-    this.logger.error(messages.join(" "));
+    this.log(3 /* ERROR */, ...messages);
   }
 };
 __name(_SimpleLogger, "SimpleLogger");
@@ -131,6 +104,7 @@ const logger = {
   }
 };
 export {
+  CONSOLE_METHOD,
   LogLevel,
   getLogger,
   logger,

package/dist/esm/utils/logger_browser.js

@@ -0,0 +1,58 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CONSOLE_METHOD, LogLevel, setLogger } from "./logger.js";
+const LEVEL_COLOR = {
+  [LogLevel.DEBUG]: "blue",
+  [LogLevel.INFO]: "green",
+  [LogLevel.WARN]: "orange",
+  [LogLevel.ERROR]: "red"
+};
+const _BrowserLogger = class _BrowserLogger {
+  constructor() {
+    this.logLevel = LogLevel.INFO;
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const rest = `: [ADK] ${timestamp} ${messages.join(" ")}`;
+    console[CONSOLE_METHOD[level]](
+      `%c${LogLevel[level]}%c${rest}`,
+      `color: ${LEVEL_COLOR[level]}`,
+      "color: inherit"
+    );
+  }
+  debug(...messages) {
+    this.log(LogLevel.DEBUG, ...messages);
+  }
+  info(...messages) {
+    this.log(LogLevel.INFO, ...messages);
+  }
+  warn(...messages) {
+    this.log(LogLevel.WARN, ...messages);
+  }
+  error(...messages) {
+    this.log(LogLevel.ERROR, ...messages);
+  }
+};
+__name(_BrowserLogger, "BrowserLogger");
+let BrowserLogger = _BrowserLogger;
+function installBrowserLogger() {
+  setLogger(new BrowserLogger());
+}
+__name(installBrowserLogger, "installBrowserLogger");
+export {
+  BrowserLogger,
+  installBrowserLogger
+};

package/dist/esm/utils/logger_node.js

@@ -0,0 +1,81 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as winston from "winston";
+import { LogLevel, setLogger } from "./logger.js";
+const _WinstonLogger = class _WinstonLogger {
+  constructor() {
+    this.logLevel = LogLevel.INFO;
+    this.logger = winston.createLogger({
+      levels: {
+        "debug": LogLevel.DEBUG,
+        "info": LogLevel.INFO,
+        "warn": LogLevel.WARN,
+        "error": LogLevel.ERROR
+      },
+      level: "error",
+      format: winston.format.combine(
+        winston.format.label({ label: "ADK" }),
+        winston.format((info) => {
+          info.level = info.level.toUpperCase();
+          return info;
+        })(),
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          return `${info.level}: [${info.label}] ${info.timestamp} ${info.message}`;
+        })
+      ),
+      transports: [new winston.transports.Console()]
+    });
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  log(level, ...messages) {
+    if (this.logLevel > level) {
+      return;
+    }
+    this.logger.log(level.toString(), messages.join(" "));
+  }
+  debug(...messages) {
+    if (this.logLevel > LogLevel.DEBUG) {
+      return;
+    }
+    this.logger.debug(messages.join(" "));
+  }
+  info(...messages) {
+    if (this.logLevel > LogLevel.INFO) {
+      return;
+    }
+    this.logger.info(messages.join(" "));
+  }
+  warn(...messages) {
+    if (this.logLevel > LogLevel.WARN) {
+      return;
+    }
+    this.logger.warn(messages.join(" "));
+  }
+  error(...messages) {
+    if (this.logLevel > LogLevel.ERROR) {
+      return;
+    }
+    this.logger.error(messages.join(" "));
+  }
+};
+__name(_WinstonLogger, "WinstonLogger");
+let WinstonLogger = _WinstonLogger;
+function installNodeLogger() {
+  setLogger(new WinstonLogger());
+}
+__name(installNodeLogger, "installNodeLogger");
+export {
+  WinstonLogger,
+  installNodeLogger
+};

package/dist/esm/utils/redact_inline_data.js

@@ -0,0 +1,19 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function stringifyWithRedactedInlineData(value) {
+  return JSON.stringify(
+    value,
+    (key, val) => key === "inlineData" && typeof val === "object" && val !== null && "data" in val && typeof val.data === "string" ? { ...val, data: `<redacted ${val.data.length} chars>` } : val
+  );
+}
+__name(stringifyWithRedactedInlineData, "stringifyWithRedactedInlineData");
+export {
+  stringifyWithRedactedInlineData
+};

package/dist/esm/utils/redact_uri.js

@@ -11,7 +11,21 @@ const SECRET_QUERY_PARAMS = /* @__PURE__ */ new Set([
   "password",
   "passwd",
   "pwd",
-  "sslpassword"
+  "sslpassword",
+  // OAuth2 callback/authorization-response URIs carry their own secrets as
+  // query parameters rather than in userinfo: an authorization `code` is a
+  // single-use, bearer-equivalent credential, and a token response echoed
+  // back via URI can carry `access_token`/`id_token`/`refresh_token`.
+  // Only the query string is scanned: in the implicit and hybrid flows those
+  // token parameters arrive in the fragment, which is left untouched.
+  // `client_secret` is not meant to travel in a URL at all, but is included
+  // here in case a misconfigured flow puts it there anyway.
+  "code",
+  "access_token",
+  "id_token",
+  "refresh_token",
+  "client_secret",
+  "code_verifier"
 ]);
 function redactUriPassword(uri) {
   try {

package/dist/esm/utils/schema.js

@@ -89,7 +89,7 @@ function objectSchemaFields(schema) {
   return fields != null ? fields : void 0;
 }
 __name(objectSchemaFields, "objectSchemaFields");
-const UNRESOLVABLE_REF = Symbol("unresolvable-ref");
+const UNRESOLVABLE_REF = /* @__PURE__ */ Symbol("unresolvable-ref");
 function compileField(fieldSchema, document) {
   try {
     return compileJsonSchema(inlineRefs(fieldSchema, document));

package/dist/{web/tools/load_web_page.js → esm/utils/ssrf_guard.js}

@@ -9,11 +9,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 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 = [
+const HTTP_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+const NON_GLOBAL_IPV4_CIDRS = [
   "0.0.0.0/8",
   // "this host on this network"
   "10.0.0.0/8",
@@ -45,7 +42,7 @@ const BLOCKED_IPV4_CIDRS = [
   "240.0.0.0/4"
   // reserved / future use (includes 255.255.255.255)
 ].map(parseIpv4Cidr);
-const BLOCKED_IPV6_CIDRS = [
+const NON_GLOBAL_IPV6_CIDRS = [
   "::/128",
   // unspecified
   "::1/128",
@@ -63,19 +60,57 @@ const BLOCKED_IPV6_CIDRS = [
   "ff00::/8"
   // multicast
 ].map(parseIpv6Cidr);
-function failedToFetchMessage(url) {
-  return "Failed to fetch url: ".concat(url);
-}
-__name(failedToFetchMessage, "failedToFetchMessage");
-function isBlockedHostname(hostname) {
+const LINK_LOCAL_IPV4_CIDR = parseIpv4Cidr("169.254.0.0/16");
+const LINK_LOCAL_IPV6_CIDR = parseIpv6Cidr("fe80::/10");
+const IPV4_MAPPED_CIDR = parseIpv6Cidr("::ffff:0:0/96");
+const NAT64_CIDR = parseIpv6Cidr("64:ff9b::/96");
+const SIX_TO_FOUR_CIDR = parseIpv6Cidr("2002::/16");
+const IPV4_COMPATIBLE_CIDR = parseIpv6Cidr("::/96");
+function isHttpUrl(url) {
+  return HTTP_SCHEMES.has(url.protocol);
+}
+__name(isHttpUrl, "isHttpUrl");
+function isLocalhostHostname(hostname) {
   const normalized = hostname.replace(/\.+$/, "").toLowerCase();
   return normalized === "localhost" || normalized.endsWith(".localhost");
 }
-__name(isBlockedHostname, "isBlockedHostname");
+__name(isLocalhostHostname, "isLocalhostHostname");
 function normalizeHost(hostname) {
   return hostname.startsWith("[") ? hostname.slice(1, -1) : hostname;
 }
 __name(normalizeHost, "normalizeHost");
+function isNonGlobalAddress(address) {
+  return classifyAddress(address, isNonGlobalIpv4, isNonGlobalIpv6);
+}
+__name(isNonGlobalAddress, "isNonGlobalAddress");
+function isLinkLocalAddress(address) {
+  return classifyAddress(address, isLinkLocalIpv4, isLinkLocalIpv6);
+}
+__name(isLinkLocalAddress, "isLinkLocalAddress");
+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 classifyAddress(address, matchesIpv4, matchesIpv6) {
+  const octets = parseIpv4(address);
+  if (octets) {
+    return matchesIpv4(octets);
+  }
+  const hextets = parseIpv6(address);
+  if (hextets) {
+    return matchesIpv6(hextets);
+  }
+  return true;
+}
+__name(classifyAddress, "classifyAddress");
 function parseIpv4(address) {
   const match = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
   if (!match) {
@@ -117,9 +152,9 @@ function ipv4ToInt(octets) {
 }
 __name(ipv4ToInt, "ipv4ToInt");
 function hextetsToBigInt(hextets) {
-  let value = /* @__PURE__ */ BigInt("0");
+  let value = 0n;
   for (const hextet of hextets) {
-    value = value << /* @__PURE__ */ BigInt("16") | BigInt(hextet);
+    value = value << 16n | BigInt(hextet);
   }
   return value;
 }
@@ -135,108 +170,61 @@ function parseIpv6Cidr(cidr) {
   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 >> /* @__PURE__ */ BigInt("32") === /* @__PURE__ */ BigInt("0xffff")) {
-    return isBlockedIpv4([
-      Number(value >> /* @__PURE__ */ BigInt("24") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value >> /* @__PURE__ */ BigInt("16") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value >> /* @__PURE__ */ BigInt("8") & /* @__PURE__ */ BigInt("0xff")),
-      Number(value & /* @__PURE__ */ BigInt("0xff"))
-    ]);
+function matchesIpv4Cidr(octets, { base, mask }) {
+  return (ipv4ToInt(octets) & mask) >>> 0 === base;
+}
+__name(matchesIpv4Cidr, "matchesIpv4Cidr");
+function matchesIpv6Cidr(hextets, { base, prefix }) {
+  const shift = BigInt(128 - prefix);
+  return hextetsToBigInt(hextets) >> shift === base >> shift;
+}
+__name(matchesIpv6Cidr, "matchesIpv6Cidr");
+function embeddedIpv4(hextets) {
+  if (matchesIpv6Cidr(hextets, SIX_TO_FOUR_CIDR)) {
+    return hextetsToOctets(hextets[1], hextets[2]);
   }
-  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);
+  if (matchesIpv6Cidr(hextets, IPV4_MAPPED_CIDR) || matchesIpv6Cidr(hextets, NAT64_CIDR)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
   }
-  const hextets = parseIpv6(address);
-  if (hextets) {
-    return isBlockedIpv6(hextets);
+  if (matchesIpv6Cidr(hextets, IPV4_COMPATIBLE_CIDR) && (hextets[6] !== 0 || hextets[7] > 1)) {
+    return hextetsToOctets(hextets[6], hextets[7]);
   }
-  return true;
+  return null;
 }
-__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: ".concat(hostname));
-  }
-  return addresses;
+__name(embeddedIpv4, "embeddedIpv4");
+function hextetsToOctets(high, low) {
+  return [high >> 8, high & 255, low >> 8, low & 255];
 }
-__name(resolveHostAddresses, "resolveHostAddresses");
-function assertUrlAllowed(url) {
-  const parsed = new URL(url);
-  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
-    throw new Error("Unsupported url scheme: ".concat(url));
-  }
-  if (isBlockedHostname(parsed.hostname)) {
-    throw new Error("Blocked host: ".concat(parsed.hostname));
-  }
-  return parsed;
+__name(hextetsToOctets, "hextetsToOctets");
+function isNonGlobalIpv4(octets) {
+  return NON_GLOBAL_IPV4_CIDRS.some((cidr) => matchesIpv4Cidr(octets, cidr));
 }
-__name(assertUrlAllowed, "assertUrlAllowed");
-async function validateResolvedAddresses(hostname) {
-  const addresses = await resolveHostAddresses(hostname);
-  if (addresses.some(isBlockedAddress)) {
-    throw new Error("Blocked host: ".concat(hostname));
+__name(isNonGlobalIpv4, "isNonGlobalIpv4");
+function isNonGlobalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isNonGlobalIpv4(embedded);
   }
+  return NON_GLOBAL_IPV6_CIDRS.some((cidr) => matchesIpv6Cidr(hextets, cidr));
 }
-__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;
-  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 (e) {
-    return failedToFetchMessage(url);
+__name(isNonGlobalIpv6, "isNonGlobalIpv6");
+function isLinkLocalIpv4(octets) {
+  return matchesIpv4Cidr(octets, LINK_LOCAL_IPV4_CIDR);
+}
+__name(isLinkLocalIpv4, "isLinkLocalIpv4");
+function isLinkLocalIpv6(hextets) {
+  const embedded = embeddedIpv4(hextets);
+  if (embedded) {
+    return isLinkLocalIpv4(embedded);
   }
+  return matchesIpv6Cidr(hextets, LINK_LOCAL_IPV6_CIDR);
 }
-__name(loadWebPage, "loadWebPage");
-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: /* @__PURE__ */ __name(({ url }) => loadWebPage(url), "execute")
-});
+__name(isLinkLocalIpv6, "isLinkLocalIpv6");
 export {
-  LOAD_WEB_PAGE,
-  loadWebPage
+  isHttpUrl,
+  isLinkLocalAddress,
+  isLocalhostHostname,
+  isNonGlobalAddress,
+  normalizeHost,
+  resolveHostAddresses
 };

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.0.0";
+const version = "2.1.0";
 export {
   version
 };

package/dist/esm/workflow/base_node.js

@@ -17,7 +17,7 @@ import {
   prepareRetryConfig
 } from "./retry_config.js";
 import { createRequestInputEvent } from "./utils/hitl_utils.js";
-const BASE_NODE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.baseNode");
+const BASE_NODE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.baseNode");
 _a = BASE_NODE_SIGNATURE_SYMBOL;
 const _BaseNode = class _BaseNode {
   constructor(config) {

package/dist/esm/workflow/graph.js

@@ -11,7 +11,7 @@ var _a;
 import { logger } from "../utils/logger.js";
 import { parseEdgeItems } from "./utils/graph_parser.js";
 import { validateGraph } from "./utils/graph_validation.js";
-const EDGE_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.edge");
+const EDGE_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.edge");
 const DEFAULT_ROUTE = "__DEFAULT__";
 _a = EDGE_SIGNATURE_SYMBOL;
 const _Edge = class _Edge {

package/dist/esm/workflow/nodes/node_tool.js

@@ -16,7 +16,7 @@ import {
 } from "../../utils/simple_zod_to_json.js";
 import { NodeContext } from "../node_context.js";
 import { executeChildNode } from "../node_runner.js";
-const NODE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.workflow.nodeTool");
+const NODE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.workflow.nodeTool");
 const MAX_NODE_TOOL_DEPTH = 8;
 const _NodeTool = class _NodeTool extends (_b = BaseTool, _a = NODE_TOOL_SIGNATURE_SYMBOL, _b) {
   constructor(node, name, description) {
@@ -97,7 +97,7 @@ const _NodeTool = class _NodeTool extends (_b = BaseTool, _a = NODE_TOOL_SIGNATU
       // not the node name doubled.
       nodePath: "",
       runId,
-      resumeInputs: collectResumeInputs(toolContext)
+      resumeInputs: toolContext.resumeInputs
     });
     const base = childIc.branch;
     const segment = `${this.name}@${runId}`;
@@ -116,15 +116,6 @@ function isNodeTool(value) {
   return typeof value === "object" && value !== null && NODE_TOOL_SIGNATURE_SYMBOL in value && value[NODE_TOOL_SIGNATURE_SYMBOL] === true;
 }
 __name(isNodeTool, "isNodeTool");
-function collectResumeInputs(toolContext) {
-  var _a2;
-  const payload = (_a2 = toolContext.toolConfirmation) == null ? void 0 : _a2.payload;
-  if (payload && typeof payload === "object") {
-    return payload;
-  }
-  return {};
-}
-__name(collectResumeInputs, "collectResumeInputs");
 export {
   NodeTool,
   isNodeTool