@parallelworks/ui 0.19.0 → 0.19.1

package/dist/ai/core/KeyboardShortcutsProvider.js

@@ -0,0 +1,9 @@
+import { useKeyboardShortcuts } from "./useKeyboardShortcuts.js";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/ai/core/KeyboardShortcutsProvider.tsx
+function KeyboardShortcutsProvider({ children }) {
+	useKeyboardShortcuts({ enabled: true });
+	return /* @__PURE__ */ jsx(Fragment, { children });
+}
+//#endregion
+export { KeyboardShortcutsProvider };

package/dist/ai/core/chatReducer.js

@@ -0,0 +1,223 @@
+import { applyPartDelta } from "./parts.js";
+//#region src/ai/core/chatReducer.ts
+var initialState = {
+	conversations: [],
+	currentConversation: null,
+	providers: [],
+	models: [],
+	unreachableSessions: [],
+	selectedProvider: null,
+	selectedAllocation: null,
+	isLoading: false,
+	isLoadingConversation: false,
+	isLoadingModels: false,
+	hasLoadedModels: false,
+	modelsError: null,
+	isStreaming: false,
+	isThinking: false,
+	streamingContent: "",
+	streamingReasoning: "",
+	streamingParts: [],
+	thinkingStartTime: null,
+	sidebarCollapsed: false,
+	queuedMessages: []
+};
+function chatReducer(state, action) {
+	switch (action.type) {
+		case "SET_CONVERSATIONS": return {
+			...state,
+			conversations: action.conversations
+		};
+		case "SET_CURRENT_CONVERSATION":
+			if (action.conversation) {
+				const isNewConversation = state.currentConversation?.id !== action.conversation.id;
+				let restoredProvider = state.selectedProvider;
+				if (isNewConversation) {
+					const messages = action.conversation.messages || [];
+					for (let i = messages.length - 1; i >= 0; i--) {
+						const msg = messages[i];
+						if (msg.role === "assistant" && msg.model) {
+							if (!state.hasLoadedModels || state.models.some((m) => m.id === msg.model)) restoredProvider = msg.model;
+							break;
+						}
+					}
+				}
+				return {
+					...state,
+					currentConversation: {
+						...action.conversation,
+						messages: action.conversation.messages || []
+					},
+					selectedProvider: restoredProvider,
+					...isNewConversation && {
+						streamingContent: "",
+						streamingReasoning: "",
+						streamingParts: [],
+						isStreaming: false,
+						isThinking: false,
+						thinkingStartTime: null,
+						queuedMessages: []
+					}
+				};
+			}
+			return {
+				...state,
+				currentConversation: null,
+				isLoadingConversation: false,
+				streamingContent: "",
+				streamingReasoning: "",
+				streamingParts: [],
+				isStreaming: false,
+				isThinking: false,
+				thinkingStartTime: null,
+				queuedMessages: []
+			};
+		case "UPDATE_CURRENT_CONVERSATION_TITLE":
+			if (!state.currentConversation) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					title: action.title
+				}
+			};
+		case "SET_PROVIDERS": return {
+			...state,
+			providers: action.providers
+		};
+		case "SET_MODELS": return {
+			...state,
+			models: action.models,
+			unreachableSessions: action.unreachableSessions || [],
+			hasLoadedModels: true,
+			modelsError: null
+		};
+		case "SET_SELECTED_PROVIDER": return {
+			...state,
+			selectedProvider: action.providerId
+		};
+		case "SET_SELECTED_ALLOCATION": return {
+			...state,
+			selectedAllocation: action.allocation
+		};
+		case "SET_LOADING": return {
+			...state,
+			isLoading: action.isLoading
+		};
+		case "SET_LOADING_MODELS": return {
+			...state,
+			isLoadingModels: action.isLoadingModels
+		};
+		case "SET_MODELS_ERROR": return {
+			...state,
+			modelsError: action.error,
+			hasLoadedModels: true
+		};
+		case "SET_STREAMING":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				isStreaming: action.isStreaming
+			};
+		case "SET_THINKING": return {
+			...state,
+			isThinking: action.isThinking,
+			thinkingStartTime: action.isThinking ? Date.now() : state.thinkingStartTime
+		};
+		case "APPEND_STREAMING_CONTENT":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingContent: state.streamingContent + action.content,
+				isThinking: false
+			};
+		case "APPEND_STREAMING_REASONING":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingReasoning: state.streamingReasoning + action.reasoning,
+				isThinking: true,
+				thinkingStartTime: state.thinkingStartTime || Date.now()
+			};
+		case "APPLY_STREAMING_PART":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingParts: applyPartDelta(state.streamingParts, action.delta)
+			};
+		case "CLEAR_STREAMING_CONTENT":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingContent: "",
+				streamingReasoning: "",
+				streamingParts: [],
+				isThinking: false,
+				thinkingStartTime: null
+			};
+		case "ADD_MESSAGE":
+			if (!state.currentConversation || state.currentConversation.id !== action.conversationId) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					messages: [...state.currentConversation.messages || [], action.message],
+					activeBranchId: action.message.id
+				}
+			};
+		case "UPDATE_MESSAGE":
+			if (!state.currentConversation || state.currentConversation.id !== action.conversationId) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					messages: (state.currentConversation.messages || []).map((msg) => msg.id === action.messageId ? {
+						...msg,
+						...action.updates
+					} : msg)
+				}
+			};
+		case "TOGGLE_SIDEBAR": return {
+			...state,
+			sidebarCollapsed: !state.sidebarCollapsed
+		};
+		case "ADD_CONVERSATION":
+			if (state.conversations.some((c) => c.id === action.conversation.id)) return state;
+			return {
+				...state,
+				conversations: [action.conversation, ...state.conversations]
+			};
+		case "REMOVE_CONVERSATION": return {
+			...state,
+			conversations: state.conversations.filter((c) => c.id !== action.conversationId)
+		};
+		case "SET_LOADING_CONVERSATION": return {
+			...state,
+			isLoadingConversation: action.isLoadingConversation
+		};
+		case "RESTORE_BACKGROUND_STREAM": return {
+			...state,
+			streamingContent: action.content,
+			streamingReasoning: action.reasoning,
+			streamingParts: action.parts ?? [],
+			isStreaming: true
+		};
+		case "ADD_QUEUED_MESSAGE":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				queuedMessages: [...state.queuedMessages, action.message]
+			};
+		case "REMOVE_QUEUED_MESSAGE": return {
+			...state,
+			queuedMessages: state.queuedMessages.filter((m) => m.id !== action.id)
+		};
+		case "CLEAR_QUEUED_MESSAGES": return {
+			...state,
+			queuedMessages: []
+		};
+		default: return state;
+	}
+}
+//#endregion
+export { chatReducer, initialState };

