@semalt-ai/code 1.7.0 → 1.8.1

package/lib/tools.js

@@ -1,81 +1,796 @@
 'use strict';
 
 const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-function createToolExecutor(permissionManager, ui) {
-  const { FG_DARK, FG_GRAY, FG_GREEN, FG_RED, RST } = ui;
+const { logToolCall } = require('./audit');
+
+const MEMORY_PATH = path.join(os.homedir(), '.semalt-ai', 'memory.json');
+
+const _dryRun = process.argv.includes('--dry-run');
+const _skippedOps = [];
+function getSkippedOps() { return _skippedOps.slice(); }
+
+// When the full TUI is active, suppress direct console.log writes — the UI
+// handles all tool-status display via onToolEnd callbacks instead.
+let _uiActive = false;
+function setUIActive(v) { _uiActive = v; }
+function _log(...args) { if (!_uiActive) console.log(...args); }
+
+// Chunk store for large http_get responses.
+// Maps URL → { chunks: string[], total: number, delivered: number }
+const _httpChunkStore = new Map();
+const HTTP_CHUNK_CHARS = 10000;
+
+function createToolExecutor(permissionManager, ui, getConfig) {
+  const { BOLD, DIM, FG_DARK, FG_GRAY, FG_GREEN, FG_RED, FG_YELLOW, RST, renderDiff } = ui;
+
+  function _parseNumberedOptions(text) {
+    const options = [];
+    for (const line of text.split('\n')) {
+      const m = line.match(/^\s*\d+[.)]\s+(.+)$/);
+      if (m) options.push(m[1].trim());
+    }
+    return options.length >= 2 ? options : [];
+  }
 
   async function agentExecShell(command) {
-    const approved = await permissionManager.askPermission('shell', command);
+    if (_dryRun) {
+      _log(`  ${FG_DARK}[dry-run] $ ${command}${RST}`);
+      _skippedOps.push({ category: 'cmd', symbol: '▶', desc: command });
+      logToolCall('exec', { command }, false, 'dry-run');
+      return { exit_code: 0, stdout: '', stderr: 'dry-run: command skipped' };
+    }
+
+    const approved = await permissionManager.askPermission('shell', command, 'exec');
     if (!approved) {
+      logToolCall('exec', { command }, false, 'denied');
       return { exit_code: -1, stdout: '', stderr: 'Permission denied by user' };
     }
 
-    console.log(`  ${FG_DARK}$ ${command}${RST}`);
     try {
-      const result = spawnSync(command, { shell: true, encoding: 'utf8', timeout: 60000 });
+      const cfg = getConfig ? getConfig() : {};
+      const timeout = cfg.command_timeout_ms || 30000;
+      const result = spawnSync(command, { shell: true, encoding: 'utf8', timeout });
       const stdout = result.stdout || '';
       const stderr = result.stderr || '';
-      const combined = stdout + (stderr ? `\n${stderr}` : '');
-      const lines = combined.trim().split('\n').filter((line) => line !== '');
-
-      if (lines.length > 20) {
-        lines.slice(0, 15).forEach((line) => console.log(`  ${FG_GRAY}${line}${RST}`));
-        console.log(`  ${FG_DARK}... (${lines.length - 15} more lines)${RST}`);
-      } else {
-        lines.forEach((line) => console.log(`  ${FG_GRAY}${line}${RST}`));
-      }
-      console.log();
-
-      return { exit_code: result.status ?? 0, stdout, stderr };
+      const exitCode = result.status ?? 0;
+      logToolCall('exec', { command }, true, exitCode === 0 ? 'ok' : 'error');
+      return { exit_code: exitCode, stdout, stderr };
     } catch (error) {
-      console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      logToolCall('exec', { command }, true, 'error');
       return { exit_code: -1, stdout: '', stderr: error.message };
     }
   }
 
-  async function agentExecFile(action, filePath, content = null) {
-    if (action === 'read') {
-      const approved = await permissionManager.askPermission('file', `Read ${filePath}`);
-      if (!approved) return { error: 'Permission denied' };
+  async function agentExecFile(action, ...args) {
+    const [arg0 = null, arg1 = null, arg2 = null, arg3 = null] = args;
 
+    if (action === 'read') {
+      const filePath = arg0;
+      try {
+        const stat = fs.statSync(filePath);
+        const cfg = getConfig ? getConfig() : {};
+        const maxBytes = (cfg.max_file_size_kb || 512) * 1024;
+        if (stat.size > maxBytes) {
+          const kb = (stat.size / 1024).toFixed(0);
+          logToolCall('read_file', { path: filePath }, false, 'error');
+          return { error: `File too large: ${kb} KB exceeds max_file_size_kb=${cfg.max_file_size_kb || 512}` };
+        }
+      } catch {
+        // file doesn't exist yet — readFileSync will report it
+      }
+      const approved = await permissionManager.askPermission('file', `Read ${filePath}`, 'read_file');
+      if (!approved) {
+        logToolCall('read_file', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
       try {
         const data = fs.readFileSync(filePath, 'utf8');
         const lines = data.split('\n').length;
         if (lines > 10) {
-          console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath} (${lines} lines, ${data.length} chars)${RST}`);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath} (${lines} lines, ${data.length} chars)${RST}`);
         } else {
-          console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath}${RST}`);
+          _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Read ${filePath}${RST}`);
         }
+        logToolCall('read_file', { path: filePath }, true, 'ok');
         return { content: data, path: filePath };
       } catch (error) {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('read_file', { path: filePath }, true, 'error');
         return { error: error.message };
       }
     }
 
     if (action === 'write' || action === 'append') {
+      const filePath = arg0;
+      const content = arg1;
+      const tag = action === 'write' ? 'write_file' : 'append_file';
+
+      const blocked = permissionManager.readonlyBlock(tag);
+      if (blocked) {
+        logToolCall(tag, { path: filePath, content }, false, 'denied');
+        return blocked;
+      }
+
+      // Read existing content for diff display
+      let existing = '';
+      try { existing = fs.readFileSync(filePath, 'utf8'); } catch {}
+
+      // For append the final state is existing + new content
+      const finalContent = action === 'write' ? (content || '') : (existing + (content || ''));
+
+      // In CLI mode, print the diff inline. In TUI mode, direct stdout writes
+      // collide with the live chat-history/status-bar redraw, so we route the
+      // diff into the permission description instead (where it renders inside
+      // the permission bubble and is safely truncated by MAX_DESC_LINES).
+      const diffOutput = renderDiff(existing, finalContent, filePath);
+      if (!_uiActive) process.stdout.write(diffOutput + '\n');
+
+      // Dry-run: record the skipped op and return without writing
+      if (_dryRun) {
+        const verb = action === 'write' ? 'write' : 'append';
+        _skippedOps.push({ category: 'file', symbol: '✎', desc: `${verb} ${filePath}` });
+        logToolCall(tag, { path: filePath }, false, 'dry-run');
+        return { status: 'dry-run', message: 'dry-run: write skipped', path: filePath };
+      }
+
+      // Permission check — routes through TUI dialog in chat mode, interactiveSelect in legacy CLI mode
       let desc = `${action === 'write' ? 'Write' : 'Append to'} ${filePath}`;
       if (content) desc += ` (${content.length} chars)`;
-      const approved = await permissionManager.askPermission('file', desc);
-      if (!approved) return { error: 'Permission denied' };
-
+      if (_uiActive) desc = `${desc}\n${diffOutput}`;
+      const approved = await permissionManager.askPermission('file', desc, tag);
+      if (!approved) {
+        logToolCall(tag, { path: filePath, content }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
       try {
         const dir = path.dirname(filePath);
         if (dir && dir !== '.') fs.mkdirSync(dir, { recursive: true });
         if (action === 'write') fs.writeFileSync(filePath, content || '');
         else fs.appendFileSync(filePath, content || '');
         const verb = action === 'write' ? 'Wrote' : 'Appended to';
-        console.log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}${verb} ${filePath}${RST}`);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}${verb} ${filePath}${RST}`);
+        logToolCall(tag, { path: filePath, content }, true, 'ok');
         return { status: 'ok', path: filePath, bytes: (content || '').length };
       } catch (error) {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall(tag, { path: filePath, content }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'list_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `List ${dirPath}`, 'list_dir');
+      if (!approved) {
+        logToolCall('list_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const items = entries.map((e) => {
+          if (e.isSymbolicLink()) return `[L] ${e.name}`;
+          if (e.isDirectory()) return `[D] ${e.name}`;
+          return `[F] ${e.name}`;
+        });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Listed ${dirPath} (${items.length} items)${RST}`);
+        logToolCall('list_dir', { path: dirPath }, true, 'ok');
+        return { items, path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('list_dir', { path: dirPath }, true, 'error');
         return { error: error.message };
       }
     }
 
+    if (action === 'delete_file') {
+      const filePath = arg0;
+
+      const blocked = permissionManager.readonlyBlock('delete_file');
+      if (blocked) {
+        logToolCall('delete_file', { path: filePath }, false, 'denied');
+        return blocked;
+      }
+
+      _log(`  ${FG_YELLOW}${BOLD}⚠ Deleting: ${filePath}${RST}`);
+
+      const approved = await permissionManager.askPermission('file', `Delete ${filePath}`, 'delete_file');
+      if (!approved) {
+        logToolCall('delete_file', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.unlinkSync(filePath);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Deleted ${filePath}${RST}`);
+        logToolCall('delete_file', { path: filePath }, true, 'ok');
+        return { status: 'ok', path: filePath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('delete_file', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'make_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `Create directory ${dirPath}`, 'make_dir');
+      if (!approved) {
+        logToolCall('make_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.mkdirSync(dirPath, { recursive: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Created directory ${dirPath}${RST}`);
+        logToolCall('make_dir', { path: dirPath }, true, 'ok');
+        return { status: 'ok', path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('make_dir', { path: dirPath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'remove_dir') {
+      const dirPath = arg0;
+      const approved = await permissionManager.askPermission('file', `Remove directory ${dirPath}`, 'remove_dir');
+      if (!approved) {
+        logToolCall('remove_dir', { path: dirPath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Removed directory ${dirPath}${RST}`);
+        logToolCall('remove_dir', { path: dirPath }, true, 'ok');
+        return { status: 'ok', path: dirPath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('remove_dir', { path: dirPath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'move_file') {
+      const src = arg0;
+      const dst = arg1;
+
+      const blocked = permissionManager.readonlyBlock('move_file');
+      if (blocked) {
+        logToolCall('move_file', { src, dst }, false, 'denied');
+        return blocked;
+      }
+
+      _log(`  ${FG_YELLOW}${BOLD}⚠ Moving: ${src} → ${dst}${RST}`);
+
+      const approved = await permissionManager.askPermission('file', `Move ${src} to ${dst}`, 'move_file');
+      if (!approved) {
+        logToolCall('move_file', { src, dst }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dstDir = path.dirname(dst);
+        if (dstDir && dstDir !== '.') fs.mkdirSync(dstDir, { recursive: true });
+        try {
+          fs.renameSync(src, dst);
+        } catch (renameErr) {
+          if (renameErr.code !== 'EXDEV') throw renameErr;
+          // Cross-device rename not supported — copy then remove
+          fs.cpSync(src, dst, { recursive: true });
+          fs.rmSync(src, { recursive: true, force: true });
+        }
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Moved ${src} → ${dst}${RST}`);
+        logToolCall('move_file', { src, dst }, true, 'ok');
+        return { status: 'ok', src, dst };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('move_file', { src, dst }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'copy_file') {
+      const src = arg0;
+      const dst = arg1;
+
+      const blocked = permissionManager.readonlyBlock('copy_file');
+      if (blocked) {
+        logToolCall('copy_file', { src, dst }, false, 'denied');
+        return blocked;
+      }
+
+      const approved = await permissionManager.askPermission('file', `Copy ${src} to ${dst}`, 'copy_file');
+      if (!approved) {
+        logToolCall('copy_file', { src, dst }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dstDir = path.dirname(dst);
+        if (dstDir && dstDir !== '.') fs.mkdirSync(dstDir, { recursive: true });
+        fs.cpSync(src, dst, { recursive: true });
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Copied ${src} → ${dst}${RST}`);
+        logToolCall('copy_file', { src, dst }, true, 'ok');
+        return { status: 'ok', src, dst };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('copy_file', { src, dst }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'edit_file') {
+      const filePath = arg0;
+      const lineNum = arg1;
+      const newContent = arg2;
+      const approved = await permissionManager.askPermission('file', `Edit line ${lineNum} in ${filePath}`, 'edit_file');
+      if (!approved) {
+        logToolCall('edit_file', { path: filePath, line: lineNum }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        const lines = data.split('\n');
+        if (lineNum < 1 || lineNum > lines.length) {
+          logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'error');
+          return { error: `Line ${lineNum} out of range (file has ${lines.length} lines)` };
+        }
+        lines[lineNum - 1] = newContent;
+        fs.writeFileSync(filePath, lines.join('\n'));
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Edited line ${lineNum} in ${filePath}${RST}`);
+        logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'ok');
+        return { status: 'ok', path: filePath, line: lineNum };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('edit_file', { path: filePath, line: lineNum }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'search_in_file') {
+      const filePath = arg0;
+      const pattern = arg1;
+      const approved = await permissionManager.askPermission('file', `Search in ${filePath}`, 'search_in_file');
+      if (!approved) {
+        logToolCall('search_in_file', { path: filePath, pattern }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        const regex = new RegExp(pattern);
+        const matches = data.split('\n')
+          .map((content, idx) => regex.test(content) ? { line: idx + 1, content } : null)
+          .filter(Boolean);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${matches.length} match(es) in ${filePath}${RST}`);
+        logToolCall('search_in_file', { path: filePath, pattern }, true, 'ok');
+        return { matches, path: filePath };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('search_in_file', { path: filePath, pattern }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'replace_in_file') {
+      const filePath = arg0;
+      const searchStr = arg1;
+      const replaceStr = arg2;
+      const flags = arg3 || '';
+      const approved = await permissionManager.askPermission('file', `Replace in ${filePath}`, 'replace_in_file');
+      if (!approved) {
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        const safeFlags = flags.replace(/[^gimsuy]/g, '');
+        const countFlags = safeFlags.includes('g') ? safeFlags : safeFlags + 'g';
+        const count = (data.match(new RegExp(searchStr, countFlags)) || []).length;
+        const regex = new RegExp(searchStr, safeFlags || undefined);
+        const newData = data.replace(regex, replaceStr);
+        fs.writeFileSync(filePath, newData);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Replaced ${count} occurrence(s) in ${filePath}${RST}`);
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, true, 'ok');
+        return { status: 'ok', path: filePath, count };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('replace_in_file', { path: filePath, search: searchStr }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'search_files') {
+      const pattern = arg0;
+      const searchDir = arg1 || '.';
+      const approved = await permissionManager.askPermission('file', `Search files: ${pattern} in ${searchDir}`, 'search_files');
+      if (!approved) {
+        logToolCall('search_files', { pattern, dir: searchDir }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let regStr = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        regStr = regStr.replace(/\*\*/g, '\x00');
+        regStr = regStr.replace(/\*/g, '[^/]*');
+        regStr = regStr.replace(/\x00\//g, '(?:.*/)?');
+        regStr = regStr.replace(/\x00/g, '.*');
+        const regex = new RegExp(`^${regStr}$`);
+        const matchName = !pattern.includes('/');
+        const files = [];
+        function walk(dir, rel) {
+          let entries;
+          try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+          for (const entry of entries) {
+            const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+            if (regex.test(matchName ? entry.name : relPath)) files.push(relPath);
+            if (entry.isDirectory()) walk(path.join(dir, entry.name), relPath);
+          }
+        }
+        walk(searchDir, '');
+        files.sort();
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Found ${files.length} file(s) matching "${pattern}"${RST}`);
+        logToolCall('search_files', { pattern, dir: searchDir }, true, 'ok');
+        return { files, pattern, dir: searchDir };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('search_files', { pattern, dir: searchDir }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'file_stat') {
+      const filePath = arg0;
+      const approved = await permissionManager.askPermission('file', `Stat ${filePath}`, 'file_stat');
+      if (!approved) {
+        logToolCall('file_stat', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const stat = fs.statSync(filePath);
+        const type = stat.isDirectory() ? 'directory' : stat.isSymbolicLink() ? 'symlink' : 'file';
+        const size_kb = (stat.size / 1024).toFixed(2);
+        const mode = '0o' + stat.mode.toString(8);
+        const mtime = stat.mtime.toISOString();
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Stat ${filePath}${RST}`);
+        logToolCall('file_stat', { path: filePath }, true, 'ok');
+        return { path: filePath, size_kb, mtime, type, mode };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('file_stat', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'get_env') {
+      const varName = arg0;
+      const value = process.env[varName];
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Got env ${varName}${RST}`);
+      logToolCall('get_env', { name: varName }, true, 'ok');
+      return { name: varName, value: value !== undefined ? value : null };
+    }
+
+    if (action === 'set_env') {
+      const varName = arg0;
+      const value = arg1 || '';
+      const approved = await permissionManager.askPermission('shell', `Set env ${varName}=${value}`, 'set_env');
+      if (!approved) {
+        logToolCall('set_env', { name: varName }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      process.env[varName] = value;
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Set env ${varName}${RST}`);
+      logToolCall('set_env', { name: varName }, true, 'ok');
+      return { status: 'ok', name: varName };
+    }
+
+    if (action === 'download') {
+      const url = arg0;
+      if (_dryRun) {
+        _skippedOps.push({ category: 'net', symbol: '↓', desc: `download ${url}` });
+        logToolCall('download', { url }, false, 'dry-run');
+        return { status: 'dry-run', message: 'dry-run: network call skipped' };
+      }
+      let fileName;
+      try {
+        fileName = path.basename(new URL(url).pathname) || 'download';
+      } catch {
+        fileName = 'download';
+      }
+      const outPath = path.join(process.cwd(), fileName);
+      const approved = await permissionManager.askPermission('shell', `Download ${url}`, 'download');
+      if (!approved) {
+        logToolCall('download', { url }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      return new Promise((resolve) => {
+        function doDownload(target, redirectsLeft) {
+          const proto = target.startsWith('https') ? https : http;
+          const req = proto.get(target, (res) => {
+            if ([301, 302, 303, 307, 308].includes(res.statusCode) && redirectsLeft > 0 && res.headers.location) {
+              res.resume();
+              return doDownload(res.headers.location, redirectsLeft - 1);
+            }
+            if (res.statusCode >= 400) {
+              res.resume();
+              const msg = `HTTP ${res.statusCode}`;
+              _log(`  ${FG_RED}✗ ${msg}${RST}`);
+              logToolCall('download', { url }, true, 'error');
+              return resolve({ error: msg });
+            }
+            const file = fs.createWriteStream(outPath);
+            res.pipe(file);
+            file.on('finish', () => {
+              file.close();
+              _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Downloaded to ${outPath}${RST}`);
+              logToolCall('download', { url }, true, 'ok');
+              resolve({ status: 'ok', path: outPath });
+            });
+            file.on('error', (err) => {
+              fs.unlink(outPath, () => {});
+              _log(`  ${FG_RED}✗ ${err.message}${RST}`);
+              logToolCall('download', { url }, true, 'error');
+              resolve({ error: err.message });
+            });
+          });
+          req.on('error', (err) => {
+            fs.unlink(outPath, () => {});
+            _log(`  ${FG_RED}✗ ${err.message}${RST}`);
+            logToolCall('download', { url }, true, 'error');
+            resolve({ error: err.message });
+          });
+          req.setTimeout(120000, () => {
+            req.destroy();
+            fs.unlink(outPath, () => {});
+            logToolCall('download', { url }, true, 'error');
+            resolve({ error: 'Request timeout' });
+          });
+        }
+        doDownload(url, 5);
+      });
+    }
+
+    if (action === 'upload') {
+      const filePath = arg0;
+      const encodedContent = arg1 || '';
+      const approved = await permissionManager.askPermission('file', `Upload to ${filePath}`, 'upload');
+      if (!approved) {
+        logToolCall('upload', { path: filePath }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        const dir = path.dirname(filePath);
+        if (dir && dir !== '.') fs.mkdirSync(dir, { recursive: true });
+        const buffer = Buffer.from(encodedContent.trim(), 'base64');
+        fs.writeFileSync(filePath, buffer);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Uploaded ${buffer.length} bytes to ${filePath}${RST}`);
+        logToolCall('upload', { path: filePath }, true, 'ok');
+        return { status: 'ok', path: filePath, bytes: buffer.length };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('upload', { path: filePath }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    function buildHttpResult(url, statusCode, body, raw) {
+      // Strip HTML markup so the LLM receives readable text instead of raw HTML.
+      // Reduces a typical 150k-char page to ~25-40k chars, cutting chunk count
+      // from ~16 to ~3 and preventing context-overflow re-fetch loops.
+      // Pass raw=true to skip stripping (e.g. when the agent needs to parse markup).
+      const looksLikeHtml = !raw && (/^\s*<!doctype\s+html/i.test(body) || /^\s*<html[\s>]/i.test(body));
+      const processedBody = looksLikeHtml
+        ? body
+            .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+            .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/&nbsp;/gi, ' ')
+            .replace(/&amp;/gi, '&')
+            .replace(/&lt;/gi, '<')
+            .replace(/&gt;/gi, '>')
+            .replace(/&quot;/gi, '"')
+            .replace(/&#x?[\da-f]+;/gi, ' ')
+            .replace(/\s{2,}/g, ' ')
+            .trim()
+        : body;
+
+      if (processedBody.length > HTTP_CHUNK_CHARS) {
+        const chunks = [];
+        for (let i = 0; i < processedBody.length; i += HTTP_CHUNK_CHARS) {
+          chunks.push(processedBody.slice(i, i + HTTP_CHUNK_CHARS));
+        }
+        _httpChunkStore.set(url, { chunks: chunks.slice(1), total: chunks.length, delivered: 1 });
+        return { status_code: statusCode, body: chunks[0], chunked: true, part: 1, total_parts: chunks.length, key: url };
+      }
+      _httpChunkStore.delete(url);
+      return { status_code: statusCode, body: processedBody };
+    }
+
+    if (action === 'http_get_next') {
+      const key = arg0;
+      const store = _httpChunkStore.get(key);
+      if (!store || store.chunks.length === 0) {
+        _httpChunkStore.delete(key);
+        return { key, body: '', part: null, total_parts: null, done: true };
+      }
+      const nextChunk = store.chunks[0];
+      store.chunks = store.chunks.slice(1);
+      store.delivered += 1;
+      const done = store.chunks.length === 0;
+      if (done) _httpChunkStore.delete(key);
+      return { key, body: nextChunk, part: store.delivered, total_parts: store.total, done };
+    }
+
+    if (action === 'http_get') {
+      const url = arg0;
+      const rawHtml = arg1 === 'true';
+      if (_dryRun) {
+        _skippedOps.push({ category: 'net', symbol: '↓', desc: `GET ${url}` });
+        logToolCall('http_get', { url }, false, 'dry-run');
+        return { status: 'dry-run', message: 'dry-run: network call skipped' };
+      }
+      const approved = await permissionManager.askPermission('shell', `HTTP GET ${url}`, 'http_get');
+      if (!approved) {
+        logToolCall('http_get', { url }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const httpCfg = getConfig ? getConfig() : {};
+      const reqTimeoutMs = Math.max(15000, httpCfg.request_timeout_ms || 15000);
+      return new Promise((resolve) => {
+        function doGet(target, redirectsLeft) {
+          const proto = target.startsWith('https') ? https : http;
+          const req = proto.get(target, (res) => {
+            if ([301, 302, 303, 307, 308].includes(res.statusCode) && redirectsLeft > 0 && res.headers.location) {
+              res.resume();
+              return doGet(res.headers.location, redirectsLeft - 1);
+            }
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+              _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}HTTP GET ${target} (${res.statusCode}, ${data.length} chars)${RST}`);
+              logToolCall('http_get', { url: target }, true, res.statusCode < 400 ? 'ok' : 'error');
+              resolve(buildHttpResult(url, res.statusCode, data, rawHtml));
+            });
+          });
+          req.on('error', (err) => {
+            _log(`  ${FG_RED}✗ ${err.message}${RST}`);
+            logToolCall('http_get', { url: target }, true, 'error');
+            resolve({ error: err.message });
+          });
+          req.setTimeout(reqTimeoutMs, () => {
+            req.destroy();
+            logToolCall('http_get', { url: target }, true, 'error');
+            resolve({ error: 'Request timeout' });
+          });
+        }
+        doGet(url, 5);
+      });
+    }
+
+    if (action === 'ask_user') {
+      const question = arg0;
+      const approved = await permissionManager.askPermission('shell', `Ask user: ${question}`, 'ask_user');
+      if (!approved) {
+        logToolCall('ask_user', { question }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const options = _parseNumberedOptions(question);
+      if (options.length >= 2) {
+        const selected = await permissionManager.captureSelect({ options });
+        logToolCall('ask_user', { question }, true, 'ok');
+        return { question, answer: selected || options[0] };
+      }
+      if (!process.stdout.isTTY || process.stdin.isRaw) {
+        process.stdout.write(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${DIM}[auto-answering 'y']${RST}\n`);
+        logToolCall('ask_user', { question }, true, 'ok');
+        return { question, answer: 'y' };
+      }
+      process.stdout.write(`\n  ${FG_YELLOW}?${RST} ${question}\n  ${FG_GRAY}>${RST} `);
+      const buf = Buffer.alloc(4096);
+      let input = '';
+      while (true) {
+        const n = fs.readSync(0, buf, 0, 1);
+        if (n === 0) break;
+        const ch = buf[0];
+        if (ch === 0x0a) break;
+        if (ch === 0x0d) continue;
+        input += String.fromCharCode(ch);
+      }
+      _log();
+      logToolCall('ask_user', { question }, true, 'ok');
+      return { question, answer: input };
+    }
+
+    if (action === 'store_memory') {
+      const key = arg0;
+      const value = arg1 || '';
+      const approved = await permissionManager.askPermission('file', `Store memory: ${key}`, 'store_memory');
+      if (!approved) {
+        logToolCall('store_memory', { key }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        mem[key] = value;
+        fs.mkdirSync(path.dirname(MEMORY_PATH), { recursive: true });
+        fs.writeFileSync(MEMORY_PATH, JSON.stringify(mem, null, 2));
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Stored memory: ${key}${RST}`);
+        logToolCall('store_memory', { key }, true, 'ok');
+        return { status: 'ok', key };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('store_memory', { key }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'recall_memory') {
+      const key = arg0;
+      const approved = await permissionManager.askPermission('file', `Recall memory: ${key}`, 'recall_memory');
+      if (!approved) {
+        logToolCall('recall_memory', { key }, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        const found = key in mem;
+        const value = found ? mem[key] : null;
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Recalled memory: ${key}${RST}`);
+        logToolCall('recall_memory', { key }, true, 'ok');
+        return { key, value, found };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('recall_memory', { key }, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'list_memories') {
+      const approved = await permissionManager.askPermission('file', 'List memories', 'list_memories');
+      if (!approved) {
+        logToolCall('list_memories', {}, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      try {
+        let mem = {};
+        try { mem = JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf8')); } catch {}
+        const keys = Object.keys(mem);
+        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Listed ${keys.length} memory key(s)${RST}`);
+        logToolCall('list_memories', {}, true, 'ok');
+        return { keys };
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('list_memories', {}, true, 'error');
+        return { error: error.message };
+      }
+    }
+
+    if (action === 'system_info') {
+      const approved = await permissionManager.askPermission('shell', 'System info', 'system_info');
+      if (!approved) {
+        logToolCall('system_info', {}, false, 'denied');
+        return { error: 'Permission denied' };
+      }
+      const info = {
+        platform: os.platform(),
+        arch: os.arch(),
+        hostname: os.hostname(),
+        user: process.env.USER || process.env.USERNAME || '',
+        total_mem_mb: Math.round(os.totalmem() / 1024 / 1024),
+        free_mem_mb: Math.round(os.freemem() / 1024 / 1024),
+        node_version: process.version,
+        cwd: process.cwd(),
+      };
+      _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}System info: ${info.platform}/${info.arch}${RST}`);
+      logToolCall('system_info', {}, true, 'ok');
+      return info;
+    }
+
+    logToolCall(action, { action }, false, 'error');
     return { error: `Unknown action: ${action}` };
   }
 
@@ -85,9 +800,162 @@ function createToolExecutor(permissionManager, ui) {
   };
 }
 
+// Map a MiniMax-style {name, params} invocation to the internal
+// [action, arg1, arg2, …] call tuple consumed by the agent loop.
+function mapInvokeToCall(toolName, params) {
+  const name = (toolName || '').toLowerCase();
+  const p = params || {};
+  switch (name) {
+    case 'write_file':
+    case 'create_file':
+      return p.path ? ['write', p.path, p.content != null ? p.content : ''] : null;
+    case 'read_file':
+      return p.path ? ['read', p.path] : null;
+    case 'append_file':
+      return p.path ? ['append', p.path, p.content != null ? p.content : ''] : null;
+    case 'delete_file':
+      return p.path ? ['delete_file', p.path] : null;
+    case 'list_dir':
+      return ['list_dir', p.path || p.dir || '.'];
+    case 'make_dir':
+      return p.path ? ['make_dir', p.path] : null;
+    case 'remove_dir':
+      return p.path ? ['remove_dir', p.path] : null;
+    case 'move_file':
+      return p.src && p.dst ? ['move_file', p.src, p.dst] : null;
+    case 'copy_file':
+      return p.src && p.dst ? ['copy_file', p.src, p.dst] : null;
+    case 'file_stat':
+      return p.path ? ['file_stat', p.path] : null;
+    case 'search_files':
+      return ['search_files', p.pattern || p.glob || '*', p.dir || '.'];
+    case 'search_in_file':
+      return p.path && p.pattern ? ['search_in_file', p.path, p.pattern] : null;
+    case 'replace_in_file':
+      return p.path && p.search !== undefined
+        ? ['replace_in_file', p.path, p.search, p.replace != null ? p.replace : '', p.flags || '']
+        : null;
+    case 'edit_file':
+      return p.path && p.line !== undefined
+        ? ['edit_file', p.path, parseInt(p.line, 10), p.content != null ? p.content : '']
+        : null;
+    case 'get_env':
+      return p.name ? ['get_env', p.name] : null;
+    case 'set_env':
+      return p.name ? ['set_env', p.name, p.value != null ? p.value : ''] : null;
+    case 'download':
+      return p.url ? ['download', p.url] : null;
+    case 'upload':
+      return p.path ? ['upload', p.path, p.content != null ? p.content : ''] : null;
+    case 'http_get':
+      return p.url ? ['http_get', p.url, p.raw || ''] : null;
+    case 'http_get_next':
+      return p.key ? ['http_get_next', p.key] : null;
+    case 'ask_user':
+      return p.question ? ['ask_user', p.question] : null;
+    case 'store_memory':
+      return p.key ? ['store_memory', p.key, p.value != null ? p.value : ''] : null;
+    case 'recall_memory':
+      return p.key ? ['recall_memory', p.key] : null;
+    case 'list_memories':
+      return ['list_memories'];
+    case 'system_info':
+      return ['system_info'];
+    case 'exec':
+    case 'shell':
+    case 'run':
+    case 'run_command':
+    case 'bash':
+      return p.command ? ['shell', p.command] : null;
+    default:
+      return null;
+  }
+}
+
 function extractToolCalls(text) {
   const calls = [];
 
+  // MiniMax-M2 / Qwen3 native tool-call wrappers. Emitted inline when the
+  // inference server's tool parser is disabled, or round-tripped back into
+  // text by chatStream when delta.tool_calls is streamed.
+  //
+  //   <minimax:tool_call>          <qwen:tool_call>
+  //     <invoke name="write_file">   <invoke name="write_file">
+  //       <parameter name="path">…     <parameter name="path">…
+  //     </invoke>                    </invoke>
+  //   </minimax:tool_call>         </qwen:tool_call>
+  const INVOKE_RE = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/g;
+  const PARAM_RE = /<parameter\s+name="([^"]+)"\s*>([\s\S]*?)<\/parameter>/g;
+  const WRAPPER_BLOCK_RE = /<(?:minimax:tool_call|qwen:tool_call)>([\s\S]*?)<\/(?:minimax:tool_call|qwen:tool_call)>/g;
+  for (const blockMatch of text.matchAll(WRAPPER_BLOCK_RE)) {
+    const block = blockMatch[1];
+    for (const invokeMatch of block.matchAll(INVOKE_RE)) {
+      const params = {};
+      for (const pMatch of invokeMatch[2].matchAll(PARAM_RE)) {
+        let val = pMatch[2];
+        if (val.startsWith('\n')) val = val.slice(1);
+        if (val.endsWith('\n')) val = val.slice(0, -1);
+        params[pMatch[1]] = val;
+      }
+      const call = mapInvokeToCall(invokeMatch[1], params);
+      if (call) calls.push(call);
+    }
+  }
+
+  // Qwen3 / Hermes-style JSON tool-call format. Qwen3-30B-A3B, Qwen3.5-4B,
+  // and most Qwen-derived finetunes (Qwen3.6-Opus4.7 etc.) emit:
+  //
+  //   <tool_call>
+  //   {"name": "write_file", "arguments": {"path": "a.css", "content": "…"}}
+  //   </tool_call>
+  //
+  // Some variants use <function_call> or the key `parameters` instead of
+  // `arguments`. The block may also wrap <invoke> when the finetune follows
+  // the MiniMax instruction template — handle both.
+  const JSON_BLOCK_RE = /<(tool_call|function_call)>([\s\S]*?)<\/\1>/g;
+  for (const blockMatch of text.matchAll(JSON_BLOCK_RE)) {
+    const inner = blockMatch[2].trim();
+    if (!inner) continue;
+
+    if (/<invoke\s/i.test(inner)) {
+      for (const invokeMatch of inner.matchAll(INVOKE_RE)) {
+        const params = {};
+        for (const pMatch of invokeMatch[2].matchAll(PARAM_RE)) {
+          let val = pMatch[2];
+          if (val.startsWith('\n')) val = val.slice(1);
+          if (val.endsWith('\n')) val = val.slice(0, -1);
+          params[pMatch[1]] = val;
+        }
+        const call = mapInvokeToCall(invokeMatch[1], params);
+        if (call) calls.push(call);
+      }
+      continue;
+    }
+
+    let parsed = null;
+    try { parsed = JSON.parse(inner); } catch {}
+    if (!parsed) {
+      const firstBrace = inner.indexOf('{');
+      const lastBrace = inner.lastIndexOf('}');
+      if (firstBrace !== -1 && lastBrace > firstBrace) {
+        try { parsed = JSON.parse(inner.slice(firstBrace, lastBrace + 1)); } catch {}
+      }
+    }
+    if (!parsed) continue;
+
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    for (const entry of entries) {
+      if (!entry || typeof entry !== 'object') continue;
+      const name = entry.name || entry.tool || entry.function || entry.tool_name;
+      const params = entry.arguments || entry.parameters || entry.params || entry.args || {};
+      const resolved = typeof params === 'string'
+        ? (() => { try { return JSON.parse(params); } catch { return {}; } })()
+        : params;
+      const call = mapInvokeToCall(name, resolved);
+      if (call) calls.push(call);
+    }
+  }
+
   for (const match of text.matchAll(/```(?:shell|bash|sh)\n([\s\S]*?)```/g)) {
     for (const line of match[1].trim().split('\n')) {
       const cmd = line.trim();
@@ -95,11 +963,7 @@ function extractToolCalls(text) {
     }
   }
 
-  for (const match of text.matchAll(/<shell>([\s\S]*?)<\/shell>/g)) {
-    calls.push(['shell', match[1].trim()]);
-  }
-
-  for (const match of text.matchAll(/<exec>([\s\S]*?)<\/exec>/g)) {
+  for (const match of text.matchAll(/<(?:shell|exec|run_command|run)>([\s\S]*?)<\/(?:shell|exec|run_command|run)>/g)) {
     calls.push(['shell', match[1].trim()]);
   }
 
@@ -107,14 +971,124 @@ function extractToolCalls(text) {
     calls.push(['read', match[1].trim()]);
   }
 
+  for (const match of text.matchAll(/<read_file\s+path="([^"]+)"\s*\/?>/g)) {
+    calls.push(['read', match[1]]);
+  }
+
   for (const match of text.matchAll(/<write_file\s+path="([^"]+)">([\s\S]*?)<\/write_file>/g)) {
     calls.push(['write', match[1], match[2]]);
   }
 
+  for (const match of text.matchAll(/<create_file\s+path="([^"]+)">([\s\S]*?)<\/create_file>/g)) {
+    calls.push(['write', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<append_file\s+path="([^"]+)">([\s\S]*?)<\/append_file>/g)) {
+    calls.push(['append', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<list_dir>([\s\S]*?)<\/list_dir>/g)) {
+    calls.push(['list_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<search_files>([\s\S]*?)<\/search_files>/g)) {
+    calls.push(['search_files', match[1].trim(), '.']);
+  }
+
+  for (const match of text.matchAll(/<search_files\s+pattern="([^"]+)"(?:\s+dir="([^"]*)")?\s*(?:><\/search_files>|\/>)/g)) {
+    calls.push(['search_files', match[1], match[2] || '.']);
+  }
+
+  for (const match of text.matchAll(/<delete_file>([\s\S]*?)<\/delete_file>/g)) {
+    calls.push(['delete_file', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<make_dir>([\s\S]*?)<\/make_dir>/g)) {
+    calls.push(['make_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<remove_dir>([\s\S]*?)<\/remove_dir>/g)) {
+    calls.push(['remove_dir', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<get_env>([\s\S]*?)<\/get_env>/g)) {
+    calls.push(['get_env', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<set_env\s+name="([^"]+)"\s+value="([^"]*)"\s*(?:><\/set_env>|\/>)/g)) {
+    calls.push(['set_env', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<move_file\s+src="([^"]+)"\s+dst="([^"]+)"\s*(?:><\/move_file>|\/>)/g)) {
+    calls.push(['move_file', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<copy_file\s+src="([^"]+)"\s+dst="([^"]+)"\s*(?:><\/copy_file>|\/>)/g)) {
+    calls.push(['copy_file', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<edit_file\s+path="([^"]+)"\s+line="(\d+)">([\s\S]*?)<\/edit_file>/g)) {
+    calls.push(['edit_file', match[1], parseInt(match[2], 10), match[3]]);
+  }
+
+  for (const match of text.matchAll(/<search_in_file\s+path="([^"]+)">([\s\S]*?)<\/search_in_file>/g)) {
+    calls.push(['search_in_file', match[1], match[2].trim()]);
+  }
+
+  for (const match of text.matchAll(/<replace_in_file\s+path="([^"]+)"\s+search="([^"]*)"\s+replace="([^"]*)">([\s\S]*?)<\/replace_in_file>/g)) {
+    calls.push(['replace_in_file', match[1], match[2], match[3], match[4].trim()]);
+  }
+
+  for (const match of text.matchAll(/<download>([\s\S]*?)<\/download>/g)) {
+    calls.push(['download', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<upload\s+path="([^"]+)">([\s\S]*?)<\/upload>/g)) {
+    calls.push(['upload', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<file_stat>([\s\S]*?)<\/file_stat>/g)) {
+    calls.push(['file_stat', match[1].trim()]);
+  }
+
+  for (const match of text.matchAll(/<http_get\b([^>]*?)(?:><\/http_get>|\/>)/g)) {
+    const attrStr = match[1];
+    const urlMatch = attrStr.match(/url="([^"]+)"/);
+    const rawMatch = attrStr.match(/raw="([^"]+)"/);
+    if (urlMatch) calls.push(['http_get', urlMatch[1], rawMatch ? rawMatch[1] : '']);
+  }
+
+  for (const match of text.matchAll(/<http_get_next\s+key="([^"]+)"\s*(?:><\/http_get_next>|\/>)/g)) {
+    calls.push(['http_get_next', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<ask_user\s+question="([^"]+)"\s*(?:><\/ask_user>|\/>)/g)) {
+    calls.push(['ask_user', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<store_memory\s+key="([^"]+)">([\s\S]*?)<\/store_memory>/g)) {
+    calls.push(['store_memory', match[1], match[2]]);
+  }
+
+  for (const match of text.matchAll(/<recall_memory\s+key="([^"]+)"\s*(?:><\/recall_memory>|\/>)/g)) {
+    calls.push(['recall_memory', match[1]]);
+  }
+
+  for (const match of text.matchAll(/<list_memories\s*(?:><\/list_memories>|\/>)/g)) {
+    calls.push(['list_memories']);
+  }
+
+  for (const match of text.matchAll(/<system_info\s*(?:><\/system_info>|\/>)/g)) {
+    calls.push(['system_info']);
+  }
+
   return calls;
 }
 
 module.exports = {
   createToolExecutor,
   extractToolCalls,
+  getSkippedOps,
+  mapInvokeToCall,
+  setUIActive,
 };