agentool 0.0.1 → 1.1.0

package/dist/chunk-FW3UJ622.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(); } }// src/context-compaction/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var parametersSchema = _zod.z.object({
+  messages: _zod.z.array(
+    _zod.z.object({
+      role: _zod.z.string().describe("Message role (system, user, assistant)"),
+      content: _zod.z.string().describe("Message content")
+    })
+  ).describe("The conversation messages to compact"),
+  maxTokens: _zod.z.number().optional().describe(
+    "Target maximum tokens (default: config.maxTokens or 4096)"
+  )
+});
+function createContextCompaction(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Compact conversation history by summarizing older messages to reduce context size. Requires a summarize function in config. Returns compacted messages where total chars < maxTokens * 4.",
+    inputSchema: _ai.zodSchema.call(void 0, parametersSchema),
+    execute: async ({
+      messages,
+      maxTokens: inputMaxTokens
+    }) => {
+      const maxTokens = _nullishCoalesce(_nullishCoalesce(inputMaxTokens, () => ( config.maxTokens)), () => ( 4096));
+      const charBudget = maxTokens * 4;
+      const totalChars = messages.reduce(
+        (sum, m) => sum + m.content.length,
+        0
+      );
+      if (totalChars <= charBudget) {
+        return JSON.stringify({
+          compacted: false,
+          messages,
+          reason: "Already within token budget"
+        });
+      }
+      if (!config.summarize) {
+        return "Error [context-compaction]: No summarize function configured. Provide a summarize callback in the tool config.";
+      }
+      try {
+        const summary = await config.summarize(messages);
+        const compactedMessages = [{ role: "system", content: summary }];
+        return JSON.stringify({
+          compacted: true,
+          messages: compactedMessages,
+          originalCount: messages.length
+        });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [context-compaction]: Summarization failed: ${msg}`;
+      }
+    }
+  });
+}
+var contextCompaction = createContextCompaction();
+
+
+
+
+exports.createContextCompaction = createContextCompaction; exports.contextCompaction = contextCompaction;

package/dist/chunk-G3ITTPGX.js

@@ -0,0 +1,99 @@
+// src/shared/edit-helpers.ts
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+function findActualString(fileContent, searchString) {
+  if (fileContent.includes(searchString)) {
+    return searchString;
+  }
+  const normalizedSearch = normalizeQuotes(searchString);
+  const normalizedFile = normalizeQuotes(fileContent);
+  const searchIndex = normalizedFile.indexOf(normalizedSearch);
+  if (searchIndex !== -1) {
+    return fileContent.substring(
+      searchIndex,
+      searchIndex + searchString.length
+    );
+  }
+  return null;
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const hasDoubleQuotes = actualOldString.includes(LEFT_DOUBLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingleQuotes = actualOldString.includes(LEFT_SINGLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDoubleQuotes && !hasSingleQuotes) {
+    return newString;
+  }
+  let result = newString;
+  if (hasDoubleQuotes) {
+    result = applyCurlyDoubleQuotes(result);
+  }
+  if (hasSingleQuotes) {
+    result = applyCurlySingleQuotes(result);
+  }
+  return result;
+}
+function applyEditToFile(originalContent, oldString, newString, replaceAll = false) {
+  const f = replaceAll ? (content, search, replace) => content.replaceAll(search, () => replace) : (content, search, replace) => content.replace(search, () => replace);
+  if (newString !== "") {
+    return f(originalContent, oldString, newString);
+  }
+  const stripTrailingNewline = !oldString.endsWith("\n") && originalContent.includes(oldString + "\n");
+  return stripTrailingNewline ? f(originalContent, oldString + "\n", newString) : f(originalContent, oldString, newString);
+}
+function isOpeningContext(chars, index) {
+  if (index === 0) {
+    return true;
+  }
+  const prev = chars[index - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || // em dash
+  prev === "\u2013";
+}
+function applyCurlyDoubleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === '"') {
+      result.push(
+        isOpeningContext(chars, i) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE
+      );
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function applyCurlySingleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "'") {
+      const prev = i > 0 ? chars[i - 1] : void 0;
+      const next = i < chars.length - 1 ? chars[i + 1] : void 0;
+      const prevIsLetter = prev !== void 0 && new RegExp("\\p{L}", "u").test(prev);
+      const nextIsLetter = next !== void 0 && new RegExp("\\p{L}", "u").test(next);
+      if (prevIsLetter && nextIsLetter) {
+        result.push(RIGHT_SINGLE_CURLY_QUOTE);
+      } else {
+        result.push(
+          isOpeningContext(chars, i) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE
+        );
+      }
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+
+export {
+  findActualString,
+  preserveQuoteStyle,
+  applyEditToFile
+};

package/dist/chunk-HDKXSKMO.js

@@ -0,0 +1,30 @@
+// src/ask-user/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createAskUser(config = {}) {
+  return tool({
+    description: "Ask the user a question and wait for their response. Use this when you need clarification, confirmation, or additional information from the user before proceeding.",
+    inputSchema: z.object({
+      question: z.string().describe("The question to ask the user"),
+      options: z.array(z.string()).optional().describe("Optional list of suggested response options")
+    }),
+    execute: async ({ question, options }) => {
+      if (!config.onQuestion) {
+        return "Error [ask-user]: No onQuestion callback configured. Provide an onQuestion function in the tool config to enable user interaction.";
+      }
+      try {
+        const response = await config.onQuestion(question, options);
+        return response;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [ask-user]: Failed to get user response: ${msg}`;
+      }
+    }
+  });
+}
+var askUser = createAskUser();
+
+export {
+  createAskUser,
+  askUser
+};

