@google/adk 2.0.0 → 2.1.0

package/dist/cjs/telemetry/tracing.js

@@ -248,13 +248,23 @@ function traceSendData({
   );
 }
 __name(traceSendData, "traceSendData");
+function redactHttpOptions(httpOptions) {
+  const redacted = { ...httpOptions };
+  delete redacted.headers;
+  delete redacted.extraBody;
+  return redacted;
+}
+__name(redactHttpOptions, "redactHttpOptions");
 function buildLlmRequestForTrace(llmRequest) {
   const result = {
     model: llmRequest.model,
     contents: []
   };
   if (llmRequest.config) {
-    const { responseSchema, ...cleanConfig } = llmRequest.config;
+    const { responseSchema: _responseSchema, ...cleanConfig } = llmRequest.config;
+    if (cleanConfig.httpOptions) {
+      cleanConfig.httpOptions = redactHttpOptions(cleanConfig.httpOptions);
+    }
     result.config = cleanConfig;
   }
   result.contents = llmRequest.contents.map((content) => {

package/dist/cjs/tools/agent_tool.js

@@ -44,7 +44,7 @@ var import_forwarding_artifact_service = require("./forwarding_artifact_service.
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
-const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
+const AGENT_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.agentTool");
 function isAgentTool(obj) {
   return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
 }
@@ -67,8 +67,7 @@ const _AgentTool = class _AgentTool extends (_b = import_base_tool.BaseTool, _a
         name: this.name,
         description: this.description,
         // TODO(b/425992518): We should not use the agent's input schema as is.
-        // It should be validated and possibly transformed. Consider similar
-        // logic to one we have in Python ADK.
+        // It should be validated and possibly transformed first.
         parameters: this.agent.inputSchema
       };
     } else {
@@ -102,8 +101,8 @@ const _AgentTool = class _AgentTool extends (_b = import_base_tool.BaseTool, _a
       role: "user",
       parts: [
         {
-          // TODO(b/425992518): Should be validated. Consider similar
-          // logic to one we have in Python ADK.
+          // TODO(b/425992518): Args should be validated against the agent's
+          // input schema before being forwarded.
           text: hasInputSchema ? JSON.stringify(args) : args["request"]
         }
       ]

package/dist/cjs/tools/base_tool.js

@@ -26,7 +26,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var base_tool_exports = {};
 __export(base_tool_exports, {
   BaseTool: () => BaseTool,
-  isBaseTool: () => isBaseTool
+  IN_MODEL_TOOL_SYMBOL: () => IN_MODEL_TOOL_SYMBOL,
+  isBaseTool: () => isBaseTool,
+  isInModelTool: () => isInModelTool
 });
 module.exports = __toCommonJS(base_tool_exports);
 var import_variant_utils = require("../utils/variant_utils.js");
@@ -36,7 +38,12 @@ var import_variant_utils = require("../utils/variant_utils.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+const BASE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseTool");
+const IN_MODEL_TOOL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.inModelTool");
+function isInModelTool(tool) {
+  return typeof tool === "object" && tool !== null && tool[IN_MODEL_TOOL_SYMBOL] === true;
+}
+__name(isInModelTool, "isInModelTool");
 function isBaseTool(obj) {
   return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
 }
@@ -103,7 +110,8 @@ const _BaseTool = class _BaseTool {
     if (!functionDeclaration) {
       return;
     }
-    if (this.name in llmRequest.toolsDict) {
+    const registered = Object.hasOwn(llmRequest.toolsDict, this.name) ? llmRequest.toolsDict[this.name] : void 0;
+    if (registered && !isInModelTool(registered)) {
       throw new Error(`Duplicate tool name: ${this.name}`);
     }
     llmRequest.toolsDict[this.name] = this;
@@ -140,5 +148,7 @@ __name(findToolWithFunctionDeclarations, "findToolWithFunctionDeclarations");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseTool,
-  isBaseTool
+  IN_MODEL_TOOL_SYMBOL,
+  isBaseTool,
+  isInModelTool
 });

package/dist/cjs/tools/base_toolset.js

@@ -35,7 +35,7 @@ module.exports = __toCommonJS(base_toolset_exports);
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+const BASE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseToolset");
 function isBaseToolset(obj) {
   return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
 }
@@ -75,10 +75,10 @@ const _BaseToolset = class _BaseToolset {
    *   process the llm request. e.g. ComputerUseToolset can add computer use
    *   tool to the llm request.
    *
-   * @param toolContext The context of the tool.
-   * @param llmRequest The outgoing LLM request, mutable this method.
+   * @param _toolContext The context of the tool.
+   * @param _llmRequest The outgoing LLM request, mutable this method.
    */
-  async processLlmRequest(toolContext, llmRequest) {
+  async processLlmRequest(_toolContext, _llmRequest) {
   }
 };
 __name(_BaseToolset, "BaseToolset");

package/dist/cjs/tools/built_in_tool.js

@@ -0,0 +1,75 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 built_in_tool_exports = {};
+__export(built_in_tool_exports, {
+  BuiltInTool: () => BuiltInTool
+});
+module.exports = __toCommonJS(built_in_tool_exports);
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const _BuiltInTool = class _BuiltInTool extends (_b = import_base_tool.BaseTool, _a = import_base_tool.IN_MODEL_TOOL_SYMBOL, _b) {
+  constructor() {
+    super(...arguments);
+    /** Marks this tool as one the model runs itself. */
+    this[_a] = true;
+  }
+  async processLlmRequest(request) {
+    if (this._getDeclaration()) {
+      throw new Error(
+        `${this.name} extends BuiltInTool but returns a function declaration. A tool the model runs itself cannot declare a callable function; extend BaseTool instead.`
+      );
+    }
+    await this.applyBuiltInConfig(request);
+    if (!Object.hasOwn(request.llmRequest.toolsDict, this.name)) {
+      request.llmRequest.toolsDict[this.name] = this;
+    }
+  }
+  /**
+   * Answers a function call the model should not have made. The tool is
+   * already configured on the request and its results arrive as grounding
+   * metadata, so the model is told to use those rather than call again.
+   */
+  async runAsync() {
+    import_logger.logger.warn(
+      `${this.name} runs inside the model but was called as a function; answering with guidance instead of executing anything.`
+    );
+    return {
+      error: `${this.name} runs inside the model and cannot be called as a function. It is already enabled on this request and its results arrive as grounding metadata; answer from those instead of calling it.`
+    };
+  }
+};
+__name(_BuiltInTool, "BuiltInTool");
+let BuiltInTool = _BuiltInTool;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuiltInTool
+});

package/dist/cjs/tools/enterprise_web_search_tool.js

@@ -31,7 +31,7 @@ __export(enterprise_web_search_tool_exports, {
 });
 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");
+var import_built_in_tool = require("./built_in_tool.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -58,17 +58,14 @@ function applyEnterpriseWebSearch(llmRequest) {
   );
 }
 __name(applyEnterpriseWebSearch, "applyEnterpriseWebSearch");
-const _EnterpriseWebSearchTool = class _EnterpriseWebSearchTool extends import_base_tool.BaseTool {
+const _EnterpriseWebSearchTool = class _EnterpriseWebSearchTool extends import_built_in_tool.BuiltInTool {
   constructor() {
     super({
       name: "enterprise_web_search",
       description: "Enterprise Web Search Tool"
     });
   }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
+  async applyBuiltInConfig({
     llmRequest
   }) {
     applyEnterpriseWebSearch(llmRequest);

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)