formagent-sdk 0.1.3 → 0.3.0

package/dist/cli/index.js

@@ -5,8 +5,9 @@ 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";
+import { readFileSync as readFileSync2 } from "node:fs";
 
 // src/utils/id.ts
 var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -76,6 +77,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 +420,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 +535,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 +557,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 +658,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 +741,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 +770,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 +1221,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 +1235,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 +1256,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 +1285,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 +1355,7 @@ class SessionImpl {
   _state;
   provider;
   tools;
+  toolNameLookup = new Map;
   emitter;
   pendingMessage = null;
   isReceiving = false;
@@ -1254,6 +1363,7 @@ class SessionImpl {
   closed = false;
   hooksManager = null;
   maxTurns;
+  enableToolRepair = true;
   constructor(id, config, provider, state) {
     this.id = id;
     this.config = config;
@@ -1276,6 +1386,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 +1395,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) {
@@ -1567,8 +1679,18 @@ class SessionImpl {
   async executeToolCall(block, abortSignal) {
     let toolInput = block.input;
     let systemMessage;
+    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 (this.hooksManager) {
-      const preResult = await this.hooksManager.runPreToolUse(block.name, block.input, block.id, abortSignal);
+      const preResult = await this.hooksManager.runPreToolUse(effectiveToolName, block.input, block.id, abortSignal);
       if (!preResult.continue) {
         return {
           type: "tool_result",
@@ -1582,7 +1704,7 @@ class SessionImpl {
         return {
           type: "tool_result",
           tool_use_id: block.id,
-          content: preResult.reason ?? `Tool "${block.name}" was denied by hook`,
+          content: preResult.reason ?? `Tool "${effectiveToolName}" was denied by hook`,
           is_error: true,
           _hookSystemMessage: preResult.systemMessage
         };
@@ -1592,12 +1714,13 @@ class SessionImpl {
       }
       systemMessage = preResult.systemMessage;
     }
-    const tool = this.tools.get(block.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)` : "";
       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 +1733,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",
@@ -1628,7 +1754,7 @@ class SessionImpl {
       };
     }
     if (this.hooksManager) {
-      const postResult = await this.hooksManager.runPostToolUse(block.name, toolInput, toolResponse, block.id, abortSignal);
+      const postResult = await this.hooksManager.runPostToolUse(effectiveToolName, toolInput, toolResponse, block.id, abortSignal);
       if (postResult.systemMessage) {
         systemMessage = postResult.systemMessage;
       }
@@ -2270,7 +2396,7 @@ class OpenAIProvider {
     }
     this.config = {
       apiKey,
-      baseUrl: config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+      baseUrl: this.normalizeBaseUrl(config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"),
       organization: config.organization,
       defaultMaxTokens: config.defaultMaxTokens ?? 4096
     };
@@ -2279,8 +2405,23 @@ class OpenAIProvider {
     return this.supportedModels.some((pattern) => pattern.test(model));
   }
   async complete(request) {
+    if (this.usesResponsesApi(request.config.model)) {
+      const openaiRequest2 = this.buildResponsesRequest(request, false);
+      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(openaiRequest2),
+        signal: request.abortSignal
+      });
+      if (!response2.ok) {
+        const error = await response2.text();
+        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
+      }
+      const data2 = await response2.json();
+      return this.convertResponsesResponse(data2);
+    }
     const openaiRequest = this.buildRequest(request, false);
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
@@ -2288,14 +2429,43 @@ class OpenAIProvider {
     });
     if (!response.ok) {
       const error = await response.text();
+      if (this.shouldFallbackToResponses(response.status, error)) {
+        const fallbackRequest = this.buildResponsesRequest(request, false);
+        response = await fetch(`${this.config.baseUrl}/responses`, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(fallbackRequest),
+          signal: request.abortSignal
+        });
+        if (!response.ok) {
+          const fallbackError = await response.text();
+          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
+        }
+        const data2 = await response.json();
+        return this.convertResponsesResponse(data2);
+      }
       throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options) {
+    if (this.usesResponsesApi(request.config.model)) {
+      const openaiRequest2 = this.buildResponsesRequest(request, true);
+      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(openaiRequest2),
+        signal: request.abortSignal
+      });
+      if (!response2.ok) {
+        const error = await response2.text();
+        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
+      }
+      return this.createResponsesStreamIterator(response2.body, options);
+    }
     const openaiRequest = this.buildRequest(request, true);
-    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
@@ -2303,6 +2473,20 @@ class OpenAIProvider {
     });
     if (!response.ok) {
       const error = await response.text();
+      if (this.shouldFallbackToResponses(response.status, error)) {
+        const fallbackRequest = this.buildResponsesRequest(request, true);
+        response = await fetch(`${this.config.baseUrl}/responses`, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(fallbackRequest),
+          signal: request.abortSignal
+        });
+        if (!response.ok) {
+          const fallbackError = await response.text();
+          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
+        }
+        return this.createResponsesStreamIterator(response.body, options);
+      }
       throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     return this.createStreamIterator(response.body, options);
@@ -2310,10 +2494,10 @@ class OpenAIProvider {
   buildRequest(request, stream) {
     const messages = this.convertMessages(request.messages, request.systemPrompt);
     const tools = request.tools ? this.convertTools(request.tools) : undefined;
-    return {
+    const maxTokens = request.config.maxTokens ?? this.config.defaultMaxTokens;
+    const openaiRequest = {
       model: request.config.model,
       messages,
-      max_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
       temperature: request.config.temperature,
       top_p: request.config.topP,
       stop: request.config.stopSequences,
@@ -2321,6 +2505,162 @@ class OpenAIProvider {
       stream_options: stream ? { include_usage: true } : undefined,
       tools
     };
+    if (this.usesMaxCompletionTokens(request.config.model)) {
+      openaiRequest.max_completion_tokens = maxTokens;
+    } else {
+      openaiRequest.max_tokens = maxTokens;
+    }
+    return openaiRequest;
+  }
+  buildResponsesRequest(request, stream) {
+    const input = this.convertResponsesInput(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertResponsesTools(request.tools) : undefined;
+    return {
+      model: request.config.model,
+      input,
+      max_output_tokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+      temperature: request.config.temperature,
+      top_p: request.config.topP,
+      stop: request.config.stopSequences,
+      stream,
+      tools
+    };
+  }
+  usesMaxCompletionTokens(model) {
+    return /^gpt-5/.test(model) || /^o1/.test(model);
+  }
+  usesResponsesApi(model) {
+    return /^gpt-5/.test(model) || /^o1/.test(model);
+  }
+  shouldFallbackToResponses(status, errorText) {
+    if (status !== 404) {
+      return false;
+    }
+    const normalized = errorText.toLowerCase();
+    return normalized.includes("/chat/completions") && normalized.includes("not found");
+  }
+  convertResponsesInput(messages, systemPrompt) {
+    const input = [];
+    if (systemPrompt) {
+      input.push({ role: "system", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        input.push({
+          role: "system",
+          content: typeof msg.content === "string" ? msg.content : ""
+        });
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        if (msg.role === "user") {
+          input.push({
+            role: "user",
+            content: [{ type: "input_text", text: msg.content }]
+          });
+        } else {
+          input.push({
+            role: "assistant",
+            content: [{ type: "output_text", text: msg.content }]
+          });
+        }
+        continue;
+      }
+      const userContent = [];
+      const assistantContent = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          if (msg.role === "user") {
+            userContent.push({ type: "input_text", text: block.text });
+          } else if (msg.role === "assistant") {
+            assistantContent.push({ type: "output_text", text: block.text });
+          }
+        } else if (block.type === "image" && msg.role === "user") {
+          if (block.source.type === "base64") {
+            userContent.push({
+              type: "input_image",
+              image_url: `data:${block.source.media_type};base64,${block.source.data}`
+            });
+          } else if (block.source.type === "url") {
+            userContent.push({
+              type: "input_image",
+              image_url: block.source.url
+            });
+          }
+        } else if (block.type === "tool_use") {
+          input.push({
+            type: "function_call",
+            call_id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          });
+        } else if (block.type === "tool_result") {
+          input.push({
+            type: "function_call_output",
+            call_id: block.tool_use_id,
+            output: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+          });
+        }
+      }
+      if (msg.role === "user" && userContent.length > 0) {
+        input.push({ role: "user", content: userContent });
+      } else if (msg.role === "assistant" && assistantContent.length > 0) {
+        input.push({ role: "assistant", content: assistantContent });
+      }
+    }
+    return input;
+  }
+  convertResponsesResponse(data) {
+    const content = [];
+    for (const item of data.output ?? []) {
+      if (item.type === "message" && item.content) {
+        for (const part of item.content) {
+          if (part.type === "output_text") {
+            content.push({ type: "text", text: part.text });
+          }
+        }
+      } else if (item.type === "function_call" && item.call_id && item.name) {
+        content.push({
+          type: "tool_use",
+          id: item.call_id,
+          name: item.name,
+          input: item.arguments ? JSON.parse(item.arguments) : {}
+        });
+      }
+    }
+    return {
+      id: data.id,
+      model: data.model,
+      content,
+      stopReason: "end_turn",
+      stopSequence: null,
+      usage: {
+        input_tokens: data.usage?.input_tokens ?? 0,
+        output_tokens: data.usage?.output_tokens ?? 0
+      }
+    };
+  }
+  normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, "");
+    try {
+      const url = new URL(trimmed);
+      const path2 = url.pathname.replace(/\/+$/, "");
+      if (path2 === "" || path2 === "/") {
+        url.pathname = "/v1";
+        return url.toString().replace(/\/+$/, "");
+      }
+      if (path2.endsWith("/openai")) {
+        url.pathname = `${path2}/v1`;
+        return url.toString().replace(/\/+$/, "");
+      }
+      if (!/\/v\d/.test(path2)) {
+        url.pathname = `${path2}/v1`;
+        return url.toString().replace(/\/+$/, "");
+      }
+      return url.toString().replace(/\/+$/, "");
+    } catch {
+      return trimmed;
+    }
   }
   convertMessages(messages, systemPrompt) {
     const result = [];
@@ -2403,6 +2743,14 @@ class OpenAIProvider {
       }
     }));
   }
+  convertResponsesTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+  }
   convertResponse(data) {
     const choice = data.choices[0];
     const content = [];
@@ -2615,6 +2963,221 @@ class OpenAIProvider {
       }
     };
   }
+  createResponsesStreamIterator(body, options) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let emittedMessageStart = false;
+        let textBlockStarted = false;
+        let finished = false;
+        const toolCalls = new Map;
+        let nextToolBlockIndex = 1;
+        const ensureMessageStart = (id, model) => {
+          if (emittedMessageStart)
+            return;
+          emittedMessageStart = true;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: id ?? "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: model ?? "",
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          return startEvent;
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.startsWith("data: "))
+                continue;
+              const data = line.slice(6).trim();
+              if (!data)
+                continue;
+              if (data === "[DONE]") {
+                if (!finished) {
+                  const stopEvent = { type: "message_stop" };
+                  options?.onEvent?.(stopEvent);
+                  yield stopEvent;
+                }
+                finished = true;
+                continue;
+              }
+              let payload;
+              try {
+                payload = JSON.parse(data);
+              } catch {
+                continue;
+              }
+              const type = payload?.type;
+              if (type === "response.created") {
+                const startEvent = ensureMessageStart(payload.response?.id, payload.response?.model);
+                if (startEvent)
+                  yield startEvent;
+                continue;
+              }
+              if (!emittedMessageStart) {
+                const startEvent = ensureMessageStart(payload?.response?.id, payload?.response?.model);
+                if (startEvent)
+                  yield startEvent;
+              }
+              if (type === "response.output_text.delta") {
+                if (!textBlockStarted) {
+                  textBlockStarted = true;
+                  const startText = {
+                    type: "content_block_start",
+                    index: 0,
+                    content_block: { type: "text", text: "" }
+                  };
+                  options?.onEvent?.(startText);
+                  yield startText;
+                }
+                const textDelta = payload.delta ?? "";
+                if (textDelta) {
+                  const textEvent = {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text: textDelta }
+                  };
+                  options?.onText?.(textDelta);
+                  options?.onEvent?.(textEvent);
+                  yield textEvent;
+                }
+              } else if (type === "response.output_item.added") {
+                const item = payload.item;
+                if (item?.type === "function_call") {
+                  const blockIndex = nextToolBlockIndex++;
+                  const callId = item.call_id ?? item.id ?? "";
+                  toolCalls.set(item.id, {
+                    callId,
+                    name: item.name ?? "",
+                    arguments: item.arguments ?? "",
+                    blockIndex,
+                    done: false
+                  });
+                  const startEvent = {
+                    type: "content_block_start",
+                    index: blockIndex,
+                    content_block: {
+                      type: "tool_use",
+                      id: callId,
+                      name: item.name ?? "",
+                      input: {}
+                    }
+                  };
+                  options?.onEvent?.(startEvent);
+                  yield startEvent;
+                  if (item.arguments) {
+                    const deltaEvent = {
+                      type: "content_block_delta",
+                      index: blockIndex,
+                      delta: {
+                        type: "input_json_delta",
+                        partial_json: item.arguments
+                      }
+                    };
+                    options?.onEvent?.(deltaEvent);
+                    yield deltaEvent;
+                  }
+                }
+              } else if (type === "response.function_call_arguments.delta") {
+                const entry = toolCalls.get(payload.item_id);
+                if (entry && payload.delta) {
+                  entry.arguments += payload.delta;
+                  const deltaEvent = {
+                    type: "content_block_delta",
+                    index: entry.blockIndex,
+                    delta: { type: "input_json_delta", partial_json: payload.delta }
+                  };
+                  options?.onEvent?.(deltaEvent);
+                  yield deltaEvent;
+                }
+              } else if (type === "response.output_item.done") {
+                const item = payload.item;
+                if (item?.type === "function_call") {
+                  const entry = toolCalls.get(item.id);
+                  if (entry && !entry.done) {
+                    entry.done = true;
+                    const stopEvent = {
+                      type: "content_block_stop",
+                      index: entry.blockIndex
+                    };
+                    options?.onEvent?.(stopEvent);
+                    yield stopEvent;
+                    try {
+                      const input = entry.arguments ? JSON.parse(entry.arguments) : {};
+                      options?.onToolUse?.({ id: entry.callId, name: entry.name, input });
+                    } catch {
+                      options?.onToolUse?.({ id: entry.callId, name: entry.name, input: {} });
+                    }
+                  }
+                }
+              } else if (type === "response.completed" || type === "response.incomplete") {
+                finished = true;
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                for (const entry of toolCalls.values()) {
+                  if (entry.done)
+                    continue;
+                  entry.done = true;
+                  const stopEvent2 = {
+                    type: "content_block_stop",
+                    index: entry.blockIndex
+                  };
+                  options?.onEvent?.(stopEvent2);
+                  yield stopEvent2;
+                  try {
+                    const input = entry.arguments ? JSON.parse(entry.arguments) : {};
+                    options?.onToolUse?.({ id: entry.callId, name: entry.name, input });
+                  } catch {
+                    options?.onToolUse?.({ id: entry.callId, name: entry.name, input: {} });
+                  }
+                }
+                const finishReason = payload.response?.incomplete_details?.reason;
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertResponsesStopReason(finishReason),
+                    stop_sequence: null
+                  },
+                  usage: {
+                    output_tokens: payload.response?.usage?.output_tokens ?? 0,
+                    input_tokens: payload.response?.usage?.input_tokens ?? 0
+                  }
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+    };
+  }
   getHeaders() {
     const headers = {
       "Content-Type": "application/json",
@@ -2625,71 +3188,675 @@ class OpenAIProvider {
     }
     return headers;
   }
-}
-
-// src/api.ts
-var globalManager = null;
-var defaultProvider = null;
-var defaultStorage = null;
-function getGlobalManager() {
-  if (!globalManager) {
-    if (!defaultProvider) {
-      if (process.env.ANTHROPIC_API_KEY) {
-        defaultProvider = new AnthropicProvider;
-      } else if (process.env.OPENAI_API_KEY) {
-        defaultProvider = new OpenAIProvider({
-          apiKey: process.env.OPENAI_API_KEY,
-          baseUrl: process.env.OPENAI_BASE_URL
-        });
-      } else {
-        throw new Error("No default provider set. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
-      }
-    }
-    globalManager = new SessionManagerImpl({
-      provider: defaultProvider,
-      storage: defaultStorage ?? new MemorySessionStorage
-    });
-  }
-  return globalManager;
-}
-async function createSession(options) {
-  if (options?.provider || options?.sessionStorage) {
-    let provider = options?.provider ?? defaultProvider;
-    if (!provider) {
-      if (process.env.ANTHROPIC_API_KEY) {
-        provider = new AnthropicProvider;
-      } else if (process.env.OPENAI_API_KEY) {
-        provider = new OpenAIProvider({
-          apiKey: process.env.OPENAI_API_KEY,
-          baseUrl: process.env.OPENAI_BASE_URL
-        });
-      } else {
-        throw new Error("No provider available. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
-      }
+  convertResponsesStopReason(reason) {
+    if (reason === "max_output_tokens") {
+      return "max_tokens";
     }
-    const customManager = new SessionManagerImpl({
-      provider,
-      storage: options?.sessionStorage ?? defaultStorage ?? new MemorySessionStorage
-    });
-    return customManager.create(options);
+    return "end_turn";
   }
-  const manager = getGlobalManager();
-  return manager.create(options);
 }
 
-// src/tools/registry.ts
-class ToolRegistry {
-  tools = new Map;
-  register(tool) {
-    this.tools.set(tool.id, tool);
-  }
-  unregister(toolId) {
-    this.tools.delete(toolId);
+// src/llm/gemini.ts
+class GeminiProvider {
+  id = "gemini";
+  name = "Gemini";
+  supportedModels = [/^gemini-/, /^models\/gemini-/];
+  config;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      throw new Error("Gemini API key is required. Set GEMINI_API_KEY/GOOGLE_API_KEY or pass apiKey in config.");
+    }
+    this.config = {
+      apiKey,
+      baseUrl: config.baseUrl ?? process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta",
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+    };
   }
-  get(toolId) {
-    return this.tools.get(toolId);
+  supportsModel(model) {
+    return this.supportedModels.some((pattern) => pattern.test(model));
   }
-  getAll() {
+  async complete(request) {
+    const geminiRequest = this.buildRequest(request);
+    const url = this.buildUrl(this.getModelPath(request.config.model) + ":generateContent");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(geminiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return this.convertResponse(data, request.config.model);
+  }
+  async stream(request, options) {
+    const geminiRequest = this.buildRequest(request);
+    const url = this.buildUrl(this.getModelPath(request.config.model) + ":streamGenerateContent", {
+      alt: "sse"
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(geminiRequest),
+      signal: request.abortSignal
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${error}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("text/event-stream")) {
+      const data = await response.json();
+      return this.createResponseIterator(data, options, request.config.model);
+    }
+    return this.createStreamIterator(response.body, options, request.config.model);
+  }
+  buildRequest(request) {
+    const { contents, systemInstruction } = this.convertMessages(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    return {
+      contents,
+      systemInstruction,
+      generationConfig: {
+        temperature: request.config.temperature,
+        topP: request.config.topP,
+        maxOutputTokens: request.config.maxTokens ?? this.config.defaultMaxTokens,
+        stopSequences: request.config.stopSequences
+      },
+      tools,
+      toolConfig: tools ? { functionCallingConfig: { mode: "AUTO" } } : undefined
+    };
+  }
+  convertMessages(messages, systemPrompt) {
+    const contents = [];
+    const systemTexts = [];
+    const toolNameById = new Map;
+    for (const msg of messages) {
+      if (typeof msg.content !== "string") {
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            toolNameById.set(block.id, block.name);
+          }
+        }
+      }
+    }
+    if (systemPrompt) {
+      systemTexts.push(systemPrompt);
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        if (typeof msg.content === "string") {
+          systemTexts.push(msg.content);
+        } else {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              systemTexts.push(block.text);
+            }
+          }
+        }
+        continue;
+      }
+      if (typeof msg.content === "string") {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts: [{ text: msg.content }]
+        });
+        continue;
+      }
+      const parts = [];
+      const toolResponses = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "image") {
+          if (block.source.type === "base64") {
+            parts.push({
+              inlineData: {
+                mimeType: block.source.media_type ?? "image/jpeg",
+                data: block.source.data ?? ""
+              }
+            });
+          } else if (block.source.type === "url") {
+            parts.push({
+              fileData: {
+                mimeType: block.source.media_type ?? "image/jpeg",
+                fileUri: block.source.url ?? ""
+              }
+            });
+          }
+        } else if (block.type === "tool_result") {
+          const toolName = toolNameById.get(block.tool_use_id) ?? "tool";
+          const output = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+          toolResponses.push({
+            functionResponse: {
+              name: toolName,
+              response: { output }
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({
+          role: msg.role === "assistant" ? "model" : "user",
+          parts
+        });
+      }
+      if (toolResponses.length > 0) {
+        contents.push({
+          role: "user",
+          parts: toolResponses
+        });
+      }
+    }
+    const systemInstruction = systemTexts.length > 0 ? { parts: [{ text: systemTexts.join(`
+
+`) }] } : undefined;
+    return { contents, systemInstruction };
+  }
+  convertTools(tools) {
+    return [
+      {
+        functionDeclarations: tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: this.sanitizeSchema(tool.inputSchema)
+        }))
+      }
+    ];
+  }
+  sanitizeSchema(schema) {
+    const visited = new WeakMap;
+    const scrub = (value) => {
+      if (value === null || typeof value !== "object") {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => scrub(item));
+      }
+      const existing = visited.get(value);
+      if (existing) {
+        return existing;
+      }
+      const result = {};
+      visited.set(value, result);
+      for (const [key, inner] of Object.entries(value)) {
+        if (key === "additionalProperties") {
+          continue;
+        }
+        result[key] = scrub(inner);
+      }
+      return result;
+    };
+    return scrub(schema);
+  }
+  convertResponse(data, model) {
+    const candidate = data.candidates?.[0];
+    const content = [];
+    const parts = candidate?.content?.parts ?? [];
+    let toolIndex = 0;
+    for (const part of parts) {
+      if ("text" in part && part.text) {
+        content.push({ type: "text", text: part.text });
+      } else if ("functionCall" in part && part.functionCall) {
+        const callId = `${part.functionCall.name}_${toolIndex++}`;
+        content.push({
+          type: "tool_use",
+          id: callId,
+          name: part.functionCall.name,
+          input: part.functionCall.args ?? {}
+        });
+      }
+    }
+    return {
+      id: "",
+      model: data.model ?? model,
+      content,
+      stopReason: this.convertStopReason(candidate?.finishReason),
+      stopSequence: null,
+      usage: this.convertUsage(data.usageMetadata)
+    };
+  }
+  convertUsage(usage) {
+    return {
+      input_tokens: usage?.promptTokenCount ?? 0,
+      output_tokens: usage?.candidatesTokenCount ?? 0
+    };
+  }
+  convertStopReason(reason) {
+    switch (reason) {
+      case "MAX_TOKENS":
+        return "max_tokens";
+      case "STOP":
+        return "end_turn";
+      default:
+        return "end_turn";
+    }
+  }
+  createStreamIterator(body, options, model) {
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const reader = body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let emittedMessageStart = false;
+        let textBlockStarted = false;
+        let finished = false;
+        let toolIndex = 0;
+        let emittedAny = false;
+        const emitMessageStart = (modelId) => {
+          if (emittedMessageStart)
+            return;
+          emittedMessageStart = true;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: modelId,
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          return startEvent;
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed)
+                continue;
+              let jsonText = trimmed;
+              if (trimmed.startsWith("data:")) {
+                jsonText = trimmed.slice(5).trim();
+              }
+              let payload;
+              try {
+                payload = JSON.parse(jsonText);
+              } catch {
+                continue;
+              }
+              const startEvent = emitMessageStart(payload.model ?? model);
+              if (startEvent) {
+                yield startEvent;
+                emittedAny = true;
+              }
+              const candidate = payload.candidates?.[0];
+              const parts = candidate?.content?.parts ?? [];
+              for (const part of parts) {
+                if ("text" in part && part.text) {
+                  if (!textBlockStarted) {
+                    textBlockStarted = true;
+                    const startText = {
+                      type: "content_block_start",
+                      index: 0,
+                      content_block: { type: "text", text: "" }
+                    };
+                    options?.onEvent?.(startText);
+                    yield startText;
+                    emittedAny = true;
+                  }
+                  const textEvent = {
+                    type: "content_block_delta",
+                    index: 0,
+                    delta: { type: "text_delta", text: part.text }
+                  };
+                  options?.onText?.(part.text);
+                  options?.onEvent?.(textEvent);
+                  yield textEvent;
+                  emittedAny = true;
+                } else if ("functionCall" in part && part.functionCall) {
+                  const callId = `${part.functionCall.name}_${toolIndex}`;
+                  const blockIndex = 1 + toolIndex;
+                  toolIndex += 1;
+                  const startTool = {
+                    type: "content_block_start",
+                    index: blockIndex,
+                    content_block: {
+                      type: "tool_use",
+                      id: callId,
+                      name: part.functionCall.name,
+                      input: {}
+                    }
+                  };
+                  options?.onEvent?.(startTool);
+                  yield startTool;
+                  emittedAny = true;
+                  const args = JSON.stringify(part.functionCall.args ?? {});
+                  if (args) {
+                    const deltaEvent = {
+                      type: "content_block_delta",
+                      index: blockIndex,
+                      delta: { type: "input_json_delta", partial_json: args }
+                    };
+                    options?.onEvent?.(deltaEvent);
+                    yield deltaEvent;
+                    emittedAny = true;
+                  }
+                  const stopTool = {
+                    type: "content_block_stop",
+                    index: blockIndex
+                  };
+                  options?.onEvent?.(stopTool);
+                  yield stopTool;
+                  emittedAny = true;
+                  options?.onToolUse?.({
+                    id: callId,
+                    name: part.functionCall.name,
+                    input: part.functionCall.args ?? {}
+                  });
+                  emittedAny = true;
+                }
+              }
+              if (candidate?.finishReason && !finished) {
+                finished = true;
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertStopReason(candidate.finishReason),
+                    stop_sequence: null
+                  },
+                  usage: self.convertUsage(payload.usageMetadata)
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                emittedAny = true;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+                emittedAny = true;
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        if (!emittedAny) {
+          const trimmed = buffer.trim();
+          if (trimmed) {
+            try {
+              const parsed = JSON.parse(trimmed);
+              const responses = Array.isArray(parsed) ? parsed : [parsed];
+              for (const payload of responses) {
+                const startEvent = emitMessageStart(payload.model ?? model);
+                if (startEvent) {
+                  yield startEvent;
+                }
+                const candidate = payload.candidates?.[0];
+                const parts = candidate?.content?.parts ?? [];
+                for (const part of parts) {
+                  if ("text" in part && part.text) {
+                    if (!textBlockStarted) {
+                      textBlockStarted = true;
+                      const startText = {
+                        type: "content_block_start",
+                        index: 0,
+                        content_block: { type: "text", text: "" }
+                      };
+                      options?.onEvent?.(startText);
+                      yield startText;
+                    }
+                    const textEvent = {
+                      type: "content_block_delta",
+                      index: 0,
+                      delta: { type: "text_delta", text: part.text }
+                    };
+                    options?.onText?.(part.text);
+                    options?.onEvent?.(textEvent);
+                    yield textEvent;
+                  }
+                }
+                if (textBlockStarted) {
+                  const stopText = { type: "content_block_stop", index: 0 };
+                  options?.onEvent?.(stopText);
+                  yield stopText;
+                }
+                const messageDelta = {
+                  type: "message_delta",
+                  delta: {
+                    stop_reason: self.convertStopReason(candidate?.finishReason),
+                    stop_sequence: null
+                  },
+                  usage: self.convertUsage(payload.usageMetadata)
+                };
+                options?.onEvent?.(messageDelta);
+                yield messageDelta;
+                const stopEvent = { type: "message_stop" };
+                options?.onEvent?.(stopEvent);
+                yield stopEvent;
+              }
+              return;
+            } catch {}
+          }
+        }
+        if (!finished) {
+          if (textBlockStarted) {
+            const stopText = { type: "content_block_stop", index: 0 };
+            options?.onEvent?.(stopText);
+            yield stopText;
+          }
+          const stopEvent = { type: "message_stop" };
+          options?.onEvent?.(stopEvent);
+          yield stopEvent;
+        }
+      }
+    };
+  }
+  createResponseIterator(data, options, model) {
+    const responses = Array.isArray(data) ? data : [data];
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        for (const payload of responses) {
+          const candidate = payload.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          let textIndex = 0;
+          let toolIndex = 0;
+          const startEvent = {
+            type: "message_start",
+            message: {
+              id: "",
+              type: "message",
+              role: "assistant",
+              content: [],
+              model: payload.model ?? model,
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          };
+          options?.onEvent?.(startEvent);
+          yield startEvent;
+          for (const part of parts) {
+            if ("text" in part && part.text) {
+              const startText = {
+                type: "content_block_start",
+                index: textIndex,
+                content_block: { type: "text", text: "" }
+              };
+              options?.onEvent?.(startText);
+              yield startText;
+              const textEvent = {
+                type: "content_block_delta",
+                index: textIndex,
+                delta: { type: "text_delta", text: part.text }
+              };
+              options?.onText?.(part.text);
+              options?.onEvent?.(textEvent);
+              yield textEvent;
+              const stopText = { type: "content_block_stop", index: textIndex };
+              options?.onEvent?.(stopText);
+              yield stopText;
+              textIndex += 1;
+            } else if ("functionCall" in part && part.functionCall) {
+              const callId = `${part.functionCall.name}_${toolIndex}`;
+              const blockIndex = textIndex + toolIndex + 1;
+              toolIndex += 1;
+              const startTool = {
+                type: "content_block_start",
+                index: blockIndex,
+                content_block: {
+                  type: "tool_use",
+                  id: callId,
+                  name: part.functionCall.name,
+                  input: {}
+                }
+              };
+              options?.onEvent?.(startTool);
+              yield startTool;
+              const args = JSON.stringify(part.functionCall.args ?? {});
+              if (args) {
+                const deltaEvent = {
+                  type: "content_block_delta",
+                  index: blockIndex,
+                  delta: { type: "input_json_delta", partial_json: args }
+                };
+                options?.onEvent?.(deltaEvent);
+                yield deltaEvent;
+              }
+              const stopTool = { type: "content_block_stop", index: blockIndex };
+              options?.onEvent?.(stopTool);
+              yield stopTool;
+              options?.onToolUse?.({
+                id: callId,
+                name: part.functionCall.name,
+                input: part.functionCall.args ?? {}
+              });
+            }
+          }
+          const messageDelta = {
+            type: "message_delta",
+            delta: {
+              stop_reason: self.convertStopReason(candidate?.finishReason),
+              stop_sequence: null
+            },
+            usage: self.convertUsage(payload.usageMetadata)
+          };
+          options?.onEvent?.(messageDelta);
+          yield messageDelta;
+          const stopEvent = { type: "message_stop" };
+          options?.onEvent?.(stopEvent);
+          yield stopEvent;
+        }
+      }
+    };
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-goog-api-key": this.config.apiKey
+    };
+  }
+  buildUrl(path2, params) {
+    const base = this.config.baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/${path2.replace(/^\/+/, "")}`);
+    if (!url.searchParams.has("key")) {
+      url.searchParams.set("key", this.config.apiKey);
+    }
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  getModelPath(model) {
+    return model.startsWith("models/") ? model : `models/${model}`;
+  }
+}
+
+// src/api.ts
+var globalManager = null;
+var defaultProvider = null;
+var defaultStorage = null;
+function getGlobalManager() {
+  if (!globalManager) {
+    if (!defaultProvider) {
+      if (process.env.ANTHROPIC_API_KEY) {
+        defaultProvider = new AnthropicProvider;
+      } else if (process.env.OPENAI_API_KEY) {
+        defaultProvider = new OpenAIProvider({
+          apiKey: process.env.OPENAI_API_KEY,
+          baseUrl: process.env.OPENAI_BASE_URL
+        });
+      } else if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+        defaultProvider = new GeminiProvider({
+          apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+          baseUrl: process.env.GEMINI_BASE_URL
+        });
+      } else {
+        throw new Error("No default provider set. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
+      }
+    }
+    globalManager = new SessionManagerImpl({
+      provider: defaultProvider,
+      storage: defaultStorage ?? new MemorySessionStorage
+    });
+  }
+  return globalManager;
+}
+async function createSession(options) {
+  if (options?.provider || options?.sessionStorage) {
+    let provider = options?.provider ?? defaultProvider;
+    if (!provider) {
+      if (process.env.ANTHROPIC_API_KEY) {
+        provider = new AnthropicProvider;
+      } else if (process.env.OPENAI_API_KEY) {
+        provider = new OpenAIProvider({
+          apiKey: process.env.OPENAI_API_KEY,
+          baseUrl: process.env.OPENAI_BASE_URL
+        });
+      } else if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+        provider = new GeminiProvider({
+          apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+          baseUrl: process.env.GEMINI_BASE_URL
+        });
+      } else {
+        throw new Error("No provider available. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable, " + "call setDefaultProvider(), or pass a provider in the options.");
+      }
+    }
+    const customManager = new SessionManagerImpl({
+      provider,
+      storage: options?.sessionStorage ?? defaultStorage ?? new MemorySessionStorage
+    });
+    return customManager.create(options);
+  }
+  const manager = getGlobalManager();
+  return manager.create(options);
+}
+
+// src/tools/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    this.tools.set(tool.id, tool);
+  }
+  unregister(toolId) {
+    this.tools.delete(toolId);
+  }
+  get(toolId) {
+    return this.tools.get(toolId);
+  }
+  getAll() {
     return Array.from(this.tools.values());
   }
   clear() {
@@ -2828,24 +3995,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 +4036,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 +4081,7 @@ class ToolManager {
   }
   clear() {
     this.tools.clear();
+    this.toolNameLookup.clear();
   }
   async registerMCPServer(server) {
     const wrapper = new MCPServerWrapper(server);
@@ -2881,6 +4089,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 +4101,7 @@ class ToolManager {
           const parsed = parseMCPToolName(name);
           if (parsed?.serverName === serverName) {
             this.tools.delete(name);
+            this.toolNameLookup.delete(name.toLowerCase());
           }
         }
       }
@@ -2903,9 +4113,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) {
+      tool = this.get(name);
+    }
     if (!tool) {
-      throw new Error(`Tool not found: ${name}`);
+      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 +4138,7 @@ class ToolManager {
     this.emitEvent({
       type: "tool_start",
       toolId,
-      toolName: name,
+      toolName: effectiveName,
       input
     });
     try {
@@ -3220,869 +4444,1618 @@ var BINARY_EXTENSIONS = new Set([
 function createReadTool(options = {}) {
   const maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
   return {
-    name: "Read",
-    description: `Read file contents. Supports text files with optional line range. Returns line numbers in output. For images/PDFs, returns metadata only.`,
+    name: "Read",
+    description: `Read file contents. Supports text files with optional line range. Returns line numbers in output. For images/PDFs, returns metadata only.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to read"
+        },
+        offset: {
+          type: "number",
+          description: "Line number to start reading from (1-indexed)"
+        },
+        limit: {
+          type: "number",
+          description: "Number of lines to read (default: 2000)"
+        }
+      },
+      required: ["file_path"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { file_path, offset = 1, limit = DEFAULT_LINE_LIMIT } = input;
+      const access = checkPathAccess(file_path, options, "file");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      if (!existsSync4(access.resolved)) {
+        return {
+          content: `File not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      const fileStat = await stat(access.resolved);
+      if (fileStat.size > maxFileSize) {
+        return {
+          content: `File too large: ${fileStat.size} bytes (max: ${maxFileSize} bytes)`,
+          isError: true
+        };
+      }
+      const ext = extname(access.resolved).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        return {
+          content: `Binary file: ${access.resolved}
+Size: ${fileStat.size} bytes
+Type: ${ext}`
+        };
+      }
+      try {
+        const content = await readFile3(access.resolved, "utf-8");
+        const lines = content.split(`
+`);
+        const startLine = Math.max(1, offset);
+        const endLine = Math.min(lines.length, startLine + limit - 1);
+        const outputLines = [];
+        for (let i = startLine - 1;i < endLine; i++) {
+          const lineNum = i + 1;
+          let line = lines[i];
+          if (line.length > MAX_LINE_LENGTH) {
+            line = line.slice(0, MAX_LINE_LENGTH) + "...";
+          }
+          const padding = String(endLine).length;
+          outputLines.push(`${String(lineNum).padStart(padding)}→${line}`);
+        }
+        let header = "";
+        if (startLine > 1 || endLine < lines.length) {
+          header = `[Lines ${startLine}-${endLine} of ${lines.length}]
+
+`;
+        }
+        return {
+          content: header + outputLines.join(`
+`)
+        };
+      } catch (error) {
+        return {
+          content: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var ReadTool = createReadTool();
+// src/tools/builtin/write.ts
+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 = {}) {
+  return {
+    name: "Write",
+    description: `Write content to a file. Creates parent directories if needed. Overwrites existing files. Use Edit tool for modifying existing files.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Absolute path to the file to write"
+        },
+        content: {
+          type: "string",
+          description: "Content to write to the file"
+        }
+      },
+      required: ["file_path", "content"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { file_path, content } = input;
+      const access = checkPathAccess(file_path, options, "file");
+      if (!access.ok) {
+        return { content: access.error, isError: true };
+      }
+      try {
+        const dir = dirname3(access.resolved);
+        if (!existsSync5(dir)) {
+          await mkdir2(dir, { recursive: true });
+        }
+        await writeFile2(access.resolved, content, "utf-8");
+        const lines = content.split(`
+`).length;
+        const bytes = Buffer.byteLength(content, "utf-8");
+        return {
+          content: `Successfully wrote ${bytes} bytes (${lines} lines) to ${access.resolved}`
+        };
+      } catch (error) {
+        return {
+          content: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var WriteTool = createWriteTool();
+// src/tools/builtin/edit.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+function createEditTool(options = {}) {
+  return {
+    name: "Edit",
+    description: `Edit a file by replacing text. Finds old_string and replaces with new_string. The old_string must be unique in the file unless replace_all is true.`,
     inputSchema: {
       type: "object",
       properties: {
         file_path: {
           type: "string",
-          description: "Absolute path to the file to read"
+          description: "Absolute path to the file to edit"
         },
-        offset: {
-          type: "number",
-          description: "Line number to start reading from (1-indexed)"
+        old_string: {
+          type: "string",
+          description: "Text to find and replace"
         },
-        limit: {
-          type: "number",
-          description: "Number of lines to read (default: 2000)"
+        new_string: {
+          type: "string",
+          description: "Replacement text"
+        },
+        replace_all: {
+          type: "boolean",
+          description: "Replace all occurrences (default: false)",
+          default: false
         }
       },
-      required: ["file_path"]
+      required: ["file_path", "old_string", "new_string"]
     },
     execute: async (rawInput, _context) => {
       const input = rawInput;
-      const { file_path, offset = 1, limit = DEFAULT_LINE_LIMIT } = input;
+      const { file_path, old_string, new_string, replace_all = false } = input;
       const access = checkPathAccess(file_path, options, "file");
       if (!access.ok) {
         return { content: access.error, isError: true };
       }
-      if (!existsSync4(access.resolved)) {
+      if (!existsSync6(access.resolved)) {
         return {
           content: `File not found: ${access.resolved}`,
           isError: true
         };
       }
-      const fileStat = await stat(access.resolved);
-      if (fileStat.size > maxFileSize) {
+      if (old_string === new_string) {
         return {
-          content: `File too large: ${fileStat.size} bytes (max: ${maxFileSize} bytes)`,
+          content: `old_string and new_string are identical. No changes needed.`,
           isError: true
         };
       }
-      const ext = extname(access.resolved).toLowerCase();
-      if (BINARY_EXTENSIONS.has(ext)) {
-        return {
-          content: `Binary file: ${access.resolved}
-Size: ${fileStat.size} bytes
-Type: ${ext}`
-        };
-      }
       try {
-        const content = await readFile3(access.resolved, "utf-8");
-        const lines = content.split(`
-`);
-        const startLine = Math.max(1, offset);
-        const endLine = Math.min(lines.length, startLine + limit - 1);
-        const outputLines = [];
-        for (let i = startLine - 1;i < endLine; i++) {
-          const lineNum = i + 1;
-          let line = lines[i];
-          if (line.length > MAX_LINE_LENGTH) {
-            line = line.slice(0, MAX_LINE_LENGTH) + "...";
-          }
-          const padding = String(endLine).length;
-          outputLines.push(`${String(lineNum).padStart(padding)}→${line}`);
+        const content = await readFile4(access.resolved, "utf-8");
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return {
+            content: `Text not found in file: "${old_string.slice(0, 100)}${old_string.length > 100 ? "..." : ""}"`,
+            isError: true
+          };
         }
-        let header = "";
-        if (startLine > 1 || endLine < lines.length) {
-          header = `[Lines ${startLine}-${endLine} of ${lines.length}]
-
-`;
+        if (!replace_all && occurrences > 1) {
+          return {
+            content: `Found ${occurrences} occurrences of the text. Use replace_all: true to replace all, or provide a more unique string.`,
+            isError: true
+          };
+        }
+        let newContent;
+        let replacedCount;
+        if (replace_all) {
+          newContent = content.split(old_string).join(new_string);
+          replacedCount = occurrences;
+        } else {
+          newContent = content.replace(old_string, new_string);
+          replacedCount = 1;
         }
+        await writeFile3(access.resolved, newContent, "utf-8");
         return {
-          content: header + outputLines.join(`
-`)
+          content: `Successfully replaced ${replacedCount} occurrence${replacedCount > 1 ? "s" : ""} in ${access.resolved}`
         };
       } catch (error) {
         return {
-          content: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
+          content: `Failed to edit file: ${error instanceof Error ? error.message : String(error)}`,
           isError: true
         };
       }
     }
   };
 }
-var ReadTool = createReadTool();
-// src/tools/builtin/write.ts
-import { writeFile, mkdir } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
-function createWriteTool(options = {}) {
+var EditTool = createEditTool();
+// src/tools/builtin/glob.ts
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join5, relative } from "node:path";
+var MAX_RESULTS = 1000;
+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(path2);
+}
+async function scanDir(dir, pattern, results, baseDir, maxDepth = 10, currentDepth = 0) {
+  if (currentDepth > maxDepth || results.length >= MAX_RESULTS) {
+    return;
+  }
+  if (!existsSync7(dir)) {
+    return;
+  }
+  try {
+    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 = join5(dir, entry.name);
+      const relativePath = relative(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        if (matchGlob(pattern, relativePath) || matchGlob(pattern, relativePath + "/")) {
+          results.push(fullPath);
+        }
+        await scanDir(fullPath, pattern, results, baseDir, maxDepth, currentDepth + 1);
+      } else if (entry.isFile()) {
+        if (matchGlob(pattern, relativePath)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {}
+}
+function createGlobTool(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
   return {
-    name: "Write",
-    description: `Write content to a file. Creates parent directories if needed. Overwrites existing files. Use Edit tool for modifying existing files.`,
+    name: "Glob",
+    description: `Find files matching a glob pattern. Supports ** for recursive matching, * for single directory, ? for single character. Returns file paths sorted by modification time.`,
     inputSchema: {
       type: "object",
       properties: {
-        file_path: {
+        pattern: {
           type: "string",
-          description: "Absolute path to the file to write"
+          description: 'Glob pattern to match (e.g., "**/*.ts", "src/**/*.js")'
         },
-        content: {
+        path: {
           type: "string",
-          description: "Content to write to the file"
+          description: "Directory to search in (default: current directory)"
         }
       },
-      required: ["file_path", "content"]
+      required: ["pattern"]
     },
     execute: async (rawInput, _context) => {
       const input = rawInput;
-      const { file_path, content } = input;
-      const access = checkPathAccess(file_path, options, "file");
+      const { pattern, path: path2 = defaultCwd } = input;
+      const access = checkDirAccess(path2, options);
       if (!access.ok) {
         return { content: access.error, isError: true };
       }
-      try {
-        const dir = dirname3(access.resolved);
-        if (!existsSync5(dir)) {
-          await mkdir(dir, { recursive: true });
+      if (!existsSync7(access.resolved)) {
+        return {
+          content: `Directory not found: ${access.resolved}`,
+          isError: true
+        };
+      }
+      try {
+        const results = [];
+        await scanDir(access.resolved, pattern, results, access.resolved);
+        if (results.length === 0) {
+          return {
+            content: `No files found matching pattern: ${pattern}`
+          };
+        }
+        const filesWithStats = await Promise.all(results.map(async (file) => {
+          try {
+            const stats = await stat2(file);
+            return { file, mtime: stats.mtime.getTime() };
+          } catch {
+            return { file, mtime: 0 };
+          }
+        }));
+        filesWithStats.sort((a, b) => b.mtime - a.mtime);
+        const output = filesWithStats.map((f) => f.file).join(`
+`);
+        const truncated = results.length >= MAX_RESULTS ? `
+
+(Results truncated at ${MAX_RESULTS} files)` : "";
+        return {
+          content: `Found ${results.length} files:
+
+${output}${truncated}`
+        };
+      } catch (error) {
+        return {
+          content: `Failed to search: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+var GlobTool = createGlobTool();
+// src/tools/builtin/grep.ts
+import { readFile as readFile5, readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join6, extname as extname2 } from "node:path";
+var MAX_RESULTS2 = 500;
+var MAX_LINE_LENGTH2 = 500;
+var BINARY_EXTENSIONS2 = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".lock"
+]);
+function matchGlob2(pattern, filename) {
+  const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\./g, "\\.");
+  return new RegExp(`^${regexPattern}$`).test(filename);
+}
+async function searchFile(filePath, regex, before, after) {
+  const matches = [];
+  try {
+    const content = await readFile5(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    for (let i = 0;i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        const match = {
+          file: filePath,
+          line: i + 1,
+          content: lines[i].slice(0, MAX_LINE_LENGTH2)
+        };
+        if (before > 0) {
+          match.before = lines.slice(Math.max(0, i - before), i).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+        }
+        if (after > 0) {
+          match.after = lines.slice(i + 1, i + 1 + after).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+        }
+        matches.push(match);
+        if (matches.length >= MAX_RESULTS2) {
+          break;
+        }
+      }
+    }
+  } catch {}
+  return matches;
+}
+async function searchDir(dir, regex, glob, before, after, results, maxDepth = 10, currentDepth = 0) {
+  if (currentDepth > maxDepth || results.length >= MAX_RESULTS2) {
+    return;
+  }
+  try {
+    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 = join6(dir, entry.name);
+      if (entry.isDirectory()) {
+        await searchDir(fullPath, regex, glob, before, after, results, maxDepth, currentDepth + 1);
+      } else if (entry.isFile()) {
+        const ext = extname2(entry.name).toLowerCase();
+        if (BINARY_EXTENSIONS2.has(ext)) {
+          continue;
         }
-        await writeFile(access.resolved, content, "utf-8");
-        const lines = content.split(`
-`).length;
-        const bytes = Buffer.byteLength(content, "utf-8");
-        return {
-          content: `Successfully wrote ${bytes} bytes (${lines} lines) to ${access.resolved}`
-        };
-      } catch (error) {
-        return {
-          content: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
-          isError: true
-        };
+        if (glob && !matchGlob2(glob, entry.name)) {
+          continue;
+        }
+        const matches = await searchFile(fullPath, regex, before, after);
+        results.push(...matches);
       }
     }
-  };
+  } catch {}
 }
-var WriteTool = createWriteTool();
-// src/tools/builtin/edit.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
-import { existsSync as existsSync6 } from "node:fs";
-function createEditTool(options = {}) {
+function createGrepTool(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
   return {
-    name: "Edit",
-    description: `Edit a file by replacing text. Finds old_string and replaces with new_string. The old_string must be unique in the file unless replace_all is true.`,
+    name: "Grep",
+    description: `Search file contents using regular expressions. Supports context lines before/after matches. Returns matching lines with file paths and line numbers.`,
     inputSchema: {
       type: "object",
       properties: {
-        file_path: {
+        pattern: {
           type: "string",
-          description: "Absolute path to the file to edit"
+          description: "Regular expression pattern to search for"
         },
-        old_string: {
+        path: {
           type: "string",
-          description: "Text to find and replace"
+          description: "File or directory to search in"
         },
-        new_string: {
+        glob: {
           type: "string",
-          description: "Replacement text"
+          description: 'Glob pattern to filter files (e.g., "*.ts")'
         },
-        replace_all: {
+        before: {
+          type: "number",
+          description: "Number of lines to show before each match"
+        },
+        after: {
+          type: "number",
+          description: "Number of lines to show after each match"
+        },
+        ignoreCase: {
           type: "boolean",
-          description: "Replace all occurrences (default: false)",
-          default: false
+          description: "Case insensitive search"
         }
       },
-      required: ["file_path", "old_string", "new_string"]
+      required: ["pattern"]
     },
     execute: async (rawInput, _context) => {
       const input = rawInput;
-      const { file_path, old_string, new_string, replace_all = false } = input;
-      const access = checkPathAccess(file_path, options, "file");
+      const {
+        pattern,
+        path: path2 = defaultCwd,
+        glob,
+        before = 0,
+        after = 0,
+        ignoreCase = false
+      } = input;
+      const access = checkPathAccess(path2, options, "dir");
       if (!access.ok) {
         return { content: access.error, isError: true };
       }
-      if (!existsSync6(access.resolved)) {
-        return {
-          content: `File not found: ${access.resolved}`,
-          isError: true
-        };
-      }
-      if (old_string === new_string) {
+      if (!existsSync8(access.resolved)) {
         return {
-          content: `old_string and new_string are identical. No changes needed.`,
+          content: `Path not found: ${access.resolved}`,
           isError: true
         };
       }
       try {
-        const content = await readFile4(access.resolved, "utf-8");
-        const occurrences = content.split(old_string).length - 1;
-        if (occurrences === 0) {
-          return {
-            content: `Text not found in file: "${old_string.slice(0, 100)}${old_string.length > 100 ? "..." : ""}"`,
-            isError: true
-          };
+        const flags = ignoreCase ? "gi" : "g";
+        const regex = new RegExp(pattern, flags);
+        const results = [];
+        const pathStat = await stat3(access.resolved);
+        if (pathStat.isFile()) {
+          const matches = await searchFile(access.resolved, regex, before, after);
+          results.push(...matches);
+        } else if (pathStat.isDirectory()) {
+          await searchDir(access.resolved, regex, glob, before, after, results);
         }
-        if (!replace_all && occurrences > 1) {
+        if (results.length === 0) {
           return {
-            content: `Found ${occurrences} occurrences of the text. Use replace_all: true to replace all, or provide a more unique string.`,
-            isError: true
+            content: `No matches found for pattern: ${pattern}`
           };
         }
-        let newContent;
-        let replacedCount;
-        if (replace_all) {
-          newContent = content.split(old_string).join(new_string);
-          replacedCount = occurrences;
-        } else {
-          newContent = content.replace(old_string, new_string);
-          replacedCount = 1;
+        const output = [];
+        for (const match of results) {
+          if (match.before?.length) {
+            for (let i = 0;i < match.before.length; i++) {
+              const lineNum = match.line - match.before.length + i;
+              output.push(`${match.file}:${lineNum}- ${match.before[i]}`);
+            }
+          }
+          output.push(`${match.file}:${match.line}: ${match.content}`);
+          if (match.after?.length) {
+            for (let i = 0;i < match.after.length; i++) {
+              const lineNum = match.line + i + 1;
+              output.push(`${match.file}:${lineNum}+ ${match.after[i]}`);
+            }
+          }
+          if (match.before?.length || match.after?.length) {
+            output.push("--");
+          }
         }
-        await writeFile2(access.resolved, newContent, "utf-8");
+        const truncated = results.length >= MAX_RESULTS2 ? `
+
+(Results truncated at ${MAX_RESULTS2} matches)` : "";
         return {
-          content: `Successfully replaced ${replacedCount} occurrence${replacedCount > 1 ? "s" : ""} in ${access.resolved}`
+          content: `Found ${results.length} matches:
+
+${output.join(`
+`)}${truncated}`
         };
       } catch (error) {
         return {
-          content: `Failed to edit file: ${error instanceof Error ? error.message : String(error)}`,
+          content: `Search failed: ${error instanceof Error ? error.message : String(error)}`,
           isError: true
         };
       }
     }
   };
 }
-var EditTool = createEditTool();
-// src/tools/builtin/glob.ts
-import { readdir, stat as stat2 } from "node:fs/promises";
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join4, relative } from "node:path";
-var MAX_RESULTS = 1000;
-function matchGlob(pattern, path) {
-  const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*").replace(/\./g, "\\.");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(path);
+var GrepTool = createGrepTool();
+// src/tools/builtin/webfetch.ts
+import { lookup } from "node:dns/promises";
+var MAX_CONTENT_LENGTH = 1e5;
+var FETCH_TIMEOUT = 30000;
+function isIpV4(host) {
+  return /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
 }
-async function scanDir(dir, pattern, results, baseDir, maxDepth = 10, currentDepth = 0) {
-  if (currentDepth > maxDepth || results.length >= MAX_RESULTS) {
-    return;
+function isIpV6(host) {
+  return /^[0-9a-fA-F:]+$/.test(host) && host.includes(":");
+}
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map((p) => Number(p));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255))
+    return true;
+  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;
+  return false;
+}
+function isPrivateIpv6(ip) {
+  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 denyPrivateNetworkTargets(url, options) {
+  if (options.allowPrivateNetwork)
+    return null;
+  const hostname = url.hostname.toLowerCase();
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+    return `Blocked by policy (allowPrivateNetwork=false): hostname "${hostname}" is local-only`;
   }
-  if (!existsSync7(dir)) {
-    return;
+  if (isIpV4(hostname) && isPrivateIpv4(hostname)) {
+    return `Blocked by policy (allowPrivateNetwork=false): private IPv4 target "${hostname}"`;
+  }
+  if (isIpV6(hostname) && isPrivateIpv6(hostname)) {
+    return `Blocked by policy (allowPrivateNetwork=false): private IPv6 target "${hostname}"`;
   }
+  const resolveHostnames = options.resolveHostnames ?? true;
+  if (!resolveHostnames)
+    return null;
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (results.length >= MAX_RESULTS)
-        break;
-      if (entry.name.startsWith(".") || entry.name === "node_modules") {
-        continue;
+    const addrs = await lookup(hostname, { all: true, verbatim: true });
+    for (const addr of addrs) {
+      if (addr.family === 4 && isPrivateIpv4(addr.address)) {
+        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv4 "${addr.address}"`;
       }
-      const fullPath = join4(dir, entry.name);
-      const relativePath = relative(baseDir, fullPath);
-      if (entry.isDirectory()) {
-        if (matchGlob(pattern, relativePath) || matchGlob(pattern, relativePath + "/")) {
-          results.push(fullPath);
-        }
-        await scanDir(fullPath, pattern, results, baseDir, maxDepth, currentDepth + 1);
-      } else if (entry.isFile()) {
-        if (matchGlob(pattern, relativePath)) {
-          results.push(fullPath);
-        }
+      if (addr.family === 6 && isPrivateIpv6(addr.address)) {
+        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv6 "${addr.address}"`;
       }
     }
-  } catch {}
+  } catch (e) {
+    return `DNS resolution failed for "${hostname}" (allowPrivateNetwork=false): ${e instanceof Error ? e.message : String(e)}`;
+  }
+  return null;
+}
+function htmlToMarkdown(html) {
+  let md = html;
+  md = md.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  md = md.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, `
+# $1
+`);
+  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, `
+## $1
+`);
+  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, `
+### $1
+`);
+  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, `
+#### $1
+`);
+  md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, `
+##### $1
+`);
+  md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, `
+###### $1
+`);
+  md = md.replace(/<p[^>]*>(.*?)<\/p>/gi, `
+$1
+`);
+  md = md.replace(/<a[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  md = md.replace(/<(strong|b)[^>]*>(.*?)<\/\1>/gi, "**$2**");
+  md = md.replace(/<(em|i)[^>]*>(.*?)<\/\1>/gi, "*$2*");
+  md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  md = md.replace(/<pre[^>]*>(.*?)<\/pre>/gis, "\n```\n$1\n```\n");
+  md = md.replace(/<li[^>]*>(.*?)<\/li>/gi, `- $1
+`);
+  md = md.replace(/<\/?[ou]l[^>]*>/gi, `
+`);
+  md = md.replace(/<br\s*\/?>/gi, `
+`);
+  md = md.replace(/<[^>]+>/g, "");
+  md = md.replace(/&nbsp;/g, " ");
+  md = md.replace(/&amp;/g, "&");
+  md = md.replace(/&lt;/g, "<");
+  md = md.replace(/&gt;/g, ">");
+  md = md.replace(/&quot;/g, '"');
+  md = md.replace(/\n{3,}/g, `
+
+`);
+  md = md.trim();
+  return md;
 }
-function createGlobTool(options = {}) {
-  const defaultCwd = options.cwd ?? process.cwd();
+function createWebFetchTool(options = {}) {
   return {
-    name: "Glob",
-    description: `Find files matching a glob pattern. Supports ** for recursive matching, * for single directory, ? for single character. Returns file paths sorted by modification time.`,
+    name: "WebFetch",
+    description: `Fetch content from a URL. Converts HTML to markdown for readability. Use for retrieving web pages, documentation, or API responses.`,
     inputSchema: {
       type: "object",
       properties: {
-        pattern: {
+        url: {
           type: "string",
-          description: 'Glob pattern to match (e.g., "**/*.ts", "src/**/*.js")'
+          description: "URL to fetch"
         },
-        path: {
+        prompt: {
           type: "string",
-          description: "Directory to search in (default: current directory)"
+          description: "Optional prompt to describe what information to extract"
         }
       },
-      required: ["pattern"]
+      required: ["url"]
     },
     execute: async (rawInput, _context) => {
       const input = rawInput;
-      const { pattern, path = defaultCwd } = input;
-      const access = checkDirAccess(path, options);
-      if (!access.ok) {
-        return { content: access.error, isError: true };
-      }
-      if (!existsSync7(access.resolved)) {
+      const { url, prompt } = input;
+      let parsedUrl;
+      try {
+        parsedUrl = new URL(url);
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+          return {
+            content: `Invalid URL protocol: ${parsedUrl.protocol}. Only http/https are allowed.`,
+            isError: true
+          };
+        }
+        if (parsedUrl.protocol === "http:")
+          parsedUrl.protocol = "https:";
+      } catch {
         return {
-          content: `Directory not found: ${access.resolved}`,
+          content: `Invalid URL: ${url}`,
           isError: true
         };
       }
+      const ssrfDeny = await denyPrivateNetworkTargets(parsedUrl, options);
+      if (ssrfDeny) {
+        return { content: ssrfDeny, isError: true };
+      }
       try {
-        const results = [];
-        await scanDir(access.resolved, pattern, results, access.resolved);
-        if (results.length === 0) {
+        const controller = new AbortController;
+        const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+        const response = await fetch(parsedUrl.toString(), {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Agent/1.0)",
+            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+          }
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
           return {
-            content: `No files found matching pattern: ${pattern}`
+            content: `HTTP error: ${response.status} ${response.statusText}`,
+            isError: true
           };
         }
-        const filesWithStats = await Promise.all(results.map(async (file) => {
-          try {
-            const stats = await stat2(file);
-            return { file, mtime: stats.mtime.getTime() };
-          } catch {
-            return { file, mtime: 0 };
-          }
-        }));
-        filesWithStats.sort((a, b) => b.mtime - a.mtime);
-        const output = filesWithStats.map((f) => f.file).join(`
-`);
-        const truncated = results.length >= MAX_RESULTS ? `
-
-(Results truncated at ${MAX_RESULTS} files)` : "";
-        return {
-          content: `Found ${results.length} files:
+        const finalUrl = new URL(response.url);
+        if (finalUrl.host !== parsedUrl.host) {
+          return {
+            content: `Redirected to different host: ${response.url}
 
-${output}${truncated}`
-        };
-      } catch (error) {
-        return {
-          content: `Failed to search: ${error instanceof Error ? error.message : String(error)}`,
-          isError: true
-        };
-      }
-    }
-  };
-}
-var GlobTool = createGlobTool();
-// src/tools/builtin/grep.ts
-import { readFile as readFile5, readdir as readdir2, stat as stat3 } from "node:fs/promises";
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join5, extname as extname2 } from "node:path";
-var MAX_RESULTS2 = 500;
-var MAX_LINE_LENGTH2 = 500;
-var BINARY_EXTENSIONS2 = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".bmp",
-  ".ico",
-  ".webp",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".avi",
-  ".mov",
-  ".mkv",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".rar",
-  ".7z",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".otf",
-  ".eot",
-  ".lock"
-]);
-function matchGlob2(pattern, filename) {
-  const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\./g, "\\.");
-  return new RegExp(`^${regexPattern}$`).test(filename);
-}
-async function searchFile(filePath, regex, before, after) {
-  const matches = [];
-  try {
-    const content = await readFile5(filePath, "utf-8");
-    const lines = content.split(`
-`);
-    for (let i = 0;i < lines.length; i++) {
-      if (regex.test(lines[i])) {
-        const match = {
-          file: filePath,
-          line: i + 1,
-          content: lines[i].slice(0, MAX_LINE_LENGTH2)
-        };
-        if (before > 0) {
-          match.before = lines.slice(Math.max(0, i - before), i).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+Please fetch the new URL if you want to continue.`
+          };
         }
-        if (after > 0) {
-          match.after = lines.slice(i + 1, i + 1 + after).map((l) => l.slice(0, MAX_LINE_LENGTH2));
+        const ssrfDenyAfter = await denyPrivateNetworkTargets(finalUrl, options);
+        if (ssrfDenyAfter) {
+          return { content: `Redirect target denied: ${ssrfDenyAfter}`, isError: true };
         }
-        matches.push(match);
-        if (matches.length >= MAX_RESULTS2) {
-          break;
+        const contentType = response.headers.get("content-type") || "";
+        let content = await response.text();
+        if (content.length > MAX_CONTENT_LENGTH) {
+          content = content.slice(0, MAX_CONTENT_LENGTH) + `
+
+... (content truncated)`;
         }
-      }
-    }
-  } catch {}
-  return matches;
-}
-async function searchDir(dir, regex, glob, before, after, results, maxDepth = 10, currentDepth = 0) {
-  if (currentDepth > maxDepth || results.length >= MAX_RESULTS2) {
-    return;
-  }
-  try {
-    const entries = await readdir2(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);
-      if (entry.isDirectory()) {
-        await searchDir(fullPath, regex, glob, before, after, results, maxDepth, currentDepth + 1);
-      } else if (entry.isFile()) {
-        const ext = extname2(entry.name).toLowerCase();
-        if (BINARY_EXTENSIONS2.has(ext)) {
-          continue;
+        if (contentType.includes("text/html")) {
+          content = htmlToMarkdown(content);
         }
-        if (glob && !matchGlob2(glob, entry.name)) {
-          continue;
+        let output = `URL: ${response.url}
+`;
+        output += `Content-Type: ${contentType}
+
+`;
+        if (prompt) {
+          output += `Requested: ${prompt}
+
+`;
         }
-        const matches = await searchFile(fullPath, regex, before, after);
-        results.push(...matches);
+        output += content;
+        return {
+          content: output
+        };
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          return {
+            content: `Request timed out after ${FETCH_TIMEOUT}ms`,
+            isError: true
+          };
+        }
+        return {
+          content: `Failed to fetch: ${error instanceof Error ? error.message : String(error)}`,
+          isError: true
+        };
       }
     }
-  } catch {}
+  };
 }
-function createGrepTool(options = {}) {
-  const defaultCwd = options.cwd ?? process.cwd();
+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: "Grep",
-    description: `Search file contents using regular expressions. Supports context lines before/after matches. Returns matching lines with file paths and line numbers.`,
+    name: "WebSearch",
+    description: WEBSEARCH_DESCRIPTION,
     inputSchema: {
       type: "object",
       properties: {
-        pattern: {
+        query: {
           type: "string",
-          description: "Regular expression pattern to search for"
+          description: "Search query to find relevant information"
         },
-        path: {
-          type: "string",
-          description: "File or directory to search in"
+        numResults: {
+          type: "number",
+          description: "Number of search results to return (default: 8, max: 20)"
         },
-        glob: {
+        livecrawl: {
           type: "string",
-          description: 'Glob pattern to filter files (e.g., "*.ts")'
+          enum: ["fallback", "preferred"],
+          description: "Live crawl mode - 'fallback': use live crawling as backup, 'preferred': prioritize live crawling"
         },
-        before: {
-          type: "number",
-          description: "Number of lines to show before each match"
+        type: {
+          type: "string",
+          enum: ["auto", "fast", "deep"],
+          description: "Search type - 'auto': balanced, 'fast': quick results, 'deep': comprehensive"
         },
-        after: {
+        contextMaxCharacters: {
           type: "number",
-          description: "Number of lines to show after each match"
-        },
-        ignoreCase: {
-          type: "boolean",
-          description: "Case insensitive search"
+          description: "Maximum characters for context per result (default: 10000)"
         }
       },
-      required: ["pattern"]
+      required: ["query"]
     },
-    execute: async (rawInput, _context) => {
+    execute: async (rawInput, context) => {
       const input = rawInput;
-      const {
-        pattern,
-        path = defaultCwd,
-        glob,
-        before = 0,
-        after = 0,
-        ignoreCase = false
-      } = input;
-      const access = checkPathAccess(path, options, "dir");
-      if (!access.ok) {
-        return { content: access.error, isError: true };
-      }
-      if (!existsSync8(access.resolved)) {
+      const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
+      if (!query || typeof query !== "string" || query.trim().length === 0) {
         return {
-          content: `Path not found: ${access.resolved}`,
+          content: "Error: A non-empty search query is required.",
           isError: true
         };
       }
-      try {
-        const flags = ignoreCase ? "gi" : "g";
-        const regex = new RegExp(pattern, flags);
-        const results = [];
-        const pathStat = await stat3(access.resolved);
-        if (pathStat.isFile()) {
-          const matches = await searchFile(access.resolved, regex, before, after);
-          results.push(...matches);
-        } else if (pathStat.isDirectory()) {
-          await searchDir(access.resolved, regex, glob, before, after, results);
+      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
+          }
         }
-        if (results.length === 0) {
+      };
+      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: `No matches found for pattern: ${pattern}`
+            content: `Search error (${response.status}): ${errorText}`,
+            isError: true
           };
         }
-        const output = [];
-        for (const match of results) {
-          if (match.before?.length) {
-            for (let i = 0;i < match.before.length; i++) {
-              const lineNum = match.line - match.before.length + i;
-              output.push(`${match.file}:${lineNum}- ${match.before[i]}`);
-            }
-          }
-          output.push(`${match.file}:${match.line}: ${match.content}`);
-          if (match.after?.length) {
-            for (let i = 0;i < match.after.length; i++) {
-              const lineNum = match.line + i + 1;
-              output.push(`${match.file}:${lineNum}+ ${match.after[i]}`);
+        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;
             }
           }
-          if (match.before?.length || match.after?.length) {
-            output.push("--");
-          }
         }
-        const truncated = results.length >= MAX_RESULTS2 ? `
-
-(Results truncated at ${MAX_RESULTS2} matches)` : "";
+        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: `Found ${results.length} matches:
-
-${output.join(`
-`)}${truncated}`
+          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: ${error instanceof Error ? error.message : String(error)}`,
+          content: `Search failed: ${String(error)}`,
           isError: true
         };
       }
     }
   };
 }
-var GrepTool = createGrepTool();
-// src/tools/builtin/webfetch.ts
-import { lookup } from "node:dns/promises";
-var MAX_CONTENT_LENGTH = 1e5;
-var FETCH_TIMEOUT = 30000;
-function isIpV4(host) {
-  return /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
-}
-function isIpV6(host) {
-  return /^[0-9a-fA-F:]+$/.test(host) && host.includes(":");
+var WebSearchTool = createWebSearchTool();
+// src/tools/builtin/todo.ts
+var globalTodos = [];
+var onTodoChange = null;
+function setTodoChangeCallback(callback) {
+  onTodoChange = callback;
 }
-function isPrivateIpv4(ip) {
-  const parts = ip.split(".").map((p) => Number(p));
-  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255))
-    return true;
-  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;
-  return false;
+function getTodos() {
+  return [...globalTodos];
 }
-function isPrivateIpv6(ip) {
-  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;
+function clearTodos() {
+  globalTodos = [];
+  onTodoChange?.(globalTodos);
 }
-async function denyPrivateNetworkTargets(url, options) {
-  if (options.allowPrivateNetwork)
-    return null;
-  const hostname = url.hostname.toLowerCase();
-  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
-    return `Blocked by policy (allowPrivateNetwork=false): hostname "${hostname}" is local-only`;
-  }
-  if (isIpV4(hostname) && isPrivateIpv4(hostname)) {
-    return `Blocked by policy (allowPrivateNetwork=false): private IPv4 target "${hostname}"`;
-  }
-  if (isIpV6(hostname) && isPrivateIpv6(hostname)) {
-    return `Blocked by policy (allowPrivateNetwork=false): private IPv6 target "${hostname}"`;
-  }
-  const resolveHostnames = options.resolveHostnames ?? true;
-  if (!resolveHostnames)
-    return null;
-  try {
-    const addrs = await lookup(hostname, { all: true, verbatim: true });
-    for (const addr of addrs) {
-      if (addr.family === 4 && isPrivateIpv4(addr.address)) {
-        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv4 "${addr.address}"`;
+function createTodoWriteTool(options = {}) {
+  return {
+    name: "TodoWrite",
+    description: `Manage a task list to track progress on complex tasks. Use to plan work, track completed items, and show progress to the user.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        todos: {
+          type: "array",
+          description: "Updated todo list",
+          items: {
+            type: "object",
+            properties: {
+              content: {
+                type: "string",
+                description: "Task description (imperative form, e.g., 'Run tests')"
+              },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed"],
+                description: "Task status"
+              },
+              activeForm: {
+                type: "string",
+                description: "Present continuous form (e.g., 'Running tests')"
+              }
+            },
+            required: ["content", "status", "activeForm"]
+          }
+        }
+      },
+      required: ["todos"]
+    },
+    execute: async (rawInput, _context) => {
+      const input = rawInput;
+      const { todos } = input;
+      for (const todo of todos) {
+        if (!todo.content || !todo.status || !todo.activeForm) {
+          return {
+            content: "Invalid todo item: missing required fields (content, status, activeForm)",
+            isError: true
+          };
+        }
+        if (!["pending", "in_progress", "completed"].includes(todo.status)) {
+          return {
+            content: `Invalid status: ${todo.status}. Must be pending, in_progress, or completed.`,
+            isError: true
+          };
+        }
       }
-      if (addr.family === 6 && isPrivateIpv6(addr.address)) {
-        return `Blocked by policy (allowPrivateNetwork=false): "${hostname}" resolves to private IPv6 "${addr.address}"`;
+      globalTodos = todos;
+      onTodoChange?.(globalTodos);
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const inProgress = todos.filter((t) => t.status === "in_progress").length;
+      const pending = todos.filter((t) => t.status === "pending").length;
+      const lines = [
+        `Todo list updated (${completed}/${todos.length} completed)`,
+        ""
+      ];
+      for (const todo of todos) {
+        const icon = todo.status === "completed" ? "✓" : todo.status === "in_progress" ? "→" : "○";
+        lines.push(`${icon} ${todo.content}`);
+      }
+      if (inProgress > 0) {
+        lines.push("");
+        lines.push(`Currently: ${todos.find((t) => t.status === "in_progress")?.activeForm}`);
       }
+      return {
+        content: lines.join(`
+`)
+      };
     }
-  } catch (e) {
-    return `DNS resolution failed for "${hostname}" (allowPrivateNetwork=false): ${e instanceof Error ? e.message : String(e)}`;
-  }
-  return null;
+  };
 }
-function htmlToMarkdown(html) {
-  let md = html;
-  md = md.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
-  md = md.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
-  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, `
-# $1
-`);
-  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, `
-## $1
-`);
-  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, `
-### $1
-`);
-  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, `
-#### $1
-`);
-  md = md.replace(/<h5[^>]*>(.*?)<\/h5>/gi, `
-##### $1
-`);
-  md = md.replace(/<h6[^>]*>(.*?)<\/h6>/gi, `
-###### $1
-`);
-  md = md.replace(/<p[^>]*>(.*?)<\/p>/gi, `
-$1
-`);
-  md = md.replace(/<a[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi, "[$2]($1)");
-  md = md.replace(/<(strong|b)[^>]*>(.*?)<\/\1>/gi, "**$2**");
-  md = md.replace(/<(em|i)[^>]*>(.*?)<\/\1>/gi, "*$2*");
-  md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
-  md = md.replace(/<pre[^>]*>(.*?)<\/pre>/gis, "\n```\n$1\n```\n");
-  md = md.replace(/<li[^>]*>(.*?)<\/li>/gi, `- $1
-`);
-  md = md.replace(/<\/?[ou]l[^>]*>/gi, `
-`);
-  md = md.replace(/<br\s*\/?>/gi, `
-`);
-  md = md.replace(/<[^>]+>/g, "");
-  md = md.replace(/&nbsp;/g, " ");
-  md = md.replace(/&amp;/g, "&");
-  md = md.replace(/&lt;/g, "<");
-  md = md.replace(/&gt;/g, ">");
-  md = md.replace(/&quot;/g, '"');
-  md = md.replace(/\n{3,}/g, `
+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.
 
-`);
-  md = md.trim();
-  return md;
-}
-function createWebFetchTool(options = {}) {
+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: "WebFetch",
-    description: `Fetch content from a URL. Converts HTML to markdown for readability. Use for retrieving web pages, documentation, or API responses.`,
+    name: "AskUser",
+    description: ASKUSER_DESCRIPTION,
     inputSchema: {
       type: "object",
       properties: {
-        url: {
-          type: "string",
-          description: "URL to fetch"
-        },
-        prompt: {
-          type: "string",
-          description: "Optional prompt to describe what information to extract"
+        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: ["url"]
+      required: ["questions"]
     },
-    execute: async (rawInput, _context) => {
+    execute: async (rawInput, context) => {
       const input = rawInput;
-      const { url, prompt } = input;
-      let parsedUrl;
-      try {
-        parsedUrl = new URL(url);
-        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-          return {
-            content: `Invalid URL protocol: ${parsedUrl.protocol}. Only http/https are allowed.`,
-            isError: true
-          };
-        }
-        if (parsedUrl.protocol === "http:")
-          parsedUrl.protocol = "https:";
-      } catch {
+      const { questions } = input;
+      if (!questions || !Array.isArray(questions) || questions.length === 0) {
         return {
-          content: `Invalid URL: ${url}`,
+          content: "Error: At least one question is required.",
           isError: true
         };
       }
-      const ssrfDeny = await denyPrivateNetworkTargets(parsedUrl, options);
-      if (ssrfDeny) {
-        return { content: ssrfDeny, 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 controller = new AbortController;
-        const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
-        const response = await fetch(parsedUrl.toString(), {
-          signal: controller.signal,
-          headers: {
-            "User-Agent": "Mozilla/5.0 (compatible; OpenCode-Agent/1.0)",
-            Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        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
           }
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-          return {
-            content: `HTTP error: ${response.status} ${response.statusText}`,
-            isError: true
-          };
-        }
-        const finalUrl = new URL(response.url);
-        if (finalUrl.host !== parsedUrl.host) {
-          return {
-            content: `Redirected to different host: ${response.url}
+        };
+      } 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.
 
-Please fetch the new URL if you want to continue.`
-          };
-        }
-        const ssrfDenyAfter = await denyPrivateNetworkTargets(finalUrl, options);
-        if (ssrfDenyAfter) {
-          return { content: `Redirect target denied: ${ssrfDenyAfter}`, isError: true };
-        }
-        const contentType = response.headers.get("content-type") || "";
-        let content = await response.text();
-        if (content.length > MAX_CONTENT_LENGTH) {
-          content = content.slice(0, MAX_CONTENT_LENGTH) + `
+Use this tool when you need to:
+- Read multiple files at once
+- Perform several independent operations
+- Speed up tasks that don't have dependencies
 
-... (content truncated)`;
-        }
-        if (contentType.includes("text/html")) {
-          content = htmlToMarkdown(content);
-        }
-        let output = `URL: ${response.url}
-`;
-        output += `Content-Type: ${contentType}
+Parameters:
+- tool_calls: Array of tool calls (1-10 calls per batch)
+  - tool: Name of the tool to execute
+  - parameters: Parameters for that tool
 
-`;
-        if (prompt) {
-          output += `Requested: ${prompt}
+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
         }
-        output += content;
+      },
+      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: output
+          content: "Error: At least one tool call is required.",
+          isError: true
         };
-      } catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
+      }
+      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 {
-            content: `Request timed out after ${FETCH_TIMEOUT}ms`,
-            isError: true
+            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
           };
         }
-        return {
-          content: `Failed to fetch: ${error instanceof Error ? error.message : String(error)}`,
-          isError: true
-        };
+      };
+      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}` };
       }
     }
-  };
-}
-var WebFetchTool = createWebFetchTool();
-// src/tools/builtin/todo.ts
-var globalTodos = [];
-var onTodoChange = null;
-function setTodoChangeCallback(callback) {
-  onTodoChange = callback;
-}
-function getTodos() {
-  return [...globalTodos];
-}
-function clearTodos() {
-  globalTodos = [];
-  onTodoChange?.(globalTodos);
+  }
+  return { valid: true, parsedUrl };
 }
-function createTodoWriteTool(options = {}) {
+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: "TodoWrite",
-    description: `Manage a task list to track progress on complex tasks. Use to plan work, track completed items, and show progress to the user.`,
+    name: "HttpRequest",
+    description: HTTPREQUEST_DESCRIPTION,
     inputSchema: {
       type: "object",
       properties: {
-        todos: {
-          type: "array",
-          description: "Updated todo list",
-          items: {
-            type: "object",
-            properties: {
-              content: {
-                type: "string",
-                description: "Task description (imperative form, e.g., 'Run tests')"
-              },
-              status: {
-                type: "string",
-                enum: ["pending", "in_progress", "completed"],
-                description: "Task status"
-              },
-              activeForm: {
-                type: "string",
-                description: "Present continuous form (e.g., 'Running tests')"
-              }
-            },
-            required: ["content", "status", "activeForm"]
-          }
+        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: ["todos"]
+      required: ["method", "url"]
     },
-    execute: async (rawInput, _context) => {
+    execute: async (rawInput, context) => {
       const input = rawInput;
-      const { todos } = input;
-      for (const todo of todos) {
-        if (!todo.content || !todo.status || !todo.activeForm) {
+      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: "Invalid todo item: missing required fields (content, status, activeForm)",
+            content: `Response too large: ${contentLength} bytes (max: ${MAX_RESPONSE_SIZE})`,
             isError: true
           };
         }
-        if (!["pending", "in_progress", "completed"].includes(todo.status)) {
+        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: `Invalid status: ${todo.status}. Must be pending, in_progress, or completed.`,
+            content: `Request failed: ${error.message}`,
             isError: true
           };
         }
+        return {
+          content: `Request failed: ${String(error)}`,
+          isError: true
+        };
       }
-      globalTodos = todos;
-      onTodoChange?.(globalTodos);
-      const completed = todos.filter((t) => t.status === "completed").length;
-      const inProgress = todos.filter((t) => t.status === "in_progress").length;
-      const pending = todos.filter((t) => t.status === "pending").length;
-      const lines = [
-        `Todo list updated (${completed}/${todos.length} completed)`,
-        ""
-      ];
-      for (const todo of todos) {
-        const icon = todo.status === "completed" ? "✓" : todo.status === "in_progress" ? "→" : "○";
-        lines.push(`${icon} ${todo.content}`);
-      }
-      if (inProgress > 0) {
-        lines.push("");
-        lines.push(`Currently: ${todos.find((t) => t.status === "in_progress")?.activeForm}`);
-      }
-      return {
-        content: lines.join(`
-`)
-      };
     }
   };
 }
-var TodoWriteTool = createTodoWriteTool();
+var HttpRequestTool = createHttpRequestTool();
 // src/tools/builtin/index.ts
 var builtinTools = [
   BashTool,
@@ -4092,14 +6065,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;
   }
@@ -4128,8 +6105,18 @@ function loadEnvOverride(cwd) {
 
 // src/cli/cli.ts
 loadEnvOverride();
-var VERSION = "0.1.0";
-var SKILLS_PATH = join7(homedir4(), ".claude");
+function getCliVersion() {
+  try {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const raw = readFileSync2(pkgUrl, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getCliVersion();
+var SKILLS_PATH = join8(homedir4(), ".claude");
 var colors = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -4157,8 +6144,10 @@ var session = null;
 var totalInputTokens = 0;
 var totalOutputTokens = 0;
 var messageCount = 0;
+var currentProviderId = null;
+var currentModelOverride = null;
 function isGitRepo(dir) {
-  return existsSync10(join7(dir, ".git"));
+  return existsSync10(join8(dir, ".git"));
 }
 function getOsVersion() {
   try {
@@ -4204,15 +6193,20 @@ ${c.bold("Interactive Commands:")}
   ${c.cyan("/clear")}    Clear conversation history
   ${c.cyan("/tools")}    List available tools
   ${c.cyan("/skills")}   List available skills
+  ${c.cyan("/models")}   Show or switch provider/model
   ${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:")}
   ${c.cyan("ANTHROPIC_API_KEY")}   Anthropic API key (for Claude models)
   ${c.cyan("ANTHROPIC_MODEL")}     Optional. Claude model (default: claude-sonnet-4-20250514)
+  ${c.cyan("GEMINI_API_KEY")}      Gemini API key (for Gemini models)
+  ${c.cyan("GEMINI_MODEL")}        Optional. Gemini model (default: gemini-1.5-pro)
+  ${c.cyan("GEMINI_BASE_URL")}     Optional. Custom Gemini API base URL
   ${c.cyan("OPENAI_API_KEY")}      OpenAI API key (for GPT models)
-  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-4o)
+  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-5.2)
   ${c.cyan("OPENAI_BASE_URL")}     Optional. Custom OpenAI-compatible API URL
 
 ${c.bold("Examples:")}
@@ -4230,7 +6224,7 @@ function printVersion() {
   console.log(`formagent-sdk v${VERSION}`);
 }
 function printBanner() {
-  const model = getDefaultModel();
+  const model = getActiveModel();
   console.log();
   console.log(c.cyan("╔═══════════════════════════════════════════════════════════╗"));
   console.log(c.cyan("║") + c.bold("              FormAgent CLI v" + VERSION + "                     ") + c.cyan("║"));
@@ -4238,6 +6232,7 @@ function printBanner() {
   console.log(c.cyan("╚═══════════════════════════════════════════════════════════╝"));
   console.log();
   console.log(c.dim("  Model: ") + c.green(model));
+  console.log(c.dim("  Provider: ") + c.green(getActiveProviderId() ?? "auto"));
   console.log(c.dim("  Type your message and press Enter to chat."));
   console.log(c.dim("  Use /help for commands, /exit to quit."));
   console.log();
@@ -4250,8 +6245,10 @@ function printInteractiveHelp() {
   console.log(`  ${c.cyan("/clear")}    Clear conversation history`);
   console.log(`  ${c.cyan("/tools")}    List available tools`);
   console.log(`  ${c.cyan("/skills")}   List available skills`);
+  console.log(`  ${c.cyan("/models")}   Show or switch provider/model`);
   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 +6319,298 @@ function printUsage() {
   console.log(`  ${c.cyan("Est. cost:")}     $${(inputCost + outputCost).toFixed(4)}`);
   console.log();
 }
+async function resetSessionForModelChange() {
+  if (session) {
+    await session.close();
+    session = null;
+  }
+  totalInputTokens = 0;
+  totalOutputTokens = 0;
+  messageCount = 0;
+}
+function printModelsHelp() {
+  const provider = getActiveProviderId() ?? "auto";
+  const model = getActiveModel();
+  console.log();
+  console.log(c.bold("Model Selection:"));
+  console.log();
+  console.log(`  ${c.cyan("Current provider:")} ${provider}`);
+  console.log(`  ${c.cyan("Current model:")}    ${model}`);
+  console.log();
+  console.log(c.bold("Usage:"));
+  console.log(`  ${c.cyan("/models")}`);
+  console.log(c.dim("    List models for the active provider"));
+  console.log(`  ${c.cyan("/models")} openai gpt-5-mini`);
+  console.log(`  ${c.cyan("/models")} anthropic claude-sonnet-4-20250514`);
+  console.log(`  ${c.cyan("/models")} gemini gemini-1.5-pro`);
+  console.log(`  ${c.cyan("/models")} gpt-5.2`);
+  console.log(`  ${c.cyan("/models")} reset`);
+  console.log();
+}
+async function handleModelsCommand(args) {
+  if (args.length === 0) {
+    await listModelsSummary();
+    return;
+  }
+  if (args[0].toLowerCase() === "reset") {
+    currentProviderId = null;
+    currentModelOverride = null;
+    await resetSessionForModelChange();
+    console.log(c.green(`
+  ✓ Model selection reset to environment defaults.
+`));
+    return;
+  }
+  if (args.length === 1) {
+    const provider2 = parseProvider(args[0]);
+    if (provider2) {
+      currentProviderId = provider2;
+      currentModelOverride = null;
+      await resetSessionForModelChange();
+      console.log(c.green(`
+  ✓ Provider set to ${provider2}. Model: ${getActiveModel()}.
+`));
+      return;
+    }
+    currentModelOverride = args[0];
+    currentProviderId = inferProviderFromModel(args[0]) ?? currentProviderId;
+    await resetSessionForModelChange();
+    console.log(c.green(`
+  ✓ Model set to ${currentModelOverride} (provider: ${getActiveProviderId() ?? "auto"}).
+`));
+    return;
+  }
+  const provider = parseProvider(args[0]);
+  if (!provider) {
+    console.log(c.yellow(`
+  Unknown provider: ${args[0]}. Use "openai", "anthropic", or "gemini".
+`));
+    return;
+  }
+  const model = args.slice(1).join(" ");
+  if (!model) {
+    console.log(c.yellow(`
+  Missing model name. Example: /models openai gpt-5-mini
+`));
+    return;
+  }
+  currentProviderId = provider;
+  currentModelOverride = model;
+  await resetSessionForModelChange();
+  console.log(c.green(`
+  ✓ Provider set to ${provider}, model set to ${model}.
+`));
+}
+function normalizeOpenAIBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    return trimmed;
+  }
+  return `${trimmed}/v1`;
+}
+function getOpenAIApiType(baseUrl) {
+  const normalized = baseUrl.toLowerCase();
+  return normalized.includes("api.openai.com") ? "openai" : "openai-compatible";
+}
+function isGoogleGeminiBaseUrl(baseUrl) {
+  const normalized = baseUrl.toLowerCase();
+  return normalized.includes("generativelanguage.googleapis.com") || normalized.includes("/v1beta");
+}
+async function listAnthropicModels() {
+  const baseUrlRaw = (process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com").replace(/\/+$/, "");
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  const baseUrl = baseUrlRaw.endsWith("/v1") ? baseUrlRaw : `${baseUrlRaw}/v1`;
+  console.log(c.bold("Anthropic Models:"));
+  console.log(c.dim("  API Type: anthropic (official)"));
+  console.log(c.dim(`  Base URL: ${baseUrl}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ ANTHROPIC_API_KEY not set"));
+    console.log();
+    return;
+  }
+  const res = await fetch(`${baseUrl}/models`, {
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${baseUrl}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const name = item.display_name ? ` (${item.display_name})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${name}`);
+  }
+  console.log();
+}
+async function listOpenAIModels() {
+  const baseUrl = normalizeOpenAIBaseUrl(process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1");
+  const apiFlavor = getOpenAIApiType(baseUrl);
+  const apiKey = process.env.OPENAI_API_KEY;
+  console.log(c.bold("OpenAI Models:"));
+  console.log(c.dim(`  API Type: ${apiFlavor}`));
+  console.log(c.dim(`  Base URL: ${baseUrl}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ OPENAI_API_KEY not set"));
+    console.log();
+    return;
+  }
+  const res = await fetch(`${baseUrl}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${baseUrl}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const owner = item.owned_by ? ` (${item.owned_by})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${owner}`);
+  }
+  console.log();
+}
+async function listGeminiModels() {
+  const baseUrlRaw = (process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta").replace(/\/+$/, "");
+  const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+  console.log(c.bold("Gemini Models:"));
+  console.log(c.dim(`  Base URL: ${baseUrlRaw}`));
+  if (!apiKey) {
+    console.log(c.red("  ✗ GEMINI_API_KEY not set"));
+    console.log();
+    return;
+  }
+  if (isGoogleGeminiBaseUrl(baseUrlRaw)) {
+    console.log(c.dim("  API Type: gemini"));
+    const url = `${baseUrlRaw}/models`;
+    const res2 = await fetch(url, {
+      headers: { "x-goog-api-key": apiKey }
+    });
+    if (!res2.ok) {
+      console.log(c.red(`  ✗ Failed to fetch models (${res2.status})`));
+      console.log(c.dim(`  URL: ${url}`));
+      console.log();
+      return;
+    }
+    const payload2 = await res2.json();
+    const items2 = payload2.models ?? [];
+    for (const item of items2) {
+      console.log(`  ${c.green("●")} ${item.name}`);
+    }
+    console.log();
+    return;
+  }
+  const openaiBase = normalizeOpenAIBaseUrl(baseUrlRaw);
+  console.log(c.dim("  API Type: openai-compatible"));
+  console.log(c.dim("  Auth: Bearer (GEMINI_API_KEY)"));
+  const res = await fetch(`${openaiBase}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${openaiBase}/models`));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const owner = item.owned_by ? ` (${item.owned_by})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${owner}`);
+  }
+  console.log();
+}
+async function listModelsSummary() {
+  const provider = getActiveProviderId();
+  const apiType = provider ?? "auto";
+  console.log();
+  console.log(c.bold("Available Models:"));
+  console.log(c.dim(`  Active Provider: ${apiType}`));
+  console.log();
+  printModelsHelp();
+  try {
+    await listOpenAIModels();
+  } catch (error) {
+    console.log(c.red(`  ✗ OpenAI: ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
+  try {
+    await listGeminiModels();
+  } catch (error) {
+    console.log(c.red(`  ✗ Gemini: ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
+  await listAnthropicModels();
+}
+function printDebug() {
+  const model = getActiveModel();
+  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("Provider:")}       ${getActiveProviderId() ?? "auto"}`);
+  console.log(`  ${c.cyan("Override:")}       ${currentModelOverride ?? c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("ANTHROPIC_MODEL:")} ${process.env.ANTHROPIC_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("GEMINI_MODEL:")}    ${process.env.GEMINI_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("GEMINI_BASE_URL:")} ${process.env.GEMINI_BASE_URL || 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 geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_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("GEMINI_API_KEY:")}    ${geminiKey ? c.green("✓ set") + c.dim(` (${geminiKey.slice(0, 8)}...${geminiKey.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":
@@ -4349,19 +6638,94 @@ function formatToolInput(name, input) {
       return JSON.stringify(input).slice(0, 50);
   }
 }
-function getDefaultModel() {
+function getDefaultProviderFromEnv() {
   if (process.env.ANTHROPIC_API_KEY) {
-    return process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+    return "anthropic";
   }
   if (process.env.OPENAI_API_KEY) {
-    return process.env.OPENAI_MODEL || "gpt-4o";
+    return "openai";
+  }
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+    return "gemini";
+  }
+  return null;
+}
+function inferProviderFromModel(model) {
+  const normalized = model.toLowerCase();
+  if (normalized.startsWith("claude")) {
+    return "anthropic";
+  }
+  if (normalized.startsWith("gpt") || normalized.startsWith("o1") || normalized.startsWith("chatgpt")) {
+    return "openai";
+  }
+  if (normalized.startsWith("gemini") || normalized.startsWith("models/gemini")) {
+    return "gemini";
+  }
+  return null;
+}
+function getDefaultModelForProvider(providerId) {
+  if (providerId === "anthropic") {
+    return process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
+  }
+  if (providerId === "gemini") {
+    return process.env.GEMINI_MODEL || "gemini-1.5-pro";
+  }
+  return process.env.OPENAI_MODEL || "gpt-5.2";
+}
+function getActiveProviderId() {
+  if (currentProviderId) {
+    return currentProviderId;
+  }
+  if (currentModelOverride) {
+    return inferProviderFromModel(currentModelOverride);
+  }
+  return getDefaultProviderFromEnv();
+}
+function getActiveModel() {
+  if (currentModelOverride) {
+    return currentModelOverride;
+  }
+  const provider = getActiveProviderId();
+  if (provider) {
+    return getDefaultModelForProvider(provider);
   }
   return "claude-sonnet-4-20250514";
 }
+function parseProvider(arg) {
+  const normalized = arg.toLowerCase();
+  if (normalized === "anthropic" || normalized === "claude") {
+    return "anthropic";
+  }
+  if (normalized === "openai" || normalized === "gpt") {
+    return "openai";
+  }
+  if (normalized === "gemini" || normalized === "google") {
+    return "gemini";
+  }
+  return null;
+}
+function createProvider(providerId) {
+  if (providerId === "anthropic") {
+    return new AnthropicProvider;
+  }
+  if (providerId === "gemini") {
+    return new GeminiProvider({
+      apiKey: process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY,
+      baseUrl: process.env.GEMINI_BASE_URL
+    });
+  }
+  return new OpenAIProvider({
+    apiKey: process.env.OPENAI_API_KEY,
+    baseUrl: process.env.OPENAI_BASE_URL
+  });
+}
 async function getSession() {
   if (!session) {
+    const providerId = getActiveProviderId();
+    const provider = providerId ? createProvider(providerId) : undefined;
     session = await createSession({
-      model: getDefaultModel(),
+      model: getActiveModel(),
+      provider,
       tools: getAllTools(),
       systemPrompt: buildSystemPrompt()
     });
@@ -4419,7 +6783,9 @@ async function handleInput(input) {
     return true;
   }
   if (trimmed.startsWith("/")) {
-    const cmd = trimmed.toLowerCase();
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
     switch (cmd) {
       case "/help":
         printInteractiveHelp();
@@ -4443,12 +6809,18 @@ async function handleInput(input) {
       case "/skills":
         await printSkills();
         return true;
+      case "/models":
+        await handleModelsCommand(args);
+        return true;
       case "/todos":
         printTodos();
         return true;
       case "/usage":
         printUsage();
         return true;
+      case "/debug":
+        printDebug();
+        return true;
       case "/exit":
       case "/quit":
       case "/q":
@@ -4472,9 +6844,9 @@ Error: ${error instanceof Error ? error.message : String(error)}
   return true;
 }
 async function runQuickQuery(query) {
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) {
     console.error(c.red("Error: No API key found"));
-    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable"));
     process.exit(1);
   }
   try {
@@ -4488,9 +6860,9 @@ async function runQuickQuery(query) {
   }
 }
 async function runInteractive() {
-  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+  if (!process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY && !process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) {
     console.error(c.red("Error: No API key found"));
-    console.error(c.dim("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable"));
+    console.error(c.dim("Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY environment variable"));
     process.exit(1);
   }
   setTodoChangeCallback(() => {});