cortena-ui 1.5.0 → 1.7.0

package/dist/agent-chat/store.js

@@ -1,7 +1,8 @@
 "use client";
 "use client";
 import { extractA2UIBlocks, foldA2UIBlocks } from "./a2ui-block.js";
-import { isProvisionalSessionKey, isSessionOfAgent, mintSessionKey, parseHistoryMessages, readStoredSessionKey, separateThinking, wouldShrinkHistory, writeStoredSessionKey } from "./session.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
 /**
@@ -36,6 +37,8 @@ const EMPTY = {
 	loadingHistory: false,
 	toolOrder: [],
 	tools: {},
+	steps: [],
+	retiredSteps: [],
 	approvals: [],
 	historyCount: 0,
 	sessions: [],
@@ -63,6 +66,11 @@ function reduce(state, action) {
 			...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, {
@@ -78,7 +86,10 @@ function reduce(state, action) {
 		case "send": return {
 			...state,
 			sessionKey: action.sessionKey,
-			messages: action.message ? [...state.messages, action.message] : state.messages,
+			messages: action.message ? [...state.messages, action.message] : action.reanchor ? state.messages.map((m) => m.id === action.reanchor ? {
+				...m,
+				runId: action.runId
+			} : m) : state.messages,
 			streaming: true,
 			streamText: "",
 			streamThinkingText: "",
@@ -86,9 +97,15 @@ function reduce(state, action) {
 			runId: action.runId,
 			toolOrder: [],
 			tools: {},
+			steps: [],
+			retiredSteps: [],
 			approvals: [],
 			error: null
 		};
+		case "message/remove": return {
+			...state,
+			messages: state.messages.filter((m) => m.id !== action.id)
+		};
 		case "send/failed": return {
 			...state,
 			streaming: false,
@@ -108,13 +125,18 @@ function reduce(state, action) {
 			streamThinkingText: "",
 			streamA2ui: [],
 			runId: null,
-			approvals: []
+			approvals: [],
+			steps: endRunningSteps(state.steps, { kind: "stopped" })
 		};
 		case "history/loading": return {
 			...state,
 			loadingHistory: true
 		};
 		case "history/loaded":
+			if (action.sessionKey !== state.sessionKey) return {
+				...state,
+				loadingHistory: false
+			};
 			if (wouldShrinkHistory({
 				currentSessionKey: state.sessionKey,
 				loadedSessionKey: action.sessionKey,
@@ -139,13 +161,18 @@ function reduce(state, action) {
 				streamThinkingText: "",
 				streamA2ui: []
 			};
-		case "history/older": return {
-			...state,
-			messages: [...action.messages, ...state.messages],
-			hasMoreHistory: action.hasMore,
-			loadingHistory: false,
-			historyCount: state.historyCount + action.records
-		};
+		case "history/older":
+			if (action.sessionKey !== state.sessionKey) return {
+				...state,
+				loadingHistory: false
+			};
+			return {
+				...state,
+				messages: [...action.messages, ...state.messages],
+				hasMoreHistory: action.hasMore,
+				loadingHistory: false,
+				historyCount: state.historyCount + action.records
+			};
 		case "history/failed": return {
 			...state,
 			loadingHistory: false
@@ -159,6 +186,10 @@ function reduce(state, action) {
 			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
@@ -203,7 +234,8 @@ function reduceChat(state, event) {
 				streaming: false,
 				streamText: "",
 				streamThinkingText: "",
-				streamA2ui: []
+				streamA2ui: [],
+				steps: endRunningSteps(state.steps, event.interrupted ? { kind: "paused" } : { kind: "finished" })
 			};
 			if (!text && a2ui.length === 0) {
 				const accumulated = state.streamThinkingText;
@@ -260,6 +292,10 @@ function reduceChat(state, event) {
 			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",
@@ -333,16 +369,275 @@ function reduceTool(state, event) {
 			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]
+		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")
 	};
 }
-function useAgentChat({ client, storageScope, ephemeral, thinking }) {
+/** 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, mintSessionKey: mintKey, restoreSession = true, listSessions = true }) {
 	const [state, dispatch] = React.useReducer(reduce, EMPTY);
 	const stateRef = React.useRef(state);
 	stateRef.current = state;
@@ -372,6 +667,7 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 		};
 	}, [client]);
 	const refreshSessions = React.useCallback(() => {
+		if (!listSessions) return;
 		dispatch({ kind: "sessions/loading" });
 		client.request("sessions.list", { includeDerivedTitles: true }).then((response) => {
 			const sessions = (response?.sessions ?? []).filter((s) => isSessionOfAgent(s.key, client.agentId));
@@ -389,7 +685,7 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 				message: errorText(err)
 			});
 		});
-	}, [client]);
+	}, [client, listSessions]);
 	const loadHistory = React.useCallback((sessionKey) => {
 		dispatch({ kind: "history/loading" });
 		client.request("chat.history", {
@@ -410,13 +706,18 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 	React.useEffect(() => {
 		if (restored.current) return;
 		restored.current = true;
-		const stored = ephemeral ? null : readStoredSessionKey(storageScope);
+		const stored = ephemeral || !restoreSession ? 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();
@@ -425,8 +726,50 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 		ephemeral,
 		loadHistory,
 		refreshSessions,
+		restoreSession,
 		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",
@@ -434,24 +777,26 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 		});
 		if (!ephemeral) writeStoredSessionKey(storageScope, key);
 	}, [ephemeral, storageScope]);
-	const run = React.useCallback((text, extra = {}) => {
+	const run = React.useCallback((text, extra = {}, reanchor) => {
 		const current = stateRef.current;
 		if (current.streaming) return;
-		const sessionKey = current.sessionKey ?? mintSessionKey(client.agentId);
+		const sessionKey = current.sessionKey ?? (mintKey ? mintKey() : mintSessionKey(client.agentId));
 		if (!current.sessionKey && !ephemeral) writeStoredSessionKey(storageScope, sessionKey);
 		const runId = generateId();
-		const message = text || !extra.a2uiAction && !extra.mcpAppAction ? {
+		const message = !reanchor && (text || !extra.a2uiAction && !extra.mcpAppAction) ? {
 			id: runId,
 			role: "user",
 			text,
 			timestamp: Date.now(),
-			runId
+			runId,
+			...extra.attachments?.length ? { attachmentItems: extra.attachments } : {}
 		} : null;
 		dispatch({
 			kind: "send",
 			message,
 			runId,
-			sessionKey
+			sessionKey,
+			...reanchor ? { reanchor } : {}
 		});
 		client.send({
 			sessionKey,
@@ -466,16 +811,44 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 	}, [
 		client,
 		ephemeral,
+		mintKey,
 		refreshSessions,
 		storageScope,
 		thinking
 	]);
-	const send = React.useCallback((text, attachments) => {
-		run(text, attachments?.length ? { attachments } : {});
+	const send = React.useCallback((text, attachments, options) => {
+		run(text, {
+			...attachments?.length ? { attachments } : {},
+			...options?.model ? { model: options.model } : {},
+			...options?.thinking ? { thinking: options.thinking } : {}
+		});
 	}, [run]);
 	const sendAction = React.useCallback((a2uiAction) => {
 		run("", { a2uiAction });
 	}, [run]);
+	const sendMcpAppAction = React.useCallback((mcpAppAction) => {
+		run("", { mcpAppAction });
+	}, [run]);
+	const regenerate = React.useCallback((messageId) => {
+		const { messages, streaming } = stateRef.current;
+		if (streaming) return;
+		const index = messages.findIndex((m) => m.id === messageId);
+		if (index < 1) return;
+		let question = null;
+		for (let i = index - 1; i >= 0; i -= 1) {
+			const candidate = messages[i];
+			if (candidate?.role === "user" && !candidate.isToolMessage) {
+				question = candidate;
+				break;
+			}
+		}
+		if (question === null) return;
+		dispatch({
+			kind: "message/remove",
+			id: messageId
+		});
+		run(question.text, {}, question.id);
+	}, [run]);
 	const abort = React.useCallback(() => {
 		const { runId, sessionKey } = stateRef.current;
 		dispatch({ kind: "abort" });
@@ -487,7 +860,10 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 	const resolveApproval = React.useCallback((id, decision) => {
 		const request = stateRef.current.approvals.find((r) => r.id === id);
 		if (!request) return;
-		dispatch({
+		dispatch(decision === "deny" ? {
+			kind: "approval/denied",
+			id
+		} : {
 			kind: "approval/resolved",
 			id
 		});
@@ -503,38 +879,55 @@ function useAgentChat({ client, storageScope, ephemeral, thinking }) {
 		});
 	}, [client]);
 	const newSession = React.useCallback(() => {
-		setSession(mintSessionKey(client.agentId));
-	}, [client, setSession]);
+		setSession(mintKey ? mintKey() : mintSessionKey(client.agentId));
+	}, [
+		client,
+		mintKey,
+		setSession
+	]);
+	const clearSession = React.useCallback(() => {
+		dispatch({
+			kind: "session",
+			key: null
+		});
+		if (!ephemeral) writeStoredSessionKey(storageScope, null);
+	}, [ephemeral, storageScope]);
 	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;
+		if (!current.sessionKey || current.loadingHistory || !current.hasMoreHistory) return false;
+		const sessionKey = current.sessionKey;
 		dispatch({ kind: "history/loading" });
 		client.request("chat.history", {
-			sessionKey: current.sessionKey,
+			sessionKey,
 			limit: 100,
 			offset: current.historyCount
 		}).then((response) => {
 			const records = response?.messages ?? [];
 			dispatch({
 				kind: "history/older",
+				sessionKey,
 				messages: parseHistoryMessages(records),
 				hasMore: response?.hasMore ?? false,
 				records: records.length
 			});
 		}).catch(() => dispatch({ kind: "history/failed" }));
+		return true;
 	}, [client]);
 	return {
 		...state,
 		send,
 		sendAction,
+		sendMcpAppAction,
 		abort,
 		resolveApproval,
 		newSession,
 		resumeSession,
+		clearSession,
+		regenerate,
 		loadOlder,
 		refreshSessions
 	};
@@ -543,6 +936,6 @@ function errorText(err) {
 	return err instanceof Error ? err.message : "The agent could not be reached";
 }
 //#endregion
-export { useAgentChat };
+export { readResultMetadata, useAgentChat };
 
 //# sourceMappingURL=store.js.map