cortena-ui 1.4.2 → 1.6.0

package/dist/agent-chat/store.js

@@ -0,0 +1,876 @@
+"use client";
+"use client";
+import { extractA2UIBlocks, foldA2UIBlocks } from "./a2ui-block.js";
+import { confirmationRequiredLabel, isGenericLabel, stepLabel, truncate } from "./step-label.js";
+import { isProvisionalSessionKey, isSessionOfAgent, mintSessionKey, parseHistoryMessages, readStoredSessionKey, readStoredSteps, separateThinking, wouldShrinkHistory, writeStoredSessionKey, writeStoredSteps } from "./session.js";
+import * as React from "react";
+//#region src/agent-chat/store.ts
+/**
+* The chat state, and the hook that drives an `AgentChatClient` from React.
+*
+* The accumulation rules are ported from `cortena-shared/src/stores/use-chat.ts`
+* (Cortena monorepo) so a run leaves this state in the same place it leaves
+* cortenaweb's. The ones that are not obvious, and that a rewrite gets wrong:
+*
+* - A `delta` carries a snapshot, so text and A2UI blocks are **replaced**, not
+*   appended. Appending doubles every character.
+* - Thinking is never replaced by something shorter. The upstream emitter can
+*   fall back to increments when a snapshot is unavailable, and treating one of
+*   those as a snapshot truncates the accumulated chain of thought.
+* - On `final`, a second assistant message in the same turn folds the previous
+*   visible text into the chain of thought rather than adding a second bubble,
+*   and keeps the A2UI blocks of the message it folded away — the surface is
+*   still on screen and still interactive.
+* - A reply that is only a drawn surface has no text, so `text || a2ui.length`
+*   is the test for "there is something to show". Testing text alone silently
+*   dropped everything the agent drew.
+*/
+const EMPTY = {
+	sessionKey: null,
+	messages: [],
+	streaming: false,
+	streamText: "",
+	streamThinkingText: "",
+	streamA2ui: [],
+	runId: null,
+	hasMoreHistory: false,
+	loadingHistory: false,
+	toolOrder: [],
+	tools: {},
+	steps: [],
+	retiredSteps: [],
+	approvals: [],
+	historyCount: 0,
+	sessions: [],
+	loadingSessions: false,
+	error: null
+};
+function generateId() {
+	return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function extractText(message) {
+	return (message?.content ?? []).filter((c) => c.type === "text" && c.text).map((c) => c.text).join("");
+}
+function extractThinking(message) {
+	return (message?.content ?? []).filter((c) => c.type === "thinking").map((c) => c.thinking ?? c.text ?? "").filter(Boolean).join("\n\n");
+}
+function reduce(state, action) {
+	switch (action.kind) {
+		case "chat": return reduceChat(state, action.event);
+		case "tool": return reduceTool(state, action.event);
+		case "approval/request": return state.approvals.some((r) => r.id === action.request.id) ? state : {
+			...state,
+			approvals: [...state.approvals, action.request]
+		};
+		case "approval/resolved": return {
+			...state,
+			approvals: state.approvals.filter((r) => r.id !== action.id)
+		};
+		case "approval/denied": return {
+			...state,
+			approvals: state.approvals.filter((r) => r.id !== action.id),
+			steps: endRunningSteps(state.steps, { kind: "denied" })
+		};
+		case "approval/failed": return state.approvals.some((r) => r.id === action.request.id) ? state : {
+			...state,
+			approvals: [...state.approvals, {
+				...action.request,
+				error: action.message
+			}]
+		};
+		case "session": return action.key === state.sessionKey ? state : {
+			...EMPTY,
+			sessions: state.sessions,
+			sessionKey: action.key
+		};
+		case "send": return {
+			...state,
+			sessionKey: action.sessionKey,
+			messages: action.message ? [...state.messages, action.message] : state.messages,
+			streaming: true,
+			streamText: "",
+			streamThinkingText: "",
+			streamA2ui: [],
+			runId: action.runId,
+			toolOrder: [],
+			tools: {},
+			steps: [],
+			retiredSteps: [],
+			approvals: [],
+			error: null
+		};
+		case "send/failed": return {
+			...state,
+			streaming: false,
+			runId: null,
+			messages: [...state.messages, {
+				id: generateId(),
+				role: "assistant",
+				text: action.message,
+				timestamp: Date.now(),
+				isError: true
+			}]
+		};
+		case "abort": return {
+			...state,
+			streaming: false,
+			streamText: "",
+			streamThinkingText: "",
+			streamA2ui: [],
+			runId: null,
+			approvals: [],
+			steps: endRunningSteps(state.steps, { kind: "stopped" })
+		};
+		case "history/loading": return {
+			...state,
+			loadingHistory: true
+		};
+		case "history/loaded":
+			if (wouldShrinkHistory({
+				currentSessionKey: state.sessionKey,
+				loadedSessionKey: action.sessionKey,
+				currentCount: state.messages.length,
+				loadedCount: action.messages.length
+			})) return {
+				...state,
+				sessionKey: action.sessionKey,
+				hasMoreHistory: action.hasMore,
+				loadingHistory: false,
+				historyCount: action.records
+			};
+			return {
+				...state,
+				sessionKey: action.sessionKey,
+				messages: action.messages,
+				hasMoreHistory: action.hasMore,
+				loadingHistory: false,
+				historyCount: action.records,
+				streaming: false,
+				streamText: "",
+				streamThinkingText: "",
+				streamA2ui: []
+			};
+		case "history/older": return {
+			...state,
+			messages: [...action.messages, ...state.messages],
+			hasMoreHistory: action.hasMore,
+			loadingHistory: false,
+			historyCount: state.historyCount + action.records
+		};
+		case "history/failed": return {
+			...state,
+			loadingHistory: false
+		};
+		case "sessions/loading": return {
+			...state,
+			loadingSessions: true
+		};
+		case "sessions/loaded": return {
+			...state,
+			sessions: action.sessions,
+			loadingSessions: false
+		};
+		case "steps/restored": return state.steps.length > 0 ? state : {
+			...state,
+			steps: action.steps.slice(-50)
+		};
+		case "error": return {
+			...state,
+			error: action.message
+		};
+		default: return state;
+	}
+}
+function reduceChat(state, event) {
+	if (event.sessionKey && state.sessionKey && event.sessionKey !== state.sessionKey) {
+		if (!isProvisionalSessionKey(state.sessionKey)) return state;
+		state = {
+			...state,
+			sessionKey: event.sessionKey
+		};
+	} else if (event.sessionKey && !state.sessionKey) state = {
+		...state,
+		sessionKey: event.sessionKey
+	};
+	switch (event.state) {
+		case "delta": {
+			const text = extractText(event.message);
+			const thinking = extractThinking(event.message);
+			const a2ui = extractA2UIBlocks(event.message);
+			const next = {
+				...state,
+				streaming: true
+			};
+			if (text) next.streamText = text;
+			if (a2ui.length > 0) next.streamA2ui = a2ui;
+			const acceptThinking = !!thinking && thinking.length >= state.streamThinkingText.length;
+			if (acceptThinking) next.streamThinkingText = thinking;
+			return text || acceptThinking || a2ui.length > 0 ? next : state;
+		}
+		case "final": {
+			const finalText = extractText(event.message);
+			const finalThinking = extractThinking(event.message);
+			const finalA2ui = extractA2UIBlocks(event.message);
+			const text = finalText || state.streamText;
+			const thinkingFromBlocks = finalThinking || state.streamThinkingText;
+			const a2ui = foldA2UIBlocks(finalA2ui.length > 0 ? finalA2ui : state.streamA2ui);
+			const cleared = {
+				streaming: false,
+				streamText: "",
+				streamThinkingText: "",
+				streamA2ui: [],
+				steps: endRunningSteps(state.steps, event.interrupted ? { kind: "paused" } : { kind: "finished" })
+			};
+			if (!text && a2ui.length === 0) {
+				const accumulated = state.streamThinkingText;
+				const last = state.messages[state.messages.length - 1];
+				if (!accumulated || !foldsInto(last, state.runId)) return {
+					...state,
+					...cleared
+				};
+				const messages = [...state.messages];
+				messages[messages.length - 1] = {
+					...last,
+					timestamp: Date.now(),
+					thinkingText: [last.thinkingText ?? "", accumulated].filter(Boolean).join("\n\n")
+				};
+				return {
+					...state,
+					...cleared,
+					messages
+				};
+			}
+			const { thinkingText: tagThinking, mainText } = separateThinking(text);
+			const thinkingText = thinkingFromBlocks || tagThinking;
+			const displayText = thinkingFromBlocks ? text : mainText;
+			const messages = [...state.messages];
+			const last = messages[messages.length - 1];
+			if (foldsInto(last, state.runId)) {
+				const updated = [[last.thinkingText ?? "", last.text.trim()].filter(Boolean).join("\n\n"), thinkingText].filter(Boolean).join("\n\n");
+				messages[messages.length - 1] = {
+					...last,
+					text: displayText,
+					timestamp: Date.now(),
+					...updated ? { thinkingText: updated } : { thinkingText: void 0 },
+					...a2ui.length > 0 || last.a2ui?.length ? { a2ui: foldA2UIBlocks([...last.a2ui ?? [], ...a2ui]) } : {}
+				};
+			} else messages.push({
+				id: generateId(),
+				role: "assistant",
+				text: displayText,
+				timestamp: Date.now(),
+				...state.runId ? { runId: state.runId } : {},
+				...thinkingText ? { thinkingText } : {},
+				...a2ui.length > 0 ? { a2ui } : {}
+			});
+			return {
+				...state,
+				...cleared,
+				messages
+			};
+		}
+		case "error": return {
+			...state,
+			streaming: false,
+			streamText: "",
+			streamThinkingText: "",
+			streamA2ui: [],
+			runId: null,
+			steps: endRunningSteps(state.steps, {
+				kind: "failed",
+				message: truncate(event.errorMessage ?? "The run failed.", ERROR_LIMIT)
+			}),
+			messages: [...state.messages, {
+				id: generateId(),
+				role: "assistant",
+				text: event.errorMessage ?? "An error occurred",
+				timestamp: Date.now(),
+				isError: true
+			}]
+		};
+		default: return state;
+	}
+}
+/**
+* May a `final` fold into this message?
+*
+* Only when it is an assistant bubble from the SAME run. Two assistant
+* messages in one turn are one answer with an interruption in the middle, and
+* folding them is right. Two assistant messages from different runs are two
+* answers to two questions, and folding them rewrote the earlier answer with
+* the later one — visibly, in a transcript the user had already read.
+*
+* A message with no `runId` is history, which never folds either.
+*/
+function foldsInto(last, runId) {
+	return last !== void 0 && last.role === "assistant" && !last.isError && runId !== null && last.runId === runId;
+}
+function reduceTool(state, event) {
+	const id = event.data.id;
+	if (!id) return state;
+	const base = state.tools[id] ?? {
+		id,
+		name: event.data.name ?? "tool",
+		status: "running",
+		startedAt: event.data.startedAt ?? Date.now()
+	};
+	let entry;
+	switch (event.event) {
+		case "tool.start":
+			entry = {
+				...base,
+				name: event.data.name ?? base.name,
+				status: "running"
+			};
+			break;
+		case "tool.args":
+			entry = {
+				...base,
+				input: event.data.input
+			};
+			break;
+		case "tool.progress":
+			entry = {
+				...base,
+				output: event.data.output
+			};
+			break;
+		case "tool.complete":
+			entry = {
+				...base,
+				status: "complete",
+				output: event.data.output,
+				completedAt: event.data.completedAt ?? Date.now()
+			};
+			break;
+		case "tool.error":
+			entry = {
+				...base,
+				status: "error",
+				output: event.data.output,
+				completedAt: event.data.completedAt ?? Date.now()
+			};
+			break;
+		default: return state;
+	}
+	const stepped = reduceStep(state, event, id);
+	return {
+		...state,
+		tools: {
+			...state.tools,
+			[id]: entry
+		},
+		toolOrder: state.toolOrder.includes(id) ? state.toolOrder : [...state.toolOrder, id],
+		steps: stepped.steps,
+		retiredSteps: stepped.retiredSteps
+	};
+}
+/**
+* `TOOL_CALL_RESULT.metadata`, read defensively.
+*
+* `null` when nothing usable arrived, which a transport that predates the
+* contract will produce. A step with no metadata at all is treated as a
+* success by `tool.complete` and as a failure by `tool.error`, which is the
+* most either event can honestly claim on its own.
+*
+* Note what is NOT here: any reading of `content`. The result text is the
+* model's copy of the reply, in whatever shape the tool returned, and the
+* client's previous attempt to find `ok: false` in it matched nothing real —
+* a Cortena tool result is `{ content: [...], details }`, so the envelope it
+* was looking for was two levels down when it existed at all.
+*/
+function readResultMetadata(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+	const record = raw;
+	const meta = readMeta(record.meta);
+	return {
+		...typeof record.toolName === "string" ? { toolName: record.toolName } : {},
+		isError: record.isError === true,
+		...meta ? { meta } : {}
+	};
+}
+function readMeta(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+	const record = raw;
+	const meta = {
+		...typeof record.status === "number" ? { status: record.status } : {},
+		...typeof record.code === "string" ? { code: record.code } : {},
+		...typeof record.message === "string" ? { message: record.message } : {}
+	};
+	return Object.keys(meta).length > 0 ? meta : null;
+}
+/**
+* Is this the broker asking for a yes rather than reporting a failure?
+*
+* The broker refuses a catalogued write with `409 confirmation_required` until
+* the call carries `confirmed: true`. It is the safety rail working, and the
+* step says so instead of showing the user a red cross for it.
+*
+* Keyed on the CODE, never on the status. `409` is also an ordinary conflict —
+* a task already claimed, a version that moved under a write — and wording one
+* of those as "Needs your confirmation" invites the user to retry something
+* that will never work.
+*/
+function isConfirmationRequired(meta) {
+	return meta?.code === "confirmation_required";
+}
+/** Longest failure message put on a step. */
+const ERROR_LIMIT = 200;
+/**
+* The human part of a tool result, for a failure that carried no `meta`.
+*
+* A Cortena tool returns `{ content: [{ type: "text", text }], details }`,
+* JSON-stringified by the mapper, so the text blocks are the message and the
+* rest is machinery. Anything else — a plain string, a shape this does not
+* recognise — is used as it stands. Bounded and sanitised either way.
+*/
+function resultText(output) {
+	const direct = typeof output === "string" ? output : "";
+	let value = output;
+	if (direct) try {
+		value = JSON.parse(direct);
+	} catch {
+		return truncate(direct, ERROR_LIMIT);
+	}
+	if (typeof value === "object" && value !== null) {
+		const content = value.content;
+		if (Array.isArray(content)) {
+			const text = content.map((part) => typeof part === "object" && part !== null && typeof part.text === "string" ? part.text : "").filter(Boolean).join(" ");
+			if (text) return truncate(text, ERROR_LIMIT);
+		}
+	}
+	return truncate(direct, ERROR_LIMIT);
+}
+/** What a failed step says: the server's message, or the result text. */
+function errorMessageOf(meta, output) {
+	return (meta?.message ? truncate(meta.message, ERROR_LIMIT) : "") || resultText(output) || "The call failed.";
+}
+/** The call's input as an object, or nothing when it never parsed as one. */
+function readArgs(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input) ? input : void 0;
+}
+/** Is this step still open — spinning, or waiting on the user? */
+function isOpenStep(step) {
+	return step.status === "running" || step.status === "paused";
+}
+function endRunningSteps(steps, outcome) {
+	const closes = (step) => outcome.kind === "paused" ? step.status === "running" : outcome.kind === "denied" ? step.status === "paused" : isOpenStep(step);
+	if (!steps.some(closes)) return steps;
+	const endedAt = Date.now();
+	return steps.map((step) => {
+		if (!closes(step)) return step;
+		if (outcome.kind === "paused") return {
+			...step,
+			status: "paused"
+		};
+		if (outcome.kind === "failed") return {
+			...step,
+			status: "error",
+			endedAt,
+			errorMessage: outcome.message
+		};
+		if (outcome.kind === "stopped" || outcome.kind === "denied") return {
+			...step,
+			status: "stopped",
+			endedAt
+		};
+		return {
+			...step,
+			status: "done",
+			endedAt
+		};
+	});
+}
+/**
+* A step appended, with the list capped at `STEP_LIMIT`.
+*
+* A turn with more calls than this is a loop, not a plan, and an uncapped list
+* grows without bound in memory and re-renders the whole strip on every event
+* of it. The most recent are kept: they are what the user is waiting on, and
+* the ids of the ones dropped are kept so a late result for one is recognised
+* rather than mistaken for a call nobody announced.
+*/
+function append(steps, retiredSteps, step) {
+	const next = [...steps, step];
+	if (next.length <= 50) return {
+		steps: next,
+		retiredSteps
+	};
+	const dropped = next.slice(0, next.length - 50).map((s) => s.id);
+	return {
+		steps: next.slice(-50),
+		retiredSteps: [...retiredSteps, ...dropped].slice(-RETIRED_LIMIT)
+	};
+}
+/** Most dropped ids remembered. Enough for stragglers, not a transcript. */
+const RETIRED_LIMIT = 100;
+function replaceStep(steps, index, next) {
+	const copy = [...steps];
+	copy[index] = next;
+	return copy;
+}
+/**
+* One tool event, folded into the step list.
+*
+* Start and end are paired by the AG-UI `toolCallId`, not by position: calls
+* overlap, and a run that issues two searches at once ended the wrong one when
+* the list was treated as a stack.
+*
+* The label is recomputed when the arguments land, because they land in a
+* SECOND event. `TOOL_CALL_START` carries the name only, so a label fixed at
+* start time is "Working: engram_search" for the whole of the call — the one
+* line the wording map exists to avoid.
+*/
+function reduceStep(state, event, id) {
+	const { steps, retiredSteps } = state;
+	const keep = {
+		steps,
+		retiredSteps
+	};
+	const index = steps.findIndex((step) => step.id === id);
+	const existing = index === -1 ? void 0 : steps[index];
+	if (!existing && retiredSteps.includes(id)) return keep;
+	if (event.event === "tool.start") {
+		if (existing && !isOpenStep(existing)) return keep;
+		const toolName = event.data.name ?? existing?.toolName ?? "tool";
+		const step = {
+			id,
+			toolName,
+			...existing?.args ? { args: existing.args } : {},
+			label: stepLabel(toolName, existing?.args, "running"),
+			startedAt: event.data.startedAt ?? existing?.startedAt ?? Date.now(),
+			status: "running"
+		};
+		return existing && index !== -1 ? {
+			steps: replaceStep(steps, index, step),
+			retiredSteps
+		} : append(steps, retiredSteps, step);
+	}
+	const base = existing ?? {
+		id,
+		toolName: event.data.name ?? "tool",
+		label: stepLabel(event.data.name ?? "tool", void 0, "running"),
+		startedAt: event.data.startedAt ?? Date.now(),
+		status: "running"
+	};
+	const at = index === -1 ? steps.length : index;
+	const put = (next) => index === -1 ? append(steps, retiredSteps, next) : {
+		steps: replaceStep(steps, at, next),
+		retiredSteps
+	};
+	switch (event.event) {
+		case "tool.args": {
+			const args = readArgs(event.data.input);
+			if (!args) return keep;
+			if (base.label === CONFIRMATION_FALLBACK) return put({
+				...base,
+				args,
+				label: confirmationRequiredLabel(args)
+			});
+			const open = isOpenStep(base);
+			const relabel = open || isGenericLabel(base.toolName, base.label);
+			return put({
+				...base,
+				args,
+				label: relabel ? stepLabel(base.toolName, args, open ? "running" : "done") : base.label
+			});
+		}
+		case "tool.progress": return keep;
+		case "tool.complete":
+		case "tool.error": return put(endStep(base, event));
+		default: return keep;
+	}
+}
+/** The confirmation label with no operation on it; see `tool.args` above. */
+const CONFIRMATION_FALLBACK = confirmationRequiredLabel(void 0);
+/**
+* A start event's step, ended by its result.
+*
+* The whole outcome decision, in one place, against
+* `TOOL_CALL_RESULT.metadata` and nothing else:
+*
+* - `isError` with `meta.code === "confirmation_required"` — not a failure.
+*   The broker is asking a question, and the step is relabelled to ask it.
+* - `isError` otherwise — a failure, worded from `meta.message` when there is
+*   one and from the result text when there is not.
+* - neither — done.
+*/
+function endStep(base, event) {
+	const metadata = readResultMetadata(event.data.metadata);
+	const isError = metadata?.isError === true || event.event === "tool.error";
+	const meta = metadata?.meta;
+	const endedAt = event.data.completedAt ?? Date.now();
+	if (isError && isConfirmationRequired(meta)) return {
+		...base,
+		status: "done",
+		endedAt,
+		label: confirmationRequiredLabel(base.args)
+	};
+	if (isError) return {
+		...base,
+		status: "error",
+		endedAt,
+		errorMessage: errorMessageOf(meta, event.data.output)
+	};
+	return {
+		...base,
+		status: "done",
+		endedAt,
+		label: stepLabel(base.toolName, base.args, "done")
+	};
+}
+/** How long a burst of step changes is collapsed for before it is written. */
+const STEP_WRITE_DEBOUNCE_MS = 250;
+function useAgentChat({ client, storageScope, ephemeral, thinking }) {
+	const [state, dispatch] = React.useReducer(reduce, EMPTY);
+	const stateRef = React.useRef(state);
+	stateRef.current = state;
+	React.useEffect(() => {
+		const offChat = client.onChat((event) => dispatch({
+			kind: "chat",
+			event
+		}));
+		const offTool = client.onTool((event) => dispatch({
+			kind: "tool",
+			event
+		}));
+		const offApproval = client.onApproval((event) => {
+			if (event.type === "request") dispatch({
+				kind: "approval/request",
+				request: event.request
+			});
+			else dispatch({
+				kind: "approval/resolved",
+				id: event.id
+			});
+		});
+		return () => {
+			offChat();
+			offTool();
+			offApproval();
+		};
+	}, [client]);
+	const refreshSessions = React.useCallback(() => {
+		dispatch({ kind: "sessions/loading" });
+		client.request("sessions.list", { includeDerivedTitles: true }).then((response) => {
+			const sessions = (response?.sessions ?? []).filter((s) => isSessionOfAgent(s.key, client.agentId));
+			dispatch({
+				kind: "sessions/loaded",
+				sessions
+			});
+		}).catch((err) => {
+			dispatch({
+				kind: "sessions/loaded",
+				sessions: []
+			});
+			dispatch({
+				kind: "error",
+				message: errorText(err)
+			});
+		});
+	}, [client]);
+	const loadHistory = React.useCallback((sessionKey) => {
+		dispatch({ kind: "history/loading" });
+		client.request("chat.history", {
+			sessionKey,
+			limit: 100
+		}).then((response) => {
+			const records = response?.messages ?? [];
+			dispatch({
+				kind: "history/loaded",
+				sessionKey,
+				messages: parseHistoryMessages(records),
+				hasMore: response?.hasMore ?? false,
+				records: records.length
+			});
+		}).catch(() => dispatch({ kind: "history/failed" }));
+	}, [client]);
+	const restored = React.useRef(false);
+	React.useEffect(() => {
+		if (restored.current) return;
+		restored.current = true;
+		const stored = ephemeral ? null : readStoredSessionKey(storageScope);
+		const key = stored && isSessionOfAgent(stored, client.agentId) ? stored : null;
+		if (key) {
+			dispatch({
+				kind: "session",
+				key
+			});
+			const steps = ephemeral ? [] : readStoredSteps(storageScope, key);
+			if (steps.length > 0) dispatch({
+				kind: "steps/restored",
+				steps
+			});
+			loadHistory(key);
+		}
+		refreshSessions();
+	}, [
+		client,
+		ephemeral,
+		loadHistory,
+		refreshSessions,
+		storageScope
+	]);
+	/**
+	* Keep the per-window store in step with the strip, on a debounce.
+	*
+	* Skipped while there is no session key, which is also the first commit —
+	* writing then would empty the slot the effect above is about to read.
+	*
+	* Debounced because a busy run changes `steps` several times per call —
+	* start, arguments, result — and each write serialises the whole list and
+	* hands it to a SYNCHRONOUS storage API on the main thread. A quarter of a
+	* second collapses a call's worth of edits into one write and is far below
+	* anything a reload could notice.
+	*/
+	const pendingSteps = React.useRef(null);
+	React.useEffect(() => {
+		if (ephemeral || !state.sessionKey) return;
+		const sessionKey = state.sessionKey;
+		const steps = state.steps;
+		pendingSteps.current = {
+			sessionKey,
+			steps
+		};
+		const id = setTimeout(() => {
+			pendingSteps.current = null;
+			writeStoredSteps(storageScope, sessionKey, steps);
+		}, STEP_WRITE_DEBOUNCE_MS);
+		return () => clearTimeout(id);
+	}, [
+		ephemeral,
+		state.sessionKey,
+		state.steps,
+		storageScope
+	]);
+	React.useEffect(() => {
+		return () => {
+			const pending = pendingSteps.current;
+			if (!ephemeral && pending) {
+				pendingSteps.current = null;
+				writeStoredSteps(storageScope, pending.sessionKey, pending.steps);
+			}
+		};
+	}, [ephemeral, storageScope]);
+	const setSession = React.useCallback((key) => {
+		dispatch({
+			kind: "session",
+			key
+		});
+		if (!ephemeral) writeStoredSessionKey(storageScope, key);
+	}, [ephemeral, storageScope]);
+	const run = React.useCallback((text, extra = {}) => {
+		const current = stateRef.current;
+		if (current.streaming) return;
+		const sessionKey = current.sessionKey ?? mintSessionKey(client.agentId);
+		if (!current.sessionKey && !ephemeral) writeStoredSessionKey(storageScope, sessionKey);
+		const runId = generateId();
+		const message = text || !extra.a2uiAction && !extra.mcpAppAction ? {
+			id: runId,
+			role: "user",
+			text,
+			timestamp: Date.now(),
+			runId
+		} : null;
+		dispatch({
+			kind: "send",
+			message,
+			runId,
+			sessionKey
+		});
+		client.send({
+			sessionKey,
+			message: text,
+			runId,
+			...thinking ? { thinking } : {},
+			...extra
+		}).then(() => refreshSessions()).catch((err) => dispatch({
+			kind: "send/failed",
+			message: errorText(err)
+		}));
+	}, [
+		client,
+		ephemeral,
+		refreshSessions,
+		storageScope,
+		thinking
+	]);
+	const send = React.useCallback((text, attachments) => {
+		run(text, attachments?.length ? { attachments } : {});
+	}, [run]);
+	const sendAction = React.useCallback((a2uiAction) => {
+		run("", { a2uiAction });
+	}, [run]);
+	const abort = React.useCallback(() => {
+		const { runId, sessionKey } = stateRef.current;
+		dispatch({ kind: "abort" });
+		client.abort({
+			...runId ? { runId } : {},
+			...sessionKey ? { sessionKey } : {}
+		}).catch(() => {});
+	}, [client]);
+	const resolveApproval = React.useCallback((id, decision) => {
+		const request = stateRef.current.approvals.find((r) => r.id === id);
+		if (!request) return;
+		dispatch(decision === "deny" ? {
+			kind: "approval/denied",
+			id
+		} : {
+			kind: "approval/resolved",
+			id
+		});
+		client.resolveApproval(id, decision, {
+			runId: request.runId,
+			sessionKey: request.sessionKey
+		}).catch((err) => {
+			dispatch({
+				kind: "approval/failed",
+				request,
+				message: errorText(err)
+			});
+		});
+	}, [client]);
+	const newSession = React.useCallback(() => {
+		setSession(mintSessionKey(client.agentId));
+	}, [client, setSession]);
+	const resumeSession = React.useCallback((key) => {
+		setSession(key);
+		loadHistory(key);
+	}, [loadHistory, setSession]);
+	const loadOlder = React.useCallback(() => {
+		const current = stateRef.current;
+		if (!current.sessionKey || current.loadingHistory || !current.hasMoreHistory) return;
+		dispatch({ kind: "history/loading" });
+		client.request("chat.history", {
+			sessionKey: current.sessionKey,
+			limit: 100,
+			offset: current.historyCount
+		}).then((response) => {
+			const records = response?.messages ?? [];
+			dispatch({
+				kind: "history/older",
+				messages: parseHistoryMessages(records),
+				hasMore: response?.hasMore ?? false,
+				records: records.length
+			});
+		}).catch(() => dispatch({ kind: "history/failed" }));
+	}, [client]);
+	return {
+		...state,
+		send,
+		sendAction,
+		abort,
+		resolveApproval,
+		newSession,
+		resumeSession,
+		loadOlder,
+		refreshSessions
+	};
+}
+function errorText(err) {
+	return err instanceof Error ? err.message : "The agent could not be reached";
+}
+//#endregion
+export { readResultMetadata, useAgentChat };
+
+//# sourceMappingURL=store.js.map