@oxecli/oxe 1.0.97 → 1.0.99

package/dist/cli.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 import { loadOrPrompt, default_reasoning_effort, max_action_chars, max_resume_history_items, runtimeOsSummary, max_context_tokens, context_overhead_margin, } from "./config.js";
 import { InferenceEngine, estimateTokens } from "./engine.js";
 import { saveSession, loadSession, listSessions, nextSessionId, conversationLabel, COMMAND_HELP, stripOrphanCalls, toolOutputFailed, } from "./sessions.js";
-import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, toolCallLabel, formatToolResult, truncateEllipsis, stripAnsi, plainLen, truncateStyled, terminalWidth, TOOL_RESULT_MAX_LINES, MAX_COMMAND_DISPLAY_CHARS, renderPanel, renderTableString, enableRawStdin, disableRawStdin, waitRawKey, dockAppendContent, dockSetInactive, dockTearDown, startDraftCapture, } from "./ui.js";
+import { clearScreen, enableAnsi, askBottomPrompt, userDisplayText, aiMarkdown, mutedMarkdown, messageText, toolCallLabel, formatToolResult, truncateEllipsis, stripAnsi, plainLen, truncateStyled, terminalWidth, TOOL_RESULT_MAX_LINES, MAX_COMMAND_DISPLAY_CHARS, renderPanel, renderTableString, renderWarning, enableRawStdin, disableRawStdin, waitRawKey, dockAppendContent, dockSetInactive, dockTearDown, dockRenderPrompt, startDraftCapture, } from "./ui.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const packageInfo = require("../package.json");
@@ -20,6 +20,13 @@ export class CLI {
     promptHistory = [];
     lastPrompt = "";
     interruptPending = false;
+    /**
+     * When a prompt is submitted during an in-flight query (Enter while the AI is
+     * responding), we interrupt the query silently and queue the submitted prompt
+     * here so the next loop iteration processes it directly without showing the
+     * "Interrupted agent" alert.
+     */
+    autoSubmit = null;
     constructor() {
         clearScreen();
         this.renderHeader();
@@ -241,7 +248,7 @@ export class CLI {
                 process.stdout.write(mutedMarkdown(text) + "\n");
             }
             else if (typ === "warning") {
-                process.stdout.write(`\x1b[33m${text}\x1b[0m\n`);
+                renderWarning(text);
             }
             else if (typ === "error") {
                 process.stdout.write(`\x1b[31m${text}\x1b[0m\n`);
@@ -404,14 +411,33 @@ export class CLI {
                 const pct = Math.max(0, Math.min(100, Math.round(((budget - used) / budget) * 100)));
                 // Queries run the proven settle-on-Enter flow: the prompt settles and
                 // the query streams above it (robust dock streaming). While the query
-                // runs, typed keys are captured into a draft; the draft (or the sent
-                // prompt) is restored into the next prompt box so input is never lost.
-                const [input, spans] = await askBottomPrompt("You", "❯", this.promptHistory, {
+                // runs, the prompt box stays live-editable: typed keys are rendered
+                // into the box, and Enter submits a new prompt that interrupts the
+                // running response (no "Interrupted agent" alert) and is processed
+                // immediately. A plain (non-submitted) draft is restored into the next
+                // prompt box so input is never lost.
+                const hints = {
                     left: "\x1b[90mPress \x1b[1;36mCtrl+C\x1b[0m\x1b[90m to interrupt\x1b[0m",
                     right: `\x1b[1;36m${pct}%\x1b[0m \x1b[90muntil auto-compact\x1b[0m`,
-                }, this.lastPrompt);
-                if (!input.trim())
-                    continue;
+                };
+                let input;
+                let spans;
+                if (this.autoSubmit) {
+                    // A prompt was submitted while the previous response was running. It
+                    // has already interrupted that response; process it directly, first
+                    // clearing the prompt box as a normal send would.
+                    input = this.autoSubmit.input;
+                    spans = this.autoSubmit.spans;
+                    this.autoSubmit = null;
+                    dockRenderPrompt("", [], "You", "❯", hints);
+                }
+                else {
+                    const got = await askBottomPrompt("You", "❯", this.promptHistory, hints, this.lastPrompt);
+                    input = got[0];
+                    spans = got[1];
+                    if (!input.trim())
+                        continue;
+                }
                 this.interruptPending = false;
                 this.promptHistory.push(input);
                 const lower = input.trim().toLowerCase();
@@ -463,18 +489,25 @@ export class CLI {
                     continue;
                 }
                 dockAppendContent(`\x1b[1;36m❯\x1b[0m ${userDisplayText(input, spans)}\n`);
-                // Empty the prompt field as soon as the prompt is sent. Only a draft
-                // typed while the query runs is restored into the next box.
+                // Empty the prompt field as soon as the prompt is sent. A draft typed
+                // while the query runs is rendered into the box and restored into the
+                // next one; Enter submits it as a new prompt.
                 this.lastPrompt = "";
                 queryStarted = true;
-                const stopCapture = startDraftCapture(() => engine.interrupt());
+                const stopCapture = startDraftCapture(() => engine.interrupt(), (buf, sp) => dockRenderPrompt(buf, sp, "You", "❯", hints));
                 try {
                     await engine.executeQuery(input, this.inputItems, this.story, spans);
                 }
                 finally {
                     const captured = stopCapture();
-                    if (captured.trim())
-                        this.lastPrompt = captured;
+                    if (captured.submitted && captured.draft.trim()) {
+                        // The user pressed Enter during the response: interrupt it and queue
+                        // the new prompt so the next loop iteration sends it (silently).
+                        this.autoSubmit = { input: captured.draft, spans: [] };
+                    }
+                    else if (captured.draft.trim()) {
+                        this.lastPrompt = captured.draft;
+                    }
                     queryStarted = false;
                 }
                 this.saveSession(engine);
@@ -488,6 +521,24 @@ export class CLI {
                 }
                 if (err?.message === "interrupt") {
                     const wasActive = queryStarted || engine.inQuery;
+                    // A prompt submitted during the response was queued in `autoSubmit`
+                    // (by the finally above). Interrupt silently — no "Interrupted agent"
+                    // alert — and let the next iteration process the new prompt (the loop
+                    // top consumes `autoSubmit`).
+                    if (this.autoSubmit && this.autoSubmit.input.trim()) {
+                        engine.inQuery = false;
+                        stripOrphanCalls(this.inputItems);
+                        if (this.inputItems.length &&
+                            this.inputItems[this.inputItems.length - 1]["role"] === "user") {
+                            this.inputItems.pop();
+                        }
+                        if (this.story.length &&
+                            this.story[this.story.length - 1]["type"] === "user") {
+                            this.story.pop();
+                        }
+                        this.interruptPending = false;
+                        continue;
+                    }
                     if (wasActive && !engine.queryHasOutput && !engine.queryCalledTool) {
                         dockAppendContent(aiMarkdown("What else can I help you with?") + "\n");
                     }

package/dist/config.js

@@ -28,6 +28,9 @@ export const context_overhead_margin = 32_000;
 export const compact_keep_recent_turns = 4;
 export const max_summary_source_chars = 200_000;
 export const max_output_tokens = 16384;
+/** Cap on how many times a single turn may be continued past the output-token
+ *  cap before we give up extending it (prevents runaway generation). */
+export const max_output_continuations = 6;
 export const max_empty_retries = 2;
 export const max_diff_source_chars = 1_000_000;
 export const max_grep_file_bytes = 20 * 1024 * 1024;

package/dist/engine.js

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
-import { max_output_tokens, max_empty_retries, max_agent_steps, max_context_tokens, context_overhead_margin, compact_keep_recent_turns, max_summary_source_chars, max_read_file_stored_chars, } from "./config.js";
+import { max_output_tokens, max_empty_retries, max_output_continuations, max_agent_steps, max_context_tokens, context_overhead_margin, compact_keep_recent_turns, max_summary_source_chars, max_read_file_stored_chars, } from "./config.js";
 import { getSystemPrompt } from "./system.js";
 import { buildTools, truncateToolOutput, toolReadFile, toolWriteFile, toolEditFile, toolBash, toolGlob, toolGrep, toolLoadSkill, } from "./tools.js";
-import { mutedMarkdown, aiMarkdown, tickDuration, safeCommitPoint, printAiChunk, toolCallLabel, formatToolResult, renderPanel, Spinner, hideCursor, dockAppendContent, dockReplaceTransient, dockTransientStart, } from "./ui.js";
+import { mutedMarkdown, aiMarkdown, tickDuration, safeCommitPoint, printAiChunk, toolCallLabel, formatToolResult, renderPanel, renderWarning, Spinner, hideCursor, dockAppendContent, dockReplaceTransient, dockTransientStart, } from "./ui.js";
 import { reportUsage } from "./api.js";
 import { stripOrphanCalls, persistCompactionSummary, toolOutputFailed, } from "./sessions.js";
 import { takePendingDiffOutput } from "./tools.js";
@@ -315,10 +315,13 @@ export class InferenceEngine {
         const text = response?.output_text ?? content;
         if (text.trim())
             story.push({ type: "assistant", text });
-        let incompleteReason = null;
+        // The incomplete reason must always be captured — not only in the empty
+        // case — so a response truncated by the output-token cap is never mistaken
+        // for a complete answer. `emptyMessage` is only relevant when nothing at
+        // all (text or tool call) was produced.
+        const incompleteReason = this.incompleteReason(response);
         let emptyMessage = null;
         if (!text.trim() && calls.length === 0) {
-            incompleteReason = this.incompleteReason(response);
             emptyMessage = this.diagnoseEmptyResponse(response, sawReasoning);
         }
         return {
@@ -428,6 +431,7 @@ export class InferenceEngine {
         let conversation = [...inputItems];
         [conversation] = await this.compactIfNeeded(conversation, inputItems, story);
         let emptyRetries = 0;
+        let outputContinuations = 0;
         const retryPrompts = [];
         const stats = {
             thinking: 0,
@@ -524,6 +528,20 @@ export class InferenceEngine {
                     prevId = null;
                     pending = conversation;
                 }
+                // A response cut off by the output-token cap is NOT a final answer —
+                // treating it as one is what returned force-truncated replies. Instead,
+                // continue generating from the previous response via `previous_response_id`
+                // until the response completes naturally. Bounded to prevent runaway
+                // output. Each continuation's output items are already committed above,
+                // so the full (concatenated) response is preserved in the transcript.
+                if (!compactedNow &&
+                    incompleteReason === "max_output_tokens" &&
+                    outputContinuations < max_output_continuations) {
+                    outputContinuations++;
+                    prevId = respId;
+                    pending = [];
+                    continue;
+                }
                 if (emptyMessage !== null) {
                     if (incompleteReason === "max_output_tokens" &&
                         emptyRetries < max_empty_retries) {
@@ -617,12 +635,10 @@ export class InferenceEngine {
             // The preceding tool action already leaves the cursor on a blank row, so
             // no extra newline is needed above; renderPanel ends with its own "\n",
             // and the prompt adds one leading "\n" -> exactly one blank row below.
-            const maxIterationMsg = "⚠ Max tool-call iterations reached for this turn. The work so far is " +
+            const maxIterationMsg = "Max tool-call iterations reached for this turn. The work so far is " +
                 "saved. If you want the agent to keep going, type continue and the next " +
                 "step will resume from where it left off.";
-            renderPanel("[bold yellow]⚠ Max tool-call iterations reached for this turn.[/bold yellow]\n" +
-                "[yellow]The work so far is saved. If you want the agent to keep going, type " +
-                "[bold]continue[/bold] and the next step will resume from where it left off.[/yellow]", "Warning", "", false, "33");
+            renderWarning(maxIterationMsg);
             story.push({ type: "warning", text: maxIterationMsg });
             if (retryPrompts.length)
                 dropRetryPrompts(conversation, inputItems, retryPrompts);

package/dist/ui.js

@@ -39,14 +39,18 @@ export function waitRawKey() {
     });
 }
 /**
- * Capture typed input while a query runs (the prompt box is torn down during
- * streaming). Keystrokes are accumulated into a draft that the next prompt box
- * is pre-filled with, so nothing the user types while the AI is busy is lost.
- * Returns a stop() function returning the captured draft (may be empty).
+ * Capture typed input while a query runs (the prompt box is docked during
+ * streaming). Keystrokes are accumulated into a draft AND rendered into the
+ * docked prompt box via `renderBox`, so the user sees their input live while
+ * the AI is busy. Enter submits the draft: it interrupts the running query
+ * (as if Ctrl+C) and flags `submitted`, so the caller can send the new prompt.
+ * Returns a stop() function returning `{ draft, submitted }`.
  */
-export function startDraftCapture(onInterrupt) {
+export function startDraftCapture(onInterrupt, renderBox) {
     let draft = "";
+    let pasteSpans = [];
     let active = true;
+    let submitted = false;
     const onKey = (str, key) => {
         if (!active)
             return;
@@ -56,14 +60,24 @@ export function startDraftCapture(onInterrupt) {
         }
         if (key && key.ctrl && (key.name === "d" || key.name === "z"))
             return;
+        if (isEnterKey(str, key)) {
+            if (draft.trim()) {
+                submitted = true;
+                active = false;
+                onInterrupt();
+            }
+            return;
+        }
+        if (key && (key.name === "enter" || key.name === "linefeed"))
+            return;
         if (key && key.name === "backspace") {
             draft = draft.slice(0, -1);
+            renderBox?.(draft, pasteSpans);
             return;
         }
-        if (key && (key.name === "return" || key.name === "enter"))
-            return;
         if (str && !key?.ctrl && !key?.meta) {
             draft += str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+            renderBox?.(draft, pasteSpans);
         }
     };
     readline.emitKeypressEvents(process.stdin);
@@ -81,7 +95,7 @@ export function startDraftCapture(onInterrupt) {
             /* ignore */
         }
         process.stdin.pause();
-        return draft;
+        return { draft, submitted };
     };
 }
 // ---------------------------------------------------------------------------
@@ -465,6 +479,25 @@ function panelString(content, title = "", subtitle = "", expand = true, borderSt
 export function renderPanel(content, title = "", subtitle = "", expand = true, borderStyle = "90", titleAlign = "center") {
     dockAppendContent(panelString(content, title, subtitle, expand, borderStyle, titleAlign) + "\n");
 }
+/** Warning sign with the text-presentation variation selector, so it renders
+ *  as a monochrome icon (matching the app's ✓/✗ symbols) rather than a color
+ *  emoji that varies by platform. */
+export const WARNING_ICON = "\u26A0\uFE0E";
+/**
+ * Render a warning as a framed panel (consistent shape whether shown live or
+ * replayed from a resumed session), using the text-presentation warning icon
+ * instead of an emoji. The first sentence is emphasized; the rest is plain.
+ */
+export function renderWarning(message) {
+    const text = String(message ?? "").replace(/^[\s\u26A0\uFE0E]+/, "").trim();
+    const idx = text.indexOf(". ");
+    const head = idx === -1 ? text : text.slice(0, idx + 1);
+    const body = idx === -1 ? "" : text.slice(idx + 2).trim();
+    let content = `[bold yellow]${WARNING_ICON} ${head}[/bold yellow]`;
+    if (body)
+        content += `\n[yellow]${body}[/yellow]`;
+    renderPanel(content, "Warning", "", false, "33");
+}
 // ---------------------------------------------------------------------------
 // Table Panel Rendering
 // ---------------------------------------------------------------------------
@@ -568,6 +601,13 @@ let dockBoxRows = 0;
 let dockGap = false;
 let dockTransient = false;
 let dockFrameLines = [];
+/**
+ * How many rows the caret sits BELOW boxTop when the prompt box is being
+ * live-edited during a query (0 = cursor parked at boxTop / transient, the
+ * normal dock invariant). dockEraseBox must know this to erase the box from
+ * the caret's position instead of assuming the cursor is at boxTop.
+ */
+let dockCaretBelow = 0;
 export function dockIsDocked() {
     return docked;
 }
@@ -585,12 +625,14 @@ export function dockSetInactive() {
     dockGap = false;
     dockTransient = false;
     dockFrameLines = [];
+    dockCaretBelow = 0;
 }
 export function dockEnterDocked() {
     docked = true;
     dockRel = 0;
     dockGap = false;
     dockTransient = false;
+    dockCaretBelow = 0;
 }
 /** Erase the docked box and leave the cursor at boxTop with the gap above it,
  *  so a pager/replay can write there and a later prompt re-docks cleanly. */
@@ -639,12 +681,18 @@ export function dockTransientStart(mode = "blank") {
     dockTransient = true;
 }
 /** Erase the box and any transient rows above it, leaving the cursor at boxTop
- *  with the gap row intact above. */
+ *  with the gap row intact above. Handles the cursor being parked at boxTop,
+ *  above it (transient), or inside it at the live-edit caret. */
 function dockEraseBox() {
     if (!docked || dockBoxRows < 1)
         return;
     const rel = dockRel;
-    process.stdout.write(`\x1b[${dockBoxRows - 1 + rel}B`);
+    const caret = dockCaretBelow;
+    // Move from the cursor to the box's bottom row, then erase the box upward.
+    //   cursor at boxTop - rel (transient): go down (dockBoxRows - 1 + rel)
+    //   cursor at boxTop + caret (live caret): go down (dockBoxRows - 1 - caret)
+    const down = caret > 0 ? dockBoxRows - 1 - caret : dockBoxRows - 1 + rel;
+    process.stdout.write(`\x1b[${down}B`);
     for (let i = 0; i < dockBoxRows; i++) {
         process.stdout.write("\r\x1b[K");
         if (i < dockBoxRows - 1)
@@ -657,6 +705,7 @@ function dockEraseBox() {
     }
     docked = false;
     dockRel = 0;
+    dockCaretBelow = 0;
     dockGap = true;
     dockTransient = false;
 }
@@ -674,6 +723,7 @@ function dockEraseBoxKeep() {
     process.stdout.write(`\x1b[${dockRel}A`);
     docked = false;
     dockRel = 0;
+    dockCaretBelow = 0;
     dockGap = true;
     dockTransient = false;
 }
@@ -685,10 +735,31 @@ function dockRenderBox() {
     process.stdout.write("\n\n" + dockFrameLines.join("\n"));
     process.stdout.write(`\x1b[${dockBoxRows - 1}A\r`);
     dockRel = 0;
+    dockCaretBelow = 0;
     docked = true;
     dockGap = false;
     dockTransient = false;
 }
+/**
+ * Redraw the docked prompt box with the given buffer/caret, keeping whatever
+ * content already streams above it. Used to make the prompt field live-edit
+ * while a query runs. Erases the box (and any transient row above it),
+ * writes the new frame, and parks the cursor at the caret. Preserves exactly
+ * one blank row between the last content and the box.
+ */
+export function dockRenderPrompt(buffer, pasteSpans, prefix, label, hints) {
+    if (!docked || dockBoxRows < 1)
+        return;
+    const { frame, cursorRow, cursorCol, totalRows } = renderBufferWithCursor(buffer, pasteSpans, prefix, label, buffer.length, hints);
+    dockEraseBox();
+    process.stdout.write(frame);
+    // Park the cursor at the caret inside the box (cursorRow is 1-indexed, so
+    // the caret sits cursorRow rows below boxTop).
+    process.stdout.write(`\x1b[${totalRows - 1 - cursorRow}A\r\x1b[${cursorCol}C`);
+    dockSetFrame(frame, totalRows);
+    dockEnterDocked();
+    dockCaretBelow = cursorRow;
+}
 /** Commit content at the box top, pushing the box down, preserving exactly one
  *  blank row between the content and the box. */
 export function dockAppendContent(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxecli/oxe",
-  "version": "1.0.97",
+  "version": "1.0.99",
   "publishConfig": {
     "access": "public"
   },