package/dist/chunk-HNP7JDQC.cjs

@@ -0,0 +1,159 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkMIYA7TNRcjs = require('./chunk-MIYA7TNR.cjs');
+
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/grep/index.ts
+var _promises = require('fs/promises');
+var _ai = require('ai');
+var _zod = require('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 = _nullishCoalesce(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 _chunkQZ5GS6HWcjs.toRelativePath.call(void 0, 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 = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  return _ai.tool.call(void 0, {
+    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: _zod.z.object({
+      pattern: _zod.z.string().describe("The regular expression pattern to search for in file contents"),
+      path: _zod.z.string().optional().describe("File or directory to search in (rg PATH). Defaults to current working directory."),
+      glob: _zod.z.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob'),
+      output_mode: _zod.z.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".'),
+      "-B": _zod.z.number().optional().describe('Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.'),
+      "-A": _zod.z.number().optional().describe('Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.'),
+      "-C": _zod.z.number().optional().describe("Alias for context."),
+      context: _zod.z.number().optional().describe('Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.'),
+      "-n": _zod.z.boolean().optional().describe('Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.'),
+      "-i": _zod.z.boolean().optional().describe("Case insensitive search (rg -i)"),
+      type: _zod.z.string().optional().describe("File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types."),
+      head_limit: _zod.z.number().optional().describe('Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly \u2014 large result sets waste context).'),
+      offset: _zod.z.number().optional().describe('Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0.'),
+      multiline: _zod.z.boolean().optional().describe("Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.")
+    }),
+    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 ? _chunkQZ5GS6HWcjs.expandPath.call(void 0, 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 _chunkMIYA7TNRcjs.executeRipgrep.call(void 0, 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) => _promises.stat.call(void 0, f)));
+        const sorted = results.map((fp, i) => {
+          const r = stats[i];
+          const mt = r.status === "fulfilled" ? _nullishCoalesce(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) => _chunkQZ5GS6HWcjs.toRelativePath.call(void 0, 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();
+
+
+
+
+exports.createGrep = createGrep; exports.grep = grep;

package/dist/chunk-HNUL2CID.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkL5JH4I77cjs = require('./chunk-L5JH4I77.cjs');
+
+// src/task-list/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+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: "List all tasks with their status, owner, and dependencies.",
+    inputSchema: _zod.z.object({}),
+    execute: async () => {
+      try {
+        const tasks = await _chunkL5JH4I77cjs.loadTasks.call(void 0, tasksFile);
+        const visible = tasks.filter((t) => t.status !== "deleted");
+        if (visible.length === 0) return "No tasks found.";
+        return visible.map(_chunkL5JH4I77cjs.formatTaskSummary).join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-list]: ${msg}`;
+      }
+    }
+  });
+}
+var taskList = createTaskList();
+
+
+
+
+exports.createTaskList = createTaskList; exports.taskList = taskList;

package/dist/chunk-HZAQRHBT.js

@@ -0,0 +1,99 @@
+import {
+  executeRipgrep
+} from "./chunk-MJCAXASI.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/glob/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/glob.ts
+import { isAbsolute, join, basename, dirname, sep } from "path";
+function extractGlobBaseDirectory(pattern) {
+  const globChars = /[*?[{]/;
+  const match = pattern.match(globChars);
+  if (!match || match.index === void 0) {
+    const dir = dirname(pattern);
+    const file = basename(pattern);
+    return { baseDir: dir, relativePattern: file };
+  }
+  const staticPrefix = pattern.slice(0, match.index);
+  const lastSepIndex = Math.max(
+    staticPrefix.lastIndexOf("/"),
+    staticPrefix.lastIndexOf(sep)
+  );
+  if (lastSepIndex === -1) {
+    return { baseDir: "", relativePattern: pattern };
+  }
+  let baseDir = staticPrefix.slice(0, lastSepIndex);
+  const relativePattern = pattern.slice(lastSepIndex + 1);
+  if (baseDir === "" && lastSepIndex === 0) {
+    baseDir = "/";
+  }
+  return { baseDir, relativePattern };
+}
+async function glob(pattern, cwd, options) {
+  const limit = options?.limit ?? 100;
+  const offset = options?.offset ?? 0;
+  let searchDir = cwd;
+  let searchPattern = pattern;
+  if (isAbsolute(pattern)) {
+    const { baseDir, relativePattern } = extractGlobBaseDirectory(pattern);
+    if (baseDir) {
+      searchDir = baseDir;
+      searchPattern = relativePattern;
+    }
+  }
+  const args = [
+    "--files",
+    "--glob",
+    searchPattern,
+    "--sort=modified",
+    "--hidden",
+    "--no-ignore"
+  ];
+  const allPaths = await executeRipgrep(args, searchDir, {
+    signal: options?.signal
+  });
+  const absolutePaths = allPaths.map(
+    (p) => isAbsolute(p) ? p : join(searchDir, p)
+  );
+  const truncated = absolutePaths.length > offset + limit;
+  const files = absolutePaths.slice(offset, offset + limit);
+  return { files, truncated };
+}
+
+// src/glob/index.ts
+function createGlob(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: 'Find files matching a glob pattern. Returns absolute file paths sorted by modification time (newest first). Supports patterns like "**/*.ts", "src/**/*.js", or "*.json".',
+    inputSchema: z.object({
+      pattern: z.string().describe("Glob pattern to match files against"),
+      path: z.string().optional().describe("Directory to search in. Defaults to the working directory.")
+    }),
+    execute: async ({ pattern, path }) => {
+      try {
+        const searchDir = path ? expandPath(path, cwd) : cwd;
+        const { files, truncated } = await glob(pattern, searchDir);
+        if (files.length === 0) {
+          return "No files found";
+        }
+        const header = truncated ? `Found ${files.length}+ files (results truncated)` : `Found ${files.length} files`;
+        return `${header}
+${files.join("\n")}`;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error [glob]: Failed to search for files: ${message}`;
+      }
+    }
+  });
+}
+var glob2 = createGlob();
+
+export {
+  createGlob,
+  glob2 as glob
+};

