agentool 0.0.1 → 1.0.0

package/dist/chunk-U2YMJM25.cjs

@@ -0,0 +1,115 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/web-fetch/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/shared/fetch.ts
+var MAX_MARKDOWN_LENGTH = 1e5;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_CONTENT_LENGTH = 10 * 1024 * 1024;
+var turndownPromise;
+function getTurndownService() {
+  return turndownPromise ??= Promise.resolve().then(() => _interopRequireWildcard(require("turndown"))).then((m) => {
+    const Turndown = m.default;
+    return new Turndown();
+  });
+}
+function composeSignal(timeoutMs, userSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (!userSignal) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([timeoutSignal, userSignal]);
+}
+async function fetchUrl(url, options) {
+  const timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.timeout]), () => ( DEFAULT_TIMEOUT_MS));
+  const maxBytes = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.maxContentLength]), () => ( DEFAULT_MAX_CONTENT_LENGTH));
+  const signal = composeSignal(timeoutMs, _optionalChain([options, 'optionalAccess', _3 => _3.signal]));
+  const headers = {
+    Accept: "text/markdown, text/html, */*"
+  };
+  if (_optionalChain([options, 'optionalAccess', _4 => _4.userAgent])) {
+    headers["User-Agent"] = options.userAgent;
+  }
+  const response = await fetch(url, { signal, headers });
+  const chunks = [];
+  let totalBytes = 0;
+  if (response.body) {
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel();
+        throw new Error(
+          `Response body exceeds maxContentLength (${maxBytes} bytes)`
+        );
+      }
+      chunks.push(value);
+    }
+  }
+  const rawBuffer = Buffer.concat(chunks);
+  const byteLength = rawBuffer.length;
+  const contentType = _nullishCoalesce(response.headers.get("content-type"), () => ( ""));
+  const textContent = rawBuffer.toString("utf-8");
+  let content;
+  if (contentType.includes("text/html")) {
+    const td = await getTurndownService();
+    content = td.turndown(textContent);
+  } else {
+    content = textContent;
+  }
+  let truncated = false;
+  if (content.length > MAX_MARKDOWN_LENGTH) {
+    content = content.slice(0, MAX_MARKDOWN_LENGTH);
+    truncated = true;
+  }
+  return {
+    content,
+    contentType,
+    statusCode: response.status,
+    byteLength,
+    truncated
+  };
+}
+
+// src/web-fetch/index.ts
+function createWebFetch(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Fetch a URL and return its content. HTML pages are automatically converted to markdown for easier reading. JSON and other text content is returned as-is. Content is truncated at 100,000 characters to manage context size.",
+    inputSchema: _zod.z.object({
+      url: _zod.z.string().describe("The URL to fetch"),
+      prompt: _zod.z.string().optional().describe(
+        "Optional context about what to extract from the page"
+      )
+    }),
+    execute: async ({ url }) => {
+      try {
+        const result = await fetchUrl(url, {
+          timeout: _nullishCoalesce(config.timeout, () => ( 3e4)),
+          maxContentLength: config.maxContentLength,
+          userAgent: config.userAgent
+        });
+        const parts = [];
+        parts.push(`URL: ${url}`);
+        parts.push(`Status: ${result.statusCode}`);
+        parts.push(`Content-Type: ${result.contentType}`);
+        if (result.truncated) {
+          parts.push("(Content truncated to 100,000 characters)");
+        }
+        parts.push("");
+        parts.push(result.content);
+        return parts.join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [web-fetch]: Failed to fetch ${url}: ${msg}`;
+      }
+    }
+  });
+}
+var webFetch = createWebFetch();
+
+
+
+
+exports.createWebFetch = createWebFetch; exports.webFetch = webFetch;

package/dist/chunk-VLNDEVKS.js

@@ -0,0 +1,102 @@
+import {
+  containsPathTraversal
+} from "./chunk-I3ONDY7P.js";
+
+// src/memory/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+function sanitizeKey(key) {
+  if (!key || key.trim() === "") {
+    return { err: "Error [memory]: Key must not be empty." };
+  }
+  if (containsPathTraversal(key)) {
+    return { err: "Error [memory]: Key contains path traversal and was rejected." };
+  }
+  const cleaned = key.replace(/^\.+/, "");
+  if (cleaned === "") {
+    return { err: "Error [memory]: Key must not be empty after stripping leading dots." };
+  }
+  return { ok: cleaned };
+}
+function createMemory(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const memoryDir = config.memoryDir ?? join(cwd, ".agentool", "memory");
+  return tool({
+    description: "File-based key-value memory store. Use this to persist notes, context, or any text data across conversations. Supports write, read, list, and delete operations.",
+    inputSchema: z.object({
+      action: z.enum(["read", "write", "list", "delete"]).describe(
+        "The operation to perform: read, write, list, or delete"
+      ),
+      key: z.string().optional().describe(
+        "The memory key (required for read, write, delete)"
+      ),
+      content: z.string().optional().describe(
+        "The content to store (required for write)"
+      )
+    }),
+    execute: async ({ action, key, content }) => {
+      try {
+        if (action === "list") {
+          return await listKeys(memoryDir);
+        }
+        const result = sanitizeKey(key);
+        if ("err" in result) return result.err;
+        const safeKey = result.ok;
+        switch (action) {
+          case "write":
+            return await writeEntry(memoryDir, safeKey, content);
+          case "read":
+            return await readEntry(memoryDir, safeKey);
+          case "delete":
+            return await deleteEntry(memoryDir, safeKey);
+          default:
+            return `Error [memory]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [memory]: ${msg}`;
+      }
+    }
+  });
+}
+async function writeEntry(dir, key, content) {
+  if (!content && content !== "") {
+    return "Error [memory]: Content is required for write action.";
+  }
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `${key}.md`), content, "utf-8");
+  return `Saved memory "${key}".`;
+}
+async function readEntry(dir, key) {
+  try {
+    return await readFile(join(dir, `${key}.md`), "utf-8");
+  } catch {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+async function listKeys(dir) {
+  try {
+    const files = await readdir(dir);
+    const keys = files.filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
+    if (keys.length === 0) return "No memory entries found.";
+    return keys.join("\n");
+  } catch {
+    return "No memory entries found.";
+  }
+}
+async function deleteEntry(dir, key) {
+  try {
+    await unlink(join(dir, `${key}.md`));
+    return `Deleted memory "${key}".`;
+  } catch {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+var memory = createMemory();
+
+export {
+  createMemory,
+  memory
+};

package/dist/chunk-XKG2A3EW.js

@@ -0,0 +1,159 @@
+import {
+  executeRipgrep
+} from "./chunk-MJCAXASI.js";
+import {
+  expandPath,
+  toRelativePath
+} from "./chunk-I3ONDY7P.js";
+
+// src/grep/index.ts
+import { stat } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+var VCS_DIRS = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"];
+var DEFAULT_HEAD_LIMIT = 250;
+function applyHeadLimit(items, limit, offset = 0) {
+  if (limit === 0) return { items: items.slice(offset), appliedLimit: void 0 };
+  const cap = limit ?? DEFAULT_HEAD_LIMIT;
+  const sliced = items.slice(offset, offset + cap);
+  const truncated = items.length - offset > cap;
+  return { items: sliced, appliedLimit: truncated ? cap : void 0 };
+}
+function truncationSuffix(appliedLimit, offset) {
+  const parts = [];
+  if (appliedLimit !== void 0) parts.push(`limit: ${appliedLimit}`);
+  if (offset > 0) parts.push(`offset: ${offset}`);
+  return parts.length > 0 ? `
+
+[Results truncated. ${parts.join(", ")}]` : "";
+}
+function relativizeLine(line, baseCwd, last = false) {
+  const idx = last ? line.lastIndexOf(":") : line.indexOf(":");
+  if (idx > 0) {
+    return toRelativePath(line.substring(0, idx), baseCwd) + line.substring(idx);
+  }
+  return line;
+}
+function parseGlobPatterns(globFilter) {
+  const patterns = [];
+  for (const raw of globFilter.split(/\s+/)) {
+    if (raw.includes("{") && raw.includes("}")) {
+      patterns.push(raw);
+    } else {
+      patterns.push(...raw.split(",").filter(Boolean));
+    }
+  }
+  return patterns;
+}
+function createGrep(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: 'Search file contents using ripgrep. Supports regex patterns, context lines, and three output modes: "content" (matching lines), "files_with_matches" (file paths), and "count" (match counts).',
+    inputSchema: z.object({
+      pattern: z.string().describe("Regex pattern to search for"),
+      path: z.string().optional().describe("File or directory to search in"),
+      glob: z.string().optional().describe('Glob pattern to filter files (e.g. "*.js")'),
+      output_mode: z.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode. Defaults to "files_with_matches".'),
+      "-B": z.number().optional().describe("Lines of context before each match"),
+      "-A": z.number().optional().describe("Lines of context after each match"),
+      "-C": z.number().optional().describe("Lines of context around each match"),
+      context: z.number().optional().describe("Context lines (alias for -C)"),
+      "-n": z.boolean().optional().describe("Show line numbers (content mode, default true)"),
+      "-i": z.boolean().optional().describe("Case insensitive search"),
+      type: z.string().optional().describe('File type filter (e.g. "js", "py")'),
+      head_limit: z.number().optional().describe("Max entries. Default 250, 0 = unlimited."),
+      offset: z.number().optional().describe("Skip first N entries. Default 0."),
+      multiline: z.boolean().optional().describe("Enable multiline matching")
+    }),
+    execute: async (input) => {
+      try {
+        const {
+          pattern,
+          path,
+          glob: globFilter,
+          type: typeFilter,
+          output_mode: outputMode = "files_with_matches",
+          "-B": ctxBefore,
+          "-A": ctxAfter,
+          "-C": ctxC,
+          context: ctxAlias,
+          "-n": showLineNumbers = true,
+          "-i": caseInsensitive = false,
+          head_limit: headLimit,
+          offset = 0,
+          multiline = false
+        } = input;
+        const absolutePath = path ? expandPath(path, cwd) : cwd;
+        const args = ["--hidden"];
+        for (const dir of VCS_DIRS) args.push("--glob", `!${dir}`);
+        args.push("--max-columns", "500");
+        if (multiline) args.push("-U", "--multiline-dotall");
+        if (caseInsensitive) args.push("-i");
+        if (outputMode === "files_with_matches") args.push("-l");
+        else if (outputMode === "count") args.push("-c");
+        if (showLineNumbers && outputMode === "content") args.push("-n");
+        if (outputMode === "content") {
+          if (ctxAlias !== void 0) args.push("-C", ctxAlias.toString());
+          else if (ctxC !== void 0) args.push("-C", ctxC.toString());
+          else {
+            if (ctxBefore !== void 0) args.push("-B", ctxBefore.toString());
+            if (ctxAfter !== void 0) args.push("-A", ctxAfter.toString());
+          }
+        }
+        if (pattern.startsWith("-")) args.push("-e", pattern);
+        else args.push(pattern);
+        if (typeFilter) args.push("--type", typeFilter);
+        if (globFilter) {
+          for (const gp of parseGlobPatterns(globFilter)) args.push("--glob", gp);
+        }
+        const results = await executeRipgrep(args, absolutePath);
+        if (results.length === 0) return "No matches found";
+        if (outputMode === "content") {
+          const { items: items2, appliedLimit: appliedLimit2 } = applyHeadLimit(results, headLimit, offset);
+          const lines = items2.map((l) => relativizeLine(l, cwd));
+          return lines.join("\n") + truncationSuffix(appliedLimit2, offset);
+        }
+        if (outputMode === "count") {
+          const { items: items2, appliedLimit: appliedLimit2 } = applyHeadLimit(results, headLimit, offset);
+          const lines = items2.map((l) => relativizeLine(l, cwd, true));
+          let totalMatches = 0;
+          let fileCount = 0;
+          for (const line of lines) {
+            const idx = line.lastIndexOf(":");
+            if (idx > 0) {
+              const n = parseInt(line.substring(idx + 1), 10);
+              if (!isNaN(n)) {
+                totalMatches += n;
+                fileCount += 1;
+              }
+            }
+          }
+          return lines.join("\n") + `
+
+Total: ${totalMatches} matches in ${fileCount} files` + truncationSuffix(appliedLimit2, offset);
+        }
+        const stats = await Promise.allSettled(results.map((f) => stat(f)));
+        const sorted = results.map((fp, i) => {
+          const r = stats[i];
+          const mt = r.status === "fulfilled" ? r.value.mtimeMs ?? 0 : 0;
+          return [fp, mt];
+        }).sort((a, b) => {
+          const d = b[1] - a[1];
+          return d !== 0 ? d : a[0].localeCompare(b[0]);
+        }).map((e) => e[0]);
+        const { items, appliedLimit } = applyHeadLimit(sorted, headLimit, offset);
+        const relative = items.map((f) => toRelativePath(f, cwd));
+        return relative.join("\n") + truncationSuffix(appliedLimit, offset);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [grep]: Failed to search: ${msg}`;
+      }
+    }
+  });
+}
+var grep = createGrep();
+
+export {
+  createGrep,
+  grep
+};