package/dist/ai/core/config.js

@@ -0,0 +1,45 @@
+import { defaultChatStrings } from "../strings.js";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/ai/core/config.tsx
+function hrefFor(target) {
+	switch (target.kind) {
+		case "conversation": return `/chat/${target.id}`;
+		case "attachments": return "/chat/attachments";
+		case "external": return target.href;
+	}
+}
+function DefaultLink({ target, className, title, onClick, children }) {
+	return /* @__PURE__ */ jsx("a", {
+		href: hrefFor(target),
+		className,
+		title,
+		onClick,
+		children
+	});
+}
+function resolveStrings(overrides) {
+	const merged = {};
+	for (const key of Object.keys(defaultChatStrings)) merged[key] = {
+		...defaultChatStrings[key],
+		...overrides?.[key]
+	};
+	return merged;
+}
+function resolveChatConfig(config) {
+	return {
+		LinkComponent: config?.LinkComponent ?? DefaultLink,
+		extraLinks: config?.extraLinks ?? {},
+		slots: config?.slots ?? {},
+		strings: resolveStrings(config?.strings),
+		...config?.markdownComponents ? { markdownComponents: config.markdownComponents } : {},
+		...config?.suggestedPrompts ? { suggestedPrompts: config.suggestedPrompts } : {}
+	};
+}
+var ChatConfigContext = createContext(resolveChatConfig());
+var ChatConfigProvider = ChatConfigContext.Provider;
+function useChatConfig() {
+	return useContext(ChatConfigContext);
+}
+//#endregion
+export { ChatConfigProvider, resolveChatConfig, useChatConfig };