package/dist/chunk-I3ONDY7P.js

@@ -0,0 +1,46 @@
+// src/shared/path.ts
+import { homedir } from "os";
+import { isAbsolute, join, normalize, relative, resolve } from "path";
+function expandPath(inputPath, baseDir) {
+  const actualBaseDir = baseDir ?? process.cwd();
+  if (typeof inputPath !== "string") {
+    throw new TypeError(
+      `Path must be a string, received ${typeof inputPath}`
+    );
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(
+      `Base directory must be a string, received ${typeof actualBaseDir}`
+    );
+  }
+  if (inputPath.includes("\0") || actualBaseDir.includes("\0")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmed = inputPath.trim();
+  if (!trimmed) {
+    return normalize(actualBaseDir);
+  }
+  if (trimmed === "~") {
+    return homedir();
+  }
+  if (trimmed.startsWith("~/")) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  if (isAbsolute(trimmed)) {
+    return normalize(trimmed);
+  }
+  return resolve(actualBaseDir, trimmed);
+}
+function toRelativePath(absolutePath, baseDir) {
+  const rel = relative(baseDir ?? process.cwd(), absolutePath);
+  return rel.startsWith("..") ? absolutePath : rel;
+}
+function containsPathTraversal(inputPath) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(inputPath);
+}
+
+export {
+  expandPath,
+  toRelativePath,
+  containsPathTraversal
+};

