apex-dev 2.1.3 → 3.0.1

package/src/agent.js

@@ -1,58 +1,121 @@
 'use strict';
 
-const ora = require('ora');
 const {
   NVIDIA_MODEL,
   MAX_TOOL_ITERATIONS,
   nvidiaClient,
   session,
   sleep,
+  getMode,
 } = require('./config');
 const { buildSystemPrompt } = require('./prompt');
 const { toolDefs } = require('./tools');
 const { executeTool } = require('./toolExecutors');
-const {
-  t,
-  indent,
-  hr,
-  showUserMessage,
-  showAssistantHeader,
-  toolDetail,
-  showToolCall,
-  finishToolCall,
-  showDiff,
-} = require('./ui');
+const { toolDetailStr } = require('./utils');
+const store = require('./store');
 const {
   parseThinkBlocks,
   findThinkClose,
   stripStrayCloseTag,
   splitAtPartialTag,
-  showThinkingBlock,
 } = require('./thinking');
 
 // ===== State =====
 let isProcessing = false;
-let rlClosed = false;
 
 function getIsProcessing() { return isProcessing; }
-function setRlClosed(val) { rlClosed = val; }
-function getRlClosed() { return rlClosed; }
+
+// ===== Exploration Detection =====
+const EXPLORATION_KEYWORDS = [
+  'explore', 'find files', 'where is', 'search for', 'locate',
+  'what files', 'which files', 'show me all', 'list all',
+  'find code', 'search code', 'find function', 'find class',
+  'find module', 'find component', 'find endpoint', 'find route',
+  'find api', 'find service', 'find model', 'find controller',
+  'where can i find', 'how do i find', 'look for',
+  'codebase structure', 'project structure', 'directory structure'
+];
+
+function isExplorationTask(text) {
+  const lower = text.toLowerCase();
+  return EXPLORATION_KEYWORDS.some(keyword => lower.includes(keyword));
+}
+
+// ===== Complexity Detection (for MAX mode auto-thinker) =====
+const COMPLEX_TASK_KEYWORDS = [
+  'refactor', 'redesign', 'architect', 'migrate', 'overhaul',
+  'implement', 'build', 'create a system', 'design pattern',
+  'add feature', 'new feature', 'integrate', 'convert',
+  'multiple files', 'across files', 'full stack',
+  'database schema', 'api endpoint', 'authentication',
+  'complex', 'tricky', 'challenging', 'difficult',
+];
+
+function isComplexTask(text) {
+  const lower = text.toLowerCase();
+  const wordCount = text.split(/\s+/).length;
+  const keywordMatch = COMPLEX_TASK_KEYWORDS.some(kw => lower.includes(kw));
+  return keywordMatch || wordCount > 40;
+}
 
 // ===== AI Conversation — Agentic Loop =====
