agentool 1.0.0 → 1.1.1

package/dist/chunk-3FT4ZPB2.cjs

@@ -0,0 +1,65 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkVQSWMGG7cjs = require('./chunk-VQSWMGG7.cjs');
+
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/task-list/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+
+// src/task-list/prompt.ts
+function getPrompt() {
+  return `List all tasks with their status, owner, and dependencies.
+
+## When to Use
+- To see what tasks are available to work on (status: pending, not blocked)
+- To check overall progress on the current work
+- To find tasks that are blocked and need dependencies resolved
+- After completing a task \u2014 check for newly unblocked work
+- Before creating new tasks \u2014 check for duplicates
+
+## Output Format
+Returns a summary of each non-deleted task:
+- **id**: Task identifier (use with task-get or task-update)
+- **status**: pending, in_progress, or completed
+- **subject**: Brief description of the task
+- **owner**: Who is assigned (if set)
+- **blockedBy**: Tasks that must complete before this one can start
+
+## Tips
+- Tasks with non-empty \`blockedBy\` lists cannot be started until their dependencies are resolved
+- Use task-get with a specific ID to see full details including description and metadata
+- After marking a task completed, call this tool to find the next available task`;
+}
+
+// src/task-list/index.ts
+function createTaskList(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: _nullishCoalesce(config.description, () => ( getPrompt())),
+    inputSchema: _zod.z.object({}),
+    execute: async () => {
+      try {
+        const tasks = await _chunkVQSWMGG7cjs.loadTasks.call(void 0, tasksFile);
+        const visible = tasks.filter((t) => t.status !== "deleted");
+        if (visible.length === 0) return "No tasks found.";
+        return visible.map(_chunkVQSWMGG7cjs.formatTaskSummary).join("\n");
+      } catch (error) {
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [task-list]: ${msg}`;
+      }
+    }
+  });
+}
+var taskList = createTaskList();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createTaskList = createTaskList; exports.taskList = taskList;

package/dist/{chunk-VLNDEVKS.js → chunk-3LGXZLBH.js}

@@ -1,12 +1,50 @@
+import {
+  listDirectory,
+  readTextContent,
+  removeFile,
+  writeTextContent
+} from "./chunk-PWBVB6MN.js";
 import {
   containsPathTraversal
 } from "./chunk-I3ONDY7P.js";
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.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";
+
+// src/memory/prompt.ts
+function getPrompt() {
+  return `File-based key-value memory store for persisting notes, context, or any text data across conversations.
+
+Entries are stored as individual .md files in the memory directory.
+
+## Operations
+- **write**: Store content under a key (creates or overwrites)
+- **read**: Retrieve content by key
+- **list**: List all stored keys
+- **delete**: Remove a key and its content
+
+## When to Use
+- To persist information that should survive across conversations or sessions
+- To store user preferences, project notes, or context summaries
+- To keep a running log of decisions, findings, or important details
+
+## When NOT to Use
+- For temporary data within a single conversation \u2014 just keep it in context
+- For structured task tracking \u2014 use the task management tools instead
+
+## Usage Guidelines
+- Keys are sanitized to prevent path traversal (no ../ allowed)
+- The \`key\` parameter is required for read, write, and delete operations
+- The \`content\` parameter is required for write operations
+- Use descriptive key names for easy discovery (e.g., "user-preferences", "project-architecture")`;
+}
+
+// src/memory/index.ts
 function sanitizeKey(key) {
   if (!key || key.trim() === "") {
     return { err: "Error [memory]: Key must not be empty." };
@@ -24,7 +62,7 @@ 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.",
+    description: config.description ?? getPrompt(),
     inputSchema: z.object({
       action: z.enum(["read", "write", "list", "delete"]).describe(
         "The operation to perform: read, write, list, or delete"
@@ -55,7 +93,7 @@ function createMemory(config = {}) {
             return `Error [memory]: Unknown action "${String(action)}".`;
         }
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = extractErrorMessage(error);
         return `Error [memory]: ${msg}`;
       }
     }
@@ -65,20 +103,19 @@ 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");
+  await writeTextContent(join(dir, `${key}.md`), content);
   return `Saved memory "${key}".`;
 }
 async function readEntry(dir, key) {
   try {
-    return await readFile(join(dir, `${key}.md`), "utf-8");
+    return await readTextContent(join(dir, `${key}.md`));
   } catch {
     return `Error [memory]: Key "${key}" not found.`;
   }
 }
 async function listKeys(dir) {
   try {
-    const files = await readdir(dir);
+    const files = await listDirectory(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");
@@ -88,7 +125,7 @@ async function listKeys(dir) {
 }
 async function deleteEntry(dir, key) {
   try {
-    await unlink(join(dir, `${key}.md`));
+    await removeFile(join(dir, `${key}.md`));
     return `Deleted memory "${key}".`;
   } catch {
     return `Error [memory]: Key "${key}" not found.`;
@@ -97,6 +134,7 @@ async function deleteEntry(dir, key) {
 var memory = createMemory();
 
 export {
+  getPrompt,
   createMemory,
   memory
 };

package/dist/{chunk-G3ITTPGX.js → chunk-4MXDQEPA.js}

@@ -47,6 +47,16 @@ function applyEditToFile(originalContent, oldString, newString, replaceAll = fal
   const stripTrailingNewline = !oldString.endsWith("\n") && originalContent.includes(oldString + "\n");
   return stripTrailingNewline ? f(originalContent, oldString + "\n", newString) : f(originalContent, oldString, newString);
 }
+function countOccurrences(text, search) {
+  if (search.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = text.indexOf(search, pos)) !== -1) {
+    count++;
+    pos += search.length;
+  }
+  return count;
+}
 function isOpeningContext(chars, index) {
   if (index === 0) {
     return true;
@@ -95,5 +105,6 @@ function applyCurlySingleQuotes(str) {
 export {
   findActualString,
   preserveQuoteStyle,
-  applyEditToFile
+  applyEditToFile,
+  countOccurrences
 };

package/dist/{chunk-CGTPF6IS.js → chunk-4UUSERSH.js}

@@ -1,14 +1,18 @@
+import {
+  readTextContent
+} from "./chunk-PWBVB6MN.js";
 import {
   expandPath
 } from "./chunk-I3ONDY7P.js";
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
 
 // src/diff/index.ts
-import { readFile as readFile2 } from "fs/promises";
 import { tool } from "ai";
 import { z } from "zod";
 
 // src/shared/diff.ts
-import { readFile } from "fs/promises";
 import { createTwoFilesPatch } from "diff";
 function diffStrings(oldContent, newContent, options) {
   if (oldContent === newContent) {
@@ -29,8 +33,8 @@ function diffStrings(oldContent, newContent, options) {
 }
 async function diffFiles(oldFilePath, newFilePath, options) {
   const [oldContent, newContent] = await Promise.all([
-    readFile(oldFilePath, "utf-8"),
-    readFile(newFilePath, "utf-8")
+    readTextContent(oldFilePath),
+    readTextContent(newFilePath)
   ]);
   return diffStrings(oldContent, newContent, {
     ...options,
@@ -39,11 +43,30 @@ async function diffFiles(oldFilePath, newFilePath, options) {
   });
 }
 
+// src/diff/prompt.ts
+function getPrompt() {
+  return `Generate a unified diff between two files or two strings.
+
+Supports three modes:
+1. **Two file paths**: \`file_path\` + \`other_file_path\` \u2014 compares the contents of both files
+2. **Two strings**: \`old_content\` + \`new_content\` \u2014 compares the provided strings directly
+3. **File + string**: \`file_path\` + \`old_content\` or \`new_content\` \u2014 compares a file against provided content
+
+## When to Use
+- To preview what changes would look like before making edits
+- To compare two versions of a file or text
+- To generate a diff for review or documentation purposes
+
+## When NOT to Use
+- To actually apply changes to a file \u2014 use the file editing tool instead
+- To read file contents \u2014 use the file reading tool instead`;
+}
+
 // src/diff/index.ts
 function createDiff(config = {}) {
   const cwd = config.cwd ?? process.cwd();
   return tool({
-    description: "Generate a unified diff between two files or two strings. Provide file_path + other_file_path to compare files, or old_content + new_content to compare strings. You can also provide file_path with old_content or new_content to compare a file against provided content.",
+    description: config.description ?? getPrompt(),
     inputSchema: z.object({
       file_path: z.string().optional().describe("Path to the first file (absolute or relative to cwd)"),
       other_file_path: z.string().optional().describe("Path to the second file (absolute or relative to cwd)"),
@@ -62,7 +85,7 @@ function createDiff(config = {}) {
         }
         if (file_path && (old_content !== void 0 || new_content !== void 0)) {
           const resolvedPath = expandPath(file_path, cwd);
-          const fileContent = await readFile2(resolvedPath, "utf-8");
+          const fileContent = await readTextContent(resolvedPath);
           if (old_content !== void 0) {
             return diffStrings(old_content, fileContent, {
               oldLabel: "provided",
@@ -76,7 +99,7 @@ function createDiff(config = {}) {
         }
         return "Error [diff]: Insufficient parameters. Provide either: (1) file_path + other_file_path, (2) old_content + new_content, or (3) file_path + old_content/new_content.";
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = extractErrorMessage(error);
         return `Error [diff]: ${msg}`;
       }
     }
@@ -85,6 +108,7 @@ function createDiff(config = {}) {
 var diff = createDiff();
 
 export {
+  getPrompt,
   createDiff,
   diff
 };

package/dist/{chunk-I6KFFQPV.cjs → chunk-5T3SQYI4.cjs}

@@ -1,9 +1,38 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/http-request/index.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/http-request/index.ts
 var _ai = require('ai');
 var _zod = require('zod');
+
+// src/http-request/prompt.ts
+function getPrompt(config = {}) {
+  const timeout = _nullishCoalesce(config.timeout, () => ( 3e4));
+  return `Make an HTTP request to a URL. Returns the raw response status, headers, and body as JSON.
+
+Supports GET, POST, PUT, PATCH, DELETE, and HEAD methods.
+
+## When to Use
+- For API interactions: REST calls, webhook triggers, service health checks
+- When you need full control over HTTP method, headers, and request body
+- When you need the raw response (status codes, headers) not just content
+
+## When NOT to Use
+- To read a web page for its content \u2014 use the web fetch tool instead (it converts HTML to markdown)
+- To search the web \u2014 use the web search tool instead
+
+## Usage Guidelines
+- Default timeout: ${timeout}ms. Override with the timeout parameter.
+- Request body is sent for POST, PUT, and PATCH methods
+- Response is returned as JSON with status, statusText, headers, and body fields
+- Default headers from config are merged with per-request headers (per-request takes precedence)`;
+}
+
+// src/http-request/index.ts
 function createHttpRequest(config = {}) {
   return _ai.tool.call(void 0, {
-    description: "Make an HTTP request to a URL. Returns the response status, headers, and body. Use this for API interactions, webhook calls, and service health checks. Unlike web-fetch, this returns raw response data without markdown conversion.",
+    description: _nullishCoalesce(config.description, () => ( getPrompt(config))),
     inputSchema: _zod.z.object({
       method: _zod.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).describe("HTTP method"),
       url: _zod.z.string().describe("The URL to send the request to"),
@@ -44,7 +73,7 @@ function createHttpRequest(config = {}) {
         if (error instanceof Error && error.name === "AbortError") {
           return `Error [http-request]: Request timed out after ${effectiveTimeout}ms for ${method} ${url}. Try increasing the timeout or verify the server is responsive.`;
         }
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
         return `Error [http-request]: ${method} ${url} failed: ${msg}. Verify the URL is correct and the server is reachable.`;
       }
     }
@@ -55,4 +84,5 @@ var httpRequest = createHttpRequest();
 
 
 
-exports.createHttpRequest = createHttpRequest; exports.httpRequest = httpRequest;
+
+exports.getPrompt = getPrompt; exports.createHttpRequest = createHttpRequest; exports.httpRequest = httpRequest;

package/dist/chunk-6ULQG2W2.cjs

@@ -0,0 +1,99 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+var _chunkYTPZHJDCcjs = require('./chunk-YTPZHJDC.cjs');
+
+
+
+var _chunkBIAODQ2Pcjs = require('./chunk-BIAODQ2P.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/edit/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/edit/prompt.ts
+function getPrompt() {
+  return `Perform an exact string replacement in a file. Locates old_string and replaces it with new_string.
+
+Supports absolute paths, relative paths, and tilde (~) expansion. Includes curly-quote fallback matching and quote-style preservation.
+
+## When to Use
+- To make targeted changes to existing files
+- To rename variables, update configuration values, or fix bugs
+- Prefer this over the file writing tool for modifying existing files \u2014 it only changes what you specify
+
+## When NOT to Use
+- To create a new file from scratch \u2014 use the file writing tool instead
+- To make many changes at once \u2014 consider the multi-edit tool for batch operations
+
+## Usage Guidelines
+- The edit will fail if \`old_string\` is not found in the file
+- When \`replace_all\` is false (default), \`old_string\` must appear exactly once in the file. If it appears multiple times, provide more surrounding context to make it unique, or set \`replace_all: true\`
+- Use \`replace_all: true\` for renaming a variable or string across the entire file
+- Preserve exact indentation (tabs/spaces) from the original file in both old_string and new_string
+- old_string and new_string must be different`;
+}
+
+// src/edit/index.ts
+function createEdit(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt())),
+    inputSchema: _zod.z.object({
+      file_path: _zod.z.string().describe("The absolute path to the file to modify"),
+      old_string: _zod.z.string().describe("The exact string to find and replace"),
+      new_string: _zod.z.string().describe("The replacement string"),
+      replace_all: _zod.z.boolean().default(false).optional().describe("Replace all occurrences (default: false)")
+    }),
+    execute: async ({ file_path, old_string, new_string, replace_all }) => {
+      try {
+        const resolved = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, config.cwd);
+        let content;
+        try {
+          content = await _chunkBIAODQ2Pcjs.readTextContent.call(void 0, resolved);
+        } catch (err) {
+          const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, err);
+          return `Error [edit]: Cannot read file "${resolved}": ${msg}`;
+        }
+        if (old_string === new_string) {
+          return "Error [edit]: old_string and new_string are identical \u2014 nothing to change.";
+        }
+        const actualOld = _chunkYTPZHJDCcjs.findActualString.call(void 0, content, old_string);
+        if (actualOld === null) {
+          const preview = content.slice(0, 200);
+          return `Error [edit]: old_string not found in "${resolved}". File starts with:
+${preview}`;
+        }
+        if (!replace_all) {
+          const count = _chunkYTPZHJDCcjs.countOccurrences.call(void 0, content, actualOld);
+          if (count > 1) {
+            return `Error [edit]: old_string appears ${count} times in "${resolved}". Use replace_all to replace every occurrence, or provide a more specific string.`;
+          }
+        }
+        const styledNew = _chunkYTPZHJDCcjs.preserveQuoteStyle.call(void 0, old_string, actualOld, new_string);
+        const updated = _chunkYTPZHJDCcjs.applyEditToFile.call(void 0, content, actualOld, styledNew, replace_all);
+        await _chunkBIAODQ2Pcjs.writeTextContent.call(void 0, resolved, updated);
+        const snippet = styledNew.length > 0 ? styledNew.slice(0, 200) : "(deletion)";
+        return `Successfully edited "${resolved}". Replacement snippet:
+${snippet}`;
+      } catch (error) {
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [edit]: ${msg}`;
+      }
+    }
+  });
+}
+var edit = createEdit();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createEdit = createEdit; exports.edit = edit;

package/dist/chunk-ABXTBB2N.cjs

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkBIAODQ2Pcjs = require('./chunk-BIAODQ2P.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/write/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/write/prompt.ts
+function getPrompt() {
+  return `Write text content to a file, creating parent directories as needed. If the file already exists it is overwritten entirely.
+
+Supports absolute paths, relative paths, and tilde (~) expansion.
+
+## When to Use
+- To create new files that don't exist yet
+- To completely rewrite an existing file's content
+- When the changes are so extensive that targeted editing would be impractical
+
+## When NOT to Use
+- To make small, targeted changes to an existing file \u2014 use the file editing tool instead (it only changes what you specify and is less error-prone)
+- Prefer the editing tool for modifications; reserve this tool for creating new files or complete rewrites
+
+## Usage Guidelines
+- This tool overwrites the entire file \u2014 make sure you include all desired content, not just the changes
+- Parent directories are created automatically if they don't exist
+- Read the existing file first before overwriting it, so you don't accidentally lose content`;
+}
+
+// src/write/index.ts
+function createWrite(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt())),
+    inputSchema: _zod.z.object({
+      file_path: _zod.z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+      content: _zod.z.string().describe("Text content to write to the file")
+    }),
+    execute: async ({ file_path, content }) => {
+      try {
+        const absolutePath = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, cwd);
+        const existed = await _chunkBIAODQ2Pcjs.pathExists.call(void 0, absolutePath);
+        await _chunkBIAODQ2Pcjs.writeTextContent.call(void 0, absolutePath, content);
+        const bytes = Buffer.byteLength(content, "utf-8");
+        const verb = existed ? "Updated" : "Created";
+        return `${verb} file: ${absolutePath} (${bytes} bytes)`;
+      } catch (error) {
+        const message = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [write]: Failed to write file: ${message}`;
+      }
+    }
+  });
+}
+var write = createWrite();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createWrite = createWrite; exports.write = write;

package/dist/{chunk-CAEVLIQB.cjs → chunk-BIAODQ2P.cjs}

@@ -25,6 +25,18 @@ async function pathExists(path) {
     return false;
   }
 }
+async function readTextContent(filePath) {
+  return _promises.readFile.call(void 0, filePath, "utf-8");
+}
+async function listDirectory(dirPath) {
+  return _promises.readdir.call(void 0, dirPath);
+}
+async function removeFile(filePath) {
+  await _promises.unlink.call(void 0, filePath);
+}
+async function getFileStats(filePath) {
+  return _promises.stat.call(void 0, filePath);
+}
 async function readFileInRange(filePath, offset = 0, maxLines) {
   const stats = await _promises.stat.call(void 0, filePath);
   if (stats.isDirectory()) {
@@ -114,4 +126,8 @@ function readFileInRangeStreaming(filePath, offset, maxLines) {
 
 
 
-exports.addLineNumbers = addLineNumbers; exports.writeTextContent = writeTextContent; exports.pathExists = pathExists; exports.readFileInRange = readFileInRange;
+
+
+
+
+exports.addLineNumbers = addLineNumbers; exports.writeTextContent = writeTextContent; exports.pathExists = pathExists; exports.readTextContent = readTextContent; exports.listDirectory = listDirectory; exports.removeFile = removeFile; exports.getFileStats = getFileStats; exports.readFileInRange = readFileInRange;

package/dist/chunk-CJA76MKM.js

@@ -0,0 +1,59 @@
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
+
+// src/web-search/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/web-search/prompt.ts
+function getPrompt() {
+  return `Search the web for information using a search query. Results can be filtered by allowed or blocked domains.
+
+Requires an onSearch callback to be configured \u2014 the application provides the actual search implementation.
+
+## When to Use
+- To find current information beyond the model's training data
+- To look up documentation, recent news, or real-time data
+- To verify facts or find authoritative sources
+
+## When NOT to Use
+- To read a specific URL whose address you already know \u2014 use the web fetch tool instead
+- To search file contents in the local codebase \u2014 use the dedicated content search tool instead
+
+## Usage Guidelines
+- After answering a question using search results, include a "Sources:" section listing the relevant URLs
+- Use the current year when searching for recent information or documentation
+- Use \`allowed_domains\` to restrict results to specific sites (e.g., ["docs.python.org"])
+- Use \`blocked_domains\` to exclude specific sites from results`;
+}
+
+// src/web-search/index.ts
+function createWebSearch(config = {}) {
+  return tool({
+    description: config.description ?? getPrompt(),
+    inputSchema: z.object({
+      query: z.string().min(2).describe("The search query to use"),
+      allowed_domains: z.array(z.string()).optional().describe("Only include search results from these domains"),
+      blocked_domains: z.array(z.string()).optional().describe("Never include search results from these domains")
+    }),
+    execute: async ({ query, allowed_domains, blocked_domains }) => {
+      try {
+        if (!config.onSearch) {
+          return "Error [web-search]: No search callback configured. Provide onSearch via createWebSearch({ onSearch: async (query, opts) => ... })";
+        }
+        return await config.onSearch(query, { allowed_domains, blocked_domains });
+      } catch (error) {
+        const msg = extractErrorMessage(error);
+        return `Error [web-search]: ${msg}`;
+      }
+    }
+  });
+}
+var webSearch = createWebSearch();
+
+export {
+  getPrompt,
+  createWebSearch,
+  webSearch
+};

package/dist/chunk-CM3VRCNX.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/web-search/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/web-search/prompt.ts
+function getPrompt() {
+  return `Search the web for information using a search query. Results can be filtered by allowed or blocked domains.
+
+Requires an onSearch callback to be configured \u2014 the application provides the actual search implementation.
+
+## When to Use
+- To find current information beyond the model's training data
+- To look up documentation, recent news, or real-time data
+- To verify facts or find authoritative sources
+
+## When NOT to Use
+- To read a specific URL whose address you already know \u2014 use the web fetch tool instead
+- To search file contents in the local codebase \u2014 use the dedicated content search tool instead
+
+## Usage Guidelines
+- After answering a question using search results, include a "Sources:" section listing the relevant URLs
+- Use the current year when searching for recent information or documentation
+- Use \`allowed_domains\` to restrict results to specific sites (e.g., ["docs.python.org"])
+- Use \`blocked_domains\` to exclude specific sites from results`;
+}
+
+// src/web-search/index.ts
+function createWebSearch(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt())),
+    inputSchema: _zod.z.object({
+      query: _zod.z.string().min(2).describe("The search query to use"),
+      allowed_domains: _zod.z.array(_zod.z.string()).optional().describe("Only include search results from these domains"),
+      blocked_domains: _zod.z.array(_zod.z.string()).optional().describe("Never include search results from these domains")
+    }),
+    execute: async ({ query, allowed_domains, blocked_domains }) => {
+      try {
+        if (!config.onSearch) {
+          return "Error [web-search]: No search callback configured. Provide onSearch via createWebSearch({ onSearch: async (query, opts) => ... })";
+        }
+        return await config.onSearch(query, { allowed_domains, blocked_domains });
+      } catch (error) {
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [web-search]: ${msg}`;
+      }
+    }
+  });
+}
+var webSearch = createWebSearch();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createWebSearch = createWebSearch; exports.webSearch = webSearch;