@semalt-ai/code 1.8.0 → 1.8.1

package/lib/agent.js

@@ -395,6 +395,19 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
           break;
         } catch (err) {
           lastApiErr = err;
+          if (debug) {
+            const header = `\n───── raw http error (iteration ${iteration + 1}, attempt ${attempt}/${MAX_RETRIES}) ─────\n`;
+            const footer = `\n───── end raw http error ─────\n`;
+            const status = err.statusCode ? `HTTP ${err.statusCode}` : 'network error';
+            const headerLines = err.responseHeaders
+              ? Object.entries(err.responseHeaders).map(([k, v]) => `${k}: ${v}`).join('\n')
+              : '';
+            const body = err.rawBody !== undefined ? err.rawBody : (err.stack || err.message || String(err));
+            const parts = [status];
+            if (headerLines) parts.push(headerLines);
+            parts.push(body || '(empty body)');
+            process.stderr.write(header + parts.join('\n\n') + footer);
+          }
         }
       }
 
@@ -433,18 +446,74 @@ function createAgentRunner({ chatStream, extractToolCalls, agentExecShell, agent
         }
       }
 
-      if (!reply) break;
+      if (!reply) {
+        // Empty reply from the model — stream resolved with no content and no
+        // tool_calls. Most common causes: server-side disconnect mid-stream,
+        // context-window overflow that slipped past the 400/413 handler, or a
+        // model that returns only a stop token. Surface it so the user isn't
+        // left staring at an idle prompt.
+        if (cb.onError) {
+          const hint = iteration > 0 ? ' (after tool execution)' : '';
+          cb.onError({ message: `Agent returned an empty response${hint}. The connection to the model may have dropped — try again or /compact if context is large.`, isWarning: true });
+        }
+        break;
+      }
 
       const toolCalls = extractToolCalls(reply);
       const cleanedReply = cleanAssistantContent(reply);
 
+      // Detect mid-tag truncation: an opening tool tag in the raw reply with
+      // no matching close. This happens when the model streams a large
+      // `<write_file>…` body and hits max_tokens or a server-side cutoff
+      // before the closing tag arrives. cleanAssistantContent strips the
+      // unclosed tag + its trailing content, so cleanedReply looks
+      // legitimate (just the planning preamble) and extractToolCalls finds
+      // zero calls — the loop would break silently and the user sees the
+      // planning text followed by nothing. Surface it so the user can retry,
+      // shorten the request, or bump max_tokens.
+      let truncatedTag = null;
+      for (const [tag, entry] of Object.entries(TAG_REGISTRY)) {
+        if (entry.type !== 'tool') continue;
+        let opens = 0;
+        for (const m of reply.matchAll(new RegExp(`<${tag}([^>]*)>`, 'gi'))) {
+          // Skip self-closing (`<tag .../>`) — they don't need a matching close.
+          if (!m[1].trimEnd().endsWith('/')) opens++;
+        }
+        if (opens === 0) continue;
+        const closes = (reply.match(new RegExp(`<\\/${tag}>`, 'gi')) || []).length;
+        if (opens > closes) { truncatedTag = tag; break; }
+      }
+      if (truncatedTag && cb.onError) {
+        cb.onError({ message: `Response truncated mid-<${truncatedTag}> tag — likely hit max_tokens or a server-side cutoff. Try again, shorten the request, or raise the model's max_tokens.`, isWarning: true });
+      }
+
       messages.push({ role: 'assistant', content: cleanedReply });
       // When showThink is off and the turn has tool calls, suppress the text bubble —
       // pre-tool reasoning is noise, tool result bubbles already convey what happened.
       const displayReply = (!showThink && toolCalls.length > 0) ? '' : cleanedReply;
       if (cb.onAssistantMessage) cb.onAssistantMessage(displayReply);
 
