@easynet/agent-tool-buildin 0.0.3 → 0.0.4

package/dist/index.js

@@ -103,62 +103,19 @@ var DEFAULT_CORE_TOOLS_CONFIG = {
 
 // fs/readText.ts
 import { readFile, stat } from "fs/promises";
-
-// security/sandbox.ts
-import { resolve, normalize, dirname, basename } from "path";
-import { realpath, access } from "fs/promises";
+import { resolveSandboxedPath } from "@easynet/agent-tool";
 import { createTaggedError } from "@easynet/agent-tool";
-async function resolveSandboxedPath(inputPath, sandboxRoot) {
-  let normalizedRoot;
-  try {
-    normalizedRoot = await realpath(resolve(sandboxRoot));
-  } catch {
-    normalizedRoot = normalize(resolve(sandboxRoot));
-  }
-  const resolved = resolve(normalizedRoot, inputPath);
-  let real;
-  try {
-    await access(resolved);
-    real = await realpath(resolved);
-  } catch {
-    const parentDir = dirname(resolved);
-    let realParent;
-    try {
-      await access(parentDir);
-      realParent = await realpath(parentDir);
-    } catch {
-      realParent = normalize(parentDir);
-    }
-    real = resolve(realParent, basename(resolved));
-  }
-  if (!isWithinRoot(real, normalizedRoot)) {
-    throw createTaggedError(
-      "PATH_OUTSIDE_SANDBOX",
-      `Path "${inputPath}" resolves to "${real}" which is outside sandbox "${normalizedRoot}"`,
-      { inputPath, resolvedPath: real, sandboxRoot: normalizedRoot }
-    );
-  }
-  return real;
-}
-function isWithinRoot(path, root) {
-  const normalizedPath = normalize(path);
-  const normalizedRoot = normalize(root);
-  return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
-}
-
-// fs/readText.ts
-import { createTaggedError as createTaggedError2 } from "@easynet/agent-tool";
 var readTextHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const inputPath = (args.path ?? args.filePath)?.trim();
   if (!inputPath) {
-    throw createTaggedError2("FS_INVALID", "path is required (pass 'path' or 'filePath')", {});
+    throw createTaggedError("FS_INVALID", "path is required (pass 'path' or 'filePath')", {});
   }
   const maxBytes = args.maxBytes ?? ctx.config.maxReadBytes;
   const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
   const fileStat = await stat(resolvedPath);
   if (fileStat.size > maxBytes) {
-    throw createTaggedError2(
+    throw createTaggedError(
       "FILE_TOO_LARGE",
       `File size ${fileStat.size} bytes exceeds limit of ${maxBytes} bytes`,
       { path: resolvedPath, size: fileStat.size, limit: maxBytes }
@@ -185,7 +142,8 @@ var readTextHandler = (async (args) => {
 // fs/writeText.ts
 import { writeFile, mkdir } from "fs/promises";
 import { createHash } from "crypto";
-import { dirname as dirname2 } from "path";
+import { dirname } from "path";
+import { resolveSandboxedPath as resolveSandboxedPath2 } from "@easynet/agent-tool";
 var writeTextHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const inputPath = (args.path ?? args.filePath)?.trim();
@@ -195,11 +153,11 @@ var writeTextHandler = (async (args) => {
   const text = args.text ?? args.content ?? "";
   const overwrite = args.overwrite ?? false;
   const mkdirp = args.mkdirp ?? true;
-  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const resolvedPath = await resolveSandboxedPath2(inputPath, ctx.config.sandboxRoot);
   if (!overwrite) {
-    const { access: access2 } = await import("fs/promises");
+    const { access } = await import("fs/promises");
     try {
-      await access2(resolvedPath);
+      await access(resolvedPath);
       throw new Error(
         `File already exists: ${resolvedPath}. Set overwrite=true to allow overwriting.`
       );
@@ -211,7 +169,7 @@ var writeTextHandler = (async (args) => {
     }
   }
   if (mkdirp) {
-    await mkdir(dirname2(resolvedPath), { recursive: true });
+    await mkdir(dirname(resolvedPath), { recursive: true });
   }
   await writeFile(resolvedPath, text, "utf-8");
   const bytes = Buffer.byteLength(text, "utf-8");
@@ -235,7 +193,8 @@ var writeTextHandler = (async (args) => {
 
 // fs/listDir.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import { resolve as resolve2, join } from "path";
+import { resolve, join } from "path";
+import { resolveSandboxedPath as resolveSandboxedPath3 } from "@easynet/agent-tool";
 var listDirHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const inputPath = (args.path ?? args.filePath ?? args.dir ?? args.directory)?.trim();
@@ -246,7 +205,7 @@ var listDirHandler = (async (args) => {
   const includeHidden = args.includeHidden ?? false;
   const recursive = args.recursive ?? false;
   const maxDepth = args.maxDepth ?? 5;
-  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const resolvedPath = await resolveSandboxedPath3(inputPath, ctx.config.sandboxRoot);
   const entries = [];
   let truncated = false;
   await walkDir(resolvedPath, "", entries, {
@@ -281,7 +240,7 @@ async function walkDir(basePath, relativePath, entries, options) {
     options.onTruncate();
     return;
   }
-  const fullPath = relativePath ? resolve2(basePath, relativePath) : basePath;
+  const fullPath = relativePath ? resolve(basePath, relativePath) : basePath;
   const dirEntries = await readdir(fullPath, { withFileTypes: true });
   for (const dirent of dirEntries) {
     if (entries.length >= options.maxEntries) {
@@ -331,6 +290,7 @@ import { readdir as readdir2, stat as stat3 } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
 import { join as join2, relative } from "path";
+import { resolveSandboxedPath as resolveSandboxedPath4 } from "@easynet/agent-tool";
 var searchTextHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const rootPath = (args.root ?? args.path ?? args.dir ?? args.directory)?.trim();
@@ -344,7 +304,7 @@ var searchTextHandler = (async (args) => {
   const glob = args.glob ?? "**/*.{md,txt,log,json,ts,js,py,java,scala}";
   const maxMatches = args.maxMatches ?? 100;
   const maxFiles = args.maxFiles ?? 500;
-  const resolvedRoot = await resolveSandboxedPath(rootPath, ctx.config.sandboxRoot);
+  const resolvedRoot = await resolveSandboxedPath4(rootPath, ctx.config.sandboxRoot);
   let regex;
   try {
     regex = new RegExp(query, "i");
@@ -459,20 +419,21 @@ function escapeRegExp(str) {
 import { createReadStream as createReadStream2 } from "fs";
 import { stat as stat4 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import { createTaggedError as createTaggedError3 } from "@easynet/agent-tool";
+import { resolveSandboxedPath as resolveSandboxedPath5 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError2 } from "@easynet/agent-tool";
 var sha256Handler = (async (args) => {
   const ctx = getBuiltinContext();
   const inputPath = (args.path ?? args.filePath)?.trim();
   if (!inputPath) {
-    throw createTaggedError3("FS_INVALID", "path is required (pass 'path' or 'filePath')", {});
+    throw createTaggedError2("FS_INVALID", "path is required (pass 'path' or 'filePath')", {});
   }
-  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const resolvedPath = await resolveSandboxedPath5(inputPath, ctx.config.sandboxRoot);
   const fileStat = await stat4(resolvedPath);
-  const hash = await new Promise((resolve3, reject) => {
+  const hash = await new Promise((resolve2, reject) => {
     const hasher = createHash2("sha256");
     const stream = createReadStream2(resolvedPath);
     stream.on("data", (chunk) => hasher.update(chunk));
-    stream.on("end", () => resolve3(hasher.digest("hex")));
+    stream.on("end", () => resolve2(hasher.digest("hex")));
     stream.on("error", reject);
   });
   return {
@@ -494,6 +455,7 @@ var sha256Handler = (async (args) => {
 
 // fs/deletePath.ts
 import { rm, unlink, rmdir, stat as stat5 } from "fs/promises";
+import { resolveSandboxedPath as resolveSandboxedPath6 } from "@easynet/agent-tool";
 var deletePathHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const inputPath = (args.path ?? args.filePath)?.trim();
@@ -507,7 +469,7 @@ var deletePathHandler = (async (args) => {
       "Deletion not confirmed. Set confirm=true to proceed with deletion."
     );
   }
-  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const resolvedPath = await resolveSandboxedPath6(inputPath, ctx.config.sandboxRoot);
   let realSandboxRoot;
   try {
     const { realpath: rp } = await import("fs/promises");
@@ -546,175 +508,25 @@ var deletePathHandler = (async (args) => {
   };
 });
 
-// security/ssrf.ts
-import { lookup } from "dns/promises";
-import { createTaggedError as createTaggedError4 } from "@easynet/agent-tool";
-async function validateUrl(url, allowedHosts, blockedCidrs) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw createTaggedError4(
-      "HTTP_DISALLOWED_HOST",
-      `Invalid URL: ${url}`,
-      { url }
-    );
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw createTaggedError4(
-      "HTTP_DISALLOWED_HOST",
-      `Protocol not allowed: ${parsed.protocol}. Only http: and https: are supported.`,
-      { url, protocol: parsed.protocol }
-    );
-  }
-  const hostname = parsed.hostname;
-  if (!isHostAllowed(hostname, allowedHosts)) {
-    throw createTaggedError4(
-      "HTTP_DISALLOWED_HOST",
-      `Host "${hostname}" is not in the allowed hosts list`,
-      { url, hostname, allowedHosts }
-    );
-  }
-  try {
-    const { address } = await lookup(hostname);
-    if (isIpInBlockedCidrs(address, blockedCidrs)) {
-      throw createTaggedError4(
-        "HTTP_DISALLOWED_HOST",
-        `Host "${hostname}" resolves to blocked IP: ${address}`,
-        { url, hostname, resolvedIp: address }
-      );
-    }
-  } catch (err) {
-    if (err instanceof Error && err.kind === "HTTP_DISALLOWED_HOST") {
-      throw err;
-    }
-    throw createTaggedError4(
-      "HTTP_DISALLOWED_HOST",
-      `DNS resolution failed for host "${hostname}": ${err instanceof Error ? err.message : String(err)}`,
-      { url, hostname }
-    );
-  }
-  return parsed;
-}
-function isHostAllowed(hostname, allowedHosts) {
-  for (const pattern of allowedHosts) {
-    if (pattern === "*") {
-      return true;
-    }
-    if (pattern.startsWith("*.")) {
-      const suffix = pattern.slice(1);
-      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
-        return true;
-      }
-    } else if (hostname === pattern) {
-      return true;
-    }
-  }
-  return false;
-}
-function isIpInBlockedCidrs(ip, cidrs) {
-  const normalizedIp = normalizeIp(ip);
-  if (!normalizedIp) return false;
-  for (const cidr of cidrs) {
-    if (cidr.includes(":")) {
-      if (!ip.includes(":")) continue;
-      if (isIpv6InCidr(ip, cidr)) return true;
-    } else {
-      if (isIpv4InCidr(normalizedIp, cidr)) return true;
-    }
-  }
-  return false;
-}
-function normalizeIp(ip) {
-  if (ip.startsWith("::ffff:")) {
-    return ip.slice(7);
-  }
-  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
-    return ip;
-  }
-  return null;
-}
-function isIpv4InCidr(ip, cidr) {
-  const [cidrIp, prefixStr] = cidr.split("/");
-  if (!cidrIp || !prefixStr) return false;
-  const prefix = parseInt(prefixStr, 10);
-  if (isNaN(prefix) || prefix < 0 || prefix > 32) return false;
-  const ipNum = ipv4ToNum(ip);
-  const cidrNum = ipv4ToNum(cidrIp);
-  if (ipNum === null || cidrNum === null) return false;
-  const mask = prefix === 0 ? 0 : ~0 << 32 - prefix >>> 0;
-  return (ipNum & mask) === (cidrNum & mask);
-}
-function ipv4ToNum(ip) {
-  const parts = ip.split(".");
-  if (parts.length !== 4) return null;
-  let num = 0;
-  for (const part of parts) {
-    const n = parseInt(part, 10);
-    if (isNaN(n) || n < 0 || n > 255) return null;
-    num = num << 8 | n;
-  }
-  return num >>> 0;
-}
-function isIpv6InCidr(ip, cidr) {
-  const [cidrIp, prefixStr] = cidr.split("/");
-  if (!cidrIp || !prefixStr) return false;
-  const prefix = parseInt(prefixStr, 10);
-  if (isNaN(prefix)) return false;
-  const ipBytes = expandIpv6(ip);
-  const cidrBytes = expandIpv6(cidrIp);
-  if (!ipBytes || !cidrBytes) return false;
-  const fullBytes = Math.floor(prefix / 8);
-  for (let i = 0; i < fullBytes && i < 16; i++) {
-    if (ipBytes[i] !== cidrBytes[i]) return false;
-  }
-  const remainingBits = prefix % 8;
-  if (remainingBits > 0 && fullBytes < 16) {
-    const mask = ~0 << 8 - remainingBits & 255;
-    if ((ipBytes[fullBytes] & mask) !== (cidrBytes[fullBytes] & mask)) return false;
-  }
-  return true;
-}
-function expandIpv6(ip) {
-  const zoneIdx = ip.indexOf("%");
-  if (zoneIdx !== -1) ip = ip.slice(0, zoneIdx);
-  const parts = ip.split("::");
-  if (parts.length > 2) return null;
-  const bytes = new Array(16).fill(0);
-  const expandGroup = (group) => {
-    if (!group) return [];
-    return group.split(":").flatMap((hex) => {
-      const val = parseInt(hex || "0", 16);
-      return [val >> 8 & 255, val & 255];
-    });
-  };
-  if (parts.length === 1) {
-    const expanded = expandGroup(parts[0]);
-    if (expanded.length !== 16) return null;
-    return expanded;
-  }
-  const left = expandGroup(parts[0]);
-  const right = expandGroup(parts[1]);
-  if (left.length + right.length > 16) return null;
-  for (let i = 0; i < left.length; i++) bytes[i] = left[i];
-  for (let i = 0; i < right.length; i++) bytes[16 - right.length + i] = right[i];
-  return bytes;
-}
-
 // http/fetchText.ts
-import { createTaggedError as createTaggedError5 } from "@easynet/agent-tool";
+import { validateUrl } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError3 } from "@easynet/agent-tool";
 var fetchTextHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const url = (args.url ?? args.uri)?.trim();
   if (!url) {
-    throw createTaggedError5("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
+    throw createTaggedError3("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
   }
   const method = args.method ?? "GET";
   const headers = args.headers ?? {};
   const body = args.body ?? void 0;
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
   const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  await validateUrl(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
   if (!headers["User-Agent"] && !headers["user-agent"]) {
     headers["User-Agent"] = ctx.config.httpUserAgent;
   }
@@ -730,13 +542,13 @@ var fetchTextHandler = (async (args) => {
     });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError5(
+      throw createTaggedError3(
         "HTTP_TIMEOUT",
         `Request to ${url} timed out after ${timeoutMs}ms`,
         { url, timeoutMs }
       );
     }
-    throw createTaggedError5(
+    throw createTaggedError3(
       "UPSTREAM_ERROR",
       `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
       { url }
@@ -746,7 +558,7 @@ var fetchTextHandler = (async (args) => {
   }
   const contentLength = response.headers.get("content-length");
   if (contentLength && parseInt(contentLength, 10) > maxBytes) {
-    throw createTaggedError5(
+    throw createTaggedError3(
       "HTTP_TOO_LARGE",
       `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
       { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
@@ -791,7 +603,7 @@ async function readResponseWithLimit(response, maxBytes, url) {
       totalBytes += value.byteLength;
       if (totalBytes > maxBytes) {
         reader.cancel();
-        throw createTaggedError5(
+        throw createTaggedError3(
           "HTTP_TOO_LARGE",
           `Response body exceeded limit of ${maxBytes} bytes while reading from ${url}`,
           { url, bytesRead: totalBytes, limit: maxBytes }
@@ -807,19 +619,24 @@ async function readResponseWithLimit(response, maxBytes, url) {
 }
 
 // http/fetchJson.ts
-import { createTaggedError as createTaggedError6 } from "@easynet/agent-tool";
+import { validateUrl as validateUrl2 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError4 } from "@easynet/agent-tool";
 var fetchJsonHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const url = (args.url ?? args.uri)?.trim();
   if (!url) {
-    throw createTaggedError6("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
+    throw createTaggedError4("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
   }
   const method = args.method ?? "GET";
   const headers = args.headers ?? {};
   const body = args.body ?? void 0;
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
   const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  await validateUrl2(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
   if (!headers["Accept"] && !headers["accept"]) {
     headers["Accept"] = "application/json";
   }
@@ -838,13 +655,13 @@ var fetchJsonHandler = (async (args) => {
     });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError6(
+      throw createTaggedError4(
         "HTTP_TIMEOUT",
         `Request to ${url} timed out after ${timeoutMs}ms`,
         { url, timeoutMs }
       );
     }
-    throw createTaggedError6(
+    throw createTaggedError4(
       "UPSTREAM_ERROR",
       `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
       { url }
@@ -854,7 +671,7 @@ var fetchJsonHandler = (async (args) => {
   }
   const contentLength = response.headers.get("content-length");
   if (contentLength && parseInt(contentLength, 10) > maxBytes) {
-    throw createTaggedError6(
+    throw createTaggedError4(
       "HTTP_TOO_LARGE",
       `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
       { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
@@ -863,7 +680,7 @@ var fetchJsonHandler = (async (args) => {
   const text = await response.text();
   const bytes = Buffer.byteLength(text, "utf-8");
   if (bytes > maxBytes) {
-    throw createTaggedError6(
+    throw createTaggedError4(
       "HTTP_TOO_LARGE",
       `Response body ${bytes} bytes exceeds limit of ${maxBytes} bytes`,
       { url, bytes, limit: maxBytes }
@@ -873,7 +690,7 @@ var fetchJsonHandler = (async (args) => {
   try {
     json = JSON.parse(text);
   } catch {
-    throw createTaggedError6(
+    throw createTaggedError4(
       "UPSTREAM_ERROR",
       `Failed to parse JSON response from ${url}: ${text.slice(0, 200)}`,
       { url, status: response.status, textPreview: text.slice(0, 500) }
@@ -900,28 +717,33 @@ var fetchJsonHandler = (async (args) => {
 // http/downloadFile.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-import { dirname as dirname3 } from "path";
-import { createTaggedError as createTaggedError7 } from "@easynet/agent-tool";
+import { dirname as dirname2 } from "path";
+import { validateUrl as validateUrl3, resolveSandboxedPath as resolveSandboxedPath7 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError5 } from "@easynet/agent-tool";
 var downloadFileHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const url = (args.url ?? args.uri)?.trim();
   if (!url) {
-    throw createTaggedError7("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
+    throw createTaggedError5("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
   }
   const destPath = (args.destPath ?? args.destination ?? args.filePath)?.trim();
   if (!destPath) {
-    throw createTaggedError7("HTTP_INVALID", "destPath is required (pass 'destPath', 'destination', or 'filePath')", {});
+    throw createTaggedError5("HTTP_INVALID", "destPath is required (pass 'destPath', 'destination', or 'filePath')", {});
   }
   const headers = args.headers ?? {};
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
   const maxBytes = args.maxBytes ?? ctx.config.maxDownloadBytes;
   const overwrite = args.overwrite ?? false;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
-  const resolvedDest = await resolveSandboxedPath(destPath, ctx.config.sandboxRoot);
+  await validateUrl3(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
+  const resolvedDest = await resolveSandboxedPath7(destPath, ctx.config.sandboxRoot);
   if (!overwrite) {
-    const { access: access2 } = await import("fs/promises");
+    const { access } = await import("fs/promises");
     try {
-      await access2(resolvedDest);
+      await access(resolvedDest);
       throw new Error(
         `File already exists: ${resolvedDest}. Set overwrite=true to allow overwriting.`
       );
@@ -946,13 +768,13 @@ var downloadFileHandler = (async (args) => {
     });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError7(
+      throw createTaggedError5(
         "HTTP_TIMEOUT",
         `Download from ${url} timed out after ${timeoutMs}ms`,
         { url, timeoutMs }
       );
     }
-    throw createTaggedError7(
+    throw createTaggedError5(
       "UPSTREAM_ERROR",
       `Download failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
       { url }
@@ -962,14 +784,14 @@ var downloadFileHandler = (async (args) => {
   }
   const contentLength = response.headers.get("content-length");
   if (contentLength && parseInt(contentLength, 10) > maxBytes) {
-    throw createTaggedError7(
+    throw createTaggedError5(
       "HTTP_TOO_LARGE",
       `Download Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
       { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
     );
   }
   if (!response.body) {
-    throw createTaggedError7("UPSTREAM_ERROR", `No response body from ${url}`, { url });
+    throw createTaggedError5("UPSTREAM_ERROR", `No response body from ${url}`, { url });
   }
   const reader = response.body.getReader();
   const chunks = [];
@@ -982,7 +804,7 @@ var downloadFileHandler = (async (args) => {
       totalBytes += value.byteLength;
       if (totalBytes > maxBytes) {
         reader.cancel();
-        throw createTaggedError7(
+        throw createTaggedError5(
           "HTTP_TOO_LARGE",
           `Download from ${url} exceeded limit of ${maxBytes} bytes (received ${totalBytes})`,
           { url, bytesRead: totalBytes, limit: maxBytes }
@@ -995,7 +817,7 @@ var downloadFileHandler = (async (args) => {
     reader.releaseLock();
   }
   const sha256 = hasher.digest("hex");
-  await mkdir2(dirname3(resolvedDest), { recursive: true });
+  await mkdir2(dirname2(resolvedDest), { recursive: true });
   const buffer = Buffer.concat(chunks);
   await writeFile2(resolvedDest, buffer);
   return {
@@ -1024,16 +846,21 @@ var downloadFileHandler = (async (args) => {
 });
 
 // http/head.ts
-import { createTaggedError as createTaggedError8 } from "@easynet/agent-tool";
+import { validateUrl as validateUrl4 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError6 } from "@easynet/agent-tool";
 var headHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const url = (args.url ?? args.uri)?.trim();
   if (!url) {
-    throw createTaggedError8("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
+    throw createTaggedError6("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
   }
   const headers = args.headers ?? {};
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  await validateUrl4(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
   if (!headers["User-Agent"] && !headers["user-agent"]) {
     headers["User-Agent"] = ctx.config.httpUserAgent;
   }
@@ -1048,13 +875,13 @@ var headHandler = (async (args) => {
     });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError8(
+      throw createTaggedError6(
         "HTTP_TIMEOUT",
         `HEAD request to ${url} timed out after ${timeoutMs}ms`,
         { url, timeoutMs }
       );
     }
-    throw createTaggedError8(
+    throw createTaggedError6(
       "UPSTREAM_ERROR",
       `HEAD request failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
       { url }
@@ -1084,18 +911,23 @@ var headHandler = (async (args) => {
 });
 
 // http/duckduckgoSearch.ts
-import { createTaggedError as createTaggedError9 } from "@easynet/agent-tool";
+import { validateUrl as validateUrl5 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError7 } from "@easynet/agent-tool";
 var DUCKDUCKGO_API = "https://api.duckduckgo.com/";
 var duckduckgoSearchHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const query = (args.query ?? args.q)?.trim();
   if (!query) {
-    throw createTaggedError9("DUCKDUCKGO_INVALID", "query is required (pass 'query' or 'q')", {});
+    throw createTaggedError7("DUCKDUCKGO_INVALID", "query is required (pass 'query' or 'q')", {});
   }
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
   const maxResults = args.maxResults ?? 10;
   const url = `${DUCKDUCKGO_API}?q=${encodeURIComponent(query)}&format=json`;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  await validateUrl5(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   let response;
@@ -1108,13 +940,13 @@ var duckduckgoSearchHandler = (async (args) => {
   } catch (err) {
     clearTimeout(timer);
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError9(
+      throw createTaggedError7(
         "HTTP_TIMEOUT",
         `DuckDuckGo search timed out after ${timeoutMs}ms`,
         { query, timeoutMs }
       );
     }
-    throw createTaggedError9(
+    throw createTaggedError7(
       "UPSTREAM_ERROR",
       `DuckDuckGo search failed: ${err instanceof Error ? err.message : String(err)}`,
       { query }
@@ -1125,7 +957,7 @@ var duckduckgoSearchHandler = (async (args) => {
   const text = await response.text();
   const bytes = Buffer.byteLength(text, "utf-8");
   if (bytes > maxBytes) {
-    throw createTaggedError9(
+    throw createTaggedError7(
       "HTTP_TOO_LARGE",
       `DuckDuckGo response ${bytes} bytes exceeds limit of ${maxBytes} bytes`,
       { query, bytes, limit: maxBytes }
@@ -1135,7 +967,7 @@ var duckduckgoSearchHandler = (async (args) => {
   try {
     raw = JSON.parse(text);
   } catch {
-    throw createTaggedError9(
+    throw createTaggedError7(
       "UPSTREAM_ERROR",
       `DuckDuckGo returned invalid JSON`,
       { query, textPreview: text.slice(0, 200) }
@@ -1186,7 +1018,8 @@ var duckduckgoSearchHandler = (async (args) => {
 
 // http/fetchPageMainContent.ts
 import { parse } from "node-html-parser";
-import { createTaggedError as createTaggedError10 } from "@easynet/agent-tool";
+import { validateUrl as validateUrl6 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError8 } from "@easynet/agent-tool";
 var MAIN_SELECTORS = [
   "main",
   "article",
@@ -1229,11 +1062,15 @@ var fetchPageMainContentHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const url = (args.url ?? args.uri)?.trim();
   if (!url) {
-    throw createTaggedError10("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
+    throw createTaggedError8("HTTP_INVALID", "url is required (pass 'url' or 'uri')", {});
   }
   const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
   const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
-  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  await validateUrl6(url, {
+    allowedHosts: ctx.config.allowedHosts,
+    blockedHosts: ctx.config.blockedHosts,
+    blockedCidrs: ctx.config.blockedCidrs
+  });
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   let response;
@@ -1246,13 +1083,13 @@ var fetchPageMainContentHandler = (async (args) => {
   } catch (err) {
     clearTimeout(timer);
     if (err instanceof Error && err.name === "AbortError") {
-      throw createTaggedError10(
+      throw createTaggedError8(
         "HTTP_TIMEOUT",
         `Request to ${url} timed out after ${timeoutMs}ms`,
         { url, timeoutMs }
       );
     }
-    throw createTaggedError10(
+    throw createTaggedError8(
       "UPSTREAM_ERROR",
       `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
       { url }
@@ -1261,7 +1098,7 @@ var fetchPageMainContentHandler = (async (args) => {
   clearTimeout(timer);
   const contentLength = response.headers.get("content-length");
   if (contentLength && parseInt(contentLength, 10) > maxBytes) {
-    throw createTaggedError10(
+    throw createTaggedError8(
       "HTTP_TOO_LARGE",
       `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
       { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
@@ -1270,7 +1107,7 @@ var fetchPageMainContentHandler = (async (args) => {
   const rawText = await response.text();
   const rawBytes = Buffer.byteLength(rawText, "utf-8");
   if (rawBytes > maxBytes) {
-    throw createTaggedError10(
+    throw createTaggedError8(
       "HTTP_TOO_LARGE",
       `Response body ${rawBytes} bytes exceeds limit of ${maxBytes} bytes`,
       { url, bytes: rawBytes, limit: maxBytes }
@@ -1313,14 +1150,15 @@ var fetchPageMainContentHandler = (async (args) => {
 });
 
 // http/yahooFinance.ts
-import { createTaggedError as createTaggedError11 } from "@easynet/agent-tool";
+import { validateUrl as validateUrl7 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError9 } from "@easynet/agent-tool";
 var YAHOO_CHART_BASE = "https://query1.finance.yahoo.com/v8/finance/chart/";
 var yahooFinanceQuoteHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const rawSymbols = args.symbols ?? args.symbol ?? args.tickers;
   const symbols = Array.isArray(rawSymbols) ? rawSymbols.map((s) => String(s).trim().toUpperCase()).filter(Boolean) : rawSymbols != null ? [String(rawSymbols).trim().toUpperCase()].filter(Boolean) : [];
   if (symbols.length === 0) {
-    throw createTaggedError11(
+    throw createTaggedError9(
       "YAHOO_INVALID",
       "At least one symbol is required",
       {}
@@ -1332,7 +1170,11 @@ var yahooFinanceQuoteHandler = (async (args) => {
   const quotes = [];
   for (const symbol of symbols) {
     const url2 = `${YAHOO_CHART_BASE}${encodeURIComponent(symbol)}?interval=1d&range=${range}`;
-    await validateUrl(url2, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+    await validateUrl7(url2, {
+      allowedHosts: ctx.config.allowedHosts,
+      blockedHosts: ctx.config.blockedHosts,
+      blockedCidrs: ctx.config.blockedCidrs
+    });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     let response;
@@ -1348,13 +1190,13 @@ var yahooFinanceQuoteHandler = (async (args) => {
     } catch (err) {
       clearTimeout(timer);
       if (err instanceof Error && err.name === "AbortError") {
-        throw createTaggedError11(
+        throw createTaggedError9(
           "HTTP_TIMEOUT",
           `Yahoo Finance request for ${symbol} timed out after ${timeoutMs}ms`,
           { symbol, timeoutMs }
         );
       }
-      throw createTaggedError11(
+      throw createTaggedError9(
         "UPSTREAM_ERROR",
         `Yahoo Finance request failed: ${err instanceof Error ? err.message : String(err)}`,
         { symbol }
@@ -1364,7 +1206,7 @@ var yahooFinanceQuoteHandler = (async (args) => {
     const text = await response.text();
     const bytes = Buffer.byteLength(text, "utf-8");
     if (bytes > maxBytes) {
-      throw createTaggedError11(
+      throw createTaggedError9(
         "HTTP_TOO_LARGE",
         `Yahoo Finance response ${bytes} bytes exceeds limit of ${maxBytes} bytes`,
         { symbol, bytes, limit: maxBytes }
@@ -1374,7 +1216,7 @@ var yahooFinanceQuoteHandler = (async (args) => {
     try {
       data = JSON.parse(text);
     } catch {
-      throw createTaggedError11(
+      throw createTaggedError9(
         "UPSTREAM_ERROR",
         "Yahoo Finance returned invalid JSON",
         { symbol, textPreview: text.slice(0, 200) }
@@ -1382,7 +1224,7 @@ var yahooFinanceQuoteHandler = (async (args) => {
     }
     const error = data.chart?.error;
     if (error?.description) {
-      throw createTaggedError11(
+      throw createTaggedError9(
         "YAHOO_ERROR",
         `Yahoo Finance error for ${symbol}: ${error.description}`,
         { symbol, code: error.code }
@@ -1595,12 +1437,13 @@ var templateRenderHandler = (async (args) => {
 // exec/runCommand.ts
 import { spawn } from "child_process";
 import { resolve as pathResolve } from "path";
-import { createTaggedError as createTaggedError12 } from "@easynet/agent-tool";
+import { resolveSandboxedPath as resolveSandboxedPath8 } from "@easynet/agent-tool";
+import { createTaggedError as createTaggedError10 } from "@easynet/agent-tool";
 var runCommandHandler = (async (args) => {
   const ctx = getBuiltinContext();
   const { allowedCommands, maxCommandOutputBytes, commandTimeoutMs } = ctx.config;
   if (!allowedCommands.length) {
-    throw createTaggedError12(
+    throw createTaggedError10(
       "EXEC_DISABLED",
       "Exec is disabled: allowedCommands is empty",
       {}
@@ -1608,18 +1451,18 @@ var runCommandHandler = (async (args) => {
   }
   const rawCommand = (args.command ?? args.cmd)?.trim();
   if (!rawCommand) {
-    throw createTaggedError12("EXEC_INVALID", "command is required (pass 'command' or 'cmd')", {});
+    throw createTaggedError10("EXEC_INVALID", "command is required (pass 'command' or 'cmd')", {});
   }
   const baseName = rawCommand.replace(/^.*\//, "").trim();
   if (baseName !== rawCommand || /[;&|$`\s]/.test(rawCommand)) {
-    throw createTaggedError12(
+    throw createTaggedError10(
       "EXEC_INVALID",
       "command must be a single executable name (no path, no shell chars)",
       { command: rawCommand }
     );
   }
   if (!allowedCommands.includes(baseName)) {
-    throw createTaggedError12(
+    throw createTaggedError10(
       "EXEC_NOT_ALLOWED",
       `Command "${baseName}" is not in allowedCommands`,
       { command: baseName, allowed: allowedCommands }
@@ -1629,7 +1472,7 @@ var runCommandHandler = (async (args) => {
   const timeoutMs = args.timeoutMs ?? commandTimeoutMs;
   let cwd = pathResolve(ctx.config.sandboxRoot);
   if (args.cwd != null && args.cwd !== "") {
-    cwd = await resolveSandboxedPath(args.cwd, ctx.config.sandboxRoot);
+    cwd = await resolveSandboxedPath8(args.cwd, ctx.config.sandboxRoot);
   }
   return new Promise((resolvePromise, rejectPromise) => {
     const proc = spawn(baseName, cmdArgs, {
@@ -1646,7 +1489,7 @@ var runCommandHandler = (async (args) => {
       if (totalBytes + len > maxCommandOutputBytes) {
         proc.kill("SIGKILL");
         rejectPromise(
-          createTaggedError12(
+          createTaggedError10(
             "EXEC_OUTPUT_TOO_LARGE",
             `Command output exceeded ${maxCommandOutputBytes} bytes`,
             { maxBytes: maxCommandOutputBytes }
@@ -1684,7 +1527,7 @@ var runCommandHandler = (async (args) => {
     proc.on("error", (err) => {
       clearTimeout(timeout);
       rejectPromise(
-        createTaggedError12("EXEC_SPAWN_ERROR", err.message, { command: baseName })
+        createTaggedError10("EXEC_SPAWN_ERROR", err.message, { command: baseName })
       );
     });
     proc.on("close", (code, signal) => {
@@ -1918,7 +1761,8 @@ var CORE_GROUP_PREFIX = {
 function registerCoreTools(registry, userConfig, options) {
   const config = {
     ...DEFAULT_CORE_TOOLS_CONFIG,
-    ...userConfig
+    ...userConfig,
+    blockedHosts: userConfig.blockedHosts ?? []
   };
   const adapter = new CoreAdapter(config);
   const onlySet = options?.only?.length ? new Set(options.only) : null;
@@ -1935,6 +1779,9 @@ function registerCoreTools(registry, userConfig, options) {
   }
   return adapter;
 }
+
+// index.ts
+import { resolveSandboxedPath as resolveSandboxedPath9, validateUrl as validateUrl8, isIpInBlockedCidrs } from "@easynet/agent-tool";
 export {
   CoreAdapter,
   DEFAULT_CORE_TOOLS_CONFIG,
@@ -1954,14 +1801,14 @@ export {
   nowSpec,
   readTextSpec,
   registerCoreTools,
-  resolveSandboxedPath,
+  resolveSandboxedPath9 as resolveSandboxedPath,
   runCommandSpec,
   runWithBuiltinContext,
   searchTextSpec,
   sha256Spec,
   templateRenderSpec,
   truncateSpec,
-  validateUrl,
+  validateUrl8 as validateUrl,
   writeTextSpec,
   yahooFinanceQuoteSpec
 };