Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🗓️ fix: Surface a Run Now Scheduled Chat in the Sidebar (#15630)
Danny Avilae1f2298cb84d
diff --git a/client/src/data-provider/Schedules/admission.ts b/client/src/data-provider/Schedules/admission.tsnew file mode 100644index 0000000000..18358af8f7--- /dev/null+++ b/client/src/data-provider/Schedules/admission.ts@@ -0,0 +1,169 @@+/* Scheduled chats */+import { QueryKeys, dataService } from 'librechat-data-provider';+import type { TUser, TConversation } from 'librechat-data-provider';+import type { QueryClient } from '@tanstack/react-query';+import { extendActiveJobsGrace, queueTitleGeneration } from '~/data-provider/SSE/queries';+import { upsertConvoInAllQueries, getResponseStatus } from '~/utils';++/**+ * Waits before each probe, so the first is not spent on a conversation that+ * cannot exist yet. Admission is normally a second or two, but a dispatch that+ * keeps failing is retried, and the budget has to outlast that or the watch+ * gives up on a run the server is still going to admit: the trigger engine+ * allows eight attempts backing off from a second and doubling, which is about+ * two minutes of retries in the worst case. Roughly five minutes of probes+ * covers that window twice over in eleven requests.+ *+ * It does not cover everything, deliberately. A dispatch refused with a long+ * `Retry-After` can be re-driven hours later, and holding a watch open for that+ * is worse than what already happens without one — the chat arrives with the+ * next list refetch. A later announcement of the same run restarts the watch.+ */+const ADMISSION_DELAYS_MS = [+ 750, 1_500, 3_000, 6_000, 10_000, 15_000, 30_000, 45_000, 60_000, 60_000, 60_000,+];++/** 404 is the run not having started yet, which is the whole reason for waiting.+ * 408 and 429 ask to be retried by definition, and a proxy in front of the app+ * can raise either without the run being involved at all. */+const RETRYABLE_CLIENT_STATUS = new Set([404, 408, 429]);++/**+ * Whether a failed probe has answered the question for good. A 5xx, or a request+ * that never got a response, has not — those are the probe failing rather than the+ * run, and the durable delivery is still free to admit afterwards. Only a client+ * error that is not asking to be retried settles it: waiting longer will not make+ * this client able to read that conversation.+ */+const isTerminalProbeFailure = (error: unknown): boolean => {+ const status = getResponseStatus(error);+ return status != null && status >= 400 && status < 500 && !RETRYABLE_CLIENT_STATUS.has(status);+};++const wait = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));++/** Who this cache belongs to. Both sign-in and sign-out empty it wholesale, so a+ * watch outliving either has no business writing to whatever replaced it. An+ * `undefined` is "not loaded yet" or "emptied", and the two read the same. */+const cacheOwner = (queryClient: QueryClient): string | undefined =>+ queryClient.getQueryData<TUser>([QueryKeys.user])?.id;++/**+ * Runs with a watch in flight or already landed. A run can be announced twice —+ * by the click that started it, and by the schedules poll that then lists it —+ * and must be watched once. A watch that gave up is forgotten, so a later+ * announcement of a run admitted after the budget can try again.+ */+const tracked = new Set<string>();++/** @internal Test seam. */+export function resetTrackedRuns(): void {+ tracked.clear();+}++/**+ * The session fence, in one place. The server enforces ownership on the probe+ * itself — a request sent under one account can never return another's chat —+ * so the only dangerous response is one SENT under the account that clicked and+ * LANDING after someone else signed in. That fixes the shape of the fence:+ *+ * - The owner is bound only from a reading taken BEFORE a probe goes out. A+ * reading taken after one cannot tell a cache that finished loading from a+ * cache that changed hands, so it is never adopted as the baseline.+ * - Once bound, any different reading — another id, or none — ends the watch.+ * - A successful probe with no baseline yet is not written and not abandoned:+ * the budget is kept, and the next iteration binds before it probes.+ */+async function admit(queryClient: QueryClient, conversationId: string): Promise<boolean> {+ let startedFor = cacheOwner(queryClient);+ for (const delay of ADMISSION_DELAYS_MS) {+ await wait(delay);+ const before = cacheOwner(queryClient);+ if (startedFor === undefined) {+ startedFor = before;+ } else if (before !== startedFor) {+ return false;+ }+ let conversation: TConversation;+ try {+ conversation = await dataService.getConversationById(conversationId);+ } catch (error) {+ if (isTerminalProbeFailure(error)) {+ return false;+ }+ continue;+ }+ if (startedFor === undefined) {+ continue;+ }+ if (cacheOwner(queryClient) !== startedFor) {+ return false;+ }+ /** The conversation route serves an archived chat; the list query filters one+ * out. Another tab archiving this run between its first write and this probe+ * would otherwise put a row in the sidebar that no refetch agrees belongs+ * there — and the archive was deliberate, so there is nothing else to do. */+ if (conversation.isArchived === true) {+ return true;+ }+ /** Warms the key the chat route reads, so opening the row it just added does+ * not have to ask again. Absent-only: anything already cached under this id+ * was put there by the chat itself and knows more than one list read does. */+ queryClient.setQueryData<TConversation>(+ [QueryKeys.conversation, conversationId],+ (current) => current ?? conversation,+ );+ upsertConvoInAllQueries(queryClient, conversation);+ /** The same bookkeeping the foreground path does when a chat lands in a+ * project: the project's count and recent-activity ordering live on the+ * project rows, which the conversation caches above do not touch. */+ if (conversation.chatProjectId) {+ queryClient.invalidateQueries([QueryKeys.projects]);+ queryClient.invalidateQueries([QueryKeys.project, conversation.chatProjectId]);+ }+ /** A generation is live by definition here. The active-job list is the only+ * thing that can mark the row as running, and it stops polling while nothing+ * is listed — so re-arm it at admission, which is when a job exists, rather+ * than at the click, which is before one does. */+ extendActiveJobsGrace();+ queryClient.invalidateQueries([QueryKeys.activeJobs]);+ /** A conversation admitted mid-run has not been titled yet, so the row lands+ * as "New Chat". The foreground paths hand that to the title queue, which+ * owns the timing the server was configured for; a scheduled run has no+ * foreground path, so hand it over here rather than leaving the placeholder+ * until an unrelated refetch. */+ queueTitleGeneration(conversationId);+ return true;+ }+ return false;+}++/**+ * Puts a scheduled run's chat in the sidebar once the server actually has it.+ *+ * The generation that writes the conversation starts after the run is announced+ * — after run-now answers, after the schedules poll first lists the occurrence —+ * so at the moment of the announcement there is nothing to refetch. The+ * conversation route answers 404 until that write commits and applies the same+ * visibility rule the list query does, which makes it an exact admission probe:+ * a 200 means the chat is listable now, and carries the server's own row rather+ * than a guess assembled from the client's cached schedule.+ *+ * Deliberately detached from the caller: the sidebar has to gain the chat whether+ * or not the panel the run was announced in is still mounted. Bounded, and it+ * writes only what the server returned — a delivery that never admits leaves+ * every cache exactly as it found it.+ */+export async function trackScheduledRun(+ queryClient: QueryClient,+ conversationId: string,+): Promise<void> {+ if (!conversationId || tracked.has(conversationId)) {+ return;+ }+ tracked.add(conversationId);+ const landed = await admit(queryClient, conversationId);+ if (!landed) {+ tracked.delete(conversationId);+ }+}diff --git a/client/src/data-provider/Schedules/mutations.ts b/client/src/data-provider/Schedules/mutations.tsindex a16e48e2ef..6fbc4f875b 100644--- a/client/src/data-provider/Schedules/mutations.ts+++ b/client/src/data-provider/Schedules/mutations.ts@@ -8,6 +8,7 @@ import type {TScheduleRunNowResponse,} from 'librechat-data-provider';import type { UseMutationOptions } from '@tanstack/react-query';+import { trackScheduledRun } from './admission';export const useCreateScheduleMutation = (options?: UseMutationOptions<TSchedule, Error, TCreateSchedule>,@@ -73,6 +74,10 @@ export const useRunScheduleNowMutation = ((id: string) => dataService.runScheduleNow(id),{...options,+ onSuccess: (data, ...rest) => {+ void trackScheduledRun(queryClient, data.conversationId);+ options?.onSuccess?.(data, ...rest);+ },// Invalidate on SETTLED, not just success: several run-now 409 paths are still// server-side mutations (a balance skip updates lastRun/counters and can// auto-disable; agent/permission/invalid-schedule skips disable the schedulediff --git a/client/src/data-provider/__tests__/scheduleRunNow.test.tsx b/client/src/data-provider/__tests__/scheduleRunNow.test.tsxnew file mode 100644index 0000000000..2a87f25926--- /dev/null+++ b/client/src/data-provider/__tests__/scheduleRunNow.test.tsx@@ -0,0 +1,438 @@+import React from 'react';+import { QueryKeys } from 'librechat-data-provider';+import { act, renderHook } from '@testing-library/react';+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';+import type { TConversation, TScheduleRunNowResponse } from 'librechat-data-provider';+import type { InfiniteData } from '@tanstack/react-query';+import type { ReactNode } from 'react';+import {+ ACTIVE_JOBS_POLL_MS,+ resetActiveJobsGrace,+ getActiveJobsRefetchInterval,+} from '../SSE/queries';+import { useRunScheduleNowMutation } from '../Schedules/mutations';+import { resetTrackedRuns } from '../Schedules/admission';+import * as sseQueries from '../SSE/queries';++const mockRunScheduleNow = jest.fn<Promise<TScheduleRunNowResponse>, [string]>();+const mockGetConversationById = jest.fn<Promise<TConversation>, [string]>();++jest.mock('librechat-data-provider', () => {+ const actual = jest.requireActual('librechat-data-provider');+ return {+ ...actual,+ dataService: {+ ...actual.dataService,+ runScheduleNow: (id: string) => mockRunScheduleNow(id),+ getConversationById: (id: string) => mockGetConversationById(id),+ },+ };+});++type ConversationPages = InfiniteData<{+ conversations: TConversation[];+ nextCursor: string | null;+}>;++type ListParams = { projectId?: string };++/** Past the first two probes, and still inside the active-job grace window that+ * admission opens — a test asserting that window must not advance the clock+ * beyond it and read its own fast-forward as the poll having lapsed. */+const PAST_ADMISSION_MS = 3_000;+/** Past the whole probe budget, so a test can run the watch to exhaustion. */+const ADMISSION_BUDGET_MS = 600_000;++/** `isNotFoundError` reads the status off an axios error, so the marker matters:+ * a bare `{ response: { status } }` is not one, and the watch would read a 404 as+ * an unrelated failure and stop — passing the never-admits tests for the wrong+ * reason while failing the ones that retry. */+const httpError = (status: number, message: string) =>+ Object.assign(new Error(message), { isAxiosError: true, response: { status } });++const archivedConversation = (): TConversation =>+ ({ ...serverConversation(), isArchived: true }) as TConversation;++const serverConversation = (chatProjectId?: string): TConversation =>+ ({+ conversationId: 'run-convo-1',+ title: 'Overnight activity summary',+ endpoint: 'agents',+ agent_id: 'agent-1',+ ...(chatProjectId != null ? { chatProjectId } : {}),+ createdAt: '2026-09-04T09:00:01.000Z',+ updatedAt: '2026-09-04T09:00:01.000Z',+ }) as TConversation;++function createQueryClient() {+ return new QueryClient({+ defaultOptions: {+ /** These tests run the fake clock past the whole probe budget, which is+ * longer than the default five-minute cacheTime — without this the list+ * query is garbage collected mid-test and its emptiness reads as the+ * watch having removed something. */+ queries: { retry: false, cacheTime: Infinity },+ mutations: { retry: false },+ },+ });+}++const createWrapper = (queryClient: QueryClient) =>+ function Wrapper({ children }: { children: ReactNode }) {+ return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;+ };++const signIn = (queryClient: QueryClient, id: string) => {+ queryClient.setQueryData([QueryKeys.user], { id });+};++const seedList = (queryClient: QueryClient, params?: ListParams) => {+ queryClient.setQueryData<ConversationPages>(+ params ? [QueryKeys.allConversations, params] : [QueryKeys.allConversations],+ {+ pages: [+ {+ conversations: [{ conversationId: 'existing-convo' } as TConversation],+ nextCursor: null,+ },+ ],+ pageParams: [],+ },+ );+};++const readList = (queryClient: QueryClient, params?: ListParams) =>+ queryClient.getQueryData<ConversationPages>(+ params ? [QueryKeys.allConversations, params] : [QueryKeys.allConversations],+ )?.pages[0].conversations ?? [];++const runNow = async (queryClient: QueryClient) => {+ const { result } = renderHook(() => useRunScheduleNowMutation(), {+ wrapper: createWrapper(queryClient),+ });+ await act(async () => {+ await result.current.mutateAsync('schedule-1');+ });+};++const settleAdmission = async (ms = PAST_ADMISSION_MS) => {+ await act(async () => {+ await jest.advanceTimersByTimeAsync(ms);+ });+};++describe('run-now conversation tracking', () => {+ beforeEach(() => {+ /** `resetAllMocks`, not `clearAllMocks`: a test whose `mockRejectedValueOnce`+ * queue is not fully drained — which is what a failing retry assertion looks+ * like — leaves the remainder queued for the next test, where it silently+ * answers the first probe. That coupling let an assertion here pass against a+ * missing guard. */+ jest.resetAllMocks();+ jest.useFakeTimers();+ resetActiveJobsGrace();+ resetTrackedRuns();+ mockRunScheduleNow.mockResolvedValue({+ scheduleId: 'schedule-1',+ conversationId: 'run-convo-1',+ status: 'started',+ });+ });++ afterEach(() => {+ jest.useRealTimers();+ });++ it('adds the run to the sidebar once the server has the conversation', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById+ .mockRejectedValueOnce(httpError(404, 'Not Found'))+ .mockResolvedValue(serverConversation());++ await runNow(queryClient);+ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);++ await settleAdmission();++ const [first, ...rest] = readList(queryClient);+ expect(first.conversationId).toBe('run-convo-1');+ expect(first.title).toBe('Overnight activity summary');+ expect(rest.map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ queryClient.clear();+ });++ it('files the row by the server row, not by a client snapshot of the schedule', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient, { projectId: 'project-server' });+ seedList(queryClient, { projectId: 'project-stale' });+ mockGetConversationById.mockResolvedValue(serverConversation('project-server'));++ await runNow(queryClient);+ await settleAdmission();++ expect(readList(queryClient, { projectId: 'project-server' })[0].conversationId).toBe(+ 'run-convo-1',+ );+ expect(readList(queryClient, { projectId: 'project-stale' })[0].conversationId).toBe(+ 'existing-convo',+ );+ queryClient.clear();+ });++ it('warms the chat route cache so the new row opens without a 404', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(serverConversation());++ await runNow(queryClient);+ await settleAdmission();++ expect(+ queryClient.getQueryData<TConversation>([QueryKeys.conversation, 'run-convo-1'])?.title,+ ).toBe('Overnight activity summary');+ queryClient.clear();+ });++ it('re-arms the active-job poll only once a generation is known to exist', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById+ .mockRejectedValueOnce(httpError(404, 'Not Found'))+ .mockResolvedValue(serverConversation());++ await runNow(queryClient);+ expect(getActiveJobsRefetchInterval({ activeJobIds: [] })).toBe(false);++ await settleAdmission();++ expect(getActiveJobsRefetchInterval({ activeJobIds: [] })).toBe(ACTIVE_JOBS_POLL_MS);+ queryClient.clear();+ });++ it('leaves every cache untouched when the delivery never admits', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockRejectedValue(httpError(404, 'Not Found'));++ await runNow(queryClient);+ await settleAdmission(ADMISSION_BUDGET_MS);++ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ expect(queryClient.getQueryData([QueryKeys.conversation, 'run-convo-1'])).toBeUndefined();+ expect(getActiveJobsRefetchInterval({ activeJobIds: [] })).toBe(false);+ queryClient.clear();+ });++ it('keeps waiting through a probe that fails for its own reasons', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById+ .mockRejectedValueOnce(httpError(502, 'Bad Gateway'))+ .mockRejectedValueOnce(new Error('Network Error'))+ .mockResolvedValue(serverConversation());++ await runNow(queryClient);+ await settleAdmission(6_000);++ expect(readList(queryClient)[0].conversationId).toBe('run-convo-1');+ queryClient.clear();+ });++ it('hands the admitted chat to the title queue, since it lands as "New Chat"', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(serverConversation());+ /** A spy that calls through: the queue is module state with no reader of its+ * own, and the point is that the tracker joins it at all. */+ const queueTitle = jest.spyOn(sseQueries, 'queueTitleGeneration');++ await runNow(queryClient);+ await settleAdmission();++ expect(queueTitle).toHaveBeenCalledWith('run-convo-1');+ queueTitle.mockRestore();+ queryClient.clear();+ });++ it('does not file the chat into a cache that changed hands mid-watch', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);++ /** The switch lands while the probe is IN FLIGHT, which is the window that+ * matters: sign-out and sign-in both empty the cache, and the response then+ * arrives holding a chat that belongs to whoever was here before. */+ mockGetConversationById.mockImplementation(async () => {+ queryClient.removeQueries([QueryKeys.user]);+ seedList(queryClient);+ signIn(queryClient, 'user-b');+ return serverConversation();+ });++ await runNow(queryClient);+ await settleAdmission();++ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ expect(queryClient.getQueryData([QueryKeys.conversation, 'run-convo-1'])).toBeUndefined();+ queryClient.clear();+ });++ it('keeps waiting through a client error that asks to be retried', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById+ .mockRejectedValueOnce(httpError(429, 'Too Many Requests'))+ .mockRejectedValueOnce(httpError(408, 'Request Timeout'))+ .mockResolvedValue(serverConversation());++ await runNow(queryClient);+ await settleAdmission(6_000);++ expect(readList(queryClient)[0].conversationId).toBe('run-convo-1');+ queryClient.clear();+ });++ it('does not put an archived chat in the active sidebar', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(archivedConversation());++ await runNow(queryClient);+ await settleAdmission();++ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ queryClient.clear();+ });++ it('still tracks a run started before the user query resolved', async () => {+ const queryClient = createQueryClient();+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(serverConversation());++ /** Deliberately signed out of the CACHE at the click, not signed in later:+ * run-now answering 200 already proved a session exists, so the query+ * resolving is a load rather than a change of hands. */+ await runNow(queryClient);+ signIn(queryClient, 'user-a');+ await settleAdmission();++ expect(readList(queryClient)[0].conversationId).toBe('run-convo-1');+ queryClient.clear();+ });++ it('keeps its budget when admitted before the owner is known, and lands once it is', async () => {+ const queryClient = createQueryClient();+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(serverConversation());++ /** The first probe succeeds with nobody to attribute it to: the user query is+ * still loading. That must not end the watch — the same account resolves a+ * moment later, and the next probe is the one that gets to write. */+ await runNow(queryClient);+ await settleAdmission(1_000);+ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);++ signIn(queryClient, 'user-a');+ await settleAdmission(3_000);++ expect(readList(queryClient)[0].conversationId).toBe('run-convo-1');+ expect(mockGetConversationById).toHaveBeenCalledTimes(2);+ queryClient.clear();+ });++ it('refreshes the project rows when the run was filed under a project', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ queryClient.setQueryData([QueryKeys.projects], { pages: [], pageParams: [] });+ queryClient.setQueryData([QueryKeys.project, 'project-a'], { _id: 'project-a' });+ mockGetConversationById.mockResolvedValue(serverConversation('project-a'));++ await runNow(queryClient);+ await settleAdmission();++ expect(queryClient.getQueryState([QueryKeys.projects])?.isInvalidated).toBe(true);+ expect(queryClient.getQueryState([QueryKeys.project, 'project-a'])?.isInvalidated).toBe(true);+ queryClient.clear();+ });++ it('watches a run once however many times it is announced', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockResolvedValue(serverConversation());++ await runNow(queryClient);+ await runNow(queryClient);+ await settleAdmission();++ expect(mockGetConversationById).toHaveBeenCalledTimes(1);+ expect(readList(queryClient).filter((c) => c.conversationId === 'run-convo-1')).toHaveLength(1);+ queryClient.clear();+ });++ it('refuses the write when the cache is claimed while the owner is still unknown', async () => {+ const queryClient = createQueryClient();+ seedList(queryClient);+ /** Never known at the click, and someone else's session arrives while the+ * probe is in flight — "loading" and "changed hands" read identically here,+ * so the response that was sent for the first account must not be written.+ * Every probe after that goes out under the second account, and the server+ * enforces ownership on the read, so those answer 404: the watch drains its+ * budget and nothing lands. */+ mockGetConversationById+ .mockImplementationOnce(async () => {+ signIn(queryClient, 'user-b');+ return serverConversation();+ })+ .mockRejectedValue(httpError(404, 'Not Found'));++ await runNow(queryClient);+ await settleAdmission(ADMISSION_BUDGET_MS);++ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ expect(queryClient.getQueryData([QueryKeys.conversation, 'run-convo-1'])).toBeUndefined();+ queryClient.clear();+ });++ it('stops on a failure that settles the matter', async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ mockGetConversationById.mockRejectedValue(httpError(403, 'Forbidden'));++ await runNow(queryClient);+ await settleAdmission(ADMISSION_BUDGET_MS);++ expect(mockGetConversationById).toHaveBeenCalledTimes(1);+ expect(readList(queryClient).map((convo) => convo.conversationId)).toEqual(['existing-convo']);+ queryClient.clear();+ });++ it("outlasts the trigger engine's own retry window", async () => {+ const queryClient = createQueryClient();+ signIn(queryClient, 'user-a');+ seedList(queryClient);+ /** The engine allows eight attempts backing off from a second and doubling,+ * so a dispatch that keeps failing can admit around two minutes in. */+ mockGetConversationById.mockRejectedValue(httpError(404, 'Not Found'));++ await runNow(queryClient);+ await settleAdmission(150_000);+ mockGetConversationById.mockResolvedValue(serverConversation());+ await settleAdmission(120_000);++ expect(readList(queryClient)[0].conversationId).toBe('run-convo-1');+ queryClient.clear();+ });+});