@tangle-network/ui 11.12.0 → 11.13.0

package/dist/use-sse-stream-DjqRuDft.js

@@ -1,884 +0,0 @@
-import { n as parseToolEvent } from "./tool-call-feed-BpmMLpPX.js";
-import { _ as setForegroundActiveSession, d as registerActiveSession, g as setActiveSessionRunning, h as setActiveSessionError, m as setActiveSessionConnection, n as bumpActiveSessionActivity, p as setActiveSessionAttention, v as unregisterActiveSession, y as updateActiveSessionMeta } from "./active-sessions-store-Gt1R0rFG.js";
-import * as React from "react";
-import { createElement, useCallback, useEffect, useMemo, useRef, useState } from "react";
-//#region src/hooks/use-dropdown-menu.ts
-function useDropdownMenu(options) {
-	const closeOnEsc = options?.closeOnEsc ?? true;
-	const [open, setOpen] = useState(false);
-	const ref = useRef(null);
-	useEffect(() => {
-		function handleClick(e) {
-			if (ref.current && !ref.current.contains(e.target)) setOpen(false);
-		}
-		if (open) document.addEventListener("mousedown", handleClick);
-		return () => document.removeEventListener("mousedown", handleClick);
-	}, [open]);
-	useEffect(() => {
-		if (!open || !closeOnEsc) return;
-		function handleKey(e) {
-			if (e.key === "Escape") setOpen(false);
-		}
-		document.addEventListener("keydown", handleKey);
-		return () => document.removeEventListener("keydown", handleKey);
-	}, [open, closeOnEsc]);
-	return {
-		open,
-		setOpen,
-		ref,
-		toggle: () => setOpen((prev) => !prev),
-		close: () => setOpen(false)
-	};
-}
-//#endregion
-//#region src/hooks/use-tool-call-stream.ts
-/**
-* useToolCallStream — parses SSE events into ToolCallFeed segments.
-*
-* Takes raw SSE event data from the orchestrator stream and produces
-* structured FeedSegments that ToolCallFeed can render.
-*/
-function useToolCallStream() {
-	const [segments, setSegments] = useState([]);
-	const pendingToolsRef = useRef(/* @__PURE__ */ new Map());
-	const lastSegmentKindRef = useRef(null);
-	const pushText = useCallback((delta) => {
-		setSegments((prev) => {
-			const last = prev[prev.length - 1];
-			if (last && last.kind === "text") return [...prev.slice(0, -1), {
-				kind: "text",
-				content: last.content + delta
-			}];
-			return [...prev, {
-				kind: "text",
-				content: delta
-			}];
-		});
-		lastSegmentKindRef.current = "text";
-	}, []);
-	return {
-		segments,
-		pushEvent: useCallback((event) => {
-			const toolCall = parseToolEvent(event);
-			if (!toolCall) return;
-			if (event.type === "tool.invocation" || event.type === "tool_use") {
-				pendingToolsRef.current.set(toolCall.id, toolCall);
-				setSegments((prev) => [...prev, {
-					kind: "tool_call",
-					call: {
-						...toolCall,
-						status: "running"
-					}
-				}]);
-				lastSegmentKindRef.current = "tool";
-			}
-		}, []),
-		pushText,
-		completeToolCall: useCallback((id, result) => {
-			const pending = pendingToolsRef.current.get(id);
-			if (pending) {
-				pending.status = result.error ? "error" : "success";
-				pending.output = result.output || result.error;
-				pending.duration = result.duration;
-				pendingToolsRef.current.delete(id);
-			}
-			setSegments((prev) => prev.map((seg) => {
-				if (seg.kind === "tool_call" && seg.call.id === id) return {
-					kind: "tool_call",
-					call: {
-						...seg.call,
-						status: result.error ? "error" : "success",
-						output: result.output || result.error,
-						duration: result.duration
-					}
-				};
-				return seg;
-			}));
-		}, []),
-		reset: useCallback(() => {
-			setSegments([]);
-			pendingToolsRef.current.clear();
-			lastSegmentKindRef.current = null;
-		}, [])
-	};
-}
-//#endregion
-//#region src/hooks/use-realtime-session.ts
-function parseEvent(message) {
-	try {
-		const parsed = JSON.parse(message);
-		return typeof parsed?.type === "string" ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-function eventTimestamp(event) {
-	const rootTimestamp = event.timestamp;
-	if (typeof rootTimestamp === "number" && Number.isFinite(rootTimestamp)) return rootTimestamp;
-	const raw = event.data?.timestamp ?? event.data?.ts ?? event.data?.time ?? event.data?.eventAt;
-	if (typeof raw === "number" && Number.isFinite(raw)) return raw;
-	return null;
-}
-function resolveErrorMessage(event) {
-	const message = event.data?.message;
-	return typeof message === "string" && message.length > 0 ? message : null;
-}
-function updateStoreFromEvent(sessionId, event) {
-	const lastEventAt = eventTimestamp(event) ?? Date.now();
-	bumpActiveSessionActivity(sessionId, { lastEventAt });
-	if (event.type === "session.run.started") {
-		setActiveSessionRunning(sessionId, true, { lastEventAt });
-		return;
-	}
-	if (event.type === "session.run.completed" || event.type === "done" || event.type === "result") {
-		setActiveSessionRunning(sessionId, false, { lastEventAt });
-		return;
-	}
-	if (event.type === "session.attention") {
-		setActiveSessionAttention(sessionId, true, { lastEventAt });
-		return;
-	}
-	if (event.type === "error" || event.type === "session.run.failed") {
-		setActiveSessionError(sessionId, resolveErrorMessage(event) ?? "Session error");
-		return;
-	}
-}
-function useRealtimeSession({ sessionId, projectId = null, projectLabel, title, href, metadata, connectUrl, enabled = true, foreground = true, keepRegistered = true, reconnect = true, reconnectIntervalMs = 1500, maxReconnectAttempts = Infinity, transportMode = "websocket", onEvent, onOpen, onClose, onError }) {
-	const [connectionState, setConnectionState] = useState("disconnected");
-	const [lastError, setLastError] = useState(null);
-	const [reconnectAttempts, setReconnectAttempts] = useState(0);
-	const socketRef = useRef(null);
-	const timerRef = useRef(null);
-	const reconnectAttemptsRef = useRef(0);
-	const shouldReconnectRef = useRef(true);
-	const registration = useMemo(() => ({
-		sessionId,
-		projectId,
-		projectLabel,
-		title,
-		href,
-		metadata
-	}), [
-		href,
-		metadata,
-		projectId,
-		projectLabel,
-		sessionId,
-		title
-	]);
-	useEffect(() => {
-		if (!sessionId || !keepRegistered) return void 0;
-		registerActiveSession(registration);
-		return () => {
-			unregisterActiveSession(sessionId);
-		};
-	}, [
-		keepRegistered,
-		registration,
-		sessionId
-	]);
-	useEffect(() => {
-		if (!sessionId || !keepRegistered) return;
-		updateActiveSessionMeta(sessionId, {
-			projectId,
-			projectLabel,
-			title,
-			href,
-			metadata
-		});
-	}, [
-		href,
-		keepRegistered,
-		metadata,
-		projectId,
-		projectLabel,
-		sessionId,
-		title
-	]);
-	useEffect(() => {
-		if (!sessionId || !foreground) return void 0;
-		setForegroundActiveSession(sessionId);
-		return () => {
-			setForegroundActiveSession(null);
-		};
-	}, [foreground, sessionId]);
-	useEffect(() => {
-		if (!enabled || !sessionId || !connectUrl || typeof window === "undefined") {
-			setConnectionState("disconnected");
-			if (sessionId) setActiveSessionConnection(sessionId, {
-				connectionState: "disconnected",
-				reconnectState: "idle",
-				transportMode
-			});
-			return;
-		}
-		shouldReconnectRef.current = true;
-		const clearReconnectTimer = () => {
-			if (timerRef.current != null) {
-				window.clearTimeout(timerRef.current);
-				timerRef.current = null;
-			}
-		};
-		const connect = () => {
-			clearReconnectTimer();
-			setConnectionState(reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting");
-			setActiveSessionConnection(sessionId, {
-				connectionState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "connecting",
-				reconnectState: reconnectAttemptsRef.current > 0 ? "reconnecting" : "idle",
-				transportMode,
-				lastError: null
-			});
-			const socket = new window.WebSocket(connectUrl);
-			socketRef.current = socket;
-			socket.onopen = () => {
-				reconnectAttemptsRef.current = 0;
-				setReconnectAttempts(0);
-				setLastError(null);
-				setConnectionState("connected");
-				registerActiveSession(registration);
-				setActiveSessionConnection(sessionId, {
-					connectionState: "connected",
-					reconnectState: "idle",
-					transportMode,
-					lastError: null,
-					lastEventAt: Date.now()
-				});
-				onOpen?.();
-			};
-			socket.onmessage = (message) => {
-				const event = parseEvent(message.data);
-				if (!event) return;
-				registerActiveSession(registration);
-				updateStoreFromEvent(sessionId, event);
-				onEvent?.(event);
-			};
-			socket.onerror = () => {
-				const nextError = "Realtime session connection error";
-				setLastError(nextError);
-				setConnectionState("error");
-				setActiveSessionConnection(sessionId, {
-					connectionState: "error",
-					reconnectState: reconnect ? "reconnecting" : "failed",
-					transportMode,
-					lastError: nextError
-				});
-				onError?.(/* @__PURE__ */ new Error(nextError));
-			};
-			socket.onclose = () => {
-				socketRef.current = null;
-				onClose?.();
-				if (!shouldReconnectRef.current || !reconnect) {
-					setConnectionState("disconnected");
-					setActiveSessionConnection(sessionId, {
-						connectionState: "disconnected",
-						reconnectState: "idle",
-						transportMode
-					});
-					return;
-				}
-				reconnectAttemptsRef.current += 1;
-				setReconnectAttempts(reconnectAttemptsRef.current);
-				if (reconnectAttemptsRef.current > maxReconnectAttempts) {
-					setConnectionState("error");
-					setActiveSessionConnection(sessionId, {
-						connectionState: "error",
-						reconnectState: "failed",
-						transportMode,
-						lastError: "Unable to reconnect to realtime session"
-					});
-					return;
-				}
-				setConnectionState("reconnecting");
-				timerRef.current = window.setTimeout(connect, reconnectIntervalMs);
-			};
-		};
-		connect();
-		return () => {
-			shouldReconnectRef.current = false;
-			clearReconnectTimer();
-			const socket = socketRef.current;
-			socketRef.current = null;
-			if (socket && socket.readyState < WebSocket.CLOSING) socket.close();
-		};
-	}, [
-		connectUrl,
-		enabled,
-		maxReconnectAttempts,
-		onClose,
-		onError,
-		onEvent,
-		onOpen,
-		reconnect,
-		reconnectIntervalMs,
-		registration,
-		sessionId,
-		transportMode
-	]);
-	return {
-		connectionState,
-		lastError,
-		reconnectAttempts,
-		isConnected: connectionState === "connected"
-	};
-}
-function RealtimeSessionRegistryItem(props) {
-	useRealtimeSession({
-		...props,
-		foreground: props.foreground ?? false
-	});
-	return null;
-}
-function RealtimeSessionRegistry({ sessions }) {
-	return sessions.map((session) => createElement(RealtimeSessionRegistryItem, {
-		key: session.key ?? session.sessionId,
-		...session
-	}));
-}
-//#endregion
-//#region src/hooks/use-sdk-session.ts
-function uid() {
-	if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") try {
-		return globalThis.crypto.randomUUID();
-	} catch {}
-	return `sdk-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function toMillis(value) {
-	if (value == null) return void 0;
-	if (typeof value === "number") return value;
-	if (value instanceof Date) return value.getTime();
-	const millis = new Date(value).getTime();
-	return Number.isFinite(millis) ? millis : void 0;
-}
-function asRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function asString(value) {
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function textPartsFromContent(content, attachments) {
-	const text = `${content}${attachments?.length ? `\n\nAttachments:\n${attachments.map((attachment) => `- ${attachment.name}`).join("\n")}` : ""}`.trim();
-	return text ? [{
-		type: "text",
-		text
-	}] : [];
-}
-function normalizeTime(value) {
-	const record = asRecord(value);
-	if (!record) return void 0;
-	const start = Number(record.start ?? record.startedAt ?? record.started_at);
-	const end = Number(record.end ?? record.completedAt ?? record.completed_at);
-	if (!Number.isFinite(start) && !Number.isFinite(end)) return;
-	return {
-		start: Number.isFinite(start) ? start : void 0,
-		end: Number.isFinite(end) ? end : void 0
-	};
-}
-function normalizeStatus(value, output, error) {
-	if (value === "pending" || value === "running" || value === "completed" || value === "error") return value;
-	if (typeof error === "string" && error.length > 0) return "error";
-	if (output !== void 0) return "completed";
-	return "running";
-}
-function resolveToolIdentity(rawPart) {
-	return String(rawPart.id ?? rawPart.callID ?? rawPart.callId ?? rawPart.toolUseId ?? rawPart.toolCallId ?? rawPart.tool ?? rawPart.name ?? "tool");
-}
-function normalizePart(rawPart) {
-	const type = String(rawPart.type ?? "");
-	if (type === "text") return {
-		type: "text",
-		text: asString(rawPart.text) ?? asString(rawPart.content) ?? ""
-	};
-	if (type === "reasoning") return {
-		type: "reasoning",
-		text: asString(rawPart.text) ?? asString(rawPart.content) ?? "",
-		time: normalizeTime(rawPart.time)
-	};
-	if (type === "tool") {
-		const stateRecord = asRecord(rawPart.state);
-		const input = stateRecord?.input ?? rawPart.input;
-		const output = stateRecord?.output ?? rawPart.output;
-		const error = stateRecord?.error ?? rawPart.error;
-		return {
-			type: "tool",
-			id: resolveToolIdentity(rawPart),
-			tool: String(rawPart.tool ?? rawPart.name ?? "tool"),
-			callID: rawPart.callID != null || rawPart.callId != null ? String(rawPart.callID ?? rawPart.callId) : void 0,
-			state: {
-				status: normalizeStatus(stateRecord?.status ?? rawPart.status, output, error),
-				input,
-				output,
-				error: typeof error === "string" ? error : void 0,
-				metadata: asRecord(stateRecord?.metadata) ?? asRecord(rawPart.metadata),
-				time: normalizeTime(stateRecord?.time ?? rawPart.time)
-			}
-		};
-	}
-	return null;
-}
-function getPartKey(rawPart) {
-	const type = String(rawPart.type ?? "unknown");
-	if (type === "tool") return `tool:${resolveToolIdentity(rawPart)}`;
-	if (type === "reasoning") return `reasoning:${String(rawPart.id ?? rawPart.partId ?? rawPart.index ?? "current")}`;
-	return `text:${String(rawPart.id ?? rawPart.partId ?? rawPart.index ?? "current")}`;
-}
-function mergePart(existing, incoming, delta) {
-	if (!existing) {
-		if (incoming.type === "text" && delta) return {
-			type: "text",
-			text: delta
-		};
-		return incoming;
-	}
-	if (existing.type === "text" && incoming.type === "text") return {
-		type: "text",
-		text: delta ? `${existing.text}${delta}` : incoming.text,
-		synthetic: incoming.synthetic ?? existing.synthetic
-	};
-	if (existing.type === "reasoning" && incoming.type === "reasoning") return {
-		...existing,
-		...incoming,
-		text: delta && incoming.text === existing.text ? `${existing.text}${delta}` : incoming.text || existing.text,
-		time: incoming.time ?? existing.time
-	};
-	if (existing.type === "tool" && incoming.type === "tool") return {
-		...existing,
-		...incoming,
-		state: {
-			...existing.state,
-			...incoming.state,
-			time: incoming.state.time ?? existing.state.time
-		}
-	};
-	return incoming;
-}
-function mapSeeds(messages) {
-	return {
-		messages: messages.map((message, index) => ({
-			id: message.id,
-			role: message.role,
-			_insertionIndex: index,
-			time: { created: toMillis(message.createdAt) ?? Date.now() }
-		})),
-		partMap: Object.fromEntries(messages.map((message) => [message.id, message.parts ?? textPartsFromContent(message.content ?? "", message.attachments)]))
-	};
-}
-function useSdkSession({ initialMessages = [] } = {}) {
-	const initialConversation = useMemo(() => mapSeeds(initialMessages), [initialMessages]);
-	const [conversation, setConversation] = useState(initialConversation);
-	const [isStreaming, setIsStreaming] = useState(false);
-	const activeAssistantIdRef = useRef(null);
-	const insertionIndexRef = useRef(initialConversation.messages.length);
-	const partIndexRef = useRef({});
-	const replaceHistory = useCallback((messages) => {
-		const next = mapSeeds(messages);
-		setConversation(next);
-		setIsStreaming(false);
-		activeAssistantIdRef.current = null;
-		insertionIndexRef.current = next.messages.length;
-		partIndexRef.current = {};
-	}, []);
-	const appendUserMessage = useCallback(({ id = uid(), role = "user", content, createdAt, attachments }) => {
-		setConversation((prev) => ({
-			messages: [...prev.messages, {
-				id,
-				role,
-				_insertionIndex: insertionIndexRef.current++,
-				time: { created: toMillis(createdAt) ?? Date.now() }
-			}],
-			partMap: {
-				...prev.partMap,
-				[id]: textPartsFromContent(content, attachments)
-			}
-		}));
-		return id;
-	}, []);
-	const beginAssistantMessage = useCallback(({ id = uid(), role = "assistant", createdAt } = {}) => {
-		setConversation((prev) => ({
-			messages: [...prev.messages, {
-				id,
-				role,
-				_insertionIndex: insertionIndexRef.current++,
-				time: { created: toMillis(createdAt) ?? Date.now() }
-			}],
-			partMap: {
-				...prev.partMap,
-				[id]: prev.partMap[id] ?? []
-			}
-		}));
-		activeAssistantIdRef.current = id;
-		partIndexRef.current[id] = partIndexRef.current[id] ?? {};
-		setIsStreaming(true);
-		return id;
-	}, []);
-	const completeAssistantMessage = useCallback(({ messageId, finalText } = {}) => {
-		const targetId = messageId ?? activeAssistantIdRef.current;
-		if (!targetId) {
-			setIsStreaming(false);
-			return;
-		}
-		if (finalText) setConversation((prev) => {
-			const nextParts = [...prev.partMap[targetId] ?? []];
-			const textIndex = nextParts.findIndex((part) => part.type === "text");
-			if (textIndex === -1) nextParts.push({
-				type: "text",
-				text: finalText
-			});
-			else nextParts[textIndex] = {
-				type: "text",
-				text: finalText
-			};
-			return {
-				...prev,
-				partMap: {
-					...prev.partMap,
-					[targetId]: nextParts
-				}
-			};
-		});
-		delete partIndexRef.current[targetId];
-		if (activeAssistantIdRef.current === targetId) activeAssistantIdRef.current = null;
-		setIsStreaming(false);
-	}, []);
-	const failAssistantMessage = useCallback((error, options) => {
-		const targetId = options?.messageId ?? activeAssistantIdRef.current;
-		if (!targetId) {
-			setIsStreaming(false);
-			return;
-		}
-		setConversation((prev) => ({
-			...prev,
-			partMap: {
-				...prev.partMap,
-				[targetId]: [{
-					type: "text",
-					text: `Error: ${error}`
-				}]
-			}
-		}));
-		delete partIndexRef.current[targetId];
-		if (activeAssistantIdRef.current === targetId) activeAssistantIdRef.current = null;
-		setIsStreaming(false);
-	}, []);
-	const applySdkEvent = useCallback((event, options) => {
-		const eventData = asRecord(event.data) ?? {};
-		if (event.type === "message.updated") {
-			const id = asString(eventData.id) ?? asString(eventData.messageId) ?? options?.messageId;
-			const role = asString(eventData.role) ?? "assistant";
-			if (!id) return;
-			setConversation((prev) => {
-				if (prev.messages.some((message) => message.id === id)) return prev;
-				return {
-					...prev,
-					messages: [...prev.messages, {
-						id,
-						role,
-						_insertionIndex: insertionIndexRef.current++,
-						time: { created: Date.now() }
-					}],
-					partMap: {
-						...prev.partMap,
-						[id]: prev.partMap[id] ?? []
-					}
-				};
-			});
-			if (role === "assistant" || role === "system") {
-				activeAssistantIdRef.current = id;
-				partIndexRef.current[id] = partIndexRef.current[id] ?? {};
-				setIsStreaming(true);
-			}
-			return;
-		}
-		if (event.type === "message.part.updated") {
-			const rawPart = asRecord(eventData.part) ?? eventData;
-			const targetId = options?.messageId ?? activeAssistantIdRef.current;
-			const delta = asString(eventData.delta);
-			if (!targetId || !rawPart) return;
-			const normalizedPart = normalizePart(rawPart);
-			if (!normalizedPart) return;
-			const key = getPartKey(rawPart);
-			setConversation((prev) => {
-				const nextParts = [...prev.partMap[targetId] ?? []];
-				const indexMap = partIndexRef.current[targetId] ?? (partIndexRef.current[targetId] = {});
-				const existingIndex = indexMap[key];
-				if (existingIndex == null) {
-					indexMap[key] = nextParts.length;
-					nextParts.push(mergePart(void 0, normalizedPart, delta));
-				} else nextParts[existingIndex] = mergePart(nextParts[existingIndex], normalizedPart, delta);
-				return {
-					...prev,
-					partMap: {
-						...prev.partMap,
-						[targetId]: nextParts
-					}
-				};
-			});
-			activeAssistantIdRef.current = targetId;
-			setIsStreaming(true);
-			return;
-		}
-		if (event.type === "result") {
-			completeAssistantMessage({
-				messageId: options?.messageId,
-				finalText: asString(eventData.finalText)
-			});
-			return;
-		}
-		if (event.type === "done") {
-			completeAssistantMessage({ messageId: options?.messageId });
-			return;
-		}
-		if (event.type === "error") failAssistantMessage(asString(eventData.message) ?? "Agent error", { messageId: options?.messageId });
-	}, [completeAssistantMessage, failAssistantMessage]);
-	const reset = useCallback(() => {
-		setConversation({
-			messages: [],
-			partMap: {}
-		});
-		setIsStreaming(false);
-		activeAssistantIdRef.current = null;
-		insertionIndexRef.current = 0;
-		partIndexRef.current = {};
-	}, []);
-	return {
-		messages: conversation.messages,
-		partMap: conversation.partMap,
-		isStreaming,
-		activeAssistantMessageId: activeAssistantIdRef.current,
-		replaceHistory,
-		appendUserMessage,
-		beginAssistantMessage,
-		applySdkEvent,
-		completeAssistantMessage,
-		failAssistantMessage,
-		setStreaming: setIsStreaming,
-		reset
-	};
-}
-//#endregion
-//#region src/hooks/use-sse-stream.ts
-/**
-* React hook for consuming SSE streams with automatic reconnection,
-* event buffering, and state management.
-*
-* @example
-* ```tsx
-* const { events, state, lastEvent } = useSSEStream({
-*   url: '/api/v1/tasks/123/stream',
-*   authToken: 'Bearer xxx',
-*   onEvent: (e) => console.log('Event:', e),
-* });
-*
-* return (
-*   <div>
-*     <p>Status: {state}</p>
-*     {events.map((e, i) => (
-*       <div key={i}>{e.event}: {JSON.stringify(e.data)}</div>
-*     ))}
-*   </div>
-* );
-* ```
-*/
-function useSSEStream(options) {
-	const { url, authToken, autoReconnect = true, maxRetries = 5, reconnectDelay = 1e3, eventTypes, onEvent, onStateChange, onError, headers, enabled = true } = options;
-	const [state, setState] = React.useState("disconnected");
-	const [events, setEvents] = React.useState([]);
-	const [lastEvent, setLastEvent] = React.useState(null);
-	const [error, setError] = React.useState(null);
-	const [lastEventTime, setLastEventTime] = React.useState(Date.now());
-	const [timeSinceLastEvent, setTimeSinceLastEvent] = React.useState(0);
-	const retryCountRef = React.useRef(0);
-	const eventSourceRef = React.useRef(null);
-	const abortControllerRef = React.useRef(null);
-	const reconnectTimeoutRef = React.useRef(null);
-	const lastEventIdRef = React.useRef(void 0);
-	React.useEffect(() => {
-		const interval = setInterval(() => {
-			setTimeSinceLastEvent(Date.now() - lastEventTime);
-		}, 1e3);
-		return () => clearInterval(interval);
-	}, [lastEventTime]);
-	React.useEffect(() => {
-		onStateChange?.(state);
-	}, [state, onStateChange]);
-	const handleEvent = React.useCallback((eventType, data, id) => {
-		const event = {
-			id,
-			event: eventType,
-			data,
-			timestamp: Date.now()
-		};
-		if (id) lastEventIdRef.current = id;
-		setLastEventTime(Date.now());
-		setLastEvent(event);
-		setEvents((prev) => {
-			const next = [...prev, event];
-			return next.length > 1e3 ? next.slice(-1e3) : next;
-		});
-		onEvent?.(event);
-	}, [onEvent]);
-	const disconnect = React.useCallback(() => {
-		if (reconnectTimeoutRef.current) {
-			clearTimeout(reconnectTimeoutRef.current);
-			reconnectTimeoutRef.current = null;
-		}
-		if (abortControllerRef.current) {
-			abortControllerRef.current.abort();
-			abortControllerRef.current = null;
-		}
-		if (eventSourceRef.current) {
-			eventSourceRef.current.close();
-			eventSourceRef.current = null;
-		}
-		setState("disconnected");
-	}, []);
-	const connect = React.useCallback(() => {
-		disconnect();
-		if (!url || !enabled) return;
-		setState("connecting");
-		setError(null);
-		const connectUrl = new URL(url, window.location.origin);
-		if (lastEventIdRef.current) connectUrl.searchParams.set("lastEventId", lastEventIdRef.current);
-		if (authToken || headers) {
-			abortControllerRef.current = new AbortController();
-			const fetchHeaders = {
-				Accept: "text/event-stream",
-				"Cache-Control": "no-cache",
-				...headers
-			};
-			if (authToken) fetchHeaders.Authorization = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
-			if (lastEventIdRef.current) fetchHeaders["Last-Event-ID"] = lastEventIdRef.current;
-			fetch(connectUrl.toString(), {
-				headers: fetchHeaders,
-				signal: abortControllerRef.current.signal
-			}).then(async (response) => {
-				if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-				if (!response.body) throw new Error("Response body is null");
-				setState("connected");
-				retryCountRef.current = 0;
-				const reader = response.body.getReader();
-				const decoder = new TextDecoder();
-				let buffer = "";
-				while (true) {
-					const { done, value } = await reader.read();
-					if (done) break;
-					buffer += decoder.decode(value, { stream: true });
-					const lines = buffer.split("\n");
-					buffer = lines.pop() || "";
-					let currentEvent = "";
-					let currentData = "";
-					let currentId;
-					for (const line of lines) if (line.startsWith("event:")) currentEvent = line.slice(6).trim();
-					else if (line.startsWith("data:")) currentData += (currentData ? "\n" : "") + line.slice(5).trim();
-					else if (line.startsWith("id:")) currentId = line.slice(3).trim();
-					else if (line === "" && currentData) {
-						try {
-							const parsedData = JSON.parse(currentData);
-							const eventType = currentEvent || "message";
-							if (!eventTypes || eventTypes.includes(eventType)) handleEvent(eventType, parsedData, currentId);
-						} catch {
-							if (!eventTypes || eventTypes.includes(currentEvent || "message")) handleEvent(currentEvent || "message", currentData, currentId);
-						}
-						currentEvent = "";
-						currentData = "";
-						currentId = void 0;
-					}
-				}
-				if (autoReconnect && enabled) {
-					setState("reconnecting");
-					const delay = reconnectDelay * 2 ** retryCountRef.current;
-					reconnectTimeoutRef.current = setTimeout(() => {
-						retryCountRef.current += 1;
-						connect();
-					}, Math.min(delay, 3e4));
-				} else setState("disconnected");
-			}).catch((err) => {
-				if (err.name === "AbortError") return;
-				setError(err);
-				onError?.(err);
-				setState("error");
-				if (autoReconnect && enabled && retryCountRef.current < maxRetries) {
-					setState("reconnecting");
-					const delay = reconnectDelay * 2 ** retryCountRef.current;
-					reconnectTimeoutRef.current = setTimeout(() => {
-						retryCountRef.current += 1;
-						connect();
-					}, Math.min(delay, 3e4));
-				}
-			});
-		} else {
-			const es = new EventSource(connectUrl.toString());
-			eventSourceRef.current = es;
-			es.onopen = () => {
-				setState("connected");
-				retryCountRef.current = 0;
-			};
-			es.onerror = () => {
-				const err = /* @__PURE__ */ new Error("EventSource connection error");
-				setError(err);
-				onError?.(err);
-				if (autoReconnect && enabled && retryCountRef.current < maxRetries) {
-					setState("reconnecting");
-					es.close();
-					const delay = reconnectDelay * 2 ** retryCountRef.current;
-					reconnectTimeoutRef.current = setTimeout(() => {
-						retryCountRef.current += 1;
-						connect();
-					}, Math.min(delay, 3e4));
-				} else setState("error");
-			};
-			const types = eventTypes || ["message"];
-			for (const type of types) es.addEventListener(type, (e) => {
-				try {
-					const data = JSON.parse(e.data);
-					handleEvent(type, data, e.lastEventId);
-				} catch {
-					handleEvent(type, e.data, e.lastEventId);
-				}
-			});
-			if (!eventTypes) es.onmessage = (e) => {
-				try {
-					const data = JSON.parse(e.data);
-					handleEvent("message", data, e.lastEventId);
-				} catch {
-					handleEvent("message", e.data, e.lastEventId);
-				}
-			};
-		}
-	}, [
-		url,
-		authToken,
-		headers,
-		enabled,
-		autoReconnect,
-		maxRetries,
-		reconnectDelay,
-		eventTypes,
-		handleEvent,
-		onError,
-		disconnect
-	]);
-	React.useEffect(() => {
-		if (enabled) connect();
-		return () => disconnect();
-	}, [
-		enabled,
-		connect,
-		disconnect
-	]);
-	return {
-		state,
-		events,
-		lastEvent,
-		error,
-		connect,
-		disconnect,
-		clearEvents: React.useCallback(() => {
-			setEvents([]);
-			setLastEvent(null);
-		}, []),
-		retryCount: retryCountRef.current,
-		timeSinceLastEvent
-	};
-}
-//#endregion
-export { useToolCallStream as a, useRealtimeSession as i, useSdkSession as n, useDropdownMenu as o, RealtimeSessionRegistry as r, useSSEStream as t };