@maudecode/talaria-web 0.0.0 → 1.11.0

package/dist/sessions/turn.js

@@ -20,9 +20,10 @@ import { dict } from '../config/agent-config.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
 import { messageWindowForDisplay, messagesForLimitedPayload, toolCallsForMessageWindow } from './window.js';
 import { attachTodoState } from './todo.js';
+import { hydrateAnchorActivityScenes, withTurnIds } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { maxIterationsFromConfig, maxTokensFromConfig, processWakeupMaxIterations, reasoningConfigFromConfig, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { assistantReplyAddedAfterCurrentTurn, buildPartialMessage, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stripXmlToolCalls, workspaceContextPrefix } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, buildPartialMessage, extractToolCallsFromMessages, injectMaxIterationSummaryFallback, isContextCompressionMarker, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, sanitizeMessagesForApi, sessionLacksFinalAssistantAnswer, splitThinkingFromContent, stripXmlToolCalls, workspaceContextPrefix } from './merge.js';
 import { fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
 import { str } from '../util.js';
 export const CHAT_LOCK_WAIT_SECONDS = 2;
@@ -138,6 +139,8 @@ export function explicitTextSignal(cfg) {
     return !['', 'auto'].includes(provider) || Boolean(str(vision.model).trim()) || Boolean(str(vision.base_url).trim());
 }
 export const GATEWAY_APPROVAL_RELAY_UNAVAILABLE = 'Gateway approval could not be relayed because the active run is unavailable. Reopen the session or retry after it reconnects.';
+/** Error classifications that are turn outcomes in their own right (not a generic failure). */
+const CLASSIFIED_OUTCOMES = new Set(['no_response', 'compression_exhausted', 'interrupted', 'cancelled']);
 export class TurnRunner {
     deps;
     writers = new Map();
@@ -146,6 +149,8 @@ export class TurnRunner {
     yoloChains = new Map();
     abortControllers = new Map();
     steers = new Map();
+    consumedSteers = new Map();
+    lastCompletedTool = new Map();
     /** Streams whose run completed (`done` emitted) and only await title work; a late cancel is a no-op for these. */
     settledStreams = new Set();
     constructor(deps) {
@@ -156,6 +161,8 @@ export class TurnRunner {
     /** Python `_start_chat_stream_for_session`: persist pending state, register the channel, launch the worker. */
     start(session, opts) {
         const s = session;
+        if (this.deps.updateInProgress?.())
+            return { error: 'Web is updating. Retry after it restarts.', _status: 503 };
         if (this.deps.profileDeleting?.(s.profile ?? null))
             return { error: `Profile '${str(s.profile)}' is being deleted.`, _status: 409 };
         const locked = s.active_stream_id;
@@ -190,7 +197,7 @@ export class TurnRunner {
                 s.title = provisional;
         }
         if (this.deps.saveMode() === 'eager')
-            this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source);
+            this.checkpointUserMessage(s, opts.msg, attachments, s.pending_started_at, source, streamId);
         this.deps.store.save(s);
         this.registry.writebackOwners.set(s.session_id, streamId);
         if (wasHiddenEmpty)
@@ -206,7 +213,7 @@ export class TurnRunner {
         void this.run(s.session_id, streamId, channel, opts).catch((error) => {
             this.deps.log(`[webui] ERROR turn ${streamId} crashed\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
         });
-        const response = { stream_id: streamId, session_id: s.session_id, pending_started_at: s.pending_started_at, turn_id: null, title: s.title };
+        const response = { stream_id: streamId, session_id: s.session_id, pending_started_at: s.pending_started_at, turn_id: streamId, title: s.title };
         if (opts.normalizedModel && opts.model)
             response.effective_model = opts.model;
         if (opts.modelProvider)
@@ -214,11 +221,11 @@ export class TurnRunner {
         return response;
     }
     /** Python `_checkpoint_user_message_for_eager_session_save`. */
-    checkpointUserMessage(s, msg, attachments, startedAt, source) {
+    checkpointUserMessage(s, msg, attachments, startedAt, source, turnId) {
         const latest = s.messages[s.messages.length - 1];
         if (latest?.role === 'user' && messageText(latest.content).split(/\s+/).join(' ') === msg.split(/\s+/).join(' '))
             return;
-        const user = { role: 'user', content: msg };
+        const user = { role: 'user', content: msg, _turn_id: turnId };
         const token = buildActiveTurnToken(s.active_stream_id, startedAt);
         if (token)
             user._active_turn_token = token;
@@ -370,6 +377,7 @@ export class TurnRunner {
                         case 'steer_pending':
                             for (const record of this.takeConsumedSteers(streamId, str(data.text), { keepLeftovers: true }))
                                 put('steer_consumed', record);
+                            this.saveConsumedSteers(sessionId, streamId);
                             return;
                         case 'tool':
                             liveToolCalls.push({ name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false });
@@ -386,6 +394,8 @@ export class TurnRunner {
                                     break;
                                 }
                             }
+                            if (str(data.tid))
+                                this.lastCompletedTool.set(streamId, str(data.tid));
                             put('tool_complete', data);
                             return;
                         // Python: the live chat frame carries the queue head plus depth, not the entry that just arrived.
@@ -462,7 +472,7 @@ export class TurnRunner {
             // sidecar reports `completed` whenever a failed run still carries messages).
             // Python's second chance: a turn that emitted no new row still counts when the merged transcript it produced
             // ends on a final answer (the current user row or trailing tool activity makes it "lacking").
-            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now() });
+            const mergedForCheck = () => mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
             const assistantAdded = assistantReplyAddedAfterCurrentTurn(resultMessages, previousContext, msgText) || !sessionLacksFinalAssistantAnswer(mergedForCheck());
             const lastErr = result.error ?? capturedTerminalError ?? '';
             // Python `_turn_transcript_lacks_final_assistant_answer`: a partial result with no final answer is a silent failure even if tokens streamed.
@@ -471,16 +481,22 @@ export class TurnRunner {
                 const classification = classifyProviderError(lastErr, { silentFailure: !lastErr });
                 const errStr = lastErr || `${classification.label}.`;
                 const payload = providerErrorPayload(errStr, classification.type, classification.hint, deps.redactEnabled());
+                // Settle the steers first so the persisted turn carries every consumed one; the Agent's pending text stays a leftover.
+                const steerEvents = this.finalizeSteerEvents(streamId, str(result.pending_steer));
                 this.persistError(s, streamId, classification.label, payload, activeTurnToken);
                 payload.session = redactSessionData(this.terminalSessionPayload(s), deps.redactEnabled());
                 payload.session_id = s.session_id;
                 payload.old_session_id = sessionId;
+                for (const [event, data] of steerEvents)
+                    put(event, data);
                 put('apperror', payload);
                 failed = true;
                 return;
             }
             // ── settle the transcript ──
-            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now() });
+            // The Agent's last pending-steer text settles the remaining steers before the turn is written back.
+            const steerEvents = this.finalizeSteerEvents(streamId, result.pending_steer);
+            s.messages = mergeDisplayMessagesAfterAgentResult(previousMessages, previousContext, resultMessages, msgText, { source: opts.source ?? 'webui', activeTurnToken, now: deps.now(), turnId: streamId });
             s.context_messages = dedupeContext(resultMessages);
             for (const m of s.messages) {
                 if (m.role !== 'assistant')
@@ -565,9 +581,13 @@ export class TurnRunner {
                         m._turnTps = Math.round((usage.completion_tokens / duration) * 10) / 10;
                     if (result.model)
                         m._usedModel = result.model;
+                    // The live `done` frame says the tool budget ran out; the persisted row says so too, so a reload agrees.
+                    if (result.tool_limit_reached && m._turn_id === streamId)
+                        m._terminal_state = 'tool_limit_reached';
                     break;
                 }
             }
+            this.persistConsumedSteers(s, streamId, previousStartedAt(s, activeRun), now);
             deps.store.save(s);
             deps.pending.clearApprovals(sessionId);
             deps.pending.clearClarifies(sessionId);
@@ -610,7 +630,7 @@ export class TurnRunner {
                 donePayload.terminal_reason = 'max_iterations';
             }
             put('done', donePayload);
-            for (const [event, payload] of this.finalizeSteerEvents(streamId, result.pending_steer))
+            for (const [event, payload] of steerEvents)
                 put(event, payload);
             // The turn is over: release admission before the title work so a follow-up message is accepted while the
             // (up to two) title prompts run; the channel and journal stay open for the `title` events (Python retired the
@@ -661,6 +681,8 @@ export class TurnRunner {
                     current = s;
                 }
                 if (current.active_stream_id === streamId) {
+                    for (const [event, data] of this.takeSteerEventsBefore(streamId, 'apperror'))
+                        put(event, data);
                     this.persistError(current, streamId, classification.label, payload, activeTurnToken);
                     payload.session = redactSessionData(this.terminalSessionPayload(current), deps.redactEnabled());
                 }
@@ -756,7 +778,8 @@ export class TurnRunner {
      */
     terminalSessionPayload(s) {
         const payload = s.compact({ includeRuntime: true, activeStreamIds: this.registry.liveIds });
-        const [window, offset] = messageWindowForDisplay(s.messages, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
+        const scened = hydrateAnchorActivityScenes(withTurnIds(s.messages), s.anchor_activity_scenes, { activeTurnId: s.active_stream_id, clipToolResults: true });
+        const [window, offset] = messageWindowForDisplay(scened, TERMINAL_SSE_VISIBLE_MESSAGE_LIMIT, null);
         const limited = messagesForLimitedPayload(window);
         payload.messages = limited;
         payload.message_count = s.messages.length;
@@ -769,7 +792,7 @@ export class TurnRunner {
     /** Python `_materialize_pending_user_turn_before_error` + error message append + save. */
     persistError(s, streamId, label, payload, activeTurnToken) {
         const startedAt = s.pending_started_at;
-        this.materializePendingUserTurn(s, activeTurnToken);
+        this.materializePendingUserTurn(s, activeTurnToken, streamId);
         const duration = typeof startedAt === 'number' && startedAt > 0 ? Math.max(0, this.deps.now() - startedAt) : null;
         s.active_stream_id = null;
         s.pending_user_message = null;
@@ -778,9 +801,12 @@ export class TurnRunner {
         s.pending_user_source = null;
         this.appendPartialSnapshot(s, streamId);
         const hint = str(payload.hint);
-        const errorMessage = { role: 'assistant', content: `**${label}:** ${str(payload.message) || label}${hint ? `\n\n*${hint}*` : ''}`, timestamp: Math.trunc(this.deps.now()), _error: true };
+        const errorMessage = { role: 'assistant', content: `**${label}:** ${str(payload.message) || label}${hint ? `\n\n*${hint}*` : ''}`, timestamp: Math.trunc(this.deps.now()), _error: true, _turn_id: streamId };
         if (duration !== null)
             errorMessage._turnDuration = Math.round(duration * 1000) / 1000;
+        // The classified outcome the live frame reported stays on the row, so the settled scene says the same.
+        if (CLASSIFIED_OUTCOMES.has(str(payload.type)))
+            errorMessage._terminal_state = str(payload.type);
         if (payload.type === 'compression_exhausted') {
             // Python `stamp_compression_exhausted_recovery`: durable recovery metadata on the session, the marker, and the frame.
             const recovery = stampCompressionExhaustedRecovery(s, str(payload.message) || label, str(payload.details));
@@ -795,6 +821,7 @@ export class TurnRunner {
         else if (payload.type === 'interrupted')
             errorMessage.provider_details_label = 'Interruption details';
         s.messages.push(errorMessage);
+        this.persistConsumedSteers(s, streamId, startedAt, this.deps.now());
         try {
             this.deps.store.save(s);
         }
@@ -805,7 +832,7 @@ export class TurnRunner {
         this.deps.pending.clearClarifies(s.session_id);
         this.deps.events.publish('session_error', { profile: s.profile, sessionId: s.session_id });
     }
-    materializePendingUserTurn(s, activeTurnToken) {
+    materializePendingUserTurn(s, activeTurnToken, turnId) {
         const pendingText = str(s.pending_user_message);
         if (!pendingText)
             return false;
@@ -816,7 +843,7 @@ export class TurnRunner {
             for (let i = s.messages.length - 1; i >= 0; i -= 1) {
                 const m = s.messages[i];
                 if (m.role === 'user' && m._active_turn_token === activeTurnToken) {
-                    if (!s.messages.slice(i + 1).some((later) => later.role === 'user'))
+                    if (!s.messages.slice(i + 1).some((later) => later.role === 'user' && !later._steer))
                         return false;
                     break;
                 }
@@ -826,7 +853,7 @@ export class TurnRunner {
         // Python `_synthesize_user_message_on_cancel`: a worker that already merged this prompt (same text, not older than the pending start) wins.
         if (last?.role === 'user' && messageText(last.content).trim() === pendingText.trim() && Math.trunc(Number(last.timestamp)) >= Math.trunc(recoveredTs))
             return false;
-        const recovered = { role: 'user', content: pendingText, timestamp: recoveredTs, _recovered: true };
+        const recovered = { role: 'user', content: pendingText, timestamp: recoveredTs, _recovered: true, _turn_id: turnId };
         if (source !== 'webui')
             recovered._source = source;
         if (attachments.length)
@@ -840,6 +867,7 @@ export class TurnRunner {
         const partial = buildPartialMessage((this.registry.partialText.get(streamId) ?? []).join(''), (this.registry.reasoningText.get(streamId) ?? []).join(''), this.registry.liveToolCalls.get(streamId) ?? [], this.deps.now());
         if (!partial)
             return;
+        partial._turn_id = streamId;
         const key = messageIdentity(partial);
         if (key !== null && s.messages.some((m) => m._partial && messageIdentity(m) === key))
             return;
@@ -882,7 +910,8 @@ export class TurnRunner {
         }
         if (current.messages.some((m) => m._error && str(m.content).startsWith('**Task cancelled:**')) && current.active_stream_id === null && !current.pending_user_message)
             return true;
-        this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at));
+        const startedAt = current.pending_started_at;
+        this.materializePendingUserTurn(current, buildActiveTurnToken(streamId, current.pending_started_at), streamId);
         current.active_stream_id = null;
         current.pending_user_message = null;
         current.pending_attachments = [];
@@ -890,7 +919,8 @@ export class TurnRunner {
         current.pending_user_source = null;
         this.appendPartialSnapshot(current, streamId);
         const text = message.trim().endsWith('.') ? message.trim() : `${message.trim()}.`;
-        current.messages.push({ role: 'assistant', content: `**Task cancelled:** ${text}\n\n*${cancelledTurnHint(this.deps.agentName())}*`, _error: true, provider_details: text, provider_details_label: 'Cancellation details', timestamp: Math.trunc(this.deps.now()) });
+        current.messages.push({ role: 'assistant', content: `**Task cancelled:** ${text}\n\n*${cancelledTurnHint(this.deps.agentName())}*`, _error: true, provider_details: text, provider_details_label: 'Cancellation details', timestamp: Math.trunc(this.deps.now()), _turn_id: streamId });
+        this.persistConsumedSteers(current, streamId, startedAt, this.deps.now());
         try {
             this.deps.store.save(current);
         }
@@ -917,6 +947,8 @@ export class TurnRunner {
         }
         this.abortControllers.delete(streamId);
         this.steers.delete(streamId);
+        this.consumedSteers.delete(streamId);
+        this.lastCompletedTool.delete(streamId);
         this.settledStreams.delete(streamId);
         this.registry.retire(streamId, this.deps.now());
         this.registry.forgetOwner(streamId);
@@ -1089,6 +1121,8 @@ export class TurnRunner {
                 leftover = '';
             }
         }
+        // Settle the steers first so the persisted cancel carries every consumed one.
+        const steerEvents = (this.steers.get(streamId) ?? []).length ? this.finalizeSteerEvents(streamId, leftover) : [];
         if (sessionId) {
             let current = null;
             try {
@@ -1117,9 +1151,8 @@ export class TurnRunner {
                 }
                 channel.put([event, data, eventId]);
             };
-            if ((this.steers.get(streamId) ?? []).length)
-                for (const [event, data] of this.finalizeSteerEvents(streamId, leftover))
-                    emit(event, data);
+            for (const [event, data] of steerEvents)
+                emit(event, data);
             emit('cancel', sessionId ? this.cancelFrame(sessionId) : this.cancelPayload());
             this.registry.streams.delete(streamId);
             this.registry.liveIds.delete(streamId);
@@ -1196,7 +1229,70 @@ export class TurnRunner {
         return null;
     }
     consumedSteerPayload(record) {
-        return { ...record, agent_text: record.text, text: record.display_text || record.text, consumed_at: this.deps.now() };
+        const consumedAt = this.deps.now();
+        const afterToolCallId = this.lastCompletedTool.get(record.stream_id) ?? null;
+        const consumed = this.consumedSteers.get(record.stream_id) ?? [];
+        if (!consumed.some((c) => c.steer_id === record.steer_id)) {
+            consumed.push({ steer_id: record.steer_id, text: record.display_text || record.text, agent_text: record.text, submitted_at: record.created_at, consumed_at: consumedAt, after_tool_call_id: afterToolCallId });
+            this.consumedSteers.set(record.stream_id, consumed);
+        }
+        return { ...record, agent_text: record.text, text: record.display_text || record.text, consumed_at: consumedAt, after_tool_call_id: afterToolCallId };
+    }
+    /**
+     * Consumed steers become display-only `_steer` user rows at their causal place in the turn: after the tool results of
+     * the call that had completed when the Agent took them (else right after the turn's prompt), in consumption order,
+     * each with the phase it ended. Returns where the last phase starts. Replaces the turn's earlier placement, so the
+     * mid-turn save and the terminal one agree. Leftover steers are not persisted.
+     */
+    placeConsumedSteers(s, streamId, startedAt) {
+        const steers = this.consumedSteers.get(streamId) ?? [];
+        if (!steers.length)
+            return null;
+        s.messages = s.messages.filter((m) => !(m._steer && m._turn_id === streamId));
+        let boundary = typeof startedAt === 'number' && startedAt > 0 ? startedAt : steers[0].submitted_at;
+        for (const steer of steers) {
+            const row = {
+                role: 'user', content: steer.text, timestamp: steer.consumed_at, _turn_id: streamId,
+                _steer: { steer_id: steer.steer_id, submitted_at: steer.submitted_at, consumed_at: steer.consumed_at, phase_duration: roundDuration(steer.consumed_at - boundary) },
+            };
+            // An Agent that records the steer it delivered does so at its exact place: that row becomes the steer, not a copy.
+            const agentRows = s.messages.flatMap((m, i) => (m._turn_id === streamId && agentSteerText(m) !== null ? [i] : []));
+            const agentRow = agentRows.find((i) => agentSteerText(s.messages[i]) === steer.agent_text.trim()) ?? agentRows[0];
+            if (agentRow === undefined)
+                s.messages.splice(steerInsertIndex(s.messages, streamId, steer.after_tool_call_id), 0, row);
+            else
+                s.messages[agentRow] = row;
+            boundary = steer.consumed_at;
+        }
+        return boundary;
+    }
+    /** A steer is saved as it enters the stream, so a reload mid-turn already has it; the terminal save re-places it. */
+    saveConsumedSteers(sessionId, streamId) {
+        let s;
+        try {
+            s = this.deps.store.get(sessionId);
+        }
+        catch {
+            return;
+        }
+        if (s.active_stream_id !== streamId || this.placeConsumedSteers(s, streamId, s.pending_started_at) === null)
+            return;
+        try {
+            this.deps.store.save(s, { touchUpdatedAt: false });
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: failed to save consumed steer for ${sessionId}: ${error.message}`);
+        }
+    }
+    /** Terminal placement: the turn's rows are final now, and its last reply carries the final phase. */
+    persistConsumedSteers(s, streamId, startedAt, endedAt) {
+        const boundary = this.placeConsumedSteers(s, streamId, startedAt);
+        this.consumedSteers.delete(streamId);
+        if (boundary === null)
+            return;
+        const last = s.messages.findLast((m) => m.role === 'assistant' && m._turn_id === streamId);
+        if (last)
+            last._final_phase_duration = roundDuration(endedAt - boundary);
     }
     /**
      * Python `_take_consumed_webui_steers` (live, `keepLeftovers`) and `_finalize_webui_steers` (terminal): records the
@@ -1354,4 +1450,35 @@ function dedupeContext(messages) {
     return out;
 }
 export { HttpFailure };
+/** Where a consumed steer goes: past the tool results of the call it followed, else past the turn's prompt. */
+function roundDuration(seconds) {
+    return Math.round(Math.max(0, seconds) * 1000) / 1000;
+}
+function steerInsertIndex(messages, turnId, afterToolCallId) {
+    // OpenAI-style `tool_calls` and Anthropic-style `tool_use` content blocks both name the call a steer followed.
+    const callIds = (m) => [
+        ...(Array.isArray(m.tool_calls) ? m.tool_calls : []).map((tc) => str(tc.id) || str(tc.call_id) || str(tc.tool_call_id)),
+        ...(Array.isArray(m.content) ? m.content : []).flatMap((part) => (isDict(part) && part.type === 'tool_use' ? [str(part.id)] : [])),
+    ];
+    // The steer followed that call's result: right after its row (a `tool` row, or a user row of `tool_result` blocks), even
+    // when the same assistant message made later calls; steers already placed there keep their consumption order.
+    const answers = (m) => (m.role === 'tool' && (str(m.tool_call_id) || str(m.tool_use_id)) === afterToolCallId)
+        || (m.role === 'user' && Array.isArray(m.content) && m.content.some((part) => isDict(part) && part.type === 'tool_result' && str(part.tool_use_id) === afterToolCallId));
+    const result = afterToolCallId ? messages.findIndex((m) => m._turn_id === turnId && answers(m)) : -1;
+    if (result !== -1) {
+        let i = result + 1;
+        while (i < messages.length && messages[i]._turn_id === turnId && messages[i]._steer)
+            i += 1;
+        return i;
+    }
+    let at = afterToolCallId ? messages.findIndex((m) => m._turn_id === turnId && m.role === 'assistant' && callIds(m).includes(afterToolCallId)) : -1;
+    if (at === -1)
+        at = messages.findIndex((m) => m._turn_id === turnId && m.role === 'user' && !m._steer);
+    if (at === -1)
+        return messages.length;
+    let i = at + 1;
+    while (i < messages.length && messages[i]._turn_id === turnId && (messages[i].role === 'tool' || messages[i]._steer))
+        i += 1;
+    return i;
+}
 //# sourceMappingURL=turn.js.map