markov-cli 1.0.11 → 1.0.12

package/.env.example

@@ -0,0 +1,12 @@
+# Optional: enable web search in the CLI AI (uses Serper by default).
+# Get a key at https://serper.dev
+# MARKOV_SEARCH_API_KEY=your_serper_api_key
+
+# Optional: use Anthropic (Claude) instead of the backend. Takes priority over OpenAI when set.
+# ANTHROPIC_API_KEY=sk-ant-your_anthropic_api_key
+# ANTHROPIC_MODEL=claude-haiku-4-5-20251001
+# Or Claude 3.5 Sonnet (if still available): ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
+
+# Optional: use OpenAI (ChatGPT) instead of the backend. Used when ANTHROPIC_API_KEY is not set.
+# OPENAI_API_KEY=sk-your_openai_api_key
+# OPENAI_MODEL=gpt-4o-mini

package/bin/markov.js

@@ -1,4 +1,19 @@
 #!/usr/bin/env node
 
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageEnv = path.resolve(__dirname, '../.env');
+
+// Load from package dir first (for npm link / local dev), then cwd (project-specific overrides)
+const r1 = dotenv.config({ path: packageEnv });
+dotenv.config();
+
+if (process.env.MARKOV_DEBUG && r1.error && r1.error.code === 'ENOENT') {
+  console.error(`[markov] .env not found at ${packageEnv} (run from CLI project dir or ensure .env exists)`);
+}
+
 const { startInteractive } = await import('../src/interactive.js');
 startInteractive();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markov-cli",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Markov CLI",
   "type": "module",
   "bin": {

package/src/agent/agentLoop.js

@@ -0,0 +1,131 @@
+import chalk from 'chalk';
+import { streamChatWithTools, MODEL } from '../ollama.js';
+import { runTool, AGENT_TOOLS } from '../tools.js';
+import { printTokenUsage, formatToolCallSummary, formatToolResultSummary, formatResponseWithCodeBlocks } from '../ui/formatting.js';
+
+export const AGENT_LOOP_MAX_ITERATIONS = 20;
+
+/** If MARKOV_DEBUG is set, print the full message payload (system + conversation) before sending. */
+export function maybePrintFullPayload(messages) {
+  if (!process.env.MARKOV_DEBUG) return;
+  const payload = messages.map((m) => ({
+    role: m.role,
+    ...(m.tool_calls && { tool_calls: m.tool_calls.length }),
+    ...(m.tool_name && { tool_name: m.tool_name }),
+    content: typeof m.content === 'string' ? m.content : '(binary/object)',
+  }));
+  console.log(chalk.dim('\n--- MARKOV_DEBUG: full payload sent to API ---'));
+  console.log(JSON.stringify(payload, null, 2));
+  console.log(chalk.dim('--- end payload ---\n'));
+}
+
+/**
+ * Run the agent loop: call chatWithTools, run any tool_calls locally, append results, repeat until the model returns a final response.
+ * For search_replace, confirmFileEdit is called first; if it returns false, the change is skipped and the model is told the user declined.
+ * @param {Array<{ role: string; content?: string; tool_calls?: unknown[]; tool_name?: string }>} messages - Full message list (system + conversation)
+ * @param {{ signal?: AbortSignal; cwd?: string; executionProvider?: string; confirmFn?: (command: string) => Promise<boolean>; confirmFileEdit?: (name: string, args: object) => Promise<boolean>; onBeforeToolRun?: () => void; onToolCall?: (name: string, args: object) => void; onToolResult?: (name: string, result: string) => void }} opts
+ * @returns {Promise<{ content: string; finalMessage: object } | null>} Final assistant content and message, or null if cancelled/error
+ */
+export async function runAgentLoop(messages, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const confirmFn = opts.confirmFn;
+  const confirmFileEdit = opts.confirmFileEdit;
+  const onBeforeToolRun = opts.onBeforeToolRun;
+  const onToolCall = opts.onToolCall;
+  const onToolResult = opts.onToolResult;
+  const onIteration = opts.onIteration;
+  const onThinking = opts.onThinking;
+  let iteration = 0;
+
+  while (iteration < AGENT_LOOP_MAX_ITERATIONS) {
+    iteration += 1;
+    onThinking?.(iteration);
+    const { content: streamContent, toolCalls, usage } = await streamChatWithTools(
+      messages,
+      AGENT_TOOLS,
+      MODEL,
+      {
+        onContent: opts.onStreamContent,
+        onThinking: opts.onStreamThinking,
+      },
+      opts.signal ?? null,
+      opts.executionProvider ?? null
+    );
+
+    // Ensure each tool call has an id (backend may omit it); needed for Anthropic tool_result matching
+    const normalizedToolCalls = toolCalls?.map((tc, i) => ({
+      ...tc,
+      id: tc.id || `toolu_${i}_${Math.random().toString(36).slice(2)}`,
+    }));
+    const message = {
+      role: 'assistant',
+      content: streamContent ?? '',
+      ...(normalizedToolCalls && normalizedToolCalls.length > 0 && { tool_calls: normalizedToolCalls }),
+    };
+
+    if (!toolCalls || toolCalls.length === 0) {
+      printTokenUsage(usage);
+      return { content: message.content ?? '', finalMessage: message };
+    }
+
+    // Append assistant message with tool_calls
+    messages.push(message);
+
+    onBeforeToolRun?.();
+    onIteration?.(iteration, AGENT_LOOP_MAX_ITERATIONS, normalizedToolCalls.length);
+
+    for (const tc of normalizedToolCalls) {
+      const name = tc?.function?.name;
+      const rawArgs = tc?.function?.arguments;
+      let args = rawArgs;
+      if (typeof rawArgs === 'string') {
+        try {
+          args = JSON.parse(rawArgs);
+        } catch {
+          messages.push({
+            role: 'tool',
+            tool_name: name ?? 'unknown',
+            tool_call_id: tc.id,
+            content: JSON.stringify({ error: 'Invalid JSON in arguments' }),
+          });
+          if (onToolCall) onToolCall(name ?? 'unknown', {});
+          if (onToolResult) onToolResult(name ?? 'unknown', JSON.stringify({ error: 'Invalid JSON in arguments' }));
+          continue;
+        }
+      }
+
+      if (onToolCall) onToolCall(name ?? 'unknown', args ?? {});
+
+      const isFileEdit = name === 'search_replace';
+      let result;
+      if (isFileEdit && confirmFileEdit) {
+        const ok = await confirmFileEdit(name, args ?? {});
+        if (!ok) {
+          result = JSON.stringify({ declined: true, message: 'User declined the change' });
+          if (onToolResult) onToolResult(name ?? 'unknown', result);
+          messages.push({
+            role: 'tool',
+            tool_name: name ?? 'unknown',
+            tool_call_id: tc.id,
+            content: result,
+          });
+          continue;
+        }
+      }
+
+      result = await runTool(name, args ?? {}, { cwd, confirmFn });
+      if (onToolResult) onToolResult(name ?? 'unknown', typeof result === 'string' ? result : JSON.stringify(result));
+      messages.push({
+        role: 'tool',
+        tool_name: name ?? 'unknown',
+        tool_call_id: tc.id,
+        content: typeof result === 'string' ? result : JSON.stringify(result),
+      });
+    }
+  }
+
+  return {
+    content: '(agent loop reached max iterations)',
+    finalMessage: { role: 'assistant', content: '(max iterations)' },
+  };
+}

package/src/agent/context.js

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { execCommand } from '../tools.js';
+import { getFiles } from '../ui/picker.js';
+
+const MARKOV_FILE = 'markov.md';
+
+const GREP_DEFAULT_PATTERN = 'function |class |export |def ';
+const GREP_MAX_LINES_DEFAULT = 400;
+const GREP_INCLUDE = "--include='*.js' --include='*.ts' --include='*.jsx' --include='*.tsx' --include='*.py'";
+/** Portable: filter paths with grep -v (BSD grep may not support --exclude-dir). */
+const GREP_FILTER_PATHS = "| grep -v '/node_modules/' | grep -v '/.git/' | grep -v '/.next/' | grep -v '/dist/' | grep -v '/build/' | grep -v '/coverage/'";
+
+/** Safe chars for MARKOV_GREP_PATTERN (no shell metacharacters). */
+function isValidGrepPattern(p) {
+  if (typeof p !== 'string' || p.length > 200) return false;
+  return /^[a-zA-Z0-9 \|\.\-_\\\[\]\(\)\?\+\*]+$/.test(p);
+}
+
+/** Run `ls -la` in cwd and return a context string to prepend to user messages. */
+export async function getLsContext(cwd = process.cwd()) {
+  try {
+    const { stdout, stderr, exitCode } = await execCommand('ls -la', cwd);
+    const out = [stdout, stderr].filter(Boolean).join('\n').trim();
+    if (exitCode === 0 && out) {
+      return `[Current directory: ${cwd}]\n$ ls -la\n${out}\n\n`;
+    }
+  } catch (_) {}
+  return `[Current directory: ${cwd}]\n(listing unavailable)\n\n`;
+}
+
+/** Run grep for key definitions; return context block or empty string. Only runs when MARKOV_GREP_CONTEXT=1. */
+export async function getGrepContext(cwd = process.cwd()) {
+  if (!process.env.MARKOV_GREP_CONTEXT) return '';
+
+  const rawPattern = process.env.MARKOV_GREP_PATTERN;
+  const pattern = (rawPattern && isValidGrepPattern(rawPattern.trim())) ? rawPattern.trim() : GREP_DEFAULT_PATTERN;
+  const maxLines = Math.min(2000, Math.max(1, parseInt(process.env.MARKOV_GREP_MAX_LINES, 10) || GREP_MAX_LINES_DEFAULT));
+  const escaped = pattern.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const cmd = `grep -rn -E "${escaped}" ${GREP_INCLUDE} . 2>/dev/null ${GREP_FILTER_PATHS} | head -n ${maxLines}`;
+
+  try {
+    const { stdout, exitCode } = await execCommand(cmd, cwd);
+    const out = (stdout || '').trim();
+    if (exitCode === 0 && out) {
+      return `[Grep: key definitions in repo]\n$ grep -rn -E '${pattern}' ...\n${out}\n\n`;
+    }
+  } catch (_) {}
+  return `[Grep: key definitions in repo]\n(grep context unavailable)\n\n`;
+}
+
+/** Shared system message base: Markov intro, cwd, file list, and markov.md summary if present. */
+export function getSystemMessageBase() {
+  const files = getFiles();
+  const fileList = files.length > 0 ? `\nFiles in working directory:\n${files.map(f => `  ${f}`).join('\n')}\n` : '';
+  let out = `You are Markov, an AI CLI coding assistant.\nWorking directory: ${process.cwd()}\n${fileList}`;
+  const markovPath = resolve(process.cwd(), MARKOV_FILE);
+  if (existsSync(markovPath)) {
+    try {
+      const summary = readFileSync(markovPath, 'utf-8').trim();
+      if (summary) out += `\n\nProject summary (markov.md):\n${summary}`;
+    } catch (_) {}
+  }
+  return out;
+}
+
+/** System message for /plan: research with tools, then output a step-by-step plan (saved to plan.md; /build runs it). */
+export function buildPlanSystemMessage() {
+  return {
+    role: 'system',
+    content: getSystemMessageBase() +
+      '\n\nPLAN MODE — two phases.\n' +
+      '1) RESEARCH (DONT OVERTHINK) (use tools now): Use web_search and run_terminal_command to gather facts, check docs, list files, inspect the codebase. You may use at most 3 web_search calls; use them sparingly for the most relevant queries. Do not describe research in your final plan.\n' +
+      '2) OUTPUT THE PLAN: After research, you MUST output a plan. Output a single plan as clear, numbered steps. Each step must be an actionable instruction (e.g. "Create src/foo.js with …", "Run npm install", "Add route X in file Y"). No vague steps like "Gather information" or "Investigate options"—do that in phase 1 with tools. In plan mode, plan.md is always created or overwritten with your plan output; the user then runs /build, which executes only the contents of plan.md.',
+  };
+}
+
+/** System message for /init: create markov.md with project summary using tools. */
+export function buildInitSystemMessage() {
+  return {
+    role: 'system',
+    content: getSystemMessageBase() +
+      '\n\nINIT MODE — your only goal is to create or overwrite markov.md in the project root with a concise project summary.\n' +
+      'Use run_terminal_command to list files, read key files (e.g. README, package.json), and to write markov.md (e.g. cat > markov.md << \'EOF\' ... EOF). You may use web_search if needed. Use RELATIVE paths. When done, reply briefly that markov.md was created.',
+  };
+}
+
+/** System message for agent mode: tool-only instructions (no !!run / !!write). */
+export function buildAgentSystemMessage() {
+  const toolInstructions =
+    `\nTOOL MODE — you have tools; use them. \n` +
+    `- run_terminal_command: run shell commands (npm install, npx create-next-app, etc.). Use this to create or overwrite files (e.g. echo 'content' > path, cat > path << 'EOF', tee). One command per call.\n` +
+    // `- create_folder: create directories.\n` +
+    `- read_file: read file contents before editing.\n` +
+    `- search_replace: replace first occurrence of text in a file (for small, targeted edits).\n` +
+    // `- delete_file: delete a file.\n` +
+    // `- list_dir: list directory contents (path optional, defaults to current dir).\n` +
+    `- web_search: search the web for current information; use when the user asks about recent events, docs, or facts.\n` +
+    `When the user asks to run commands, create/edit/delete files, scaffold projects, or to "plan" or "start" an app (e.g. npm run dev), you MUST call the appropriate tool. Do not only describe steps in your reply.\n` +
+    `For file creation or overwriting, use run_terminal_command only (e.g. echo, cat, heredocs, tee). For small edits use search_replace. Never paste full file contents directly in your reply. All file operations must use RELATIVE paths. Do not output modified file contents in chat — apply changes through tool calls only.\n`;
+  return { role: 'system', content: getSystemMessageBase() + toolInstructions };
+}

package/src/auth.js

@@ -4,9 +4,55 @@ import { homedir } from 'os';
 
 const CONFIG_DIR = join(homedir(), '.markov');
 const TOKEN_PATH = join(CONFIG_DIR, 'token');
+const ANTHROPIC_KEY_PATH = join(CONFIG_DIR, 'anthropic_api_key');
+const OPENAI_KEY_PATH = join(CONFIG_DIR, 'openai_api_key');
 
 export const API_URL = 'https://api.livingcloud.app/api';
 
+export function getOpenAIKey() {
+  const env = process.env.OPENAI_API_KEY?.trim();
+  if (env) return env;
+  if (!existsSync(OPENAI_KEY_PATH)) return null;
+  return readFileSync(OPENAI_KEY_PATH, 'utf-8').trim() || null;
+}
+
+export function setOpenAIKey(key) {
+  const trimmed = (key && String(key).trim()) || '';
+  if (!trimmed) return;
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(OPENAI_KEY_PATH, trimmed, 'utf-8');
+  process.env.OPENAI_API_KEY = trimmed;
+}
+
+export function clearOpenAIKey() {
+  if (existsSync(OPENAI_KEY_PATH)) {
+    writeFileSync(OPENAI_KEY_PATH, '', 'utf-8');
+  }
+  delete process.env.OPENAI_API_KEY;
+}
+
+export function getClaudeKey() {
+  const env = process.env.ANTHROPIC_API_KEY?.trim();
+  if (env) return env;
+  if (!existsSync(ANTHROPIC_KEY_PATH)) return null;
+  return readFileSync(ANTHROPIC_KEY_PATH, 'utf-8').trim() || null;
+}
+
+export function setClaudeKey(key) {
+  const trimmed = (key && String(key).trim()) || '';
+  if (!trimmed) return;
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(ANTHROPIC_KEY_PATH, trimmed, 'utf-8');
+  process.env.ANTHROPIC_API_KEY = trimmed;
+}
+
+export function clearClaudeKey() {
+  if (existsSync(ANTHROPIC_KEY_PATH)) {
+    writeFileSync(ANTHROPIC_KEY_PATH, '', 'utf-8');
+  }
+  delete process.env.ANTHROPIC_API_KEY;
+}
+
 export function getToken() {
   if (!existsSync(TOKEN_PATH)) return null;
   return readFileSync(TOKEN_PATH, 'utf-8').trim() || null;

package/src/claude.js

@@ -0,0 +1,318 @@
+/**
+ * Anthropic (Claude) client for the CLI.
+ * Used when ANTHROPIC_API_KEY is set (env or ~/.markov); same interface as openai.js.
+ *
+ * Converts between CLI/OpenAI message format and Anthropic API format.
+ */
+
+import { getClaudeKey } from './auth.js';
+
+const ANTHROPIC_API = 'https://api.anthropic.com/v1';
+const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || 'claude-haiku-4-5-20251001';
+
+const RATE_LIMIT_MAX_RETRIES = 3;
+const RATE_LIMIT_DEFAULT_WAIT_MS = 60_000; // 1 minute (limit is per minute)
+
+function getHeaders() {
+  const key = getClaudeKey();
+  if (!key || !key.trim()) throw new Error('Claude API key is not set');
+  return {
+    'Content-Type': 'application/json',
+    'x-api-key': key.trim(),
+    'anthropic-version': ANTHROPIC_VERSION,
+  };
+}
+
+/**
+ * Fetch with retry on 429 (rate limit). Waits Retry-After seconds or default 60s, then retries up to RATE_LIMIT_MAX_RETRIES.
+ */
+async function fetchWithRetry(url, options, signal = null) {
+  let lastRes = null;
+  let lastErr = null;
+  for (let attempt = 0; attempt <= RATE_LIMIT_MAX_RETRIES; attempt++) {
+    const res = await fetch(url, { ...options, signal: signal ?? undefined });
+    lastRes = res;
+    if (res.status !== 429) return res;
+    await res.text(); // drain body
+    if (attempt === RATE_LIMIT_MAX_RETRIES) break;
+    const retryAfter = res.headers.get('retry-after');
+    const waitMs = retryAfter ? Math.min(120, Math.max(1, parseInt(retryAfter, 10))) * 1000 : RATE_LIMIT_DEFAULT_WAIT_MS;
+    await new Promise((r) => setTimeout(r, waitMs));
+  }
+  const errBody = await lastRes.text().catch(() => '');
+  lastErr = new Error(`Anthropic API error ${lastRes.status} ${lastRes.statusText} (rate limited; retried ${RATE_LIMIT_MAX_RETRIES} times)${errBody ? ': ' + errBody : ''}`);
+  throw lastErr;
+}
+
+/**
+ * Convert CLI messages (OpenAI-compatible format) to Anthropic format.
+ * - System messages are extracted into a top-level system string.
+ * - Assistant tool_calls become tool_use content blocks.
+ * - Tool role messages are grouped into user messages with tool_result blocks.
+ */
+function toClaudeMessages(messages) {
+  const systemParts = [];
+  const out = [];
+  let lastToolUseIds = [];
+  let toolResultBuffer = [];
+
+  function flushToolResults() {
+    if (toolResultBuffer.length === 0) return;
+    const results = toolResultBuffer.map((item, i) => {
+      const content = typeof item === 'string' ? item : item.content;
+      const id = (typeof item === 'object' && item?.tool_use_id) || lastToolUseIds[i] || lastToolUseIds[0];
+      if (!id) throw new Error(`Tool result ${i} has no tool_use_id and no matching tool_use from previous assistant message.`);
+      return { type: 'tool_result', tool_use_id: id, content };
+    });
+    out.push({ role: 'user', content: results });
+    toolResultBuffer = [];
+  }
+
+  for (const m of messages) {
+    if (m.role === 'tool') {
+      const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
+      toolResultBuffer.push(m.tool_call_id ? { content, tool_use_id: m.tool_call_id } : content);
+      continue;
+    }
+
+    flushToolResults();
+
+    if (m.role === 'system') {
+      systemParts.push(typeof m.content === 'string' ? m.content : '');
+      continue;
+    }
+    if (m.role === 'user') {
+      lastToolUseIds = [];
+      out.push({ role: 'user', content: typeof m.content === 'string' ? m.content : '' });
+      continue;
+    }
+    if (m.role === 'assistant') {
+      const content = [];
+      const text = typeof m.content === 'string' ? m.content : '';
+      if (text) content.push({ type: 'text', text });
+      lastToolUseIds = [];
+      if (m.tool_calls && Array.isArray(m.tool_calls)) {
+        for (const tc of m.tool_calls) {
+          const id = tc.id || `toolu_${Math.random().toString(36).slice(2)}`;
+          let input = {};
+          try { input = JSON.parse(tc.function?.arguments || '{}'); } catch (_) {}
+          content.push({ type: 'tool_use', id, name: tc.function?.name ?? 'unknown', input });
+          lastToolUseIds.push(id);
+        }
+      }
+      out.push({ role: 'assistant', content: content.length > 0 ? content : [{ type: 'text', text: '' }] });
+    }
+  }
+
+  flushToolResults();
+
+  return { system: systemParts.join('\n\n') || undefined, messages: out };
+}
+
+/**
+ * Convert Ollama/OpenAI-format tools to Anthropic format.
+ * Renames `parameters` → `input_schema` and drops the outer `type: 'function'` wrapper.
+ */
+function toClaudeTools(tools) {
+  if (!tools || tools.length === 0) return undefined;
+  return tools.map((t) => {
+    const f = t.function ?? t;
+    return {
+      name: f.name,
+      description: f.description ?? '',
+      input_schema: f.parameters ?? { type: 'object', properties: {} },
+    };
+  });
+}
+
+/**
+ * Convert an Anthropic content array back to CLI format: { text, toolCalls }.
+ * toolCalls uses OpenAI format ({ id, type, function: { name, arguments } }) for compatibility.
+ */
+function contentToCliFormat(content) {
+  if (!Array.isArray(content)) {
+    return { text: typeof content === 'string' ? content : '', toolCalls: null };
+  }
+  let text = '';
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.type === 'text') text += block.text || '';
+    if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input ?? {}),
+        },
+      });
+    }
+  }
+  return { text, toolCalls: toolCalls.length > 0 ? toolCalls : null };
+}
+
+/**
+ * Stream chat (no tools). Same signature as openai.js streamChat.
+ */
+export async function streamChat(messages, onToken, _model = DEFAULT_MODEL, signal = null, opts = {}) {
+  const { system, messages: claudeMessages } = toClaudeMessages(messages);
+  const body = { model: _model, max_tokens: 8096, messages: claudeMessages, stream: true, temperature: 0.2 };
+  if (system) body.system = system;
+
+  const res = await fetchWithRetry(
+    `${ANTHROPIC_API}/messages`,
+    { method: 'POST', headers: getHeaders(), body: JSON.stringify(body) },
+    signal
+  );
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '');
+    throw new Error(`Anthropic API error ${res.status} ${res.statusText}${errBody ? ': ' + errBody : ''}`);
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullText = '';
+
+  try {
+    while (true) {
+      if (signal?.aborted) { reader.cancel(); break; }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === 'content_block_delta' && parsed.delta?.type === 'text_delta') {
+            fullText += parsed.delta.text;
+            onToken(parsed.delta.text);
+          }
+        } catch (_) {}
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return fullText;
+}
+
+/**
+ * Chat with tools (non-streaming). Returns { message } with message.content and optional message.tool_calls.
+ */
+export async function chatWithTools(messages, tools, model = DEFAULT_MODEL, signal = null) {
+  const { system, messages: claudeMessages } = toClaudeMessages(messages);
+  const claudeTools = toClaudeTools(tools);
+  const body = { model, max_tokens: 8096, messages: claudeMessages, temperature: 0.2 };
+  if (system) body.system = system;
+  if (claudeTools) body.tools = claudeTools;
+
+  const res = await fetchWithRetry(
+    `${ANTHROPIC_API}/messages`,
+    { method: 'POST', headers: getHeaders(), body: JSON.stringify(body) },
+    signal
+  );
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '');
+    throw new Error(`Anthropic API error ${res.status} ${res.statusText}${errBody ? ': ' + errBody : ''}`);
+  }
+
+  const data = await res.json();
+  const { text, toolCalls } = contentToCliFormat(data.content);
+  return {
+    message: {
+      role: 'assistant',
+      content: text,
+      tool_calls: toolCalls ?? undefined,
+    },
+    usage: data.usage ?? null,
+  };
+}
+
+/**
+ * Stream chat with tools. Returns { content, toolCalls } where toolCalls are in OpenAI format for compatibility.
+ */
+export async function streamChatWithTools(messages, tools, model = DEFAULT_MODEL, callbacks = {}, signal = null) {
+  const onContent = callbacks.onContent;
+  const { system, messages: claudeMessages } = toClaudeMessages(messages);
+  const claudeTools = toClaudeTools(tools);
+  const body = { model, max_tokens: 8096, messages: claudeMessages, stream: true, temperature: 0.2 };
+  if (system) body.system = system;
+  if (claudeTools) body.tools = claudeTools;
+
+  const res = await fetchWithRetry(
+    `${ANTHROPIC_API}/messages`,
+    { method: 'POST', headers: getHeaders(), body: JSON.stringify(body) },
+    signal
+  );
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '');
+    throw new Error(`Anthropic API error ${res.status} ${res.statusText}${errBody ? ': ' + errBody : ''}`);
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let fullContent = '';
+  const blocks = {}; // index -> { type, id?, name?, text?, inputJson? }
+  let usage = null;
+
+  try {
+    while (true) {
+      if (signal?.aborted) { reader.cancel(); break; }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === 'message_delta' && parsed.usage) usage = parsed.usage;
+          if (parsed.type === 'content_block_start') {
+            const { index, content_block: cb } = parsed;
+            blocks[index] = { type: cb.type };
+            if (cb.type === 'tool_use') {
+              blocks[index].id = cb.id;
+              blocks[index].name = cb.name;
+              blocks[index].inputJson = '';
+            } else if (cb.type === 'text') {
+              blocks[index].text = '';
+            }
+          } else if (parsed.type === 'content_block_delta') {
+            const { index, delta } = parsed;
+            if (!blocks[index]) continue;
+            if (delta.type === 'text_delta') {
+              blocks[index].text = (blocks[index].text || '') + delta.text;
+              fullContent += delta.text;
+              if (onContent) onContent(delta.text);
+            } else if (delta.type === 'input_json_delta') {
+              blocks[index].inputJson = (blocks[index].inputJson || '') + delta.partial_json;
+            }
+          }
+        } catch (_) {}
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const toolCalls = Object.keys(blocks)
+    .sort((a, b) => Number(a) - Number(b))
+    .filter((k) => blocks[k].type === 'tool_use')
+    .map((k) => {
+      const b = blocks[k];
+      return { id: b.id, type: 'function', function: { name: b.name, arguments: b.inputJson || '{}' } };
+    })
+    .filter((tc) => tc.id || tc.function?.name);
+
+  return { content: fullContent, toolCalls: toolCalls.length > 0 ? toolCalls : null, usage };
+}
+
+export const ANTHROPIC_MODEL = DEFAULT_MODEL;