@fragno-dev/pi-fragment 0.0.1 → 0.0.3

package/dist/node/client/session-store.js

@@ -0,0 +1,637 @@
+import { atom, computed, onMount } from "nanostores";
+
+//#region src/client/session-store.ts
+const createOverlayState = (sessionId) => ({
+	sessionId,
+	connection: "idle",
+	error: null,
+	sendError: null,
+	sending: false,
+	activity: { kind: "none" },
+	pendingTurn: false,
+	pendingSnapshotReconcile: false,
+	readyForInputOverride: null,
+	optimisticMessages: [],
+	streamedMessages: [],
+	draftAssistant: null,
+	runningTools: [],
+	trace: []
+});
+const buildOptimisticUserMessage = (text) => ({
+	role: "user",
+	content: [{
+		type: "text",
+		text
+	}],
+	timestamp: Date.now()
+});
+const formatJson = (value) => {
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+};
+const buildLiveToolResultMessage = (message) => {
+	const result = message.result;
+	const content = result && Array.isArray(result.content) ? result.content : [{
+		type: "text",
+		text: formatJson(message.result)
+	}];
+	return {
+		role: "toolResult",
+		toolCallId: message.toolCallId,
+		toolName: message.toolName,
+		content,
+		details: result?.details,
+		isError: message.isError,
+		timestamp: Date.now()
+	};
+};
+const appendOrReplaceLiveMessage = (messages, nextMessage) => {
+	if (nextMessage.role === "assistant") {
+		const existingIndex = messages.findIndex((message) => message.role === "assistant" && message.timestamp === nextMessage.timestamp);
+		if (existingIndex >= 0) return [
+			...messages.slice(0, existingIndex),
+			nextMessage,
+			...messages.slice(existingIndex + 1)
+		];
+	}
+	if (nextMessage.role === "toolResult") {
+		const existingIndex = messages.findIndex((message) => message.role === "toolResult" && message.toolCallId === nextMessage.toolCallId);
+		if (existingIndex >= 0) return [
+			...messages.slice(0, existingIndex),
+			nextMessage,
+			...messages.slice(existingIndex + 1)
+		];
+	}
+	return [...messages, nextMessage];
+};
+const mergeMessages = (snapshotMessages, optimisticMessages, streamedMessages, draftAssistant) => {
+	let messages = [...snapshotMessages];
+	for (const optimisticMessage of optimisticMessages) messages = appendOrReplaceLiveMessage(messages, optimisticMessage);
+	for (const streamedMessage of streamedMessages) messages = appendOrReplaceLiveMessage(messages, streamedMessage);
+	if (draftAssistant) messages = appendOrReplaceLiveMessage(messages, draftAssistant);
+	return messages;
+};
+const hasActiveOverlay = (state) => state.draftAssistant !== null || state.runningTools.length > 0 || state.streamedMessages.length > 0;
+const activityLabel = (activity) => {
+	switch (activity.kind) {
+		case "none": return null;
+		case "sending-message": return "Sending message";
+		case "assistant-responding": return "Assistant responding";
+		case "assistant-ready": return "Assistant response ready";
+		case "tool-running": return `Running ${activity.toolName}`;
+		case "tool-updating": return `Updating ${activity.toolName}`;
+		case "tool-finished": return `${activity.toolName} finished`;
+		case "agent-started": return "Agent started";
+		case "agent-finished": return "Agent finished";
+		case "turn-started": return "Turn started";
+		case "turn-finished": return "Turn finished";
+		default: return null;
+	}
+};
+const connectionStatusText = (connection) => {
+	switch (connection) {
+		case "connecting": return "Connecting to live updates";
+		case "reconnecting": return "Reconnecting to live updates";
+		default: return null;
+	}
+};
+const reduceProtocolMessage = (state, message) => {
+	if (message.layer === "system") switch (message.type) {
+		case "snapshot": {
+			const readyForInput = isSessionReadyForInput(message.phase, message.waitingFor);
+			return {
+				...state,
+				error: null,
+				activity: readyForInput ? { kind: "none" } : state.activity,
+				pendingTurn: !readyForInput,
+				readyForInputOverride: readyForInput
+			};
+		}
+		case "inactive": return {
+			...state,
+			connection: "idle",
+			error: null,
+			readyForInputOverride: false
+		};
+		case "settled": return {
+			...state,
+			connection: "reconnecting",
+			activity: { kind: "turn-finished" },
+			pendingTurn: true,
+			pendingSnapshotReconcile: true,
+			readyForInputOverride: false,
+			error: null
+		};
+		default: return state;
+	}
+	const event = message.event;
+	const trace = [...state.trace, event];
+	switch (event.type) {
+		case "message_start":
+		case "message_update": return {
+			...state,
+			trace,
+			draftAssistant: event.message,
+			activity: { kind: "assistant-responding" },
+			pendingTurn: true,
+			error: null
+		};
+		case "message_end": return {
+			...state,
+			trace,
+			streamedMessages: appendOrReplaceLiveMessage(state.streamedMessages, event.message),
+			draftAssistant: null,
+			activity: { kind: "assistant-ready" },
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_start": return {
+			...state,
+			trace,
+			runningTools: [...state.runningTools.filter((tool) => tool.toolCallId !== event.toolCallId), {
+				toolCallId: event.toolCallId,
+				toolName: event.toolName,
+				args: event.args,
+				partialResult: null
+			}],
+			activity: {
+				kind: "tool-running",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_update": return {
+			...state,
+			trace,
+			runningTools: state.runningTools.map((tool) => tool.toolCallId === event.toolCallId ? {
+				...tool,
+				partialResult: event.partialResult
+			} : tool),
+			activity: {
+				kind: "tool-updating",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "tool_execution_end": return {
+			...state,
+			trace,
+			streamedMessages: appendOrReplaceLiveMessage(state.streamedMessages, buildLiveToolResultMessage(event)),
+			runningTools: state.runningTools.filter((tool) => tool.toolCallId !== event.toolCallId),
+			activity: {
+				kind: "tool-finished",
+				toolName: event.toolName
+			},
+			pendingTurn: true,
+			error: null
+		};
+		case "agent_start": return {
+			...state,
+			trace,
+			activity: { kind: "agent-started" },
+			pendingTurn: true,
+			error: null
+		};
+		case "agent_end": return {
+			...state,
+			trace,
+			activity: { kind: "agent-finished" },
+			pendingTurn: true,
+			error: null
+		};
+		case "turn_start": return {
+			...state,
+			trace,
+			activity: { kind: "turn-started" },
+			pendingTurn: true,
+			error: null
+		};
+		case "turn_end": return {
+			...state,
+			trace,
+			activity: { kind: "turn-finished" },
+			pendingTurn: true,
+			error: null
+		};
+		default: return {
+			...state,
+			trace,
+			pendingTurn: true,
+			error: null
+		};
+	}
+};
+const reduceOverlayState = (state, action) => {
+	switch (action.type) {
+		case "snapshot-updated":
+			if (action.sessionId !== state.sessionId) return createOverlayState(action.sessionId);
+			if (!state.pendingSnapshotReconcile) return {
+				...state,
+				optimisticMessages: [],
+				sendError: null,
+				error: null,
+				readyForInputOverride: null
+			};
+			return {
+				...state,
+				optimisticMessages: [],
+				streamedMessages: [],
+				draftAssistant: null,
+				runningTools: [],
+				trace: [],
+				error: null,
+				sendError: null,
+				activity: { kind: "none" },
+				pendingTurn: false,
+				pendingSnapshotReconcile: false,
+				readyForInputOverride: null
+			};
+		case "send-started": return {
+			...state,
+			sending: true,
+			sendError: null,
+			optimisticMessages: [...state.optimisticMessages, {
+				clientId: action.clientId,
+				message: buildOptimisticUserMessage(action.text)
+			}],
+			activity: { kind: "sending-message" },
+			pendingTurn: true,
+			readyForInputOverride: false,
+			error: null
+		};
+		case "send-acknowledged": return {
+			...state,
+			sending: false,
+			sendError: null
+		};
+		case "send-failed": {
+			const optimisticMessages = state.optimisticMessages.filter((message) => message.clientId !== action.clientId);
+			const keepPending = state.pendingSnapshotReconcile || hasActiveOverlay(state);
+			return {
+				...state,
+				sending: false,
+				sendError: action.message,
+				optimisticMessages,
+				activity: keepPending ? state.activity : { kind: "none" },
+				pendingTurn: keepPending,
+				readyForInputOverride: keepPending ? state.readyForInputOverride : null
+			};
+		}
+		case "stream-connecting": {
+			const connection = action.reconnecting ? "reconnecting" : "connecting";
+			return {
+				...state,
+				connection,
+				error: null
+			};
+		}
+		case "stream-open": return {
+			...state,
+			connection: "listening",
+			error: null
+		};
+		case "stream-message": return reduceProtocolMessage(state, action.message);
+		case "stream-settled": return {
+			...state,
+			connection: "reconnecting"
+		};
+		case "stream-inactive": return {
+			...state,
+			connection: "idle",
+			error: null
+		};
+		case "stream-error": return {
+			...state,
+			connection: "error",
+			error: action.message
+		};
+		case "stream-idle": return {
+			...state,
+			connection: "idle",
+			error: null,
+			activity: state.pendingTurn ? state.activity : { kind: "none" }
+		};
+		default: return state;
+	}
+};
+const readPiRouteError = async (response) => {
+	const text = await response.text();
+	if (!text) return `Request failed (${response.status}).`;
+	try {
+		const parsed = JSON.parse(text);
+		return parsed.message ?? parsed.error ?? text;
+	} catch {
+		return text;
+	}
+};
+const consumeProtocolStream = async (body, onMessage, signal) => {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			if (signal.aborted) {
+				await reader.cancel();
+				return;
+			}
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed) continue;
+				onMessage(JSON.parse(trimmed));
+			}
+		}
+		const trailing = `${buffer}${decoder.decode()}`.trim();
+		if (trailing) onMessage(JSON.parse(trailing));
+	} finally {
+		reader.releaseLock();
+	}
+};
+const waitWithAbort = (ms, signal) => new Promise((resolve, reject) => {
+	const timeoutId = setTimeout(() => {
+		signal.removeEventListener("abort", handleAbort);
+		resolve();
+	}, ms);
+	function handleAbort() {
+		clearTimeout(timeoutId);
+		signal.removeEventListener("abort", handleAbort);
+		reject(new DOMException("Aborted", "AbortError"));
+	}
+	if (signal.aborted) {
+		handleAbort();
+		return;
+	}
+	signal.addEventListener("abort", handleAbort, { once: true });
+});
+const isSessionReadyForInput = (phase, waitingFor) => phase === "waiting-for-user" && waitingFor?.type === "user_message";
+const shouldKeepLiveConnection = (session) => session?.phase !== "complete";
+const withAcceptHeader = (defaultOptions) => {
+	const headers = new Headers(defaultOptions?.headers);
+	headers.set("accept", "application/x-ndjson");
+	return {
+		...defaultOptions,
+		headers
+	};
+};
+function createPiSessionStore(deps, args) {
+	const detailStore = deps.createDetailStore(args.sessionId);
+	const snapshotStore = atom(args.initialData ?? null);
+	const overlayStore = atom(createOverlayState(args.sessionId));
+	const lastSnapshotVersion = { current: args.initialData ? `${args.initialData.id}:${String(args.initialData.updatedAt)}` : null };
+	let destroyed = false;
+	let mounted = false;
+	let activeAbortController = null;
+	let activeLoopPromise = null;
+	let detailUnsubscribe = null;
+	const logActive = (event, details) => {
+		deps.activeLogger?.(event, {
+			sessionId: args.sessionId,
+			...details
+		});
+	};
+	const updateSnapshot = (session) => {
+		if (!session) return;
+		snapshotStore.set(session);
+		const nextVersion = `${session.id}:${String(session.updatedAt)}`;
+		if (nextVersion !== lastSnapshotVersion.current) {
+			logActive("snapshot:updated", {
+				version: nextVersion,
+				phase: session.phase,
+				status: session.status,
+				turn: session.turn
+			});
+			lastSnapshotVersion.current = nextVersion;
+			overlayStore.set(reduceOverlayState(overlayStore.get(), {
+				type: "snapshot-updated",
+				sessionId: session.id
+			}));
+		}
+	};
+	const refetch = () => {
+		logActive("detail:refetch");
+		detailStore.revalidate();
+	};
+	const stopActiveLoop = () => {
+		if (activeAbortController || activeLoopPromise) logActive("stream:stop");
+		activeAbortController?.abort();
+		activeAbortController = null;
+		activeLoopPromise = null;
+	};
+	const ensureActiveLoop = () => {
+		if (destroyed || !mounted || activeLoopPromise || deps.enableActiveStream === false) return;
+		const currentSession = snapshotStore.get();
+		if (!shouldKeepLiveConnection(currentSession)) {
+			logActive("stream:idle", {
+				reason: "session-complete",
+				phase: currentSession?.phase ?? null,
+				status: currentSession?.status ?? null
+			});
+			overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+			return;
+		}
+		logActive("stream:start", {
+			phase: currentSession?.phase ?? null,
+			status: currentSession?.status ?? null,
+			turn: currentSession?.turn ?? null
+		});
+		const abortController = new AbortController();
+		activeAbortController = abortController;
+		activeLoopPromise = (async () => {
+			let reconnecting = false;
+			while (!abortController.signal.aborted && !destroyed) {
+				if (!shouldKeepLiveConnection(snapshotStore.get())) {
+					overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+					return;
+				}
+				const activeUrl = deps.buildActiveUrl(args.sessionId);
+				logActive("stream:connecting", {
+					reconnecting,
+					url: activeUrl
+				});
+				overlayStore.set(reduceOverlayState(overlayStore.get(), {
+					type: "stream-connecting",
+					reconnecting
+				}));
+				try {
+					const response = await deps.fetcher(activeUrl, {
+						...withAcceptHeader(deps.defaultOptions),
+						method: "GET",
+						cache: "no-store",
+						signal: abortController.signal
+					});
+					logActive("stream:response", {
+						ok: response.ok,
+						status: response.status,
+						statusText: response.statusText,
+						url: activeUrl
+					});
+					if (!response.ok) throw new Error(await readPiRouteError(response));
+					if (!response.body) throw new Error("The active session stream did not return a response body.");
+					logActive("stream:open", { url: activeUrl });
+					overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-open" }));
+					let sawInactive = false;
+					let sawSettled = false;
+					await consumeProtocolStream(response.body, (message) => {
+						logActive("stream:message", { message });
+						overlayStore.set(reduceOverlayState(overlayStore.get(), {
+							type: "stream-message",
+							message
+						}));
+						if (message.layer === "system" && message.type === "inactive") sawInactive = true;
+						if (message.layer === "system" && message.type === "settled") sawSettled = true;
+					}, abortController.signal);
+					if (abortController.signal.aborted || destroyed) return;
+					if (sawSettled || sawInactive) {
+						logActive("stream:settled", {
+							sawSettled,
+							sawInactive
+						});
+						overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-settled" }));
+						detailStore.revalidate();
+					}
+					if (sawInactive) {
+						logActive("stream:inactive");
+						overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-inactive" }));
+						return;
+					}
+					reconnecting = true;
+					logActive("stream:retry", { delayMs: 250 });
+					await waitWithAbort(250, abortController.signal);
+				} catch (error) {
+					if (abortController.signal.aborted || destroyed) return;
+					const message = error instanceof Error ? error.message : "Failed to stream the active session.";
+					logActive("stream:error", { message });
+					overlayStore.set(reduceOverlayState(overlayStore.get(), {
+						type: "stream-error",
+						message
+					}));
+					reconnecting = true;
+					logActive("stream:retry", { delayMs: 1e3 });
+					await waitWithAbort(1e3, abortController.signal).catch(() => void 0);
+				}
+			}
+		})().finally(() => {
+			logActive("stream:end");
+			if (activeAbortController === abortController) activeAbortController = null;
+			if (activeLoopPromise) activeLoopPromise = null;
+		});
+	};
+	const store = computed([
+		detailStore,
+		snapshotStore,
+		overlayStore
+	], (detailValue, session, overlay) => {
+		const optimisticMessages = overlay.optimisticMessages.map((entry) => entry.message);
+		const messages = mergeMessages(session?.messages ?? [], optimisticMessages, overlay.streamedMessages, overlay.draftAssistant);
+		const statusText = activityLabel(overlay.activity) ?? connectionStatusText(overlay.connection);
+		const readyForInput = session !== null && (overlay.readyForInputOverride ?? (isSessionReadyForInput(session.phase, session.waitingFor) && !overlay.pendingTurn));
+		return {
+			loading: detailValue.loading,
+			session,
+			messages,
+			traceEvents: [...session?.trace ?? [], ...overlay.trace],
+			runningTools: overlay.runningTools,
+			connection: overlay.connection,
+			statusText,
+			readyForInput,
+			sending: overlay.sending,
+			error: detailValue.error?.message ?? overlay.error,
+			sendError: overlay.sendError
+		};
+	});
+	onMount(store, () => {
+		mounted = true;
+		logActive("store:mount");
+		updateSnapshot(detailStore.get().data);
+		detailUnsubscribe = detailStore.listen((value) => {
+			updateSnapshot(value.data);
+			if (destroyed) return;
+			if (!shouldKeepLiveConnection(snapshotStore.get())) {
+				logActive("stream:idle", { reason: "detail-store-update" });
+				stopActiveLoop();
+				overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "stream-idle" }));
+				return;
+			}
+			ensureActiveLoop();
+		});
+		ensureActiveLoop();
+		return () => {
+			logActive("store:unmount");
+			mounted = false;
+			stopActiveLoop();
+			detailUnsubscribe?.();
+			detailUnsubscribe = null;
+		};
+	});
+	const sendMessage = (input) => {
+		const text = input.text.trim();
+		if (!text) return false;
+		const current = store.get();
+		if (current.sending || !current.readyForInput) return false;
+		const clientId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		logActive("send:start", {
+			clientId,
+			text
+		});
+		overlayStore.set(reduceOverlayState(overlayStore.get(), {
+			type: "send-started",
+			clientId,
+			text
+		}));
+		ensureActiveLoop();
+		deps.sendMessage({
+			sessionId: args.sessionId,
+			text,
+			done: input.done,
+			steeringMode: input.steeringMode
+		}).then(() => {
+			logActive("send:acknowledged", { clientId });
+			overlayStore.set(reduceOverlayState(overlayStore.get(), { type: "send-acknowledged" }));
+		}).catch((error) => {
+			const message = error instanceof Error ? error.message : "Failed to send message.";
+			logActive("send:failed", {
+				clientId,
+				message
+			});
+			overlayStore.set(reduceOverlayState(overlayStore.get(), {
+				type: "send-failed",
+				clientId,
+				message
+			}));
+		});
+		return true;
+	};
+	const deactivate = () => {
+		logActive("store:dispose");
+		mounted = false;
+		stopActiveLoop();
+		detailUnsubscribe?.();
+		detailUnsubscribe = null;
+	};
+	const destroy = () => {
+		if (destroyed) return;
+		logActive("store:destroy");
+		destroyed = true;
+		deactivate();
+	};
+	return {
+		store,
+		sendMessage,
+		refetch,
+		deactivate,
+		destroy
+	};
+}
+
+//#endregion
+export { createPiSessionStore };
+//# sourceMappingURL=session-store.js.map