@semalt-ai/code 1.8.1 → 1.8.3

package/lib/api.js

@@ -4,6 +4,9 @@ const http = require('http');
 const https = require('https');
 const { URL } = require('url');
 
+const { buildToolsSchema, isUIActive } = require('./tools');
+const { TOOL_SPECS } = require('./tool_specs');
+
 function createApiClient({ getConfig, saveConfig, ui }) {
   const {
     BOLD,
@@ -55,9 +58,10 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     return Math.floor((text || '').length / 4);
   }
 
-  // Discovered context limit for this process lifetime.
-  // Set on the first context-overflow 400; used to proactively trim all subsequent calls.
-  let _sessionInputLimit = null;
+  // Discovered context limit per model for this process lifetime.
+  // Keyed by resolved model name; set on the first context-overflow 400
+  // for that model and used to proactively trim subsequent calls.
+  const _sessionInputLimits = new Map();
 
   function httpRequest(urlStr, options, body) {
     return new Promise((resolve, reject) => {
@@ -71,7 +75,10 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         headers: options.headers || {},
       };
 
-      const req = lib.request(reqOpts, (res) => resolve(res));
+      const req = lib.request(reqOpts, (res) => {
+        if (options.onResponse) options.onResponse(res);
+        resolve(res);
+      });
       req.on('error', reject);
 
       if (options.timeout) {
@@ -80,6 +87,18 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         });
       }
 
+      if (options.signal) {
+        if (options.signal.aborted) {
+          req.destroy(new Error('Aborted'));
+          return reject(new Error('Aborted'));
+        }
+        options.signal.addEventListener('abort', () => {
+          req.destroy(new Error('Aborted'));
+        });
+      }
+
+      if (options.onRequest) options.onRequest(req);
+
       if (body) req.write(body);
       req.end();
     });
@@ -224,17 +243,32 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     });
   }
 
