Skip to content

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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 './serv
import { 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.ts
index 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.ts
index 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): TurnInputI
return 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.ts
index 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' | 'creat
return { 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.ts
new file mode 100644
index 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.ts
index 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'] | Rec
return { 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.tsx
index 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' }],
});
});