@parallelworks/ui 0.19.0 → 0.19.1

package/dist/ai/core/ChatProvider.js

@@ -0,0 +1,848 @@
+import { applyPartDelta, finalizeParts } from "./parts.js";
+import { chatReducer, initialState } from "./chatReducer.js";
+import { ChatConfigProvider, resolveChatConfig } from "./config.js";
+import { useSSEStream } from "./useSSEStream.js";
+import { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { DateTime } from "luxon";
+//#region src/ai/core/ChatProvider.tsx
+var SELECTED_MODEL_STORAGE_KEY = "aiChatSelectedModel";
+var SIDEBAR_COLLAPSED_STORAGE_KEY = "aiChatSidebarCollapsed";
+function readStoredSidebarCollapsed() {
+	try {
+		return globalThis.localStorage?.getItem(SIDEBAR_COLLAPSED_STORAGE_KEY) === "1";
+	} catch {
+		return false;
+	}
+}
+function storeSidebarCollapsed(collapsed) {
+	try {
+		globalThis.localStorage?.setItem(SIDEBAR_COLLAPSED_STORAGE_KEY, collapsed ? "1" : "0");
+	} catch {}
+}
+function readStoredModel() {
+	try {
+		return globalThis.localStorage?.getItem(SELECTED_MODEL_STORAGE_KEY) ?? null;
+	} catch {
+		return null;
+	}
+}
+function storeSelectedModel(modelId) {
+	try {
+		globalThis.localStorage?.setItem(SELECTED_MODEL_STORAGE_KEY, modelId);
+	} catch {}
+}
+function generateTitleFromMessage(content) {
+	const cleaned = content.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/[#*_~[\]()]/g, "").replace(/\s+/g, " ").trim();
+	if (cleaned.length <= 50) return cleaned;
+	const truncated = cleaned.substring(0, 50);
+	const lastSpace = truncated.lastIndexOf(" ");
+	if (lastSpace > 30) return `${truncated.substring(0, lastSpace)}...`;
+	return `${truncated}...`;
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+var ChatContext = createContext(void 0);
+function useChat() {
+	const context = useContext(ChatContext);
+	if (!context) throw new Error("useChat must be used within a ChatProvider");
+	return context;
+}
+function ChatProvider({ adapter, currentUser, navigation, notify, activeConversationId = null, config, children }) {
+	const [state, dispatch] = useReducer(chatReducer, initialState, (seed) => ({
+		...seed,
+		sidebarCollapsed: readStoredSidebarCollapsed()
+	}));
+	const hasLoadedConversationsRef = useRef(false);
+	const { onStreamingChunk, startStreaming, stopAnimationLoop, resetAnimationRefs, targetStreamContentRef, streamActiveRef, streamingConversationIdRef, backgroundStreamsRef, abortControllerRef } = useSSEStream(dispatch);
+	const currentConversationIdRef = useRef(null);
+	const selectedProviderRef = useRef(state.selectedProvider);
+	useEffect(() => {
+		selectedProviderRef.current = state.selectedProvider;
+	}, [state.selectedProvider]);
+	const isSelectedModelAvailable = !!state.selectedProvider && (!state.hasLoadedModels || state.models.some((m) => m.id === state.selectedProvider));
+	const isSendingRef = useRef(false);
+	const pendingQueueRef = useRef([]);
+	const sendMessageRef = useRef(null);
+	const loadConversations = useCallback(async () => {
+		if (!hasLoadedConversationsRef.current) dispatch({
+			type: "SET_LOADING",
+			isLoading: true
+		});
+		try {
+			const conversations = await adapter.conversations.list();
+			dispatch({
+				type: "SET_CONVERSATIONS",
+				conversations
+			});
+			hasLoadedConversationsRef.current = true;
+		} catch (error) {
+			notify.error(errorText(error));
+		} finally {
+			dispatch({
+				type: "SET_LOADING",
+				isLoading: false
+			});
+		}
+	}, [adapter, notify]);
+	const streamingToConversationRef = useRef(null);
+	const loadSequenceRef = useRef(0);
+	const loadConversation = useCallback(async (id) => {
+		if (streamingToConversationRef.current === id && currentConversationIdRef.current === id) return;
+		if (streamingConversationIdRef.current && streamingConversationIdRef.current !== id) resetAnimationRefs();
+		const bgStream = backgroundStreamsRef.current.get(id);
+		dispatch({
+			type: "SET_LOADING_CONVERSATION",
+			isLoadingConversation: true
+		});
+		const sequence = ++loadSequenceRef.current;
+		let conversation;
+		try {
+			conversation = await adapter.conversations.get(id);
+		} catch (error) {
+			if (loadSequenceRef.current !== sequence) return;
+			dispatch({
+				type: "SET_LOADING_CONVERSATION",
+				isLoadingConversation: false
+			});
+			notify.error(errorText(error));
+			currentConversationIdRef.current = null;
+			dispatch({
+				type: "SET_CURRENT_CONVERSATION",
+				conversation: null
+			});
+			return;
+		}
+		if (loadSequenceRef.current !== sequence) return;
+		dispatch({
+			type: "SET_LOADING_CONVERSATION",
+			isLoadingConversation: false
+		});
+		currentConversationIdRef.current = id;
+		dispatch({
+			type: "SET_CURRENT_CONVERSATION",
+			conversation
+		});
+		if (bgStream?.isActive) {
+			streamingConversationIdRef.current = id;
+			targetStreamContentRef.current = bgStream.content;
+			streamActiveRef.current = true;
+			dispatch({
+				type: "RESTORE_BACKGROUND_STREAM",
+				content: "",
+				reasoning: bgStream.reasoning,
+				parts: bgStream.parts
+			});
+			startStreaming(id);
+		}
+	}, [
+		adapter,
+		notify,
+		resetAnimationRefs,
+		streamingConversationIdRef,
+		backgroundStreamsRef,
+		targetStreamContentRef,
+		streamActiveRef,
+		startStreaming
+	]);
+	const hasLoadedProvidersRef = useRef(false);
+	const loadProviders = useCallback(async () => {
+		if (hasLoadedProvidersRef.current || !adapter.providers) return;
+		try {
+			const providers = await adapter.providers.list();
+			dispatch({
+				type: "SET_PROVIDERS",
+				providers
+			});
+			hasLoadedProvidersRef.current = true;
+		} catch (error) {
+			notify.error(errorText(error));
+		}
+	}, [adapter, notify]);
+	const refreshProviders = useCallback(async () => {
+		hasLoadedProvidersRef.current = false;
+		await loadProviders();
+	}, [loadProviders]);
+	const hasLoadedModelsRef = useRef(false);
+	const loadModels = useCallback(async () => {
+		if (hasLoadedModelsRef.current) return;
+		dispatch({
+			type: "SET_LOADING_MODELS",
+			isLoadingModels: true
+		});
+		try {
+			const { models, unreachableSessions } = await adapter.models.list();
+			dispatch({
+				type: "SET_MODELS",
+				models,
+				unreachableSessions
+			});
+			hasLoadedModelsRef.current = true;
+			const current = selectedProviderRef.current;
+			const stored = readStoredModel();
+			const offers = (id) => !!id && models.some((m) => m.id === id);
+			const resolved = offers(current) ? current : offers(stored) ? stored : models[0]?.id ?? null;
+			if (resolved !== current) dispatch({
+				type: "SET_SELECTED_PROVIDER",
+				providerId: resolved
+			});
+		} catch (error) {
+			console.error("Failed to load models:", error);
+			dispatch({
+				type: "SET_MODELS_ERROR",
+				error: errorText(error)
+			});
+			hasLoadedModelsRef.current = true;
+		} finally {
+			dispatch({
+				type: "SET_LOADING_MODELS",
+				isLoadingModels: false
+			});
+		}
+	}, [adapter]);
+	const refreshModels = useCallback(async () => {
+		hasLoadedModelsRef.current = false;
+		dispatch({
+			type: "SET_MODELS_ERROR",
+			error: null
+		});
+		await loadModels();
+	}, [loadModels]);
+	useEffect(() => {
+		loadProviders();
+		loadModels();
+	}, [loadProviders, loadModels]);
+	const createConversation = useCallback(async (title) => {
+		try {
+			const conversation = await adapter.conversations.create(title);
+			dispatch({
+				type: "ADD_CONVERSATION",
+				conversation
+			});
+			return conversation.id;
+		} catch (error) {
+			notify.error(errorText(error));
+			return null;
+		}
+	}, [adapter, notify]);
+	const deleteConversation = useCallback(async (id) => {
+		try {
+			await adapter.conversations.remove(id);
+		} catch (error) {
+			notify.error(errorText(error));
+			return false;
+		}
+		dispatch({
+			type: "REMOVE_CONVERSATION",
+			conversationId: id
+		});
+		if (state.currentConversation?.id === id) {
+			dispatch({
+				type: "SET_CURRENT_CONVERSATION",
+				conversation: null
+			});
+			navigation.toNewChat();
+		}
+		return true;
+	}, [
+		adapter,
+		notify,
+		state.currentConversation,
+		navigation
+	]);
+	const sendMessage = useCallback(async (content, attachmentIds, parentId, attachmentMeta, _precedingMessages) => {
+		if (isSendingRef.current) {
+			const convId = currentConversationIdRef.current;
+			if (!convId) return false;
+			const MAX_QUEUED_MESSAGES = 10;
+			if (pendingQueueRef.current.length >= MAX_QUEUED_MESSAGES) {
+				notify.error(`You can queue up to ${MAX_QUEUED_MESSAGES} messages while waiting for a response`);
+				return false;
+			}
+			for (const pm of _precedingMessages ?? []) {
+				const pmId = crypto.randomUUID();
+				pendingQueueRef.current.push({
+					id: pmId,
+					...pm
+				});
+				dispatch({
+					type: "ADD_QUEUED_MESSAGE",
+					message: {
+						id: pmId,
+						role: "user",
+						content: pm.content,
+						timestamp: DateTime.now().toISO(),
+						author: currentUser,
+						attachments: pm.attachmentIds.length ? pm.attachmentIds.map((id) => ({
+							id,
+							filename: pm.attachmentMeta[id]?.filename ?? "",
+							contentType: pm.attachmentMeta[id]?.contentType ?? "",
+							size: pm.attachmentMeta[id]?.size ?? 0,
+							uploadedAt: DateTime.now().toISO()
+						})) : void 0
+					},
+					conversationId: convId
+				});
+			}
+			const queuedId = crypto.randomUUID();
+			pendingQueueRef.current.push({
+				id: queuedId,
+				content,
+				attachmentIds: attachmentIds ? [...attachmentIds] : [],
+				attachmentMeta: attachmentMeta ? { ...attachmentMeta } : {}
+			});
+			dispatch({
+				type: "ADD_QUEUED_MESSAGE",
+				message: {
+					id: queuedId,
+					role: "user",
+					content,
+					timestamp: DateTime.now().toISO(),
+					author: currentUser,
+					attachments: attachmentIds?.map((id) => ({
+						id,
+						filename: attachmentMeta?.[id]?.filename ?? "",
+						contentType: attachmentMeta?.[id]?.contentType ?? "",
+						size: attachmentMeta?.[id]?.size ?? 0,
+						uploadedAt: DateTime.now().toISO()
+					}))
+				},
+				conversationId: convId
+			});
+			return true;
+		}
+		if (!isSelectedModelAvailable) {
+			notify.error("Please select a provider first");
+			return false;
+		}
+		isSendingRef.current = true;
+		if (pendingQueueRef.current.length > 0) {
+			const held = pendingQueueRef.current;
+			pendingQueueRef.current = [];
+			dispatch({ type: "CLEAR_QUEUED_MESSAGES" });
+			_precedingMessages = [...held.map(({ id: _id, ...rest }) => rest), ..._precedingMessages ?? []];
+		}
+		let conversationId = currentConversationIdRef.current;
+		let isNewConversation = false;
+		if (!conversationId) {
+			const newId = await createConversation();
+			if (!newId) {
+				isSendingRef.current = false;
+				return false;
+			}
+			conversationId = newId;
+			isNewConversation = true;
+			currentConversationIdRef.current = newId;
+			const generatedTitle = content.trim() ? generateTitleFromMessage(content) : null;
+			dispatch({
+				type: "SET_CURRENT_CONVERSATION",
+				conversation: {
+					id: newId,
+					title: generatedTitle,
+					messages: [],
+					activeBranchId: null,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+					isOwner: true,
+					canCollaborate: true
+				}
+			});
+			navigation.toConversation(newId);
+			if (generatedTitle) adapter.conversations.rename(newId, generatedTitle).then(() => {
+				loadConversations();
+			}).catch((err) => console.error("Failed to set title:", err));
+		}
+		streamingToConversationRef.current = conversationId;
+		const targetConversationId = conversationId;
+		startStreaming(targetConversationId);
+		let lastBranchId = parentId || state.currentConversation?.activeBranchId || null;
+		const precedingApiMessages = [];
+		if (_precedingMessages?.length) for (const pm of _precedingMessages) {
+			const pmId = crypto.randomUUID();
+			const pmMessage = {
+				id: pmId,
+				parentId: lastBranchId,
+				role: "user",
+				content: pm.content,
+				attachments: pm.attachmentIds?.length ? pm.attachmentIds.map((id) => ({
+					id,
+					filename: pm.attachmentMeta[id]?.filename ?? "",
+					contentType: pm.attachmentMeta[id]?.contentType ?? "",
+					size: pm.attachmentMeta[id]?.size ?? 0,
+					uploadedAt: DateTime.now().toISO()
+				})) : void 0,
+				timestamp: DateTime.now().toISO(),
+				author: currentUser
+			};
+			dispatch({
+				type: "ADD_MESSAGE",
+				message: pmMessage,
+				conversationId: targetConversationId
+			});
+			precedingApiMessages.push({
+				role: "user",
+				content: pm.content,
+				attachment_ids: pm.attachmentIds?.length ? pm.attachmentIds : void 0
+			});
+			lastBranchId = pmId;
+		}
+		const userMessageId = crypto.randomUUID();
+		const userMessage = {
+			id: userMessageId,
+			parentId: lastBranchId,
+			role: "user",
+			content,
+			attachments: attachmentIds?.map((id) => ({
+				id,
+				filename: attachmentMeta?.[id]?.filename ?? "",
+				contentType: attachmentMeta?.[id]?.contentType ?? "",
+				size: attachmentMeta?.[id]?.size ?? 0,
+				uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+			})),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			author: currentUser
+		};
+		dispatch({
+			type: "ADD_MESSAGE",
+			message: userMessage,
+			conversationId: targetConversationId
+		});
+		backgroundStreamsRef.current.set(targetConversationId, {
+			content: "",
+			reasoning: "",
+			parts: [],
+			messageId: null,
+			isActive: true
+		});
+		const setMessageError = (errorMsg) => {
+			dispatch({
+				type: "UPDATE_MESSAGE",
+				messageId: userMessageId,
+				updates: { error: errorMsg },
+				conversationId: targetConversationId
+			});
+		};
+		const apiMessages = [
+			...(isNewConversation ? [] : state.currentConversation?.messages || []).filter((m) => m.content || m.toolCalls?.length).map((m) => {
+				const msg = {
+					role: m.role,
+					content: m.content || null
+				};
+				if (m.role === "assistant" && m.reasoning) msg.reasoning_content = m.reasoning;
+				if (m.role === "assistant" && m.toolCalls?.length) msg.tool_calls = m.toolCalls;
+				if (m.role === "assistant" && m.responsesOutput?.length && m.model === state.selectedProvider) msg.responses_output = m.responsesOutput;
+				if (m.role === "tool" && m.toolCallId) msg.tool_call_id = m.toolCallId;
+				return msg;
+			}),
+			...precedingApiMessages,
+			{
+				role: "user",
+				content,
+				attachment_ids: attachmentIds?.length ? attachmentIds : void 0
+			}
+		];
+		dispatch({
+			type: "SET_STREAMING",
+			isStreaming: true,
+			conversationId: targetConversationId
+		});
+		dispatch({
+			type: "CLEAR_STREAMING_CONTENT",
+			conversationId: targetConversationId
+		});
+		const controller = new AbortController();
+		abortControllerRef.current = controller;
+		let sendSucceeded = false;
+		let wasAborted = false;
+		try {
+			const modelString = state.selectedProvider;
+			const useResponses = state.models.find((m) => m.id === modelString)?.supports_responses === true;
+			let thinkingStart = null;
+			const markStreamStart = () => {
+				if (thinkingStart === null) thinkingStart = Date.now();
+			};
+			let liveParts = [];
+			const { content: assistantContent, messageId: assistantMessageId, toolCalls, model: resolvedModel, reasoning: assistantReasoning, responsesOutput } = await adapter.streamCompletion({
+				model: modelString,
+				messages: apiMessages,
+				conversationId,
+				parentMessageId: userMessage.parentId ?? null,
+				userMessageId,
+				allocation: state.selectedAllocation,
+				useResponses
+			}, {
+				onContent: (chunk) => {
+					markStreamStart();
+					onStreamingChunk(chunk);
+				},
+				onReasoning: (reasoning) => {
+					markStreamStart();
+					dispatch({
+						type: "APPEND_STREAMING_REASONING",
+						reasoning,
+						conversationId: targetConversationId
+					});
+					const bgStream = backgroundStreamsRef.current.get(targetConversationId);
+					if (bgStream) bgStream.reasoning += reasoning;
+				},
+				onMessageId: (messageId) => {
+					markStreamStart();
+					const bgStream = backgroundStreamsRef.current.get(targetConversationId);
+					if (bgStream) bgStream.messageId = messageId;
+				},
+				onPart: (delta) => {
+					markStreamStart();
+					liveParts = applyPartDelta(liveParts, delta);
+					dispatch({
+						type: "APPLY_STREAMING_PART",
+						delta,
+						conversationId: targetConversationId
+					});
+					const bgStream = backgroundStreamsRef.current.get(targetConversationId);
+					if (bgStream) bgStream.parts = liveParts;
+				}
+			}, controller.signal);
+			const thinkingDuration = assistantReasoning && thinkingStart !== null ? Date.now() - thinkingStart : null;
+			const assistantMessage = {
+				id: assistantMessageId || crypto.randomUUID(),
+				parentId: userMessageId,
+				role: "assistant",
+				content: assistantContent || (toolCalls.length > 0 ? null : ""),
+				toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+				model: useResponses ? modelString : resolvedModel || modelString,
+				providerId: state.selectedProvider,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				reasoning: assistantReasoning || void 0,
+				reasoningDuration: thinkingDuration ?? void 0,
+				responsesOutput: responsesOutput.length ? responsesOutput : void 0,
+				...liveParts.length ? { parts: finalizeParts(liveParts) } : {}
+			};
+			dispatch({
+				type: "ADD_MESSAGE",
+				message: assistantMessage,
+				conversationId: targetConversationId
+			});
+			if (isNewConversation) loadConversations();
+			sendSucceeded = true;
+			return true;
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") {
+				wasAborted = true;
+				return false;
+			}
+			console.error("Failed to send message:", error);
+			setMessageError(errorText(error));
+			return false;
+		} finally {
+			abortControllerRef.current = null;
+			const { unrevealed } = stopAnimationLoop();
+			if (unrevealed) dispatch({
+				type: "APPEND_STREAMING_CONTENT",
+				content: unrevealed,
+				conversationId: targetConversationId
+			});
+			streamingConversationIdRef.current = null;
+			backgroundStreamsRef.current.delete(targetConversationId);
+			setTimeout(() => {
+				streamingToConversationRef.current = null;
+			}, 500);
+			dispatch({
+				type: "SET_STREAMING",
+				isStreaming: false,
+				conversationId: targetConversationId
+			});
+			dispatch({
+				type: "CLEAR_STREAMING_CONTENT",
+				conversationId: targetConversationId
+			});
+			if (wasAborted) isSendingRef.current = false;
+			else if (sendSucceeded) {
+				const queued = pendingQueueRef.current;
+				pendingQueueRef.current = [];
+				dispatch({ type: "CLEAR_QUEUED_MESSAGES" });
+				if (queued.length > 0) {
+					const lastQueued = queued[queued.length - 1];
+					const preceding = queued.slice(0, -1);
+					setTimeout(() => {
+						isSendingRef.current = false;
+						sendMessageRef.current?.(lastQueued.content, lastQueued.attachmentIds.length > 0 ? lastQueued.attachmentIds : void 0, void 0, Object.keys(lastQueued.attachmentMeta).length > 0 ? lastQueued.attachmentMeta : void 0, preceding.length > 0 ? preceding : void 0);
+					}, 0);
+				} else isSendingRef.current = false;
+			} else isSendingRef.current = false;
+		}
+	}, [
+		adapter,
+		notify,
+		isSelectedModelAvailable,
+		state.selectedProvider,
+		state.selectedAllocation,
+		state.currentConversation,
+		state.models,
+		currentUser,
+		createConversation,
+		loadConversations,
+		navigation,
+		onStreamingChunk,
+		startStreaming,
+		stopAnimationLoop,
+		streamingConversationIdRef,
+		backgroundStreamsRef,
+		abortControllerRef
+	]);
+	useEffect(() => {
+		sendMessageRef.current = sendMessage;
+	}, [sendMessage]);
+	const updateConversationTitle = useCallback(async (id, title) => {
+		try {
+			await adapter.conversations.rename(id, title);
+		} catch (error) {
+			notify.error(errorText(error));
+			return false;
+		}
+		dispatch({
+			type: "SET_CONVERSATIONS",
+			conversations: state.conversations.map((c) => c.id === id ? {
+				...c,
+				title
+			} : c)
+		});
+		if (state.currentConversation?.id === id) dispatch({
+			type: "SET_CURRENT_CONVERSATION",
+			conversation: {
+				...state.currentConversation,
+				title
+			}
+		});
+		return true;
+	}, [
+		adapter,
+		notify,
+		state.conversations,
+		state.currentConversation
+	]);
+	const setSelectedProvider = useCallback((providerId) => {
+		if (providerId && state.models.some((m) => m.id === providerId)) storeSelectedModel(providerId);
+		dispatch({
+			type: "SET_SELECTED_PROVIDER",
+			providerId
+		});
+	}, [state.models]);
+	const setSelectedAllocation = useCallback((allocation) => {
+		dispatch({
+			type: "SET_SELECTED_ALLOCATION",
+			allocation
+		});
+	}, []);
+	const retryMessage = useCallback(async (messageId) => {
+		const currentConvId = state.currentConversation?.id;
+		const messages = state.currentConversation?.messages || [];
+		const failedMessage = messages.find((m) => m.id === messageId);
+		if (!failedMessage?.error || !currentConvId) return false;
+		if (failedMessage.role === "user") {
+			dispatch({
+				type: "UPDATE_MESSAGE",
+				messageId,
+				updates: { error: null },
+				conversationId: currentConvId
+			});
+			return sendMessage(failedMessage.content || "", failedMessage.attachments?.map((a) => a.id), failedMessage.parentId || void 0);
+		}
+		if (failedMessage.role === "assistant") {
+			const parentMessage = messages.find((m) => m.id === failedMessage.parentId);
+			if (parentMessage && parentMessage.role === "user") {
+				dispatch({
+					type: "UPDATE_MESSAGE",
+					messageId,
+					updates: { error: null },
+					conversationId: currentConvId
+				});
+				return sendMessage(parentMessage.content || "", parentMessage.attachments?.map((a) => a.id), parentMessage.parentId || void 0);
+			}
+		}
+		return false;
+	}, [
+		state.currentConversation?.messages,
+		state.currentConversation?.id,
+		sendMessage
+	]);
+	const stopStreaming = useCallback(() => {
+		if (abortControllerRef.current) {
+			abortControllerRef.current.abort();
+			abortControllerRef.current = null;
+		}
+		const conversationId = streamingConversationIdRef.current;
+		const bgStream = conversationId ? backgroundStreamsRef.current.get(conversationId) : null;
+		const stoppedContent = bgStream?.content || "";
+		const stoppedReasoning = bgStream?.reasoning || "";
+		const stoppedParts = bgStream?.parts ?? [];
+		const stoppedMessageId = bgStream?.messageId || null;
+		const hasContent = stoppedContent || stoppedReasoning || stoppedParts.length;
+		stopAnimationLoop();
+		if (conversationId) backgroundStreamsRef.current.delete(conversationId);
+		streamingConversationIdRef.current = null;
+		streamingToConversationRef.current = null;
+		resetAnimationRefs();
+		dispatch({
+			type: "SET_STREAMING",
+			isStreaming: false
+		});
+		dispatch({ type: "CLEAR_STREAMING_CONTENT" });
+		if (!conversationId || !hasContent) return;
+		const lastUserMessage = [...state.currentConversation?.messages || []].reverse().find((m) => m.role === "user");
+		const messageId = stoppedMessageId || crypto.randomUUID();
+		dispatch({
+			type: "ADD_MESSAGE",
+			message: {
+				id: messageId,
+				parentId: lastUserMessage?.id || null,
+				role: "assistant",
+				content: stoppedContent || null,
+				reasoning: stoppedReasoning || void 0,
+				...stoppedParts.length ? { parts: finalizeParts(stoppedParts) } : {},
+				reasoningDuration: state.thinkingStartTime ? Date.now() - state.thinkingStartTime : void 0,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				stopped: true
+			},
+			conversationId
+		});
+		setTimeout(() => {
+			if (currentConversationIdRef.current === conversationId) loadConversation(conversationId);
+		}, 500);
+	}, [
+		resetAnimationRefs,
+		streamingConversationIdRef,
+		abortControllerRef,
+		backgroundStreamsRef,
+		stopAnimationLoop,
+		loadConversation,
+		state.currentConversation?.messages,
+		state.thinkingStartTime
+	]);
+	const sidebarCollapsedRef = useRef(state.sidebarCollapsed);
+	sidebarCollapsedRef.current = state.sidebarCollapsed;
+	const toggleSidebar = useCallback(() => {
+		storeSidebarCollapsed(!sidebarCollapsedRef.current);
+		dispatch({ type: "TOGGLE_SIDEBAR" });
+	}, []);
+	const navigateToBranch = useCallback((messageId) => {
+		if (!state.currentConversation) return;
+		dispatch({
+			type: "SET_CURRENT_CONVERSATION",
+			conversation: {
+				...state.currentConversation,
+				activeBranchId: messageId
+			}
+		});
+	}, [state.currentConversation]);
+	const removeQueuedMessage = useCallback((id) => {
+		pendingQueueRef.current = pendingQueueRef.current.filter((m) => m.id !== id);
+		dispatch({
+			type: "REMOVE_QUEUED_MESSAGE",
+			id
+		});
+	}, []);
+	const flushQueuedMessages = useCallback(() => {
+		if (isSendingRef.current) return;
+		const held = pendingQueueRef.current;
+		if (held.length === 0) return;
+		pendingQueueRef.current = [];
+		dispatch({ type: "CLEAR_QUEUED_MESSAGES" });
+		const last = held[held.length - 1];
+		const preceding = held.slice(0, -1).map(({ id: _id, ...rest }) => rest);
+		sendMessageRef.current?.(last.content, last.attachmentIds.length > 0 ? last.attachmentIds : void 0, void 0, Object.keys(last.attachmentMeta).length > 0 ? last.attachmentMeta : void 0, preceding.length > 0 ? preceding : void 0);
+	}, []);
+	const clearCurrentConversation = useCallback(() => {
+		currentConversationIdRef.current = null;
+		loadSequenceRef.current++;
+		streamingConversationIdRef.current = null;
+		resetAnimationRefs();
+		pendingQueueRef.current = [];
+		isSendingRef.current = false;
+		dispatch({
+			type: "SET_CURRENT_CONVERSATION",
+			conversation: null
+		});
+	}, [resetAnimationRefs, streamingConversationIdRef]);
+	const resolvedConfig = useMemo(() => resolveChatConfig(config), [config]);
+	const value = useMemo(() => ({
+		adapter,
+		currentUser,
+		navigation,
+		notify,
+		activeConversationId,
+		conversations: state.conversations,
+		currentConversation: state.currentConversation,
+		providers: state.providers,
+		models: state.models,
+		unreachableSessions: state.unreachableSessions,
+		selectedProvider: state.selectedProvider,
+		isSelectedModelAvailable,
+		selectedAllocation: state.selectedAllocation,
+		isLoading: state.isLoading,
+		isLoadingConversation: state.isLoadingConversation,
+		isLoadingModels: state.isLoadingModels,
+		hasLoadedModels: state.hasLoadedModels,
+		modelsError: state.modelsError,
+		isStreaming: state.isStreaming,
+		isThinking: state.isThinking,
+		streamingContent: state.streamingContent,
+		streamingReasoning: state.streamingReasoning,
+		streamingParts: state.streamingParts,
+		thinkingStartTime: state.thinkingStartTime,
+		sidebarCollapsed: state.sidebarCollapsed,
+		queuedMessages: state.queuedMessages,
+		loadConversations,
+		loadConversation,
+		loadProviders,
+		refreshProviders,
+		refreshModels,
+		createConversation,
+		deleteConversation,
+		sendMessage,
+		retryMessage,
+		setSelectedProvider,
+		setSelectedAllocation,
+		stopStreaming,
+		removeQueuedMessage,
+		flushQueuedMessages,
+		toggleSidebar,
+		updateConversationTitle,
+		navigateToBranch,
+		clearCurrentConversation
+	}), [
+		adapter,
+		currentUser,
+		navigation,
+		notify,
+		activeConversationId,
+		state,
+		isSelectedModelAvailable,
+		loadConversations,
+		loadConversation,
+		loadProviders,
+		refreshProviders,
+		refreshModels,
+		createConversation,
+		deleteConversation,
+		sendMessage,
+		retryMessage,
+		setSelectedProvider,
+		setSelectedAllocation,
+		stopStreaming,
+		removeQueuedMessage,
+		flushQueuedMessages,
+		toggleSidebar,
+		updateConversationTitle,
+		navigateToBranch,
+		clearCurrentConversation
+	]);
+	return /* @__PURE__ */ jsx(ChatConfigProvider, {
+		value: resolvedConfig,
+		children: /* @__PURE__ */ jsx(ChatContext.Provider, {
+			value,
+			children
+		})
+	});
+}
+//#endregion
+export { ChatProvider, useChat };