-      if (toolCalls.length === 0) break;
+      // If nothing meaningful came back (no text to show, no tools to run) but
+      // the reply string wasn't strictly empty, it's usually model wrapper
+      // noise or a stripped-only response. Still a dead-end for the user.
+      if (toolCalls.length === 0 && !cleanedReply.trim()) {
+        if (cb.onError) {
+          cb.onError({ message: 'Agent reply had no visible content and no actions — stopping.', isWarning: true });
+        }
+        break;
+      }
+
+      if (toolCalls.length === 0) {
+        // Model narrated next steps but didn't emit a tool tag. Happens when the
+        // model ends a plan with "Let me do that for you." and stops. If we just
+        // break, the user sees a dangling promise and thinks the connection dropped.
+        if (iteration > 0 && /\b(let me|i['’]?ll|i will|i'?m going to|next[, ]|now[, ]? ?(i|we)|going to (create|write|build|add|make|run|do|set up|install))\b/i.test(cleanedReply)) {
+          if (cb.onError) {
+            cb.onError({ message: 'Agent described next steps but did not emit a tool call. Reply "continue" (or similar) to push it forward, or restart if it keeps stalling.', isWarning: true });
+          }
+        }
+        break;
+      }
       if (isAborted()) break;
 
       if (!cb.onToolStart) {

package/lib/api.js

@@ -284,6 +284,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       messages: trimmedMessages,
       temperature: temperature !== undefined ? temperature : config.temperature,
       stream: true,
+      stream_options: { include_usage: true },
     };
 
     if (maxTokens !== undefined) payload.max_tokens = maxTokens;
@@ -319,6 +320,8 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         err.statusCode = res.statusCode;
         err.parsedErr = parsedErr;
         err.detail = detail;
+        err.rawBody = errBody;
+        err.responseHeaders = res.headers;
         throw err;
       }
       return res;
@@ -365,6 +368,9 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       let inReasoning = false;
       let streamUsage = null;
       let resolved = false;
+      // delta.tool_calls accumulator (OpenAI function-calling streaming format).
+      // Keyed by `index` per the OpenAI spec.
+      const toolCallAcc = [];
       const renderer = new StreamRenderer({ firstLinePrefix: linePrefix, showThink });
       if (!silent) {
         process.stdout.write('\n');
@@ -373,9 +379,35 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       let firstContentToken = true;
       let lineBuffer = '';
 
+      function escapeXml(s) {
+        return String(s)
+          .replace(/&/g, '&')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;');
+      }
+
+      // Convert any accumulated tool_calls into a MiniMax XML block and
+      // append it to fullText so extractToolCalls() picks them up. Runs once
+      // at stream end.
+      function appendToolCallsXml() {
+        const valid = toolCallAcc.filter((t) => t && t.name);
+        if (valid.length === 0) return;
+        const invokes = valid.map((tc) => {
+          let args = {};
+          try { args = tc.arguments ? JSON.parse(tc.arguments) : {}; } catch {}
+          const params = Object.entries(args).map(([k, v]) => {
+            const val = typeof v === 'string' ? v : JSON.stringify(v);
+            return `<parameter name="${escapeXml(k)}">${val}</parameter>`;
+          }).join('\n');
+          return `<invoke name="${escapeXml(tc.name)}">\n${params}\n</invoke>`;
+        }).join('\n');
+        fullText += `\n<minimax:tool_call>\n${invokes}\n</minimax:tool_call>`;
+      }
+
       function finalize() {
         if (resolved) return;
         resolved = true;
+        appendToolCallsXml();
         if (!silent) renderer.flush();
         const elapsed = (Date.now() - startTime) / 1000;
         const tps = tokenCount / (elapsed || 1);
@@ -385,7 +417,16 @@ function createApiClient({ getConfig, saveConfig, ui }) {
           StatusBar.current.liveUpdate({ tokens: `${tokenCount} tok`, latency });
           StatusBar.current.render();
         }
-        resolve({ content: fullText, usage: streamUsage });
+        // Fallback for endpoints that don't honor stream_options.include_usage:
+        // estimate prompt/completion tokens locally so the status bar still updates.
+        let usage = streamUsage;
+        if (!usage) {
+          usage = {
+            prompt_tokens: estimateTokens(JSON.stringify(trimmedMessages)),
+            completion_tokens: estimateTokens(fullText) + estimateTokens(reasoningText),
+          };
+        }
+        resolve({ content: fullText, usage });
       }
 
       res.setEncoding('utf8');
@@ -427,6 +468,25 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               }
             }
 
