🧩 refactor: Move the Resumable Submission Mount Into the Chat Core (#17132)

This commit is contained in:
Marco Beretta 2026-10-20 22:28:21 +02:00 • committed by GitHub
parent 2f724fccff
commit 490ad4a32e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 957 additions and 654 deletions

View file

@ -27,36 +27,27 @@ import {
recoveryDispositionsFamily,
} from '@librechat/chat/react';
import {
toStartGenerationError,
getOptimisticMessages,
isInitialNewConversation,
getStreamStartFailureText,
keepLocalCodeApprovalMode,
hydrateSubmissionMessages,
buildOptimisticConversation,
GENERATION_PROTOCOL_VERSION,
supportsGenerationProtocolV2,
ResumableRun,
documentVisibility,
attachResumableStream,
startGeneration,
} from '@librechat/chat';
import type {
ResumableHost,
ResumableCache,
SubscriptionTarget,
GenerationProtocolVersion,
mountSubmission,
releaseSubmission,
} from '@librechat/chat';
import type {
TMessage,
TSubmission,
TConversation,
TPendingSteer,
EventSubmission,
} from 'librechat-data-provider';
import type { QueuedMessageOrigin, DrainAfterAbort, RunEnd } from '@librechat/chat';
import type { ActiveJobsResponse, StreamStatusResponse } from '~/data-provider';
import type { ResumableHost, ResumableCache } from '@librechat/chat';
import type { EventHandlerParams } from './useEventHandlers';
import type { ActiveJobsResponse } from '~/data-provider';
import type { TResData, TFinalResData } from '~/common';
import {
logger,
@ -196,6 +187,38 @@ export default function useResumableSSE(
[queryClient],
);
const addOptimisticConversation = useCallback(
(conversationId: string, currentSubmission: TSubmission): TSubmission => {
if (!isInitialNewConversation(currentSubmission)) {
return currentSubmission;
}
const optimisticConversation = buildOptimisticConversation(currentSubmission, conversationId);
const optimisticMessages = getOptimisticMessages(
currentSubmission,
conversationId,
getMessages(),
);
queryClient.setQueryData<TConversation>(
[QueryKeys.conversation, conversationId],
(current) => current ?? optimisticConversation,
);
queryClient.setQueryData<TMessage[]>(
[QueryKeys.messages, conversationId],
optimisticMessages,
);
queryClient.setQueryData<TMessage[]>(
[QueryKeys.messages, Constants.NEW_CONVO],
optimisticMessages,
);
upsertConvoInAllQueries(queryClient, optimisticConversation);
return hydrateSubmissionMessages(currentSubmission, conversationId);
},
[getMessages, queryClient],
);
const resumableCache = useMemo<ResumableCache>(
() => ({
invalidateMessages: (conversationId, refetch) =>
@ -237,40 +260,16 @@ export default function useResumableSSE(
upsertConvoInAllQueries(queryClient, conversation, true, 'snapshot'),
removeConversation: (conversationId) =>
removeConvoFromAllQueries(queryClient, conversationId),
getConversation: (conversationId) =>
queryClient.getQueryData<TConversation>([QueryKeys.conversation, conversationId]),
removeConversationQueries: (conversationId) => {
queryClient.removeQueries({ queryKey: [QueryKeys.conversation, conversationId] });
queryClient.removeQueries({ queryKey: [QueryKeys.messages, conversationId] });
},
queueTitleGeneration,
addOptimisticConversation,
}),
[addActiveJob, queryClient, removeActiveJob],
);
const addOptimisticConversation = useCallback(
(conversationId: string, currentSubmission: TSubmission): TSubmission => {
if (!isInitialNewConversation(currentSubmission)) {
return currentSubmission;
}
const optimisticConversation = buildOptimisticConversation(currentSubmission, conversationId);
const optimisticMessages = getOptimisticMessages(
currentSubmission,
conversationId,
getMessages(),
);
queryClient.setQueryData<TConversation>(
[QueryKeys.conversation, conversationId],
(current) => current ?? optimisticConversation,
);
queryClient.setQueryData<TMessage[]>(
[QueryKeys.messages, conversationId],
optimisticMessages,
);
queryClient.setQueryData<TMessage[]>(
[QueryKeys.messages, Constants.NEW_CONVO],
optimisticMessages,
);
upsertConvoInAllQueries(queryClient, optimisticConversation);
return hydrateSubmissionMessages(currentSubmission, conversationId);
},
[getMessages, queryClient],
[addActiveJob, addOptimisticConversation, queryClient, removeActiveJob],
);
const [_completed, setCompleted] = useState(new Set());
const [streamId, setStreamId] = useState<string | null>(null);
@ -419,6 +418,24 @@ export default function useResumableSSE(
fetchStatus: fetchStreamStatus,
subscribe: (next) => attachResumableStream(run, buildHost(), next),
cache: resumableCache,
queue: {
clearSupersededMarkers: (conversationId, isSameGeneration) => {
const stopFamily = stopRequestedByConvoId(conversationId);
const stopped = jotaiStore.get(stopFamily);
if (stopped != null && !isSameGeneration(stopped.generationCreatedAt)) {
jotaiStore.set(stopFamily, null);
}
const detachedFamily = detachedRunByConvoId(conversationId);
const detached = jotaiStore.get(detachedFamily);
if (detached != null && !isSameGeneration(detached.generationCreatedAt)) {
jotaiStore.set(detachedFamily, null);
}
},
isStopped: (conversationId, generationCreatedAt) =>
isStoppedRun(jotaiStore.get(stopRequestedByConvoId(conversationId)), generationCreatedAt),
rememberDetachedRun: (conversationId, detachedRun) =>
jotaiStore.set(detachedRunByConvoId(conversationId), detachedRun),
},
pane: {
setIsSubmitting,
setShowStopButton,
@ -431,6 +448,11 @@ export default function useResumableSSE(
clearComposerDrafts(runIndex, conversationId, options),
publishRunEnd: setRunEnd,
setAbortScroll,
setConversation,
startNewConversation: newConversation
? () => newConversation({ template: { conversationId: String(Constants.NEW_CONVO) } })
: undefined,
replaceNewConversationUrl,
renewActiveRun: () => setActiveRunId(v4()),
runEndTarget: resolveRunEndTarget,
clearDrainAfterAbort,
@ -540,6 +562,7 @@ export default function useResumableSSE(
}),
[
run,
newConversation,
localize,
queryClient,
restoreQueuedSubmission,
@ -594,617 +617,13 @@ export default function useResumableSSE(
],
);
const subscribeToStream = useCallback(
(target: SubscriptionTarget) => attachResumableStream(run, buildHost(), target),
[buildHost, run],
);
useEffect(() => {
const host = buildHost();
if (!submission || Object.keys(submission).length === 0) {
logger.log('ResumableSSE', 'No submission, cleaning up');
// Clear reconnect timeout if submission is cleared
run.clearReconnectTimeout();
run.stopForegroundReattach?.();
run.stopForegroundReattach = null;
// Close SSE but do NOT dispatch cancel - navigation should not abort
run.stream?.abort();
run.stream = null;
setStreamId(null);
run.reconnectAttempt = 0;
run.submission = null;
releaseSubmission(run, host);
return;
}
const resumableSubmission = submission as TSubmission & {
resumeStreamId?: string;
resumeGenerationCreatedAt?: number;
resumeGenerationProtocolVersion?: GenerationProtocolVersion;
};
const resumeStreamId = resumableSubmission.resumeStreamId;
const resumeGenerationCreatedAt = resumableSubmission.resumeGenerationCreatedAt;
const resumeGenerationProtocolVersion =
resumableSubmission.resumeGenerationProtocolVersion ?? 1;
logger.log('ResumableSSE', 'Effect triggered', {
conversationId: submission.conversation?.conversationId,
hasResumeStreamId: !!resumeStreamId,
resumeStreamId,
userMessageId: submission.userMessage?.messageId,
});
run.submission = submission;
run.runEndPublished = false;
run.identityConfirmed = false;
run.subscribedEpoch = null;
if (submission.conversation?.conversationId != null) {
/** A different run starting here owns the conversation's end from now on: an earlier run
* this pane left is superseded, and a Stop belonged to that earlier run. Reattaching to
* the same generation keeps both, since that run's end is still owed and it was stopped. */
const startingConvoId = submission.conversation.conversationId;
const sameGeneration = (generationCreatedAt?: number) =>
resumeStreamId != null &&
resumeGenerationCreatedAt != null &&
generationCreatedAt === resumeGenerationCreatedAt;
const stopFamily = stopRequestedByConvoId(startingConvoId);
const stopped = jotaiStore.get(stopFamily);
if (stopped != null && !sameGeneration(stopped.generationCreatedAt)) {
jotaiStore.set(stopFamily, null);
}
const detachedFamily = detachedRunByConvoId(startingConvoId);
const detached = jotaiStore.get(detachedFamily);
if (detached != null && !sameGeneration(detached.generationCreatedAt)) {
jotaiStore.set(detachedFamily, null);
}
}
const startController = new AbortController();
const { signal } = startController;
const isCurrentEffect = () => !signal.aborted && run.submission === submission;
const initStream = async () => {
if (!isCurrentEffect()) {
return;
}
bindResponse(submission);
setIsSubmitting(true);
/** Starting a new generation is the one interval where `isSubmitting`
* is true but no generation epoch exists yet. Clear any prior epoch and
* withhold live Stop/steer controls; the composer can still queue input.
* subscribeToStream exposes controls once the POST/resume installs the
* server-provided epoch. */
const submissionConversationId =
submission.conversation?.conversationId ?? Constants.NEW_CONVO;
if (!resumeStreamId || resumeGenerationCreatedAt == null) {
updateActiveGenerationCreatedAt(resumeStreamId ?? submissionConversationId, null);
}
setShowStopButton(false);
if (resumeStreamId) {
if (!isCurrentEffect()) {
return;
}
// Resume: just subscribe to existing stream, don't start new generation
logger.log('ResumableSSE', 'Resuming existing stream:', resumeStreamId);
setStreamId(resumeStreamId);
// Optimistically add to active jobs (in case it's not already there)
addActiveJob(resumeStreamId);
subscribeToStream({
streamId: resumeStreamId,
submission,
isResume: true,
generationCreatedAt: resumeGenerationCreatedAt,
generationProtocolVersion: resumeGenerationProtocolVersion,
signal,
});
} else {
// New generation: start and then subscribe
logger.log('ResumableSSE', 'Starting NEW generation');
const startResult = await startGeneration(run, buildHost(), submission, signal);
if (!isCurrentEffect()) {
return;
}
if (startResult) {
let replacementStart = startResult.status === 'replaced' ? startResult : null;
let knownReplacementStatus: StreamStatusResponse | null = null;
if (startResult.status === 'predecessor_mismatch') {
const expectedPredecessorCreatedAt = submission.expectedPredecessorCreatedAt;
let refreshedStatus: StreamStatusResponse | null = null;
try {
refreshedStatus = await fetchStreamStatus(startResult.conversationId);
if (!isCurrentEffect()) {
return;
}
} catch (error) {
if (!isCurrentEffect()) {
return;
}
logger.warn('ResumableSSE', 'Could not refresh predecessor mismatch status', {
conversationId: startResult.conversationId,
error,
});
}
if (!isCurrentEffect()) {
return;
}
const reportedReplacement =
startResult.active === true &&
startResult.generationCreatedAt != null &&
startResult.generationCreatedAt !== expectedPredecessorCreatedAt;
if (
refreshedStatus?.active === true &&
supportsGenerationProtocolV2(refreshedStatus) &&
typeof refreshedStatus.streamId === 'string' &&
refreshedStatus.streamId.length > 0 &&
refreshedStatus.createdAt != null &&
refreshedStatus.createdAt !== expectedPredecessorCreatedAt
) {
replacementStart = {
status: 'replaced',
streamId: refreshedStatus.streamId,
conversationId: startResult.conversationId,
generationCreatedAt: refreshedStatus.createdAt,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
knownReplacementStatus = refreshedStatus;
restoreQueuedSubmission(submission, refreshedStatus.createdAt);
} else if (reportedReplacement) {
/** The atomic 409 is itself authoritative at admission time.
* Status publication can lag that response, so retain its exact
* epoch as a minimal handoff snapshot; the fenced SSE attach can
* reconcile if the replacement finishes in the meantime. */
replacementStart = {
status: 'replaced',
streamId: startResult.streamId,
conversationId: startResult.conversationId,
generationCreatedAt: startResult.generationCreatedAt!,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
knownReplacementStatus = {
active: true,
status: 'running',
streamId: startResult.streamId,
createdAt: startResult.generationCreatedAt,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
restoreQueuedSubmission(submission, startResult.generationCreatedAt!);
} else {
/** No different live epoch is proven. Reconcile away the
* optimistic C rows, but publish no run-end: doing so would
* immediately drain and re-send the just-restored queue item. */
const terminalWinnerCreatedAt =
refreshedStatus?.createdAt ?? startResult.generationCreatedAt;
if (terminalWinnerCreatedAt != null) {
restoreQueuedSubmission(submission, terminalWinnerCreatedAt);
}
if (refreshedStatus != null) {
queryClient.setQueryData(
streamStatusQueryKey(startResult.conversationId),
refreshedStatus,
);
} else {
queryClient.invalidateQueries({
queryKey: streamStatusQueryKey(startResult.conversationId),
});
}
try {
await queryClient.invalidateQueries({
queryKey: [QueryKeys.messages, startResult.conversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({
queryKey: [QueryKeys.conversation, startResult.conversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await invalidateConversationLists(queryClient);
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({ queryKey: [QueryKeys.pinnedConversations] });
if (!isCurrentEffect()) {
return;
}
} catch (error) {
if (!isCurrentEffect()) {
return;
}
logger.warn('ResumableSSE', 'Could not reconcile predecessor mismatch history', {
conversationId: startResult.conversationId,
error,
});
}
clearDrainAfterAbort(startResult.conversationId, expectedPredecessorCreatedAt);
run.submission = null;
setIsSubmitting(false);
setShowStopButton(false);
setSubmission(null);
return;
}
}
if (replacementStart != null) {
/** This POST belongs to an older optimistic submission, while the
* conversation-scoped stream id now belongs to a newer generation.
* Never attach A's submission directly to B. Discover B's
* authoritative resume snapshot, refresh durable history, then let
* useResumeOnLoad construct a new epoch-fenced submission. */
const replacementStatus =
knownReplacementStatus ??
(await fetchStreamStatus(replacementStart.conversationId).catch((error) => {
if (!isCurrentEffect()) {
return null;
}
logger.warn('ResumableSSE', 'Could not discover replacement start generation', {
conversationId: replacementStart.conversationId,
generationCreatedAt: replacementStart.generationCreatedAt,
error,
});
return null;
}));
if (!isCurrentEffect()) {
return;
}
if (
replacementStatus?.active === true &&
supportsGenerationProtocolV2(replacementStatus) &&
replacementStatus.streamId === replacementStart.streamId &&
replacementStatus.createdAt === replacementStart.generationCreatedAt
) {
const startedAsNewConvo = isInitialNewConversation(submission);
try {
await queryClient.invalidateQueries({
queryKey: [QueryKeys.messages, replacementStart.conversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({
queryKey: [QueryKeys.conversation, replacementStart.conversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await invalidateConversationLists(queryClient);
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({ queryKey: [QueryKeys.pinnedConversations] });
if (!isCurrentEffect()) {
return;
}
} catch (error) {
if (!isCurrentEffect()) {
return;
}
logger.warn('ResumableSSE', 'Could not refresh replacement generation history', {
conversationId: replacementStart.conversationId,
error,
});
}
const authoritativeConversation = queryClient.getQueryData<TConversation>([
QueryKeys.conversation,
replacementStart.conversationId,
]);
if (authoritativeConversation?.conversationId === replacementStart.conversationId) {
const localConversationId = isInitialNewConversation(submission)
? Constants.NEW_CONVO
: replacementStart.conversationId;
setConversation?.((current) =>
keepLocalCodeApprovalMode(
authoritativeConversation,
current,
localConversationId,
),
);
}
queryClient.setQueryData(streamStatusQueryKey(replacementStart.conversationId), {
...replacementStatus,
generationHandoff: true,
});
updateActiveGenerationCreatedAt(
replacementStart.conversationId,
replacementStart.generationCreatedAt,
undefined,
replacementStart.generationProtocolVersion,
);
addActiveJob(replacementStart.streamId);
if (startedAsNewConvo) {
run.optimisticStreamIds.add(replacementStart.streamId);
updateActiveGenerationCreatedAt(
Constants.NEW_CONVO,
replacementStart.generationCreatedAt,
undefined,
replacementStart.generationProtocolVersion,
);
replaceNewConversationUrl(replacementStart.conversationId);
}
seedSteerChips(
replacementStart.conversationId,
(replacementStatus.resumeState?.pendingSteers ?? []) as TPendingSteer[],
replacementStart.generationCreatedAt,
replacementStart.generationProtocolVersion,
);
settleAppliedSteerParts(
replacementStart.conversationId,
replacementStatus.resumeState?.aggregatedContent ??
replacementStatus.aggregatedContent,
);
run.replacementHandoff = true;
run.submission = null;
setIsSubmitting(true);
setShowStopButton(true);
setSubmission(null);
return;
}
/** The server reported a replacement but its authoritative status
* could not be confirmed. Drop A without ever attaching it to B;
* leave history/status invalidated so navigation/reload can recover,
* and keep any queued text parked (non-completed outcome). */
queryClient.invalidateQueries({
queryKey: streamStatusQueryKey(replacementStart.conversationId),
});
queryClient.invalidateQueries({
queryKey: [QueryKeys.messages, replacementStart.conversationId],
});
clearDrainAfterAbort(
replacementStart.conversationId,
replacementStart.generationCreatedAt,
);
setIsSubmitting(false);
setShowStopButton(false);
setRunEnd({
conversationId: replacementStart.conversationId,
outcome: 'error',
endedAt: run.scheduler.now(),
generationCreatedAt: replacementStart.generationCreatedAt,
});
setSubmission(null);
return;
}
if (startResult.status === 'predecessor_mismatch') {
// Every mismatch path above either hands off or reconciles.
return;
}
if (startResult.status === 'settled') {
const settledConversationId = startResult.conversationId;
const startedAsNewConvo = isInitialNewConversation(submission);
let persistedConversation: TConversation | undefined;
let conversationLookup: 'found' | 'not_found' | 'inconclusive' = 'inconclusive';
try {
persistedConversation = await fetchConvoSnapshot(
queryClient,
settledConversationId,
() => dataService.getConversationById(settledConversationId),
);
if (!isCurrentEffect()) {
return;
}
conversationLookup = 'found';
} catch (error) {
if (!isCurrentEffect()) {
return;
}
conversationLookup =
toStartGenerationError(error)?.response?.status === 404
? 'not_found'
: 'inconclusive';
logger.warn('ResumableSSE', 'Could not load settled generation conversation', {
conversationId: settledConversationId,
conversationLookup,
error,
});
}
if (persistedConversation != null) {
/** The persisted copy carries the mode the settled turn started
* with; a pick made while the start was pending is newer. The
* live conversation still holds the new-chat id here because no
* stream event ran for this turn. */
const settledCopy = persistedConversation;
const localConversationId = startedAsNewConvo
? Constants.NEW_CONVO
: settledConversationId;
const conversationRecord = keepLocalCodeApprovalMode(
settledCopy,
queryClient.getQueryData<TConversation>([
QueryKeys.conversation,
settledConversationId,
]),
settledConversationId,
);
queryClient.setQueryData(
[QueryKeys.conversation, settledConversationId],
conversationRecord,
);
upsertConvoInAllQueries(queryClient, conversationRecord, true, 'snapshot');
setConversation?.((current) =>
keepLocalCodeApprovalMode(settledCopy, current, localConversationId),
);
if (startedAsNewConvo) {
replaceNewConversationUrl(settledConversationId);
}
}
try {
await queryClient.invalidateQueries({
queryKey: [QueryKeys.messages, settledConversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({
queryKey: [QueryKeys.conversation, settledConversationId],
refetchType: 'all',
});
if (!isCurrentEffect()) {
return;
}
await invalidateConversationLists(queryClient);
if (!isCurrentEffect()) {
return;
}
await queryClient.invalidateQueries({ queryKey: [QueryKeys.pinnedConversations] });
if (!isCurrentEffect()) {
return;
}
} catch (error) {
if (!isCurrentEffect()) {
return;
}
logger.warn('ResumableSSE', 'Could not refresh settled generation history', {
conversationId: settledConversationId,
error,
});
}
if (conversationLookup === 'not_found' && startedAsNewConvo) {
/** A failed/early-aborted first turn can settle without ever
* creating a conversation. Never mint A's optimistic rows here:
* prune any partial cache and return to `/c/new` instead of
* leaving a phantom chat/URL. */
removeConvoFromAllQueries(queryClient, settledConversationId);
queryClient.removeQueries({
queryKey: [QueryKeys.conversation, settledConversationId],
});
queryClient.removeQueries({
queryKey: [QueryKeys.messages, settledConversationId],
});
newConversation?.({
template: { conversationId: String(Constants.NEW_CONVO) },
});
}
if (conversationLookup === 'inconclusive') {
/** A network/5xx lookup cannot prove the conversation is absent.
* Preserve its optimistic/cache state for a later refetch and do
* not navigate or mint a fresh `/c/new` conversation. */
clearDrainAfterAbort(settledConversationId, submission.expectedPredecessorCreatedAt);
}
clearStepMaps();
setIsSubmitting(false);
setShowStopButton(false);
setRunEnd({
conversationId: settledConversationId,
outcome: conversationLookup === 'inconclusive' ? 'error' : 'aborted',
startedAsNewConvo,
endedAt: run.scheduler.now(),
});
setSubmission(null);
return;
}
if (startResult.status !== 'stream') {
return;
}
const {
streamId: newStreamId,
resumed,
generationCreatedAt,
generationProtocolVersion,
} = startResult;
setStreamId(newStreamId);
// Optimistically add to active jobs
addActiveJob(newStreamId);
// Queue title generation if this is a new conversation (first message).
// Skip temporary conversations: the server never generates titles for
// them, so polling would 404 indefinitely.
const isNewConvo = isInitialNewConversation(submission);
if (isNewConvo && !submission.isTemporary) {
queueTitleGeneration(newStreamId);
}
if (isInitialNewConversation(submission)) {
run.optimisticStreamIds.add(newStreamId);
replaceNewConversationUrl(newStreamId);
}
const streamSubmission = addOptimisticConversation(newStreamId, submission);
run.submission = streamSubmission;
// A deduped retry (status: 'resumed') attaches to an already-running stream, so
// subscribe with resume=true to replay its state instead of only live events.
subscribeToStream({
streamId: newStreamId,
submission: streamSubmission,
isResume: resumed,
generationCreatedAt,
generationProtocolVersion,
signal,
});
} else {
logger.error('ResumableSSE', 'Failed to get streamId from startGeneration');
}
}
};
/* Fire-and-forget, but not silent: this sets the submitting flags before
it does any work, so a throw would leave the composer generating with no
stream, no final event and no way back but a reload. */
initStream().catch((error: unknown) => {
logger.error('[useResumableSSE] Failed to start the stream', error);
setIsSubmitting(false);
setShowStopButton(false);
setSubmission(null);
});
return () => {
logger.log('ResumableSSE', 'Cleanup - closing SSE, resetting UI state');
startController.abort();
// Cleanup on unmount/navigation - close connection but DO NOT abort backend
// Reset UI state so it doesn't leak to other conversations
// If user returns to this conversation, useResumeOnLoad will restore the state
run.clearReconnectTimeout();
run.cancelRetryFrames();
run.stopForegroundReattach?.();
run.stopForegroundReattach = null;
// Reset reconnect counter before closing (so abort handler doesn't think we're reconnecting)
run.reconnectAttempt = 0;
/** The pane is moving off a run that is still generating (another chat, a new chat, or
* an unmount): the server keeps going with no subscriber and deletes the job when done,
* so no terminal event will reach the queue drain. Remember the run; on return its end is
* read from history. Only a run whose identity the server confirmed (its epoch, and the
* user message `created` or a resume's sync named) is remembered, and not a regeneration,
* a run that already published its end, or one the user stopped. */
const closing = run.submission;
const closingConvoId = closing?.conversation?.conversationId;
const closingUserMessageId = closing?.userMessage?.messageId;
const generationCreatedAt = run.subscribedEpoch;
if (
run.stream != null &&
run.identityConfirmed &&
!run.runEndPublished &&
closing?.isRegenerate !== true &&
closingConvoId != null &&
closingConvoId !== Constants.NEW_CONVO &&
closingUserMessageId != null &&
generationCreatedAt != null &&
!isStoppedRun(jotaiStore.get(stopRequestedByConvoId(closingConvoId)), generationCreatedAt)
) {
jotaiStore.set(detachedRunByConvoId(closingConvoId), {
userMessageId: closingUserMessageId,
responseMessageId: closing?.initialResponse?.messageId,
generationCreatedAt,
});
}
run.stream?.abort();
run.stream = null;
// Clear handler maps to prevent memory leaks and stale state
clearStepMaps();
// Reset UI state on ordinary cleanup. A generation handoff already
// cached the replacement and must remain non-idle until resume-on-load
// installs its epoch-fenced submission.
if (!run.replacementHandoff) {
setIsSubmitting(false);
setShowStopButton(false);
}
run.replacementHandoff = false;
};
return mountSubmission(run, host, submission);
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [submission]);

View file

@ -85,6 +85,15 @@ export const createHost = (
setConversation: jest.fn(),
upsertConversation: jest.fn(),
removeConversation: jest.fn(),
getConversation: jest.fn(() => undefined),
removeConversationQueries: jest.fn(),
queueTitleGeneration: jest.fn(),
addOptimisticConversation: jest.fn((_conversationId, submission) => submission),
},
queue: {
clearSupersededMarkers: jest.fn(),
isStopped: jest.fn(() => false),
rememberDetachedRun: jest.fn(),
},
pane: {
setIsSubmitting: jest.fn(),
@ -100,6 +109,9 @@ export const createHost = (
updateConversation: jest.fn(),
resolveDetachedEnd: jest.fn(() => ({ resolvable: false, end: null })),
setAbortScroll: jest.fn(),
setConversation: jest.fn(),
startNewConversation: jest.fn(),
replaceNewConversationUrl: jest.fn(),
renewActiveRun: jest.fn(),
runEndTarget: jest.fn((params) => ({
conversationId: params.conversationId,

View file

@ -0,0 +1,161 @@
import { Constants } from 'librechat-data-provider';
import type { TMessage, TSubmission, TConversation } from 'librechat-data-provider';
import type { ResumableHost, StreamStatusResponse } from '../resumable';
import { ResumableRun, mountSubmission, releaseSubmission } from '../resumable';
import { createHost, createScheduler } from '../__fixtures__/resumable';
const submission = {
userMessage: { messageId: 'u-1', conversationId: 'c-1', isCreatedByUser: true, text: 'Hi' },
initialResponse: { messageId: 'u-1_', conversationId: 'c-1' } as TMessage,
conversation: { conversationId: 'c-1', endpoint: 'agents' },
endpointOption: { endpoint: 'agents' },
} as unknown as TSubmission;
const newChat = {
...submission,
userMessage: { ...submission.userMessage, conversationId: null },
conversation: { conversationId: Constants.NEW_CONVO, endpoint: 'agents' },
} as unknown as TSubmission;
const flush = () => new Promise((resolve) => setImmediate(resolve));
const setup = () => {
const fetchStatus = jest.fn<Promise<StreamStatusResponse>, [string]>();
const host: ResumableHost = createHost(fetchStatus);
const run = new ResumableRun(createScheduler().scheduler);
return { host, run, fetchStatus };
};
describe('mountSubmission', () => {
it('re-attaches a resume submission without starting a generation', () => {
const { host, run } = setup();
mountSubmission(run, host, {
...submission,
resumeStreamId: 'c-1',
resumeGenerationCreatedAt: 2000,
resumeGenerationProtocolVersion: 2,
} as TSubmission);
expect(host.queue.clearSupersededMarkers).toHaveBeenCalledWith('c-1', expect.any(Function));
const [, isSameGeneration] = (host.queue.clearSupersededMarkers as jest.Mock).mock.calls[0];
expect(isSameGeneration(2000)).toBe(true);
expect(isSameGeneration(1000)).toBe(false);
expect(host.start).not.toHaveBeenCalled();
expect(host.cache.addActiveJob).toHaveBeenCalledWith('c-1');
expect(host.stream.reconnectToStream).toHaveBeenCalledWith(
expect.objectContaining({ url: expect.stringContaining('resume=true') }),
expect.anything(),
);
});
it('starts a new chat, creates its optimistic records and attaches', async () => {
const { host, run } = setup();
(host.start as jest.Mock).mockResolvedValue({ streamId: 'c-9', generationCreatedAt: 5 });
mountSubmission(run, host, newChat);
await flush();
expect(host.cache.queueTitleGeneration).toHaveBeenCalledWith('c-9');
expect(host.pane.replaceNewConversationUrl).toHaveBeenCalledWith('c-9');
expect(host.cache.addOptimisticConversation).toHaveBeenCalledWith('c-9', newChat);
expect(run.optimisticStreamIds.has('c-9')).toBe(true);
expect(host.stream.reconnectToStream).toHaveBeenCalledTimes(1);
});
it('ends a settled start from the persisted conversation without attaching', async () => {
const { host, run } = setup();
(host.start as jest.Mock).mockResolvedValue({
status: 'settled',
conversationId: 'c-1',
generationProtocolVersion: 2,
});
const persisted = { conversationId: 'c-1', title: 'Saved' } as TConversation;
(host.cache.fetchConversation as jest.Mock).mockResolvedValue(persisted);
mountSubmission(run, host, submission);
await flush();
expect(host.cache.setConversation).toHaveBeenCalledWith('c-1', persisted);
expect(host.cache.invalidateMessages).toHaveBeenCalledWith('c-1', 'all');
expect(host.pane.publishRunEnd).toHaveBeenCalledWith(
expect.objectContaining({ conversationId: 'c-1', outcome: 'aborted' }),
);
expect(host.stream.reconnectToStream).not.toHaveBeenCalled();
});
it('hands a lost predecessor fence to the live replacement', async () => {
const { host, run, fetchStatus } = setup();
const error = Object.assign(new Error('mismatch'), {
response: {
status: 409,
headers: {},
data: {
status: 'predecessor_mismatch',
code: 'GENERATION_PREDECESSOR_MISMATCH',
streamId: 'c-1',
conversationId: 'c-1',
generationCreatedAt: 3000,
active: true,
},
},
});
(host.start as jest.Mock).mockRejectedValue(error);
fetchStatus.mockResolvedValue({
active: true,
streamId: 'c-1',
createdAt: 3000,
generationProtocolVersion: 2,
});
mountSubmission(run, host, {
...submission,
expectedPredecessorCreatedAt: 1000,
} as TSubmission);
await flush();
await flush();
expect(host.steers.restoreQueued).toHaveBeenCalledWith(expect.anything(), 3000);
expect(run.replacementHandoff).toBe(true);
expect(host.cache.setStreamStatus).toHaveBeenCalledWith(
'c-1',
expect.objectContaining({ generationHandoff: true, createdAt: 3000 }),
);
expect(host.pane.setSubmission).toHaveBeenCalledWith(null);
});
it('remembers a confirmed run the pane leaves mid-stream', () => {
const { host, run } = setup();
const cleanup = mountSubmission(run, host, {
...submission,
resumeStreamId: 'c-1',
resumeGenerationCreatedAt: 2000,
} as TSubmission);
run.identityConfirmed = true;
cleanup();
expect(host.queue.rememberDetachedRun).toHaveBeenCalledWith('c-1', {
userMessageId: 'u-1',
responseMessageId: 'u-1_',
generationCreatedAt: 2000,
});
expect(run.stream).toBeNull();
expect(host.pane.setIsSubmitting).toHaveBeenLastCalledWith(false);
});
it('keeps the pane busy through a generation handoff', () => {
const { host, run } = setup();
const cleanup = mountSubmission(run, host, submission);
run.replacementHandoff = true;
(host.pane.setIsSubmitting as jest.Mock).mockClear();
cleanup();
expect(host.pane.setIsSubmitting).not.toHaveBeenCalled();
expect(run.replacementHandoff).toBe(false);
});
});
describe('releaseSubmission', () => {
it('closes the connection without aborting the generation', () => {
const { host, run } = setup();
const stream = new AbortController();
run.stream = stream;
run.submission = submission;
run.reconnectAttempt = 3;
releaseSubmission(run, host);
expect(stream.signal.aborted).toBe(true);
expect(run.submission).toBeNull();
expect(run.reconnectAttempt).toBe(0);
expect(host.pane.setStreamId).toHaveBeenCalledWith(null);
});
});

View file

@ -22,6 +22,7 @@ import type {
import type { GenerationProtocolVersion } from '../protocol';
import type { RunEnd } from '../steer/types';
import type { StepEvent } from '../reducer';
import type { ResumableRun } from './run';
/** Where a resumable run reports what it is doing. The app passes its own logger. */
export interface ResumableLogger {
@ -166,7 +167,7 @@ export interface ResumableSteers {
export interface ResumableCache {
/** Marks the conversation's messages stale; `all` refetches them now, `none` leaves that to
* the next read. */
invalidateMessages: (conversationId: string, refetch: 'all' | 'none') => Promise<void>;
invalidateMessages: (conversationId: string, refetch: 'all' | 'active' | 'none') => Promise<void>;
/** Fetches the conversation's messages through its query. `fallback` reads them directly
* when no query for the conversation is mounted yet. */
fetchMessages: (conversationId: string, fallback?: boolean) => Promise<unknown>;
@ -187,6 +188,33 @@ export interface ResumableCache {
upsertConversation: (conversation: TConversation) => void;
/** Drops the conversation from every conversation list. */
removeConversation: (conversationId: string) => void;
getConversation: (conversationId: string) => TConversation | undefined;
/** Drops the conversation's own record and messages from the cache. */
removeConversationQueries: (conversationId: string) => void;
/** Polls for the title the server generates for a new conversation. */
queueTitleGeneration: (conversationId: string) => void;
/**
* Gives a new chat its conversation record and messages under the id the server assigned,
* before any stream event names it; returns the submission rewritten onto that id.
*/
addOptimisticConversation: (conversationId: string, submission: TSubmission) => TSubmission;
}
/** The run markers the queue drain reads for a conversation this pane may leave mid-run. */
export interface ResumableQueue {
/** Clears the stop and detached-run markers an earlier generation left, keeping the ones
* `isSameGeneration` says belong to the generation being resumed. */
clearSupersededMarkers: (
conversationId: string,
isSameGeneration: (generationCreatedAt?: number) => boolean,
) => void;
/** Whether the user stopped this generation. */
isStopped: (conversationId: string, generationCreatedAt: number) => boolean;
/** Records a run the pane left while it was still generating. */
rememberDetachedRun: (
conversationId: string,
run: { userMessageId: string; responseMessageId?: string; generationCreatedAt: number },
) => void;
}
/** The pane's controls and run bookkeeping a resumable run drives. */
@ -223,6 +251,12 @@ export interface ResumablePane {
earlyAbort: boolean;
startedAsNewConvo: boolean;
}) => { conversationId: string; startedAsNewConvo: boolean };
/** Sets the pane's conversation, whatever response the pane adds. */
setConversation?: (update: (current: TConversation | null) => TConversation | null) => void;
/** Resets the pane to a fresh new chat. */
startNewConversation?: () => void;
/** Moves the address bar off `/c/new` onto the conversation the server assigned. */
replaceNewConversationUrl: (conversationId: string) => void;
/** Updates the pane's conversation; absent for a pane that only adds a comparison response. */
updateConversation?: (update: (current: TConversation | null) => TConversation | null) => void;
/**
@ -314,6 +348,7 @@ export interface ResumableParts {
/** Everything a resumable run needs from the app it runs in. */
export interface ResumableHost extends SubscriptionHost {
cache: ResumableCache;
queue: ResumableQueue;
pane: ResumablePane;
steers: ResumableSteers;
events: ResumableEvents;
@ -327,3 +362,14 @@ export interface ResumableHost extends SubscriptionHost {
/** Receives the dev-only controls that simulate a dropped or a clean close. */
exposeDebugControls?: (controls: { killNetwork: () => void; closeClean: () => void }) => void;
}
/** One submission the pane serves, from its start (or resume) until it is replaced. */
export interface MountContext {
run: ResumableRun;
host: ResumableHost;
submission: TSubmission;
/** Aborted once the pane moves to another submission or unmounts. */
signal: AbortSignal;
/** Whether this submission is still the one the pane serves. */
isCurrent: () => boolean;
}

View file

@ -16,3 +16,6 @@ export * from './frames';
export * from './sync';
export * from './attach';
export * from './launch';
export * from './mount';
export * from './outcomes';
export * from './settled';

View file

@ -0,0 +1,278 @@
import { Constants } from 'librechat-data-provider';
import type { TSubmission } from 'librechat-data-provider';
import type { ResumableHost, MountContext } from './host';
import type { StartGenerationResult } from './start';
import type { ResumeSubmission } from './resume';
import type { ResumableRun } from './run';
import { resolvePredecessorMismatch, handoffStartToReplacement } from './outcomes';
import { isInitialNewConversation } from './messages';
import { attachResumableStream } from './attach';
import { startGeneration } from './launch';
import { settleStart } from './settled';
/**
* The pane no longer serves a submission: close the connection without dispatching a cancel
* (navigation must not abort the generation) and drop the pending re-attach.
*/
export function releaseSubmission(run: ResumableRun, host: ResumableHost): void {
host.logger.log('ResumableSSE', 'No submission, cleaning up');
// Clear reconnect timeout if submission is cleared
run.clearReconnectTimeout();
run.stopForegroundReattach?.();
run.stopForegroundReattach = null;
// Close SSE but do NOT dispatch cancel - navigation should not abort
run.stream?.abort();
run.stream = null;
host.pane.setStreamId(null);
run.reconnectAttempt = 0;
run.submission = null;
}
/** Attaches the stream a start named, creating the new chat's optimistic records first. */
function attachStartedStream(
{ run, host, submission, signal }: MountContext,
startResult: Extract<StartGenerationResult, { status: 'stream' }>,
): void {
const {
streamId: newStreamId,
resumed,
generationCreatedAt,
generationProtocolVersion,
} = startResult;
host.pane.setStreamId(newStreamId);
// Optimistically add to active jobs
host.cache.addActiveJob(newStreamId);
// Queue title generation if this is a new conversation (first message).
// Skip temporary conversations: the server never generates titles for
// them, so polling would 404 indefinitely.
const isNewConvo = isInitialNewConversation(submission);
if (isNewConvo && !submission.isTemporary) {
host.cache.queueTitleGeneration(newStreamId);
}
if (isInitialNewConversation(submission)) {
run.optimisticStreamIds.add(newStreamId);
host.pane.replaceNewConversationUrl(newStreamId);
}
const streamSubmission = host.cache.addOptimisticConversation(newStreamId, submission);
run.submission = streamSubmission;
// A deduped retry (status: 'resumed') attaches to an already-running stream, so
// subscribe with resume=true to replay its state instead of only live events.
attachResumableStream(run, host, {
streamId: newStreamId,
submission: streamSubmission,
isResume: resumed,
generationCreatedAt,
generationProtocolVersion,
signal,
});
}
/** Acts on what the generation start reported. */
async function settleStartResult(
mount: MountContext,
startResult: StartGenerationResult,
): Promise<void> {
let replacementStart = startResult.status === 'replaced' ? startResult : null;
let knownReplacementStatus = null;
if (startResult.status === 'predecessor_mismatch') {
const resolved = await resolvePredecessorMismatch(mount, startResult);
if (resolved == null) {
return;
}
({ replacementStart, knownReplacementStatus } = resolved);
}
if (replacementStart != null) {
await handoffStartToReplacement(mount, replacementStart, knownReplacementStatus);
return;
}
if (startResult.status === 'predecessor_mismatch') {
// Every mismatch path above either hands off or reconciles.
return;
}
if (startResult.status === 'settled') {
await settleStart(mount, startResult);
return;
}
if (startResult.status !== 'stream') {
return;
}
attachStartedStream(mount, startResult);
}
/** Starts the submission's generation, or re-attaches to the one it resumes. */
async function initStream(
mount: MountContext,
resume: Partial<Pick<ResumeSubmission, 'resumeStreamId' | 'resumeGenerationCreatedAt'>> &
Pick<ResumeSubmission, 'resumeGenerationProtocolVersion'>,
): Promise<void> {
const { run, host, submission, signal, isCurrent } = mount;
const { resumeStreamId, resumeGenerationCreatedAt, resumeGenerationProtocolVersion } = resume;
if (!isCurrent()) {
return;
}
host.usage.bindResponse(submission);
host.pane.setIsSubmitting(true);
/** Starting a new generation is the one interval where `isSubmitting`
* is true but no generation epoch exists yet. Clear any prior epoch and
* withhold live Stop/steer controls; the composer can still queue input.
* The attach exposes controls once the POST/resume installs the
* server-provided epoch. */
const submissionConversationId = submission.conversation?.conversationId ?? Constants.NEW_CONVO;
if (!resumeStreamId || resumeGenerationCreatedAt == null) {
host.pane.setGenerationEpoch(resumeStreamId ?? submissionConversationId, null);
}
host.pane.setShowStopButton(false);
if (resumeStreamId) {
if (!isCurrent()) {
return;
}
// Resume: just subscribe to existing stream, don't start new generation
host.logger.log('ResumableSSE', 'Resuming existing stream:', resumeStreamId);
host.pane.setStreamId(resumeStreamId);
// Optimistically add to active jobs (in case it's not already there)
host.cache.addActiveJob(resumeStreamId);
attachResumableStream(run, host, {
streamId: resumeStreamId,
submission,
isResume: true,
generationCreatedAt: resumeGenerationCreatedAt,
generationProtocolVersion: resumeGenerationProtocolVersion,
signal,
});
return;
}
// New generation: start and then subscribe
host.logger.log('ResumableSSE', 'Starting NEW generation');
const startResult = await startGeneration(run, host, submission, signal);
if (!isCurrent()) {
return;
}
if (startResult) {
await settleStartResult(mount, startResult);
} else {
host.logger.error('ResumableSSE', 'Failed to get streamId from startGeneration');
}
}
/**
* The pane is moving off a run that is still generating (another chat, a new chat, or an
* unmount): the server keeps going with no subscriber and deletes the job when done, so no
* terminal event will reach the queue drain. Remember the run; on return its end is read from
* history. Only a run whose identity the server confirmed (its epoch, and the user message
* `created` or a resume's sync named) is remembered, and not a regeneration, a run that
* already published its end, or one the user stopped.
*/
function rememberDetachedRun(run: ResumableRun, host: ResumableHost): void {
const closing = run.submission;
const closingConvoId = closing?.conversation?.conversationId;
const closingUserMessageId = closing?.userMessage?.messageId;
const generationCreatedAt = run.subscribedEpoch;
if (
run.stream != null &&
run.identityConfirmed &&
!run.runEndPublished &&
closing?.isRegenerate !== true &&
closingConvoId != null &&
closingConvoId !== Constants.NEW_CONVO &&
closingUserMessageId != null &&
generationCreatedAt != null &&
!host.queue.isStopped(closingConvoId, generationCreatedAt)
) {
host.queue.rememberDetachedRun(closingConvoId, {
userMessageId: closingUserMessageId,
responseMessageId: closing?.initialResponse?.messageId,
generationCreatedAt,
});
}
}
/**
* Serves `submission` in the pane: starts its generation (or resumes the one it names) and
* attaches to the stream. Returns the cleanup that closes the connection without aborting the
* generation server-side and resets the pane's controls.
*/
export function mountSubmission(
run: ResumableRun,
host: ResumableHost,
submission: TSubmission,
): () => void {
const { resumeStreamId, resumeGenerationCreatedAt, resumeGenerationProtocolVersion } =
submission as Partial<ResumeSubmission>;
host.logger.log('ResumableSSE', 'Effect triggered', {
conversationId: submission.conversation?.conversationId,
hasResumeStreamId: !!resumeStreamId,
resumeStreamId,
userMessageId: submission.userMessage?.messageId,
});
run.submission = submission;
run.runEndPublished = false;
run.identityConfirmed = false;
run.subscribedEpoch = null;
if (submission.conversation?.conversationId != null) {
/** A different run starting here owns the conversation's end from now on: an earlier run
* this pane left is superseded, and a Stop belonged to that earlier run. Reattaching to
* the same generation keeps both, since that run's end is still owed and it was stopped. */
host.queue.clearSupersededMarkers(
submission.conversation.conversationId,
(generationCreatedAt) =>
resumeStreamId != null &&
resumeGenerationCreatedAt != null &&
generationCreatedAt === resumeGenerationCreatedAt,
);
}
const startController = new AbortController();
const { signal } = startController;
const mount: MountContext = {
run,
host,
submission,
signal,
isCurrent: () => !signal.aborted && run.submission === submission,
};
/* Fire-and-forget, but not silent: this sets the submitting flags before
it does any work, so a throw would leave the composer generating with no
stream, no final event and no way back but a reload. */
initStream(mount, {
resumeStreamId,
resumeGenerationCreatedAt,
resumeGenerationProtocolVersion: resumeGenerationProtocolVersion ?? 1,
}).catch((error: unknown) => {
host.logger.error('[useResumableSSE] Failed to start the stream', error);
host.pane.setIsSubmitting(false);
host.pane.setShowStopButton(false);
host.pane.setSubmission(null);
});
return () => {
host.logger.log('ResumableSSE', 'Cleanup - closing SSE, resetting UI state');
startController.abort();
// Cleanup on unmount/navigation - close connection but DO NOT abort backend
// Reset UI state so it doesn't leak to other conversations
// If user returns to this conversation, useResumeOnLoad will restore the state
run.clearReconnectTimeout();
run.cancelRetryFrames();
run.stopForegroundReattach?.();
run.stopForegroundReattach = null;
// Reset reconnect counter before closing (so abort handler doesn't think we're reconnecting)
run.reconnectAttempt = 0;
rememberDetachedRun(run, host);
run.stream?.abort();
run.stream = null;
// Clear handler maps to prevent memory leaks and stale state
host.events.clearStepMaps();
// Reset UI state on ordinary cleanup. A generation handoff already
// cached the replacement and must remain non-idle until resume-on-load
// installs its epoch-fenced submission.
if (!run.replacementHandoff) {
host.pane.setIsSubmitting(false);
host.pane.setShowStopButton(false);
}
run.replacementHandoff = false;
};
}

View file

@ -0,0 +1,270 @@
import { Constants } from 'librechat-data-provider';
import type { TPendingSteer } from 'librechat-data-provider';
import type { StreamStatusResponse, MountContext } from './host';
import type { StartGenerationResult } from './start';
import { GENERATION_PROTOCOL_VERSION, supportsGenerationProtocolV2 } from '../protocol';
import { isInitialNewConversation, keepLocalCodeApprovalMode } from './messages';
export type ReplacedStart = Extract<StartGenerationResult, { status: 'replaced' }>;
type MismatchStart = Extract<StartGenerationResult, { status: 'predecessor_mismatch' }>;
/**
* A queued turn lost its predecessor fence. Decides from a fresh status read (or the atomic
* 409 itself) whether a different live epoch owns the conversation, restoring the queued turn
* either way. Resolves to the replacement to hand off to, or null once it reconciled history
* without one (or the pane moved on).
*/
export async function resolvePredecessorMismatch(
mount: MountContext,
startResult: MismatchStart,
): Promise<{
replacementStart: ReplacedStart | null;
knownReplacementStatus: StreamStatusResponse | null;
} | null> {
const { run, host, submission, isCurrent } = mount;
let replacementStart: ReplacedStart | null = null;
let knownReplacementStatus: StreamStatusResponse | null = null;
const expectedPredecessorCreatedAt = submission.expectedPredecessorCreatedAt;
let refreshedStatus: StreamStatusResponse | null = null;
try {
refreshedStatus = await host.fetchStatus(startResult.conversationId);
if (!isCurrent()) {
return null;
}
} catch (error) {
if (!isCurrent()) {
return null;
}
host.logger.warn('ResumableSSE', 'Could not refresh predecessor mismatch status', {
conversationId: startResult.conversationId,
error,
});
}
if (!isCurrent()) {
return null;
}
const reportedReplacement =
startResult.active === true &&
startResult.generationCreatedAt != null &&
startResult.generationCreatedAt !== expectedPredecessorCreatedAt;
if (
refreshedStatus?.active === true &&
supportsGenerationProtocolV2(refreshedStatus) &&
typeof refreshedStatus.streamId === 'string' &&
refreshedStatus.streamId.length > 0 &&
refreshedStatus.createdAt != null &&
refreshedStatus.createdAt !== expectedPredecessorCreatedAt
) {
replacementStart = {
status: 'replaced',
streamId: refreshedStatus.streamId,
conversationId: startResult.conversationId,
generationCreatedAt: refreshedStatus.createdAt,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
knownReplacementStatus = refreshedStatus;
host.steers.restoreQueued(submission, refreshedStatus.createdAt);
} else if (reportedReplacement) {
/** The atomic 409 is itself authoritative at admission time.
* Status publication can lag that response, so retain its exact
* epoch as a minimal handoff snapshot; the fenced SSE attach can
* reconcile if the replacement finishes in the meantime. */
replacementStart = {
status: 'replaced',
streamId: startResult.streamId,
conversationId: startResult.conversationId,
generationCreatedAt: startResult.generationCreatedAt!,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
knownReplacementStatus = {
active: true,
status: 'running',
streamId: startResult.streamId,
createdAt: startResult.generationCreatedAt,
generationProtocolVersion: GENERATION_PROTOCOL_VERSION,
};
host.steers.restoreQueued(submission, startResult.generationCreatedAt!);
} else {
/** No different live epoch is proven. Reconcile away the
* optimistic C rows, but publish no run-end: doing so would
* immediately drain and re-send the just-restored queue item. */
const terminalWinnerCreatedAt = refreshedStatus?.createdAt ?? startResult.generationCreatedAt;
if (terminalWinnerCreatedAt != null) {
host.steers.restoreQueued(submission, terminalWinnerCreatedAt);
}
if (refreshedStatus != null) {
host.cache.setStreamStatus(startResult.conversationId, refreshedStatus);
} else {
host.cache.invalidateStreamStatus(startResult.conversationId);
}
try {
await host.cache.invalidateMessages(startResult.conversationId, 'all');
if (!isCurrent()) {
return null;
}
await host.cache.refreshConversation(startResult.conversationId);
if (!isCurrent()) {
return null;
}
await host.cache.refreshConversationLists();
if (!isCurrent()) {
return null;
}
await host.cache.refreshPinnedConversations();
if (!isCurrent()) {
return null;
}
} catch (error) {
if (!isCurrent()) {
return null;
}
host.logger.warn('ResumableSSE', 'Could not reconcile predecessor mismatch history', {
conversationId: startResult.conversationId,
error,
});
}
host.pane.clearDrainAfterAbort(startResult.conversationId, expectedPredecessorCreatedAt);
run.submission = null;
host.pane.setIsSubmitting(false);
host.pane.setShowStopButton(false);
host.pane.setSubmission(null);
return null;
}
return { replacementStart, knownReplacementStatus };
}
/**
* This POST belongs to an older optimistic submission, while the conversation-scoped stream
* now belongs to a newer generation. Hands the pane to that generation without ever attaching
* the older submission to it.
*/
export async function handoffStartToReplacement(
mount: MountContext,
replacementStart: ReplacedStart,
knownReplacementStatus: StreamStatusResponse | null,
): Promise<void> {
const { run, host, submission, isCurrent } = mount;
/** This POST belongs to an older optimistic submission, while the
* conversation-scoped stream id now belongs to a newer generation.
* Never attach A's submission directly to B. Discover B's
* authoritative resume snapshot, refresh durable history, then let
* useResumeOnLoad construct a new epoch-fenced submission. */
const replacementStatus =
knownReplacementStatus ??
(await host.fetchStatus(replacementStart.conversationId).catch((error) => {
if (!isCurrent()) {
return null;
}
host.logger.warn('ResumableSSE', 'Could not discover replacement start generation', {
conversationId: replacementStart.conversationId,
generationCreatedAt: replacementStart.generationCreatedAt,
error,
});
return null;
}));
if (!isCurrent()) {
return;
}
if (
replacementStatus?.active === true &&
supportsGenerationProtocolV2(replacementStatus) &&
replacementStatus.streamId === replacementStart.streamId &&
replacementStatus.createdAt === replacementStart.generationCreatedAt
) {
const startedAsNewConvo = isInitialNewConversation(submission);
try {
await host.cache.invalidateMessages(replacementStart.conversationId, 'all');
if (!isCurrent()) {
return;
}
await host.cache.refreshConversation(replacementStart.conversationId);
if (!isCurrent()) {
return;
}
await host.cache.refreshConversationLists();
if (!isCurrent()) {
return;
}
await host.cache.refreshPinnedConversations();
if (!isCurrent()) {
return;
}
} catch (error) {
if (!isCurrent()) {
return;
}
host.logger.warn('ResumableSSE', 'Could not refresh replacement generation history', {
conversationId: replacementStart.conversationId,
error,
});
}
const authoritativeConversation = host.cache.getConversation(replacementStart.conversationId);
if (authoritativeConversation?.conversationId === replacementStart.conversationId) {
const localConversationId = isInitialNewConversation(submission)
? Constants.NEW_CONVO
: replacementStart.conversationId;
host.pane.setConversation?.((current) =>
keepLocalCodeApprovalMode(authoritativeConversation, current, localConversationId),
);
}
host.cache.setStreamStatus(replacementStart.conversationId, {
...replacementStatus,
generationHandoff: true,
});
host.pane.setGenerationEpoch(
replacementStart.conversationId,
replacementStart.generationCreatedAt,
undefined,
replacementStart.generationProtocolVersion,
);
host.cache.addActiveJob(replacementStart.streamId);
if (startedAsNewConvo) {
run.optimisticStreamIds.add(replacementStart.streamId);
host.pane.setGenerationEpoch(
Constants.NEW_CONVO,
replacementStart.generationCreatedAt,
undefined,
replacementStart.generationProtocolVersion,
);
host.pane.replaceNewConversationUrl(replacementStart.conversationId);
}
host.steers.seed(
replacementStart.conversationId,
(replacementStatus.resumeState?.pendingSteers ?? []) as TPendingSteer[],
replacementStart.generationCreatedAt,
replacementStart.generationProtocolVersion,
);
host.steers.settleApplied(
replacementStart.conversationId,
replacementStatus.resumeState?.aggregatedContent ?? replacementStatus.aggregatedContent,
);
run.replacementHandoff = true;
run.submission = null;
host.pane.setIsSubmitting(true);
host.pane.setShowStopButton(true);
host.pane.setSubmission(null);
return;
}
/** The server reported a replacement but its authoritative status
* could not be confirmed. Drop A without ever attaching it to B;
* leave history/status invalidated so navigation/reload can recover,
* and keep any queued text parked (non-completed outcome). */
host.cache.invalidateStreamStatus(replacementStart.conversationId);
host.cache.invalidateMessages(replacementStart.conversationId, 'active');
host.pane.clearDrainAfterAbort(
replacementStart.conversationId,
replacementStart.generationCreatedAt,
);
host.pane.setIsSubmitting(false);
host.pane.setShowStopButton(false);
host.pane.publishRunEnd({
conversationId: replacementStart.conversationId,
outcome: 'error',
endedAt: run.scheduler.now(),
generationCreatedAt: replacementStart.generationCreatedAt,
});
host.pane.setSubmission(null);
}

View file

@ -0,0 +1,114 @@
import { Constants } from 'librechat-data-provider';
import type { TConversation } from 'librechat-data-provider';
import type { StartGenerationResult } from './start';
import type { MountContext } from './host';
import { isInitialNewConversation, keepLocalCodeApprovalMode } from './messages';
import { toStartGenerationError } from './start';
/**
* The server reports the turn already settled (a duplicate start of a finished generation).
* Adopts the persisted conversation, refreshes history, and ends the run without attaching.
*/
export async function settleStart(
mount: MountContext,
startResult: Extract<StartGenerationResult, { status: 'settled' }>,
): Promise<void> {
const { run, host, submission, isCurrent } = mount;
const settledConversationId = startResult.conversationId;
const startedAsNewConvo = isInitialNewConversation(submission);
let persistedConversation: TConversation | undefined;
let conversationLookup: 'found' | 'not_found' | 'inconclusive' = 'inconclusive';
try {
persistedConversation = await host.cache.fetchConversation(settledConversationId);
if (!isCurrent()) {
return;
}
conversationLookup = 'found';
} catch (error) {
if (!isCurrent()) {
return;
}
conversationLookup =
toStartGenerationError(error)?.response?.status === 404 ? 'not_found' : 'inconclusive';
host.logger.warn('ResumableSSE', 'Could not load settled generation conversation', {
conversationId: settledConversationId,
conversationLookup,
error,
});
}
if (persistedConversation != null) {
/** The persisted copy carries the mode the settled turn started
* with; a pick made while the start was pending is newer. The
* live conversation still holds the new-chat id here because no
* stream event ran for this turn. */
const settledCopy = persistedConversation;
const localConversationId = startedAsNewConvo ? Constants.NEW_CONVO : settledConversationId;
const conversationRecord = keepLocalCodeApprovalMode(
settledCopy,
host.cache.getConversation(settledConversationId),
settledConversationId,
);
host.cache.setConversation(settledConversationId, conversationRecord);
host.cache.upsertConversation(conversationRecord);
host.pane.setConversation?.((current) =>
keepLocalCodeApprovalMode(settledCopy, current, localConversationId),
);
if (startedAsNewConvo) {
host.pane.replaceNewConversationUrl(settledConversationId);
}
}
try {
await host.cache.invalidateMessages(settledConversationId, 'all');
if (!isCurrent()) {
return;
}
await host.cache.refreshConversation(settledConversationId);
if (!isCurrent()) {
return;
}
await host.cache.refreshConversationLists();
if (!isCurrent()) {
return;
}
await host.cache.refreshPinnedConversations();
if (!isCurrent()) {
return;
}
} catch (error) {
if (!isCurrent()) {
return;
}
host.logger.warn('ResumableSSE', 'Could not refresh settled generation history', {
conversationId: settledConversationId,
error,
});
}
if (conversationLookup === 'not_found' && startedAsNewConvo) {
/** A failed/early-aborted first turn can settle without ever
* creating a conversation. Never mint A's optimistic rows here:
* prune any partial cache and return to `/c/new` instead of
* leaving a phantom chat/URL. */
host.cache.removeConversation(settledConversationId);
host.cache.removeConversationQueries(settledConversationId);
host.pane.startNewConversation?.();
}
if (conversationLookup === 'inconclusive') {
/** A network/5xx lookup cannot prove the conversation is absent.
* Preserve its optimistic/cache state for a later refetch and do
* not navigate or mint a fresh `/c/new` conversation. */
host.pane.clearDrainAfterAbort(settledConversationId, submission.expectedPredecessorCreatedAt);
}
host.events.clearStepMaps();
host.pane.setIsSubmitting(false);
host.pane.setShowStopButton(false);
host.pane.publishRunEnd({
conversationId: settledConversationId,
outcome: conversationLookup === 'inconclusive' ? 'error' : 'aborted',
startedAsNewConvo,
endedAt: run.scheduler.now(),
});
host.pane.setSubmission(null);
}