cortena-ui 1.4.2 → 1.6.0

package/dist/agent-chat/session.js

@@ -0,0 +1,391 @@
+"use client";
+import { truncate } from "./step-label.js";
+//#region src/agent-chat/session.ts
+/**
+* Sessions, history and the filter chain.
+*
+* Ported from `cortena-shared/src/stores/use-chat.ts` and
+* `cortenaweb/components/chat/message-bubble.tsx` (Cortena monorepo).
+* `cortena-shared` is not published, so the rules the two transports share
+* live here; keep them in step.
+*
+* The one deliberate difference is where the current session key is kept.
+* cortenaweb puts it in `localStorage`, which is shared by every tab of an
+* origin, so a second window adopted the first window's session: it inherited
+* a stream that was not its own and both windows then showed the same content.
+* Sessions here are **per window** — the key lives in `sessionStorage`, under a
+* name scoped to the extension — so opening the extension twice starts two
+* sessions. Both stay listed and either window can resume either one; two
+* windows on one session may both send, and cortenacore serialises the runs.
+*/
+/**
+* A new session key, minted client-side.
+*
+* `agent:<agentId>:new-<Date.now()>-<random36>`. cortenacore reads the
+* `agent:<id>:` prefix to bind the session to that agent's template, and the
+* key is the AG-UI `threadId` verbatim, prefix included. Minting it rather than
+* asking for one is what lets the first message go out immediately.
+*/
+function mintSessionKey(agentId) {
+	return `agent:${agentId}:new-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+/** Was this key minted locally for a chat that had no session yet? */
+function isProvisionalSessionKey(key) {
+	return /(^|:)new-\d+-[a-z0-9]+$/.test(key);
+}
+/** Does this session belong to this agent? `sessions.list` is filtered by it. */
+function isSessionOfAgent(key, agentId) {
+	return key.startsWith(`agent:${agentId}:`);
+}
+/** The `sessionStorage` name the current key is kept under, per extension. */
+function sessionStorageKey(scope) {
+	return `cortena.agent-chat.${scope}.session`;
+}
+/** The `sessionStorage` name the open/collapsed state is kept under. */
+function viewStorageKey(scope) {
+	return `cortena.agent-chat.${scope}.view`;
+}
+/** The `sessionStorage` name this window's progress steps are kept under. */
+function stepsStorageKey(scope) {
+	return `cortena.agent-chat.${scope}.steps`;
+}
+/**
+* `sessionStorage`, or nothing.
+*
+* Absent during SSR and refused outright when a browser blocks storage for the
+* origin, and neither is a reason for the chat not to work: without it a window
+* simply forgets its session on reload.
+*/
+function windowSessionStorage() {
+	try {
+		return typeof window === "undefined" ? null : window.sessionStorage;
+	} catch {
+		return null;
+	}
+}
+function readStoredSessionKey(scope) {
+	try {
+		return windowSessionStorage()?.getItem(sessionStorageKey(scope)) ?? null;
+	} catch {
+		return null;
+	}
+}
+function writeStoredSessionKey(scope, key) {
+	try {
+		const storage = windowSessionStorage();
+		if (!storage) return;
+		if (key === null) storage.removeItem(sessionStorageKey(scope));
+		else storage.setItem(sessionStorageKey(scope), key);
+	} catch {}
+}
+/** Most steps kept, in memory and in `sessionStorage`. A turn that long is a runaway loop. */
+const STEP_LIMIT = 50;
+/**
+* Most bytes the steps slot may occupy.
+*
+* `sessionStorage` is a few megabytes for the whole origin, shared with
+* everything else the host keeps there, and a step count alone does not bound
+* the size: fifty steps whose labels are all near the limit, with a failure
+* message on each, is a slot nobody budgeted for. Over the cap the OLDEST are
+* dropped, one at a time, because the recent ones are the ones a reload has to
+* bring back.
+*/
+const STEP_BYTE_LIMIT = 65536;
+/**
+* The steps of the current turn, and the session they belong to.
+*
+* They go in the per-window store beside the session key, for the same reason
+* the key does: a tab is reloaded mid-run, or a host remounts the surface on a
+* route change, and both threw the whole strip away. (Collapsing the pop-up is
+* NOT one of them — the panel is `hidden`, not unmounted, and the run streams
+* into it either way.) Messages come back from `chat.history`; steps do not
+* exist on the server, so this is the only place they can come back from.
+*
+* Scoped to a session key, and checked on read: resuming a different session
+* must not inherit the last one's steps.
+*/
+function readStoredSteps(scope, sessionKey) {
+	try {
+		const raw = windowSessionStorage()?.getItem(stepsStorageKey(scope));
+		if (!raw) return [];
+		const parsed = JSON.parse(raw);
+		if (parsed?.sessionKey !== sessionKey || !Array.isArray(parsed.steps)) return [];
+		return parsed.steps.filter((step) => typeof step?.id === "string" && typeof step?.label === "string").map(restoreStep).slice(-50);
+	} catch {
+		return [];
+	}
+}
+/** Every status a step may legitimately come back with. */
+const STEP_STATUSES = /* @__PURE__ */ new Set([
+	"running",
+	"done",
+	"error",
+	"stopped",
+	"paused"
+]);
+/**
+* A step as it comes back from storage.
+*
+* The important cases are `running` and `paused`. Neither is true any more:
+* the run that owned the call ended when the surface went away — a reload, a
+* remount on a route change; a collapsed pop-up only HIDES the strip and never
+* reaches this path — and no result will arrive for it now, so a restored
+* spinner spins until the user gives up and reloads again, which restores it.
+*
+* It comes back `stopped`, with no message. Neutral is the honest reading:
+* nothing failed, the work simply did not continue, and "Interrupted." drawn in
+* the failure colour told the user their call had broken when the page had.
+*
+* An unrecognised status is treated the same way. Nothing else writes this
+* slot today, but it is per-origin `sessionStorage` and this is the only place
+* that decides what a strip is allowed to render.
+*/
+function restoreStep(step) {
+	if (STEP_STATUSES.has(step.status) && step.status !== "running" && step.status !== "paused") return step;
+	const restored = {
+		...step,
+		status: "stopped",
+		endedAt: step.endedAt ?? Date.now()
+	};
+	delete restored.errorMessage;
+	return restored;
+}
+/**
+* The fields of a step that are safe to keep, and the only ones kept.
+*
+* `args` is deliberately absent. A tool call's arguments are the user's data —
+* what they searched for, whose record they opened, the body of what they
+* wrote — and `sessionStorage` is readable by every script on the origin,
+* survives the run, and is the sort of thing that ends up in a support bundle.
+* Nothing on screen needs them after the run: the LABEL is already derived
+* from them, and the label is what a restored strip shows.
+*/
+function storedStep(step) {
+	return {
+		id: truncate(step.id, 80),
+		toolName: truncate(step.toolName, 80),
+		label: step.label,
+		status: step.status,
+		startedAt: step.startedAt,
+		...step.endedAt === void 0 ? {} : { endedAt: step.endedAt },
+		...step.errorMessage === void 0 ? {} : { errorMessage: step.errorMessage }
+	};
+}
+/** The slot's contents, projected and trimmed to fit the byte cap. */
+function serialiseSteps(sessionKey, steps) {
+	let kept = steps.slice(-50).map(storedStep);
+	let json = JSON.stringify({
+		sessionKey,
+		steps: kept
+	});
+	while (kept.length > 1 && json.length > STEP_BYTE_LIMIT) {
+		kept = kept.slice(1);
+		json = JSON.stringify({
+			sessionKey,
+			steps: kept
+		});
+	}
+	return json;
+}
+function writeStoredSteps(scope, sessionKey, steps) {
+	try {
+		const storage = windowSessionStorage();
+		if (!storage) return;
+		if (!sessionKey || steps.length === 0) {
+			storage.removeItem(stepsStorageKey(scope));
+			return;
+		}
+		storage.setItem(stepsStorageKey(scope), serialiseSteps(sessionKey, steps));
+	} catch {}
+}
+function generateId() {
+	return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function isToolRelatedMessage(msg) {
+	const role = typeof msg.role === "string" ? msg.role.toLowerCase() : "";
+	if (role === "tool" || role === "toolresult" || role === "tool_result") return true;
+	const content = msg.content;
+	if (Array.isArray(content) && content.length > 0) {
+		const toolTypes = /* @__PURE__ */ new Set([
+			"tool_use",
+			"tool_call",
+			"tool_result",
+			"toolresult",
+			"server_tool_use"
+		]);
+		const hasText = content.some((c) => c.type === "text" || c.type === "thinking");
+		if (content.some((c) => toolTypes.has(c.type)) && !hasText) return true;
+	}
+	return false;
+}
+/**
+* Strip `System: [timestamp] …` lines and `[System Message]` prefixes the
+* runtime prepends to a user turn as agent context. They are not user text.
+*/
+function stripSystemPrefixes(text) {
+	return text.split("\n").filter((line) => !/^System:\s*\[/.test(line) && !line.startsWith("[System Message]")).join("\n").replace(/^\n+/, "");
+}
+/** Lift `<thinking>…</thinking>` out of plain text. */
+function separateThinking(text) {
+	const match = text.match(/<thinking>([\s\S]*?)<\/thinking>/);
+	if (!match?.[1]) return { mainText: text };
+	const thinkingText = match[1].trim();
+	const mainText = text.replace(/<thinking>[\s\S]*?<\/thinking>\s*/, "").trim();
+	return {
+		...thinkingText ? { thinkingText } : {},
+		mainText
+	};
+}
+function parseOneHistoryMessage(raw) {
+	const msg = raw;
+	const content = msg.content;
+	let text = Array.isArray(content) ? content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("") : typeof msg.content === "string" ? msg.content : typeof msg.text === "string" ? msg.text : "";
+	const isToolMessage = isToolRelatedMessage(msg);
+	const role = msg.role === "user" ? "user" : "assistant";
+	if (role === "user") text = stripSystemPrefixes(text);
+	let thinkingText = "";
+	if (typeof msg.thinking === "string" && msg.thinking.trim()) thinkingText = msg.thinking.trim();
+	else if (Array.isArray(content)) thinkingText = content.filter((c) => c.type === "thinking").map((c) => c.thinking ?? c.text ?? "").filter(Boolean).join("\n\n");
+	if (!thinkingText) {
+		const { thinkingText: tagThinking, mainText } = separateThinking(text);
+		if (tagThinking) return {
+			id: typeof msg.id === "string" ? msg.id : generateId(),
+			role,
+			text: mainText,
+			timestamp: msg.timestamp ?? Date.now(),
+			thinkingText: tagThinking,
+			...isToolMessage ? { isToolMessage } : {}
+		};
+	}
+	return {
+		id: typeof msg.id === "string" ? msg.id : generateId(),
+		role,
+		text,
+		timestamp: msg.timestamp ?? Date.now(),
+		...thinkingText ? { thinkingText } : {},
+		...isToolMessage ? { isToolMessage } : {}
+	};
+}
+/**
+* Merge an agent turn — assistant messages plus tool call and result messages —
+* into one visible message. Everything except the final substantive response is
+* folded into the chain of thought. Only a genuine user message breaks the turn.
+*/
+function mergeConsecutiveAssistantMessages(messages) {
+	const result = [];
+	let run = [];
+	const flush = () => {
+		const first = run[0];
+		if (!first) return;
+		if (run.length === 1) {
+			result.push(first);
+			run = [];
+			return;
+		}
+		let visibleIdx = run.length - 1;
+		while (visibleIdx > 0 && !(run[visibleIdx]?.text ?? "").trim()) visibleIdx--;
+		const visible = run[visibleIdx] ?? first;
+		const cot = [];
+		for (let i = 0; i < run.length; i++) {
+			const entry = run[i];
+			if (!entry) continue;
+			if (i === visibleIdx) {
+				if (visible.thinkingText) cot.push(visible.thinkingText);
+				continue;
+			}
+			if (entry.thinkingText) cot.push(entry.thinkingText);
+			if (entry.text.trim()) cot.push(entry.text.trim());
+		}
+		const combined = cot.filter(Boolean).join("\n\n");
+		result.push({
+			...visible,
+			...combined ? { thinkingText: combined } : {}
+		});
+		run = [];
+	};
+	for (const msg of messages) if (msg.role === "user" && !msg.isToolMessage && msg.text.trim().length > 0) {
+		flush();
+		result.push(msg);
+	} else run.push(msg);
+	flush();
+	return result;
+}
+/** Raw transcript records to the messages the list renders. */
+function parseHistoryMessages(raw) {
+	return mergeConsecutiveAssistantMessages(raw.map(parseOneHistoryMessage));
+}
+/**
+* The history shrink guard.
+*
+* A history load must not shrink the session already on screen. The first
+* message of a new chat loads history while the turn is still in flight and the
+* user's message has not been persisted yet; replacing wholesale threw that
+* message away, and the reply survived, so the symptom was a conversation with
+* the answer but not the question.
+*
+* Only the same session, and only against losing messages: a longer or equal
+* history still replaces, so an edit, a deletion made elsewhere and a compaction
+* all land normally.
+*/
+function wouldShrinkHistory(params) {
+	return params.currentSessionKey === params.loadedSessionKey && params.loadedCount < params.currentCount;
+}
+/** A JSON blob a tool or an extension API returned, echoed as a message. */
+function isToolResult(text) {
+	const trimmed = text.trim();
+	if (!(trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}"))) return false;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return typeof parsed === "object" && parsed !== null;
+	} catch {
+		return false;
+	}
+}
+/** Raw skill-file content the model echoed instead of acting on. */
+function isSkillContent(text) {
+	const trimmed = text.trim();
+	return /^name:\s*\S+.*\bdescription:.*\btype:\s*skill\b/i.test(trimmed) || /^---\s*\n[\s\S]*?\btype:\s*skill\b[\s\S]*?\n---/m.test(trimmed);
+}
+/** Runtime diagnostics: token counters, a leaked api-key hint. */
+function isAgentDiagnostics(text) {
+	const trimmed = text.trim();
+	return /Tokens:\s*\d+.*Cache:.*Context:/s.test(trimmed) || /\bapi-key\s+sk-/.test(trimmed);
+}
+/** Tool execution output that leaked into history as its own message. */
+function isToolOutput(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return false;
+	if (/^Tool\s+\S+\s+not found$/i.test(trimmed)) return true;
+	if (trimmed === "(no output)") return true;
+	if (/^total\s+\d+\s+[d-][rwx-]{9}/.test(trimmed)) return true;
+	if (/^[d-][rwx-]{9}[@+]?\s+\d+\s+\S+\s+\S+/.test(trimmed)) return true;
+	if (/(?:^|\n)[A-Z_]{2,}=\S/m.test(trimmed)) {
+		if (/\b(?:PATH|PWD|HOME|USER|INIT_CWD|PNPM_|NODE_|npm_|CORTENA_|CORTENACORE_|CORTENABOT_)/m.test(trimmed)) return true;
+		if ((trimmed.match(/(?:^|\n)[A-Z_]{3,}=\S/gm) ?? []).length >= 3) return true;
+	}
+	return false;
+}
+/**
+* Should this message be hidden?
+*
+* The same chain cortenaweb's bubble applies, in the same order. It exists
+* because tool plumbing leaks into a transcript in several recognisable shapes,
+* and a chat that renders them reads as broken. Tool detail is not lost: it is
+* in the tool strip and in the chain of thought.
+*
+* A reply that is only UI the agent drew has no text at all, so an A2UI block
+* counts as content — without that, the surface the user asked for is filtered
+* away and nothing appears.
+*/
+function isHiddenMessage(message) {
+	if (message.isError) return false;
+	if (message.isToolMessage) return true;
+	if (message.role === "assistant" && !message.text.trim() && !message.thinkingText && !message.a2ui?.length) return true;
+	if (message.role === "user") return !message.text.trim() && !message.attachments?.length;
+	const text = message.text;
+	return isToolResult(text) || isSkillContent(text) || isAgentDiagnostics(text) || isToolOutput(text);
+}
+//#endregion
+export { STEP_LIMIT, isHiddenMessage, isProvisionalSessionKey, isSessionOfAgent, mintSessionKey, parseHistoryMessages, readStoredSessionKey, readStoredSteps, separateThinking, serialiseSteps, sessionStorageKey, stepsStorageKey, viewStorageKey, windowSessionStorage, wouldShrinkHistory, writeStoredSessionKey, writeStoredSteps };
+
+//# sourceMappingURL=session.js.map

package/dist/agent-chat/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":[],"sources":["../../src/agent-chat/session.ts"],"sourcesContent":["/**\n * Sessions, history and the filter chain.\n *\n * Ported from `cortena-shared/src/stores/use-chat.ts` and\n * `cortenaweb/components/chat/message-bubble.tsx` (Cortena monorepo).\n * `cortena-shared` is not published, so the rules the two transports share\n * live here; keep them in step.\n *\n * The one deliberate difference is where the current session key is kept.\n * cortenaweb puts it in `localStorage`, which is shared by every tab of an\n * origin, so a second window adopted the first window's session: it inherited\n * a stream that was not its own and both windows then showed the same content.\n * Sessions here are **per window** — the key lives in `sessionStorage`, under a\n * name scoped to the extension — so opening the extension twice starts two\n * sessions. Both stay listed and either window can resume either one; two\n * windows on one session may both send, and cortenacore serialises the runs.\n */\n\nimport { truncate } from \"./step-label\";\nimport type { AgentChatMessage, AgentChatStep } from \"./types\";\n\n/* ── minting and remembering a key ───────────────────────────────────────── */\n\n/**\n * A new session key, minted client-side.\n *\n * `agent:<agentId>:new-<Date.now()>-<random36>`. cortenacore reads the\n * `agent:<id>:` prefix to bind the session to that agent's template, and the\n * key is the AG-UI `threadId` verbatim, prefix included. Minting it rather than\n * asking for one is what lets the first message go out immediately.\n */\nexport function mintSessionKey(agentId: string): string {\n  return `agent:${agentId}:new-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;\n}\n\n/** Was this key minted locally for a chat that had no session yet? */\nexport function isProvisionalSessionKey(key: string): boolean {\n  return /(^|:)new-\\d+-[a-z0-9]+$/.test(key);\n}\n\n/** Does this session belong to this agent? `sessions.list` is filtered by it. */\nexport function isSessionOfAgent(key: string, agentId: string): boolean {\n  return key.startsWith(`agent:${agentId}:`);\n}\n\n/** The `sessionStorage` name the current key is kept under, per extension. */\nexport function sessionStorageKey(scope: string): string {\n  return `cortena.agent-chat.${scope}.session`;\n}\n\n/** The `sessionStorage` name the open/collapsed state is kept under. */\nexport function viewStorageKey(scope: string): string {\n  return `cortena.agent-chat.${scope}.view`;\n}\n\n/** The `sessionStorage` name this window's progress steps are kept under. */\nexport function stepsStorageKey(scope: string): string {\n  return `cortena.agent-chat.${scope}.steps`;\n}\n\n/**\n * `sessionStorage`, or nothing.\n *\n * Absent during SSR and refused outright when a browser blocks storage for the\n * origin, and neither is a reason for the chat not to work: without it a window\n * simply forgets its session on reload.\n */\nexport function windowSessionStorage(): Storage | null {\n  try {\n    return typeof window === \"undefined\" ? null : window.sessionStorage;\n  } catch {\n    return null;\n  }\n}\n\nexport function readStoredSessionKey(scope: string): string | null {\n  try {\n    return windowSessionStorage()?.getItem(sessionStorageKey(scope)) ?? null;\n  } catch {\n    return null;\n  }\n}\n\nexport function writeStoredSessionKey(scope: string, key: string | null): void {\n  try {\n    const storage = windowSessionStorage();\n    if (!storage) {\n      return;\n    }\n    if (key === null) {\n      storage.removeItem(sessionStorageKey(scope));\n    } else {\n      storage.setItem(sessionStorageKey(scope), key);\n    }\n  } catch {\n    // A blocked storage is not a reason to lose the run in flight.\n  }\n}\n\n/* ── the progress steps of the turn ──────────────────────────────────────── */\n\n/** Most steps kept, in memory and in `sessionStorage`. A turn that long is a runaway loop. */\nexport const STEP_LIMIT = 50;\n\n/**\n * Most bytes the steps slot may occupy.\n *\n * `sessionStorage` is a few megabytes for the whole origin, shared with\n * everything else the host keeps there, and a step count alone does not bound\n * the size: fifty steps whose labels are all near the limit, with a failure\n * message on each, is a slot nobody budgeted for. Over the cap the OLDEST are\n * dropped, one at a time, because the recent ones are the ones a reload has to\n * bring back.\n */\nconst STEP_BYTE_LIMIT = 64 * 1024;\n\n/** Longest tool call id or tool name kept, in storage and on `data-tool`. */\nexport const STORED_TEXT_LIMIT = 80;\n\n/**\n * The steps of the current turn, and the session they belong to.\n *\n * They go in the per-window store beside the session key, for the same reason\n * the key does: a tab is reloaded mid-run, or a host remounts the surface on a\n * route change, and both threw the whole strip away. (Collapsing the pop-up is\n * NOT one of them — the panel is `hidden`, not unmounted, and the run streams\n * into it either way.) Messages come back from `chat.history`; steps do not\n * exist on the server, so this is the only place they can come back from.\n *\n * Scoped to a session key, and checked on read: resuming a different session\n * must not inherit the last one's steps.\n */\nexport function readStoredSteps(scope: string, sessionKey: string): AgentChatStep[] {\n  try {\n    const raw = windowSessionStorage()?.getItem(stepsStorageKey(scope));\n    if (!raw) {\n      return [];\n    }\n    const parsed = JSON.parse(raw) as { sessionKey?: unknown; steps?: unknown };\n    if (parsed?.sessionKey !== sessionKey || !Array.isArray(parsed.steps)) {\n      return [];\n    }\n    return (parsed.steps as AgentChatStep[])\n      .filter((step) => typeof step?.id === \"string\" && typeof step?.label === \"string\")\n      .map(restoreStep)\n      .slice(-STEP_LIMIT);\n  } catch {\n    // Storage refused, or somebody else wrote the slot. Neither is worth a\n    // broken chat; the strip simply starts empty.\n    return [];\n  }\n}\n\n/** Every status a step may legitimately come back with. */\nconst STEP_STATUSES: ReadonlySet<string> = new Set([\n  \"running\",\n  \"done\",\n  \"error\",\n  \"stopped\",\n  \"paused\",\n]);\n\n/**\n * A step as it comes back from storage.\n *\n * The important cases are `running` and `paused`. Neither is true any more:\n * the run that owned the call ended when the surface went away — a reload, a\n * remount on a route change; a collapsed pop-up only HIDES the strip and never\n * reaches this path — and no result will arrive for it now, so a restored\n * spinner spins until the user gives up and reloads again, which restores it.\n *\n * It comes back `stopped`, with no message. Neutral is the honest reading:\n * nothing failed, the work simply did not continue, and \"Interrupted.\" drawn in\n * the failure colour told the user their call had broken when the page had.\n *\n * An unrecognised status is treated the same way. Nothing else writes this\n * slot today, but it is per-origin `sessionStorage` and this is the only place\n * that decides what a strip is allowed to render.\n */\nfunction restoreStep(step: AgentChatStep): AgentChatStep {\n  const known = STEP_STATUSES.has(step.status);\n  if (known && step.status !== \"running\" && step.status !== \"paused\") {\n    return step;\n  }\n  const restored: AgentChatStep = {\n    ...step,\n    status: \"stopped\",\n    endedAt: step.endedAt ?? Date.now(),\n  };\n  delete restored.errorMessage;\n  return restored;\n}\n\n/**\n * The fields of a step that are safe to keep, and the only ones kept.\n *\n * `args` is deliberately absent. A tool call's arguments are the user's data —\n * what they searched for, whose record they opened, the body of what they\n * wrote — and `sessionStorage` is readable by every script on the origin,\n * survives the run, and is the sort of thing that ends up in a support bundle.\n * Nothing on screen needs them after the run: the LABEL is already derived\n * from them, and the label is what a restored strip shows.\n */\nfunction storedStep(step: AgentChatStep): AgentChatStep {\n  return {\n    // Bounded, both of them. Neither is written by this package: the id is the\n    // producer's `toolCallId` and the name is whatever the model called, so a\n    // single call carrying 9 kB of either filled the byte cap on its own and\n    // pushed every real step out of the slot.\n    id: truncate(step.id, STORED_TEXT_LIMIT),\n    toolName: truncate(step.toolName, STORED_TEXT_LIMIT),\n    label: step.label,\n    status: step.status,\n    startedAt: step.startedAt,\n    ...(step.endedAt === undefined ? {} : { endedAt: step.endedAt }),\n    ...(step.errorMessage === undefined ? {} : { errorMessage: step.errorMessage }),\n  };\n}\n\n/** The slot's contents, projected and trimmed to fit the byte cap. */\nexport function serialiseSteps(sessionKey: string, steps: readonly AgentChatStep[]): string {\n  let kept = steps.slice(-STEP_LIMIT).map(storedStep);\n  let json = JSON.stringify({ sessionKey, steps: kept });\n  while (kept.length > 1 && json.length > STEP_BYTE_LIMIT) {\n    kept = kept.slice(1);\n    json = JSON.stringify({ sessionKey, steps: kept });\n  }\n  return json;\n}\n\nexport function writeStoredSteps(\n  scope: string,\n  sessionKey: string | null,\n  steps: readonly AgentChatStep[],\n): void {\n  try {\n    const storage = windowSessionStorage();\n    if (!storage) {\n      return;\n    }\n    if (!sessionKey || steps.length === 0) {\n      storage.removeItem(stepsStorageKey(scope));\n      return;\n    }\n    storage.setItem(stepsStorageKey(scope), serialiseSteps(sessionKey, steps));\n  } catch {\n    // Blocked, or over quota. The run in flight is not worth losing over it.\n  }\n}\n\n/* ── history ─────────────────────────────────────────────────────────────── */\n\nfunction generateId(): string {\n  return `msg-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;\n}\n\nfunction isToolRelatedMessage(msg: Record<string, unknown>): boolean {\n  const role = typeof msg.role === \"string\" ? msg.role.toLowerCase() : \"\";\n  if (role === \"tool\" || role === \"toolresult\" || role === \"tool_result\") {\n    return true;\n  }\n  const content = msg.content as Array<{ type: string }> | undefined;\n  if (Array.isArray(content) && content.length > 0) {\n    const toolTypes = new Set([\n      \"tool_use\",\n      \"tool_call\",\n      \"tool_result\",\n      \"toolresult\",\n      \"server_tool_use\",\n    ]);\n    const hasText = content.some((c) => c.type === \"text\" || c.type === \"thinking\");\n    const hasToolBlocks = content.some((c) => toolTypes.has(c.type));\n    if (hasToolBlocks && !hasText) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Strip `System: [timestamp] …` lines and `[System Message]` prefixes the\n * runtime prepends to a user turn as agent context. They are not user text.\n */\nfunction stripSystemPrefixes(text: string): string {\n  return text\n    .split(\"\\n\")\n    .filter((line) => !/^System:\\s*\\[/.test(line) && !line.startsWith(\"[System Message]\"))\n    .join(\"\\n\")\n    .replace(/^\\n+/, \"\");\n}\n\n/** Lift `<thinking>…</thinking>` out of plain text. */\nexport function separateThinking(text: string): { thinkingText?: string; mainText: string } {\n  const match = text.match(/<thinking>([\\s\\S]*?)<\\/thinking>/);\n  if (!match?.[1]) {\n    return { mainText: text };\n  }\n  const thinkingText = match[1].trim();\n  const mainText = text.replace(/<thinking>[\\s\\S]*?<\\/thinking>\\s*/, \"\").trim();\n  return { ...(thinkingText ? { thinkingText } : {}), mainText };\n}\n\nfunction parseOneHistoryMessage(raw: unknown): AgentChatMessage {\n  const msg = raw as Record<string, unknown>;\n  const content = msg.content as\n    | Array<{ type: string; text?: string; thinking?: string; a2ui?: unknown }>\n    | undefined;\n  let text = Array.isArray(content)\n    ? content\n        .filter((c) => c.type === \"text\" && c.text)\n        .map((c) => c.text!)\n        .join(\"\")\n    : typeof msg.content === \"string\"\n      ? msg.content\n      : typeof msg.text === \"string\"\n        ? msg.text\n        : \"\";\n\n  const isToolMessage = isToolRelatedMessage(msg);\n  const role = ((msg.role as string) === \"user\" ? \"user\" : \"assistant\") as \"user\" | \"assistant\";\n  if (role === \"user\") {\n    text = stripSystemPrefixes(text);\n  }\n\n  let thinkingText = \"\";\n  if (typeof msg.thinking === \"string\" && msg.thinking.trim()) {\n    thinkingText = msg.thinking.trim();\n  } else if (Array.isArray(content)) {\n    thinkingText = content\n      .filter((c) => c.type === \"thinking\")\n      .map((c) => c.thinking ?? c.text ?? \"\")\n      .filter(Boolean)\n      .join(\"\\n\\n\");\n  }\n  if (!thinkingText) {\n    const { thinkingText: tagThinking, mainText } = separateThinking(text);\n    if (tagThinking) {\n      return {\n        id: typeof msg.id === \"string\" ? msg.id : generateId(),\n        role,\n        text: mainText,\n        timestamp: (msg.timestamp as number) ?? Date.now(),\n        thinkingText: tagThinking,\n        ...(isToolMessage ? { isToolMessage } : {}),\n      };\n    }\n  }\n\n  return {\n    id: typeof msg.id === \"string\" ? msg.id : generateId(),\n    role,\n    text,\n    timestamp: (msg.timestamp as number) ?? Date.now(),\n    ...(thinkingText ? { thinkingText } : {}),\n    ...(isToolMessage ? { isToolMessage } : {}),\n  };\n}\n\n/**\n * Merge an agent turn — assistant messages plus tool call and result messages —\n * into one visible message. Everything except the final substantive response is\n * folded into the chain of thought. Only a genuine user message breaks the turn.\n */\nfunction mergeConsecutiveAssistantMessages(messages: AgentChatMessage[]): AgentChatMessage[] {\n  const result: AgentChatMessage[] = [];\n  let run: AgentChatMessage[] = [];\n\n  const flush = () => {\n    const first = run[0];\n    if (!first) {\n      return;\n    }\n    if (run.length === 1) {\n      result.push(first);\n      run = [];\n      return;\n    }\n    let visibleIdx = run.length - 1;\n    while (visibleIdx > 0 && !(run[visibleIdx]?.text ?? \"\").trim()) {\n      visibleIdx--;\n    }\n    const visible = run[visibleIdx] ?? first;\n    const cot: string[] = [];\n    for (let i = 0; i < run.length; i++) {\n      const entry = run[i];\n      if (!entry) {\n        continue;\n      }\n      if (i === visibleIdx) {\n        if (visible.thinkingText) {\n          cot.push(visible.thinkingText);\n        }\n        continue;\n      }\n      if (entry.thinkingText) {\n        cot.push(entry.thinkingText);\n      }\n      if (entry.text.trim()) {\n        cot.push(entry.text.trim());\n      }\n    }\n    const combined = cot.filter(Boolean).join(\"\\n\\n\");\n    result.push({ ...visible, ...(combined ? { thinkingText: combined } : {}) });\n    run = [];\n  };\n\n  for (const msg of messages) {\n    const isRealUser = msg.role === \"user\" && !msg.isToolMessage && msg.text.trim().length > 0;\n    if (isRealUser) {\n      flush();\n      result.push(msg);\n    } else {\n      run.push(msg);\n    }\n  }\n  flush();\n  return result;\n}\n\n/** Raw transcript records to the messages the list renders. */\nexport function parseHistoryMessages(raw: readonly unknown[]): AgentChatMessage[] {\n  return mergeConsecutiveAssistantMessages(raw.map(parseOneHistoryMessage));\n}\n\n/**\n * The history shrink guard.\n *\n * A history load must not shrink the session already on screen. The first\n * message of a new chat loads history while the turn is still in flight and the\n * user's message has not been persisted yet; replacing wholesale threw that\n * message away, and the reply survived, so the symptom was a conversation with\n * the answer but not the question.\n *\n * Only the same session, and only against losing messages: a longer or equal\n * history still replaces, so an edit, a deletion made elsewhere and a compaction\n * all land normally.\n */\nexport function wouldShrinkHistory(params: {\n  currentSessionKey: string | null;\n  loadedSessionKey: string;\n  currentCount: number;\n  loadedCount: number;\n}): boolean {\n  return (\n    params.currentSessionKey === params.loadedSessionKey &&\n    params.loadedCount < params.currentCount\n  );\n}\n\n/* ── the filter chain ────────────────────────────────────────────────────── */\n\n/** A JSON blob a tool or an extension API returned, echoed as a message. */\nfunction isToolResult(text: string): boolean {\n  const trimmed = text.trim();\n  const wrapped =\n    (trimmed.startsWith(\"[\") && trimmed.endsWith(\"]\")) ||\n    (trimmed.startsWith(\"{\") && trimmed.endsWith(\"}\"));\n  if (!wrapped) {\n    return false;\n  }\n  try {\n    const parsed = JSON.parse(trimmed);\n    return typeof parsed === \"object\" && parsed !== null;\n  } catch {\n    return false;\n  }\n}\n\n/** Raw skill-file content the model echoed instead of acting on. */\nfunction isSkillContent(text: string): boolean {\n  const trimmed = text.trim();\n  return (\n    /^name:\\s*\\S+.*\\bdescription:.*\\btype:\\s*skill\\b/i.test(trimmed) ||\n    /^---\\s*\\n[\\s\\S]*?\\btype:\\s*skill\\b[\\s\\S]*?\\n---/m.test(trimmed)\n  );\n}\n\n/** Runtime diagnostics: token counters, a leaked api-key hint. */\nfunction isAgentDiagnostics(text: string): boolean {\n  const trimmed = text.trim();\n  return /Tokens:\\s*\\d+.*Cache:.*Context:/s.test(trimmed) || /\\bapi-key\\s+sk-/.test(trimmed);\n}\n\n/** Tool execution output that leaked into history as its own message. */\nfunction isToolOutput(text: string): boolean {\n  const trimmed = text.trim();\n  if (!trimmed) {\n    return false;\n  }\n  if (/^Tool\\s+\\S+\\s+not found$/i.test(trimmed)) {\n    return true;\n  }\n  if (trimmed === \"(no output)\") {\n    return true;\n  }\n  if (/^total\\s+\\d+\\s+[d-][rwx-]{9}/.test(trimmed)) {\n    return true;\n  }\n  if (/^[d-][rwx-]{9}[@+]?\\s+\\d+\\s+\\S+\\s+\\S+/.test(trimmed)) {\n    return true;\n  }\n  if (/(?:^|\\n)[A-Z_]{2,}=\\S/m.test(trimmed)) {\n    if (\n      /\\b(?:PATH|PWD|HOME|USER|INIT_CWD|PNPM_|NODE_|npm_|CORTENA_|CORTENACORE_|CORTENABOT_)/m.test(\n        trimmed,\n      )\n    ) {\n      return true;\n    }\n    if ((trimmed.match(/(?:^|\\n)[A-Z_]{3,}=\\S/gm) ?? []).length >= 3) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Should this message be hidden?\n *\n * The same chain cortenaweb's bubble applies, in the same order. It exists\n * because tool plumbing leaks into a transcript in several recognisable shapes,\n * and a chat that renders them reads as broken. Tool detail is not lost: it is\n * in the tool strip and in the chain of thought.\n *\n * A reply that is only UI the agent drew has no text at all, so an A2UI block\n * counts as content — without that, the surface the user asked for is filtered\n * away and nothing appears.\n */\nexport function isHiddenMessage(message: AgentChatMessage): boolean {\n  if (message.isError) {\n    return false;\n  }\n  if (message.isToolMessage) {\n    return true;\n  }\n  if (\n    message.role === \"assistant\" &&\n    !message.text.trim() &&\n    !message.thinkingText &&\n    !message.a2ui?.length\n  ) {\n    return true;\n  }\n  if (message.role === \"user\") {\n    return !message.text.trim() && !message.attachments?.length;\n  }\n  const text = message.text;\n  return isToolResult(text) || isSkillContent(text) || isAgentDiagnostics(text) || isToolOutput(text);\n}\n"],"mappings":"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"}