package/dist/ai/core/events.js

@@ -0,0 +1,4 @@
+//#region src/ai/core/events.ts
+var FOCUS_SIDEBAR_SEARCH_EVENT = "aichat:focus-sidebar-search";
+//#endregion
+export { FOCUS_SIDEBAR_SEARCH_EVENT };

package/dist/ai/core/exportConversation.js

@@ -0,0 +1,42 @@
+import { DateTime } from "luxon";
+//#region src/ai/core/exportConversation.ts
+function conversationToMarkdown(conversation) {
+	const lines = [];
+	lines.push(`# ${conversation.title?.trim() || "Conversation"}`);
+	if (conversation.createdAt) {
+		const dt = DateTime.fromISO(conversation.createdAt);
+		if (dt.isValid) {
+			lines.push("");
+			lines.push(`> Started ${dt.toLocaleString(DateTime.DATETIME_MED)}`);
+		}
+	}
+	for (const message of conversation.messages) {
+		if (message.role !== "user" && message.role !== "assistant") continue;
+		const hasAttachments = (message.attachments?.length ?? 0) > 0;
+		if (!message.content?.trim() && !hasAttachments && !message.error) continue;
+		lines.push("");
+		lines.push(message.role === "user" ? "## User" : "## Assistant");
+		lines.push("");
+		if (message.content?.trim()) lines.push(message.content.trim());
+		for (const attachment of message.attachments ?? []) lines.push(`> Attached: ${attachment.filename}`);
+		if (message.error) lines.push(`> Error: ${message.error}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function exportFilename(title) {
+	return `${(title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "conversation"}.md`;
+}
+function downloadText(filename, text) {
+	const blob = new Blob([text], { type: "text/markdown;charset=utf-8" });
+	const url = URL.createObjectURL(blob);
+	const anchor = document.createElement("a");
+	anchor.href = url;
+	anchor.download = filename;
+	document.body.appendChild(anchor);
+	anchor.click();
+	anchor.remove();
+	URL.revokeObjectURL(url);
+}
+//#endregion
+export { conversationToMarkdown, downloadText, exportFilename };

package/dist/ai/core/greeting.js

@@ -0,0 +1,38 @@
+//#region src/ai/core/greeting.ts
+function getGreeting(user) {
+	const hour = (/* @__PURE__ */ new Date()).getHours();
+	let timeOfDay;
+	if (hour >= 5 && hour < 12) timeOfDay = "morning";
+	else if (hour >= 12 && hour < 18) timeOfDay = "afternoon";
+	else timeOfDay = "evening";
+	const greetings = {
+		morning: [
+			`Good morning[name]! How can I help you today?`,
+			`Morning[name]! What can I assist you with?`,
+			`Rise and shine[name]! What's on your mind this morning?`,
+			`Good morning[name]! How can I make your day easier?`
+		],
+		afternoon: [
+			`Good afternoon[name]! What can I help you with today?`,
+			`Hello[name]! How can I assist you this afternoon?`,
+			`What can I help you accomplish today[name]?`,
+			`Afternoon[name]! What questions do you have?`
+		],
+		evening: [
+			`Good evening[name]! How can I assist you?`,
+			`Evening[name]! What's on your mind?`,
+			`How can I help you tonight[name]?`,
+			`What can I do for you this evening[name]?`
+		]
+	};
+	const randomIndex = Math.floor(Math.random() * greetings[timeOfDay].length);
+	let greeting = greetings[timeOfDay][randomIndex] ?? "";
+	if (user?.name) {
+		const firstName = user.name.split(" ")[0];
+		if (Math.random() > .5) greeting = greeting.replace("[name]", `, ${firstName}`);
+	}
+	greeting = greeting.replace("[name]", "");
+	return greeting;
+}
+//#endregion
+export { getGreeting };

package/dist/ai/core/parts.js

@@ -0,0 +1,84 @@
+//#region src/ai/core/parts.ts
+/** Fold one streamed PartDelta into a parts timeline. Pure: returns a new
+*  array, leaving the input untouched, so it works for both reducer state
+*  and the provider's local accumulation. Unknown target ids are dropped
+*  rather than invented — an end without a start has nothing to render. */
+function applyPartDelta(parts, delta) {
+	switch (delta.type) {
+		case "tool_start": return [...parts, {
+			kind: "tool_call",
+			id: delta.id,
+			name: delta.name,
+			args: delta.args,
+			status: "running",
+			...delta.startLine !== void 0 ? { startLine: delta.startLine } : {}
+		}];
+		case "tool_update": return parts.map((p) => p.kind === "tool_call" && p.id === delta.id ? {
+			...p,
+			args: p.args + delta.args
+		} : p);
+		case "tool_end": return parts.map((p) => p.kind === "tool_call" && p.id === delta.id ? {
+			...p,
+			status: delta.isError ? "error" : "ok",
+			result: delta.result
+		} : p);
+		case "subagent_start": {
+			const part = {
+				kind: "subagent",
+				id: delta.id,
+				status: "running",
+				actions: [],
+				...delta.agentType !== void 0 ? { agentType: delta.agentType } : {},
+				...delta.color !== void 0 ? { color: delta.color } : {},
+				...delta.background !== void 0 ? { background: delta.background } : {},
+				...delta.description !== void 0 ? { description: delta.description } : {}
+			};
+			return [...parts, part];
+		}
+		case "subagent_action": return parts.map((p) => p.kind === "subagent" && p.id === delta.id ? {
+			...p,
+			actions: [...p.actions ?? [], delta.action]
+		} : p);
+		case "subagent_end": return parts.map((p) => p.kind === "subagent" && p.id === delta.id ? {
+			...p,
+			status: delta.ok ? "done" : "failed",
+			...delta.summary !== void 0 ? { summary: delta.summary } : {},
+			...delta.report !== void 0 ? { report: delta.report } : {}
+		} : p);
+		case "approval_request": return [...parts, delta.approval];
+		case "approval_resolved": return parts.map((p) => p.kind === "approval" && p.id === delta.id ? {
+			...p,
+			resolved: true,
+			...delta.answer !== void 0 ? { answer: delta.answer } : {}
+		} : p);
+		case "notice":
+		case "warning": return [...parts, {
+			kind: delta.type,
+			text: delta.text
+		}];
+		case "todo_snapshot": {
+			const idx = parts.findLastIndex((p) => p.kind === "todo_snapshot");
+			if (idx === -1) return [...parts, {
+				kind: "todo_snapshot",
+				todos: delta.todos
+			}];
+			return parts.map((p, i) => i === idx ? {
+				kind: "todo_snapshot",
+				todos: delta.todos
+			} : p);
+		}
+		default: return parts;
+	}
+}
+/** A turn can end (completed or stopped) with tool calls still marked
+*  running — the transport died before their tool_end arrived. A stored
+*  message must not spin forever, so close them out as interrupted. */
+function finalizeParts(parts) {
+	return parts.map((p) => p.kind === "tool_call" && p.status === "running" ? {
+		...p,
+		status: "error",
+		result: p.result ?? "interrupted"
+	} : p);
+}
+//#endregion
+export { applyPartDelta, finalizeParts };

package/dist/ai/core/useDragDrop.js

@@ -0,0 +1,36 @@
+import { useCallback, useRef, useState } from "react";
+//#region src/ai/core/useDragDrop.ts
+function useDragDrop({ onFilesDropped }) {
+	const [isDragging, setIsDragging] = useState(false);
+	const dragCounterRef = useRef(0);
+	return {
+		isDragging,
+		dragHandlers: {
+			onDragEnter: useCallback((e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				dragCounterRef.current++;
+				if (e.dataTransfer.types.includes("Files")) setIsDragging(true);
+			}, []),
+			onDragLeave: useCallback((e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				dragCounterRef.current--;
+				if (dragCounterRef.current === 0) setIsDragging(false);
+			}, []),
+			onDragOver: useCallback((e) => {
+				e.preventDefault();
+				e.stopPropagation();
+			}, []),
+			onDrop: useCallback((e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				dragCounterRef.current = 0;
+				setIsDragging(false);
+				if (e.dataTransfer.files.length > 0) onFilesDropped(e.dataTransfer.files);
+			}, [onFilesDropped])
+		}
+	};
+}
+//#endregion
+export { useDragDrop as default };

package/dist/ai/core/useKeyboardShortcuts.js

@@ -0,0 +1,77 @@
+import { useChat } from "./ChatProvider.js";
+import { isMac } from "../utils.js";
+import { FOCUS_SIDEBAR_SEARCH_EVENT } from "./events.js";
+import { useCallback, useEffect } from "react";
+//#region src/ai/core/useKeyboardShortcuts.ts
+function useKeyboardShortcuts(options = {}) {
+	const { enabled = true } = options;
+	const { currentConversation, isStreaming, stopStreaming, clearCurrentConversation, navigation, notify } = useChat();
+	const getLastAssistantMessage = useCallback(() => {
+		const messages = currentConversation?.messages || [];
+		for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "assistant" && messages[i].content) return messages[i].content;
+		return null;
+	}, [currentConversation?.messages]);
+	const getLastUserMessage = useCallback(() => {
+		const messages = currentConversation?.messages || [];
+		for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "user") return messages[i];
+		return null;
+	}, [currentConversation?.messages]);
+	const handleNewConversation = useCallback(() => {
+		clearCurrentConversation();
+		navigation.toNewChat();
+	}, [clearCurrentConversation, navigation]);
+	const handleCopyLastResponse = useCallback(async () => {
+		const content = getLastAssistantMessage();
+		if (content) try {
+			await navigator.clipboard.writeText(content);
+			notify.success("Copied to clipboard");
+		} catch {
+			notify.error("Failed to copy");
+		}
+		else notify.info("No response to copy");
+	}, [getLastAssistantMessage, notify]);
+	const handleStopGeneration = useCallback(() => {
+		if (isStreaming) stopStreaming();
+	}, [isStreaming, stopStreaming]);
+	useEffect(() => {
+		if (!enabled) return;
+		const handleKeyDown = (e) => {
+			const cmdKey = isMac() ? e.metaKey : e.ctrlKey;
+			if (e.key === "Escape") {
+				handleStopGeneration();
+				return;
+			}
+			if (cmdKey && e.shiftKey && e.key === "O") {
+				e.preventDefault();
+				handleNewConversation();
+				return;
+			}
+			if (cmdKey && e.shiftKey && e.key === "C") {
+				e.preventDefault();
+				handleCopyLastResponse();
+				return;
+			}
+			if (cmdKey && e.shiftKey && e.key === "F") {
+				e.preventDefault();
+				document.dispatchEvent(new Event(FOCUS_SIDEBAR_SEARCH_EVENT));
+				return;
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [
+		enabled,
+		handleNewConversation,
+		handleCopyLastResponse,
+		handleStopGeneration
+	]);
+	return {
+		getLastUserMessage,
+		getLastAssistantMessage,
+		handleNewConversation,
+		handleCopyLastResponse,
+		handleStopGeneration
+	};
+}
+//#endregion
+export { useKeyboardShortcuts };

package/dist/ai/core/useSSEStream.js

@@ -0,0 +1,98 @@
+import { useCallback, useEffect, useRef } from "react";
+//#region src/ai/core/useSSEStream.ts
+function useSSEStream(dispatch) {
+	const targetStreamContentRef = useRef("");
+	const revealedLengthRef = useRef(0);
+	const streamRafRef = useRef(null);
+	const streamActiveRef = useRef(false);
+	const lastFrameTimeRef = useRef(0);
+	const lastDispatchTimeRef = useRef(0);
+	const streamingConversationIdRef = useRef(null);
+	const backgroundStreamsRef = useRef(/* @__PURE__ */ new Map());
+	const abortControllerRef = useRef(null);
+	const animateStreamContent = useCallback(() => {
+		const now = performance.now();
+		const target = targetStreamContentRef.current;
+		const revealed = revealedLengthRef.current;
+		const remaining = target.length - revealed;
+		const conversationId = streamingConversationIdRef.current;
+		const timeSinceDispatch = now - lastDispatchTimeRef.current;
+		if (remaining > 0 && timeSinceDispatch >= 32 && conversationId) {
+			const dt = lastFrameTimeRef.current ? now - lastFrameTimeRef.current : 32;
+			const newRevealed = revealed + Math.min(remaining, Math.max(1, Math.round((remaining > 360 ? .48 : .24) * dt)));
+			revealedLengthRef.current = newRevealed;
+			dispatch({
+				type: "APPEND_STREAMING_CONTENT",
+				content: target.slice(revealed, newRevealed),
+				conversationId
+			});
+			lastDispatchTimeRef.current = now;
+		}
+		lastFrameTimeRef.current = now;
+		if (streamActiveRef.current || revealedLengthRef.current < targetStreamContentRef.current.length) streamRafRef.current = requestAnimationFrame(animateStreamContent);
+		else {
+			streamRafRef.current = null;
+			lastFrameTimeRef.current = 0;
+		}
+	}, [dispatch]);
+	const onStreamingChunk = useCallback((chunk) => {
+		const convId = streamingConversationIdRef.current;
+		if (convId) {
+			const bgStream = backgroundStreamsRef.current.get(convId);
+			if (bgStream) bgStream.content += chunk;
+		}
+		if (!streamActiveRef.current) return;
+		targetStreamContentRef.current += chunk;
+		if (streamRafRef.current === null) streamRafRef.current = requestAnimationFrame(animateStreamContent);
+	}, [animateStreamContent]);
+	const startStreaming = useCallback((conversationId) => {
+		streamingConversationIdRef.current = conversationId;
+		streamActiveRef.current = true;
+	}, []);
+	const stopAnimationLoop = useCallback(() => {
+		const conversationId = streamingConversationIdRef.current;
+		streamActiveRef.current = false;
+		if (streamRafRef.current !== null) {
+			cancelAnimationFrame(streamRafRef.current);
+			streamRafRef.current = null;
+		}
+		const unrevealed = targetStreamContentRef.current.slice(revealedLengthRef.current);
+		targetStreamContentRef.current = "";
+		revealedLengthRef.current = 0;
+		lastFrameTimeRef.current = 0;
+		lastDispatchTimeRef.current = 0;
+		return {
+			unrevealed,
+			conversationId
+		};
+	}, []);
+	const resetAnimationRefs = useCallback(() => {
+		streamActiveRef.current = false;
+		if (streamRafRef.current !== null) {
+			cancelAnimationFrame(streamRafRef.current);
+			streamRafRef.current = null;
+		}
+		targetStreamContentRef.current = "";
+		revealedLengthRef.current = 0;
+		lastFrameTimeRef.current = 0;
+		lastDispatchTimeRef.current = 0;
+	}, []);
+	useEffect(() => {
+		return () => {
+			if (streamRafRef.current !== null) cancelAnimationFrame(streamRafRef.current);
+		};
+	}, []);
+	return {
+		onStreamingChunk,
+		startStreaming,
+		stopAnimationLoop,
+		resetAnimationRefs,
+		targetStreamContentRef,
+		streamActiveRef,
+		streamingConversationIdRef,
+		backgroundStreamsRef,
+		abortControllerRef
+	};
+}
+//#endregion
+export { useSSEStream };