nothumanallowed 15.0.19 → 15.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "15.0.19",
+  "version": "15.1.0",
   "description": "NotHumanAllowed — 38 AI agents, 80 tools, Studio (visual agentic workflows). Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {

package/src/server/routes/webcraft.mjs

@@ -19,7 +19,7 @@ import { createServer } from 'net';
 import { promisify } from 'util';
 import { sendJSON, sendError, parseBody, sendSSE } from '../index.mjs';
 import { loadConfig }   from '../../config.mjs';
-import { callLLM, callLLMStream, fixQwen3BPE } from '../../services/llm.mjs';
+import { callLLM, callLLMStream, callLLMWithTools, getApiKey, fixQwen3BPE } from '../../services/llm.mjs';
 import { NHA_DIR } from '../../constants.mjs';
 import * as acorn from 'acorn';
 import acornJsx from 'acorn-jsx';
@@ -616,41 +616,31 @@ async function runWebCraftAgent(config, projectName, message, attachments, emit,
   const LANG_MAP = { en:'English',it:'Italian',es:'Spanish',fr:'French',de:'German',pt:'Portuguese' };
   const language = LANG_MAP[(config?.language||'it').slice(0,2)] || 'Italian';
 
-  const toolSpec = `
-TOOLS — use exactly ONE <tool> tag per action:
-
-1. read — Read file:
-<tool>{"op":"read","path":"file.js"}</tool>
-
-2. edit — Change specific lines in a file (THE ONLY WAY TO MODIFY FILES):
-<tool>{"op":"edit","path":"file.js","old":"exact code to replace","new":"replacement code"}</tool>
-CRITICAL: "old" must be EXACT text from the file. Always read the file first, then copy-paste the exact lines you want to change.
-
-3. write — Create a NEW file (ONLY for files that don't exist yet):
-<tool>{"op":"write","path":"new-file.js","content":"file content"}</tool>
-
-4. rename: <tool>{"op":"rename","path":"old.js","newPath":"new.js"}</tool>
-5. delete: <tool>{"op":"delete","path":"file.js"}</tool>
-6. check: <tool>{"op":"check","path":"file.js"}</tool>
-7. lint: <tool>{"op":"lint","path":"file.js"}</tool>
-8. search: <tool>{"op":"search","query":"pattern","glob":"*.js"}</tool>
-9. list: <tool>{"op":"list"}</tool>
-10. run: <tool>{"op":"run","cmd":"npm test"}</tool>
-11. sandbox: <tool>{"op":"sandbox"}</tool>
-12. diff: <tool>{"op":"diff","path":"file.js"}</tool>
-
-WORKFLOW:
-1. read → 2. edit (surgical changes ONLY) → 3. check → 4. sandbox → 5. <done/>
-
-⚠ CRITICAL RULES:
-- To modify an existing file: ALWAYS use edit. NEVER use write on existing files — it will be REJECTED.
-- edit workflow: read the file first → copy EXACT lines from the read output → use edit with old/new
-- To APPEND content to a truncated file: use edit where "old" is the last few lines of the file, and "new" is those same lines PLUS the new content after them.
-- Keep each edit SMALL — max 30-40 lines of old/new. If you need to add more, do MULTIPLE edits.
-- If edit returns "old_not_found": your old text didn't match. Read the file again and retry with the EXACT text.
-- NEVER say you fixed something without verifying — use check or read after edit to confirm.
-- write is ONLY for creating brand new files
-- Output <done/> when finished
+  // Native tool definitions for function calling (Anthropic/OpenAI)
+  const nativeTools = [
+    { name: 'read_file', description: 'Read a file from the project', input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Relative path to the file' } }, required: ['path'] } },
+    { name: 'edit_file', description: 'Make a surgical edit to an existing file. The old_text must be an EXACT match of the current file content. Copy-paste from read_file output.', input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Relative path' }, old_text: { type: 'string', description: 'Exact text to replace (copy from read_file output)' }, new_text: { type: 'string', description: 'Replacement text' } }, required: ['path', 'old_text', 'new_text'] } },
+    { name: 'create_file', description: 'Create a new file. ONLY for files that do not exist yet. Cannot overwrite existing files.', input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Relative path' }, content: { type: 'string', description: 'Full file content' } }, required: ['path', 'content'] } },
+    { name: 'delete_file', description: 'Delete a file', input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Relative path' } }, required: ['path'] } },
+    { name: 'list_files', description: 'List all project files', input_schema: { type: 'object', properties: {} } },
+    { name: 'search_files', description: 'Search for text in project files', input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Search pattern' }, glob: { type: 'string', description: 'File glob pattern (e.g. *.js)' } }, required: ['query'] } },
+    { name: 'run_command', description: 'Run a shell command in the project directory', input_schema: { type: 'object', properties: { command: { type: 'string', description: 'Shell command' } }, required: ['command'] } },
+    { name: 'check_syntax', description: 'Check file for syntax errors', input_schema: { type: 'object', properties: { path: { type: 'string', description: 'Relative path' } }, required: ['path'] } },
+    { name: 'restart_sandbox', description: 'Restart the sandbox server to test changes', input_schema: { type: 'object', properties: {} } },
+  ];
+
+  // System prompt for native tool calling (no <tool> tags needed)
+  const toolInstructions = `
+WORKFLOW: read_file → edit_file (surgical changes) → check_syntax → restart_sandbox
+
+RULES:
+- To modify existing files: ALWAYS use edit_file. NEVER use create_file on existing files — it will fail.
+- edit_file: read the file first, then copy EXACT text from the read output as old_text.
+- To APPEND to a truncated file: old_text = last few lines, new_text = those lines + new content.
+- Keep each edit SMALL — max 30-40 lines. Do MULTIPLE edits for larger changes.
+- If edit_file fails (old_text not found): read the file again, copy the EXACT text, retry.
+- NEVER say you fixed something without verifying with check_syntax.
+- create_file is ONLY for brand new files.
 `;
 
   // Build system prompt with fresh file list each step
@@ -685,16 +675,14 @@ WORKFLOW:
     return [
       `You are WebCraft Agent — an elite AI coding assistant. Today: ${today}. Language: ${language}.`,
       `\nYou control the project IDE. You MUST use tools to implement changes — never just explain.`,
-      `\nYour workflow: read → plan → edit/write → check → verify → done.`,
       `\nAfter EVERY tool use, you will receive the result. Based on the result, decide what to do next.`,
-      `\nWhen finished, output <done/> to signal completion.`,
       `\n\n## PROJECT: ${projectName}`,
       `\n## FILE TREE:\n${fileIndex}`,
       skillContext,
       skillCtx ? `\n\n## PROJECT KNOWLEDGE:\n${skillCtx}` : '',
       attachments?.length ? `\n\n## ATTACHMENTS: ${attachments.map((a) => a.name).join(', ')}` : '',
       fileContents ? `\n\n## LOADED FILES:\n${fileContents}` : '',
-      `\n\n${toolSpec}`,
+      `\n\n${toolInstructions}`,
     ].join('');
   }
 
