tide-commander 1.149.0 → 1.150.0

package/dist/src/packages/server/codex/json-event-parser.js

@@ -156,6 +156,15 @@ export class CodexJsonEventParser {
     enableFileDiffEnrichment;
     workingDirectory;
     gitRootCache = new Map();
+    /**
+     * Progressive agent_message text per item.id (for item.updated / delta streams).
+     * Current `codex exec --json` only emits agent_message on item.completed, but
+     * app-server / newer CLIs can stream via item.updated or agentMessage deltas.
+     */
+    streamedAgentTextByItemId = new Map();
+    openAgentTextUuids = new Set();
+    streamedThinkingByItemId = new Map();
+    openThinkingUuids = new Set();
     constructor(options = {}) {
         this.enableFileDiffEnrichment = options.enableFileDiffEnrichment === true;
         this.workingDirectory = options.workingDirectory || process.cwd();
@@ -190,6 +199,9 @@ export class CodexJsonEventParser {
         if (event.type === 'item.started') {
             return this.parseItemStarted(event.item);
         }
+        if (event.type === 'item.updated') {
+            return this.parseItemUpdated(event.item);
+        }
         if (event.type === 'item.completed') {
             // Capture agent message text for later use in step_complete
             if (event.item?.type === 'agent_message' && event.item?.text) {
@@ -197,6 +209,12 @@ export class CodexJsonEventParser {
             }
             return this.parseItemCompleted(event.item);
         }
+        // App-server style notification (when present on exec stream): streaming text delta.
+        if (event.type === 'item/agentMessage/delta' ||
+            event.type === 'item.agentMessage.delta' ||
+            event.type === 'agent_message_delta') {
+            return this.parseAgentMessageDelta(rawEvent);
+        }
         if (event.type === 'turn.completed') {
             return this.parseTurnCompleted(event.usage);
         }
@@ -228,12 +246,27 @@ export class CodexJsonEventParser {
             };
             return [];
         }
-        // agent_reasoning: Map to thinking event
+        // agent_reasoning: Map to thinking event (stable uuid when item id present)
         if (payloadType === 'agent_reasoning') {
             const text = asString(payload.text);
             if (!text)
                 return [];
-            return [{ type: 'thinking', text, isStreaming: false }];
+            const itemId = asString(payload.item_id) || asString(payload.id);
+            const uuid = itemId ? `codex-thinking-${itemId}` : undefined;
+            return [{ type: 'thinking', text, isStreaming: false, uuid }];
+        }
+        // Streaming agent message delta (app-server / experimental envelopes)
+        if (payloadType === 'agent_message_delta' ||
+            payloadType === 'agent_message/delta' ||
+            payloadType === 'output_text_delta') {
+            const delta = asString(payload.text) ||
+                asString(payload.delta);
+            if (!delta)
+                return [];
+            const itemId = asString(payload.item_id) ||
+                asString(payload.id) ||
+                'anon';
+            return this.appendAgentTextDelta(itemId, delta);
         }
         // turn_aborted: Silent. The interruption is already visible from the agent stopping.
         if (payloadType === 'turn_aborted') {
@@ -391,9 +424,109 @@ export class CodexJsonEventParser {
                 toolOutput,
             }];
     }
+    /** Stable uuid for a Codex agent_message item so streaming chunks merge. */
+    agentTextUuid(itemId) {
+        return `codex-text-${itemId}`;
+    }
+    appendAgentTextDelta(itemId, delta) {
+        if (!delta)
+            return [];
+        const prev = this.streamedAgentTextByItemId.get(itemId) || '';
+        const next = prev + delta;
+        this.streamedAgentTextByItemId.set(itemId, next);
+        this.lastAgentMessageText = next;
+        const uuid = this.agentTextUuid(itemId);
+        this.openAgentTextUuids.add(uuid);
+        return [{ type: 'text', text: delta, isStreaming: true, uuid }];
+    }
+    /**
+     * Progressive snapshot for agent_message / reasoning on item.updated.
+     * Emits only the new suffix when text grows (prefix match).
+     */
+    emitProgressiveItemText(kind, itemId, fullText, isFinal) {
+        if (!fullText)
+            return [];
+        const id = itemId || 'anon';
+        const map = kind === 'text' ? this.streamedAgentTextByItemId : this.streamedThinkingByItemId;
+        const openSet = kind === 'text' ? this.openAgentTextUuids : this.openThinkingUuids;
+        const uuid = kind === 'text' ? this.agentTextUuid(id) : `codex-thinking-${id}`;
+        const prev = map.get(id) || '';
+        if (kind === 'text')
+            this.lastAgentMessageText = fullText;
+        if (fullText === prev) {
+            if (isFinal && openSet.has(uuid)) {
+                openSet.delete(uuid);
+                map.delete(id);
+                return [{ type: kind === 'text' ? 'text' : 'thinking', text: fullText, isStreaming: false, uuid }];
+            }
+            return [];
+        }
+        map.set(id, fullText);
+        if (!isFinal && fullText.startsWith(prev)) {
+            const delta = fullText.slice(prev.length);
+            if (!delta)
+                return [];
+            openSet.add(uuid);
+            return [{ type: kind === 'text' ? 'text' : 'thinking', text: delta, isStreaming: true, uuid }];
+        }
+        openSet.delete(uuid);
+        if (isFinal)
+            map.delete(id);
+        return [{ type: kind === 'text' ? 'text' : 'thinking', text: fullText, isStreaming: false, uuid }];
+    }
+    parseItemUpdated(item) {
+        if (!item?.type)
+            return [];
+        // Progressive agent_message text (when CLI emits item.updated for messages).
+        if (item.type === 'agent_message' && item.text) {
+            const sanitized = sanitizeCodexMessageText(item.text);
+            if (!sanitized.text)
+                return [];
+            return this.emitProgressiveItemText('text', item.id, sanitized.text, false);
+        }
+        if (item.type === 'reasoning' && item.text) {
+            return this.emitProgressiveItemText('thinking', item.id, item.text, false);
+        }
+        // todo_list updates are already handled elsewhere as non-text progress;
+        // leave other item.updated types silent to avoid raw dumps.
+        if (item.type === 'todo_list') {
+            return [];
+        }
+        return [];
+    }
+    parseAgentMessageDelta(rawEvent) {
+        if (!isObject(rawEvent))
+            return [];
+        const item = isObject(rawEvent.item) ? rawEvent.item : undefined;
+        const params = isObject(rawEvent.params) ? rawEvent.params : undefined;
+        const delta = asString(rawEvent.delta) ||
+            asString(rawEvent.text) ||
+            asString(item?.text) ||
+            (params ? asString(params.delta) || asString(params.text) : undefined);
+        if (!delta)
+            return [];
+        const itemId = asString(item?.id) ||
+            asString(rawEvent.item_id) ||
+            asString(rawEvent.id) ||
+            (params ? asString(params.item_id) || asString(params.id) : undefined) ||
+            'anon';
+        return this.appendAgentTextDelta(itemId, delta);
+    }
     parseItemStarted(item) {
         if (!item?.type)
             return [];
+        // Some Codex builds open agent_message with empty text on item.started;
+        // pin the stream uuid so later updates merge into one row.
+        if (item.type === 'agent_message') {
+            if (item.id) {
+                const uuid = this.agentTextUuid(item.id);
+                this.openAgentTextUuids.add(uuid);
+                if (item.text) {
+                    return this.emitProgressiveItemText('text', item.id, item.text, false);
+                }
+            }
+            return [];
+        }
         if (item.type === 'web_search') {
             const toolName = 'web_search';
             if (item.id) {
@@ -446,7 +579,12 @@ export class CodexJsonEventParser {
             return [{ type: 'error', errorMessage }];
         }
         if (item.type === 'reasoning' && item.text) {
-            return [{ type: 'thinking', text: item.text, isStreaming: false }];
+            const uuid = item.id ? `codex-thinking-${item.id}` : undefined;
+            if (item.id) {
+                this.streamedThinkingByItemId.delete(item.id);
+                this.openThinkingUuids.delete(uuid);
+            }
+            return [{ type: 'thinking', text: item.text, isStreaming: false, uuid }];
         }
         // Handle agent_message regardless of whether `text` is present. An empty
         // agent_message (text:"" or missing) must be suppressed — NOT allowed to
@@ -467,7 +605,14 @@ export class CodexJsonEventParser {
             // Empty message → render nothing (no empty bubble, no raw debug line).
             if (!sanitized.text)
                 return [];
-            return [{ type: 'text', text: sanitized.text, isStreaming: false }];
+            const uuid = item.id ? `codex-text-${item.id}` : undefined;
+            if (item.id) {
+                this.streamedAgentTextByItemId.delete(item.id);
+                if (uuid)
+                    this.openAgentTextUuids.delete(uuid);
+            }
+            // isStreaming:false finalizes any prior streaming row with the same uuid.
+            return [{ type: 'text', text: sanitized.text, isStreaming: false, uuid }];
         }
         if (item.type === 'web_search') {
             const toolName = item.id ? (this.activeToolByItemId.get(item.id) ?? 'web_search') : 'web_search';

package/dist/src/packages/server/grok/backend.js

@@ -141,6 +141,10 @@ export class GrokBackend {
             return null;
         return events.length === 1 ? events[0] : events;
     }
+    /** See CLIBackend.breakOpenStreams — tool-boundary stream split for Grok. */
+    breakOpenStreams() {
+        return this.parser.breakOpenStreams();
+    }
     extractSessionId(rawEvent) {
         const event = rawEvent;
         if (event?.sessionId && typeof event.sessionId === 'string') {

package/dist/src/packages/server/grok/json-event-parser.js

@@ -85,18 +85,23 @@ export class GrokJsonEventParser {
                 sessionId: event.sessionId,
             }];
     }
-    parseEnd(event) {
+    /**
+     * Finalize open text/thinking streams and mint new uuids for the next
+     * generation — WITHOUT step_complete (agent stays "working").
+     *
+     * Grok keeps one agentic turn across many tool rounds and does not emit
+     * `end` between them. Without this break, every intermediate status line
+     * concatenates into a single mashed bubble until the final end.
+     */
+    breakOpenStreams(sessionId) {
         const events = [];
-        // Finalize open streams so the client stops treating the row as "live"
-        // and stops re-mounting/blinking. Final payload replaces the merged row
-        // (same uuid, isStreaming=false) with the full accumulated text.
         if (this.thinkingStreamUuid && this.lastThinkingContent) {
             events.push({
                 type: 'thinking',
                 text: this.lastThinkingContent,
                 isStreaming: false,
                 uuid: this.thinkingStreamUuid,
-                sessionId: event.sessionId,
+                sessionId,
             });
         }
         if (this.textStreamUuid && this.lastTextContent) {
@@ -105,27 +110,37 @@ export class GrokJsonEventParser {
                 text: this.lastTextContent,
                 isStreaming: false,
                 uuid: this.textStreamUuid,
-                sessionId: event.sessionId,
+                sessionId,
             });
         }
+        this.lastTextContent = '';
+        this.lastThinkingContent = '';
+        // Keep textEventEmittedInTurn so a later end/step_complete still knows
+        // we produced text this turn (avoids empty-thinking fallback).
+        this.textStreamUuid = undefined;
+        this.thinkingStreamUuid = undefined;
+        return events;
+    }
+    parseEnd(event) {
+        // Finalize open streams (same as a tool-boundary break) then step_complete.
+        const events = this.breakOpenStreams(event.sessionId);
+        // breakOpenStreams cleared accumulators — re-read is not possible. Capture
+        // resultText from the finalize events we just built.
+        const finalizedText = events.find((e) => e.type === 'text' && e.text)?.text;
+        const finalizedThinking = events.find((e) => e.type === 'thinking' && e.text)?.text;
         const stepComplete = {
             type: 'step_complete',
             sessionId: event.sessionId,
         };
-        if (this.lastTextContent) {
-            stepComplete.resultText = this.lastTextContent;
+        if (finalizedText) {
+            stepComplete.resultText = finalizedText;
         }
-        else if (this.lastThinkingContent && !this.textEventEmittedInTurn) {
+        else if (finalizedThinking && !this.textEventEmittedInTurn) {
             // Thinking-only turn — surface a marker so the terminal isn't blank
             stepComplete.resultText = `(Empty response: thinking only, stopReason=${event.stopReason || 'EndTurn'})`;
         }
         events.push(stepComplete);
-        // Reset per-turn accumulators / stream ids
-        this.lastTextContent = '';
-        this.lastThinkingContent = '';
         this.textEventEmittedInTurn = false;
-        this.textStreamUuid = undefined;
-        this.thinkingStreamUuid = undefined;
         return events;
     }
     parseError(event) {

package/dist/src/packages/server/grok/session-watcher.js

@@ -186,10 +186,43 @@ export function startGrokSessionWatcher(opts) {
     let lastSignalsUsageKey = '';
     const emittedToolStarts = new Set();
     const emittedToolResults = new Set();
-    /** raw tool_name → queue of early synthetic ids (events.jsonl, no call id) */
+    /**
+     * raw tool_name → early synthetic ids still running (events tool_started,
+     * no tool_completed yet). chat_history prefers these first.
+     */
     const pendingEarlyByName = new Map();
+    /**
+     * raw tool_name → early ids that already got tool_completed BEFORE
+     * chat_history wrote the real call. Fast tools (TodoWrite) often complete
+     * in <100ms; if we only kept them in pending and shifted on complete, the
+     * upgrade path was empty and we emitted a second call-* chip — leaving the
+     * original early card stuck with empty toolInput (bare "TODOWRITE").
+     */
+    const completedEarlyByName = new Map();
     const earlyToReal = new Map();
     const realToEarly = new Map();
+    /** Pop the next early id eligible for upgrade (still running, else completed). */
+    const takeEarlyForUpgrade = (rawName) => {
+        const pending = pendingEarlyByName.get(rawName);
+        if (pending && pending.length > 0) {
+            const id = pending.shift();
+            if (pending.length === 0)
+                pendingEarlyByName.delete(rawName);
+            else
+                pendingEarlyByName.set(rawName, pending);
+            return id;
+        }
+        const completed = completedEarlyByName.get(rawName);
+        if (completed && completed.length > 0) {
+            const id = completed.shift();
+            if (completed.length === 0)
+                completedEarlyByName.delete(rawName);
+            else
+                completedEarlyByName.set(rawName, completed);
+            return id;
+        }
+        return undefined;
+    };
     const emit = (event) => {
         if (stopped)
             return;
@@ -263,24 +296,22 @@ export function startGrokSessionWatcher(opts) {
                 pendingEarlyByName.delete(rawName);
             else
                 pendingEarlyByName.set(rawName, queue);
-            // If chat_history already completed the real call, skip empty early result.
-            if (emittedToolResults.has(synthId))
-                return;
-            // If this early was upgraded to a real call id that already has a result, skip.
-            const realId = earlyToReal.get(synthId);
-            if (realId && emittedToolResults.has(realId)) {
-                emittedToolResults.add(synthId);
-                return;
+            // Keep the early id available for chat_history upgrade even after complete.
+            // TodoWrite / list_dir often finish before the assistant tool_calls line
+            // is flushed — without this, upgrade fails and the UI keeps an empty chip.
+            if (!earlyToReal.has(synthId)) {
+                const completedQ = completedEarlyByName.get(rawName) || [];
+                completedQ.push(synthId);
+                completedEarlyByName.set(rawName, completedQ);
             }
-            emittedToolResults.add(synthId);
-            emit({
-                type: 'tool_result',
-                toolName: normalizeGrokToolName(rawName),
-                toolUseId: synthId,
-                uuid: synthId,
-                toolOutput: line.outcome === 'success' ? '(ok)' : `(${line.outcome || 'done'})`,
-            });
-            // Tools change context fill — re-read signals after completions.
+            // Do NOT emit tool_result from events.jsonl.
+            // events only has outcome (success/error) — no stdout. Emitting
+            // "Bash output:\n(ok)" here races ahead of chat_history, marks the early
+            // uuid as done, and blocks the real dual-emit with full stdout. The UI
+            // then pairs the Bash chip to "(ok)" forever ("No output available").
+            // Real tool_result content always comes from chat_history.jsonl below.
+            //
+            // Still refresh context usage — tools change fill.
             pollSignalsUsage();
             return;
         }
@@ -301,14 +332,11 @@ export function startGrokSessionWatcher(opts) {
                 const rawName = call.name || 'unknown';
                 const toolName = normalizeGrokToolName(rawName);
                 const toolInput = parseToolInput(call.arguments);
-                // Link to a pending early card for this tool name (if any)
-                const earlyQueue = pendingEarlyByName.get(rawName);
-                if (earlyQueue && earlyQueue.length > 0) {
-                    const earlyId = earlyQueue.shift();
-                    if (earlyQueue.length === 0)
-                        pendingEarlyByName.delete(rawName);
-                    earlyToReal.set(earlyId, callId);
-                    realToEarly.set(callId, earlyId);
+                // Link to an early card for this tool name (running or already completed).
+                const linkedEarlyId = takeEarlyForUpgrade(rawName);
+                if (linkedEarlyId) {
+                    earlyToReal.set(linkedEarlyId, callId);
+                    realToEarly.set(callId, linkedEarlyId);
                 }
                 emittedToolStarts.add(callId);
                 // Prefer upgrading the early card (same uuid) with full args so the UI
@@ -340,26 +368,31 @@ export function startGrokSessionWatcher(opts) {
             const callId = line.tool_call_id;
             if (emittedToolResults.has(callId))
                 return;
-            emittedToolResults.add(callId);
             const content = typeof line.content === 'string'
                 ? line.content
                 : line.content != null
                     ? JSON.stringify(line.content)
                     : '';
             const out = truncateOutput(content);
+            // Prefer the live card uuid (early synth id) so Bash output pairs with the
+            // "Using tool: Bash" row the UI already rendered under that uuid.
+            const earlyId = realToEarly.get(callId);
+            const cardUuid = earlyId || callId;
+            emittedToolResults.add(callId);
+            if (earlyId)
+                emittedToolResults.add(earlyId);
             emit({
                 type: 'tool_result',
-                toolUseId: callId,
-                uuid: callId,
+                toolUseId: cardUuid,
+                uuid: cardUuid,
                 toolOutput: out,
             });
-            const earlyId = realToEarly.get(callId);
-            if (earlyId && !emittedToolResults.has(earlyId)) {
-                emittedToolResults.add(earlyId);
+            // Also emit under callId when different so any call-id-keyed consumers match.
+            if (cardUuid !== callId) {
                 emit({
                     type: 'tool_result',
-                    toolUseId: earlyId,
-                    uuid: earlyId,
+                    toolUseId: callId,
+                    uuid: callId,
                     toolOutput: out,
                 });
             }