package/dist/chunk-I6KFFQPV.cjs

@@ -0,0 +1,58 @@
+"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
+var _ai = require('ai');
+var _zod = require('zod');
+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.",
+    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"),
+      headers: _zod.z.record(_zod.z.string()).optional().describe("Request headers as key-value pairs"),
+      body: _zod.z.string().optional().describe("Request body (for POST, PUT, PATCH)"),
+      timeout: _zod.z.number().optional().describe("Request timeout in milliseconds (default: 30000)")
+    }),
+    execute: async ({ method, url, headers, body, timeout }) => {
+      try {
+        const timeoutMs = _nullishCoalesce(_nullishCoalesce(timeout, () => ( config.timeout)), () => ( 3e4));
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const mergedHeaders = { ...config.defaultHeaders, ...headers };
+        const response = await fetch(url, {
+          method,
+          headers: mergedHeaders,
+          body: ["POST", "PUT", "PATCH"].includes(method) ? body : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const responseBody = await response.text();
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        return JSON.stringify(
+          {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            body: responseBody
+          },
+          null,
+          2
+        );
+      } catch (error) {
+        const effectiveTimeout = _nullishCoalesce(_nullishCoalesce(timeout, () => ( config.timeout)), () => ( 3e4));
+        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);
+        return `Error [http-request]: ${method} ${url} failed: ${msg}. Verify the URL is correct and the server is reachable.`;
+      }
+    }
+  });
+}
+var httpRequest = createHttpRequest();
+
+
+
+
+exports.createHttpRequest = createHttpRequest; exports.httpRequest = httpRequest;

package/dist/chunk-IEX4NOVN.cjs

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/tool-search/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createToolSearch(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Search for available tools by name or keyword. Returns matching tool names and descriptions.",
+    inputSchema: _zod.z.object({
+      query: _zod.z.string().describe("Query to find tools by name or keyword"),
+      max_results: _zod.z.number().optional().default(5).describe("Max results to return")
+    }),
+    execute: async ({ query, max_results }) => {
+      try {
+        const registry = _nullishCoalesce(config.tools, () => ( {}));
+        const entries = Object.entries(registry);
+        if (entries.length === 0) {
+          return "No tools registered. Provide a tools registry via createToolSearch({ tools: { ... } })";
+        }
+        const lower = query.toLowerCase();
+        const scored = entries.map(([name, { description }]) => {
+          let score = 0;
+          const nameLower = name.toLowerCase();
+          const descLower = description.toLowerCase();
+          if (nameLower === lower) score += 10;
+          else if (nameLower.includes(lower)) score += 5;
+          if (descLower.includes(lower)) score += 3;
+          for (const word of lower.split(/\s+/)) {
+            if (nameLower.includes(word)) score += 2;
+            if (descLower.includes(word)) score += 1;
+          }
+          return { name, description, score };
+        }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, max_results);
+        if (scored.length === 0) {
+          return `No tools matched query "${query}".`;
+        }
+        return scored.map((e) => `${e.name}: ${e.description}`).join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [tool-search]: ${msg}`;
+      }
+    }
+  });
+}
+var toolSearch = createToolSearch();
+
+
+
+
+exports.createToolSearch = createToolSearch; exports.toolSearch = toolSearch;