@@ -703,17 +691,164 @@ WORKFLOW:
     ? _buildMultimodalContent(message, attachments)
     : message;
 
-  // ── Agentic loop ───────────────────────────────────────────────────────────
+  // ── Agentic loop — native tool calling ────────────────────────────────────
   let hasChanges = false;
   const modifiedFiles = new Set();
-  let conversationHistory = [
-    { role: 'user', content: userContent },
-  ];
 
-  for (let step = 0; step < MAX_STEPS; step++) {
-    if (isAborted()) break;
+  // Tool execution handler — called by callLLMWithTools for each tool_use
+  async function handleToolCall(toolName, input) {
+    const relPath = input.path;
+    if (relPath && !_isSafePath(relPath)) return 'Error: unsafe path';
+
+    if (toolName === 'read_file') {
+      const src = ProjectStore.readFile(projectName, relPath);
+      emit({ type: 'tool', op: 'read', path: relPath, result: src ? 'ok' : 'not_found' });
+      return src !== null ? src.slice(0, 16000) : 'Error: file not found';
+    }
+
+    if (toolName === 'edit_file') {
+      const src = ProjectStore.readFile(projectName, relPath);
+      if (!src) { emit({ type: 'tool', op: 'edit', path: relPath, result: 'file_not_found' }); return 'Error: file not found'; }
+      const oldStr = input.old_text;
+      const newStr = input.new_text;
+      if (src.includes(oldStr)) {
+        const newSrc = src.replace(oldStr, newStr ?? '');
+        ProjectStore.writeFile(projectName, relPath, newSrc);
+        hasChanges = true;
+        modifiedFiles.add(relPath);
+        emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: (newStr ?? '').slice(0, 2000) });
+        return 'OK — edit applied successfully';
+      }
+      // Fuzzy match
+      const oldLines = oldStr.split('\n').map(l => l.trim());
+      const srcLines = src.split('\n');
+      let matchStart = -1;
+      for (let i = 0; i <= srcLines.length - oldLines.length; i++) {
+        let ok = true;
+        for (let j = 0; j < oldLines.length; j++) {
+          if (srcLines[i + j].trim() !== oldLines[j]) { ok = false; break; }
+        }
+        if (ok) { matchStart = i; break; }
+      }
+      if (matchStart >= 0) {
+        const before = srcLines.slice(0, matchStart).join('\n');
+        const after = srcLines.slice(matchStart + oldLines.length).join('\n');
+        const result = (before ? before + '\n' : '') + (newStr ?? '') + (after ? '\n' + after : '');
+        ProjectStore.writeFile(projectName, relPath, result);
+        hasChanges = true;
+        modifiedFiles.add(relPath);
+        emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: (newStr ?? '').slice(0, 2000) });
+        return 'OK — edit applied (fuzzy match)';
+      }
+      emit({ type: 'tool', op: 'edit', path: relPath, result: 'old_not_found' });
+      return 'Error: old_text not found in file. Use read_file to see the EXACT current content, copy the exact lines, and retry.';
+    }
+
+    if (toolName === 'create_file') {
+      const existing = ProjectStore.readFile(projectName, relPath);
+      if (existing !== null) {
+        emit({ type: 'tool', op: 'write', path: relPath, result: 'blocked_use_edit' });
+        return 'Error: file already exists. Use edit_file to modify it.';
+      }
+      ProjectStore.writeFile(projectName, relPath, input.content ?? '');
+      hasChanges = true;
+      modifiedFiles.add(relPath);
+      emit({ type: 'tool', op: 'write', path: relPath, result: 'ok', newSnippet: (input.content ?? '').slice(0, 500) });
+      return 'OK — file created';
+    }
+
+    if (toolName === 'delete_file') {
+      const abs = path.join(dir, relPath);
+      if (fs.existsSync(abs)) { fs.unlinkSync(abs); hasChanges = true; modifiedFiles.add(relPath); }
+      emit({ type: 'tool', op: 'delete', path: relPath, result: 'ok' });
+      return 'OK — file deleted';
+    }
+
+    if (toolName === 'list_files') {
+      const files = _listProjectFiles(dir);
+      emit({ type: 'tool', op: 'list', path: '', result: `${files.length} files` });
+      return files.map(f => `- ${f}`).join('\n');
+    }
+
+    if (toolName === 'search_files') {
+      const matches = ProjectStore.grep(projectName, input.query);
+      emit({ type: 'tool', op: 'search', path: '', result: `${matches.length} matches` });
+      return matches.length === 0 ? 'No matches found' : matches.slice(0, 20).map(m => `${m.file}:${m.lineNum}: ${m.line}`).join('\n');
+    }
+
+    if (toolName === 'run_command') {
+      const blocked = /rm\s+-rf|rmdir|format|mkfs|dd\s+if|shutdown|reboot|kill\s+-9\s+1\b/i;
+      if (blocked.test(input.command)) { emit({ type: 'tool', op: 'run', path: '', result: 'blocked' }); return 'Error: dangerous command blocked'; }
+      try {
+        const { stdout, stderr } = await execAsync(input.command, { cwd: dir, timeout: 30000, env: { ...process.env, NODE_ENV: 'development' } });
+        emit({ type: 'tool', op: 'run', path: '', result: 'ok' });
+        return (stdout + (stderr ? '\n[stderr] ' + stderr : '')).slice(0, 4000) || 'OK — no output';
+      } catch (e) {
+        emit({ type: 'tool', op: 'run', path: '', result: 'error' });
+        return `Error: ${(e.stderr || e.message || '').slice(0, 2000)}`;
+      }
+    }
+
+    if (toolName === 'check_syntax') {
+      const src = ProjectStore.readFile(projectName, relPath);
+      if (!src) { emit({ type: 'tool', op: 'check', path: relPath, result: 'not_found' }); return 'File not found'; }
+      const ext = relPath.split('.').pop()?.toLowerCase();
+      let result = 'ok';
+      if (ext === 'js' || ext === 'mjs') { try { new Function(src); } catch (e) { result = `syntax_error: ${e.message.replace(/\n.*/s, '')}`; } }
+      else if (ext === 'json') { try { JSON.parse(src); } catch (e) { result = `json_error: ${e.message}`; } }
+      else if (ext === 'html') { result = src.includes('</html>') ? 'ok' : 'missing </html> tag'; }
+      emit({ type: 'tool', op: 'check', path: relPath, result });
+      return result === 'ok' ? 'OK — no syntax errors' : result;
+    }
+
+    if (toolName === 'restart_sandbox') {
+      if (sandbox.isRunning()) await sandbox.stop();
+      try {
+        const port = await _findFreePort(4000, 4999);
+        if (port) {
+          const shimDir = path.join(dir, '.nha-shims');
+          ensureDir(shimDir);
+          _writeShims(shimDir);
+          const entryFile = _detectEntry(dir);
+          if (entryFile) {
+            const patchedEntry = _patchEntry(dir, entryFile, shimDir, port);
+            const proc = spawn('node', [patchedEntry], { cwd: dir, env: { ...process.env, PORT: String(port), NODE_ENV: 'development', NHA_SANDBOX: '1' }, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+            sandbox._sandbox = { proc, port, projectName, startedAt: new Date(), healthy: false };
+            const healthy = await _waitForPort(port, 10000);
+            if (healthy) { sandbox._sandbox.healthy = true; emit({ type: 'sandbox_ready', port }); return `OK — sandbox running on port ${port}`; }
+          }
+        }
+      } catch {}
+      emit({ type: 'tool', op: 'sandbox', path: '', result: 'error' });
+      return 'Error: sandbox failed to start';
+    }
+
+    return `Error: unknown tool ${toolName}`;
+  }
+
+  // Try native tool calling first (Anthropic, OpenAI)
+  const provider = config.llm?.provider || 'anthropic';
+  const useNativeTools = provider === 'anthropic' || provider === 'openai';
+
+  if (useNativeTools) {
     const systemPrompt = buildSystemPrompt();
-    emit({ type: 'step', step: step + 1, max: MAX_STEPS });
+    const messages = [{ role: 'user', content: userContent }];
+
+    await callLLMWithTools(config, systemPrompt, messages, nativeTools,
+      (text) => emit({ type: 'text', token: text }),
+      handleToolCall,
+      { max_tokens: 16384, isAborted, maxTurns: MAX_STEPS }
+    );
+  } else {
+    // Fallback for other providers — use old text-based <tool> system
+    // (kept for backward compatibility with Gemini, DeepSeek, etc.)
+    let conversationHistory = [{ role: 'user', content: userContent }];
+    emit({ type: 'text', token: 'Note: Using text-based tools (native tool calling not available for this provider).\n' });
+    // Minimal old-style loop with <tool> tags — simplified
+    for (let step = 0; step < MAX_STEPS; step++) {
+      if (isAborted()) break;
+      const systemPrompt = buildSystemPrompt();
+      emit({ type: 'step', step: step + 1, max: MAX_STEPS });
 
     // Build user message from conversation history
     // callLLMStream takes a single string, so we concatenate the conversation
@@ -867,18 +1002,9 @@ WORKFLOW:
             toolResults.push({ op: 'edit', path: relPath, result: 'ok' });
             emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok', oldSnippet: oldStr.slice(0, 2000), newSnippet: newStr?.slice(0, 2000) });
           } else {
-            // No fuzzy match — try LLM repair as last resort
-            const repaired = await _attemptEditRepair(config, relPath, src, oldStr, newStr);
-            if (repaired) {
-              ProjectStore.writeFile(projectName, relPath, repaired);
-              hasChanges = true;
-              modifiedFiles.add(relPath);
-              toolResults.push({ op: 'edit', path: relPath, result: 'ok_repaired' });
-              emit({ type: 'tool', op: 'edit', path: relPath, result: 'ok_repaired', oldSnippet: oldStr.slice(0, 2000), newSnippet: newStr?.slice(0, 2000) });
-            } else {
-              toolResults.push({ op: 'edit', path: relPath, result: 'old_not_found — read the file first, copy EXACT text to replace, then retry' });
-              emit({ type: 'tool', op: 'edit', path: relPath, result: 'old_not_found', oldSnippet: oldStr.slice(0, 200) });
-            }
+            // No match — return error, let the agent retry with correct text
+            toolResults.push({ op: 'edit', path: relPath, result: 'old_not_found — your old text does not match the file. Use read tool to see the EXACT current content, then copy-paste the exact lines and retry.' });
+            emit({ type: 'tool', op: 'edit', path: relPath, result: 'old_not_found', oldSnippet: oldStr.slice(0, 200) });
           }
         }
 
@@ -1156,6 +1282,7 @@ WORKFLOW:
       conversationHistory = [conversationHistory[0], ...conversationHistory.slice(-6)];
     }
   }