package/dist/agent-chat/step-label.d.ts

@@ -0,0 +1,99 @@
+"use client";
+//#region src/agent-chat/step-label.d.ts
+/**
+ * The wording map: one plain sentence per tool call (SKILLS-9).
+ *
+ * A run is a sequence of tool calls, and what the user sees of it today is a
+ * tool name and a JSON blob. `engram_describe {"id":"tasks.task.list"}` is an
+ * accurate description of nothing anybody asked for. This module turns the
+ * three native tools — `engram_search`, `engram_describe`, `broker_invoke` —
+ * into sentences a person can read while they wait.
+ *
+ * It is a pure function of the tool name and the arguments, in its own module,
+ * for two reasons. It is the part most likely to be edited by someone who is
+ * not editing the store, and it is the part worth testing exhaustively: the
+ * store's job is start/end pairing, and the wording's job is being readable.
+ *
+ * Deliberately NOT here: anything that needs the result. The client cannot know
+ * whether a `broker_invoke` is a read or a write before the reply comes back —
+ * only the catalogue knows, and the model only carries `confirmed` once the
+ * user has said yes — so an unconfirmed invoke is worded "Fetching …", which is
+ * true of a read and harmless of a write that has not happened yet. The one
+ * result-dependent wording, a 409 `confirmation_required`, is
+ * `confirmationRequiredLabel` and the store applies it when the envelope
+ * arrives.
+ */
+/**
+ * Which end of the step the label is for.
+ *
+ * Nearly every sentence reads the same either way, because it describes the
+ * step rather than claiming an outcome — "Reading skill: alerts" is as true of
+ * a finished read as of one in flight, and rewriting it on completion makes the
+ * strip jump under the reader's eye for no gain. The exception is the confirmed
+ * write, where "Doing: tasks task create" and "Done: tasks task create" are
+ * genuinely different facts and the user needs the second one.
+ */
+export type AgentStepPhase = "running" | "done";
+/**
+ * An id as words: `tasks.task.list` -> "tasks task list".
+ *
+ * Deterministic and dumb on purpose. A cleverer mapping — reordering to "list
+ * tasks", pluralising, looking up a display name — needs a table that has to be
+ * maintained for every capability in every extension, and a table that is one
+ * release out of date reads worse than the id did.
+ */
+export declare function humaniseId(id: string): string;
+/**
+ * One line of it, sanitised and bounded, with the ellipsis inside the limit.
+ *
+ * Everything interpolated into a label goes through this, including the ones
+ * that look safe: a tool name, an operation id, a server's `message`. All three
+ * arrive from outside — a catalogue entry, a broker reply — and none is worth
+ * trusting with the length of a line or with the direction of it. Control and
+ * format characters are stripped BEFORE the length check, so a run of
+ * invisibles cannot eat the budget and a U+202E cannot flip the rest of the
+ * strip right-to-left. Newlines have already become spaces by then, so the
+ * strip does not silently join two words.
+ */
+export declare function truncate(text: string, limit?: number): string;
+/**
+ * The line for a call nothing better can be said about yet.
+ *
+ * Its own function because two other places have to RECOGNISE it: the store
+ * re-words a step that finished on this line if its arguments turn up late, and
+ * the strip holds it out of the live region rather than announcing
+ * "Working: broker_invoke" to a screen reader a moment before the real sentence
+ * replaces it.
+ */
+export declare function genericLabel(toolName: string): string;
+/** Is this label the fallback rather than something the arguments produced? */
+export declare function isGenericLabel(toolName: string, label: string): boolean;
+/**
+ * The line shown for one tool call.
+ *
+ * | tool | label |
+ * | --- | --- |
+ * | `engram_search` | Looking for a way to \<intent\> |
+ * | `engram_describe`, `skill.*` | Reading skill: \<title, or the topic\> |
+ * | `engram_describe`, anything else | Checking how to \<id as words\> |
+ * | `broker_invoke`, `confirmed: true` | Doing: \<operation\> / Done: \<operation\> |
+ * | `broker_invoke`, otherwise | Fetching \<operation\> |
+ * | anything else | Working: \<tool name\> |
+ *
+ * The key argument missing falls through to the last row rather than inventing
+ * a sentence about nothing: arguments arrive in a second event
+ * (`TOOL_CALL_ARGS`), so "no arguments yet" is a state every call passes
+ * through, and the generic line is what it should read as until they land.
+ */
+export declare function stepLabel(toolName: string, args: Record<string, unknown> | undefined, phase: AgentStepPhase): string;
+/**
+ * The label for a call the broker refused pending a yes.
+ *
+ * A 409 `confirmation_required` is not a failure — it is the broker doing its
+ * job on a write the user has not approved — so the step keeps its tick and
+ * changes its words. Drawn as an error it reads as "the agent broke"; drawn as
+ * "Fetching …", completed, it reads as though the write went through.
+ */
+export declare function confirmationRequiredLabel(args: Record<string, unknown> | undefined): string;
+//#endregion
+//# sourceMappingURL=step-label.d.ts.map

