formagent-sdk 0.1.3 → 0.2.0

package/dist/cli/index.js

@@ -5,7 +5,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/cli/cli.ts
 import * as readline from "node:readline";
 import { homedir as homedir4 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { existsSync as existsSync10 } from "node:fs";
 
 // src/utils/id.ts
@@ -76,6 +76,113 @@ class TypedEventEmitter {
   }
 }
 
+// src/utils/truncation.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+var TRUNCATION_DEFAULTS = {
+  MAX_LINES: 2000,
+  MAX_BYTES: 50 * 1024,
+  RETENTION_MS: 7 * 24 * 60 * 60 * 1000
+};
+function getTempDir(config) {
+  return config?.tempDir ?? path.join(os.tmpdir(), "formagent-sdk-output");
+}
+function generateOutputFilename() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `tool_${timestamp}_${random}.txt`;
+}
+async function ensureTempDir(dir) {
+  try {
+    await fs.mkdir(dir, { recursive: true });
+  } catch {}
+}
+async function truncateOutput(text, config = {}) {
+  const maxLines = config.maxLines ?? TRUNCATION_DEFAULTS.MAX_LINES;
+  const maxBytes = config.maxBytes ?? TRUNCATION_DEFAULTS.MAX_BYTES;
+  const direction = config.direction ?? "head";
+  const saveToFile = config.saveToFile ?? true;
+  const lines = text.split(`
+`);
+  const totalBytes = Buffer.byteLength(text, "utf-8");
+  if (lines.length <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content: text,
+      truncated: false,
+      originalBytes: totalBytes,
+      originalLines: lines.length
+    };
+  }
+  const out = [];
+  let bytes = 0;
+  let hitBytes = false;
+  if (direction === "head") {
+    for (let i = 0;i < lines.length && i < maxLines; i++) {
+      const lineBytes = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0);
+      if (bytes + lineBytes > maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      out.push(lines[i]);
+      bytes += lineBytes;
+    }
+  } else {
+    for (let i = lines.length - 1;i >= 0 && out.length < maxLines; i--) {
+      const lineBytes = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0);
+      if (bytes + lineBytes > maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      out.unshift(lines[i]);
+      bytes += lineBytes;
+    }
+  }
+  const removed = hitBytes ? totalBytes - bytes : lines.length - out.length;
+  const unit = hitBytes ? "bytes" : "lines";
+  const preview = out.join(`
+`);
+  let outputPath;
+  if (saveToFile) {
+    const dir = getTempDir(config);
+    await ensureTempDir(dir);
+    outputPath = path.join(dir, generateOutputFilename());
+    await fs.writeFile(outputPath, text, "utf-8");
+  }
+  const hint = outputPath ? `Full output saved to: ${outputPath}
+Use Read tool with offset/limit to view specific sections, or Grep to search the content.` : "Output was truncated. Consider using more specific queries.";
+  const message = direction === "head" ? `${preview}
+
+...${removed} ${unit} truncated...
+
+${hint}` : `...${removed} ${unit} truncated...
+
+${hint}
+
+${preview}`;
+  return {
+    content: message,
+    truncated: true,
+    outputPath,
+    originalBytes: totalBytes,
+    originalLines: lines.length,
+    truncatedBytes: bytes,
+    truncatedLines: out.length
+  };
+}
+async function truncateToolOutput(output, config) {
+  const result = await truncateOutput(output, config);
+  return result.content;
+}
+function needsTruncation(text, config = {}) {
+  const maxLines = config.maxLines ?? TRUNCATION_DEFAULTS.MAX_LINES;
+  const maxBytes = config.maxBytes ?? TRUNCATION_DEFAULTS.MAX_BYTES;
+  const lines = text.split(`
+`);
+  const bytes = Buffer.byteLength(text, "utf-8");
+  return lines.length > maxLines || bytes > maxBytes;
+}
+
 // src/hooks/manager.ts
 class HookTimeoutError extends Error {
   constructor(hookName, timeout) {
@@ -312,7 +419,7 @@ class HooksManager {
 // src/skills/loader.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join, dirname, basename } from "node:path";
+import { join as join2, dirname, basename } from "node:path";
 import { homedir } from "node:os";
 
 // src/utils/frontmatter.ts
@@ -427,13 +534,13 @@ class SkillLoader {
     } = options;
     const allDirs = [...directories];
     if (includeUserSkills) {
-      const userSkillsDir = join(homedir(), USER_SKILLS_DIR);
+      const userSkillsDir = join2(homedir(), USER_SKILLS_DIR);
       if (existsSync(userSkillsDir)) {
         allDirs.push(userSkillsDir);
       }
     }
     if (includeProjectSkills && this.projectRoot) {
-      const projectSkillsDir = join(this.projectRoot, PROJECT_SKILLS_DIR);
+      const projectSkillsDir = join2(this.projectRoot, PROJECT_SKILLS_DIR);
       if (existsSync(projectSkillsDir)) {
         allDirs.push(projectSkillsDir);
       }
@@ -449,8 +556,8 @@ class SkillLoader {
     if (this.skills.has(skillId)) {
       return this.skills.get(skillId);
     }
-    for (const path of this.discoveredPaths) {
-      const skill = await this.parseSkillFile(path);
+    for (const path2 of this.discoveredPaths) {
+      const skill = await this.parseSkillFile(path2);
       if (skill && skill.id === skillId) {
         this.skills.set(skill.id, skill);
         return skill;
@@ -550,10 +657,10 @@ class SkillLoader {
     try {
       const entries = readdirSync(dir);
       for (const entry of entries) {
-        const fullPath = join(dir, entry);
+        const fullPath = join2(dir, entry);
         const stat = statSync(fullPath);
         if (stat.isDirectory()) {
-          const skillFile = join(fullPath, SKILL_FILE_NAME);
+          const skillFile = join2(fullPath, SKILL_FILE_NAME);
           if (existsSync(skillFile)) {
             if (!this.discoveredPaths.has(skillFile)) {
               const skill = await this.parseSkillFile(skillFile);
@@ -633,9 +740,9 @@ var defaultSkillLoader = new SkillLoader;
 
 // src/tools/skill.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 import { homedir as homedir2 } from "node:os";
-var DEFAULT_USER_SKILLS_PATH = join2(homedir2(), ".claude/skills");
+var DEFAULT_USER_SKILLS_PATH = join3(homedir2(), ".claude/skills");
 var skillToolSchema = {
   type: "object",
   properties: {
@@ -662,7 +769,7 @@ function createSkillTool(config = {}) {
     const paths = [];
     if (config.settingSources && config.settingSources.length > 0) {
       for (const source of config.settingSources) {
-        const resolvedPath = source.startsWith("~") ? join2(homedir2(), source.slice(1)) : source;
+        const resolvedPath = source.startsWith("~") ? join3(homedir2(), source.slice(1)) : source;
         if (existsSync2(resolvedPath)) {
           paths.push(resolvedPath);
         }
@@ -1113,7 +1220,7 @@ var defaultSystemPromptBuilder = new SystemPromptBuilderImpl;
 // src/prompt/claude-md.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { join as join3, dirname as dirname2 } from "node:path";
+import { join as join4, dirname as dirname2 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 var CLAUDE_MD_FILENAME = "CLAUDE.md";
 var USER_CLAUDE_DIR = ".claude";
@@ -1127,7 +1234,7 @@ class ClaudeMdLoaderImpl {
     return this.loadFile(filePath, "project");
   }
   async loadUserClaudeMd() {
-    const filePath = join3(homedir3(), USER_CLAUDE_DIR, CLAUDE_MD_FILENAME);
+    const filePath = join4(homedir3(), USER_CLAUDE_DIR, CLAUDE_MD_FILENAME);
     if (!existsSync3(filePath)) {
       return;
     }
@@ -1148,9 +1255,9 @@ class ClaudeMdLoaderImpl {
       }
     }
     if (config.additionalPaths) {
-      for (const path of config.additionalPaths) {
-        if (existsSync3(path)) {
-          const content = await this.loadFile(path, "project");
+      for (const path2 of config.additionalPaths) {
+        if (existsSync3(path2)) {
+          const content = await this.loadFile(path2, "project");
           if (content) {
             contents.push(content);
           }
@@ -1177,11 +1284,11 @@ class ClaudeMdLoaderImpl {
   async findProjectClaudeMd(startDir) {
     let currentDir = startDir;
     while (currentDir !== "/") {
-      const claudeMdPath = join3(currentDir, CLAUDE_MD_FILENAME);
+      const claudeMdPath = join4(currentDir, CLAUDE_MD_FILENAME);
       if (existsSync3(claudeMdPath)) {
         return claudeMdPath;
       }
-      const gitPath = join3(currentDir, ".git");
+      const gitPath = join4(currentDir, ".git");
       if (existsSync3(gitPath)) {
         break;
       }
@@ -1247,6 +1354,7 @@ class SessionImpl {
   _state;
   provider;
   tools;
+  toolNameLookup = new Map;
   emitter;
   pendingMessage = null;
   isReceiving = false;
@@ -1254,6 +1362,7 @@ class SessionImpl {
   closed = false;
   hooksManager = null;
   maxTurns;
+  enableToolRepair = true;
   constructor(id, config, provider, state) {
     this.id = id;
     this.config = config;
@@ -1276,6 +1385,7 @@ class SessionImpl {
     if (config.tools) {
       for (const tool of config.tools) {
         this.tools.set(tool.name, tool);
+        this.toolNameLookup.set(tool.name.toLowerCase(), tool.name);
       }
     }
     if (config.settingSources && config.settingSources.length > 0) {
@@ -1284,6 +1394,7 @@ class SessionImpl {
         cwd: config.cwd
       });
       this.tools.set(skillTool2.name, skillTool2);
+      this.toolNameLookup.set(skillTool2.name.toLowerCase(), skillTool2.name);
     }
     this.applyAllowedToolsFilter();
     if (config.hooks) {
@@ -1592,12 +1703,23 @@ class SessionImpl {
       }
       systemMessage = preResult.systemMessage;
     }
-    const tool = this.tools.get(block.name);
+    let tool = this.tools.get(block.name);
+    let effectiveToolName = block.name;
+    if (!tool && this.enableToolRepair) {
+      const lowerName = block.name.toLowerCase();
+      const originalName = this.toolNameLookup.get(lowerName);
+      if (originalName) {
+        tool = this.tools.get(originalName);
+        effectiveToolName = originalName;
+      }
+    }
     if (!tool) {
+      const availableTools = Array.from(this.tools.keys()).slice(0, 10);
+      const suffix = this.tools.size > 10 ? ` (and ${this.tools.size - 10} more)` : "";
       return {
         type: "tool_result",
         tool_use_id: block.id,
-        content: `Error: Tool "${block.name}" not found`,
+        content: `Error: Tool "${block.name}" not found. Available tools: ${availableTools.join(", ")}${suffix}`,
         is_error: true,
         _hookSystemMessage: systemMessage
       };
@@ -1610,7 +1732,10 @@ class SessionImpl {
     let toolResponse;
     try {
       const toolResult = await tool.execute(toolInput, context);
-      const content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
+      let content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
+      if (needsTruncation(content)) {
+        content = await truncateToolOutput(content);
+      }
       toolResponse = toolResult;
       result = {
         type: "tool_result",
@@ -2828,24 +2953,36 @@ var defaultMCPServerManager = new MCPServerManager;
 // src/tools/manager.ts
 class ToolManager {
   tools = new Map;
+  toolNameLookup = new Map;
   mcpServers = new Map;
   allowedTools;
   onToolEvent;
+  enableToolRepair;
   constructor(options = {}) {
     this.allowedTools = options.allowedTools;
     this.onToolEvent = options.onToolEvent;
+    this.enableToolRepair = options.enableToolRepair ?? true;
   }
   register(tool) {
     this.tools.set(tool.name, tool);
+    this.toolNameLookup.set(tool.name.toLowerCase(), tool.name);
   }
   unregister(name) {
     this.tools.delete(name);
+    this.toolNameLookup.delete(name.toLowerCase());
   }
   get(name) {
     const tool = this.tools.get(name);
     if (tool) {
       return tool;
     }
+    if (this.enableToolRepair) {
+      const lowerName = name.toLowerCase();
+      const originalName = this.toolNameLookup.get(lowerName);
+      if (originalName) {
+        return this.tools.get(originalName);
+      }
+    }
     if (isMCPTool(name)) {
       const parsed = parseMCPToolName(name);
       if (parsed) {
@@ -2857,6 +2994,34 @@ class ToolManager {
     }
     return;
   }
+  repairToolName(name) {
+    if (this.tools.has(name)) {
+      return { repaired: false, originalName: name };
+    }
+    const lowerName = name.toLowerCase();
+    const originalName = this.toolNameLookup.get(lowerName);
+    if (originalName && originalName !== name) {
+      return {
+        repaired: true,
+        originalName: name,
+        repairedName: originalName
+      };
+    }
+    if (isMCPTool(name)) {
+      const parsed = parseMCPToolName(name);
+      if (parsed) {
+        const wrapper = this.mcpServers.get(parsed.serverName);
+        if (wrapper) {
+          return { repaired: false, originalName: name };
+        }
+      }
+    }
+    return {
+      repaired: false,
+      originalName: name,
+      error: `Tool "${name}" not found. Available tools: ${Array.from(this.tools.keys()).join(", ")}`
+    };
+  }
   getAll() {
     const allTools = [];
     for (const tool of this.tools.values()) {
@@ -2874,6 +3039,7 @@ class ToolManager {
   }
   clear() {
     this.tools.clear();
+    this.toolNameLookup.clear();
   }
   async registerMCPServer(server) {
     const wrapper = new MCPServerWrapper(server);
@@ -2881,6 +3047,7 @@ class ToolManager {
     const tools = await wrapper.getTools();
     for (const tool of tools) {
       this.tools.set(tool.name, tool);
+      this.toolNameLookup.set(tool.name.toLowerCase(), tool.name);
     }
     return tools.length;
   }
@@ -2892,6 +3059,7 @@ class ToolManager {
           const parsed = parseMCPToolName(name);
           if (parsed?.serverName === serverName) {
             this.tools.delete(name);
+            this.toolNameLookup.delete(name.toLowerCase());
           }
         }
       }
@@ -2903,9 +3071,23 @@ class ToolManager {
     return Array.from(this.mcpServers.keys());
   }
   async execute(name, input, context) {
-    const tool = this.get(name);
+    let effectiveName = name;
+    let tool = this.tools.get(name);
+    if (!tool && this.enableToolRepair) {
+      const repairResult = this.repairToolName(name);
+      if (repairResult.repaired && repairResult.repairedName) {
+        effectiveName = repairResult.repairedName;
+        tool = this.tools.get(effectiveName);
+        console.debug(`[ToolManager] Repaired tool name: "${name}" -> "${effectiveName}"`);
+      }
+    }
     if (!tool) {
-      throw new Error(`Tool not found: ${name}`);
+      tool = this.get(name);
+    }
+    if (!tool) {
+      const availableTools = Array.from(this.tools.keys()).slice(0, 10);
+      const suffix = this.tools.size > 10 ? ` (and ${this.tools.size - 10} more)` : "";
+      throw new Error(`Tool not found: "${name}". Available tools: ${availableTools.join(", ")}${suffix}`);
     }
     if (!this.isToolAllowed(tool)) {
       throw new Error(`Tool not allowed: ${name}`);
@@ -2914,7 +3096,7 @@ class ToolManager {
     this.emitEvent({
       type: "tool_start",
       toolId,
-      toolName: name,
+      toolName: effectiveName,
       input
     });
     try {
@@ -3305,7 +3487,7 @@ Type: ${ext}`
 }
 var ReadTool = createReadTool();
 // src/tools/builtin/write.ts
-import { writeFile, mkdir } from "node:fs/promises";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 function createWriteTool(options = {}) {
@@ -3336,9 +3518,9 @@ function createWriteTool(options = {}) {
       try {
         const dir = dirname3(access.resolved);
         if (!existsSync5(dir)) {
-          await mkdir(dir, { recursive: true });
+          await mkdir2(dir, { recursive: true });
         }
-        await writeFile(access.resolved, content, "utf-8");
+        await writeFile2(access.resolved, content, "utf-8");
         const lines = content.split(`
 `).length;
         const bytes = Buffer.byteLength(content, "utf-8");
@@ -3356,7 +3538,7 @@ function createWriteTool(options = {}) {
 }
 var WriteTool = createWriteTool();
 // src/tools/builtin/edit.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { existsSync as existsSync6 } from "node:fs";
 function createEditTool(options = {}) {
   return {
@@ -3428,7 +3610,7 @@ function createEditTool(options = {}) {
           newContent = content.replace(old_string, new_string);
           replacedCount = 1;
         }
-        await writeFile2(access.resolved, newContent, "utf-8");
+        await writeFile3(access.resolved, newContent, "utf-8");
         return {
           content: `Successfully replaced ${replacedCount} occurrence${replacedCount > 1 ? "s" : ""} in ${access.resolved}`
         };
@@ -3443,14 +3625,14 @@ function createEditTool(options = {}) {
 }
 var EditTool = createEditTool();
 // src/tools/builtin/glob.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
-import { join as join4, relative } from "node:path";
+import { join as join5, relative } from "node:path";
 var MAX_RESULTS = 1000;
-function matchGlob(pattern, path) {
+function matchGlob(pattern, path2) {
   const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*").replace(/\./g, "\\.");
   const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(path);
+  return regex.test(path2);
 }
 async function scanDir(dir, pattern, results, baseDir, maxDepth = 10, currentDepth = 0) {
   if (currentDepth > maxDepth || results.length >= MAX_RESULTS) {
@@ -3460,14 +3642,14 @@ async function scanDir(dir, pattern, results, baseDir, maxDepth = 10, currentDep
     return;
   }
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= MAX_RESULTS)
         break;
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const fullPath = join4(dir, entry.name);
+      const fullPath = join5(dir, entry.name);
       const relativePath = relative(baseDir, fullPath);
       if (entry.isDirectory()) {
         if (matchGlob(pattern, relativePath) || matchGlob(pattern, relativePath + "/")) {
@@ -3503,8 +3685,8 @@ function createGlobTool(options = {}) {
     },
     execute: async (rawInput, _context) => {
       const input = rawInput;
-      const { pattern, path = defaultCwd } = input;
-      const access = checkDirAccess(path, options);
+      const { pattern, path: path2 = defaultCwd } = input;
+      const access = checkDirAccess(path2, options);
       if (!access.ok) {
         return { content: access.error, isError: true };
       }
@@ -3552,9 +3734,9 @@ ${output}${truncated}`
 }
 var GlobTool = createGlobTool();
 // src/tools/builtin/grep.ts
-import { readFile as readFile5, readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile5, readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { existsSync as existsSync8 } from "node:fs";
-import { join as join5, extname as extname2 } from "node:path";
+import { join as join6, extname as extname2 } from "node:path";
 var MAX_RESULTS2 = 500;
 var MAX_LINE_LENGTH2 = 500;
 var BINARY_EXTENSIONS2 = new Set([
@@ -3629,14 +3811,14 @@ async function searchDir(dir, regex, glob, before, after, results, maxDepth = 10
     return;
   }
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= MAX_RESULTS2)
         break;
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const fullPath = join5(dir, entry.name);
+      const fullPath = join6(dir, entry.name);
       if (entry.isDirectory()) {
         await searchDir(fullPath, regex, glob, before, after, results, maxDepth, currentDepth + 1);
       } else if (entry.isFile()) {
@@ -3692,13 +3874,13 @@ function createGrepTool(options = {}) {
       const input = rawInput;
       const {
         pattern,
-        path = defaultCwd,
+        path: path2 = defaultCwd,
         glob,
         before = 0,
         after = 0,
         ignoreCase = false
       } = input;
-      const access = checkPathAccess(path, options, "dir");
+      const access = checkPathAccess(path2, options, "dir");
       if (!access.ok) {
         return { content: access.error, isError: true };
       }
@@ -3995,6 +4177,187 @@ Please fetch the new URL if you want to continue.`
   };
 }
 var WebFetchTool = createWebFetchTool();
+// src/tools/builtin/websearch.ts
+var API_CONFIG = {
+  BASE_URL: "https://mcp.exa.ai",
+  ENDPOINTS: {
+    SEARCH: "/mcp"
+  },
+  DEFAULT_NUM_RESULTS: 8,
+  DEFAULT_CONTEXT_MAX_CHARS: 1e4,
+  TIMEOUT_MS: 30000
+};
+var WEBSEARCH_DESCRIPTION = `Search the web for up-to-date information using Exa AI.
+
+Use this tool when you need to:
+- Find current information, news, or recent events
+- Look up documentation or technical resources
+- Research topics beyond your knowledge cutoff
+- Verify facts or get multiple perspectives
+
+The search returns curated, AI-optimized content with context.
+
+Parameters:
+- query: The search query (required)
+- numResults: Number of results to return (default: 8, max: 20)
+- livecrawl: 'fallback' (default) or 'preferred' for fresh content
+- type: 'auto' (default), 'fast', or 'deep'
+- contextMaxCharacters: Max characters per result (default: 10000)
+
+Best practices:
+- Use specific, detailed queries for better results
+- For technical topics, include relevant terms and context
+- Use 'deep' type for comprehensive research
+- Use 'fast' type for quick fact-checking`;
+function createWebSearchTool(options = {}) {
+  return {
+    name: "WebSearch",
+    description: WEBSEARCH_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query to find relevant information"
+        },
+        numResults: {
+          type: "number",
+          description: "Number of search results to return (default: 8, max: 20)"
+        },
+        livecrawl: {
+          type: "string",
+          enum: ["fallback", "preferred"],
+          description: "Live crawl mode - 'fallback': use live crawling as backup, 'preferred': prioritize live crawling"
+        },
+        type: {
+          type: "string",
+          enum: ["auto", "fast", "deep"],
+          description: "Search type - 'auto': balanced, 'fast': quick results, 'deep': comprehensive"
+        },
+        contextMaxCharacters: {
+          type: "number",
+          description: "Maximum characters for context per result (default: 10000)"
+        }
+      },
+      required: ["query"]
+    },
+    execute: async (rawInput, context) => {
+      const input = rawInput;
+      const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
+      if (!query || typeof query !== "string" || query.trim().length === 0) {
+        return {
+          content: "Error: A non-empty search query is required.",
+          isError: true
+        };
+      }
+      const clampedNumResults = Math.min(Math.max(numResults || API_CONFIG.DEFAULT_NUM_RESULTS, 1), 20);
+      const searchRequest = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: "web_search_exa",
+          arguments: {
+            query: query.trim(),
+            numResults: clampedNumResults,
+            livecrawl: livecrawl || "fallback",
+            type: type || "auto",
+            contextMaxCharacters: contextMaxCharacters || API_CONFIG.DEFAULT_CONTEXT_MAX_CHARS
+          }
+        }
+      };
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), API_CONFIG.TIMEOUT_MS);
+      try {
+        const signal = context.abortSignal ? AbortSignal.any([controller.signal, context.abortSignal]) : controller.signal;
+        const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`, {
+          method: "POST",
+          headers: {
+            Accept: "application/json, text/event-stream",
+            "Content-Type": "application/json",
+            "User-Agent": "FormAgent-SDK/1.0"
+          },
+          body: JSON.stringify(searchRequest),
+          signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text();
+          return {
+            content: `Search error (${response.status}): ${errorText}`,
+            isError: true
+          };
+        }
+        const responseText = await response.text();
+        const lines = responseText.split(`
+`);
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const data = JSON.parse(line.substring(6));
+              if (data.error) {
+                return {
+                  content: `Search API error: ${data.error.message}`,
+                  isError: true
+                };
+              }
+              if (data.result?.content && data.result.content.length > 0) {
+                const resultText = data.result.content[0].text;
+                let output = `## Web Search Results
+
+`;
+                output += `**Query:** ${query}
+`;
+                output += `**Results:** ${clampedNumResults} requested
+
+`;
+                output += `---
+
+`;
+                output += resultText;
+                return {
+                  content: output
+                };
+              }
+            } catch (parseError) {
+              continue;
+            }
+          }
+        }
+        try {
+          const data = JSON.parse(responseText);
+          if (data.result?.content && data.result.content.length > 0) {
+            return {
+              content: data.result.content[0].text
+            };
+          }
+        } catch {}
+        return {
+          content: `No search results found for query: "${query}". Please try a different or more specific query.`
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            return {
+              content: `Search request timed out after ${API_CONFIG.TIMEOUT_MS}ms. Please try again or use a simpler query.`,
+              isError: true
+            };
+          }
+          return {
+            content: `Search failed: ${error.message}`,
+            isError: true
+          };
+        }
+        return {
+          content: `Search failed: ${String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var WebSearchTool = createWebSearchTool();
 // src/tools/builtin/todo.ts
 var globalTodos = [];
 var onTodoChange = null;
@@ -4083,6 +4446,574 @@ function createTodoWriteTool(options = {}) {
   };
 }
 var TodoWriteTool = createTodoWriteTool();
+// src/tools/builtin/askuser.ts
+var globalAskUserHandler = null;
+var ASKUSER_DESCRIPTION = `Ask the user questions to gather information, clarify requirements, or get decisions.
+
+Use this tool when you need to:
+- Gather user preferences or requirements
+- Clarify ambiguous instructions
+- Get decisions on implementation choices
+- Offer choices about what direction to take
+
+Parameters:
+- questions: Array of questions (1-4 questions per call)
+  - question: The question text (required)
+  - header: Short label for display (optional)
+  - options: Array of choices (optional)
+    - label: Display text
+    - description: Explanation of the option
+  - multiSelect: Allow multiple selections (default: false)
+  - defaultValue: Default if no response
+
+Best practices:
+- Keep questions clear and concise
+- Provide options when there are known choices
+- Use multiSelect for non-mutually-exclusive options
+- Limit to 4 questions per call to avoid overwhelming the user`;
+function createAskUserTool(options = {}) {
+  return {
+    name: "AskUser",
+    description: ASKUSER_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        questions: {
+          type: "array",
+          description: "Questions to ask the user (1-4 questions)",
+          items: {
+            type: "object",
+            properties: {
+              question: {
+                type: "string",
+                description: "The question text to display"
+              },
+              header: {
+                type: "string",
+                description: "Short label for the question (max 12 chars)"
+              },
+              options: {
+                type: "array",
+                description: "Available choices (2-4 options)",
+                items: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description: "Display text for this option"
+                    },
+                    description: {
+                      type: "string",
+                      description: "Explanation of what this option means"
+                    }
+                  },
+                  required: ["label"]
+                }
+              },
+              multiSelect: {
+                type: "boolean",
+                description: "Allow multiple selections (default: false)"
+              },
+              defaultValue: {
+                type: "string",
+                description: "Default value if user doesn't respond"
+              }
+            },
+            required: ["question"]
+          },
+          minItems: 1,
+          maxItems: 4
+        }
+      },
+      required: ["questions"]
+    },
+    execute: async (rawInput, context) => {
+      const input = rawInput;
+      const { questions } = input;
+      if (!questions || !Array.isArray(questions) || questions.length === 0) {
+        return {
+          content: "Error: At least one question is required.",
+          isError: true
+        };
+      }
+      if (questions.length > 4) {
+        return {
+          content: "Error: Maximum 4 questions per call. Please split into multiple calls.",
+          isError: true
+        };
+      }
+      if (!globalAskUserHandler) {
+        return {
+          content: `Error: AskUser handler not configured. The SDK user must call setAskUserHandler() to enable user interaction.
+
+Questions that would have been asked:
+${questions.map((q, i) => `${i + 1}. ${q.question}${q.options ? ` [Options: ${q.options.map((o) => o.label).join(", ")}]` : ""}`).join(`
+`)}
+
+To enable this tool, the SDK user should implement an AskUser handler.`,
+          isError: true
+        };
+      }
+      try {
+        const answers = await globalAskUserHandler(questions, context);
+        const formatAnswer = (answer) => {
+          if (answer === undefined || answer === null)
+            return "(no answer)";
+          if (Array.isArray(answer))
+            return answer.join(", ") || "(no answer)";
+          return answer || "(no answer)";
+        };
+        const formattedAnswers = questions.map((q, i) => `Q: "${q.question}"
+A: ${formatAnswer(answers[i])}`).join(`
+
+`);
+        return {
+          content: `User has answered your questions:
+
+${formattedAnswers}
+
+You can now continue with the user's answers in mind.`,
+          metadata: {
+            questions: questions.map((q) => q.question),
+            answers
+          }
+        };
+      } catch (error) {
+        return {
+          content: `Error getting user response: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var AskUserTool = createAskUserTool();
+// src/tools/builtin/batch.ts
+var globalToolResolver = null;
+var DISALLOWED_TOOLS = new Set(["Batch", "batch", "AskUser", "askuser"]);
+var BATCH_DESCRIPTION = `Execute multiple tool calls in parallel for improved performance.
+
+Use this tool when you need to:
+- Read multiple files at once
+- Perform several independent operations
+- Speed up tasks that don't have dependencies
+
+Parameters:
+- tool_calls: Array of tool calls (1-10 calls per batch)
+  - tool: Name of the tool to execute
+  - parameters: Parameters for that tool
+
+Limitations:
+- Maximum 10 tool calls per batch
+- Cannot nest Batch calls (no batch within batch)
+- Cannot batch AskUser (requires sequential interaction)
+- All calls execute in parallel - don't batch dependent operations
+
+Best practices:
+- Group independent operations (e.g., reading multiple unrelated files)
+- Don't batch operations that depend on each other's results
+- Use for bulk file reads, multiple greps, or parallel web fetches
+
+Example:
+{
+  "tool_calls": [
+    { "tool": "Read", "parameters": { "file_path": "/path/to/file1.ts" } },
+    { "tool": "Read", "parameters": { "file_path": "/path/to/file2.ts" } },
+    { "tool": "Grep", "parameters": { "pattern": "TODO", "path": "./src" } }
+  ]
+}`;
+function createBatchTool(options = {}, toolMap) {
+  return {
+    name: "Batch",
+    description: BATCH_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        tool_calls: {
+          type: "array",
+          description: "Array of tool calls to execute in parallel",
+          items: {
+            type: "object",
+            properties: {
+              tool: {
+                type: "string",
+                description: "Name of the tool to execute"
+              },
+              parameters: {
+                type: "object",
+                description: "Parameters for the tool",
+                additionalProperties: true
+              }
+            },
+            required: ["tool", "parameters"]
+          },
+          minItems: 1,
+          maxItems: 10
+        }
+      },
+      required: ["tool_calls"]
+    },
+    execute: async (rawInput, context) => {
+      const input = rawInput;
+      const { tool_calls } = input;
+      if (!tool_calls || !Array.isArray(tool_calls) || tool_calls.length === 0) {
+        return {
+          content: "Error: At least one tool call is required.",
+          isError: true
+        };
+      }
+      const callsToExecute = tool_calls.slice(0, 10);
+      const discardedCalls = tool_calls.slice(10);
+      const executeCall = async (call) => {
+        const startTime = Date.now();
+        try {
+          if (DISALLOWED_TOOLS.has(call.tool)) {
+            return {
+              success: false,
+              tool: call.tool,
+              error: `Tool '${call.tool}' cannot be used in batch. Disallowed: ${Array.from(DISALLOWED_TOOLS).join(", ")}`,
+              duration: Date.now() - startTime
+            };
+          }
+          let toolExecute;
+          if (toolMap) {
+            const tool = toolMap.get(call.tool);
+            if (tool) {
+              toolExecute = tool.execute;
+            }
+          }
+          if (!toolExecute && globalToolResolver) {
+            toolExecute = globalToolResolver(call.tool);
+          }
+          if (!toolExecute) {
+            const availableTools = toolMap ? Array.from(toolMap.keys()).filter((n) => !DISALLOWED_TOOLS.has(n)) : [];
+            return {
+              success: false,
+              tool: call.tool,
+              error: `Tool '${call.tool}' not found.${availableTools.length > 0 ? ` Available: ${availableTools.slice(0, 10).join(", ")}` : ""}`,
+              duration: Date.now() - startTime
+            };
+          }
+          const result = await toolExecute(call.parameters, context);
+          return {
+            success: !result.isError,
+            tool: call.tool,
+            result,
+            duration: Date.now() - startTime
+          };
+        } catch (error) {
+          return {
+            success: false,
+            tool: call.tool,
+            error: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - startTime
+          };
+        }
+      };
+      const results = await Promise.all(callsToExecute.map(executeCall));
+      for (const call of discardedCalls) {
+        results.push({
+          success: false,
+          tool: call.tool,
+          error: "Exceeded maximum of 10 tool calls per batch",
+          duration: 0
+        });
+      }
+      const successCount = results.filter((r) => r.success).length;
+      const failCount = results.length - successCount;
+      const totalDuration = results.reduce((sum, r) => sum + (r.duration || 0), 0);
+      const formatResult = (r, index) => {
+        if (r.success && r.result) {
+          const content = typeof r.result.content === "string" ? r.result.content.slice(0, 500) + (r.result.content.length > 500 ? "..." : "") : JSON.stringify(r.result.content).slice(0, 500);
+          return `[${index + 1}] ${r.tool}: SUCCESS (${r.duration}ms)
+${content}`;
+        } else {
+          return `[${index + 1}] ${r.tool}: FAILED (${r.duration}ms)
+Error: ${r.error}`;
+        }
+      };
+      const resultsOutput = results.map(formatResult).join(`
+
+---
+
+`);
+      const summary = failCount > 0 ? `Batch execution: ${successCount}/${results.length} succeeded, ${failCount} failed (${totalDuration}ms total)` : `Batch execution: All ${successCount} tools succeeded (${totalDuration}ms total)`;
+      return {
+        content: `${summary}
+
+${resultsOutput}`,
+        metadata: {
+          totalCalls: results.length,
+          successful: successCount,
+          failed: failCount,
+          totalDuration,
+          details: results.map((r) => ({
+            tool: r.tool,
+            success: r.success,
+            duration: r.duration,
+            error: r.error
+          }))
+        }
+      };
+    }
+  };
+}
+var BatchTool = createBatchTool();
+// src/tools/builtin/httprequest.ts
+import { lookup as lookup2 } from "node:dns/promises";
+var DEFAULT_TIMEOUT2 = 30000;
+var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+function isPrivateIp(ip) {
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+    const parts = ip.split(".").map(Number);
+    const [a, b] = parts;
+    if (a === 10)
+      return true;
+    if (a === 127)
+      return true;
+    if (a === 0)
+      return true;
+    if (a === 169 && b === 254)
+      return true;
+    if (a === 172 && b >= 16 && b <= 31)
+      return true;
+    if (a === 192 && b === 168)
+      return true;
+    if (a === 100 && b >= 64 && b <= 127)
+      return true;
+    if (a >= 224)
+      return true;
+  }
+  const normalized = ip.toLowerCase();
+  if (normalized === "::" || normalized === "::1")
+    return true;
+  if (normalized.startsWith("fe80:"))
+    return true;
+  if (normalized.startsWith("fc") || normalized.startsWith("fd"))
+    return true;
+  return false;
+}
+async function validateUrl(url, options) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return { valid: false, error: `Invalid URL: ${url}` };
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    return { valid: false, error: `Invalid protocol: ${parsedUrl.protocol}. Only http/https allowed.` };
+  }
+  if (!options.allowPrivateNetwork) {
+    const hostname = parsedUrl.hostname.toLowerCase();
+    if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+      return { valid: false, error: `Blocked: localhost/local hostnames not allowed` };
+    }
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname) && isPrivateIp(hostname)) {
+      return { valid: false, error: `Blocked: private IP address ${hostname}` };
+    }
+    const resolveHostnames = options.resolveHostnames ?? true;
+    if (resolveHostnames) {
+      try {
+        const addrs = await lookup2(hostname, { all: true, verbatim: true });
+        for (const addr of addrs) {
+          if (isPrivateIp(addr.address)) {
+            return { valid: false, error: `Blocked: ${hostname} resolves to private IP ${addr.address}` };
+          }
+        }
+      } catch (e) {
+        return { valid: false, error: `DNS resolution failed for ${hostname}` };
+      }
+    }
+  }
+  return { valid: true, parsedUrl };
+}
+var HTTPREQUEST_DESCRIPTION = `Make HTTP requests to APIs and web services.
+
+Use this tool when you need to:
+- Call REST APIs (GET, POST, PUT, DELETE, etc.)
+- Send data to web services
+- Fetch JSON data from APIs
+- Interact with webhooks
+
+Parameters:
+- method: HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS)
+- url: Full URL to request (required)
+- headers: Request headers as key-value pairs (optional)
+- body: Request body for POST/PUT/PATCH (optional, auto-serialized to JSON)
+- timeout: Request timeout in ms (default: 30000, max: 120000)
+- responseType: Expected response type - 'json', 'text', or 'binary' (default: auto-detect)
+
+Security:
+- Private/local network access is blocked by default
+- Maximum response size: 5MB
+
+Best practices:
+- Include appropriate Content-Type header for POST/PUT requests
+- Handle authentication via headers (Authorization, API keys, etc.)
+- Use responseType: 'json' when expecting JSON response
+
+Example:
+{
+  "method": "POST",
+  "url": "https://api.example.com/data",
+  "headers": {
+    "Authorization": "Bearer token123",
+    "Content-Type": "application/json"
+  },
+  "body": { "name": "test", "value": 42 }
+}`;
+function createHttpRequestTool(options = {}) {
+  return {
+    name: "HttpRequest",
+    description: HTTPREQUEST_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+          description: "HTTP method"
+        },
+        url: {
+          type: "string",
+          description: "URL to request"
+        },
+        headers: {
+          type: "object",
+          description: "Request headers",
+          additionalProperties: { type: "string" }
+        },
+        body: {
+          description: "Request body (auto-serialized to JSON if object)"
+        },
+        timeout: {
+          type: "number",
+          description: "Request timeout in milliseconds (default: 30000, max: 120000)"
+        },
+        responseType: {
+          type: "string",
+          enum: ["json", "text", "binary"],
+          description: "Expected response type (default: auto-detect)"
+        }
+      },
+      required: ["method", "url"]
+    },
+    execute: async (rawInput, context) => {
+      const input = rawInput;
+      const { method, url, headers = {}, body, timeout, responseType } = input;
+      const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+      if (!validMethods.includes(method)) {
+        return {
+          content: `Invalid HTTP method: ${method}. Must be one of: ${validMethods.join(", ")}`,
+          isError: true
+        };
+      }
+      const urlValidation = await validateUrl(url, options);
+      if (!urlValidation.valid) {
+        return {
+          content: urlValidation.error,
+          isError: true
+        };
+      }
+      const requestTimeout = Math.min(timeout ?? DEFAULT_TIMEOUT2, 120000);
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+      const signal = context.abortSignal ? AbortSignal.any([controller.signal, context.abortSignal]) : controller.signal;
+      const requestHeaders = {
+        "User-Agent": "FormAgent-SDK/1.0",
+        ...headers
+      };
+      let requestBody;
+      if (body !== undefined && ["POST", "PUT", "PATCH"].includes(method)) {
+        if (typeof body === "string") {
+          requestBody = body;
+        } else {
+          requestBody = JSON.stringify(body);
+          if (!requestHeaders["Content-Type"] && !requestHeaders["content-type"]) {
+            requestHeaders["Content-Type"] = "application/json";
+          }
+        }
+      }
+      try {
+        const response = await fetch(urlValidation.parsedUrl.toString(), {
+          method,
+          headers: requestHeaders,
+          body: requestBody,
+          signal
+        });
+        clearTimeout(timeoutId);
+        const contentLength = response.headers.get("content-length");
+        if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+          return {
+            content: `Response too large: ${contentLength} bytes (max: ${MAX_RESPONSE_SIZE})`,
+            isError: true
+          };
+        }
+        const contentType = response.headers.get("content-type") || "";
+        let responseBody;
+        let responseText;
+        const effectiveResponseType = responseType || (contentType.includes("application/json") ? "json" : "text");
+        if (effectiveResponseType === "json") {
+          try {
+            responseBody = await response.json();
+            responseText = JSON.stringify(responseBody, null, 2);
+          } catch {
+            responseText = await response.text();
+            responseBody = responseText;
+          }
+        } else if (effectiveResponseType === "binary") {
+          const buffer = await response.arrayBuffer();
+          responseText = `[Binary data: ${buffer.byteLength} bytes]`;
+          responseBody = { type: "binary", size: buffer.byteLength };
+        } else {
+          responseText = await response.text();
+          responseBody = responseText;
+        }
+        if (responseText.length > 1e5) {
+          responseText = responseText.slice(0, 1e5) + `
+
+... (truncated)`;
+        }
+        const statusEmoji = response.ok ? "✓" : "✗";
+        const output = `${statusEmoji} ${method} ${url}
+Status: ${response.status} ${response.statusText}
+Content-Type: ${contentType}
+
+Response:
+${responseText}`;
+        return {
+          content: output,
+          isError: !response.ok,
+          metadata: {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: responseBody
+          }
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            return {
+              content: `Request timed out after ${requestTimeout}ms`,
+              isError: true
+            };
+          }
+          return {
+            content: `Request failed: ${error.message}`,
+            isError: true
+          };
+        }
+        return {
+          content: `Request failed: ${String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var HttpRequestTool = createHttpRequestTool();
 // src/tools/builtin/index.ts
 var builtinTools = [
   BashTool,
@@ -4092,14 +5023,18 @@ var builtinTools = [
   GlobTool,
   GrepTool,
   WebFetchTool,
-  TodoWriteTool
+  WebSearchTool,
+  HttpRequestTool,
+  TodoWriteTool,
+  AskUserTool,
+  BatchTool
 ];
 // src/utils/env.ts
 import { existsSync as existsSync9, readFileSync } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function loadEnvOverride(cwd) {
   const dir = cwd || process.cwd();
-  const envPath = join6(dir, ".env");
+  const envPath = join7(dir, ".env");
   if (!existsSync9(envPath)) {
     return;
   }
@@ -4129,7 +5064,7 @@ function loadEnvOverride(cwd) {
 // src/cli/cli.ts
 loadEnvOverride();
 var VERSION = "0.1.0";
-var SKILLS_PATH = join7(homedir4(), ".claude");
+var SKILLS_PATH = join8(homedir4(), ".claude");
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -4158,7 +5093,7 @@ var totalInputTokens = 0;
 var totalOutputTokens = 0;
 var messageCount = 0;
 function isGitRepo(dir) {
-  return existsSync10(join7(dir, ".git"));
+  return existsSync10(join8(dir, ".git"));
 }
 function getOsVersion() {
   try {
@@ -4206,6 +5141,7 @@ ${c.bold("Interactive Commands:")}
   ${c.cyan("/skills")}   List available skills
   ${c.cyan("/todos")}    Show current todo list
   ${c.cyan("/usage")}    Show token usage statistics
+  ${c.cyan("/debug")}    Show debug info (prompt, model, env)
   ${c.cyan("/exit")}     Exit the CLI
 
 ${c.bold("Environment:")}
@@ -4252,6 +5188,7 @@ function printInteractiveHelp() {
   console.log(`  ${c.cyan("/skills")}   List available skills`);
   console.log(`  ${c.cyan("/todos")}    Show current todo list`);
   console.log(`  ${c.cyan("/usage")}    Show token usage statistics`);
+  console.log(`  ${c.cyan("/debug")}    Show debug info (prompt, model, env)`);
   console.log(`  ${c.cyan("/exit")}     Exit the CLI`);
   console.log();
 }
@@ -4322,6 +5259,62 @@ function printUsage() {
   console.log(`  ${c.cyan("Est. cost:")}     $${(inputCost + outputCost).toFixed(4)}`);
   console.log();
 }
+function printDebug() {
+  const model = getDefaultModel();
+  const tools = getAllTools();
+  const systemPrompt = buildSystemPrompt();
+  const cwd = process.cwd();
+  console.log();
+  console.log(c.bold("═══════════════════════════════════════════════════════════"));
+  console.log(c.bold("                    DEBUG INFORMATION                       "));
+  console.log(c.bold("═══════════════════════════════════════════════════════════"));
+  console.log();
+  console.log(c.bold("Model:"));
+  console.log(`  ${c.cyan("Current:")}        ${model}`);
+  console.log(`  ${c.cyan("ANTHROPIC_MODEL:")} ${process.env.ANTHROPIC_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("OPENAI_MODEL:")}    ${process.env.OPENAI_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("OPENAI_BASE_URL:")} ${process.env.OPENAI_BASE_URL || c.dim("(not set)")}`);
+  console.log();
+  console.log(c.bold("API Keys:"));
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  console.log(`  ${c.cyan("ANTHROPIC_API_KEY:")} ${anthropicKey ? c.green("✓ set") + c.dim(` (${anthropicKey.slice(0, 8)}...${anthropicKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log(`  ${c.cyan("OPENAI_API_KEY:")}    ${openaiKey ? c.green("✓ set") + c.dim(` (${openaiKey.slice(0, 8)}...${openaiKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log();
+  console.log(c.bold("Environment:"));
+  console.log(`  ${c.cyan("Working dir:")}  ${cwd}`);
+  console.log(`  ${c.cyan("Git repo:")}     ${isGitRepo(cwd) ? c.green("Yes") : "No"}`);
+  console.log(`  ${c.cyan("Platform:")}     ${process.platform}`);
+  console.log(`  ${c.cyan("OS Version:")}   ${getOsVersion()}`);
+  console.log(`  ${c.cyan("Shell:")}        ${process.env.SHELL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("Skills path:")}  ${SKILLS_PATH}`);
+  console.log();
+  console.log(c.bold("Tools:") + c.dim(` (${tools.length} total)`));
+  const toolNames = tools.map((t) => t.name);
+  console.log(`  ${toolNames.join(", ")}`);
+  console.log();
+  console.log(c.bold("Session State:"));
+  console.log(`  ${c.cyan("Active:")}         ${session ? c.green("Yes") : "No"}`);
+  console.log(`  ${c.cyan("Messages:")}       ${messageCount}`);
+  console.log(`  ${c.cyan("Input tokens:")}   ${totalInputTokens.toLocaleString()}`);
+  console.log(`  ${c.cyan("Output tokens:")}  ${totalOutputTokens.toLocaleString()}`);
+  console.log();
+  console.log(c.bold("System Prompt:") + c.dim(` (${systemPrompt.length} chars)`));
+  console.log(c.dim("─".repeat(60)));
+  const promptLines = systemPrompt.split(`
+`);
+  const maxLines = 50;
+  for (let i = 0;i < Math.min(promptLines.length, maxLines); i++) {
+    const lineNum = String(i + 1).padStart(3, " ");
+    const line = promptLines[i].slice(0, 75);
+    console.log(`${c.dim(lineNum + "│")} ${line}${promptLines[i].length > 75 ? c.dim("...") : ""}`);
+  }
+  if (promptLines.length > maxLines) {
+    console.log(c.dim(`    ... (${promptLines.length - maxLines} more lines)`));
+  }
+  console.log(c.dim("─".repeat(60)));
+  console.log();
+}
 function formatToolInput(name, input) {
   switch (name) {
     case "Bash":
@@ -4449,6 +5442,9 @@ async function handleInput(input) {
       case "/usage":
         printUsage();
         return true;
+      case "/debug":
+        printDebug();
+        return true;
       case "/exit":
       case "/quit":
       case "/q":