+            const toolCallsDelta = delta.tool_calls;
+            if (Array.isArray(toolCallsDelta)) {
+              for (const tc of toolCallsDelta) {
+                const idx = typeof tc.index === 'number' ? tc.index : toolCallAcc.length;
+                const isNew = !toolCallAcc[idx];
+                if (isNew) toolCallAcc[idx] = { name: '', arguments: '' };
+                if (tc.function?.name) toolCallAcc[idx].name += tc.function.name;
+                if (tc.function?.arguments) toolCallAcc[idx].arguments += tc.function.arguments;
+                // When the model streams purely via delta.tool_calls (no
+                // delta.content), firstContentToken never flips, so the status
+                // bar stays on "Thinking…" for the entire tool-call stream.
+                // Surface each new tool slot the moment its name is known so
+                // the user sees "Using tool: <name>" instead of a frozen UI.
+                if (isNew && StatusBar.current && toolCallAcc[idx].name) {
+                  StatusBar.current.update('tool', `Using tool: ${toolCallAcc[idx].name}`);
+                }
+              }
+            }
+
             const content = delta.content || '';
             if (content) {
               if (inReasoning) {

package/lib/commands.js

@@ -7,6 +7,7 @@ const { configShow } = require('./config');
 const { SYSTEM_PROMPT } = require('./prompts');
 const { SessionStorage } = require('./storage');
 const { getSkippedOps, setUIActive } = require('./tools');
+const { AUDIT_LOG } = require('./audit');
 
 function formatTimeAgo(ts) {
   const diffMs = Date.now() - ts;
@@ -150,6 +151,7 @@ function createCommands({
     let messages = [];
     let currentChatId = null;
     let savedUpTo = 0;
+    let debugMode = !!opts.debug;
 
     // Resolve system prompt override from --system-prompt file if provided
     let resolvedSystemPrompt = null;
@@ -576,6 +578,7 @@ function createCommands({
             '  /shell <cmd>    Run shell command',
             '  !<cmd>          Run shell command',
             '  /approve        Toggle auto-approve',
+            '  /debug [off]    Enable debug output + show last 5 audit entries',
             '  /config         Show config',
             '  exit            Quit',
           ].join('\n'),
@@ -753,6 +756,40 @@ function createCommands({
         return;
       }
 
+      if (text === '/debug' || text.startsWith('/debug ')) {
+        const arg = text === '/debug' ? '' : text.slice(7).trim().toLowerCase();
+        if (arg === 'off' || arg === 'false' || arg === '0') debugMode = false;
+        else debugMode = true;
+
+        let tail = '';
+        try {
+          const content = fs.readFileSync(AUDIT_LOG, 'utf8');
+          const lines = content.trim().split('\n').filter((l) => l.trim()).slice(-5);
+          if (lines.length) {
+            const formatted = lines.map((line) => {
+              try {
+                const entry = JSON.parse(line);
+                const mark = entry.approved ? '✓' : '✗';
+                return `  ${mark} ${entry.ts} ${entry.tag} ${entry.input} → ${entry.result}`;
+              } catch {
+                return `  ${line}`;
+              }
+            });
+            tail = '\nLast 5 audit entries:\n' + formatted.join('\n');
+          } else {
+            tail = '\nAudit log is empty.';
+          }
+        } catch {
+          tail = '\nNo audit log found.';
+        }
+
+        chatHistory.addMessage({
+          role: 'system',
+          content: `Debug output: ${debugMode ? 'ON' : 'OFF'} (raw messages, raw AI responses, raw HTTP errors → stderr)${tail}`,
+        });
+        return;
+      }
+
       if (text.startsWith('/shell ') || text.startsWith('!')) {
         const cmd = text.startsWith('/shell ') ? text.slice(7).trim() : text.slice(1).trim();
         inputField.setDisabled(true);
@@ -810,7 +847,12 @@ function createCommands({
           if (entry?.type === 'tool') {
             const actionLabel = entry.label || tag;
             const detail = attrs.path || attrs.url || attrs.key || attrs.src || '';
-            statusBar.update('tool', `${actionLabel}${detail ? ': ' + detail : ''}`);
+            const isDownload = tag === 'download' || tag === 'http_get' || tag === 'http_get_next';
+            const barState = isDownload ? 'waiting_download' : 'tool';
+            const label = isDownload
+              ? `Waiting for download${detail ? ': ' + detail : ''}`
+              : `${actionLabel}${detail ? ': ' + detail : ''}`;
+            statusBar.update(barState, label);
             if (!opts.showThink) chatHistory.clearStreamingContent();
           }
           if (entry?.display === 'think_bubble') {
@@ -824,7 +866,12 @@ function createCommands({
         onToolStart: (tag, input, attrs) => {
           const actionLabel = TAG_REGISTRY[tag]?.label || tag;
           const short = input.length > 40 ? input.slice(0, 40) + '…' : input;
-          statusBar.update('tool', `${actionLabel}: ${short}`);
+          const isDownload = tag === 'download' || tag === 'http_get' || tag === 'http_get_next';
+          if (isDownload) {
+            statusBar.update('waiting_download', `Waiting for download: ${short}`);
+          } else {
+            statusBar.update('tool', `${actionLabel}: ${short}`);
+          }
         },
         onToolEnd: (tag, result, durationMs) => {
           const isError = typeof result === 'string' && result.startsWith('Error');
@@ -913,7 +960,7 @@ function createCommands({
       try {
         const agentResult = await runAgentLoop(messages, currentModel, undefined, resolvedTokenLimit, {
           showThink: opts.showThink || false,
-          debug: opts.debug || false,
+          debug: debugMode,
           callbacks,
           systemPrompt: resolvedSystemPrompt,
           systemPromptMode: getConfig().system_prompt_mode || 'system_role',

package/lib/constants.js

@@ -34,6 +34,7 @@ const TAG_REGISTRY = {
   think:      { type: 'visual', streaming: true,  display: 'think_bubble' },
   reasoning:  { type: 'visual', streaming: true,  display: 'think_bubble' },
   reflection: { type: 'visual', streaming: true,  display: 'think_bubble' },
+  plan:       { type: 'visual', streaming: true,  display: 'think_bubble' },
 
   // Executed as tool calls
   exec:             { type: 'tool', streaming: false, label: 'Running command' },
@@ -65,6 +66,21 @@ const TAG_REGISTRY = {
   list_memories:    { type: 'tool', streaming: false, label: 'Listing memories' },
   system_info:      { type: 'tool', streaming: false, label: 'Reading system info' },
 
+  // MiniMax-M2 native tool-call wrappers. `extractToolCalls` parses them into
+  // internal calls; classifying them here keeps raw XML out of the UI stream.
+  'minimax:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  invoke:    { type: 'strip' },
+  parameter: { type: 'strip' },
+
+  // Qwen / Hermes native tool-call wrappers. Qwen3-family models emit a
+  // JSON-shaped `<tool_call>{"name":"...","arguments":{...}}</tool_call>`
+  // block inline when the server's tool parser is not applied, and some
+  // finetunes also use the namespaced `<qwen:tool_call>` or the
+  // `<function_call>` spelling. `extractToolCalls` parses all three.
+  'qwen:tool_call': { type: 'tool', streaming: false, label: 'Using tool' },
+  tool_call:       { type: 'tool', streaming: false, label: 'Using tool' },
+  function_call:   { type: 'tool', streaming: false, label: 'Using tool' },
+
   // Silently stripped — model wrapper artifacts
   answer:    { type: 'strip' },
   response:  { type: 'strip' },

package/lib/prompts.js

@@ -85,20 +85,27 @@ To read an environment variable:
 To set an environment variable for the current session:
 <set_env name="VARIABLE_NAME" value="value"/>
 
-To reason or think before acting (hidden from user by default):
-<think>your reasoning here</think>
+To plan your next action before executing a tool (hidden from user by default):
+<plan>your reasoning and planned next step here</plan>
+
+## Reasoning vs planning — IMPORTANT:
+
+- Your internal chain-of-thought reasoning uses your native \`<think>...</think>\` block. Use it normally for deliberation. Do NOT treat \`<think>\` as a user-facing tool and do NOT try to emit \`<think>\` as an action — it is reserved for your own reasoning and is handled by the runtime.
+- When you need to explicitly record a short plan that the agent framework can see (for logging or hand-off between steps), use \`<plan>...</plan>\` instead. \`<plan>\` is a tool tag; \`<think>\` is not.
+- Never emit \`<think>\` as one of the "one tool tag per response" actions. The valid action tags are only the ones listed above (exec, read_file, write_file, plan, etc.).
 
 ## STRICT RULES — follow exactly:
 
-1. **ONE tool tag per response, no exceptions.** After emitting a tag, stop. Wait for the result. Then emit the next tag in your next response. Never put two or more action tags in the same response.
-2. Only use the exact tag names listed above. Unknown tag names will not be executed.
-3. When the user asks you to do something on their system, USE the tools — do NOT just print instructions.
-4. Each action will be shown to the user for approval before execution.
-5. After execution you will receive the result and can proceed.
-6. Be concise. Provide working solutions. Use markdown for code blocks in explanations.
-7. **Permission denied fallback:** If any tool action (write_file, delete_file, make_dir, etc.) is denied or returns a permission error, immediately retry the same operation using \`<exec>\` with an equivalent shell command (e.g. \`tee\`, \`rm\`, \`mkdir -p\`, \`cp\`, \`mv\`). Never give up after a single denial — the shell is always the fallback.
-8. If a shell command itself also fails with a permission error, immediately retry it prefixed with \`sudo\` (e.g. \`sudo tee /path\`, \`sudo mkdir -p /path\`). Do not ask — just try. Only stop and explain if sudo itself fails.
-9. Current working directory: ${process.cwd()}`;
+1. **ONE tool tag per response, no exceptions.** After emitting a tag, stop. Wait for the result. Then emit the next tag in your next response. Never put two or more action tags in the same response. (Your native \`<think>\` reasoning block does NOT count as a tool tag and may precede the action tag normally.)
+2. **Always end your response with exactly one action tag** whenever the task is not yet complete. Do NOT end a response with only prose like "Let me create the files…" — that prose must be immediately followed by the actual tool tag in the same response. Preamble without a tool tag is a bug.
+3. Only use the exact tag names listed above. Unknown tag names will not be executed.
+4. When the user asks you to do something on their system, USE the tools — do NOT just print instructions.
+5. Each action will be shown to the user for approval before execution.
+6. After execution you will receive the result and can proceed with the next action in a new response.
+7. Be concise. Provide working solutions. Use markdown for code blocks in explanations.
+8. **Permission denied fallback:** If any tool action (write_file, delete_file, make_dir, etc.) is denied or returns a permission error, immediately retry the same operation using \`<exec>\` with an equivalent shell command (e.g. \`tee\`, \`rm\`, \`mkdir -p\`, \`cp\`, \`mv\`). Never give up after a single denial — the shell is always the fallback.
+9. If a shell command itself also fails with a permission error, immediately retry it prefixed with \`sudo\` (e.g. \`sudo tee /path\`, \`sudo mkdir -p /path\`). Do not ask — just try. Only stop and explain if sudo itself fails.
+10. Current working directory: ${process.cwd()}`;
 
 module.exports = {
   SYSTEM_PROMPT,

package/lib/tools.js

@@ -125,8 +125,12 @@ function createToolExecutor(permissionManager, ui, getConfig) {
       // 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);
-      process.stdout.write(diffOutput + '\n');
+      if (!_uiActive) process.stdout.write(diffOutput + '\n');
 
       // Dry-run: record the skipped op and return without writing
       if (_dryRun) {
@@ -139,6 +143,7 @@ function createToolExecutor(permissionManager, ui, getConfig) {
       // 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)`;
+      if (_uiActive) desc = `${desc}\n${diffOutput}`;
       const approved = await permissionManager.askPermission('file', desc, tag);
       if (!approved) {
         logToolCall(tag, { path: filePath, content }, false, 'denied');
@@ -270,27 +275,21 @@ function createToolExecutor(permissionManager, ui, getConfig) {
       try {
         const dstDir = path.dirname(dst);
         if (dstDir && dstDir !== '.') fs.mkdirSync(dstDir, { recursive: true });
-        const cfg = getConfig ? getConfig() : {};
-        const timeout = cfg.command_timeout_ms || 30000;
-        const mvResult = spawnSync('mv', [src, dst], { encoding: 'utf8', timeout });
-        if (mvResult.error && mvResult.error.code === 'ENOENT') throw new Error('mv not available');
-        if (mvResult.error) throw mvResult.error;
-        if (mvResult.status !== 0) throw new Error((mvResult.stderr || 'mv failed').trim());
-        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Moved ${src} → ${dst}${RST}`);
-        logToolCall('move_file', { src, dst }, true, 'ok');
-        return { status: 'ok', src, dst };
-      } catch (mvErr) {
-        // Fallback: JS rename (works only within same filesystem)
         try {
           fs.renameSync(src, dst);
-          _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 };
+        } 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 };
       }
     }
 
@@ -360,36 +359,18 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         return { error: 'Permission denied' };
       }
       try {
-        const cfg = getConfig ? getConfig() : {};
-        const timeout = cfg.command_timeout_ms || 30000;
-        const gr = spawnSync('grep', ['-n', '-E', '--', pattern, filePath], { encoding: 'utf8', timeout });
-        if (gr.error && gr.error.code === 'ENOENT') throw new Error('grep not available');
-        if (gr.error) throw gr.error;
-        // grep exit 1 = no matches (not an error), 2 = real error
-        if (gr.status === 2) throw new Error((gr.stderr || '').trim() || 'grep error');
-        const matches = (gr.stdout || '').split('\n').filter(Boolean).map(line => {
-          const colon = line.indexOf(':');
-          return colon === -1 ? null : { line: parseInt(line.slice(0, colon), 10), content: line.slice(colon + 1) };
-        }).filter(Boolean);
+        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 (grepErr) {
-        // Fallback: JS regex search
-        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 };
-        }
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('search_in_file', { path: filePath, pattern }, true, 'error');
+        return { error: error.message };
       }
     }
 
@@ -430,52 +411,32 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         return { error: 'Permission denied' };
       }
       try {
-        const cfg = getConfig ? getConfig() : {};
-        const timeout = cfg.command_timeout_ms || 30000;
-        // Split glob: "src/**/*.js" → root=searchDir/src, nameGlob="*.js"
-        const parts = pattern.split('/');
-        const nameGlob = parts[parts.length - 1];
-        const subDirs = parts.slice(0, -1).filter(p => p !== '**' && p !== '');
-        const searchRoot = subDirs.length > 0 ? path.join(searchDir, ...subDirs) : searchDir;
-        const fr = spawnSync('find', [searchRoot, '-type', 'f', '-name', nameGlob], { encoding: 'utf8', timeout });
-        if (fr.error && fr.error.code === 'ENOENT') throw new Error('find not available');
-        if (fr.error) throw fr.error;
-        const files = (fr.stdout || '').split('\n').filter(Boolean)
-          .map(f => path.relative(searchDir, f))
-          .filter(Boolean)
-          .sort();
+        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 (_findErr) {
-        // Fallback: JS glob walker
-        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, '');
-          _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 };
-        }
+      } catch (error) {
+        _log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        logToolCall('search_files', { pattern, dir: searchDir }, true, 'error');
+        return { error: error.message };
       }
     }
 
@@ -543,37 +504,50 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         logToolCall('download', { url }, false, 'denied');
         return { error: 'Permission denied' };
       }
-      const dlResult = spawnSync('curl', ['-sLo', outPath, url], { encoding: 'utf8', timeout: 120000 });
-      if (!dlResult.error || dlResult.error.code !== 'ENOENT') {
-        if (dlResult.error || dlResult.status !== 0) {
-          try { fs.unlinkSync(outPath); } catch {}
-          const msg = dlResult.error ? dlResult.error.message : (dlResult.stderr || 'curl failed').trim();
-          _log(`  ${FG_RED}✗ ${msg}${RST}`);
-          logToolCall('download', { url }, true, 'error');
-          return { error: msg };
-        }
-        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}Downloaded to ${outPath}${RST}`);
-        logToolCall('download', { url }, true, 'ok');
-        return { status: 'ok', path: outPath };
-      }
-      // Fallback: Node.js http/https
       return new Promise((resolve) => {
-        const proto = url.startsWith('https') ? https : http;
-        const file = fs.createWriteStream(outPath);
-        proto.get(url, (res) => {
-          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 });
+        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 });
+            });
           });
-        }).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);
       });
     }
 
@@ -662,32 +636,13 @@ function createToolExecutor(permissionManager, ui, getConfig) {
         return { error: 'Permission denied' };
       }
       const httpCfg = getConfig ? getConfig() : {};
-      const curlTimeout = Math.max(15, Math.floor((httpCfg.request_timeout_ms || 15000) / 1000));
-      // Try curl first: -sL follows redirects; -w appends status code on its own line
-      const curlResult = spawnSync(
-        'curl', ['-sL', '--max-time', String(curlTimeout), '-w', '\n%{http_code}', url],
-        { encoding: 'utf8', timeout: (curlTimeout + 5) * 1000 }
-      );
-      if (!curlResult.error || curlResult.error.code !== 'ENOENT') {
-        if (curlResult.error) {
-          _log(`  ${FG_RED}✗ ${curlResult.error.message}${RST}`);
-          logToolCall('http_get', { url }, true, 'error');
-          return { error: curlResult.error.message };
-        }
-        const stdout = curlResult.stdout || '';
-        const lastNl = stdout.lastIndexOf('\n');
-        const body = lastNl >= 0 ? stdout.slice(0, lastNl) : stdout;
-        const statusCode = parseInt((lastNl >= 0 ? stdout.slice(lastNl + 1) : '').trim(), 10) || 0;
-        _log(`  ${FG_GREEN}✓${RST} ${FG_GRAY}HTTP GET ${url} (${statusCode}, ${body.length} chars)${RST}`);
-        logToolCall('http_get', { url }, true, statusCode < 400 ? 'ok' : 'error');
-        return buildHttpResult(url, statusCode, body, rawHtml);
-      }
-      // Fallback: Node.js http/https
+      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 = '';
@@ -704,9 +659,13 @@ function createToolExecutor(permissionManager, ui, getConfig) {
             logToolCall('http_get', { url: target }, true, 'error');
             resolve({ error: err.message });
           });
-          req.setTimeout(15000, () => { req.destroy(); logToolCall('http_get', { url: target }, true, 'error'); resolve({ error: 'Request timeout' }); });
+          req.setTimeout(reqTimeoutMs, () => {
+            req.destroy();
+            logToolCall('http_get', { url: target }, true, 'error');
+            resolve({ error: 'Request timeout' });
+          });
         }
-        doGet(url, 3);
+        doGet(url, 5);
       });
     }
 
@@ -841,9 +800,162 @@ function createToolExecutor(permissionManager, ui, getConfig) {
   };
 }
 
+// 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();
@@ -977,5 +1089,6 @@ module.exports = {
   createToolExecutor,
   extractToolCalls,
   getSkippedOps,
+  mapInvokeToCall,
   setUIActive,
 };

package/lib/ui/ansi.js

@@ -50,9 +50,10 @@ const KEYWORDS = new Set([
 ]);
 
 const SPINNER_DEFS = {
-  thinking:  { frames: ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'], color: '\x1b[36m' },
-  streaming: { frames: ['▁','▂','▃','▄','▅','▆','▇','█','▇','▆','▅','▄','▃','▂'], color: '\x1b[32m' },
-  tool:      { frames: ['⣾','⣽','⣻','⢿','⡿','⣟','⣯','⣷'], color: '\x1b[33m' },
+  thinking:          { frames: ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'], color: '\x1b[36m' },
+  streaming:         { frames: ['▁','▂','▃','▄','▅','▆','▇','█','▇','▆','▅','▄','▃','▂'], color: '\x1b[32m' },
+  tool:              { frames: ['⣾','⣽','⣻','⢿','⡿','⣟','⣯','⣷'], color: '\x1b[33m' },
+  waiting_download:  { frames: ['⬇ ','⬇⠂','⬇⠆','⬇⠇','⬇⠧','⬇⠷','⬇⠿','⬇⠾','⬇⠼','⬇⠸','⬇⠰','⬇⠠'], color: '\x1b[38;5;75m' },
 };
 
 module.exports = {

package/lib/ui/chat-history.js

@@ -138,7 +138,7 @@ class ChatHistory {
     } else if (msg.role === 'permission') {
       process.stdout.write(`\n${FG_YELLOW}  ⚠ Permission required: ${content}${RST}\n`);
     } else {
-      const isErr = msg.isError || (content.toLowerCase().includes('error') && !content.toLowerCase().includes('iswarning'));
+      const isErr = !!msg.isError && !msg.isWarning;
       const color = isErr ? FG_RED : FG_YELLOW;
       const prefix = isErr ? '✕' : '⚠';
       const lines = content.split('\n');

package/lib/ui/input-field.js

@@ -7,7 +7,7 @@ const { RST, DIM, FG_CYAN, FG_GREEN, FG_YELLOW } = require('./ansi');
 
 const SLASH_CMDS = [
   '/help','/file','/new','/model','/models','/shell','/compact',
-  '/clear','/approve','/config','/history','/login','/whoami','/logout','/chats',
+  '/clear','/approve','/debug','/config','/history','/login','/whoami','/logout','/chats',
 ];
 
 // ─── Key sequence parser ──────────────────────────────────────────────────────

package/lib/ui/status-bar.js

@@ -42,7 +42,7 @@ class FullStatusBar {
       this._streamStart = null; this._streamTokens = 0; this._speed = 0;
     }
 
-    const animStates = ['thinking', 'streaming', 'tool'];
+    const animStates = ['thinking', 'streaming', 'tool', 'waiting_download'];
     if (animStates.includes(state) && !this._animTimer) {
       this._animTimer = setInterval(() => { this._animIdx++; this._renderBar(); }, 100);
     } else if (!animStates.includes(state) && this._animTimer) {
@@ -102,7 +102,8 @@ class FullStatusBar {
     const timePart = `${String(now.getHours()).padStart(2,'0')}:${String(now.getMinutes()).padStart(2,'0')}:${String(now.getSeconds()).padStart(2,'0')}`;
     const rightParts = [timePart];
     if (this._model) rightParts.push(this._model);
-    if (this._totalTokens > 0) rightParts.push(`${this._totalTokens.toLocaleString()} tok`);
+    const liveTokens = this._totalTokens + this._streamTokens;
+    rightParts.push(`${liveTokens.toLocaleString()} tok`);
     if (state === 'streaming' && this._speed > 0) rightParts.push(`${this._speed} t/s`);
 
     const rightVisible = rightParts.join(' · ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semalt-ai/code",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Self-hosted AI Coding Assistant CLI",
   "main": "index.js",
   "bin": {