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
⏯️ feat: Resume Streams and Send AI SDK Messages Through the Chat Facade (#16609)
Marco Beretta76b0ea82f592
diff --git a/client/src/hooks/Chat/__tests__/facade.spec.tsx b/client/src/hooks/Chat/__tests__/facade.spec.tsxindex e6bf42298b..6965cdb82d 100644--- a/client/src/hooks/Chat/__tests__/facade.spec.tsx+++ b/client/src/hooks/Chat/__tests__/facade.spec.tsx@@ -1,11 +1,14 @@import React from 'react';import { act, render, renderHook } from '@testing-library/react';-import { QueryKeys, ContentTypes } from 'librechat-data-provider';+import { QueryKeys, Constants, ContentTypes } from 'librechat-data-provider';import { QueryClient, QueryClientProvider, useQuery } from '@tanstack/react-query';import type { TConversation, TMessage, TMessageContentParts } from 'librechat-data-provider';import type { ChatContract } from '../contract';+import type { JotaiStore } from 'test/harness';import { ChatContext } from '~/Providers/ChatContext';import { useChat, useChatActions } from '../facade';+import { IsolatedAtomStore } from 'test/harness';+import { resumeRequestsAtom } from '../resume';const userMessage: TMessage = {messageId: 'user-1',@@ -637,6 +640,104 @@ describe('useChat', () => {expect(contract.stopGenerating).toHaveBeenCalledTimes(1);});+ it('sends an AI SDK user message as the ask call it describes', () => {+ const contract = createContract();+ const { result } = renderChat(contract);++ result.current.sendMessage(+ {+ parts: [+ { type: 'text', text: 'Hel' },+ { type: 'text', text: 'lo' },+ ],+ metadata: { parentMessageId: 'user-1' },+ },+ { isRegenerate: false },+ );++ expect(contract.ask).toHaveBeenCalledWith(+ { text: 'Hello', parentMessageId: 'user-1' },+ { isRegenerate: false },+ );+ });++ it('attaches an AI SDK message with a null parent at the root', () => {+ const contract = createContract();+ const { result } = renderChat(contract);++ result.current.sendMessage({+ parts: [{ type: 'text', text: 'From the top' }],+ metadata: { parentMessageId: null },+ });++ expect(contract.ask).toHaveBeenCalledWith(+ { text: 'From the top', parentMessageId: Constants.NO_PARENT },+ undefined,+ );+ });++ it('reports a refused send to the caller', () => {+ const contract = createContract({ ask: jest.fn(() => false as const) });+ const { result } = renderChat(contract);++ expect(result.current.sendMessage({ parts: [{ type: 'text', text: 'Hi' }] })).toBe(false);+ });++ it('rejects stop when the stop request fails', async () => {+ const failure = new Error('abort failed');+ const contract = createContract({+ isSubmitting: true,+ stopGenerating: jest.fn(() => Promise.reject(failure)),+ });+ const { result } = renderChat(contract);++ await expect(result.current.stop()).rejects.toBe(failure);+ });++ /** Renders `useChat` under its own atom store, seeded with another pane's pending request. */+ const renderChatWithRequests = (contract: ChatContract) => {+ let atoms: JotaiStore | undefined;+ const queryClient = new QueryClient();+ const view = renderHook(() => useChat(), {+ wrapper: ({ children }) => (+ <QueryClientProvider client={queryClient}>+ <IsolatedAtomStore+ seed={(store) => {+ atoms = store;+ store.set(resumeRequestsAtom, new Set(['convo-2']));+ }}+ >+ <ChatContext.Provider value={contract}>{children}</ChatContext.Provider>+ </IsolatedAtomStore>+ </QueryClientProvider>+ ),+ });+ const pending = () => [...(atoms?.get(resumeRequestsAtom) ?? [])];+ return { ...view, pending };+ };++ it('requests a resume of the chat it reads', async () => {+ const { result, pending } = renderChatWithRequests(createContract());++ await result.current.resumeStream();+ await result.current.resumeStream();++ expect(pending()).toEqual(['convo-2', 'convo-1']);+ });++ it('requests no resume for a chat that has no conversation yet', async () => {+ const { result, pending } = renderChatWithRequests(+ createContract({+ messagesKey: 'new',+ conversation: { conversationId: 'new' } as TConversation,+ }),+ );++ await expect(result.current.resumeStream()).resolves.toBeUndefined();+ expect(result.current.id).toBe('new');+ expect(pending()).toEqual(['convo-2']);+ });+it('writes UI messages back onto the stored messages', () => {const answered = response({text: 'Hello',@@ -716,7 +817,8 @@ describe('useChatActions', () => {it('forwards its actions to the contract', () => {const { result, contract } = renderActions([userMessage, response()]);- expect(result.current.sendMessage).toBe(contract.ask);+ result.current.sendMessage({ text: 'Hello' });+ expect(contract.ask).toHaveBeenCalledWith({ text: 'Hello' }, undefined);expect(result.current.stop).toBe(contract.stopGenerating);result.current.regenerate();expect(contract.regenerate).toHaveBeenCalledWith({diff --git a/client/src/hooks/Chat/__tests__/transport.spec.tsx b/client/src/hooks/Chat/__tests__/transport.spec.tsxindex cc0d77d979..2967e18334 100644--- a/client/src/hooks/Chat/__tests__/transport.spec.tsx+++ b/client/src/hooks/Chat/__tests__/transport.spec.tsx@@ -1,9 +1,9 @@import React from 'react';-import { useAtomValue } from 'jotai';import { MemoryRouter } from 'react-router-dom';-import { RecoilRoot, useRecoilValue } from 'recoil';-import { QueryKeys } from 'librechat-data-provider';+import { useAtomValue, getDefaultStore } from 'jotai';+import { QueryKeys, request } from 'librechat-data-provider';import { act, renderHook, waitFor } from '@testing-library/react';+import { RecoilRoot, useRecoilValue, useSetRecoilState } from 'recoil';import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import type {TEnqueueAgentQueuedTurnRequest,@@ -13,15 +13,22 @@ import type {ChatTransportRequest,} from 'librechat-data-provider';import type { MutableSnapshot } from 'recoil';+import type { StreamStatusResponse } from '~/data-provider';+import type { ChatContract } from '~/hooks/Chat/contract';import type { Transport } from '~/hooks/Chat/contract';import type { PendingSteer } from '~/hooks/Chat/queue';import { queuedMessagesByConvoId, resetQueueFamilies } from '~/hooks/Chat/queue';import { ChatTransportContext } from '~/Providers/ChatTransportContext';+import { ChatContext, useChatContext } from '~/Providers/ChatContext';+import { startupConfigKey } from '~/data-provider/Endpoints/queries';import { useSteerReclaim } from '~/hooks/Chat/useSteerCancel';import useSteerEscalate from '~/hooks/Chat/useSteerEscalate';import useResumableSSE from '~/hooks/SSE/useResumableSSE';+import useResumeOnLoad from '~/hooks/SSE/useResumeOnLoad';import useChatHelpers from '~/hooks/Chat/useChatHelpers';+import { resumeRequestsAtom } from '~/hooks/Chat/resume';import useSteering from '~/hooks/Chat/useSteering';+import { useChat } from '~/hooks/Chat/facade';import useSSE from '~/hooks/SSE/useSSE';import store from '~/store';@@ -492,4 +499,189 @@ describe('chat transport boundary', () => {expect(result.current.queue).toEqual([expect.objectContaining({ text: 'hold me here' })]);});});++ describe('resume', () => {+ /** The host builds the pane's chat contract, as the chat view does. */+ function ChatHost({ children }: { children: React.ReactNode }) {+ const helpers: ChatContract = useChatHelpers(0, 'convo-1');+ return <ChatContext.Provider value={helpers}>{children}</ChatContext.Provider>;+ }++ /** The resume-on-load path and the stream hook a chat view mounts, read through `useChat`. */+ const useResumablePane = () => {+ const helpers = useChatContext();+ useResumeOnLoad('convo-1', helpers.getMessages, 0, true);+ const submission = useRecoilValue(store.submissionByIndex(0));+ useResumableSSE(submission, helpers, false, 0);+ const showConversation = useSetRecoilState(store.conversationByIndex(0));+ return { ...useChat(), showConversation };+ };++ const seedConversation = ({ set }: MutableSnapshot) =>+ set(store.conversationByIndex(0), {+ conversationId: 'convo-1',+ endpoint: 'agents',+ } as TConversation);++ let status: StreamStatusResponse;+ /** A running job as the status route reports it, with the turn it answers. */+ const runningStatus = (): StreamStatusResponse => ({+ active: true,+ streamId: 'convo-1',+ status: 'running',+ createdAt: 2000,+ generationProtocolVersion: 2,+ resumeState: {+ runSteps: [],+ aggregatedContent: [],+ userMessage: {+ messageId: 'msg-1',+ parentMessageId: '00000000-0000-0000-0000-000000000000',+ conversationId: 'convo-1',+ text: 'Hello',+ },+ responseMessageId: 'resp-1',+ conversationId: 'convo-1',+ } as StreamStatusResponse['resumeState'],+ });+ const statusReads = () =>+ (request.get as jest.Mock).mock.calls.filter(([url]) => String(url).includes('/status/'))+ .length;++ beforeEach(() => {+ status = { active: false };+ /** The status read is the server's answer to "is anything running"; the stream itself+ * comes from the fake transport. */+ jest+ .spyOn(request, 'get')+ .mockImplementation(async (url: string) =>+ url.includes('/api/agents/chat/status/') ? status : [],+ );+ });++ afterEach(() => {+ jest.restoreAllMocks();+ });++ /** Resume waits for the startup config, which decides a rebuilt turn's retention. */+ const seedStartupConfig = (queryClient: QueryClient) => {+ queryClient.setQueryData(startupConfigKey(false), {});+ /** The turn the running generation answers, as history holds it on reload. */+ queryClient.setQueryData([QueryKeys.messages, 'convo-1'], [buildSubmission().userMessage]);+ };++ const renderPane = (+ transport: Transport,+ seed: (snapshot: MutableSnapshot) => void = seedConversation,+ ) => {+ const Wrapper = createWrapper(transport, seed, seedStartupConfig);+ return renderHook(useResumablePane, {+ wrapper: ({ children }) => (+ <Wrapper>+ <ChatHost>{children}</ChatHost>+ </Wrapper>+ ),+ });+ };++ it('reattaches to a running generation through the host transport', async () => {+ const fake = createFakeTransport();+ const { result } = renderPane(fake.transport);+ await waitFor(() => expect(statusReads()).toBe(1));+ expect(fake.streams).toHaveLength(0);++ status = runningStatus();+ await act(async () => {+ await result.current.resumeStream();+ });++ await waitFor(() => expect(fake.streams).toHaveLength(1));+ expect(fake.transport.stream).toHaveBeenCalledWith({ token: 'test-token' });+ expect(fake.streams[0].url).toContain('/api/agents/chat/stream/convo-1');+ expect(fake.streams[0].url).toContain('resume=true');+ expect(fake.streams[0].url).toContain('generationCreatedAt=2000');+ expect(fake.transport.start).not.toHaveBeenCalled();+ });++ it('re-reads the status and stays detached when nothing is running', async () => {+ const fake = createFakeTransport();+ const { result } = renderPane(fake.transport);+ await waitFor(() => expect(statusReads()).toBe(1));++ await act(async () => {+ await result.current.resumeStream();+ });++ await waitFor(() => expect(statusReads()).toBe(2));+ expect(fake.streams).toHaveLength(0);+ expect(result.current.status).toBe('ready');+ });++ it('holds a request until the pane has loaded the conversation the route names', async () => {+ const store$ = getDefaultStore();+ const fake = createFakeTransport();+ /** The pane still shows the Assistants conversation it is navigating away from. */+ const { result } = renderPane(fake.transport, ({ set }) =>+ set(store.conversationByIndex(0), {+ conversationId: 'assistants-convo',+ endpoint: 'assistants',+ } as TConversation),+ );+ status = runningStatus();++ await act(async () => {+ await result.current.resumeStream();+ });+ expect([...store$.get(resumeRequestsAtom)]).toEqual(['convo-1']);+ expect(fake.streams).toHaveLength(0);++ act(() =>+ result.current.showConversation({+ conversationId: 'convo-1',+ endpoint: 'agents',+ } as TConversation),+ );++ await waitFor(() => expect(fake.streams).toHaveLength(1));+ expect(fake.streams[0].url).toContain('resume=true');+ expect([...store$.get(resumeRequestsAtom)]).toEqual([]);+ });++ it("answers its own conversation's request and leaves another pane's pending", async () => {+ const store = getDefaultStore();+ const fake = createFakeTransport();+ const { result } = renderPane(fake.transport);+ await waitFor(() => expect(statusReads()).toBe(1));++ await act(async () => {+ /** Another pane asks in the same tick, before any effect runs. */+ store.set(resumeRequestsAtom, (pending) => new Set(pending).add('convo-2'));+ await result.current.resumeStream();+ });++ await waitFor(() => expect(statusReads()).toBe(2));+ expect([...store.get(resumeRequestsAtom)]).toEqual(['convo-2']);+ store.set(resumeRequestsAtom, new Set<string>());+ });++ it('reports a reattached stream that fails as an error', async () => {+ const fake = createFakeTransport();+ const { result } = renderPane(fake.transport);+ await waitFor(() => expect(statusReads()).toBe(1));+ status = runningStatus();+ await act(async () => {+ await result.current.resumeStream();+ });+ await waitFor(() => expect(fake.streams).toHaveLength(1));++ /** The run ends with the error, and the teardown re-reads the status to confirm it. */+ status = { active: false, status: 'error', createdAt: 2000, generationProtocolVersion: 2 };+ act(() =>+ fake.streams[0].options.onEvent({ type: 'error', data: { message: 'Generation failed' } }),+ );++ await waitFor(() => expect(result.current.status).toBe('error'));+ expect(result.current.error?.message).toContain('Generation failed');+ });+ });});diff --git a/client/src/hooks/Chat/facade.ts b/client/src/hooks/Chat/facade.tsindex 6db5ac2857..328a7cb360 100644--- a/client/src/hooks/Chat/facade.ts+++ b/client/src/hooks/Chat/facade.ts@@ -1,4 +1,5 @@import { useRef, useMemo, useCallback, useSyncExternalStore } from 'react';+import { useStore } from 'jotai';import { hashQueryKey, useQueryClient } from '@tanstack/react-query';import {QueryKeys,@@ -7,23 +8,50 @@ import {fromUIMessage,toUIMessage,} from 'librechat-data-provider';-import type { TMessage, UIMessage, TAttachment, UIMappingOptions } from 'librechat-data-provider';+import type {+ TMessage,+ UIMessage,+ UITextPart,+ TAttachment,+ UIMappingOptions,+ UIMessageMetadata,+} from 'librechat-data-provider';import type { QueryCacheNotifyEvent } from '@tanstack/react-query';+import type { TAskProps, TOptions } from '~/common';import type { ChatContract } from './contract';-import type { TAskFunction } from '~/common';import { isMemoryFailureOutput } from '~/components/Chat/Messages/Content/Parts/MemoryCall';import { getToolMeta } from '~/components/Chat/Messages/Content/outcome';import { useChatContext } from '~/Providers/ChatContext';import { isEmptyContentPart } from '~/utils/messages';+import { resumeRequestsAtom } from './resume';import { mapAttachments } from '~/utils/map';/** AI SDK `ChatStatus`. */export type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';+/**+ * A user turn in the AI SDK's `sendMessage` shape: its text parts, plus the message it attaches+ * under. It goes to the facade's own chat, as AI SDK `useChat` does, so it names no conversation.+ * File parts are left out because the turn takes its files from the composer, not the message.+ */+export type SendMessageInput = {+ parts: UITextPart[];+ metadata?: Partial<Pick<UIMessageMetadata, 'parentMessageId'>>;+};++/**+ * Submits a turn. Takes the contract's `ask` arguments, or a user message in the AI SDK shape,+ * which is sent as the `ask` call it describes; `{ text }` is already both.+ */+export type SendMessage = (+ message: TAskProps | SendMessageInput,+ options?: TOptions,+) => false | void;+/*** The `useChat` surface of `@ai-sdk/[email protected]` (`UseChatHelpers`), over LibreChat's chat- * contract. Members the contract cannot back (`resumeStream`, `addToolOutput`, `clearError`)- * are left out rather than stubbed.+ * contract. Members the contract cannot back (`addToolOutput`, `clearError`) are left out rather+ * than stubbed.*/export type UseChatHelpers = {/** The conversation the messages are read from (the contract's `messagesKey`); AI SDK's chat id. */@@ -33,11 +61,19 @@ export type UseChatHelpers = {status: ChatStatus;/** Set when the latest message is an error; LibreChat reports errors as messages. */error: Error | undefined;- /** Submits a turn: the contract's `ask`, called with the same arguments. */- sendMessage: TAskFunction;+ /** Submits a turn through the contract's `ask`; see {@link SendMessage}. */+ sendMessage: SendMessage;/** Regenerates the response to `messageId`, or the latest message of the branch. */regenerate: (options?: { messageId?: string }) => void;stop: () => Promise<void>;+ /**+ * Reattaches this chat to its running generation, if the server has one. The request is+ * answered by the resume-on-load path the chat view mounts for its pane, which checks the+ * stream status and attaches through the host transport. It resolves once requested. It does+ * nothing for a new chat or one already attached, and a request for a conversation no chat view+ * shows waits until one does.+ */+ resumeStream: () => Promise<void>;/*** Writes messages back to the cache, keeping the stored fields the UI view omits. A message* with no stored counterpart joins the active conversation under the message before it, or@@ -312,9 +348,43 @@ const findLatest = (stored: TMessage[] | undefined, latestMessageId: string | un/** The `useChat` members that need no message list. */export type ChatActions = Pick<UseChatHelpers,- 'id' | 'status' | 'sendMessage' | 'regenerate' | 'stop'+ 'id' | 'status' | 'sendMessage' | 'regenerate' | 'stop' | 'resumeStream'>;+/** `ask` arguments for a `sendMessage` call, which may carry an AI SDK user message. */+const toAskProps = (message: TAskProps | SendMessageInput): TAskProps => {+ if (!('parts' in message)) {+ return message;+ }+ const { parentMessageId } = message.metadata ?? {};+ return {+ text: message.parts.map((part) => part.text).join(''),+ /** A root message's view carries a `null` parent, which `ask` would read as "append to the+ * branch tail"; the turn asked to attach at the root. */+ ...(parentMessageId !== undefined && {+ parentMessageId: parentMessageId ?? Constants.NO_PARENT,+ }),+ };+};++/** `sendMessage` and `resumeStream` for the chat `id`, shared by `useChat` and `useChatActions`. */+function useTurnActions(ask: ChatContract['ask'], id?: string) {+ const jotaiStore = useStore();+ const sendMessage = useCallback<SendMessage>(+ (message, options) => ask(toAskProps(message), options),+ [ask],+ );+ const resumeStream = useCallback(async () => {+ if (!id || id === Constants.NEW_CONVO) {+ return;+ }+ jotaiStore.set(resumeRequestsAtom, (pending) =>+ pending.has(id) ? pending : new Set(pending).add(id),+ );+ }, [id, jotaiStore]);+ return { sendMessage, resumeStream };+}+/*** `useChat` without `messages`, for controls that submit or read status: it re-renders when the* status changes, not on every stream frame, and never maps the conversation.@@ -338,10 +408,11 @@ export function useChatActions(): ChatActions {const status = useSyncExternalStore(subscribe, readStatus, readStatus);const regenerate = useRegenerate(getMessages, latestMessageId, regenerateTarget);const id = messagesKey || conversation?.conversationId || undefined;+ const { sendMessage, resumeStream } = useTurnActions(ask, id);return useMemo(- () => ({ id, status, sendMessage: ask, regenerate, stop: stopGenerating }),- [id, status, ask, regenerate, stopGenerating],+ () => ({ id, status, sendMessage, regenerate, stop: stopGenerating, resumeStream }),+ [id, status, sendMessage, regenerate, stopGenerating, resumeStream],);}@@ -404,6 +475,7 @@ export function useChat(): UseChatHelpers {);const regenerate = useRegenerate(getMessages, latestMessageId, regenerateTarget);+ const { sendMessage, resumeStream } = useTurnActions(ask, chatId);const setMessages = useCallback((update: UIMessage[] | ((messages: UIMessage[]) => UIMessage[])) => {@@ -438,9 +510,10 @@ export function useChat(): UseChatHelpers {messages,status,error,- sendMessage: ask,+ sendMessage,regenerate,stop: stopGenerating,+ resumeStream,setMessages,};}diff --git a/client/src/hooks/Chat/resume.ts b/client/src/hooks/Chat/resume.tsnew file mode 100644index 0000000000..ca50ad3d17--- /dev/null+++ b/client/src/hooks/Chat/resume.ts@@ -0,0 +1,10 @@+import { atom } from 'jotai';++/**+ * Conversations with an unanswered request to reattach to their running generation (the+ * facade's `resumeStream`). The pane showing a conversation consumes its entry and answers it+ * with the same status re-check `useResumeOnLoad` runs when a job is announced, so a request+ * never builds a second resume path. Entries are consumed, so the set stays as small as the+ * requests in flight. Chat-owned, so it lives with the chat rather than in the app store.+ */+export const resumeRequestsAtom = atom<ReadonlySet<string>>(new Set<string>());diff --git a/client/src/hooks/SSE/useResumeOnLoad.ts b/client/src/hooks/SSE/useResumeOnLoad.tsindex 8ac28e09cb..b6ee8e6be3 100644--- a/client/src/hooks/SSE/useResumeOnLoad.ts+++ b/client/src/hooks/SSE/useResumeOnLoad.ts@@ -1,5 +1,5 @@import { useCallback, useEffect, useMemo, useRef, useState } from 'react';-import { useStore } from 'jotai';+import { useStore, useAtom } from 'jotai';import { useQueryClient } from '@tanstack/react-query';import { useSetRecoilState, useRecoilValue, useRecoilCallback } from 'recoil';import {@@ -43,6 +43,7 @@ import { pendingApprovalActionFamily } from '~/components/Chat/approval/state';import { agentQueuedTurnsQueryKey } from '~/data-provider/SSE/queuedTurns';import useSteerConvert from '~/hooks/Chat/useSteerConvert';import { revealedQueuedTurnFamily } from '~/store/steer';+import { resumeRequestsAtom } from '~/hooks/Chat/resume';import { useFileMapContext } from '~/Providers';import store from '~/store';@@ -1230,4 +1231,51 @@ export default function useResumeOnLoad(setSubmission,queryClient,]);++ /**+ * An explicit `resumeStream` request takes the announcement's path: the+ * status read decides whether anything is running, and the effect above+ * builds the resume submission that `useResumableSSE` attaches through the+ * host transport. The request is consumed either way: one made while this+ * pane is already attached is answered by that attachment.+ */+ const [resumeRequests, setResumeRequests] = useAtom(resumeRequestsAtom);+ const resumeRequested = !!conversationId && resumeRequests.has(conversationId);+ /** The route can name a conversation before this pane has loaded it; until then the endpoint+ * that decides resumability is the previous conversation's, so the request waits. */+ const routeConversationLoaded = currentConversation?.conversationId === conversationId;+ useEffect(() => {+ if (!resumeRequested || !conversationId || !routeConversationLoaded) {+ return;+ }+ setResumeRequests((pending) => {+ const next = new Set(pending);+ next.delete(conversationId);+ return next;+ });+ if (!resumableEnabled || conversationId === Constants.NEW_CONVO) {+ return;+ }+ if (hasLiveSubmissionForThisConvo) {+ return;+ }+ /** A finished submission still installed reads as attached to the check above. */+ if (hasActiveSubmissionForThisConvo) {+ setSubmission(null);+ }+ queryClient.invalidateQueries({ queryKey: streamStatusQueryKey(conversationId) });+ queryClient.invalidateQueries({ queryKey: [QueryKeys.messages, conversationId] });+ processedConvoRef.current = null;+ setExternalRunArm((arm) => arm + 1);+ }, [+ conversationId,+ resumeRequested,+ routeConversationLoaded,+ setResumeRequests,+ resumableEnabled,+ hasActiveSubmissionForThisConvo,+ hasLiveSubmissionForThisConvo,+ setSubmission,+ queryClient,+ ]);}