-  async function chatStream(messages, { model, temperature, maxTokens, linePrefix = '', showThink = false, onToken = null, silent = false } = {}) {
+  async function chatStream(messages, { model, temperature, maxTokens, linePrefix = '', showThink = false, onToken = null, silent = false, signal = null, onTrim = null, nativeTools = true } = {}) {
+    // nativeTools is plumbed through for downstream use (tools param + tool_calls parsing); no behavior change yet.
     const config = getConfig();
+    const resolvedModel = model || config.default_model;
+
+    if (signal && signal.aborted) throw new Error('Aborted');
+
+    let trimNotified = false;
+    function notifyTrim(info) {
+      if (trimNotified) return;
+      trimNotified = true;
+      if (typeof onTrim === 'function') {
+        try { onTrim(info); } catch {}
+      }
+    }
 
     // Fit messages into tokenBudget tokens.
-    // Uses chars/3 — conservative for token-dense content (code, JSON, HTML).
+    // Uses chars/4 — aligned with estimateTokens; a deliberate under-estimate
+    // for token-dense content (code, JSON, HTML) but consistent across the
+    // codebase.
     //
     // Always keeps: system prompt + first non-system message (original task).
     // Drops intermediate messages oldest-first, then truncates the last tail
     // message (typically a large tool result) if still over budget.
     function trimToTokenBudget(msgs, tokenBudget) {
-      const CHARS_PER_TOKEN = 3;
+      const CHARS_PER_TOKEN = 4;
       const system = msgs.filter((m) => m.role === 'system');
       const nonSystem = msgs.filter((m) => m.role !== 'system');
       if (nonSystem.length === 0) return [...system];
@@ -271,28 +305,62 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       return tail.length > 0 ? [...system, pinned, ...tail] : [...system, pinned];
     }
 
-    // Proactive trim: apply the session input limit discovered from a prior 400.
+    // Proactive trim: prefer a limit learned from a prior 400 overflow; otherwise
+    // fall back to config.context_length (with a ~10% safety margin) as a hint.
+    // The fallback is not written to _sessionInputLimits so a real overflow
+    // always overrides the config hint.
     let trimmedMessages = messages;
-    if (_sessionInputLimit !== null) {
-      if (Math.floor(JSON.stringify(messages).length / 3) > _sessionInputLimit) {
-        trimmedMessages = trimToTokenBudget(messages, _sessionInputLimit);
+    let sessionLimit = _sessionInputLimits.get(resolvedModel);
+    if (sessionLimit == null &&
+        Number.isInteger(config.context_length) && config.context_length > 0) {
+      sessionLimit = Math.floor(config.context_length * 0.9);
+    }
+    if (sessionLimit != null) {
+      if (Math.floor(JSON.stringify(messages).length / 4) > sessionLimit) {
+        trimmedMessages = trimToTokenBudget(messages, sessionLimit);
+        const dropped = messages.length - trimmedMessages.length;
+        const keptTokens = Math.floor(JSON.stringify(trimmedMessages).length / 4);
+        notifyTrim({ reason: 'proactive', dropped, keptTokens, limit: sessionLimit });
       }
     }
 
+    // MiniMax supports `reasoning_split: true` which moves thinking content
+    // into a separate reasoning_details field on the response (and
+    // delta.reasoning_content during streaming) instead of embedding
+    // <think>...</think> inside message.content. Only send this flag to
+    // MiniMax — other providers may reject unknown fields.
+    const isMiniMax =
+      /api\.minimax\.io/i.test(config.api_base || '') ||
+      /^minimax[-\/]/i.test(resolvedModel || '');
+
     const payload = {
-      model: model || config.default_model,
+      model: resolvedModel,
       messages: trimmedMessages,
       temperature: temperature !== undefined ? temperature : config.temperature,
       stream: true,
       stream_options: { include_usage: true },
     };
 
+    if (isMiniMax) payload.reasoning_split = true;
     if (maxTokens !== undefined) payload.max_tokens = maxTokens;
 
+    // Native function-calling: advertise the tool schema and let the model
+    // emit structured tool_calls. Wrappers are XML envelopes, not callable
+    // tools — filter them out per the TOOL_SPECS contract.
+    if (nativeTools) {
+      const callable = Object.fromEntries(
+        Object.entries(TOOL_SPECS).filter(([, spec]) => !spec.wrapper)
+      );
+      payload.tools = buildToolsSchema(callable);
+      payload.tool_choice = 'auto';
+    }
+
+    const endpoint = apiUrl('/v1/chat/completions');
+
     async function doRequest(msgs) {
       const reqPayload = { ...payload, messages: msgs };
       const reqBody = JSON.stringify(reqPayload);
-      const res = await httpRequest(apiUrl('/v1/chat/completions'), {
+      const res = await httpRequest(endpoint, {
         method: 'POST',
         timeout: config.request_timeout_ms,
         headers: {
@@ -300,6 +368,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
           'Authorization': `Bearer ${config.api_key}`,
           'Content-Length': Buffer.byteLength(reqBody),
         },
+        signal,
       }, reqBody);
 
       if (res.statusCode !== 200) {
@@ -322,6 +391,7 @@ function createApiClient({ getConfig, saveConfig, ui }) {
         err.detail = detail;
         err.rawBody = errBody;
         err.responseHeaders = res.headers;
+        err.endpoint = endpoint;
         throw err;
       }
       return res;
@@ -330,7 +400,8 @@ function createApiClient({ getConfig, saveConfig, ui }) {
     // On payload-too-large errors, trim and retry.
     //   400 with context-overflow detail → parse exact context window, budget = window/2
     //   413 Request Entity Too Large (Nginx/proxy)  → no size hint, halve current estimate
-    // In both cases _sessionInputLimit is set so all subsequent calls are proactively trimmed.
+    // In both cases the per-model session input limit is set so all subsequent
+    // calls for this model are proactively trimmed.
     let res;
     try {
       res = await doRequest(trimmedMessages);
@@ -345,15 +416,41 @@ function createApiClient({ getConfig, saveConfig, ui }) {
           const limitMatch = err.detail.match(/context length is only (\d+)/i) ||
                              err.detail.match(/maximum.*?(\d+)\s*token/i);
           const contextWindow = limitMatch ? parseInt(limitMatch[1], 10) : null;
-          budget = contextWindow
-            ? Math.floor(contextWindow / 2)
-            : Math.floor(Math.floor(JSON.stringify(trimmedMessages).length / 3) * 0.5);
+          if (contextWindow) {
+            budget = Math.floor(contextWindow * 0.9);
+            // Persist the learned context window so future turns/runs trim
+            // proactively without needing a second 400. Must not block the
+            // retry if the write fails.
+            try {
+              const currentConfig = getConfig();
+              const next = { ...currentConfig, context_length: contextWindow };
+              if (Array.isArray(currentConfig.models)) {
+                next.models = currentConfig.models.map((m) =>
+                  m && m.api_base === currentConfig.api_base && m.model === resolvedModel
+                    ? { ...m, context_length: contextWindow }
+                    : m
+                );
+              }
+              saveConfig(next);
+            } catch {}
+          } else {
+            budget = Math.floor(Math.floor(JSON.stringify(trimmedMessages).length / 4) * 0.5);
+          }
         } else {
           // 413: no token info available — halve the estimated size of the current payload.
-          budget = Math.floor(Math.floor(JSON.stringify(trimmedMessages).length / 3) * 0.5);
+          budget = Math.floor(Math.floor(JSON.stringify(trimmedMessages).length / 4) * 0.5);
         }
-        _sessionInputLimit = budget;
+        _sessionInputLimits.set(resolvedModel, budget);
+        const before = trimmedMessages;
         trimmedMessages = trimToTokenBudget(trimmedMessages, budget);
+        const dropped = before.length - trimmedMessages.length;
+        const keptTokens = Math.floor(JSON.stringify(trimmedMessages).length / 4);
+        notifyTrim({
+          reason: is413 ? 'overflow-413' : 'overflow-400',
+          dropped,
+          keptTokens,
+          limit: budget,
+        });
         res = await doRequest(trimmedMessages);
       } else {
         throw err;
@@ -364,9 +461,11 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       const startTime = Date.now();
       let fullText = '';
       let reasoningText = '';
+      let reasoningDetailsText = '';
       let tokenCount = 0;
       let inReasoning = false;
       let streamUsage = null;
+      let streamFinishReason = null;
       let resolved = false;
       // delta.tool_calls accumulator (OpenAI function-calling streaming format).
       // Keyed by `index` per the OpenAI spec.
@@ -407,7 +506,16 @@ function createApiClient({ getConfig, saveConfig, ui }) {
       function finalize() {
         if (resolved) return;
         resolved = true;
-        appendToolCallsXml();
+        // Native mode: surface tool calls as structured data; skip XML serialization.
+        // Legacy mode: serialize into <minimax:tool_call> XML so extractToolCalls picks them up.
+        const validToolCalls = toolCallAcc
+          .filter((t) => t && t.name)
+          .map((t, i) => ({
+            id: t.id || `call_${i}`,
+            type: 'function',
+            function: { name: t.name, arguments: t.arguments || '{}' },
+          }));
+        if (!nativeTools) appendToolCallsXml();
         if (!silent) renderer.flush();
         const elapsed = (Date.now() - startTime) / 1000;
         const tps = tokenCount / (elapsed || 1);
@@ -426,7 +534,38 @@ function createApiClient({ getConfig, saveConfig, ui }) {
             completion_tokens: estimateTokens(fullText) + estimateTokens(reasoningText),
           };
         }
-        resolve({ content: fullText, usage });
+        const elapsedMs = Date.now() - startTime;
+        resolve({
+          content: fullText,
+          toolCalls: nativeTools ? validToolCalls : [],
+          usage,
+          usage_from_provider: !!streamUsage,
+          tool_calls_count: validToolCalls.length,
+          finish_reason: streamFinishReason,
+          finishReason: streamFinishReason,
+          elapsed_ms: elapsedMs,
+          reasoning: reasoningText,
+          reasoning_details: reasoningDetailsText,
+          endpoint,
+          request: {
+            model: payload.model,
+            temperature: payload.temperature,
+            max_tokens: payload.max_tokens,
+            stream: payload.stream,
+            stop: payload.stop,
+            native_tools: nativeTools,
+          },
+        });
+      }
+
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          try { res?.destroy(); } catch {}
+          if (!resolved) {
+            resolved = true;
+            reject(new Error('Aborted'));
+          }
+        });
       }
 
       res.setEncoding('utf8');
@@ -450,20 +589,37 @@ function createApiClient({ getConfig, saveConfig, ui }) {
             if (obj.usage && (obj.usage.prompt_tokens !== undefined || obj.usage.completion_tokens !== undefined)) {
               streamUsage = obj.usage;
             }
-            const delta = ((obj.choices || [])[0] || {}).delta || {};
+            const choice = (obj.choices || [])[0] || {};
+            if (choice.finish_reason) streamFinishReason = choice.finish_reason;
+            const delta = choice.delta || {};
+
+            // MiniMax `reasoning_split: true` surfaces a structured
+            // reasoning_details field. It may arrive as a streaming delta
+            // (delta.reasoning_details) or as an authoritative final value
+            // on choice.message. Preserve it for debug output; not routed to
+            // the UI and not fed back into messages[] on subsequent turns.
+            const rdDelta = delta.reasoning_details;
+            if (rdDelta !== undefined && rdDelta !== null) {
+              reasoningDetailsText += typeof rdDelta === 'string' ? rdDelta : JSON.stringify(rdDelta);
+            }
+            const rdFinal = choice.message && choice.message.reasoning_details;
+            if (rdFinal !== undefined && rdFinal !== null) {
+              reasoningDetailsText = typeof rdFinal === 'string' ? rdFinal : JSON.stringify(rdFinal);
+            }
 
             const reasoning = delta.reasoning_content || '';
             if (reasoning) {
+              const uiActive = isUIActive();
               if (!inReasoning) {
                 inReasoning = true;
-                if (showThink) {
+                if (showThink && !uiActive) {
                   process.stdout.write(`\n  ${FG_DARK}${DIM}⟨thinking⟩${RST}`);
                   renderer._linesWritten++;
                 }
               }
               reasoningText += reasoning;
               tokenCount++;
-              if (showThink) {
+              if (showThink && !uiActive) {
                 process.stdout.write(`${FG_DARK}${DIM}${reasoning}${RST}`);
               }
             }
@@ -473,7 +629,8 @@ function createApiClient({ getConfig, saveConfig, ui }) {
               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 (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

package/lib/commands.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 
 const { CONFIG_PATH, DEFAULT_API_TIMEOUT_MS, TAG_REGISTRY } = require('./constants');
 const { configShow } = require('./config');
-const { SYSTEM_PROMPT } = require('./prompts');
+const { getSystemPrompt } = require('./prompts');
 const { SessionStorage } = require('./storage');
 const { getSkippedOps, setUIActive } = require('./tools');
 const { AUDIT_LOG } = require('./audit');
@@ -96,6 +96,7 @@ function createCommands({
       (m) => m.model === model || (m.api_base === config.api_base && m.model === config.default_model)
     );
     if (match && Number.isInteger(match.context_length) && match.context_length > 0) return match.context_length;
+    if (Number.isInteger(config.context_length) && config.context_length > 0) return config.context_length;
     return null;
   }
 
@@ -128,11 +129,21 @@ function createCommands({
 
     setUIActive(true);
 
+    const writer = require('./ui/writer');
     permissionManager.setUICallbacks({
       onAddMessage:      (msg)     => chatHistory.addMessage(msg),
       onRerenderMessage: (id)      => chatHistory.rerenderById(id),
       onCollapseMessage: (id)      => chatHistory.collapseById(id),
       onRemoveMessage:   (id)      => chatHistory.removeById(id),
+      // Modal-region API: setModal replaces the modal live band above the
+      // status region; clearModal drops it. Arrow-key redraws go through
+      // setModal only — no scrollback churn. When the picker resolves we
+      // clear the modal and push a single summary line to scrollback.
+      onShowModal: (lines) => writer.setModal(lines),
+      onCloseModal: (summary) => {
+        writer.clearModal();
+        if (summary) chatHistory.addMessage({ role: 'system', content: summary });
+      },
       onCaptureNavigation: (handler) => {
         inputField.captureNavigation(handler);
         return () => inputField.releaseNavigation();
@@ -187,14 +198,13 @@ function createCommands({
     }
     refreshInputSearchItems();
 
-    // Banner — write at row 1, then compact the layout so the fixed panels sit
-    // immediately below the banner with no blank gap.  The layout grows as
-    // messages are added (dynamic layout mode) until it reaches full-screen.
+    // Banner — emit once as scrollback above the live region. In the
+    // bottom-anchored live-region TUI, scrollback flows into terminal
+    // scrollback naturally, so no absolute positioning or scroll-region
+    // trickery is needed here.
     if (layout) {
-      const BANNER_LINES = 8; // blank + top-border + empty + title + desc + empty + bottom-border + blank
       const w = Math.min(getCols() - 4, 60);
-      process.stdout.write('\x1b[1;1H');
-      process.stdout.write([
+      const banner = [
         ``,
         `  ${FG_DARK}╭${'─'.repeat(w + 1)}╮${RST}`,
         boxLine('', w),
@@ -203,19 +213,8 @@ function createCommands({
         boxLine('', w),
         `  ${FG_DARK}╰${'─'.repeat(w + 1)}╯${RST}`,
         ``,
-      ].join('\n') + '\n');
-
-      // Keep historyStart = 1 so the banner is inside the scroll region.
-      // Growing mode uses _contentLines to position the first message below the
-      // banner (at row BANNER_LINES + 1).  When the terminal fills up the banner
-      // scrolls naturally into the terminal scrollback — nothing disappears behind
-      // a fixed header.
-      layout._contentLines = BANNER_LINES;
-      layout.rows = BANNER_LINES + 1 + layout.inputHeight + 3;
-
-      // Erase the stale full-screen panels createUI drew before we compacted.
-      process.stdout.write(`\x1b[${layout.rows + 1};1H\x1b[J`);
-
+      ].join('\n');
+      writer.scrollback(banner);
       redrawFixed();
     }
 
@@ -256,24 +255,29 @@ function createCommands({
       try { await dashboardSaveMessages(currentChatId, newMessages); savedUpTo = messages.length; } catch {}
     }
 
-    const HISTORY_DISPLAY_TURNS = 3; // user+assistant pairs to show on load
-
     function displayLoadedMessages(loadedMessages) {
       chatHistory.clearMessages();
-      const visible = loadedMessages.filter(
-        (m) => (m.role === 'user' || m.role === 'assistant') &&
-               (typeof m.content === 'string' ? m.content : '').trim()
-      );
-      const skip = Math.max(0, visible.length - HISTORY_DISPLAY_TURNS * 2);
-      if (skip > 0) {
-        chatHistory.addMessage({ role: 'system', content: `… ${skip} earlier messages not shown` });
-      }
-      for (const m of visible.slice(skip)) {
-        chatHistory.addMessage({
-          role: m.role,
-          content: typeof m.content === 'string' ? m.content : '',
-          ts: m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date()),
-        });
+      for (const m of loadedMessages) {
+        if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') continue;
+        const raw = typeof m.content === 'string' ? m.content : '';
+        const ts = m.created_at ? new Date(m.created_at) : (m.ts ? new Date(m.ts) : new Date());
+
+        if (m.role === 'tool') {
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: raw, ts });
+          continue;
+        }
+
+        if (m.role === 'user' && raw.startsWith('Tool execution results:')) {
+          const body = raw
+            .replace(/^Tool execution results[^\n]*\n+/, '')
+            .replace(/\n+Continue with the task\.[\s\S]*$/, '')
+            .trim();
+          chatHistory.addMessage({ role: 'tool', tag: 'tool', content: 'tool result', output: body || raw, ts });
+          continue;
+        }
+
+        if (!raw.trim()) continue;
+        chatHistory.addMessage({ role: m.role, content: raw, ts });
       }
     }
 
@@ -301,28 +305,6 @@ function createCommands({
     const PAGE_SIZE = 5;
     let listMsg = null;
 
-    // In-place progress indicator for chunked HTTP fetches (http_get + http_get_next)
-    let httpFetchMsg = null;
-
-    function showHttpFetchProgress(url, part, total) {
-      const maxUrl = Math.max(20, getCols() - 35);
-      const shortUrl = url.length > maxUrl ? url.slice(0, maxUrl - 1) + '…' : url;
-      const content = `Fetching URL  ·  ${shortUrl}  ·  Part ${part}/${total}`;
-      if (!httpFetchMsg) {
-        httpFetchMsg = { role: 'tool', tag: 'http_get', content, id: `http-fetch-${Date.now()}` };
-        chatHistory.addMessage(httpFetchMsg);
-      } else {
-        httpFetchMsg.content = content;
-        chatHistory.rerenderById(httpFetchMsg.id);
-      }
-    }
-
-    function finalizeHttpFetch() {
-      if (!httpFetchMsg) return;
-      chatHistory.removeById(httpFetchMsg.id);
-      httpFetchMsg = null;
-    }
-
     function getNavSearchText(type, item) {
       if (type === 'history') {
         const date = new Date(item.created_at).toISOString().slice(0, 16);
@@ -740,7 +722,7 @@ function createCommands({
       }
 
       if (text === '/prompt') {
-        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : SYSTEM_PROMPT;
+        const activePrompt = resolvedSystemPrompt !== null ? resolvedSystemPrompt : getSystemPrompt();
         const src = resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
         const mode = getConfig().system_prompt_mode || 'system_role';
         chatHistory.addMessage({
@@ -847,7 +829,7 @@ function createCommands({
           if (entry?.type === 'tool') {
             const actionLabel = entry.label || tag;
             const detail = attrs.path || attrs.url || attrs.key || attrs.src || '';
-            const isDownload = tag === 'download' || tag === 'http_get' || tag === 'http_get_next';
+            const isDownload = tag === 'download' || tag === 'http_get';
             const barState = isDownload ? 'waiting_download' : 'tool';
             const label = isDownload
               ? `Waiting for download${detail ? ': ' + detail : ''}`
@@ -866,7 +848,7 @@ function createCommands({
         onToolStart: (tag, input, attrs) => {
           const actionLabel = TAG_REGISTRY[tag]?.label || tag;
           const short = input.length > 40 ? input.slice(0, 40) + '…' : input;
-          const isDownload = tag === 'download' || tag === 'http_get' || tag === 'http_get_next';
+          const isDownload = tag === 'download' || tag === 'http_get';
           if (isDownload) {
             statusBar.update('waiting_download', `Waiting for download: ${short}`);
           } else {
@@ -876,7 +858,6 @@ function createCommands({
         onToolEnd: (tag, result, durationMs) => {
           const isError = typeof result === 'string' && result.startsWith('Error');
           if (isError) {
-            finalizeHttpFetch();
             chatHistory.addMessage({
               role: 'tool',
               tag,
@@ -884,24 +865,6 @@ function createCommands({
               output: typeof result === 'string' && result.trim() ? result : null,
             });
             statusBar.update('streaming', 'Streaming response');
-          } else if (tag === 'http_get') {
-            const chunkedMatch = typeof result === 'string' && result.match(/^HTTP GET (.+?) \(\d+\) \[Part 1\/(\d+)\]/);
-            if (chunkedMatch) {
-              showHttpFetchProgress(chunkedMatch[1], 1, parseInt(chunkedMatch[2], 10));
-            } else {
-              finalizeHttpFetch();
-              statusBar.update('tool', `✓ ${TAG_REGISTRY[tag]?.label || tag} [${durationMs}ms]`);
-            }
-          } else if (tag === 'http_get_next') {
-            const partMatch = typeof result === 'string' && result.match(/^HTTP content "(.+?)" \[Part (\d+)\/(\d+)\]/);
-            if (partMatch) {
-              const part = parseInt(partMatch[2], 10);
-              const total = parseInt(partMatch[3], 10);
-              showHttpFetchProgress(partMatch[1], part, total);
-              if (part === total) finalizeHttpFetch();
-            } else {
-              finalizeHttpFetch();
-            }
           } else {
             const actionLabel = TAG_REGISTRY[tag]?.label || tag;
             statusBar.update('tool', `✓ ${actionLabel} [${durationMs}ms]`);
@@ -937,6 +900,11 @@ function createCommands({
         onRetry: (attempt, max) => {
           statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
         },
+        onDebug: (block) => {
+          // Render in-history as a tool-style bubble so ctrl+O expand works and
+          // the RAW RESPONSE text survives TUI redraws (stderr would be clobbered).
+          chatHistory.addMessage({ role: 'tool', tag: 'debug', content: 'DEBUG', output: block });
+        },
         onError: (err) => {
           if (err && err.isWarning) {
             chatHistory.addMessage({ role: 'system', content: err.message || String(err) });
@@ -957,6 +925,15 @@ function createCommands({
       };
       inputField.on('abort', _onAbort);
 
+      // Refresh in case a prior turn's 400 overflow persisted a learned
+      // context_length to config after this chat started.
+      if (resolvedTokenLimit == null) {
+        const cfg = getConfig();
+        if (Number.isInteger(cfg.context_length) && cfg.context_length > 0) {
+          resolvedTokenLimit = cfg.context_length;
+        }
+      }
+
       try {
         const agentResult = await runAgentLoop(messages, currentModel, undefined, resolvedTokenLimit, {
           showThink: opts.showThink || false,

package/lib/config.js

@@ -2,9 +2,30 @@
 
 const fs = require('fs');
 const path = require('path');
+const { URL } = require('url');
 
 const { CONFIG_PATH, DEFAULT_CONFIG } = require('./constants');
 
+let _apiKeyAnyWarned = false;
+const _LOCAL_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]', '::1']);
+
+function _maybeWarnApiKeyAny(cfg) {
+  if (_apiKeyAnyWarned) return;
+  if (cfg.api_key !== 'any') return;
+  let host = '';
+  try {
+    host = new URL(cfg.api_base).hostname;
+  } catch {
+    return;
+  }
+  if (_LOCAL_HOSTS.has(host)) return;
+  _apiKeyAnyWarned = true;
+  process.stderr.write(
+    "⚠ api_key='any' against non-local endpoint — requests will likely fail " +
+    "with 401. Run 'semalt-code config set api_key <key>' to set a real key.\n"
+  );
+}
+
 function normalizeConfig(cfg = {}) {
   const merged = { ...DEFAULT_CONFIG, ...cfg };
   // Ensure every DEFAULT_CONFIG key is present without overwriting existing values
@@ -33,6 +54,7 @@ function normalizeConfig(cfg = {}) {
   merged.dashboard_model_id = Number.isInteger(cfg.dashboard_model_id) && cfg.dashboard_model_id > 0
     ? cfg.dashboard_model_id
     : null;
+  merged.repair_malformed_tool_xml = cfg.repair_malformed_tool_xml === true;
   merged.models = Array.isArray(cfg.models)
     ? cfg.models
         .filter((entry) => entry &&
@@ -53,6 +75,9 @@ function normalizeConfig(cfg = {}) {
           if (Number.isInteger(entry.context_length) && entry.context_length > 0) {
             normalized.context_length = entry.context_length;
           }
+          // native_tools defaults to true; only explicit false/0/"false"/"0" opts out.
+          const nt = entry.native_tools;
+          normalized.native_tools = !(nt === false || nt === 0 || nt === '0' || nt === 'false');
           return normalized;
         })
     : [];
@@ -61,13 +86,16 @@ function normalizeConfig(cfg = {}) {
 
 function loadConfig() {
   fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  let cfg;
   if (fs.existsSync(CONFIG_PATH)) {
     try {
       const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-      return normalizeConfig(data);
+      cfg = normalizeConfig(data);
     } catch {}
   }
-  return normalizeConfig();
+  if (!cfg) cfg = normalizeConfig();
+  _maybeWarnApiKeyAny(cfg);
+  return cfg;
 }
 
 function saveConfig(cfg) {
@@ -94,8 +122,8 @@ function configShow(systemPromptOverride = null) {
   if (systemPromptOverride) {
     lines.push(`  system_prompt: [override from ${systemPromptOverride}]`);
   } else {
-    const { SYSTEM_PROMPT } = require('./prompts');
-    lines.push(`  system_prompt: ${SYSTEM_PROMPT.slice(0, 80)}...`);
+    const { getSystemPrompt } = require('./prompts');
+    lines.push(`  system_prompt: ${getSystemPrompt().slice(0, 80)}...`);
   }
   return lines.join('\n');
 }