@maudecode/talaria-web 1.20.0 → 1.22.0

package/dist/sessions/turn.js

@@ -1,3 +1,4 @@
+import { applyPlanGauge } from './session.js';
 /**
  * One agent turn: admission, pending-state persistence, the sidecar
  * `chat.start` call, live frame relay into the journal and stream channel,
@@ -18,7 +19,7 @@ import { toolProgress } from './tool-display.js';
 import { catalogNames, connectorOperation } from '../tools/connectors.js';
 import { PendingPrompts, clarifyReply, isVaultPrompt, vaultReply } from './pending.js';
 import { COMPRESSION_RECOVERY_ACTION_START_FOCUSED, COMPRESSION_RECOVERY_TERMINAL_STATE, CONTEXT_USAGE_FIELDS, Session, contextUsage, forgetContextFigures, titleFrom } from './session.js';
-import { anchorMessageKey, markerSummary, visibleMessagesForAnchor } from './compress.js';
+import { anchorMessageKey, markerSummary, insertCompactionRow, visibleMessagesForAnchor } from './compress.js';
 import { buildActiveTurnToken, completedToolIndex, publicToolFrame, redactNestedMessageContainers, redactString, withToolId } from '../redact.js';
 import { dict, findPersonality } from '../config/agent-config.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
@@ -28,7 +29,7 @@ import { SessionGoals } from './goals.js';
 import { turnTerminalState } from './anchor.js';
 import { persistentStateChanges, persistentStateSnapshot } from './state-saved.js';
 import { agentBuildParams, webuiEphemeralSystemPrompt, workspaceSystemMessage } from './turn-context.js';
-import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, hasNativeImages, injectMaxIterationSummaryFallback, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, withDataUseRequirements, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, toolOutcome, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
+import { agentSteerText, assistantReplyAddedAfterCurrentTurn, attachedFilesPrompt, buildPartialMessage, dedupeContext, checkpointTurnStart, extractToolCallsFromMessages, finalAnswerOf, hasNativeImages, isConversationalAssistant, withFinalAssistantAnswer, isDict, mergeDisplayMessagesAfterAgentResult, messageIdentity, messageText, pendingUserRow, sanitizeMessagesForApi, withDataUseRequirements, sessionLacksFinalAssistantAnswer, splitDisplayText, stateDbSeenId, joinReasoning, reasoningFieldsText, toolOutcome, withoutMaxIterationSummaryRequest, withNativeImagesRestored, withoutNativeImages, withoutToolImages } from './merge.js';
 import { mayBecomeSilentReply, turnOrigin, recordBackgroundReview, recordBackgroundUpdate } from './background-updates.js';
 import { countExchanges, fallbackTitleFromExchange, firstExchangeSnippets, isGenericFallbackTitle, latestExchangeSnippets, looksInvalidGeneratedTitle, looksLikeDefaultCliTitle, sanitizeGeneratedTitle, titleLanguageMismatch, titlePrompts } from './titles.js';
 import { WORKSPACE_BUSY_MESSAGE } from '../workspace/git.js';
@@ -49,6 +50,7 @@ const BACKGROUND_UNWIND_WAIT_MS = 30_000;
 const COMPRESSION_EXHAUSTED = { label: 'Context compression exhausted', type: 'compression_exhausted', hint: 'The conversation context is too large to compress safely. Start a new conversation or retry with a narrower task.' };
 /** The Agent's session counters onto a session's: a zero or missing reading keeps the figure it already has. */
 function applyAgentUsage(target, usage) {
+    applyPlanGauge(target, usage, true);
     if (usage.prompt_tokens > 0)
         target.input_tokens = usage.prompt_tokens;
     if (usage.completion_tokens > 0)
@@ -62,6 +64,7 @@ function applyAgentUsage(target, usage) {
 }
 /** TAL-397: the `metering` frame's counters, the same figures the session persists. */
 const meteringUsage = (c) => ({
+    plan_gauge: c.plan_gauge ?? null,
     input_tokens: c.input_tokens || 0, output_tokens: c.output_tokens || 0, estimated_cost: typeof c.estimated_cost === 'number' ? c.estimated_cost : null,
     cache_read_tokens: c.cache_read_tokens || 0, cache_write_tokens: c.cache_write_tokens || 0,
 });
@@ -396,6 +399,7 @@ export class TurnRunner {
             timing.finish('noop');
             return { stream_id: str(accepted[opts.completionKeys[0]]), session_id: s.session_id };
         }
+        opts.admissionCheck?.(s);
         closeChecks();
         const streamId = randomUUID().replace(/-/g, '');
         timing.identify(s.session_id, streamId);
@@ -443,7 +447,7 @@ export class TurnRunner {
         const previousUpdates = s.extra.background_updates;
         if (opts.backgroundUpdate)
             recordBackgroundUpdate(s, streamId, opts.backgroundUpdate);
-        const admission = { stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral), origin: turnOrigin(source), admitting: true };
+        const admission = { stream_id: streamId, session_id: s.session_id, started_at: this.deps.now(), phase: 'starting', workspace: opts.workspace, model: opts.model, provider: opts.modelProvider, ephemeral: Boolean(opts.ephemeral), ...(opts.activityParentSessionId ? { activity_parent_session_id: opts.activityParentSessionId } : {}), origin: turnOrigin(source), admitting: true };
         this.registry.registerActiveRun(admission);
         try {
             await timing.measure('admission_persistence', () => this.deps.store.save(s));
@@ -650,10 +654,11 @@ export class TurnRunner {
         const mintToolId = () => `tool-${streamId}-${String(++mintedToolIds)}`;
         // When the server received each call's start frame: its completion's `duration` is measured from it.
         const toolStartedAt = new WeakMap();
+        let finalStreamedText = '';
         let tokenSent = false;
         let firstTokenAt = null;
         // TAL-397: the live meter. Counters start from the session's and follow the Agent's; the rate counts text deltas.
-        const liveUsage = { input_tokens: s.input_tokens, output_tokens: s.output_tokens, estimated_cost: s.estimated_cost, cache_read_tokens: s.cache_read_tokens, cache_write_tokens: s.cache_write_tokens };
+        const liveUsage = { plan_gauge: null, input_tokens: s.input_tokens, output_tokens: s.output_tokens, estimated_cost: s.estimated_cost, cache_read_tokens: s.cache_read_tokens, cache_write_tokens: s.cache_write_tokens };
         const meter = { deltas: 0, first: 0, last: 0, sentAt: null };
         const putMetering = async (force, now = deps.now()) => {
             if (!force && meter.sentAt !== null && now - meter.sentAt < METERING_INTERVAL_S)
@@ -718,7 +723,7 @@ export class TurnRunner {
             // start an Agent turn (the client also refuses an already-aborted signal outright).
             if (this.registry.cancelled.has(streamId)) {
                 await this.finalizeCancelled(s, streamId, opts.ephemeral);
-                await put('cancel', (await this.cancelFrame(sessionId)));
+                await put('cancel', (await this.cancelFrame(sessionId, streamId)));
                 return;
             }
             const turnContext = {
@@ -771,6 +776,7 @@ export class TurnRunner {
                                 const stable = titles.stableSnapshot(reasoningText.join(''));
                                 if (stable !== null)
                                     (await emitFrame('reasoning', { text: '', titles: stable }));
+                                finalStreamedText += str(data.text);
                                 partialText.push(str(data.text));
                                 if (holdSilence && mayBecomeSilentReply(partialText.join(''))) {
                                     heldText += str(data.text);
@@ -783,6 +789,7 @@ export class TurnRunner {
                                 return;
                             }
                             case 'reasoning': {
+                                finalStreamedText = '';
                                 if (partialText.length && !reasoningText.length)
                                     titles.resetSegment();
                                 reasoningText.push(str(data.text));
@@ -811,7 +818,13 @@ export class TurnRunner {
                                 await saving;
                                 return;
                             }
+                            case 'interim_assistant': {
+                                finalStreamedText = '';
+                                await emitFrame(frame.event, data);
+                                return;
+                            }
                             case 'tool': {
+                                finalStreamedText = '';
                                 const call = { name: data.name, args: data.args ?? {}, tid: str(data.tid), done: false };
                                 liveToolCalls.push(call);
                                 toolIds.set(call, call.tid || mintToolId());
@@ -992,7 +1005,7 @@ export class TurnRunner {
                 applyAgentUsage(liveUsage, result.usage);
                 this.liveUsage.set(streamId, liveUsage);
                 await this.finalizeCancelled(s, streamId, opts.ephemeral, interrupted?.checkpoint ? withImages(interrupted.checkpoint) : result.messages);
-                await put('cancel', (await this.cancelFrame(sessionId)));
+                await put('cancel', (await this.cancelFrame(sessionId, streamId)));
                 return;
             }
             // Writeback only while this stream still owns the session (Python `_stream_writeback_is_current`).
@@ -1008,9 +1021,15 @@ export class TurnRunner {
                 return;
             }
             s = current;
-            // Python `_maybe_inject_max_iteration_summary_fallback`: an exhausted tool budget leaves the closing
-            // explanation in `final_response` only, so it becomes the turn's assistant answer before anything else reads it.
-            const withFallback = (rows) => (result.tool_limit_reached ? injectMaxIterationSummaryFallback(rows, result.final_response) : rows);
+            // Recover before display, context, state.db reconciliation and terminal classification read the result.
+            const recoverAnswer = result.status === 'completed' && !result.failed && !result.partial && !result.compression_exhausted && !result.error && !capturedTerminalError;
+            const recoveredPrompt = pendingUserRow(msgText, opts.attachments ?? [], s.pending_started_at, opts.source ?? 'webui', streamId);
+            if (typeof userMessage === 'string')
+                recoveredPrompt.api_content = userMessage;
+            else
+                recoveredPrompt.content = userMessage;
+            const withFallback = (rows, finalResponse = result.final_response) => (recoverAnswer || result.tool_limit_reached
+                ? withFinalAssistantAnswer(rows, finalResponse, { previousContext, msgText, prompt: recoveredPrompt, streamedText: recoverAnswer && !opts.ephemeral ? finalStreamedText : '', toolLimitReached: result.tool_limit_reached }) : rows);
             const withoutRequest = (rows) => (result.tool_limit_reached ? withoutMaxIterationSummaryRequest(rows, result.max_iterations_summary_request, msgText) : rows);
             const agentRows = withFallback(result.messages);
             const resultMessages = withoutRequest(agentRows);
@@ -1037,7 +1056,7 @@ export class TurnRunner {
                 await this.persistError(s, settlement, streamId, classification.label, payload, activeTurnToken, resultMessages, result.provider);
                 // TAL-512: a btw error carries no session: its journaled frame must not keep a copy of the parent conversation.
                 if (!opts.ephemeral)
-                    payload.session = (await this.publicTerminalSession(s));
+                    payload.session = (await this.publicTerminalSession(s, streamId));
                 payload.session_id = s.session_id;
                 payload.old_session_id = sessionId;
                 for (const [event, data] of steerEvents)
@@ -1069,7 +1088,9 @@ export class TurnRunner {
             // ── settle the transcript ──
             // TAL-539: after a mid-turn compression the model context is the sidecar's pruned copy, settled like the transcript.
             const pruned = result.compressed ? result.context_messages ?? null : null;
-            const context = withoutToolImages(pruned ? withoutRequest(withFallback(pruned)) : resultMessages);
+            const answer = assistantAdded ? resultMessages.at(-1) : undefined;
+            const finalResponse = answer && isConversationalAssistant(answer) && finalAnswerOf(answer).trim() ? messageText(answer.content) : '';
+            const context = withoutToolImages(pruned ? withoutRequest(withFallback(pruned, finalResponse)) : resultMessages);
             let estimate = result.compressed ? result.post_compression_context_tokens_estimate ?? null : null;
             // The sidecar estimated its own rows; a tool-limit settlement or stripped screenshots (TAL-544) that changed them move
             // the estimate by the difference.
@@ -1098,6 +1119,10 @@ export class TurnRunner {
                 s.compression_anchor_visible_idx = anchorIdx;
                 s.compression_anchor_message_key = anchorMessageKey(anchorIdx !== null && anchorIdx < after.length ? after[anchorIdx] : after.at(-1));
                 s.compression_anchor_summary = markerSummary(s.context_messages);
+                // TAL-1566: the compaction's row sits where the compaction happened: before this turn's rows.
+                const at = s.messages.findIndex((m) => m._turn_id === streamId);
+                if (s.compression_anchor_summary)
+                    insertCompactionRow(s, (at < 0 ? s.messages.length : at) - 1, str(s.compression_anchor_summary), deps.now());
             }
             const now = deps.now();
             for (const m of s.messages)
@@ -1196,11 +1221,11 @@ export class TurnRunner {
             const turnInput = Math.max(0, inputTokens - prevInputTokens);
             const turnCacheRead = Math.max(0, cacheReadTokens - prevCacheReadTokens);
             const doneUsage = {
-                input_tokens: s.input_tokens, output_tokens: s.output_tokens, estimated_cost: s.estimated_cost, cache_read_tokens: s.cache_read_tokens, cache_write_tokens: s.cache_write_tokens,
+                plan_gauge: s.plan_gauge, input_tokens: s.input_tokens, output_tokens: s.output_tokens, estimated_cost: s.estimated_cost, cache_read_tokens: s.cache_read_tokens, cache_write_tokens: s.cache_write_tokens,
                 cache_hit_percent: cacheHit(cacheReadTokens, inputTokens), turn_cache_hit_percent: cacheHit(turnCacheRead, turnInput), duration_seconds: Math.round(duration * 1000) / 1000,
                 context_length: s.context_length ?? 0, threshold_tokens: s.threshold_tokens ?? 0, last_prompt_tokens: s.last_prompt_tokens ?? 0,
             };
-            const doneSession = (await this.publicTerminalSession(s));
+            const doneSession = (await this.publicTerminalSession(s, streamId));
             // TAL-299: the ring's figures match the terminal session's (and a detail reload's).
             for (const key of CONTEXT_USAGE_FIELDS)
                 doneUsage[key] = doneSession[key];
@@ -1258,7 +1283,7 @@ export class TurnRunner {
                         s.extra.completion_acceptances = Object.fromEntries(Object.entries(s.extra.completion_acceptances).filter(([, value]) => value !== streamId));
                     await deps.store.save(s, { touchUpdatedAt: false });
                 }
-                await put('apperror', { type: 'error', terminal_state: 'error', message: readOnly, session_id: sessionId, session: (await this.publicTerminalSession(s)) });
+                await put('apperror', { type: 'error', terminal_state: 'error', message: readOnly, session_id: sessionId, session: (await this.publicTerminalSession(s, streamId)) });
                 return;
             }
             if (settledAt.value && !(error instanceof SidecarError)) {
@@ -1268,7 +1293,7 @@ export class TurnRunner {
             const settlement = await deps.service().settlementRead(s);
             if (this.registry.cancelled.has(streamId)) {
                 await this.finalizeCancelled(s, streamId, opts.ephemeral);
-                await put('cancel', (await this.cancelFrame(sessionId)));
+                await put('cancel', (await this.cancelFrame(sessionId, streamId)));
                 return;
             }
             const message = error instanceof Error ? error.message : String(error);
@@ -1292,7 +1317,7 @@ export class TurnRunner {
                         (await put(event, data));
                     await this.persistError(current, settlement, streamId, classification.label, payload, activeTurnToken);
                     if (!opts.ephemeral)
-                        payload.session = (await this.publicTerminalSession(current));
+                        payload.session = (await this.publicTerminalSession(current, streamId));
                 }
             }
             catch (persistError) {
@@ -1394,8 +1419,14 @@ export class TurnRunner {
         return images ? [{ type: 'text', text: withFiles() }, ...parts] : withFiles();
     }
     /** The settled session as a terminal frame carries it: the display window, redacted. */
-    async publicTerminalSession(s) {
-        return this.deps.service().windowedDetail(s, TRANSCRIPT_WINDOW);
+    async publicTerminalSession(s, streamId) {
+        const terminal = streamId ? this.deps.service().activitySummary(s, streamId)?.terminalState : null;
+        const payload = await this.deps.service().windowedDetail(s, TRANSCRIPT_WINDOW);
+        if (!streamId)
+            return payload;
+        const terminalPhase = terminal === 'completed' || terminal === 'tool_limit_reached' ? 'completed' : terminal === 'cancelled' ? 'cancelled' : 'failed';
+        payload.activity_phase = await this.deps.service().activityPhase(s, { excludeStreamId: streamId, terminalPhase });
+        return payload;
     }
     /** TAL-540, Python `_live_usage_snapshot`: a finished compression's frame, with the counters and the ring's post-compression figures, so clients update before `done`. */
     compressedFrame(s) {
@@ -1547,11 +1578,11 @@ export class TurnRunner {
      * Python `_emit_cancel_event`: the terminal frame carries the settled session so tabs can render the partial without a
      * reload. TAL-364: no copy — clients show their one localized status for the `cancelled` outcome.
      */
-    async cancelFrame(sessionId) {
+    async cancelFrame(sessionId, streamId) {
         let snapshot = null;
         if (sessionId)
             try {
-                snapshot = (await this.publicTerminalSession((await this.deps.store.get(sessionId))));
+                snapshot = (await this.publicTerminalSession((await this.deps.store.get(sessionId)), streamId));
             }
             catch {
                 snapshot = null;
@@ -2069,7 +2100,7 @@ export class TurnRunner {
                 (await emit(event, data));
             this.runStatuses.delete(streamId);
             await emit('run_status', { session_id: sessionId, status: null });
-            await emit('cancel', (await this.cancelFrame(sessionId)));
+            await emit('cancel', (await this.cancelFrame(sessionId, streamId)));
             this.registry.streams.delete(streamId);
             this.registry.liveIds.delete(streamId);
         }
@@ -2666,7 +2697,7 @@ export class TurnRunner {
             return { ok: false, error: 'The Agent sidecar is not running; retry in a moment.' };
         let ok = false;
         try {
-            ok = (await sidecar.call('clarify.respond', { session_id: sessionId, clarify_id: str(entry.clarify_id), response })).ok;
+            ok = (await sidecar.call('clarify.respond', { profile_home: this.deps.profileHome((await this.deps.store.get(sessionId, { metadataOnly: true })).profile), session_id: sessionId, clarify_id: str(entry.clarify_id), response })).ok;
         }
         catch (error) {
             if (vault)