@qduc/term2 0.38.0 → 0.40.0

package/dist/gateway/gateway.js

@@ -11,7 +11,7 @@ import { projectConversationMessage } from '../services/conversation/conversatio
 import { normalizeRunItem } from '../services/conversation/run-item-normalizer.js';
 import { FROZEN_AGENT_EVENT_TYPES } from '@qduc/agent-wire';
 import { GatewayPersistenceError, TERMINAL_AGENT_EVENT_TYPES, } from './persistence/contracts.js';
-import { createSessionProjectionSource, hydrateConversationService, } from './persistence/projection.js';
+import { createSessionProjectionSource, wireCallId, hydrateConversationService, } from './persistence/projection.js';
 import { decideInteraction, InteractionProtocolError, projectPendingInteraction, validatePendingInteractionDto, } from './interaction-protocol.js';
 import { GatewayAdmissionPersistence, normalizedBodyHash } from './persistence/admission-persistence.js';
 import { GATEWAY_EVENT_HEARTBEAT_INTERVAL_MS, GATEWAY_EVENT_STREAM_CONTENT_TYPE, GATEWAY_EVENT_STREAM_HEARTBEAT, } from './server.js';
@@ -32,6 +32,9 @@ import { isOAuthAccountProvider, listOAuthAccounts, removeOAuthAccount, setActiv
 import { loginToCodex } from '../providers/codex-auth.js';
 import { loginToGrok } from '../providers/grok-auth.js';
 const MAX_BUFFERED_SSE_EVENTS = 256;
+// How long the replay phase waits for a client that has stopped reading before
+// it is treated as a slow subscriber and closed.
+const SSE_REPLAY_DRAIN_TIMEOUT_MS = 10_000;
 const NONCRITICAL_RUNTIME_EVENT_TYPES = new Set(['text_delta', 'reasoning_delta']);
 let malformedCommandMessageDrops = 0;
 const isCriticalRuntimeEvent = (event) => !NONCRITICAL_RUNTIME_EVENT_TYPES.has(event.type);
@@ -847,6 +850,10 @@ export class Term2Gateway {
             ownerUserId,
             sessionId,
             journal: persisted.persistence.journal,
+            activeTurnId: (() => {
+                const live = this.#sessions.get(sessionId);
+                return live instanceof ServerSession ? live.activeTurnId : null;
+            })(),
             liveInteraction: () => {
                 const session = this.#sessions.get(sessionId);
                 if (!(session instanceof ServerSession))
@@ -1555,12 +1562,19 @@ export class Term2Gateway {
             });
             this.#interactionBindings.delete(claims.sessionId);
             this.#countInteraction('interaction_resolved');
+            // A multi-question ask_user collects one answer per request; the resolved
+            // result carries all of them (in question order), while this request only
+            // carries the last. A single question keeps the answer as sent so its
+            // tool result format does not change.
+            const toolApprovalAnswer = (binding.dto.askUser?.questions.length ?? 0) > 1 && result.approvalAnswer !== undefined
+                ? result.approvalAnswer
+                : decision.approvalAnswer;
             try {
                 if (session.abortGeneration !== continuationAbortGeneration || session.activeTurnId !== binding.turnId) {
                     throw new ServerSessionError('interrupted');
                 }
                 await session.service.handleApprovalDecision(decision.answer, decision.rejectionReason, {
-                    approvalAnswer: decision.approvalAnswer,
+                    approvalAnswer: toolApprovalAnswer,
                     // Cancelling an ask_user question ends the turn, exactly as Escape
                     // does in the TUI: the question and its unanswered result stay in
                     // history, and the user speaks next. Without this the web client's
@@ -1598,7 +1612,11 @@ export class Term2Gateway {
         if (after.error)
             return publicError(400, after.error, 'event cursor is invalid');
         const source = await this.#projectionFor(claims.sub, claims.sessionId);
+        // `activeResponse` is the socket to destroy; `liveWrites` flips on only once
+        // the replay and every event queued behind it have been written, so live
+        // events never overtake the replay.
         let activeResponse = null;
+        let liveWrites = false;
         let closed = false;
         let buffered = [];
         let unsubscribe = () => undefined;
@@ -1620,7 +1638,7 @@ export class Term2Gateway {
         const live = source.subscribeFrom(after.value, (event) => {
             if (closed)
                 return;
-            if (!activeResponse) {
+            if (!liveWrites || !activeResponse) {
                 if (buffered.length >= MAX_BUFFERED_SSE_EVENTS)
                     return closeSlowSubscriber();
                 buffered.push(event);
@@ -1654,18 +1672,59 @@ export class Term2Gateway {
             stream: {
                 start: async (response, request) => {
                     activeResponse = response;
+                    // The replay can be much larger than the socket's write buffer (a
+                    // reload mid-way through a long turn replays the whole turn), so wait
+                    // for drain between writes. A client that stops reading for
+                    // SSE_REPLAY_DRAIN_TIMEOUT_MS is still closed as a slow subscriber.
+                    // Live events that arrive meanwhile queue in `buffered` (bounded by
+                    // MAX_BUFFERED_SSE_EVENTS) and are written after the replay, in order.
+                    const writeAwaitingDrain = async (event) => {
+                        if (!isPublicEventEnvelope(event))
+                            return closeSlowSubscriber();
+                        if (response.write(`id: ${event.id}\ndata: ${JSON.stringify(event)}\n\n`))
+                            return;
+                        await new Promise((resolve) => {
+                            const finish = () => {
+                                clearTimeout(timer);
+                                response.off('drain', finish);
+                                response.off('close', finish);
+                                resolve();
+                            };
+                            const timer = setTimeout(() => {
+                                closeSlowSubscriber();
+                                finish();
+                            }, SSE_REPLAY_DRAIN_TIMEOUT_MS);
+                            response.once('drain', finish);
+                            response.once('close', finish);
+                        });
+                    };
+                    request.once('close', () => {
+                        closed = true;
+                    });
+                    response.once('close', () => {
+                        closed = true;
+                    });
                     for (const event of live.replay) {
                         if (closed)
                             break;
-                        writeEvent(response, event);
+                        await writeAwaitingDrain(event);
                     }
-                    const queued = buffered;
-                    buffered = [];
-                    for (const event of queued) {
-                        if (closed)
-                            break;
-                        writeEvent(response, event);
+                    while (!closed && buffered.length > 0) {
+                        const queued = buffered;
+                        buffered = [];
+                        for (const event of queued) {
+                            if (closed)
+                                break;
+                            await writeAwaitingDrain(event);
+                        }
                     }
+                    if (closed) {
+                        unsubscribe();
+                        return;
+                    }
+                    // No await between the last empty check and this flag, so nothing
+                    // can be queued after it and left unwritten.
+                    liveWrites = true;
                     const heartbeat = setInterval(() => {
                         if (!response.writableEnded) {
                             const accepted = response.write(`${GATEWAY_EVENT_STREAM_HEARTBEAT} ${new Date().toISOString()}\n\n`);
@@ -2777,8 +2836,8 @@ function commandMessagePayload(input) {
         return null;
     }
     return {
-        callId: boundedText(callId, 256),
-        toolName: boundedText(toolName, 256),
+        callId: wireCallId(callId),
+        toolName: projectionText(toolName, 256),
         status,
         ...(typeof message.output === 'string' ? { output: boundedText(message.output, 16_384) } : {}),
         ...(typeof message.failureReason === 'string' ? { error: boundedText(message.failureReason, 10_000) } : {}),
@@ -2836,7 +2895,74 @@ function sanitizePublicInteraction(value) {
     return validatePendingInteractionDto(value);
 }
 const PROJECTION_COMMAND_STATUSES = new Set(['completed', 'failed', 'aborted', 'unknown']);
-function projectTranscriptMessages(transcript, journalCommands) {
+const PROJECTION_COMMAND_OUTPUT_MAX = 16_384;
+const PROJECTION_COMMAND_ERROR_MAX = 10_000;
+// Same credential shapes the event journal refuses to persist (event-journal.ts
+// assertSafePayload). A ledger-only body skips that check, so apply it here.
+const PROJECTION_CREDENTIAL_PATTERN = /^Bearer\s+|^sk-[A-Za-z0-9]/u;
+const PROJECTION_WITHHELD_MARKER = '[output withheld: looks like a credential]';
+// Total characters of command output + error one projection may carry. Bodies
+// beyond it are cut, newest turns first, so the response stays far below the
+// BFF's 32 MiB cap (worst case a few times this once JSON-escaped).
+const PROJECTION_COMMAND_BODY_BUDGET = 2 * 1024 * 1024;
+const PROJECTION_TRUNCATED_MARKER = '[truncated: session transcript size limit]';
+// The web client's transcript validator rejects NUL and DEL anywhere in a string,
+// so projected text carrying them would make the whole session unreadable.
+function projectionText(value, max) {
+    return boundedText(value, max).replace(/[\u0000\u007f]/gu, '\uFFFD');
+}
+function projectionCommandText(value, max) {
+    const bounded = projectionText(value, max);
+    if (bounded.length === 0)
+        return undefined;
+    return PROJECTION_CREDENTIAL_PATTERN.test(bounded) ? PROJECTION_WITHHELD_MARKER : bounded;
+}
+function projectionCommandDetails(output, error) {
+    const projectedOutput = projectionCommandText(output, PROJECTION_COMMAND_OUTPUT_MAX);
+    const projectedError = projectionCommandText(error, PROJECTION_COMMAND_ERROR_MAX);
+    return {
+        // A rejected approval records the same sentence as output and as failure
+        // reason; show it once.
+        ...(projectedOutput && projectedOutput !== projectedError ? { output: projectedOutput } : {}),
+        ...(projectedError ? { error: projectedError } : {}),
+    };
+}
+function fitToBudget(text, max, budget) {
+    if (text.length <= budget.remaining) {
+        budget.remaining -= text.length;
+        return text;
+    }
+    const keep = Math.max(0, Math.min(budget.remaining, max - PROJECTION_TRUNCATED_MARKER.length - 1));
+    budget.remaining = 0;
+    return keep > 0 ? `${text.slice(0, keep)}\n${PROJECTION_TRUNCATED_MARKER}` : PROJECTION_TRUNCATED_MARKER;
+}
+// Walk the kept messages newest first and spend the budget on their command bodies.
+// A body that no longer fits is cut and ends with a visible marker.
+function applyCommandBodyBudget(messages) {
+    const budget = { remaining: PROJECTION_COMMAND_BODY_BUDGET };
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const commands = messages[i].commands;
+        if (!commands)
+            continue;
+        const fitted = [...commands];
+        for (let j = fitted.length - 1; j >= 0; j--) {
+            const { output, error } = fitted[j];
+            if (output === undefined && error === undefined)
+                continue;
+            // Charge the short error first so a large output cannot use up its budget.
+            const fittedError = error !== undefined ? fitToBudget(error, PROJECTION_COMMAND_ERROR_MAX, budget) : undefined;
+            const fittedOutput = output !== undefined ? fitToBudget(output, PROJECTION_COMMAND_OUTPUT_MAX, budget) : undefined;
+            fitted[j] = {
+                ...fitted[j],
+                ...(fittedOutput !== undefined ? { output: fittedOutput } : {}),
+                ...(fittedError !== undefined ? { error: fittedError } : {}),
+            };
+        }
+        messages[i] = { ...messages[i], commands: fitted };
+    }
+    return messages;
+}
+function projectTranscriptMessages(transcript, journalCommands, abortedTurns) {
     if (!transcript)
         return [];
     const commandsByTurn = new Map();
@@ -2850,14 +2976,22 @@ function projectTranscriptMessages(transcript, journalCommands) {
         if (!PROJECTION_COMMAND_STATUSES.has(command.status))
             continue;
         addCommand(command.turnId, {
-            callId: boundedText(command.callId, 256),
+            callId: wireCallId(command.callId),
             toolName: boundedText(command.toolName, 256),
             status: boundedText(command.status, 32),
+            ...projectionCommandDetails(command.output, command.failureReason),
         });
     }
     for (const [turnId, commands] of journalCommands) {
-        for (const command of commands) {
-            const existing = commandsByTurn.get(turnId)?.find((candidate) => candidate.callId === command.callId);
+        for (const journalCommand of commands) {
+            const existing = commandsByTurn.get(turnId)?.find((candidate) => candidate.callId === journalCommand.callId);
+            // The journal owns status; the result body comes from the journal when it
+            // recorded one, otherwise from the transcript ledger.
+            const { output, error, ...journalBase } = journalCommand;
+            const command = {
+                ...journalBase,
+                ...projectionCommandDetails(output ?? existing?.output, error ?? existing?.error),
+            };
             if (existing) {
                 const current = commandsByTurn.get(turnId);
                 commandsByTurn.set(turnId, current.map((candidate) => (candidate.callId === command.callId ? command : candidate)));
@@ -2869,12 +3003,41 @@ function projectTranscriptMessages(transcript, journalCommands) {
     }
     const projected = [];
     let currentTurnId = null;
+    let currentTurnHasReply = false;
     const attachedTurns = new Set();
+    const botMessage = (id, text) => {
+        const projectedMessage = {
+            id: boundedText(id, 256),
+            role: 'bot',
+            text: projectionText(text, 16_384),
+        };
+        const commands = currentTurnId ? commandsByTurn.get(currentTurnId) : undefined;
+        if (commands && commands.length > 0 && !attachedTurns.has(currentTurnId)) {
+            // Ledger, journal and transcript commands all end up here, so this is the one place their names are cleaned.
+            projectedMessage.commands = commands.map((command) => ({
+                ...command,
+                toolName: projectionText(command.toolName, 256),
+            }));
+            attachedTurns.add(currentTurnId);
+        }
+        return projectedMessage;
+    };
+    // A stopped turn settles only the journal, so the transcript holds its user
+    // message and at most a synthetic "interrupted" note. Project the journal's
+    // partial answer in that note's place, marked as stopped.
+    const flushAbortedTurn = () => {
+        const partial = currentTurnId && !currentTurnHasReply ? abortedTurns.get(currentTurnId) : undefined;
+        if (partial === undefined)
+            return;
+        projected.push({ ...botMessage(`aborted-${currentTurnId}`, partial), status: 'aborted' });
+    };
     for (const message of transcript.messages) {
         const record = message;
         const sender = typeof record.sender === 'string' ? record.sender : record.role;
         if (sender === 'user') {
+            flushAbortedTurn();
             currentTurnId = typeof record.id === 'string' ? record.id : null;
+            currentTurnHasReply = false;
         }
         if (sender === 'command' || sender === 'reasoning') {
             if (sender === 'command' &&
@@ -2882,38 +3045,45 @@ function projectTranscriptMessages(transcript, journalCommands) {
                 typeof record.callId === 'string' &&
                 typeof record.toolName === 'string' &&
                 typeof record.status === 'string' &&
-                !commandsByTurn.get(currentTurnId)?.some((command) => command.callId === record.callId)) {
+                !commandsByTurn.get(currentTurnId)?.some((command) => command.callId === wireCallId(String(record.callId)))) {
                 addCommand(currentTurnId, {
-                    callId: boundedText(record.callId, 256),
+                    callId: wireCallId(record.callId),
                     toolName: boundedText(record.toolName, 256),
                     status: boundedText(record.status, 32),
+                    ...projectionCommandDetails(record.output, record.failureReason),
                 });
             }
             continue;
         }
-        const role = sender === 'user' ? 'user' : 'bot';
-        const projectedMessage = {
-            id: boundedText(record.id, 256),
-            role,
-            text: boundedText(record.text, 16_384),
-        };
-        const commands = role === 'bot' && currentTurnId ? commandsByTurn.get(currentTurnId) : undefined;
-        if (commands && commands.length > 0 && !attachedTurns.has(currentTurnId)) {
-            projectedMessage.commands = commands;
-            attachedTurns.add(currentTurnId);
+        if (sender === 'bot')
+            currentTurnHasReply = true;
+        if (sender === 'system' &&
+            currentTurnId &&
+            !currentTurnHasReply &&
+            abortedTurns.has(currentTurnId) &&
+            typeof record.id === 'string' &&
+            record.id.startsWith('system-interrupted-'))
+            continue;
+        if (sender === 'user') {
+            projected.push({ id: boundedText(record.id, 256), role: 'user', text: projectionText(record.text, 16_384) });
+        }
+        else {
+            projected.push(botMessage(record.id, record.text));
         }
-        projected.push(projectedMessage);
     }
-    return projected.slice(-200);
+    flushAbortedTurn();
+    return applyCommandBodyBudget(projected.slice(-200));
 }
 /**
  * Session transcript wire shape: messages have `id`, `role` (`user` or `bot`),
  * and bounded `text`. A completed turn's first bot message may carry a bounded
- * `commands` array of `{callId, toolName, status}` entries for its tool cards.
+ * `commands` array of `{callId, toolName, status, output?, error?}` entries for
+ * its tool cards. `output` and `error` are bounded per command and by one total
+ * budget per projection (newest first); a cut body ends with a visible marker.
  */
 function toSessionProjection(source) {
     const transcript = source.transcript;
-    const messages = projectTranscriptMessages(transcript, source.journalCommands);
+    const messages = projectTranscriptMessages(transcript, source.journalCommands, source.abortedTurns);
     const interaction = source.interaction
         ? {
             ...source.interaction,
@@ -2980,7 +3150,7 @@ export function mapConversationEvent(event, turnId, sessionId, interactionBindin
             return {
                 ...base,
                 type: 'tool_started',
-                payload: { turnId, callId: event.toolCallId, toolName: boundedText(event.toolName, 256) },
+                payload: { turnId, callId: wireCallId(event.toolCallId), toolName: projectionText(event.toolName, 256) },
             };
         case 'command_message':
             return commandMessageCandidate(base, event.message, 'command_message');
@@ -3073,7 +3243,7 @@ export function mapConversationEvent(event, turnId, sessionId, interactionBindin
                     turnId,
                     agentId: boundedText(event.agentId, 256),
                     role: boundedText(event.role, 256),
-                    toolCallId: boundedText(event.toolCallId, 256),
+                    toolCallId: wireCallId(event.toolCallId),
                     toolName: boundedText(event.toolName, 256),
                     ...(event.commandMessages
                         ? {