@tangle-network/ui 11.10.0 → 11.11.1

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

@@ -0,0 +1,884 @@
+import { n as parseToolEvent } from "./tool-call-feed-Djt2q11V.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 };