From fd86359e829672c594bdc9cbc7cb371adbd3c42e Mon Sep 17 00:00:00 2001 From: Marco Beretta <81851188+berry-13@users.noreply.github.com> Date: Mon, 26 Oct 2026 22:47:30 +0100 Subject: [PATCH] =?UTF-8?q?=F0=9F=93=A1=20refactor:=20Move=20the=20Adaptiv?= =?UTF-8?q?e=20and=20Resumable=20SSE=20Bindings=20into=20the=20Chat=20Pack?= =?UTF-8?q?age=20(#17452)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit useAdaptiveSSE and useResumableSSE now live in the chat package and own the run, the stream id and how a stream re-attaches. The app supplies the services a resumable stream runs on and the Assistants stream through a StreamHost, mounted in Root beside the chat and steer hosts. --- client/src/Providers/StreamHostContext.tsx | 12 +++ .../hooks/Chat/__tests__/transport.spec.tsx | 16 ++-- .../SSE/__tests__/useResumableSSE.spec.ts | 26 +++++-- client/src/hooks/SSE/index.ts | 3 +- .../SSE/{useResumableSSE.ts => resumable.ts} | 78 ++++++------------- client/src/routes/Root.tsx | 5 +- client/test/streamHost.tsx | 9 +++ packages/chat/src/react.ts | 1 + .../react/stream/__tests__/adaptive.spec.tsx | 38 ++++++--- .../chat/src/react/stream/adaptive.ts | 27 +++---- packages/chat/src/react/stream/host.tsx | 68 ++++++++++++++++ packages/chat/src/react/stream/index.ts | 4 + packages/chat/src/react/stream/resumable.ts | 61 +++++++++++++++ 13 files changed, 256 insertions(+), 92 deletions(-) create mode 100644 client/src/Providers/StreamHostContext.tsx rename client/src/hooks/SSE/{useResumableSSE.ts => resumable.ts} (58%) create mode 100644 client/test/streamHost.tsx rename client/src/hooks/SSE/__tests__/useAdaptiveSSE.spec.ts => packages/chat/src/react/stream/__tests__/adaptive.spec.tsx (53%) rename client/src/hooks/SSE/useAdaptiveSSE.ts => packages/chat/src/react/stream/adaptive.ts (63%) create mode 100644 packages/chat/src/react/stream/host.tsx create mode 100644 packages/chat/src/react/stream/index.ts create mode 100644 packages/chat/src/react/stream/resumable.ts diff --git a/client/src/Providers/StreamHostContext.tsx b/client/src/Providers/StreamHostContext.tsx new file mode 100644 index 0000000000..e08869ef33 --- /dev/null +++ b/client/src/Providers/StreamHostContext.tsx @@ -0,0 +1,12 @@ +import type { StreamHost } from '@librechat/chat/react'; +import { useResumableServices } from '~/hooks/SSE/resumable'; +import useSSE from '~/hooks/SSE/useSSE'; + +/** The app's services behind the stream bindings: the resumable stream's handlers, cache and + * transport, and the Assistants stream, which carries its own response. */ +export const appStreamHost: StreamHost = { + useResumableServices, + useLegacyStream: useSSE, +}; + +export { StreamHostProvider, useStreamHost } from '@librechat/chat/react'; diff --git a/client/src/hooks/Chat/__tests__/transport.spec.tsx b/client/src/hooks/Chat/__tests__/transport.spec.tsx index b9f025a8ff..8b7c8bd4e7 100644 --- a/client/src/hooks/Chat/__tests__/transport.spec.tsx +++ b/client/src/hooks/Chat/__tests__/transport.spec.tsx @@ -2,9 +2,9 @@ import React from 'react'; import { MemoryRouter } from 'react-router-dom'; import { useAtomValue, getDefaultStore } from 'jotai'; import { RecoilRoot, useSetRecoilState } from 'recoil'; -import { useChatHelpers } from '@librechat/chat/react'; import { act, renderHook, waitFor } from '@testing-library/react'; import { useChat, resumeRequestsAtom } from '@librechat/chat/react'; +import { useChatHelpers, useResumableSSE } from '@librechat/chat/react'; import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; import { Tools, QueryKeys, ContentTypes, EModelEndpoint, request } from 'librechat-data-provider'; import { @@ -37,8 +37,8 @@ import { usePaneConversation, usePaneConversationState } from '~/routes/ChatSett import { ChatTransportContext } from '~/Providers/ChatTransportContext'; import { ChatContext, useChatContext } from '~/Providers/ChatContext'; import { startupConfigKey } from '~/data-provider/Endpoints/queries'; -import useResumableSSE from '~/hooks/SSE/useResumableSSE'; import useResumeOnLoad from '~/hooks/SSE/useResumeOnLoad'; +import { StreamHostTestProvider } from 'test/streamHost'; import { SteerHostTestProvider } from 'test/steerHost'; import { ChatHostTestProvider } from 'test/chatHost'; import useSSE from '~/hooks/SSE/useSSE'; @@ -121,11 +121,13 @@ function createWrapper( > - - - {children} - - + + + + {children} + + + diff --git a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts index 4a649965f3..c2892519cf 100644 --- a/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts +++ b/client/src/hooks/SSE/__tests__/useResumableSSE.spec.ts @@ -1,7 +1,7 @@ import { createElement } from 'react'; import { getDefaultStore } from 'jotai'; import { QueryClient } from '@tanstack/react-query'; -import { renderHook, act, waitFor } from '@testing-library/react'; +import { renderHook as renderBareHook, act, waitFor } from '@testing-library/react'; import { Constants, ContentTypes, @@ -11,6 +11,7 @@ import { StepTypes, request, } from 'librechat-data-provider'; +import type { RenderHookOptions, RenderHookResult } from '@testing-library/react'; import type { TMessage, TSubmission } from 'librechat-data-provider'; import type { Query, QueryKey } from '@tanstack/react-query'; import type { ReactNode } from 'react'; @@ -312,15 +313,15 @@ jest.mock('librechat-data-provider', () => { }; }); -import useResumableSSE, { - selectLocalSteersForQueue, - ABORT_SWEEP_STATUSES, -} from '~/hooks/SSE/useResumableSSE'; +import { selectLocalSteersForQueue, ABORT_SWEEP_STATUSES } from '~/hooks/SSE/resumable'; +import { appStreamHost } from '~/Providers/StreamHostContext'; import useSSE from '~/hooks/SSE/useSSE'; import type { PendingSteer } from '@librechat/chat'; import type { Transport } from '~/hooks/Chat/contract'; import { ChatTransportContext, defaultChatTransport } from '~/Providers/ChatTransportContext'; import { + useResumableSSE, + StreamHostProvider, recoveryDispositionsFamily, queuedMessagesByConvoId, stopRequestedByConvoId, @@ -328,6 +329,21 @@ import { resetQueueFamilies, } from '@librechat/chat/react'; +/** Every hook here renders under the app's stream host, as `Root` mounts it. */ +function renderHook( + callback: (props: Props) => Result, + options?: RenderHookOptions, +): RenderHookResult { + const Inner = options?.wrapper; + const wrapper = ({ children }: { children: ReactNode }) => + createElement( + StreamHostProvider, + { host: appStreamHost }, + Inner ? createElement(Inner, null, children) : children, + ); + return renderBareHook(callback, { ...options, wrapper }); +} + const CONV_ID = 'conv-abc-123'; type PartialSubmission = { diff --git a/client/src/hooks/SSE/index.ts b/client/src/hooks/SSE/index.ts index 5de4866d49..f2438e42ba 100644 --- a/client/src/hooks/SSE/index.ts +++ b/client/src/hooks/SSE/index.ts @@ -1,6 +1,5 @@ export { default as useSSE } from './useSSE'; -export { default as useResumableSSE } from './useResumableSSE'; -export { default as useAdaptiveSSE } from './useAdaptiveSSE'; +export { useResumableSSE, useAdaptiveSSE } from '@librechat/chat/react'; export { default as useResumeOnLoad } from './useResumeOnLoad'; export { default as useStepHandler } from './useStepHandler'; export { default as useUsageHandler } from './useUsageHandler'; diff --git a/client/src/hooks/SSE/useResumableSSE.ts b/client/src/hooks/SSE/resumable.ts similarity index 58% rename from client/src/hooks/SSE/useResumableSSE.ts rename to client/src/hooks/SSE/resumable.ts index b49c1bedc8..230b032d36 100644 --- a/client/src/hooks/SSE/useResumableSSE.ts +++ b/client/src/hooks/SSE/resumable.ts @@ -1,14 +1,7 @@ -import { useState, useEffect, useCallback } from 'react'; -import { - ResumableRun, - mountSubmission, - releaseSubmission, - documentVisibility, - attachResumableStream, -} from '@librechat/chat'; -import type { ResumableHost, ResumableParts } from '@librechat/chat'; -import type { TSubmission } from 'librechat-data-provider'; -import type { EventHandlerParams } from './useEventHandlers'; +import { useCallback } from 'react'; +import { documentVisibility } from '@librechat/chat'; +import type { ResumableServices, ResumableStreamParams } from '@librechat/chat/react'; +import type { ResumableParts } from '@librechat/chat'; import { logger, applySteerPart, @@ -28,11 +21,6 @@ import useResumableCache from './cache'; import useResumablePane from './pane'; import useSteerState from './steer'; -type ChatHelpers = Pick< - EventHandlerParams, - 'setMessages' | 'getMessages' | 'setConversation' | 'setIsSubmitting' | 'newConversation' ->; - /** How the app's message parts place steers and labels onto a response. */ const resumableParts: ResumableParts = { applySteer: applySteerPart, @@ -47,31 +35,21 @@ const resumableParts: ResumableParts = { export { ABORT_SWEEP_STATUSES, selectLocalSteersForQueue } from '@librechat/chat'; /** - * Hook for resumable SSE streams. - * Separates generation start (POST) from stream subscription (GET EventSource). - * Supports auto-reconnection with exponential backoff. - * - * Key behavior: - * - Navigation away does NOT abort the generation (just closes SSE) - * - Only explicit abort (via stop button → backend abort endpoint) stops generation - * - Backend emits `done` event with `aborted: true` on abort, handled via finalHandler - * - * The run itself lives in `@librechat/chat` (`mountSubmission`, `attachResumableStream`); - * this hook supplies it the app it runs in. + * The services a pane's resumable stream runs on in this app: its query cache, steer chips, + * stream handlers, pane controls, balance refresh and transport. The binding in + * `@librechat/chat/react` owns the run, the stream id and how a stream re-attaches. */ -export default function useResumableSSE( - submission: TSubmission | null, - chatHelpers: ChatHelpers, - isAddedRequest = false, - runIndex = 0, -) { - const [run] = useState(() => new ResumableRun()); - const [streamId, setStreamId] = useState(null); +export function useResumableServices({ + run, + chat, + runIndex, + isAddedRequest, + setStreamId, +}: ResumableStreamParams): () => ResumableServices { const { auth, config } = useChatSettings(); const { token, isAuthenticated = false } = auth; const transport = useChatTransport(); - const { setMessages, getMessages, setConversation, setIsSubmitting, newConversation } = - chatHelpers; + const { setMessages, getMessages, setConversation, setIsSubmitting, newConversation } = chat; const { balanceEnabled = false } = config; const balanceQuery = useGetUserBalance({ enabled: isAuthenticated && balanceEnabled }); @@ -82,7 +60,12 @@ export default function useResumableSSE( const cache = useResumableCache(getMessages, runIndex); const steerState = useSteerState(); const steers = useResumableSteers(steerState); - const { events, usage } = useResumableEvents({ run, runIndex, isAddedRequest, chatHelpers }); + const { events, usage } = useResumableEvents({ + run, + runIndex, + isAddedRequest, + chatHelpers: chat, + }); const { pane, queue } = useResumablePane({ run, runIndex, @@ -95,12 +78,11 @@ export default function useResumableSSE( setGenerationEpoch: steerState.updateActiveGenerationCreatedAt, }); - const buildHost = useCallback( - (): ResumableHost => ({ + return useCallback( + (): ResumableServices => ({ logger, visibility: documentVisibility, fetchStatus: fetchStreamStatus, - subscribe: (next) => attachResumableStream(run, buildHost(), next), cache, queue, pane, @@ -123,18 +105,6 @@ export default function useResumableSSE( : undefined, parts: resumableParts, }), - [run, cache, queue, pane, steers, events, usage, getMessages, setMessages, transport, token], + [cache, queue, pane, steers, events, usage, getMessages, setMessages, transport, token], ); - - useEffect(() => { - const host = buildHost(); - if (!submission || Object.keys(submission).length === 0) { - releaseSubmission(run, host); - return; - } - return mountSubmission(run, host, submission); - // eslint-disable-next-line react-hooks/exhaustive-deps - }, [submission]); - - return { streamId }; } diff --git a/client/src/routes/Root.tsx b/client/src/routes/Root.tsx index 13fef43088..0cc4d41ea1 100644 --- a/client/src/routes/Root.tsx +++ b/client/src/routes/Root.tsx @@ -33,6 +33,7 @@ import { CodeHighlightThrottleContext, normalizeCodeHighlightThrottleMs, } from '~/components/Chat/Messages/Content/Parts/useLazyHighlight'; +import { StreamHostProvider, appStreamHost } from '~/Providers/StreamHostContext'; import KeyboardShortcutsDialog from '~/components/Nav/KeyboardShortcutsDialog'; import { SteerHostProvider, appSteerHost } from '~/Providers/SteerHostContext'; import { ChatHostProvider, appChatHost } from '~/Providers/ChatHostContext'; @@ -271,7 +272,9 @@ export default function Root() { - + + + diff --git a/client/test/streamHost.tsx b/client/test/streamHost.tsx new file mode 100644 index 0000000000..ecae676102 --- /dev/null +++ b/client/test/streamHost.tsx @@ -0,0 +1,9 @@ +import React from 'react'; +import { StreamHostProvider } from '@librechat/chat/react'; +import { appStreamHost } from '~/Providers/StreamHostContext'; + +/** Mounts the app's stream host the way `routes/Root.tsx` does, for specs that render the stream + * hooks outside the app shell. Import it after the spec's module mocks so the host uses them. */ +export function StreamHostTestProvider({ children }: { children?: React.ReactNode }) { + return {children}; +} diff --git a/packages/chat/src/react.ts b/packages/chat/src/react.ts index ad847f02b3..9b00210031 100644 --- a/packages/chat/src/react.ts +++ b/packages/chat/src/react.ts @@ -1,5 +1,6 @@ /** React bindings for the core `Chat`: providers and `useChat`. Populated as the hooks move in. */ export * from './react/chat'; +export * from './react/stream'; export { MessageContext, MessagePartIndex, useMessageContext } from './react/message'; export { useMessagePartsHost, diff --git a/client/src/hooks/SSE/__tests__/useAdaptiveSSE.spec.ts b/packages/chat/src/react/stream/__tests__/adaptive.spec.tsx similarity index 53% rename from client/src/hooks/SSE/__tests__/useAdaptiveSSE.spec.ts rename to packages/chat/src/react/stream/__tests__/adaptive.spec.tsx index 099d3c936d..be5c10e9cc 100644 --- a/client/src/hooks/SSE/__tests__/useAdaptiveSSE.spec.ts +++ b/packages/chat/src/react/stream/__tests__/adaptive.spec.tsx @@ -1,12 +1,28 @@ +/** + * @jest-environment jsdom + */ +import React from 'react'; import { renderHook } from '@testing-library/react'; import { EModelEndpoint } from 'librechat-data-provider'; import type { TSubmission } from 'librechat-data-provider'; -import useResumableSSE from '../useResumableSSE'; -import useAdaptiveSSE from '../useAdaptiveSSE'; -import useSSE from '../useSSE'; +import type { StreamHost } from '../host'; +import { StreamHostProvider } from '../host'; +import useResumableSSE from '../resumable'; +import useAdaptiveSSE from '../adaptive'; -jest.mock('../useSSE', () => jest.fn()); -jest.mock('../useResumableSSE', () => jest.fn(() => ({ streamId: 'stream' }))); +jest.mock('../resumable', () => jest.fn(() => ({ streamId: 'stream' }))); + +const useLegacyStream = jest.fn(); +const host: StreamHost = { + useResumableServices: () => () => { + throw new Error('the resumable binding is replaced in this spec'); + }, + useLegacyStream, +}; + +const wrapper = ({ children }: { children: React.ReactNode }) => ( + {children} +); const helpers = { setMessages: jest.fn(), @@ -30,19 +46,21 @@ it.each([ codeEnvironmentMode: 'attached', codeWorkspaces: [{ environmentId: 'vm', workspaceId: 'repo' }], } as TSubmission; - const { rerender } = renderHook(({ value }) => useAdaptiveSSE(value, helpers), { + const { rerender, result } = renderHook(({ value }) => useAdaptiveSSE(value, helpers), { initialProps: { value: submission as TSubmission | null }, + wrapper, }); - expect(useSSE).toHaveBeenLastCalledWith(null, helpers, false, 0); + expect(useLegacyStream).toHaveBeenLastCalledWith(null, helpers, false, 0); expect(useResumableSSE).toHaveBeenLastCalledWith(submission, helpers, false, 0); + expect(result.current).toEqual({ streamId: 'stream', resumableEnabled: true }); rerender({ value: null }); - expect(useSSE).toHaveBeenLastCalledWith(null, helpers, false, 0); + expect(useLegacyStream).toHaveBeenLastCalledWith(null, helpers, false, 0); }, ); it('preserves the Assistants transport and its server abort endpoint', () => { const submission = { conversation: { endpoint: EModelEndpoint.assistants } } as TSubmission; - renderHook(() => useAdaptiveSSE(submission, helpers)); - expect(useSSE).toHaveBeenLastCalledWith(submission, helpers, false, 0); + renderHook(() => useAdaptiveSSE(submission, helpers), { wrapper }); + expect(useLegacyStream).toHaveBeenLastCalledWith(submission, helpers, false, 0); expect(useResumableSSE).toHaveBeenLastCalledWith(null, helpers, false, 0); }); diff --git a/client/src/hooks/SSE/useAdaptiveSSE.ts b/packages/chat/src/react/stream/adaptive.ts similarity index 63% rename from client/src/hooks/SSE/useAdaptiveSSE.ts rename to packages/chat/src/react/stream/adaptive.ts index b1d6862718..5c733b3401 100644 --- a/client/src/hooks/SSE/useAdaptiveSSE.ts +++ b/packages/chat/src/react/stream/adaptive.ts @@ -1,38 +1,39 @@ import { isAssistantsEndpoint } from 'librechat-data-provider'; import type { TSubmission } from 'librechat-data-provider'; -import type { EventHandlerParams } from './useEventHandlers'; -import useResumableSSE from './useResumableSSE'; -import useSSE from './useSSE'; - -type ChatHelpers = Pick< - EventHandlerParams, - 'setMessages' | 'getMessages' | 'setConversation' | 'setIsSubmitting' | 'newConversation' ->; +import type { StreamChat } from './host'; +import useResumableSSE from './resumable'; +import { useStreamHost } from './host'; /** * Adaptive SSE hook that switches between standard and resumable modes. - * Uses resumable streams by default, falls back to standard SSE for assistants endpoints. + * Uses resumable streams by default, falls back to the host's standard SSE for assistants + * endpoints. * * Note: Both hooks are always called to comply with React's Rules of Hooks. * We pass null submission to the inactive one. */ export default function useAdaptiveSSE( submission: TSubmission | null, - chatHelpers: ChatHelpers, + chat: StreamChat, isAddedRequest = false, runIndex = 0, -) { +): { streamId: string | null; resumableEnabled: boolean } { const endpoint = submission?.conversation?.endpoint; const endpointType = submission?.conversation?.endpointType; const actualEndpoint = endpointType ?? endpoint; const isAssistants = isAssistantsEndpoint(actualEndpoint); const resumableEnabled = !isAssistants; - useSSE(resumableEnabled ? null : submission, chatHelpers, isAddedRequest, runIndex); + useStreamHost().useLegacyStream( + resumableEnabled ? null : submission, + chat, + isAddedRequest, + runIndex, + ); const { streamId } = useResumableSSE( resumableEnabled ? submission : null, - chatHelpers, + chat, isAddedRequest, runIndex, ); diff --git a/packages/chat/src/react/stream/host.tsx b/packages/chat/src/react/stream/host.tsx new file mode 100644 index 0000000000..d753c1a1fd --- /dev/null +++ b/packages/chat/src/react/stream/host.tsx @@ -0,0 +1,68 @@ +import { createContext, useContext } from 'react'; +import type { Dispatch, ReactNode, SetStateAction } from 'react'; +import type { TSubmission } from 'librechat-data-provider'; +import type { ResumableHost, ResumableRun } from '../../core'; +import type { ChatContract } from '../chat/contract'; + +/** The chat members a stream writes through: the message cache, the pane's conversation and its + * in-flight flag, and the generator a stream calls when the server starts a new chat. */ +export type StreamChat = Pick< + ChatContract, + 'setMessages' | 'getMessages' | 'setConversation' | 'setIsSubmitting' | 'newConversation' +>; + +/** One pane's resumable stream, as the host builds the services it runs on. */ +export type ResumableStreamParams = { + run: ResumableRun; + chat: StreamChat; + /** `0` for the main pane, `1` for the added (multi-convo) pane. */ + runIndex: number; + isAddedRequest: boolean; + /** Reports the stream the pane is attached to, or `null` once it detaches. */ + setStreamId: Dispatch>; +}; + +/** Everything a resumable stream runs on except how it re-attaches, which the binding owns. */ +export type ResumableServices = Omit; + +/** + * What the stream bindings need from the app that hosts them. Members are hooks, called + * unconditionally on every render, so the host can back each one with its own query cache, + * transport and store. A host must stay the same object for the life of the tree it wraps. + */ +export interface StreamHost { + /** + * Builds the services one pane's resumable stream runs on. The returned function is called + * whenever the stream mounts or re-attaches, so each attachment reads the services of the + * latest render; it changes only when they do. + */ + useResumableServices(params: ResumableStreamParams): () => ResumableServices; + /** Streams a turn that carries its own response (Assistants), for `submission` or none. */ + useLegacyStream( + submission: TSubmission | null, + chat: StreamChat, + isAddedRequest: boolean, + runIndex: number, + ): void; +} + +const StreamHostContext = createContext(null); + +/** Supplies the host the stream bindings read from. */ +export function StreamHostProvider({ + host, + children, +}: { + host: StreamHost; + children?: ReactNode; +}): ReactNode { + return {children}; +} + +export function useStreamHost(): StreamHost { + const host = useContext(StreamHostContext); + if (host == null) { + throw new Error('The stream hooks need a StreamHostProvider above them.'); + } + return host; +} diff --git a/packages/chat/src/react/stream/index.ts b/packages/chat/src/react/stream/index.ts new file mode 100644 index 0000000000..350dabbfa4 --- /dev/null +++ b/packages/chat/src/react/stream/index.ts @@ -0,0 +1,4 @@ +export { default as useAdaptiveSSE } from './adaptive'; +export { default as useResumableSSE } from './resumable'; +export { StreamHostProvider, useStreamHost } from './host'; +export type { StreamHost, StreamChat, ResumableServices, ResumableStreamParams } from './host'; diff --git a/packages/chat/src/react/stream/resumable.ts b/packages/chat/src/react/stream/resumable.ts new file mode 100644 index 0000000000..6bdda4b4c9 --- /dev/null +++ b/packages/chat/src/react/stream/resumable.ts @@ -0,0 +1,61 @@ +import { useState, useEffect, useCallback } from 'react'; +import type { TSubmission } from 'librechat-data-provider'; +import type { ResumableHost } from '../../core'; +import type { StreamChat } from './host'; +import { + ResumableRun, + mountSubmission, + releaseSubmission, + attachResumableStream, +} from '../../core'; +import { useStreamHost } from './host'; + +/** + * Hook for resumable SSE streams. + * Separates generation start (POST) from stream subscription (GET EventSource). + * Supports auto-reconnection with exponential backoff. + * + * Key behavior: + * - Navigation away does NOT abort the generation (just closes SSE) + * - Only explicit abort (via stop button, then the backend abort endpoint) stops generation + * - Backend emits `done` event with `aborted: true` on abort, handled via finalHandler + * + * The run itself is `mountSubmission` and `attachResumableStream`; the host supplies the + * services it runs on. + */ +export default function useResumableSSE( + submission: TSubmission | null, + chat: StreamChat, + isAddedRequest = false, + runIndex = 0, +): { streamId: string | null } { + const [run] = useState(() => new ResumableRun()); + const [streamId, setStreamId] = useState(null); + const buildServices = useStreamHost().useResumableServices({ + run, + chat, + runIndex, + isAddedRequest, + setStreamId, + }); + + const buildHost = useCallback( + (): ResumableHost => ({ + ...buildServices(), + subscribe: (next) => attachResumableStream(run, buildHost(), next), + }), + [run, buildServices], + ); + + useEffect(() => { + const host = buildHost(); + if (!submission || Object.keys(submission).length === 0) { + releaseSubmission(run, host); + return; + } + return mountSubmission(run, host, submission); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [submission]); + + return { streamId }; +}