-async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
+async function handleUserInput(userInput) {
   isProcessing = true;
+  store.setState({ isProcessing: true });
   session.turnCount++;
-  showUserMessage(userInput);
 
+  store.addMessage({ role: 'user', content: userInput });
   session.conversationHistory.push({ role: 'user', content: userInput });
 
+  // Auto-delegate to FilePickerMax for exploration tasks
+  if (isExplorationTask(userInput)) {
+    const exploreId = store.addMessage({ role: 'system', content: 'Exploring codebase...', label: '🔍 Exploring' });
+    try {
+      const pickerResult = await executeTool('FilePickerMax', { prompt: userInput }, (partial) => {
+        store.updateMessage(exploreId, { content: partial, label: '🔍 Exploring' });
+      });
+      store.updateMessage(exploreId, { content: pickerResult, label: '🔍 Codebase Exploration Results' });
+      session.conversationHistory.push({
+        role: 'assistant',
+        content: `I've explored the codebase and found the following relevant files:\n\n${pickerResult}`,
+      });
+    } catch (err) {
+      store.updateMessage(exploreId, { content: `Exploration failed: ${err.message}` });
+    }
+  }
+
+  // MAX mode: Auto-think before complex tasks
+  const mode = getMode();
+  if (mode === 'max' && isComplexTask(userInput)) {
+    const thinkId = store.addMessage({ role: 'system', content: 'Deep thinking...', label: '🧠 Thinker' });
+    try {
+      const thinkerResult = await executeTool('Thinker', { prompt: userInput }, (partial) => {
+        store.updateMessage(thinkId, { content: partial, label: '🧠 Thinker' });
+      });
+      store.updateMessage(thinkId, { content: thinkerResult, label: '🧠 Thinker' });
+      session.conversationHistory.push({
+        role: 'assistant',
+        content: `[Thinker analysis]\n${thinkerResult}`,
+      });
+    } catch (err) {
+      store.updateMessage(thinkId, { content: `Thinker failed: ${err.message}` });
+    }
+  }
+
+  // MAX mode: Auto-prune context when history is long
+  if (mode === 'max' && session.conversationHistory.length > 20) {
+    try {
+      await executeTool('ContextPruner', {}, null);
+    } catch { /* ignore pruning failures */ }
+  }
+
   const startTime = Date.now();
   let turnTokens = 0;
   let turnToolCalls = 0;
 
   try {
-    showAssistantHeader();
-    console.log();
+    // Add assistant header message
+    store.addMessage({ role: 'divider' });
 
     const systemPrompt = buildSystemPrompt();
     let messages = [
@@ -62,18 +125,9 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
 
     let iterations = 0;
 
-    // Agentic tool-use loop
     while (iterations < MAX_TOOL_ITERATIONS) {
       iterations++;
 
-      // Show thinking spinner while waiting for first token
-      const thinkSpinner = ora({
-        text: t.dim(iterations === 1 ? 'Reasoning deeply...' : 'Thinking further...'),
-        prefixText: '    ',
-        spinner: 'dots',
-        color: 'magenta',
-      }).start();
-
       let stream;
       const maxRetries = 3;
       for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -81,7 +135,6 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
           stream = await nvidiaClient.chat.completions.create({
             model: NVIDIA_MODEL,
             messages: messages.map(m => {
-              // Strip any extra fields the API might reject
               const clean = { role: m.role, content: m.content };
               if (m.tool_calls) clean.tool_calls = m.tool_calls.map(tc => ({
                 id: tc.id, type: 'function',
@@ -101,45 +154,29 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
           break;
         } catch (apiErr) {
           if (attempt < maxRetries && apiErr.status >= 400 && apiErr.status < 500) {
-            const delay = 1000 * Math.pow(2, attempt);
-            thinkSpinner.text = t.dim(`Retrying (${attempt + 1}/${maxRetries})...`);
-            await sleep(delay);
+            await sleep(1000 * Math.pow(2, attempt));
             continue;
           }
-          thinkSpinner.stop();
           throw apiErr;
         }
       }
 
       // Accumulate streamed response
       let fullContent = '';
-      const toolCallDeltas = {};  // index -> { id, name, arguments }
+      const toolCallDeltas = {};
+      const toolCallMsgIds = {};
+      const seenToolCalls = new Set();
       let finishReason = null;
       let streamUsage = null;
-      let reasoningText = '';  // collected reasoning from reasoning_content field
+      let reasoningText = '';
 
-      // Display state:
-      //   'buffering'  — accumulating, watching for <think> or safe-to-stream point
-      //   'thinking'   — inside <think>...</think>, accumulating reasoning
-      //   'streaming'  — think block done, streaming content live to terminal
+      // Display state
       let displayState = 'buffering';
-      let contentAccum = '';   // buffer for buffering/thinking states
-      let thinkAccum = '';     // accumulates text inside <think>...</think>
-      let streamingStarted = false;
-      let thinkSpinnerStopped = false;
-
-      function stopThinkSpinner() {
-        if (!thinkSpinnerStopped) { thinkSpinner.stop(); thinkSpinnerStopped = true; }
-      }
-
-      function writeToTerminal(text) {
-        if (!text) return;
-        if (!streamingStarted) {
-          streamingStarted = true;
-          process.stdout.write('    ');
-        }
-        process.stdout.write(t.text(text));
-      }
+      let contentAccum = '';
+      let thinkAccum = '';
+      let displayContent = '';
+      let thinkContent = '';
+      let lastFlushTime = Date.now();
 
       for await (const chunk of stream) {
         if (chunk.usage) streamUsage = chunk.usage;
@@ -151,7 +188,7 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
         }
         if (chunk.choices[0].finish_reason) finishReason = chunk.choices[0].finish_reason;
 
-        // Accumulate tool call deltas
+        // Tool call deltas
         if (delta.tool_calls) {
           for (const tc of delta.tool_calls) {
             const idx = tc.index;
@@ -159,14 +196,27 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
               toolCallDeltas[idx] = { id: tc.id || '', name: tc.function?.name || '', arguments: '' };
             }
             if (tc.id) toolCallDeltas[idx].id = tc.id;
-            if (tc.function?.name) toolCallDeltas[idx].name = tc.function.name;
-            if (tc.function?.arguments) toolCallDeltas[idx].arguments += tc.function.arguments;
+            if (tc.function?.name) {
+              toolCallDeltas[idx].name = tc.function.name;
+              if (!seenToolCalls.has(idx)) {
+                seenToolCalls.add(idx);
+                toolCallMsgIds[idx] = store.addMessage({
+                  role: 'tool',
+                  name: tc.function.name,
+                  detail: '...',
+                  status: 'pending',
+                });
+              }
+            }
+            if (tc.function?.arguments) {
+              toolCallDeltas[idx].arguments += tc.function.arguments;
+            }
           }
         }
 
-        // Handle reasoning_content field (some APIs send reasoning separately)
         if (delta.reasoning_content) {
           reasoningText += delta.reasoning_content;
+          store.updateStreaming(displayContent, reasoningText);
         }
 
         // Handle content tokens
@@ -175,129 +225,127 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
           const hasTool = Object.keys(toolCallDeltas).length > 0;
 
           if (displayState === 'streaming') {
-            // Live-stream, but watch for a new <think> block
             contentAccum += delta.content;
-            // Strip any stray closing tags
             contentAccum = stripStrayCloseTag(contentAccum);
-            // Find and handle any <think> in the accumulated buffer
             const openIdx = contentAccum.indexOf('<think>');
             if (openIdx !== -1) {
-              // Write everything before <think>
-              if (openIdx > 0) writeToTerminal(contentAccum.slice(0, openIdx));
+              if (openIdx > 0) displayContent += contentAccum.slice(0, openIdx);
               thinkAccum = contentAccum.slice(openIdx + 7);
               contentAccum = '';
               displayState = 'thinking';
-              // Check if closing tag already in this buffer
               const closeMatch = findThinkClose(thinkAccum);
               if (closeMatch) {
                 const thought = thinkAccum.slice(0, closeMatch.pos).trim();
                 const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
                 thinkAccum = '';
-                if (thought) showThinkingBlock([thought]);
+                if (thought) store.addMessage({ role: 'thinking', content: thought });
                 displayState = 'streaming';
                 contentAccum = after;
-                if (!hasTool) writeToTerminal(after);
+                if (!hasTool && after) displayContent += after;
                 contentAccum = '';
+                thinkContent = '';
+              } else {
+                thinkContent = thinkAccum;
               }
             } else {
-              // No <think> — stream it, but hold back possible partial tag at end
               const { safe, pending } = splitAtPartialTag(contentAccum);
               contentAccum = pending;
-              if (!hasTool && safe) writeToTerminal(safe);
+              if (!hasTool && safe) displayContent += safe;
             }
+            store.updateStreaming(displayContent, thinkContent || reasoningText);
 
           } else if (displayState === 'thinking') {
-            // Accumulate inside think block
             thinkAccum += delta.content;
             const closeMatch = findThinkClose(thinkAccum);
             if (closeMatch) {
               const thought = thinkAccum.slice(0, closeMatch.pos).trim();
               const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
               thinkAccum = '';
-              stopThinkSpinner();
-              if (thought) showThinkingBlock([thought]);
+              if (thought) store.addMessage({ role: 'thinking', content: thought });
               displayState = 'streaming';
               contentAccum = after;
-              if (!hasTool && after) writeToTerminal(after);
+              if (!hasTool && after) displayContent += after;
               contentAccum = '';
+              thinkContent = '';
+              store.updateStreaming(displayContent, reasoningText);
+            } else {
+              thinkContent = thinkAccum;
+              store.updateStreaming(displayContent, thinkContent || reasoningText);
             }
 
           } else {
-            // 'buffering' — accumulate until we know what's coming
+            // buffering
             contentAccum += delta.content;
-            // Strip stray closing tags
             contentAccum = stripStrayCloseTag(contentAccum);
             const openIdx = contentAccum.indexOf('<think>');
             if (openIdx !== -1) {
-              // Text before <think>: stream it if non-empty
               const before = contentAccum.slice(0, openIdx);
               thinkAccum = contentAccum.slice(openIdx + 7);
               contentAccum = '';
-              if (!hasTool && before.trim()) writeToTerminal(before);
+              if (!hasTool && before.trim()) displayContent += before;
               displayState = 'thinking';
-              // Check if closing tag already present
               const closeMatch = findThinkClose(thinkAccum);
               if (closeMatch) {
                 const thought = thinkAccum.slice(0, closeMatch.pos).trim();
                 const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
                 thinkAccum = '';
-                stopThinkSpinner();
-                if (thought) showThinkingBlock([thought]);
+                if (thought) store.addMessage({ role: 'thinking', content: thought });
                 displayState = 'streaming';
                 contentAccum = after;
-                if (!hasTool && after) writeToTerminal(after);
+                if (!hasTool && after) displayContent += after;
                 contentAccum = '';
+                thinkContent = '';
+              } else {
+                thinkContent = thinkAccum;
+              }
+              store.updateStreaming(displayContent, thinkContent || reasoningText);
+            } else {
+              const { safe, pending } = splitAtPartialTag(contentAccum);
+              if (safe.length > 0) {
+                displayState = 'streaming';
+                if (!hasTool) displayContent += safe;
+                contentAccum = pending;
+                store.updateStreaming(displayContent, reasoningText);
               }
-            } else if (!contentAccum.includes('<') && contentAccum.length > 20) {
-              // No think tag coming — start streaming immediately
-              stopThinkSpinner();
-              displayState = 'streaming';
-              if (!hasTool) writeToTerminal(contentAccum);
-              contentAccum = '';
             }
-            // else keep buffering (might be start of <think>)
           }
         }
-      }
 
-      // Stream ended — flush any remaining buffers
-      stopThinkSpinner();
+        // Yield to the event loop periodically so the terminal renderer can paint
+        const now = Date.now();
+        if (now - lastFlushTime > 16) {
+          lastFlushTime = now;
+          await new Promise(r => setTimeout(r, 1));
+        }
+      }
 
+      // Stream ended — flush remaining buffers
       if (displayState === 'thinking') {
-        // Unclosed <think> block — show what we accumulated
         const thought = (thinkAccum + contentAccum).trim();
-        if (thought) showThinkingBlock([thought]);
+        if (thought) store.addMessage({ role: 'thinking', content: thought });
         thinkAccum = '';
         contentAccum = '';
-        displayState = 'streaming';
       } else if (displayState === 'buffering') {
-        // Never left buffering — flush as plain content
         const hasTool = Object.keys(toolCallDeltas).length > 0;
-        if (!hasTool && contentAccum.trim()) writeToTerminal(contentAccum);
+        if (!hasTool && contentAccum.trim()) displayContent += contentAccum;
         contentAccum = '';
       } else if (contentAccum) {
-        // Flush any pending partial-tag buffer
         const hasTool = Object.keys(toolCallDeltas).length > 0;
-        if (!hasTool) writeToTerminal(contentAccum);
+        if (!hasTool) displayContent += contentAccum;
         contentAccum = '';
       }
 
-      // Show reasoning from reasoning_content field if not already shown via tags
-      if (reasoningText.trim() && displayState !== 'thinking') {
-        showThinkingBlock([reasoningText.trim()]);
-      }
-
-      if (streamingStarted) {
-        process.stdout.write('\n\n');
+      // Show reasoning from reasoning_content field
+      if (reasoningText.trim()) {
+        store.addMessage({ role: 'thinking', content: reasoningText.trim() });
       }
 
-      // Final parsed content for history/display (tags stripped)
-      const { content: displayContent } = parseThinkBlocks(fullContent);
-
+      const { content: parsedContent } = parseThinkBlocks(fullContent);
       turnTokens += streamUsage?.total_tokens || 0;
 
-      // Reconstruct the full message object
-      const toolCalls = Object.keys(toolCallDeltas).sort((a, b) => a - b).map(idx => ({
+      // Reconstruct tool calls
+      const sortedIndices = Object.keys(toolCallDeltas).sort((a, b) => a - b);
+      const toolCalls = sortedIndices.map(idx => ({
         id: toolCallDeltas[idx].id,
         type: 'function',
         function: { name: toolCallDeltas[idx].name, arguments: toolCallDeltas[idx].arguments },
@@ -311,49 +359,54 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
 
       // If the model wants to call tools
       if (toolCalls.length > 0) {
+        store.clearStreaming();
         messages.push(msg);
 
-        // Show intermediate reasoning that wasn't streamed (e.g. with tool calls)
-        if (displayContent && displayContent.trim()) {
-          console.log(indent(t.dim.italic(displayContent.trim()), 6));
-          console.log();
+        // Show intermediate text if any
+        if (displayContent.trim()) {
+          store.addMessage({ role: 'assistant', content: displayContent.trim() });
         }
 
-        // Execute tool calls (parallel for independent calls)
-        const toolPromises = toolCalls.map(async (toolCall) => {
-          const toolName = toolCall.function.name;
+        // Update tool messages with full args and execute
+        sortedIndices.forEach((idx, i) => {
+          const tc = toolCalls[i];
           let toolArgs;
-          try {
-            toolArgs = JSON.parse(toolCall.function.arguments);
-          } catch {
-            toolArgs = {};
-          }
+          try { toolArgs = JSON.parse(tc.function.arguments); } catch { toolArgs = {}; }
+          const detail = toolDetailStr(tc.function.name, toolArgs);
+          const msgId = toolCallMsgIds[idx];
+          if (msgId) store.updateMessage(msgId, { detail, status: 'running' });
+        });
 
-          const detail = toolDetail(toolName, toolArgs);
+        const toolPromises = toolCalls.map(async (toolCall, i) => {
+          const toolName = toolCall.function.name;
+          let toolArgs;
+          try { toolArgs = JSON.parse(toolCall.function.arguments); } catch { toolArgs = {}; }
+          const detail = toolDetailStr(toolName, toolArgs);
           const callStart = Date.now();
-          const spinner = await showToolCall(toolName, detail, callStart);
+          const msgId = toolCallMsgIds[sortedIndices[i]];
 
-          // Execute
-          const result = await executeTool(toolName, toolArgs);
+          const result = await executeTool(toolName, toolArgs, (partial) => {
+            if (msgId) store.updateMessage(msgId, { output: partial });
+          });
           const success = !result.startsWith('Error');
+          const elapsed = Date.now() - callStart;
 
-          finishToolCall(spinner, toolName, detail, callStart, success);
           session.toolCallCount++;
           turnToolCalls++;
 
-          // Show result preview
-          const resultLines = result.split('\n');
-          let preview;
-          if (toolName === 'Edit' || toolName === 'Patch') {
-            // Show diff
-            showDiff(toolArgs.path, result);
-          } else if (resultLines.length > 5) {
-            preview = resultLines.slice(0, 4).join('\n') + `\n... (${resultLines.length} lines)`;
-            console.log(indent(t.dim(preview), 8));
-            console.log();
-          } else if (result.trim() && result !== '(no output)') {
-            console.log(indent(t.dim(result.length > 300 ? result.slice(0, 297) + '...' : result), 8));
-            console.log();
+          if (msgId) {
+            store.updateMessage(msgId, {
+              detail,
+              status: success ? 'done' : 'error',
+              success,
+              elapsed,
+              output: result,
+            });
+          }
+
+          // Show diff for edit operations
+          if ((toolName === 'Edit' || toolName === 'Patch') && success) {
+            store.addMessage({ role: 'diff', filename: toolArgs.path, content: result });
           }
 
           return { id: toolCall.id, result };
@@ -362,60 +415,90 @@ async function handleUserInput(userInput, { setupInputLoop, askQuestion }) {
         const toolResults = await Promise.all(toolPromises);
 
         for (const { id, result } of toolResults) {
-          messages.push({
-            role: 'tool',
-            tool_call_id: id,
-            content: result,
-          });
+          messages.push({ role: 'tool', tool_call_id: id, content: result });
         }
 
-        // Check for stop condition
         if (finishReason === 'stop') break;
+        displayContent = '';
         continue;
       }
 
-      // No tool calls — final text response (already displayed above)
+      // No tool calls — final text response
       if (fullContent) {
-        const cleanedContent = displayContent.trim() || fullContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        const cleanedContent = parsedContent.trim() || fullContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        if (cleanedContent) {
+          store.finishStreaming({ role: 'assistant', content: cleanedContent });
+        } else {
+          store.clearStreaming();
+        }
         session.conversationHistory.push({ role: 'assistant', content: cleanedContent || fullContent });
+      } else {
+        store.clearStreaming();
       }
       break;
     }
 
     if (iterations >= MAX_TOOL_ITERATIONS) {
-      console.log(indent(t.yellow(`⚠ Reached maximum tool iterations (${MAX_TOOL_ITERATIONS}). Stopping.`)));
-      console.log();
+      store.addMessage({ role: 'system', content: `⚠ Reached maximum tool iterations (${MAX_TOOL_ITERATIONS}). Stopping.` });
     }
 
     session.totalTokens += turnTokens;
+
+    // Auto-delegate to CodeReview for code changes
+    if (session.filesModified.size > 0) {
+      const reviewPrompt = `User request: ${userInput}\n\n${turnTokens > 0 ? `Processed with ${turnTokens} tokens and ${turnToolCalls} tool calls.` : ''}`;
+
+      if (mode === 'max') {
+        // MAX mode: Multi-perspective code review
+        const reviewId = store.addMessage({ role: 'system', content: 'Multi-perspective code review...', label: '📋 Code Review (MAX)' });
+        try {
+          const reviewResult = await executeTool('CodeReviewMulti', { prompt: reviewPrompt }, (partial) => {
+            store.updateMessage(reviewId, { content: partial, label: '📋 Code Review (MAX)' });
+          });
+          store.updateMessage(reviewId, { content: reviewResult, label: '📋 Code Review (MAX)' });
+          session.conversationHistory.push({
+            role: 'assistant',
+            content: `\n\n--- Multi-Perspective Code Review ---\n${reviewResult}`,
+          });
+        } catch (err) {
+          store.updateMessage(reviewId, { content: `Multi-review failed: ${err.message}` });
+        }
+      } else if (mode !== 'lite') {
+        // Default mode: Single code review
+        const reviewId = store.addMessage({ role: 'system', content: 'Reviewing code changes...', label: '📋 Code Review' });
+        try {
+          const reviewResult = await executeTool('CodeReview', { prompt: reviewPrompt }, (partial) => {
+            store.updateMessage(reviewId, { content: partial, label: '📋 Code Review' });
+          });
+          store.updateMessage(reviewId, { content: reviewResult, label: '📋 Code Review' });
+          session.conversationHistory.push({
+            role: 'assistant',
+            content: `\n\n--- Code Review ---\n${reviewResult}`,
+          });
+        } catch (err) {
+          store.updateMessage(reviewId, { content: `Code review failed: ${err.message}` });
+        }
+      }
+      // Lite mode: skip code review entirely
+    }
   } catch (err) {
-    console.log();
-    console.log(indent(t.red('✗ Error: ') + t.text(err.message)));
+    store.clearStreaming();
+    let errorMsg = `Error: ${err.message}`;
     if (err.status) {
-      console.log(indent(t.dim(`Status: ${err.status}`) + (err.error ? t.dim(` | Detail: ${JSON.stringify(err.error).slice(0, 200)}`) : '')));
+      errorMsg += `\nStatus: ${err.status}`;
     }
     if (!process.env.NVIDIA_API_KEY) {
-      console.log(indent(t.yellow('Set the NVIDIA_API_KEY environment variable with your API key from build.nvidia.com')));
+      errorMsg += '\nSet the NVIDIA_API_KEY environment variable with your API key from build.nvidia.com';
     }
-    console.log();
+    store.addMessage({ role: 'system', content: errorMsg });
   }
 
-  console.log(indent(hr()));
+  store.addMessage({ role: 'divider' });
   isProcessing = false;
-  if (rlClosed) {
-    // Readline closed during processing — re-create it if stdin is still usable
-    if (!process.stdin.destroyed && process.stdin.readable) {
-      setupInputLoop();
-      askQuestion();
-      return;
-    }
-    process.exit(0);
-  }
+  store.setState({ isProcessing: false });
 }
 
 module.exports = {
   handleUserInput,
   getIsProcessing,
-  setRlClosed,
-  getRlClosed,
 };