The open-source agent harness - the runtime layer that turns an LLM into a working agent.
bugfix: implement subscribe-retry mechanism for SSE drops in turn streaming (#973)
harshil-2096d01ddc0a11e1
diff --git a/.changeset/subscribe-retry-on-sse-drop.md b/.changeset/subscribe-retry-on-sse-drop.mdnew file mode 100644index 000000000..7e7065b9d--- /dev/null+++ b/.changeset/subscribe-retry-on-sse-drop.md@@ -0,0 +1,5 @@+---+'@truefoundry/trueforge-assistant-ui-runtime': patch+---++Reattach a live turn via subscribe after create/subscribe SSE drops, using the last ingested sequence number so the composer stays running instead of toasting a network error.diff --git a/packages/assistant-ui-runtime/src/convertTurnMessages.ts b/packages/assistant-ui-runtime/src/convertTurnMessages.tsindex a8878a5bd..93dc9e459 100644--- a/packages/assistant-ui-runtime/src/convertTurnMessages.ts+++ b/packages/assistant-ui-runtime/src/convertTurnMessages.ts@@ -1628,23 +1628,43 @@ function buildMcpAuthUpdate(};}+/** Terminal `turn.done` with `status: error`. Not a transport drop — do not subscribe-retry. */+export class TurnFailedError extends Error {+ constructor(message: string) {+ super(message);+ this.name = 'TurnFailedError';+ }+}++/** SSE body ended without `turn.done` or a pause — subscribe-retry. */+export class TurnStreamDisconnectedError extends Error {+ constructor(message = 'Turn stream closed before turn.done') {+ super(message);+ this.name = 'TurnStreamDisconnectedError';+ }+}+export async function* streamTurnEvents(stream: AsyncIterable<TurnStreamData>,foldState: PeerThreadFoldState,groupRootBaseline?: readonly string[],onTurnIdAvailable?: (turnId: string) => void,+ onSequenceNumber?: (sequenceNumber: number) => void,): AsyncGenerator<TurnStreamUpdate> {let pendingMcpAuth: McpAuthRequiredEvent | undefined;let sandboxId: string | undefined;let sandboxIdYielded = false;+ let lastSequenceNumber: number | undefined;+ let sawTurnDone = false;- const withSandbox = (update: TurnStreamUpdate): TurnStreamUpdate => {+ const withCursor = (update: TurnStreamUpdate): TurnStreamUpdate => {+ const withSeq = lastSequenceNumber == null ? update : { ...update, sequenceNumber: lastSequenceNumber };if (sandboxId == null) {- return update;+ return withSeq;}return {- ...update,- metadata: { ...update.metadata, custom: { ...update.metadata?.custom, sandboxId } },+ ...withSeq,+ metadata: { ...withSeq.metadata, custom: { ...withSeq.metadata?.custom, sandboxId } },};};@@ -1658,6 +1678,8 @@ export async function* streamTurnEvents(};for await (const data of stream) {+ lastSequenceNumber = data.sequenceNumber;+ onSequenceNumber?.(data.sequenceNumber);const event = data.event;if (event.type === 'turn.created') {@@ -1677,7 +1699,7 @@ export async function* streamTurnEvents(if (event.type === 'turn.done') {if (event.state.status === 'error') {- throw new Error(event.state.message);+ throw new TurnFailedError(event.state.message);}// The turn is logically complete once `turn.done` is observed. The// resumed-turn transport (`subscribeToTurn`) is a reconnectable live@@ -1685,6 +1707,7 @@ export async function* streamTurnEvents(// event, so we must stop consuming explicitly rather than waiting// for the underlying stream to end — otherwise `isRunning` never// clears and the composer's cancel/spinner button gets stuck.+ sawTurnDone = true;break;}@@ -1697,12 +1720,12 @@ export async function* streamTurnEvents(if (sandboxId != null) {sandboxIdYielded = true;}- yield withSandbox({ content });+ yield withCursor({ content });}}if (pendingMcpAuth != null) {- yield withSandbox(buildMcpAuthUpdate(pendingMcpAuth, foldState, groupRootBaseline));+ yield withCursor(buildMcpAuthUpdate(pendingMcpAuth, foldState, groupRootBaseline));return;}@@ -1726,7 +1749,7 @@ export async function* streamTurnEvents(groupRootBaseline != null? rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline): (foldState.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? []);- yield withSandbox({+ yield withCursor({content: buildRootAssistantContentForIds(foldState, ids),status: approvalThreadId != null ? toolApprovalStatus() : toolResponseStatus(),metadata: { custom },@@ -1739,7 +1762,11 @@ export async function* streamTurnEvents(groupRootBaseline != null? rootModelMessageIdsSinceBaseline(foldState, groupRootBaseline): (foldState.threads.get(ROOT_THREAD_ID)?.modelMessageIds ?? []);- yield withSandbox({ content: buildRootAssistantContentForIds(foldState, ids) });+ yield withCursor({ content: buildRootAssistantContentForIds(foldState, ids) });+ }++ if (!sawTurnDone) {+ throw new TurnStreamDisconnectedError();}}diff --git a/packages/assistant-ui-runtime/src/sessionSnapshot.ts b/packages/assistant-ui-runtime/src/sessionSnapshot.tsindex b0085141d..e3b4006c1 100644--- a/packages/assistant-ui-runtime/src/sessionSnapshot.ts+++ b/packages/assistant-ui-runtime/src/sessionSnapshot.ts@@ -46,6 +46,8 @@ export interface ActiveStreamState {update: TurnStreamUpdate;isContinuation: boolean;streamComplete?: boolean | undefined;+ /** Exclusive subscribe cursor; events after this sequence are replayed on reconnect. */+ lastSequenceNumber?: number | undefined;}export interface PendingUserMessage {diff --git a/packages/assistant-ui-runtime/src/streamReconnect.ts b/packages/assistant-ui-runtime/src/streamReconnect.tsnew file mode 100644index 000000000..fa65a84d2--- /dev/null+++ b/packages/assistant-ui-runtime/src/streamReconnect.ts@@ -0,0 +1,39 @@+/** Consecutive subscribe attempts after a live SSE drop before the UI reports failure. */+export const STREAM_RECONNECT_MAX_ATTEMPTS = 3;++/** Abortable pause between reconnect attempts. */+export const STREAM_RECONNECT_DELAY_MS = 500;++export function isAbortError(error: unknown): boolean {+ return error instanceof Error && error.name === 'AbortError';+}++export function createAbortError(): Error {+ const error = new Error('Aborted');+ error.name = 'AbortError';+ return error;+}++export function throwIfAborted(signal: AbortSignal): void {+ if (signal.aborted) {+ throw createAbortError();+ }+}++export async function delayReconnect(signal: AbortSignal, delayMs = STREAM_RECONNECT_DELAY_MS): Promise<void> {+ throwIfAborted(signal);+ if (delayMs <= 0) {+ return;+ }+ await new Promise<void>((resolve, reject) => {+ const timer = setTimeout(() => {+ signal.removeEventListener('abort', onAbort);+ resolve();+ }, delayMs);+ const onAbort = (): void => {+ clearTimeout(timer);+ reject(createAbortError());+ };+ signal.addEventListener('abort', onAbort, { once: true });+ });+}diff --git a/packages/assistant-ui-runtime/src/streamTurn.ts b/packages/assistant-ui-runtime/src/streamTurn.tsindex 8e6c3977b..f2e307cae 100644--- a/packages/assistant-ui-runtime/src/streamTurn.ts+++ b/packages/assistant-ui-runtime/src/streamTurn.ts@@ -4,6 +4,7 @@ import type { AgentChatServer, PreviousTurnIdInput, TurnInputItem } from './servimport { streamTurnEvents, type UserMessageContent } from './convertTurnMessages.js';import { PeerThreadFoldState } from './foldPeerThreads.js';import type { RequiredActionInput } from './requiredActionInputs.js';+import { throwIfAborted } from './streamReconnect.js';import type { TurnStreamUpdate } from './turnStreamUpdate.js';export interface StreamTurnOptions {@@ -42,13 +43,12 @@ export async function* streamTurnContent(* optimistic ID with the real turn ID.*/onTurnIdAvailable?: (turnId: string) => void,+ onSequenceNumber?: (sequenceNumber: number) => void,): AsyncGenerator<TurnStreamUpdate> {// Aborting only detaches this client from the run; the turn keeps running on// the backend so switching sessions (or remounting) can reattach via// `subscribeToTurn`. Stopping the run is an explicit `cancelSession` call.- if (abortSignal.aborted) {- return;- }+ throwIfAborted(abortSignal);let turnIdNotified = false;const notifyTurnId = (turnId: string) => {@@ -66,19 +66,9 @@ export async function* streamTurnContent(...(options.headers != null ? { headers: options.headers } : {}),});- try {- for await (const update of streamTurnEvents(stream, foldState, groupRootBaseline, notifyTurnId)) {- yield update;- }- } catch (error) {- if (error instanceof Error && error.name === 'AbortError') {- return;- }- throw error;- }+ yield* streamTurnEvents(stream, foldState, groupRootBaseline, notifyTurnId, onSequenceNumber);}-/** TODO: wire `afterSequenceNumber` from the last ingested stream event to skip replay on reconnect. */export async function* resumeTurnStream(server: AgentChatServer,sessionId: string,@@ -87,6 +77,7 @@ export async function* resumeTurnStream(abortSignal: AbortSignal,afterSequenceNumber?: number,groupRootBaseline?: readonly string[],+ onSequenceNumber?: (sequenceNumber: number) => void,): AsyncGenerator<TurnStreamUpdate> {// Optional on custom backends. Callers detect the gap and report it, so an// empty stream here is safer than throwing mid-render.@@ -94,25 +85,18 @@ export async function* resumeTurnStream(return;}- if (abortSignal.aborted) {- return;- }+ throwIfAborted(abortSignal);- try {- yield* streamTurnEvents(- server.subscribeToTurn({- sessionId,- turnId,- ...(afterSequenceNumber != null ? { afterSequenceNumber } : {}),- abortSignal,- }),- foldState,- groupRootBaseline,- );- } catch (error) {- if (error instanceof Error && error.name === 'AbortError') {- return;- }- throw error;- }+ yield* streamTurnEvents(+ server.subscribeToTurn({+ sessionId,+ turnId,+ ...(afterSequenceNumber != null ? { afterSequenceNumber } : {}),+ abortSignal,+ }),+ foldState,+ groupRootBaseline,+ undefined,+ onSequenceNumber,+ );}diff --git a/packages/assistant-ui-runtime/src/turnStreamUpdate.ts b/packages/assistant-ui-runtime/src/turnStreamUpdate.tsindex 2a99a5615..8ee091275 100644--- a/packages/assistant-ui-runtime/src/turnStreamUpdate.ts+++ b/packages/assistant-ui-runtime/src/turnStreamUpdate.ts@@ -5,6 +5,8 @@ import type { AssistantContentPart } from './modelMessageContent.js';export interface TurnStreamUpdate {content: AssistantContentPart[];status?: MessageStatus;+ /** Last SSE sequence number observed for this update (reconnect cursor). */+ sequenceNumber?: number;metadata?: {custom?: Record<string, unknown>;};diff --git a/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts b/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.tsindex b5b2bbaf3..27a6730c8 100644--- a/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts+++ b/packages/assistant-ui-runtime/src/useTrueForgeAgentMessages.ts@@ -22,6 +22,7 @@ import {projectSessionMessages,resolveGatewayBranchPreviousTurnIdForTurn,rootModelMessageIdsSinceBaseline,+ TurnFailedError,userMessageContentToText,type UserMessageContent,} from './convertTurnMessages.js';@@ -43,6 +44,7 @@ import {type SessionSnapshot,type SessionTurnRecord,} from './sessionSnapshot.js';+import { delayReconnect, isAbortError, STREAM_RECONNECT_MAX_ATTEMPTS } from './streamReconnect.js';import { resumeTurnStream, streamTurnContent } from './streamTurn.js';import { TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY, type RespondToToolApprovalOptions } from './toolApproval.js';import {@@ -428,6 +430,15 @@ function resolveTurnInput(snapshot: SessionSnapshot, turnId: string): TurnInputIreturn undefined;}+interface StreamSequenceTrack {+ onSequenceNumber: (sequenceNumber: number) => void;+}++interface RunStreamReconnect {+ sessionId: string;+ gatewayTurnAccepted: { current: boolean };+}+export function useTrueForgeAgentMessages({server,sessionId,@@ -475,6 +486,8 @@ export function useTrueForgeAgentMessages({const runningTurnRef = useRef<Turn | undefined>(undefined);const loadGenerationRef = useRef(0);const streamGenerationRef = useRef(0);+ const streamReconnectPendingRef = useRef(false);+ const cancelRequestedRef = useRef(false);const lazilyCreatedSessionIdRef = useRef<string | undefined>(undefined);const initialLoadStartedForRef = useRef<string | undefined>(undefined);const skipInitialPromotionLoadForRef = useRef<string | undefined>(undefined);@@ -508,7 +521,7 @@ export function useTrueForgeAgentMessages({const runStream = useCallback((- createStream: (signal: AbortSignal) => AsyncGenerator<TurnStreamUpdate>,+ createStream: (signal: AbortSignal, track: StreamSequenceTrack) => AsyncGenerator<TurnStreamUpdate>,/*** A mutable ref whose `.current` is the turn ID to use for* `activeStream.turnId`. Callers that capture the gateway turn ID@@ -518,11 +531,13 @@ export function useTrueForgeAgentMessages({*/turnIdRef: { current: string },isContinuation: boolean,+ reconnect: RunStreamReconnect,): Promise<void> => {const streamGeneration = ++streamGenerationRef.current;abortControllerRef.current?.abort();const abortController = new AbortController();abortControllerRef.current = abortController;+ cancelRequestedRef.current = false;setIsRunning(true);// This stream's `finally` owns the running flag from here on.markResumeUnavailable(false);@@ -536,6 +551,18 @@ export function useTrueForgeAgentMessages({isContinuation: boolean;} | null = null;let streamUpdateRaf: number | null = null;+ const lastSequenceNumberRef: { current: number | undefined } = {+ current: snapshotRef.current.activeStream?.lastSequenceNumber,+ };+ let useSubscribe = false;+ let consecutiveFailures = 0;++ const track: StreamSequenceTrack = {+ onSequenceNumber: sequenceNumber => {+ lastSequenceNumberRef.current = sequenceNumber;+ consecutiveFailures = 0;+ },+ };const flushPendingStreamUpdate = () => {streamUpdateRaf = null;@@ -554,30 +581,82 @@ export function useTrueForgeAgentMessages({turnId: turnIdRef.current,update,isContinuation: pendingIsContinuation,+ ...(lastSequenceNumberRef.current != null ? { lastSequenceNumber: lastSequenceNumberRef.current } : {}),},}),);};const applyStreamUpdate = (update: TurnStreamUpdate) => {+ if (update.sequenceNumber != null) {+ lastSequenceNumberRef.current = update.sequenceNumber;+ consecutiveFailures = 0;+ }pendingStreamUpdate = { update, isContinuation };streamUpdateRaf ??= requestAnimationFrame(flushPendingStreamUpdate);};+ const readStream = (signal: AbortSignal): AsyncGenerator<TurnStreamUpdate> => {+ if (!useSubscribe) {+ return createStream(signal, track);+ }+ return resumeTurnStream(+ server,+ reconnect.sessionId,+ turnIdRef.current,+ snapshotRef.current.fold,+ signal,+ lastSequenceNumberRef.current,+ snapshotRef.current.groupRootBaseline,+ track.onSequenceNumber,+ );+ };+try {- for await (const update of createStream(abortController.signal)) {- if (abortController.signal.aborted) {+ while (streamGeneration === streamGenerationRef.current) {+ try {+ for await (const update of readStream(abortController.signal)) {+ if (streamGeneration !== streamGenerationRef.current) {+ return;+ }+ applyStreamUpdate(update);+ }return;+ } catch (error) {+ if (isAbortError(error) || streamGeneration !== streamGenerationRef.current) {+ return;+ }+ // Cancel keeps consuming a healthy live SSE for turn.done. A+ // drop after cancelSession must not start subscribe-retry.+ if (cancelRequestedRef.current) {+ abortController.abort();+ return;+ }+ const canSubscribe =+ server.subscribeToTurn != null &&+ reconnect.gatewayTurnAccepted.current &&+ !(error instanceof TurnFailedError);+ if (!canSubscribe || consecutiveFailures >= STREAM_RECONNECT_MAX_ATTEMPTS) {+ onErrorRef.current?.(error);+ throw error;+ }+ consecutiveFailures += 1;+ useSubscribe = true;+ // Stay pending through delay and the subscribe attempt so+ // cancel aborts a reconnect SSE, not only the wait.+ streamReconnectPendingRef.current = true;+ try {+ await delayReconnect(abortController.signal);+ } catch (error) {+ if (isAbortError(error) || streamGeneration !== streamGenerationRef.current) {+ return;+ }+ throw error;+ }}- applyStreamUpdate(update);}- } catch (error) {- if (error instanceof Error && error.name === 'AbortError') {- return;- }- onErrorRef.current?.(error);- throw error;} finally {+ streamReconnectPendingRef.current = false;cancelScheduledAnimationFrame(streamUpdateRaf);if (streamGeneration === streamGenerationRef.current) {flushPendingStreamUpdate();@@ -585,22 +664,29 @@ export function useTrueForgeAgentMessages({abortControllerRef.current = null;}setIsRunning(false);- setSnapshot(prev => {- if (prev.activeStream == null) {- return prev;- }- const marked = replaceSessionSnapshot(prev, {- activeStream: {- ...prev.activeStream,- streamComplete: true,- },- requiredActions: {- approvals: new Map(),- toolResponses: new Map(),- },+ if (abortController.signal.aborted) {+ setSnapshot(prev => abandonInFlightClientTurn(prev));+ } else {+ setSnapshot(prev => {+ if (prev.activeStream == null) {+ return prev;+ }+ const marked = replaceSessionSnapshot(prev, {+ activeStream: {+ ...prev.activeStream,+ streamComplete: true,+ ...(lastSequenceNumberRef.current != null+ ? { lastSequenceNumber: lastSequenceNumberRef.current }+ : {}),+ },+ requiredActions: {+ approvals: new Map(),+ toolResponses: new Map(),+ },+ });+ return commitActiveStream(marked);});- return commitActiveStream(marked);- });+ }}}})();@@ -616,7 +702,7 @@ export function useTrueForgeAgentMessages({});return run;},- [onError],+ [markResumeUnavailable, server],);const load = useCallback(async () => {@@ -703,23 +789,24 @@ export function useTrueForgeAgentMessages({}const isContinuation = extractTurnUserText(turn.input) === undefined;- // TODO: pass afterSequenceNumber once stream ingestion tracks sequence numbers.// Use loadedSnapshot directly — snapshotRef.current still points at// the empty snapshot cleared above until the setSnapshot(loadedSnapshot)// call re-renders.void runStream(- signal =>+ (signal, track) =>resumeTurnStream(server,conversationSessionId,turn.id,loadedSnapshot.fold,signal,- undefined,+ loadedSnapshot.activeStream?.lastSequenceNumber,loadedSnapshot.groupRootBaseline,+ track.onSequenceNumber,),{ current: turn.id },isContinuation,+ { sessionId: conversationSessionId, gatewayTurnAccepted: { current: true } },).catch(() => undefined);}} catch (error) {@@ -899,7 +986,7 @@ export function useTrueForgeAgentMessages({runStreamStarted = true;await runStream(- signal => {+ (signal, track) => {if ('inputs' in options) {return streamTurnContent(server,@@ -909,6 +996,7 @@ export function useTrueForgeAgentMessages({signal,groupRootBaseline,handleGatewayTurnId,+ track.onSequenceNumber,);}if ('resumeMcpAuth' in options) {@@ -920,6 +1008,7 @@ export function useTrueForgeAgentMessages({signal,groupRootBaseline,handleGatewayTurnId,+ track.onSequenceNumber,);}return streamTurnContent(@@ -938,10 +1027,12 @@ export function useTrueForgeAgentMessages({signal,groupRootBaseline,handleGatewayTurnId,+ track.onSequenceNumber,);},turnIdRef,isContinuation,+ { sessionId: conversationSessionId, gatewayTurnAccepted },);} catch (error) {if (!runStreamStarted && sendGeneration !== streamGenerationRef.current) {@@ -996,18 +1087,18 @@ export function useTrueForgeAgentMessages({abortControllerRef.current?.abort();return;}+ cancelRequestedRef.current = true;const conversationSessionId = await resolveActiveSessionId(activeSessionId,resolveConversationSessionIdRef.current,);- // Request cancellation but keep consuming the stream. After cancel(),- // the backend gracefully closes the SSE stream: it emits a terminal- // turn.done event and then ends the stream, which lets the active run- // drain to completion on its own instead of being torn down mid-flight.+ // Drain a healthy live SSE for cancelled turn.done. Abort reconnect+ // waits and reconnect subscribe so cancel cannot start or keep a new+ // subscribe after the live stream dropped.+ if (streamReconnectPendingRef.current) {+ abortControllerRef.current?.abort();+ }await server.cancelSession({ sessionId: conversationSessionId }).catch(() => undefined);- // Wait for the in-flight stream to finish draining. No explicit- // reconcile is needed here — the cancelled turn is terminal and local- // state reconciles against the event log on the next session load.await activeRunRef.current?.catch(() => undefined);markResumeUnavailable(false);setIsRunning(false);@@ -1081,22 +1172,27 @@ export function useTrueForgeAgentMessages({markResumeUnavailable(true);return;}- // TODO: pass afterSequenceNumber once stream ingestion tracks sequence numbers.+ const resumeSessionId = turn.sessionId !== '' ? turn.sessionId : sessionId;+ if (resumeSessionId == null) {+ return;+ }await runStream(- signal =>+ (signal, track) =>resumeTurnStream(server,- turn.sessionId,+ resumeSessionId,turn.id,snapshotRef.current.fold,signal,- undefined,+ snapshotRef.current.activeStream?.lastSequenceNumber,snapshotRef.current.groupRootBaseline,+ track.onSequenceNumber,),{ current: turn.id },true,+ { sessionId: resumeSessionId, gatewayTurnAccepted: { current: true } },);- }, [runStream, server]);+ }, [runStream, server, sessionId]);const branchFromTurn = useCallback(async (turnId: string, userMessage: UserMessageContent) => {diff --git a/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts b/packages/assistant-ui-runtime/test/convertTurnMessages.test.tsindex 328dce5b2..d0978b6c7 100644--- a/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts+++ b/packages/assistant-ui-runtime/test/convertTurnMessages.test.ts@@ -30,6 +30,7 @@ import {resolveGatewayBranchPreviousTurnIdForTurn,rootModelMessageIdsSinceBaseline,streamTurnEvents,+ TurnStreamDisconnectedError,turnStreamUpdateToAssistantMessage,} from '../src/convertTurnMessages.js';import { buildRootAssistantContent, ingestTurnEvent, PeerThreadFoldState } from '../src/foldPeerThreads.js';@@ -79,6 +80,15 @@ function responseRequired(event: Omit<ToolResponseRequiredEvent, 'type' | 'creatreturn { type: 'tool.response_required', createdAt, ...event };}+function turnDone(id = 'turn-done'): TurnDoneEvent {+ return {+ type: 'turn.done',+ id,+ createdAt,+ state: { status: 'done', requiredActions: [], completedAt: createdAt },+ };+}+async function* streamFrom(events: TurnStreamData['event'][]): AsyncGenerator<TurnStreamData> {for (const [index, event] of events.entries()) {yield { sequenceNumber: index + 1, event };@@ -1461,12 +1471,49 @@ describe('convertTurnMessages', () => {threadId: ROOT_THREAD_ID,content: 'streaming',}),+ turnDone(),+ ]),+ foldState,+ ),+ );++ expect(updates).toEqual([{ content: [{ type: 'text', text: 'streaming' }], sequenceNumber: 1 }]);+ });++ it('reports every stream sequence including events that do not yield UI', async () => {+ const foldState = new PeerThreadFoldState();+ const sequences: number[] = [];+ const onSequenceNumber = vi.fn((sequenceNumber: number) => {+ sequences.push(sequenceNumber);+ });+ const gatewayTurnId = 'turn-gw';++ await collectStream(+ streamTurnEvents(+ streamFrom([+ {+ type: 'turn.created',+ createdAt,+ id: 'created-1',+ turnId: gatewayTurnId,+ input: [{ type: 'user.message', content: 'hello' }],+ },+ modelMessage({+ id: 'm1',+ threadId: ROOT_THREAD_ID,+ content: 'hi',+ }),+ turnDone(),]),foldState,+ undefined,+ undefined,+ onSequenceNumber,),);- expect(updates).toEqual([{ content: [{ type: 'text', text: 'streaming' }] }]);+ expect(sequences).toEqual([1, 2, 3]);+ expect(onSequenceNumber).toHaveBeenCalledTimes(3);});it('yields folded content after each ingested stream event', async () => {@@ -1489,6 +1536,7 @@ describe('convertTurnMessages', () => {threadId: ROOT_THREAD_ID,content: 'third',}),+ turnDone(),]),foldState,),@@ -1528,13 +1576,14 @@ describe('convertTurnMessages', () => {threadId: ROOT_THREAD_ID,content: 'new turn only',}),+ turnDone(),]),foldState,['prior'],),);- expect(updates).toEqual([{ content: [{ type: 'text', text: 'new turn only' }] }]);+ expect(updates).toEqual([{ content: [{ type: 'text', text: 'new turn only' }], sequenceNumber: 1 }]);});it('throws when the turn ends in error', async () => {@@ -1631,6 +1680,7 @@ describe('convertTurnMessages', () => {expect(updates).toHaveLength(2);expect(updates[0]).toEqual({content: [{ type: 'text', text: 'before auth' }],+ sequenceNumber: 1,});expect(updates[1]?.status).toEqual({type: 'requires-action',@@ -1642,6 +1692,24 @@ describe('convertTurnMessages', () => {});});+ it('throws when the SSE body ends without turn.done or a pause', async () => {+ const foldState = new PeerThreadFoldState();+ await expect(+ collectStream(+ streamTurnEvents(+ streamFrom([+ modelMessage({+ id: 'm1',+ threadId: ROOT_THREAD_ID,+ content: 'partial',+ }),+ ]),+ foldState,+ ),+ ),+ ).rejects.toThrow(TurnStreamDisconnectedError);+ });+it('stamps sandboxId onto every content yield after sandbox.created is seen', async () => {const foldState = new PeerThreadFoldState();const updates = await collectStream(@@ -1658,6 +1726,7 @@ describe('convertTurnMessages', () => {threadId: ROOT_THREAD_ID,content: 'after sandbox',}),+ turnDone(),]),foldState,),@@ -1679,6 +1748,7 @@ describe('convertTurnMessages', () => {content: 'some content',}),sandboxCreated({ id: 'sandbox-evt', sandboxId: 'sbx-123' }),+ turnDone(),]),foldState,),@@ -2723,6 +2793,7 @@ describe('buildSnapshotFromSessionEvents', () => {threadId: ROOT_THREAD_ID,content: 'I ran 10 sandbox commands',}),+ turnDone(),]),snapshot.fold,snapshot.groupRootBaseline,diff --git a/packages/assistant-ui-runtime/test/streamReconnect.test.ts b/packages/assistant-ui-runtime/test/streamReconnect.test.tsnew file mode 100644index 000000000..b98881a80--- /dev/null+++ b/packages/assistant-ui-runtime/test/streamReconnect.test.ts@@ -0,0 +1,18 @@+import { describe, expect, it } from 'vitest';++import { delayReconnect } from '../src/streamReconnect.js';++describe('delayReconnect', () => {+ it('rejects with AbortError when the signal is already aborted', async () => {+ const controller = new AbortController();+ controller.abort();+ await expect(delayReconnect(controller.signal, 50)).rejects.toMatchObject({ name: 'AbortError' });+ });++ it('rejects with AbortError when aborted during the wait', async () => {+ const controller = new AbortController();+ const pending = delayReconnect(controller.signal, 50_000);+ controller.abort();+ await expect(pending).rejects.toMatchObject({ name: 'AbortError' });+ });+});diff --git a/packages/assistant-ui-runtime/test/streamTurn.test.ts b/packages/assistant-ui-runtime/test/streamTurn.test.tsindex e0e522580..28187dd59 100644--- a/packages/assistant-ui-runtime/test/streamTurn.test.ts+++ b/packages/assistant-ui-runtime/test/streamTurn.test.ts@@ -3,6 +3,7 @@ import type { AgentChatServer, TurnStreamData } from '../src/server/index.js';import { ROOT_THREAD_ID } from '../src/constants.js';import { PeerThreadFoldState } from '../src/foldPeerThreads.js';+import { createAbortError } from '../src/streamReconnect.js';import { resumeTurnStream, streamTurnContent } from '../src/streamTurn.js';const createdAt = new Date().toISOString();@@ -12,6 +13,15 @@ function streamData(sequenceNumber: number, event: TurnStreamData['event'] | Recreturn { sequenceNumber, event: event as TurnStreamData['event'] };}+function turnDoneEvent(): TurnStreamData['event'] {+ return {+ type: 'turn.done',+ createdAt,+ id: 'done-1',+ state: { status: 'done', requiredActions: [], completedAt: createdAt },+ };+}+function mockServer(partial: Record<string, unknown>): AgentChatServer {return partial as unknown as AgentChatServer;}@@ -36,6 +46,7 @@ describe('streamTurn', () => {threadId: ROOT_THREAD_ID,content: 'hello from stream',});+ yield streamData(2, turnDoneEvent());});const server = mockServer({createTurn,@@ -52,7 +63,7 @@ describe('streamTurn', () => {previousTurnId: 'auto',abortSignal: expect.any(AbortSignal),});- expect(updates).toEqual([{ content: [{ type: 'text', text: 'hello from stream' }] }]);+ expect(updates).toEqual([{ content: [{ type: 'text', text: 'hello from stream' }], sequenceNumber: 1 }]);});it('passes required-action inputs through createTurn', async () => {@@ -70,7 +81,9 @@ describe('streamTurn', () => {content: 'A',},];- const createTurn = vi.fn(async function* () {});+ const createTurn = vi.fn(async function* () {+ yield streamData(1, turnDoneEvent());+ });const server = mockServer({createTurn,cancelSession: vi.fn().mockResolvedValue(undefined),@@ -89,7 +102,9 @@ describe('streamTurn', () => {});it('uses empty input when resuming after MCP auth', async () => {- const createTurn = vi.fn(async function* () {});+ const createTurn = vi.fn(async function* () {+ yield streamData(1, turnDoneEvent());+ });const server = mockServer({createTurn,cancelSession: vi.fn().mockResolvedValue(undefined),@@ -114,7 +129,9 @@ describe('streamTurn', () => {});it('forwards an explicit previousTurnId when branching', async () => {- const createTurn = vi.fn(async function* () {});+ const createTurn = vi.fn(async function* () {+ yield streamData(1, turnDoneEvent());+ });const server = mockServer({createTurn,cancelSession: vi.fn().mockResolvedValue(undefined),@@ -139,7 +156,9 @@ describe('streamTurn', () => {});it('forwards previousTurnId "none" when branching from root', async () => {- const createTurn = vi.fn(async function* () {});+ const createTurn = vi.fn(async function* () {+ yield streamData(1, turnDoneEvent());+ });const server = mockServer({createTurn,cancelSession: vi.fn().mockResolvedValue(undefined),@@ -163,26 +182,27 @@ describe('streamTurn', () => {});});- it('returns early without cancelling the backend run when already aborted', async () => {+ it('throws when already aborted before streaming starts', async () => {const createTurn = vi.fn(async function* () {});const cancelSession = vi.fn().mockResolvedValue(undefined);const server = mockServer({ createTurn, cancelSession });const abortController = new AbortController();abortController.abort();- const updates = await collectUpdates(- streamTurnContent(- server,- SESSION_ID,- new PeerThreadFoldState(),- { userMessage: 'hello' },- abortController.signal,+ await expect(+ collectUpdates(+ streamTurnContent(+ server,+ SESSION_ID,+ new PeerThreadFoldState(),+ { userMessage: 'hello' },+ abortController.signal,+ ),),- );+ ).rejects.toMatchObject({ name: 'AbortError' });expect(cancelSession).not.toHaveBeenCalled();expect(createTurn).not.toHaveBeenCalled();- expect(updates).toEqual([]);});it('does not cancel the backend run when the stream is aborted mid-flight', async () => {@@ -196,25 +216,30 @@ describe('streamTurn', () => {content: 'partial',});abortController.abort();+ throw createAbortError();});const cancelSession = vi.fn().mockResolvedValue(undefined);const server = mockServer({ createTurn, cancelSession });- await collectUpdates(- streamTurnContent(- server,- SESSION_ID,- new PeerThreadFoldState(),- { userMessage: 'hello' },- abortController.signal,+ await expect(+ collectUpdates(+ streamTurnContent(+ server,+ SESSION_ID,+ new PeerThreadFoldState(),+ { userMessage: 'hello' },+ abortController.signal,+ ),),- );+ ).rejects.toMatchObject({ name: 'AbortError' });expect(cancelSession).not.toHaveBeenCalled();});it('forwards headers to createTurn', async () => {- const createTurn = vi.fn(async function* () {});+ const createTurn = vi.fn(async function* () {+ yield streamData(1, turnDoneEvent());+ });const server = mockServer({createTurn,cancelSession: vi.fn().mockResolvedValue(undefined),@@ -340,6 +365,7 @@ describe('streamTurn', () => {threadId: ROOT_THREAD_ID,content: 'resumed',});+ yield streamData(3, turnDoneEvent());});const server = mockServer({subscribeToTurn,@@ -355,7 +381,7 @@ describe('streamTurn', () => {afterSequenceNumber: 1,abortSignal: expect.any(AbortSignal),});- expect(updates).toEqual([{ content: [{ type: 'text', text: 'resumed' }] }]);+ expect(updates).toEqual([{ content: [{ type: 'text', text: 'resumed' }], sequenceNumber: 2 }]);});it('yields nothing when the server omits subscribeToTurn', async () => {@@ -370,20 +396,21 @@ describe('streamTurn', () => {expect(cancelSession).not.toHaveBeenCalled();});- it('returns early when aborted before streaming starts', async () => {+ it('throws when aborted before streaming starts', async () => {const subscribeToTurn = vi.fn(async function* () {});const cancelSession = vi.fn().mockResolvedValue(undefined);const server = mockServer({ subscribeToTurn, cancelSession });const abortController = new AbortController();abortController.abort();- const updates = await collectUpdates(- resumeTurnStream(server, SESSION_ID, 'turn-1', new PeerThreadFoldState(), abortController.signal),- );+ await expect(+ collectUpdates(+ resumeTurnStream(server, SESSION_ID, 'turn-1', new PeerThreadFoldState(), abortController.signal),+ ),+ ).rejects.toMatchObject({ name: 'AbortError' });expect(cancelSession).not.toHaveBeenCalled();expect(subscribeToTurn).not.toHaveBeenCalled();- expect(updates).toEqual([]);});});});diff --git a/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx b/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsxindex f04d9f31f..3033ec6a0 100644--- a/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx+++ b/packages/assistant-ui-runtime/test/useTrueForgeAgentMessages.test.tsx@@ -6,10 +6,15 @@ import type { AgentChatServer, Turn } from '../src/server/index.js';import { collectPendingToolResponses } from '../src/collectPending.js';import { ROOT_THREAD_ID } from '../src/constants.js';-import { prependOlderSessionHistory } from '../src/convertTurnMessages.js';+import {+ prependOlderSessionHistory,+ TurnFailedError,+ TurnStreamDisconnectedError,+} from '../src/convertTurnMessages.js';import { buildRootAssistantContent, ingestTurnEvent, PeerThreadFoldState } from '../src/foldPeerThreads.js';import { loadSessionSnapshot } from '../src/loadSessionSnapshot.js';import { createEmptySessionSnapshot, replaceSessionSnapshot, type SessionSnapshot } from '../src/sessionSnapshot.js';+import { delayReconnect } from '../src/streamReconnect.js';import { resumeTurnStream, streamTurnContent } from '../src/streamTurn.js';import { messageHasPendingApprovals, TOOL_APPROVAL_THREAD_ID_CUSTOM_KEY } from '../src/toolApproval.js';import {@@ -29,6 +34,20 @@ vi.mock('../src/streamTurn.js', () => ({resumeTurnStream: vi.fn(),}));+vi.mock('../src/streamReconnect.js', async importOriginal => {+ const actual = await importOriginal<typeof import('../src/streamReconnect.js')>();+ return {+ ...actual,+ delayReconnect: vi.fn(async (signal: AbortSignal) => {+ if (signal.aborted) {+ const error = new Error('Aborted');+ error.name = 'AbortError';+ throw error;+ }+ }),+ };+});+vi.mock('../src/convertTurnMessages.js', async importOriginal => {const actual = await importOriginal<typeof import('../src/convertTurnMessages.js')>();// Wrapped so tests can stub older-history paging; defaults to the real one.@@ -281,6 +300,13 @@ describe('useTrueForgeAgentMessages', () => {vi.mocked(loadSessionSnapshot).mockResolvedValue(createEmptySessionSnapshot());vi.mocked(streamTurnContent).mockReturnValue(singleUpdateStream());vi.mocked(resumeTurnStream).mockReturnValue(singleUpdateStream());+ vi.mocked(delayReconnect).mockImplementation(async (signal: AbortSignal) => {+ if (signal.aborted) {+ const error = new Error('Aborted');+ error.name = 'AbortError';+ throw error;+ }+ });});afterEach(() => {@@ -426,6 +452,7 @@ describe('useTrueForgeAgentMessages', () => {expect.any(AbortSignal),expect.any(Array),expect.any(Function),+ expect.any(Function),);await act(async () => {@@ -441,6 +468,7 @@ describe('useTrueForgeAgentMessages', () => {expect.any(AbortSignal),expect.any(Array),expect.any(Function),+ expect.any(Function),);});@@ -1240,6 +1268,7 @@ describe('useTrueForgeAgentMessages', () => {expect.any(AbortSignal),expect.any(Array),expect.any(Function),+ expect.any(Function),);expect(result.current.messages).toHaveLength(1);expect(result.current.messages[0]?.role).toBe('assistant');@@ -1530,6 +1559,7 @@ describe('useTrueForgeAgentMessages', () => {expect.any(AbortSignal),expect.any(Array),expect.any(Function),+ expect.any(Function),);const assistant = result.current.messages[0];@@ -1612,6 +1642,7 @@ describe('useTrueForgeAgentMessages', () => {expect.any(AbortSignal),expect.any(Array),expect.any(Function),+ expect.any(Function),);});@@ -1864,7 +1895,7 @@ describe('useTrueForgeAgentMessages', () => {vi.mocked(streamTurnContent).mockImplementation(async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {onTurnIdAvailable?.('gateway-turn-123');- yield { content: [{ type: 'text' as const, text: 'partial' }] };+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 4 };throw new Error('Mid-stream error');},);@@ -1880,12 +1911,10 @@ describe('useTrueForgeAgentMessages', () => {await waitFor(() => expect(result.current.isLoading).toBe(false));await act(async () => {- await expect(- result.current.sendTurn({- userMessage: 'test message',- onPreTurnFailure,- }),- ).rejects.toThrow('Mid-stream error');+ await result.current.sendTurn({+ userMessage: 'test message',+ onPreTurnFailure,+ });});const userMessages = result.current.messages.filter(m => m.role === 'user');@@ -1895,7 +1924,343 @@ describe('useTrueForgeAgentMessages', () => {text: 'test message',});expect(onPreTurnFailure).not.toHaveBeenCalled();- expect(onError).toHaveBeenCalledWith(expect.any(Error));+ expect(onError).not.toHaveBeenCalled();+ expect(resumeTurnStream).toHaveBeenCalledWith(+ mockServer,+ 'session-1',+ 'gateway-turn-123',+ expect.anything(),+ expect.any(AbortSignal),+ 4,+ expect.anything(),+ expect.any(Function),+ );+ });+ });++ it('does not subscribe-retry when the create stream fails before turn.created', async () => {+ const onError = vi.fn();+ vi.mocked(streamTurnContent).mockImplementation(async function* () {+ throw new Error('network error');+ });++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ await act(async () => {+ await expect(result.current.sendTurn({ userMessage: 'hello' })).rejects.toThrow('network error');+ });++ expect(resumeTurnStream).not.toHaveBeenCalled();+ expect(onError).toHaveBeenCalledWith(expect.any(Error));+ expect(result.current.isRunning).toBe(false);+ });++ it('keeps isRunning until subscribe retry finishes after a live SSE drop', async () => {+ const onError = vi.fn();+ let releaseSubscribe: (() => void) | undefined;+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ onTurnIdAvailable?.('gateway-turn-live');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 2 };+ throw new Error('network error');+ },+ );+ vi.mocked(resumeTurnStream).mockReturnValue(+ (async function* () {+ await new Promise<void>(resolve => {+ releaseSubscribe = resolve;+ });+ yield { content: [{ type: 'text' as const, text: 'resumed' }], sequenceNumber: 3 };+ })(),+ );++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ let sendPromise: Promise<void> | undefined;+ await act(async () => {+ sendPromise = result.current.sendTurn({ userMessage: 'hello' });+ });++ await waitFor(() => expect(resumeTurnStream).toHaveBeenCalled());+ expect(onError).not.toHaveBeenCalled();+ expect(result.current.isRunning).toBe(true);++ await act(async () => {+ releaseSubscribe?.();+ await sendPromise;+ });++ await waitFor(() => expect(result.current.isRunning).toBe(false));+ expect(onError).not.toHaveBeenCalled();+ });++ it('does not subscribe when cancel aborts a reconnect delay', async () => {+ const onError = vi.fn();+ let delayStarted: (() => void) | undefined;+ const delayReady = new Promise<void>(resolve => {+ delayStarted = resolve;+ });+ vi.mocked(delayReconnect).mockImplementation(async (signal: AbortSignal) => {+ delayStarted?.();+ await new Promise<void>((_resolve, reject) => {+ const fail = (): void => {+ const error = new Error('Aborted');+ error.name = 'AbortError';+ reject(error);+ };+ if (signal.aborted) {+ fail();+ return;+ }+ signal.addEventListener('abort', fail, { once: true });+ });+ });+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ onTurnIdAvailable?.('gateway-turn-cancel-reconnect');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 1 };+ throw new Error('network error');+ },+ );++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ let sendPromise: Promise<void> | undefined;+ await act(async () => {+ sendPromise = result.current.sendTurn({ userMessage: 'hello' });+ });+ await delayReady;++ await act(async () => {+ await result.current.cancel();+ await sendPromise;+ });++ expect(resumeTurnStream).not.toHaveBeenCalled();+ expect(mockServer.cancelSession).toHaveBeenCalledWith({ sessionId: 'session-1' });+ expect(result.current.isRunning).toBe(false);+ expect(onError).not.toHaveBeenCalled();+ });++ it('does not subscribe-retry when a cancelled live stream drops without turn.done', async () => {+ const onError = vi.fn();+ let dropStream: (() => void) | undefined;+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ onTurnIdAvailable?.('gateway-turn-cancel-drop');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 1 };+ await new Promise<void>((_resolve, reject) => {+ dropStream = () => {+ reject(new TurnStreamDisconnectedError());+ };+ });+ },+ );+ vi.mocked(mockServer.cancelSession).mockImplementation(async () => {+ dropStream?.();+ });++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ let sendPromise: Promise<void> | undefined;+ await act(async () => {+ sendPromise = result.current.sendTurn({ userMessage: 'hello' });+ });+ await waitFor(() => expect(result.current.isRunning).toBe(true));++ await act(async () => {+ await result.current.cancel();+ await sendPromise;+ });++ expect(resumeTurnStream).not.toHaveBeenCalled();+ expect(mockServer.cancelSession).toHaveBeenCalledWith({ sessionId: 'session-1' });+ expect(result.current.isRunning).toBe(false);+ expect(onError).not.toHaveBeenCalled();+ });++ it('does not subscribe-retry when the in-flight stream is aborted', async () => {+ const onError = vi.fn();+ let releaseFirst: (() => void) | undefined;+ let streamTurnCalls = 0;+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ streamTurnCalls += 1;+ if (streamTurnCalls === 1) {+ onTurnIdAvailable?.('gateway-turn-abort');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 1 };+ await new Promise<void>(resolve => {+ releaseFirst = resolve;+ });+ return;+ }+ onTurnIdAvailable?.('gateway-turn-two');+ yield { content: [{ type: 'text' as const, text: 'second' }], sequenceNumber: 1 };+ },+ );++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ let firstSend: Promise<void> | undefined;+ await act(async () => {+ firstSend = result.current.sendTurn({ userMessage: 'one' });+ });+ await waitFor(() => expect(result.current.isRunning).toBe(true));+ vi.mocked(resumeTurnStream).mockClear();++ await act(async () => {+ await result.current.sendTurn({ userMessage: 'two' });+ });+ await act(async () => {+ releaseFirst?.();+ await firstSend?.catch(() => undefined);+ });++ expect(resumeTurnStream).not.toHaveBeenCalled();+ expect(onError).not.toHaveBeenCalled();+ });++ it('does not subscribe-retry a terminal turn.done error', async () => {+ const onError = vi.fn();+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ onTurnIdAvailable?.('gateway-turn-failed');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 1 };+ throw new TurnFailedError('Publisher Model is not servable');+ },+ );++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ await act(async () => {+ await expect(result.current.sendTurn({ userMessage: 'hello' })).rejects.toThrow(+ 'Publisher Model is not servable',+ );+ });++ expect(resumeTurnStream).not.toHaveBeenCalled();+ expect(onError).toHaveBeenCalledWith(expect.any(Error));+ });++ it('reports onError after exhausting subscribe retries', async () => {+ const onError = vi.fn();+ vi.mocked(streamTurnContent).mockImplementation(+ async function* (_server, _sessionId, _fold, _options, _signal, _baseline, onTurnIdAvailable) {+ onTurnIdAvailable?.('gateway-turn-retry');+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 1 };+ throw new Error('network error');+ },+ );+ vi.mocked(resumeTurnStream).mockImplementation(async function* () {+ throw new Error('subscribe failed');+ });++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );+ await waitFor(() => expect(result.current.isLoading).toBe(false));++ await act(async () => {+ await expect(result.current.sendTurn({ userMessage: 'hello' })).rejects.toThrow('subscribe failed');+ });++ expect(resumeTurnStream).toHaveBeenCalledTimes(3);+ expect(onError).toHaveBeenCalledWith(expect.any(Error));+ expect(result.current.isRunning).toBe(false);+ });++ it('resubscribes after a loaded running-turn subscribe drop', async () => {+ const onError = vi.fn();+ const runningTurn = {+ id: 'turn-running',+ sessionId: 'session-1',+ input: [{ type: 'user.message' as const, content: 'continue' }],+ state: { status: 'running' as const },+ createdAt: new Date().toISOString(),+ };+ vi.mocked(loadSessionSnapshot).mockResolvedValue(+ replaceSessionSnapshot(createEmptySessionSnapshot(), {+ runningTurn,+ unstable_resume: true,+ pendingUser: {+ turnId: runningTurn.id,+ content: 'continue',+ createdAt: new Date(runningTurn.createdAt),+ },+ }),+ );+ let subscribeCalls = 0;+ vi.mocked(resumeTurnStream).mockImplementation(async function* (_server, _sid, _tid, _fold, _signal, afterSeq) {+ subscribeCalls += 1;+ if (subscribeCalls === 1) {+ yield { content: [{ type: 'text' as const, text: 'partial' }], sequenceNumber: 8 };+ throw new Error('network error');+ }+ expect(afterSeq).toBe(8);+ yield { content: [{ type: 'text' as const, text: 'resumed' }], sequenceNumber: 9 };+ });++ const { result } = renderHook(() =>+ useTrueForgeAgentMessages({+ server: mockServer,+ sessionId: 'session-1',+ onError,+ }),+ );++ await waitFor(() => expect(result.current.isLoading).toBe(false));+ await waitFor(() => expect(subscribeCalls).toBe(2));+ await waitFor(() => expect(result.current.isRunning).toBe(false));+ expect(onError).not.toHaveBeenCalled();+ expect(result.current.messages.at(-1)).toMatchObject({+ role: 'assistant',+ content: [{ type: 'text', text: 'resumed' }],});});