@semalt-ai/code 1.8.3 → 1.8.5

package/lib/api.js

@@ -6,6 +6,65 @@ const { URL } = require('url');
 
 const { buildToolsSchema, isUIActive } = require('./tools');
 const { TOOL_SPECS } = require('./tool_specs');
+const writer = require('./ui/writer');
+const messages = require('./ui/messages');
+const dbg = require('./debug');
+
+// Strict precondition for any payload that includes role:tool messages or
+// assistant.tool_calls: every tool_call_id must reference a non-empty id from
+// a prior assistant tool_calls entry. Catches the upstream "tool result's tool
+// id() not found" 400 before it leaves the client and points at the exact
+// violating message instead of a cryptic provider error.
+function validateToolCallInvariant(msgs) {
+  const calledIds = new Set();
+  for (let idx = 0; idx < msgs.length; idx++) {
+    const m = msgs[idx];
+    if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+      for (let j = 0; j < m.tool_calls.length; j++) {
+        const tc = m.tool_calls[j];
+        if (!tc || !tc.id) {
+          throw new Error(
+            `Invalid tool_calls invariant: messages[${idx}] role=assistant tool_calls[${j}] has empty id`
+          );
+        }
+        calledIds.add(tc.id);
+      }
+    }
+  }
+  for (let idx = 0; idx < msgs.length; idx++) {
+    const m = msgs[idx];
+    if (m.role !== 'tool') continue;
+    if (!m.tool_call_id) {
+      const preview = String(m.content || '').slice(0, 80).replace(/\s+/g, ' ');
+      throw new Error(
+        `Invalid tool_calls invariant: messages[${idx}] role=tool has empty tool_call_id (content_preview="${preview}")`
+      );
+    }
+    if (!calledIds.has(m.tool_call_id)) {
+      throw new Error(
+        `Invalid tool_calls invariant: messages[${idx}] role=tool tool_call_id=${m.tool_call_id} has no matching prior assistant tool_calls`
+      );
+    }
+  }
+}
+
+function debugDumpMessages(msgs) {
+  dbg.logExtended('[messages dump before API request]');
+  for (let i = 0; i < msgs.length; i++) {
+    const m = msgs[i];
+    const callIds = Array.isArray(m.tool_calls)
+      ? m.tool_calls.map((t) => (t && t.id) || '<EMPTY>').join(',')
+      : '';
+    const toolCallId = m.tool_call_id !== undefined
+      ? ` tool_call_id=${m.tool_call_id || '<EMPTY>'}`
+      : '';
+    const tcs = callIds ? ` tool_calls=[${callIds}]` : '';
+    const contentLen = (m.content !== undefined && m.content !== null)
+      ? ` content_chars=${(m.content + '').length}`
+      : '';
+    dbg.logExtended(`  [${i}] role=${m.role}${toolCallId}${tcs}${contentLen}`);
+  }
+}
 
 function createApiClient({ getConfig, saveConfig, ui }) {
   const {
@@ -17,7 +76,6 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     FG_RED,
     FG_TEAL,
     RST,
-    StatusBar,
     StreamRenderer,
   } = ui;
 
@@ -358,6 +416,8 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     const endpoint = apiUrl('/v1/chat/completions');
 
     async function doRequest(msgs) {
+      if (dbg.isFile()) debugDumpMessages(msgs);
+      validateToolCallInvariant(msgs);
       const reqPayload = { ...payload, messages: msgs };
       const reqBody = JSON.stringify(reqPayload);
       const res = await httpRequest(endpoint, {
@@ -472,10 +532,10 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       const toolCallAcc = [];
       const renderer = new StreamRenderer({ firstLinePrefix: linePrefix, showThink });
       if (!silent) {
+        // audit: allowed — non-TUI streaming setup, must interleave with StreamRenderer sync writes.
         process.stdout.write('\n');
         renderer._linesWritten = 1;
       }
-      let firstContentToken = true;
       let lineBuffer = '';
 
       function escapeXml(s) {
@@ -515,16 +575,13 @@ function createApiClient({ getConfig, saveConfig, ui }) {
             type: 'function',
             function: { name: t.name, arguments: t.arguments || '{}' },
           }));
+        dbg.logExtended(
+          `[tool_call finalize] acc_len=${toolCallAcc.length} ` +
+          `valid=${validToolCalls.length} nativeTools=${nativeTools} ` +
+          `acc=${JSON.stringify(toolCallAcc).slice(0, 400)}`
+        );
         if (!nativeTools) appendToolCallsXml();
         if (!silent) renderer.flush();
-        const elapsed = (Date.now() - startTime) / 1000;
-        const tps = tokenCount / (elapsed || 1);
-        if (StatusBar.current) {
-          let latency = `${Math.round(tps)} tok/s · ${elapsed.toFixed(1)}s`;
-          if (reasoningText) latency += ` · ${estimateTokens(reasoningText)} think`;
-          StatusBar.current.liveUpdate({ tokens: `${tokenCount} tok`, latency });
-          StatusBar.current.render();
-        }
         // 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;
@@ -571,6 +628,10 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       res.setEncoding('utf8');
 
       res.on('data', (chunk) => {
+        if (dbg.isFile()) {
+          const raw = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+          dbg.logExtended(`[SSE raw] ${raw.slice(0, 500).replace(/\n/g, '\\n')}`);
+        }
         lineBuffer += chunk;
         const lines = lineBuffer.split('\n');
         lineBuffer = lines.pop();
@@ -579,11 +640,14 @@ function createApiClient({ getConfig, saveConfig, ui }) {
           if (!line.startsWith('data: ')) continue;
           const data = line.slice(6).trim();
           if (data === '[DONE]') {
+            dbg.logExtended(`[SSE event] [DONE]`);
             finalize();
             res.destroy();
             return;
           }
 
+          dbg.logExtended(`[SSE event] ${data.slice(0, 500)}`);
+
           try {
             const obj = JSON.parse(data);
             if (obj.usage && (obj.usage.prompt_tokens !== undefined || obj.usage.completion_tokens !== undefined)) {
@@ -613,6 +677,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               if (!inReasoning) {
                 inReasoning = true;
                 if (showThink && !uiActive) {
+                  // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                   process.stdout.write(`\n  ${FG_DARK}${DIM}⟨thinking⟩${RST}`);
                   renderer._linesWritten++;
                 }
@@ -620,27 +685,36 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               reasoningText += reasoning;
               tokenCount++;
               if (showThink && !uiActive) {
+                // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                 process.stdout.write(`${FG_DARK}${DIM}${reasoning}${RST}`);
               }
             }
 
+            // Standard OpenAI tool_call streaming: the announcement chunk
+            // carries id + type + function.name with arguments="", and one or
+            // more follow-up chunks stream arguments deltas (no id/name).
+            // Process every chunk that has delta.tool_calls and patch in
+            // whichever fields are present — never gate slot creation or
+            // field updates on arguments being non-empty, or the announcement
+            // (which carries the only id/name) gets dropped.
             const toolCallsDelta = delta.tool_calls;
             if (Array.isArray(toolCallsDelta)) {
               for (const tc of toolCallsDelta) {
+                if (!tc || typeof tc !== 'object') continue;
                 const idx = typeof tc.index === 'number' ? tc.index : toolCallAcc.length;
-                const isNew = !toolCallAcc[idx];
-                if (isNew) toolCallAcc[idx] = { id: '', name: '', arguments: '' };
-                if (tc.id) toolCallAcc[idx].id = tc.id;
-                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}`);
+                if (!toolCallAcc[idx]) {
+                  toolCallAcc[idx] = { id: '', name: '', arguments: '' };
                 }
+                const slot = toolCallAcc[idx];
+                if (tc.id) slot.id = tc.id;
+                const fnName = tc.function && tc.function.name;
+                if (typeof fnName === 'string' && fnName) slot.name = fnName;
+                const fnArgs = tc.function && tc.function.arguments;
+                if (typeof fnArgs === 'string') slot.arguments += fnArgs;
+                dbg.logExtended(
+                  `[tool_call acc] idx=${idx} id=${slot.id || '<empty>'} ` +
+                  `name=${slot.name || '<empty>'} args_len=${slot.arguments.length}`
+                );
               }
             }
 
@@ -649,30 +723,22 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               if (inReasoning) {
                 inReasoning = false;
                 if (showThink && !silent) {
+                  // audit: allowed — non-TUI thinking output, interleaves with StreamRenderer sync writes.
                   process.stdout.write(`${FG_DARK}⟨/thinking⟩${RST}\n`);
                   renderer._linesWritten++;
                 }
               }
               if (onToken) {
-                if (firstContentToken) {
-                  firstContentToken = false;
-                  if (StatusBar.current) StatusBar.current.update({ status: 'streaming' });
-                }
                 onToken(content);
               } else {
                 renderer.feed(content);
               }
               fullText += content;
               tokenCount++;
-              if (tokenCount % 20 === 0 && StatusBar.current) {
-                const elapsedSec = (Date.now() - startTime) / 1000 || 0.001;
-                StatusBar.current.liveUpdate({
-                  tokens: `${tokenCount} tok`,
-                  latency: `${Math.round(tokenCount / elapsedSec)} tok/s`,
-                });
-              }
             }
-          } catch {}
+          } catch (err) {
+            dbg.logExtended(`[SSE parse-error] ${err.message} :: ${data.slice(0, 200)}`);
+          }
         }
       });
 
@@ -712,7 +778,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         },
       }, body);
     } catch (error) {
-      console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+      messages.netError(error.message);
       return '';
     }
 
@@ -724,7 +790,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       });
       res.on('end', () => {
         if (res.statusCode !== 200) {
-          console.log(`  ${FG_RED}✗ Error: HTTP ${res.statusCode} — ${data}${RST}`);
+          messages.netError(`HTTP ${res.statusCode} — ${data}`);
           resolve('');
           return;
         }
@@ -732,15 +798,15 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         try {
           const parsed = JSON.parse(data);
           const content = parsed.choices[0].message.content;
-          console.log(content);
+          writer.scrollback(content);
           resolve(content);
         } catch (error) {
-          console.log(`  ${FG_RED}✗ Parse error: ${error.message}${RST}`);
+          messages.netError(`Parse error: ${error.message}`);
           resolve('');
         }
       });
       res.on('error', (error) => {
-        console.log(`  ${FG_RED}✗ ${error.message}${RST}`);
+        messages.netError(error.message);
         resolve('');
       });
     });

package/lib/args.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const debug = require('./debug');
+
 function parseArgs(argv) {
   const opts = {};
   const positional = [];
@@ -62,6 +64,15 @@ function parseArgs(argv) {
       case '--debug':
         opts.debug = true;
         break;
+      case '--debug-file': {
+        const v = argv[++i];
+        if (!v || v.startsWith('-')) {
+          process.stderr.write(`Error: --debug-file requires a path argument.\n`);
+          process.exit(1);
+        }
+        opts.debugFile = v;
+        break;
+      }
       case '--system-prompt':
         opts.systemPromptFile = argv[++i];
         break;
@@ -71,6 +82,17 @@ function parseArgs(argv) {
     i++;
   }
 
+  if (opts.debug && opts.debugFile) {
+    process.stderr.write(
+      `Error: --debug and --debug-file are mutually exclusive.\n` +
+      `       Use --debug for inline debug output, or --debug-file <path>\n` +
+      `       for extended debug traces written to a file.\n`
+    );
+    process.exit(1);
+  }
+
+  debug.init({ debug: opts.debug, debugFile: opts.debugFile });
+
   return { opts, positional };
 }