+  } // end of fallback else block
 
   // ── Post-edit: syntax check all modified JS files ──────────────────────────
   const syntaxErrors = [];

package/src/services/llm.mjs

@@ -713,6 +713,288 @@ export function getProviderCall(provider) {
   return PROVIDERS[provider] || null;
 }
 
+/**
+ * Call LLM with native tool_use (function calling) — supports Anthropic and OpenAI.
+ * Handles the full agentic loop: call → tool_use → tool_result → call → ... → end_turn.
+ *
+ * @param {object} config — NHA config with llm.provider, llm.apiKey, etc.
+ * @param {string} systemPrompt
+ * @param {Array} messages — conversation history [{role, content}]
+ * @param {Array} tools — tool definitions [{name, description, input_schema}]
+ * @param {Function} onText — callback for text tokens (text: string) => void
+ * @param {Function} onToolCall — callback when tool is called (name: string, input: object) => Promise<string> — must return the tool result
+ * @param {object} opts — { max_tokens, isAborted, maxTurns }
+ * @returns {Promise<{messages: Array, stopReason: string}>} — updated messages array
+ */
+export async function callLLMWithTools(config, systemPrompt, messages, tools, onText, onToolCall, opts = {}) {
+  const provider = config.llm?.provider || 'anthropic';
+  const model = config.llm?.model || null;
+  const apiKey = getApiKey(config, provider);
+  if (!apiKey) throw new Error(`No API key for ${provider}`);
+
+  // Anthropic native tool calling
+  if (provider === 'anthropic') {
+    return _callAnthropicWithTools(apiKey, model, systemPrompt, messages, tools, onText, onToolCall, opts);
+  }
+
+  // OpenAI native function calling
+  if (provider === 'openai') {
+    return _callOpenAIWithTools(apiKey, model, systemPrompt, messages, tools, onText, onToolCall, opts);
+  }
+
+  // Other providers: fallback to text-based tool calling (old system)
+  // The caller should handle this by checking the return value
+  return null;
+}
+
+async function _callAnthropicWithTools(apiKey, model, systemPrompt, messages, tools, onText, onToolCall, opts = {}) {
+  const maxTokens = opts.max_tokens || 16384;
+  const isAborted = opts.isAborted || (() => false);
+  const MAX_TURNS = opts.maxTurns || 8;
+
+  for (let turn = 0; turn < MAX_TURNS; turn++) {
+    if (isAborted()) break;
+
+    const body = {
+      model: model || 'claude-sonnet-4-20250514',
+      max_tokens: maxTokens,
+      system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
+      messages,
+      tools,
+      stream: true,
+    };
+
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'anthropic-beta': 'prompt-caching-2024-07-31',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Anthropic ${res.status}: ${err}`);
+    }
+
+    // Parse streaming response
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    let assistantContent = [];
+    let currentText = '';
+    let currentToolUse = null;
+    let currentToolInput = '';
+    let stopReason = null;
+
+    while (true) {
+      if (isAborted()) { try { reader.cancel(); } catch {} break; }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') continue;
+        try {
+          const ev = JSON.parse(data);
+          if (ev.type === 'content_block_start') {
+            if (ev.content_block?.type === 'text') {
+              currentText = '';
+            } else if (ev.content_block?.type === 'tool_use') {
+              currentToolUse = { id: ev.content_block.id, name: ev.content_block.name };
+              currentToolInput = '';
+            }
+          } else if (ev.type === 'content_block_delta') {
+            if (ev.delta?.type === 'text_delta') {
+              currentText += ev.delta.text;
+              if (onText) onText(ev.delta.text);
+            } else if (ev.delta?.type === 'input_json_delta') {
+              currentToolInput += ev.delta.partial_json;
+            }
+          } else if (ev.type === 'content_block_stop') {
+            if (currentText) {
+              assistantContent.push({ type: 'text', text: currentText });
+              currentText = '';
+            }
+            if (currentToolUse) {
+              let input = {};
+              try { input = JSON.parse(currentToolInput); } catch {}
+              assistantContent.push({
+                type: 'tool_use',
+                id: currentToolUse.id,
+                name: currentToolUse.name,
+                input,
+              });
+              currentToolUse = null;
+              currentToolInput = '';
+            }
+          } else if (ev.type === 'message_delta') {
+            if (ev.delta?.stop_reason) stopReason = ev.delta.stop_reason;
+          }
+        } catch {}
+      }
+    }
+
+    // Add assistant message to conversation
+    messages.push({ role: 'assistant', content: assistantContent });
+
+    // If stop reason is end_turn (no more tool calls), we're done
+    if (stopReason === 'end_turn' || stopReason !== 'tool_use') break;
+
+    // Execute tool calls
+    const toolUseBlocks = assistantContent.filter(b => b.type === 'tool_use');
+    if (toolUseBlocks.length === 0) break;
+
+    const toolResults = [];
+    for (const toolBlock of toolUseBlocks) {
+      if (isAborted()) break;
+      const result = await onToolCall(toolBlock.name, toolBlock.input);
+      toolResults.push({
+        type: 'tool_result',
+        tool_use_id: toolBlock.id,
+        content: typeof result === 'string' ? result : JSON.stringify(result),
+      });
+    }
+
+    // Add tool results to conversation
+    messages.push({ role: 'user', content: toolResults });
+  }
+
+  return { messages, stopReason: 'end' };
+}
+
+async function _callOpenAIWithTools(apiKey, model, systemPrompt, messages, tools, onText, onToolCall, opts = {}) {
+  const maxTokens = opts.max_tokens || 16384;
+  const isAborted = opts.isAborted || (() => false);
+  const MAX_TURNS = opts.maxTurns || 8;
+
+  // Convert Anthropic tool format to OpenAI function format
+  const openaiTools = tools.map(t => ({
+    type: 'function',
+    function: { name: t.name, description: t.description, parameters: t.input_schema },
+  }));
+
+  // Convert messages: Anthropic uses content arrays, OpenAI uses strings
+  const toOpenAI = (msgs) => {
+    const result = [{ role: 'system', content: systemPrompt }];
+    for (const m of msgs) {
+      if (m.role === 'user') {
+        if (Array.isArray(m.content)) {
+          // tool_result blocks
+          for (const block of m.content) {
+            if (block.type === 'tool_result') {
+              result.push({ role: 'tool', tool_call_id: block.tool_use_id, content: block.content || '' });
+            } else {
+              result.push({ role: 'user', content: typeof block === 'string' ? block : block.text || JSON.stringify(block) });
+            }
+          }
+        } else {
+          result.push({ role: 'user', content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) });
+        }
+      } else if (m.role === 'assistant') {
+        if (Array.isArray(m.content)) {
+          const textParts = m.content.filter(b => b.type === 'text').map(b => b.text).join('');
+          const toolCalls = m.content.filter(b => b.type === 'tool_use').map(b => ({
+            id: b.id, type: 'function', function: { name: b.name, arguments: JSON.stringify(b.input) },
+          }));
+          const msg = { role: 'assistant', content: textParts || null };
+          if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+          result.push(msg);
+        } else {
+          result.push({ role: 'assistant', content: typeof m.content === 'string' ? m.content : '' });
+        }
+      }
+    }
+    return result;
+  };
+
+  for (let turn = 0; turn < MAX_TURNS; turn++) {
+    if (isAborted()) break;
+
+    const body = {
+      model: model || 'gpt-4o',
+      max_tokens: maxTokens,
+      messages: toOpenAI(messages),
+      tools: openaiTools,
+      stream: true,
+    };
+
+    const res = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) { const err = await res.text(); throw new Error(`OpenAI ${res.status}: ${err}`); }
+
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    let assistantContent = [];
+    let currentText = '';
+    let toolCalls = {};
+    let finishReason = null;
+
+    while (true) {
+      if (isAborted()) { try { reader.cancel(); } catch {} break; }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') continue;
+        try {
+          const ev = JSON.parse(data);
+          const delta = ev.choices?.[0]?.delta;
+          if (delta?.content) { currentText += delta.content; if (onText) onText(delta.content); }
+          if (delta?.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              if (!toolCalls[tc.index]) toolCalls[tc.index] = { id: tc.id || '', name: '', args: '' };
+              if (tc.id) toolCalls[tc.index].id = tc.id;
+              if (tc.function?.name) toolCalls[tc.index].name = tc.function.name;
+              if (tc.function?.arguments) toolCalls[tc.index].args += tc.function.arguments;
+            }
+          }
+          if (ev.choices?.[0]?.finish_reason) finishReason = ev.choices[0].finish_reason;
+        } catch {}
+      }
+    }
+
+    if (currentText) assistantContent.push({ type: 'text', text: currentText });
+    for (const tc of Object.values(toolCalls)) {
+      let input = {};
+      try { input = JSON.parse(tc.args); } catch {}
+      assistantContent.push({ type: 'tool_use', id: tc.id, name: tc.name, input });
+    }
+    messages.push({ role: 'assistant', content: assistantContent });
+
+    if (finishReason !== 'tool_calls' && Object.keys(toolCalls).length === 0) break;
+
+    const toolUseBlocks = assistantContent.filter(b => b.type === 'tool_use');
+    if (toolUseBlocks.length === 0) break;
+
+    const toolResults = [];
+    for (const toolBlock of toolUseBlocks) {
+      if (isAborted()) break;
+      const result = await onToolCall(toolBlock.name, toolBlock.input);
+      toolResults.push({ type: 'tool_result', tool_use_id: toolBlock.id, content: typeof result === 'string' ? result : JSON.stringify(result) });
+    }
+    messages.push({ role: 'user', content: toolResults });
+  }
+
+  return { messages, stopReason: 'end' };
+}
+
 export function getApiKey(config, provider) {
   // NHA Free (Liara) doesn't need an API key
   if (provider === 'nha') return 'nha-free-tier';