package/dist/agent-chat/step-label.js

@@ -0,0 +1,116 @@
+"use client";
+//#region src/agent-chat/step-label.ts
+/** Longest intent or title carried into a label, ellipsis included. */
+const TEXT_LIMIT = 80;
+/**
+* An id as words: `tasks.task.list` -> "tasks task list".
+*
+* Deterministic and dumb on purpose. A cleverer mapping — reordering to "list
+* tasks", pluralising, looking up a display name — needs a table that has to be
+* maintained for every capability in every extension, and a table that is one
+* release out of date reads worse than the id did.
+*/
+function humaniseId(id) {
+	return id.split(/[.\-_]+/).filter(Boolean).join(" ").toLowerCase();
+}
+/** The topic of a skill id: `skill.platform.using-extensions` -> "using extensions". */
+function skillTopic(id) {
+	const parts = id.split(".").filter(Boolean);
+	const last = parts[parts.length - 1];
+	return last ? humaniseId(last) : humaniseId(id);
+}
+/**
+* One line of it, sanitised and bounded, with the ellipsis inside the limit.
+*
+* Everything interpolated into a label goes through this, including the ones
+* that look safe: a tool name, an operation id, a server's `message`. All three
+* arrive from outside — a catalogue entry, a broker reply — and none is worth
+* trusting with the length of a line or with the direction of it. Control and
+* format characters are stripped BEFORE the length check, so a run of
+* invisibles cannot eat the budget and a U+202E cannot flip the rest of the
+* strip right-to-left. Newlines have already become spaces by then, so the
+* strip does not silently join two words.
+*/
+function truncate(text, limit = TEXT_LIMIT) {
+	const collapsed = text.replace(/\s+/g, " ").trim().replace(/[\p{Cf}\p{Cc}]/gu, "");
+	return collapsed.length <= limit ? collapsed : `${collapsed.slice(0, limit - 1)}…`;
+}
+/**
+* The line for a call nothing better can be said about yet.
+*
+* Its own function because two other places have to RECOGNISE it: the store
+* re-words a step that finished on this line if its arguments turn up late, and
+* the strip holds it out of the live region rather than announcing
+* "Working: broker_invoke" to a screen reader a moment before the real sentence
+* replaces it.
+*/
+function genericLabel(toolName) {
+	return `Working: ${truncate(toolName)}`;
+}
+/** Is this label the fallback rather than something the arguments produced? */
+function isGenericLabel(toolName, label) {
+	return label === genericLabel(toolName);
+}
+function readString(args, key) {
+	const value = args?.[key];
+	return typeof value === "string" && value.trim() ? value : "";
+}
+/**
+* The line shown for one tool call.
+*
+* | tool | label |
+* | --- | --- |
+* | `engram_search` | Looking for a way to \<intent\> |
+* | `engram_describe`, `skill.*` | Reading skill: \<title, or the topic\> |
+* | `engram_describe`, anything else | Checking how to \<id as words\> |
+* | `broker_invoke`, `confirmed: true` | Doing: \<operation\> / Done: \<operation\> |
+* | `broker_invoke`, otherwise | Fetching \<operation\> |
+* | anything else | Working: \<tool name\> |
+*
+* The key argument missing falls through to the last row rather than inventing
+* a sentence about nothing: arguments arrive in a second event
+* (`TOOL_CALL_ARGS`), so "no arguments yet" is a state every call passes
+* through, and the generic line is what it should read as until they land.
+*/
+function stepLabel(toolName, args, phase) {
+	switch (toolName) {
+		case "engram_search": {
+			const intent = readString(args, "intent");
+			if (intent) return `Looking for a way to ${truncate(intent)}`;
+			break;
+		}
+		case "engram_describe": {
+			const id = readString(args, "id");
+			if (!id) break;
+			if (id.startsWith("skill.")) {
+				const title = readString(args, "title");
+				return `Reading skill: ${truncate(title ? title : skillTopic(id))}`;
+			}
+			return `Checking how to ${truncate(humaniseId(id))}`;
+		}
+		case "broker_invoke": {
+			const operation = readString(args, "operation");
+			if (!operation) break;
+			const label = truncate(humaniseId(operation));
+			if (args?.confirmed === true) return phase === "done" ? `Done: ${label}` : `Doing: ${label}`;
+			return `Fetching ${label}`;
+		}
+	}
+	return genericLabel(toolName);
+}
+/**
+* The label for a call the broker refused pending a yes.
+*
+* A 409 `confirmation_required` is not a failure — it is the broker doing its
+* job on a write the user has not approved — so the step keeps its tick and
+* changes its words. Drawn as an error it reads as "the agent broke"; drawn as
+* "Fetching …", completed, it reads as though the write went through.
+*/
+function confirmationRequiredLabel(args) {
+	const operation = readString(args, "operation");
+	return `Needs your confirmation: ${operation ? truncate(humaniseId(operation)) : "that action"}`;
+}
+//#endregion
+export { confirmationRequiredLabel, genericLabel, humaniseId, isGenericLabel, stepLabel, truncate };
+
+//# sourceMappingURL=step-label.js.map