package/dist/chunk-XLD2Y3SS.cjs

@@ -0,0 +1,136 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/task/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _promises = require('fs/promises');
+var _path = require('path');
+var _crypto = require('crypto');
+function generateId() {
+  return _crypto.randomBytes.call(void 0, 4).toString("hex");
+}
+async function loadTasks(filePath) {
+  try {
+    const data = await _promises.readFile.call(void 0, filePath, "utf-8");
+    return JSON.parse(data);
+  } catch (e) {
+    return [];
+  }
+}
+async function saveTasks(filePath, tasks) {
+  await _promises.mkdir.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  await _promises.writeFile.call(void 0, filePath, JSON.stringify(tasks, null, 2), "utf-8");
+}
+function formatTask(t) {
+  return [
+    `ID: ${t.id}`,
+    `Subject: ${t.subject}`,
+    `Description: ${t.description}`,
+    `Status: ${t.status}`,
+    `Created: ${t.createdAt}`,
+    `Updated: ${t.updatedAt}`
+  ].join("\n");
+}
+function createTask(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const tasksFile = _nullishCoalesce(config.tasksFile, () => ( _path.join.call(void 0, cwd, ".agentool", "tasks.json")));
+  return _ai.tool.call(void 0, {
+    description: "JSON file-based task tracker. Use this to create, get, update, list, and delete tasks. Each task has an id, subject, description, status, and timestamps.",
+    inputSchema: _zod.z.object({
+      action: _zod.z.enum(["create", "get", "update", "list", "delete"]).describe(
+        "The operation to perform"
+      ),
+      id: _zod.z.string().optional().describe(
+        "Task id (required for get, update, delete)"
+      ),
+      subject: _zod.z.string().optional().describe(
+        "Task subject (required for create, optional for update)"
+      ),
+      description: _zod.z.string().optional().describe(
+        "Task description (required for create, optional for update)"
+      ),
+      status: _zod.z.enum(["pending", "in_progress", "completed"]).optional().describe(
+        "Task status (optional for create/update, defaults to pending)"
+      )
+    }),
+    execute: async ({ action, id, subject, description, status }) => {
+      try {
+        switch (action) {
+          case "create":
+            return await createEntry(tasksFile, subject, description, status);
+          case "list":
+            return await listEntries(tasksFile);
+          case "get":
+            return await getEntry(tasksFile, id);
+          case "update":
+            return await updateEntry(tasksFile, id, subject, description, status);
+          case "delete":
+            return await deleteEntry(tasksFile, id);
+          default:
+            return `Error [task]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task]: ${msg}`;
+      }
+    }
+  });
+}
+async function createEntry(filePath, subject, description, status) {
+  if (!subject) return "Error [task]: Subject is required for create action.";
+  if (!description) return "Error [task]: Description is required for create action.";
+  const tasks = await loadTasks(filePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: generateId(),
+    subject,
+    description,
+    status: _nullishCoalesce(status, () => ( "pending")),
+    createdAt: now,
+    updatedAt: now
+  };
+  tasks.push(entry);
+  await saveTasks(filePath, tasks);
+  return `Created task ${entry.id}.
+${formatTask(entry)}`;
+}
+async function listEntries(filePath) {
+  const tasks = await loadTasks(filePath);
+  if (tasks.length === 0) return "No tasks found.";
+  return tasks.map(formatTask).join("\n---\n");
+}
+async function getEntry(filePath, id) {
+  if (!id) return "Error [task]: ID is required for get action.";
+  const tasks = await loadTasks(filePath);
+  const found = tasks.find((t) => t.id === id);
+  if (!found) return `Error [task]: Task "${id}" not found.`;
+  return formatTask(found);
+}
+async function updateEntry(filePath, id, subject, description, status) {
+  if (!id) return "Error [task]: ID is required for update action.";
+  const tasks = await loadTasks(filePath);
+  const idx = tasks.findIndex((t) => t.id === id);
+  if (idx === -1) return `Error [task]: Task "${id}" not found.`;
+  const entry = tasks[idx];
+  if (subject) entry.subject = subject;
+  if (description) entry.description = description;
+  if (status) entry.status = status;
+  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  tasks[idx] = entry;
+  await saveTasks(filePath, tasks);
+  return `Updated task ${id}.
+${formatTask(entry)}`;
+}
+async function deleteEntry(filePath, id) {
+  if (!id) return "Error [task]: ID is required for delete action.";
+  const tasks = await loadTasks(filePath);
+  const idx = tasks.findIndex((t) => t.id === id);
+  if (idx === -1) return `Error [task]: Task "${id}" not found.`;
+  tasks.splice(idx, 1);
+  await saveTasks(filePath, tasks);
+  return `Deleted task "${id}".`;
+}
+var task = createTask();
+
+
+
+
+exports.createTask = createTask; exports.task = task;

package/dist/chunk-Y7KOKDFP.js

@@ -0,0 +1,115 @@
+// src/web-fetch/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/fetch.ts
+var MAX_MARKDOWN_LENGTH = 1e5;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_CONTENT_LENGTH = 10 * 1024 * 1024;
+var turndownPromise;
+function getTurndownService() {
+  return turndownPromise ??= import("turndown").then((m) => {
+    const Turndown = m.default;
+    return new Turndown();
+  });
+}
+function composeSignal(timeoutMs, userSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (!userSignal) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([timeoutSignal, userSignal]);
+}
+async function fetchUrl(url, options) {
+  const timeoutMs = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+  const maxBytes = options?.maxContentLength ?? DEFAULT_MAX_CONTENT_LENGTH;
+  const signal = composeSignal(timeoutMs, options?.signal);
+  const headers = {
+    Accept: "text/markdown, text/html, */*"
+  };
+  if (options?.userAgent) {
+    headers["User-Agent"] = options.userAgent;
+  }
+  const response = await fetch(url, { signal, headers });
+  const chunks = [];
+  let totalBytes = 0;
+  if (response.body) {
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel();
+        throw new Error(
+          `Response body exceeds maxContentLength (${maxBytes} bytes)`
+        );
+      }
+      chunks.push(value);
+    }
+  }
+  const rawBuffer = Buffer.concat(chunks);
+  const byteLength = rawBuffer.length;
+  const contentType = response.headers.get("content-type") ?? "";
+  const textContent = rawBuffer.toString("utf-8");
+  let content;
+  if (contentType.includes("text/html")) {
+    const td = await getTurndownService();
+    content = td.turndown(textContent);
+  } else {
+    content = textContent;
+  }
+  let truncated = false;
+  if (content.length > MAX_MARKDOWN_LENGTH) {
+    content = content.slice(0, MAX_MARKDOWN_LENGTH);
+    truncated = true;
+  }
+  return {
+    content,
+    contentType,
+    statusCode: response.status,
+    byteLength,
+    truncated
+  };
+}
+
+// src/web-fetch/index.ts
+function createWebFetch(config = {}) {
+  return tool({
+    description: "Fetch a URL and return its content. HTML pages are automatically converted to markdown for easier reading. JSON and other text content is returned as-is. Content is truncated at 100,000 characters to manage context size.",
+    inputSchema: z.object({
+      url: z.string().describe("The URL to fetch"),
+      prompt: z.string().optional().describe(
+        "Optional context about what to extract from the page"
+      )
+    }),
+    execute: async ({ url }) => {
+      try {
+        const result = await fetchUrl(url, {
+          timeout: config.timeout ?? 3e4,
+          maxContentLength: config.maxContentLength,
+          userAgent: config.userAgent
+        });
+        const parts = [];
+        parts.push(`URL: ${url}`);
+        parts.push(`Status: ${result.statusCode}`);
+        parts.push(`Content-Type: ${result.contentType}`);
+        if (result.truncated) {
+          parts.push("(Content truncated to 100,000 characters)");
+        }
+        parts.push("");
+        parts.push(result.content);
+        return parts.join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [web-fetch]: Failed to fetch ${url}: ${msg}`;
+      }
+    }
+  });
+}
+var webFetch = createWebFetch();
+
+export {
+  createWebFetch,
+  webFetch
+};