@langchain/react 0.3.4 → 1.0.0

package/dist/stream.lgp.js

@@ -1,671 +0,0 @@
-"use client";
-import { useControllableThreadId } from "./thread.js";
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { Client, getClientConfigHash } from "@langchain/langgraph-sdk/client";
-import { MessageTupleManager, PendingRunsTracker, StreamError, StreamManager, ensureHistoryMessageInstances, ensureMessageInstances, extractInterrupts, filterStream, getBranchContext, getMessagesMetadataMap, onFinishRequiresThreadState, toMessageClass, unique, userFacingInterruptsFromThreadTasks, userFacingInterruptsFromValuesArray } from "@langchain/langgraph-sdk/ui";
-import { getToolCallsWithResults } from "@langchain/langgraph-sdk/utils";
-import { flushPendingHeadlessToolInterrupts } from "@langchain/langgraph-sdk";
-//#region src/stream.lgp.tsx
-function getFetchHistoryKey(client, threadId, limit) {
-	return [
-		getClientConfigHash(client),
-		threadId,
-		limit
-	].join(":");
-}
-function fetchHistory(client, threadId, options) {
-	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
-		if (state.checkpoint == null) return [];
-		return [state];
-	});
-	const limit = typeof options?.limit === "number" ? options.limit : 10;
-	return client.threads.getHistory(threadId, { limit });
-}
-function useThreadHistory(client, threadId, limit, options) {
-	const key = getFetchHistoryKey(client, threadId, limit);
-	const [state, setState] = useState(() => ({
-		key: void 0,
-		data: void 0,
-		error: void 0,
-		isLoading: threadId != null
-	}));
-	const clientRef = useRef(client);
-	clientRef.current = client;
-	const onErrorRef = useRef(options?.onError);
-	onErrorRef.current = options?.onError;
-	const fetcher = useCallback((threadId, limit) => {
-		if (options.passthrough) return Promise.resolve([]);
-		const client = clientRef.current;
-		const key = getFetchHistoryKey(client, threadId, limit);
-		if (threadId != null) {
-			setState((state) => {
-				if (state.key === key) return {
-					...state,
-					isLoading: true
-				};
-				return {
-					key,
-					data: void 0,
-					error: void 0,
-					isLoading: true
-				};
-			});
-			return fetchHistory(client, threadId, { limit }).then((data) => {
-				setState((state) => {
-					if (state.key !== key) return state;
-					return {
-						key,
-						data,
-						error: void 0,
-						isLoading: false
-					};
-				});
-				return data;
-			}, (error) => {
-				setState((state) => {
-					if (state.key !== key) return state;
-					return {
-						key,
-						data: state.data,
-						error,
-						isLoading: false
-					};
-				});
-				onErrorRef.current?.(error);
-				return Promise.reject(error);
-			});
-		}
-		setState({
-			key,
-			data: void 0,
-			error: void 0,
-			isLoading: false
-		});
-		return Promise.resolve([]);
-	}, [options.passthrough]);
-	useEffect(() => {
-		if (options.submittingRef.current != null && options.submittingRef.current === threadId) return;
-		fetcher(threadId, limit);
-	}, [fetcher, key]);
-	return {
-		data: state.data,
-		error: state.error,
-		isLoading: state.isLoading,
-		mutate: (mutateId) => fetcher(mutateId ?? threadId, limit)
-	};
-}
-function useTrackStreamMode() {
-	const trackStreamModeRef = useRef([]);
-	return [trackStreamModeRef, useCallback((...mode) => {
-		const ref = trackStreamModeRef.current;
-		for (const m of mode) if (!ref.includes(m)) ref.push(m);
-	}, [])];
-}
-function useCallbackStreamMode(options) {
-	const hasUpdateListener = options.onUpdateEvent != null;
-	const hasCustomListener = options.onCustomEvent != null;
-	const hasLangChainListener = options.onLangChainEvent != null;
-	const hasDebugListener = options.onDebugEvent != null;
-	const hasCheckpointListener = options.onCheckpointEvent != null;
-	const hasTaskListener = options.onTaskEvent != null;
-	return useMemo(() => {
-		const modes = [];
-		if (hasUpdateListener) modes.push("updates");
-		if (hasCustomListener) modes.push("custom");
-		if (hasLangChainListener) modes.push("events");
-		if (hasDebugListener) modes.push("debug");
-		if (hasCheckpointListener) modes.push("checkpoints");
-		if (hasTaskListener) modes.push("tasks");
-		return modes;
-	}, [
-		hasUpdateListener,
-		hasCustomListener,
-		hasLangChainListener,
-		hasDebugListener,
-		hasCheckpointListener,
-		hasTaskListener
-	]);
-}
-function useStreamLGP(options) {
-	const reconnectOnMountRef = useRef(options.reconnectOnMount);
-	const runMetadataStorage = useMemo(() => {
-		if (typeof window === "undefined") return null;
-		const storage = reconnectOnMountRef.current;
-		if (storage === true) return window.sessionStorage;
-		if (typeof storage === "function") return storage();
-		return null;
-	}, []);
-	const client = useMemo(() => options.client ?? new Client({
-		apiUrl: options.apiUrl,
-		apiKey: options.apiKey,
-		callerOptions: options.callerOptions,
-		defaultHeaders: options.defaultHeaders
-	}), [
-		options.client,
-		options.apiKey,
-		options.apiUrl,
-		options.callerOptions,
-		options.defaultHeaders
-	]);
-	const [messageManager] = useState(() => new MessageTupleManager());
-	const [stream] = useState(() => new StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages,
-		toMessage: options.toMessage ?? toMessageClass
-	}));
-	const [pendingRuns] = useState(() => new PendingRunsTracker());
-	useSyncExternalStore(pendingRuns.subscribe, pendingRuns.getSnapshot, pendingRuns.getSnapshot);
-	const [trackStreamModeRef, trackStreamMode] = useTrackStreamMode();
-	const callbackStreamMode = useCallbackStreamMode(options);
-	const getMessages = (value) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return {
-			...current,
-			[messagesKey]: messages
-		};
-	};
-	useSyncExternalStore(stream.subscribe, stream.getSnapshot, stream.getSnapshot);
-	const [threadId, onThreadId] = useControllableThreadId(options);
-	const threadIdRef = useRef(threadId);
-	const threadIdStreamingRef = useRef(null);
-	const threadIdPromiseRef = useRef(null);
-	useEffect(() => {
-		if (threadIdRef.current !== threadId) {
-			threadIdRef.current = threadId;
-			stream.clear();
-		}
-	}, [threadId, stream]);
-	const switchThread = useCallback((newThreadId) => {
-		if (newThreadId !== threadIdRef.current) {
-			const prevThreadId = threadIdRef.current;
-			threadIdRef.current = newThreadId;
-			stream.clear();
-			const removed = pendingRuns.removeAll();
-			if (prevThreadId && removed.length > 0) Promise.all(removed.map((e) => client.runs.cancel(prevThreadId, e.id)));
-			onThreadId(newThreadId);
-		}
-	}, [
-		stream,
-		pendingRuns,
-		onThreadId,
-		client
-	]);
-	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
-	const builtInHistory = useThreadHistory(client, threadId, historyLimit, {
-		passthrough: options.thread != null,
-		submittingRef: threadIdStreamingRef,
-		onError: options.onError
-	});
-	const history = options.thread ?? builtInHistory;
-	const [branch, setBranch] = useState("");
-	const branchContext = getBranchContext(branch, history.data ?? void 0);
-	const [toolProgressMap, setToolProgressMap] = useState(/* @__PURE__ */ new Map());
-	const handleToolEvent = useCallback((data) => {
-		setToolProgressMap((prev) => {
-			const next = new Map(prev);
-			const key = data.toolCallId ?? data.name;
-			const existing = next.get(key);
-			switch (data.event) {
-				case "on_tool_start":
-					next.set(key, {
-						toolCallId: data.toolCallId,
-						name: data.name,
-						state: "starting",
-						input: data.input
-					});
-					break;
-				case "on_tool_event":
-					if (existing) next.set(key, {
-						...existing,
-						state: "running",
-						data: data.data
-					});
-					break;
-				case "on_tool_end":
-					if (existing) next.set(key, {
-						...existing,
-						state: "completed",
-						result: data.output
-					});
-					break;
-				case "on_tool_error":
-					if (existing) next.set(key, {
-						...existing,
-						state: "error",
-						error: data.error
-					});
-					break;
-				default: throw new Error(`Unexpected tool event: ${data.event}`);
-			}
-			return next;
-		});
-	}, []);
-	const historyValues = branchContext.threadHead?.values ?? options.initialValues ?? {};
-	const historyMessages = getMessages(historyValues);
-	const shouldReconstructSubagents = options.filterSubagentMessages && !stream.isLoading && !history.isLoading && historyMessages.length > 0;
-	useEffect(() => {
-		if (shouldReconstructSubagents) {
-			stream.reconstructSubagents(historyMessages, { skipIfPopulated: true });
-			if (historyLimit !== false && threadId) {
-				const controller = new AbortController();
-				stream.fetchSubagentHistory(client.threads, threadId, {
-					messagesKey: options.messagesKey ?? "messages",
-					historyLimit: typeof historyLimit === "number" ? historyLimit : void 0,
-					signal: controller.signal
-				});
-				return () => controller.abort();
-			}
-		}
-	}, [shouldReconstructSubagents, historyMessages.length]);
-	const historyError = (() => {
-		const error = branchContext.threadHead?.tasks?.at(-1)?.error;
-		if (error == null) return void 0;
-		try {
-			const parsed = JSON.parse(error);
-			if (StreamError.isStructuredError(parsed)) return new StreamError(parsed);
-			return parsed;
-		} catch {}
-		return error;
-	})();
-	const messageMetadata = getMessagesMetadataMap({
-		initialValues: options.initialValues,
-		history: history.data,
-		getMessages,
-		branchContext
-	});
-	const stop = () => stream.stop(historyValues, { onStop: (args) => {
-		if (runMetadataStorage && threadId) {
-			const runId = runMetadataStorage.getItem(`lg:stream:${threadId}`);
-			if (runId) client.runs.cancel(threadId, runId);
-			runMetadataStorage.removeItem(`lg:stream:${threadId}`);
-		}
-		options.onStop?.(args);
-	} });
-	const submitDirect = async (values, submitOptions) => {
-		setToolProgressMap(/* @__PURE__ */ new Map());
-		const checkpointId = submitOptions?.checkpoint?.checkpoint_id;
-		setBranch(checkpointId != null ? branchContext.branchByCheckpoint[checkpointId]?.branch ?? "" : "");
-		const includeImplicitBranch = historyLimit === true || typeof historyLimit === "number";
-		const shouldRefetch = includeImplicitBranch || onFinishRequiresThreadState(options.onFinish);
-		let callbackMeta;
-		let rejoinKey;
-		let usableThreadId = threadId;
-		const shouldAbortPrevious = (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") && stream.isLoading;
-		await stream.start(async (signal) => {
-			stream.setStreamValues((values) => {
-				const prev = {
-					...historyValues,
-					...values
-				};
-				if (submitOptions?.optimisticValues != null) return {
-					...prev,
-					...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(prev) : submitOptions.optimisticValues
-				};
-				return { ...prev };
-			});
-			if (!usableThreadId) {
-				const threadPromise = client.threads.create({
-					threadId: submitOptions?.threadId,
-					metadata: submitOptions?.metadata,
-					signal
-				});
-				threadIdPromiseRef.current = threadPromise.then((t) => t.thread_id);
-				usableThreadId = (await threadPromise).thread_id;
-				threadIdRef.current = usableThreadId;
-				threadIdStreamingRef.current = usableThreadId;
-				onThreadId(usableThreadId);
-			}
-			if (!usableThreadId) throw new Error("Failed to obtain valid thread ID.");
-			threadIdStreamingRef.current = usableThreadId;
-			const streamMode = unique([
-				...submitOptions?.streamMode ?? [],
-				...trackStreamModeRef.current,
-				...callbackStreamMode
-			]);
-			let checkpoint = submitOptions?.checkpoint ?? (includeImplicitBranch ? branchContext.threadHead?.checkpoint : void 0) ?? void 0;
-			if (submitOptions?.checkpoint === null) checkpoint = void 0;
-			if (checkpoint != null) delete checkpoint.thread_id;
-			const streamResumable = submitOptions?.streamResumable ?? !!runMetadataStorage;
-			return client.runs.stream(usableThreadId, options.assistantId, {
-				input: values,
-				config: submitOptions?.config,
-				context: submitOptions?.context,
-				command: submitOptions?.command,
-				interruptBefore: submitOptions?.interruptBefore,
-				interruptAfter: submitOptions?.interruptAfter,
-				metadata: submitOptions?.metadata,
-				multitaskStrategy: submitOptions?.multitaskStrategy,
-				onCompletion: submitOptions?.onCompletion,
-				onDisconnect: submitOptions?.onDisconnect ?? (streamResumable ? "continue" : "cancel"),
-				signal,
-				checkpoint,
-				streamMode,
-				streamSubgraphs: submitOptions?.streamSubgraphs,
-				streamResumable,
-				durability: submitOptions?.durability,
-				onRunCreated(params) {
-					callbackMeta = {
-						run_id: params.run_id,
-						thread_id: params.thread_id ?? usableThreadId
-					};
-					if (runMetadataStorage) {
-						rejoinKey = `lg:stream:${usableThreadId}`;
-						runMetadataStorage.setItem(rejoinKey, callbackMeta.run_id);
-					}
-					options.onCreated?.(callbackMeta);
-				}
-			});
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues,
-			callbacks: {
-				...options,
-				onToolEvent: (data, opts) => {
-					handleToolEvent(data);
-					options.onToolEvent?.(data, opts);
-				}
-			},
-			async onSuccess() {
-				if (rejoinKey) runMetadataStorage?.removeItem(rejoinKey);
-				if (shouldRefetch) {
-					const lastHead = (await history.mutate(usableThreadId))?.at(0);
-					if (lastHead) {
-						options.onFinish?.(lastHead, callbackMeta);
-						return null;
-					}
-				} else if (options.onFinish != null && !onFinishRequiresThreadState(options.onFinish)) options.onFinish(void 0, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-				submitOptions?.onError?.(error, callbackMeta);
-			},
-			onFinish() {
-				threadIdStreamingRef.current = null;
-			}
-		}, { abortPrevious: shouldAbortPrevious });
-	};
-	const submitDirectRef = useRef(submitDirect);
-	submitDirectRef.current = submitDirect;
-	const submittingRef = useRef(false);
-	const drainQueueRef = useRef(() => {});
-	const submit = async (values, submitOptions) => {
-		if (stream.isLoading || submittingRef.current) {
-			if (submitOptions?.multitaskStrategy === "interrupt" || submitOptions?.multitaskStrategy === "rollback") {
-				submittingRef.current = true;
-				try {
-					await submitDirect(values, submitOptions);
-				} finally {
-					submittingRef.current = false;
-				}
-				return;
-			}
-			let usableThreadId = threadIdRef.current ?? threadId;
-			if (!usableThreadId && threadIdPromiseRef.current) usableThreadId = await threadIdPromiseRef.current;
-			if (usableThreadId) {
-				try {
-					const run = await client.runs.create(usableThreadId, options.assistantId, {
-						input: values,
-						config: submitOptions?.config,
-						context: submitOptions?.context,
-						command: submitOptions?.command,
-						interruptBefore: submitOptions?.interruptBefore,
-						interruptAfter: submitOptions?.interruptAfter,
-						metadata: submitOptions?.metadata,
-						multitaskStrategy: "enqueue",
-						streamResumable: true,
-						streamSubgraphs: submitOptions?.streamSubgraphs,
-						durability: submitOptions?.durability
-					});
-					pendingRuns.add({
-						id: run.run_id,
-						values,
-						options: submitOptions,
-						createdAt: new Date(run.created_at)
-					});
-				} catch (error) {
-					options.onError?.(error, void 0);
-					submitOptions?.onError?.(error, void 0);
-				}
-				return;
-			}
-		}
-		submittingRef.current = true;
-		try {
-			await submitDirect(values, submitOptions);
-		} finally {
-			submittingRef.current = false;
-			drainQueueRef.current();
-		}
-	};
-	const joinStream = async (runId, lastEventId, joinOptions) => {
-		setToolProgressMap(/* @__PURE__ */ new Map());
-		lastEventId ??= "-1";
-		if (!threadId) return;
-		const callbackMeta = {
-			thread_id: threadId,
-			run_id: runId
-		};
-		const shouldRefetchJoin = historyLimit === true || typeof historyLimit === "number" || onFinishRequiresThreadState(options.onFinish);
-		await stream.start(async (signal) => {
-			threadIdStreamingRef.current = threadId;
-			const stream = client.runs.joinStream(threadId, runId, {
-				signal,
-				lastEventId,
-				streamMode: joinOptions?.streamMode
-			});
-			return joinOptions?.filter != null ? filterStream(stream, joinOptions.filter) : stream;
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: historyValues,
-			callbacks: {
-				...options,
-				onToolEvent: (data, opts) => {
-					handleToolEvent(data);
-					options.onToolEvent?.(data, opts);
-				}
-			},
-			async onSuccess() {
-				runMetadataStorage?.removeItem(`lg:stream:${threadId}`);
-				if (!shouldRefetchJoin) {
-					if (options.onFinish != null && !onFinishRequiresThreadState(options.onFinish)) options.onFinish(void 0, callbackMeta);
-					return;
-				}
-				const lastHead = (await history.mutate(threadId))?.at(0);
-				if (lastHead) options.onFinish?.(lastHead, callbackMeta);
-			},
-			onError(error) {
-				options.onError?.(error, callbackMeta);
-			},
-			onFinish() {
-				threadIdStreamingRef.current = null;
-			}
-		});
-	};
-	const joinStreamRef = useRef(joinStream);
-	joinStreamRef.current = joinStream;
-	const drainQueue = () => {
-		if (!stream.isLoading && !submittingRef.current && pendingRuns.size > 0) {
-			const next = pendingRuns.shift();
-			if (next) {
-				submittingRef.current = true;
-				joinStreamRef.current(next.id).finally(() => {
-					submittingRef.current = false;
-					drainQueue();
-				});
-			}
-		}
-	};
-	drainQueueRef.current = drainQueue;
-	useEffect(() => {
-		drainQueueRef.current();
-	}, [stream.isLoading, pendingRuns.size]);
-	const reconnectKey = useMemo(() => {
-		if (!runMetadataStorage || stream.isLoading) return void 0;
-		if (typeof window === "undefined") return void 0;
-		const runId = runMetadataStorage?.getItem(`lg:stream:${threadId}`);
-		if (!runId) return void 0;
-		return {
-			runId,
-			threadId
-		};
-	}, [
-		runMetadataStorage,
-		stream.isLoading,
-		threadId
-	]);
-	const shouldReconnect = !!runMetadataStorage;
-	const reconnectRef = useRef({
-		threadId,
-		shouldReconnect
-	});
-	useEffect(() => {
-		if (reconnectRef.current.threadId !== threadId) reconnectRef.current = {
-			threadId,
-			shouldReconnect
-		};
-	}, [threadId, shouldReconnect]);
-	useEffect(() => {
-		if (reconnectKey && reconnectRef.current.shouldReconnect) {
-			reconnectRef.current.shouldReconnect = false;
-			joinStreamRef.current?.(reconnectKey.runId);
-		}
-	}, [reconnectKey]);
-	const error = stream.error ?? historyError ?? history.error;
-	const values = stream.values ?? historyValues;
-	const handledToolsRef = useRef(/* @__PURE__ */ new Set());
-	useEffect(() => {
-		handledToolsRef.current.clear();
-	}, [threadId]);
-	useEffect(() => {
-		flushPendingHeadlessToolInterrupts(values, options.tools, handledToolsRef.current, {
-			onTool: options.onTool,
-			defer: (run) => {
-				Promise.resolve().then(run);
-			},
-			resumeSubmit: (command) => submit(null, {
-				multitaskStrategy: "interrupt",
-				command
-			})
-		});
-	}, [
-		options.onTool,
-		options.tools,
-		submit,
-		values
-	]);
-	return {
-		get values() {
-			trackStreamMode("values");
-			return values;
-		},
-		client,
-		assistantId: options.assistantId,
-		error,
-		isLoading: stream.isLoading,
-		stop,
-		submit,
-		switchThread,
-		joinStream,
-		branch,
-		setBranch,
-		get history() {
-			if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `history`");
-			return ensureHistoryMessageInstances(branchContext.flatHistory, options.messagesKey ?? "messages");
-		},
-		isThreadLoading: history.isLoading && history.data == null,
-		get experimental_branchTree() {
-			if (historyLimit === false) throw new Error("`fetchStateHistory` must be set to `true` to use `experimental_branchTree`");
-			return branchContext.branchTree;
-		},
-		get interrupts() {
-			if (values != null && "__interrupt__" in values && Array.isArray(values.__interrupt__)) return userFacingInterruptsFromValuesArray(values.__interrupt__);
-			if (stream.isLoading) return [];
-			const taskInterrupts = userFacingInterruptsFromThreadTasks((branchContext.threadHead?.tasks ?? []).flatMap((t) => t.interrupts ?? []));
-			if (taskInterrupts != null) return taskInterrupts;
-			if (!(branchContext.threadHead?.next ?? []).length || error != null) return [];
-			return [{ when: "breakpoint" }];
-		},
-		get interrupt() {
-			return extractInterrupts(values, {
-				error,
-				isLoading: stream.isLoading,
-				threadState: branchContext.threadHead
-			});
-		},
-		get messages() {
-			trackStreamMode("messages-tuple", "values");
-			return ensureMessageInstances(getMessages(values));
-		},
-		get toolCalls() {
-			trackStreamMode("messages-tuple", "values");
-			return getToolCallsWithResults(getMessages(values));
-		},
-		get toolProgress() {
-			trackStreamMode("tools");
-			return Array.from(toolProgressMap.values());
-		},
-		getToolCalls(message) {
-			trackStreamMode("messages-tuple", "values");
-			return getToolCallsWithResults(getMessages(values)).filter((tc) => tc.aiMessage.id === message.id);
-		},
-		getMessagesMetadata(message, index) {
-			trackStreamMode("values");
-			const streamMetadata = messageManager.get(message.id)?.metadata;
-			const historyMetadata = messageMetadata?.find((m) => m.messageId === (message.id ?? index));
-			if (streamMetadata != null || historyMetadata != null) return {
-				...historyMetadata,
-				streamMetadata
-			};
-		},
-		get subagents() {
-			trackStreamMode("updates", "messages-tuple");
-			return stream.getSubagents();
-		},
-		get activeSubagents() {
-			trackStreamMode("updates", "messages-tuple");
-			return stream.getActiveSubagents();
-		},
-		getSubagent(toolCallId) {
-			trackStreamMode("updates", "messages-tuple");
-			return stream.getSubagent(toolCallId);
-		},
-		getSubagentsByType(type) {
-			trackStreamMode("updates", "messages-tuple");
-			return stream.getSubagentsByType(type);
-		},
-		getSubagentsByMessage(messageId) {
-			trackStreamMode("updates", "messages-tuple");
-			return stream.getSubagentsByMessage(messageId);
-		},
-		queue: {
-			get entries() {
-				return pendingRuns.entries;
-			},
-			get size() {
-				return pendingRuns.size;
-			},
-			async cancel(id) {
-				const usableThreadId = threadIdRef.current ?? threadId;
-				const removed = pendingRuns.remove(id);
-				if (removed && usableThreadId) await client.runs.cancel(usableThreadId, id);
-				return removed;
-			},
-			async clear() {
-				const usableThreadId = threadIdRef.current ?? threadId;
-				const removed = pendingRuns.removeAll();
-				if (usableThreadId && removed.length > 0) await Promise.all(removed.map((e) => client.runs.cancel(usableThreadId, e.id)));
-			}
-		}
-	};
-}
-//#endregion
-export { useStreamLGP };
-
-//# sourceMappingURL=stream.lgp.js.map