@agimon-ai/po-web-dashboard 0.0.0-alpha.0

package/dist/web/lib/sessionModel.cjs

@@ -0,0 +1,970 @@
+const require_commands = require("./commands.cjs");
+const require_hub = require("../../types/hub.cjs");
+const require_notification = require("../../types/notification.cjs");
+//#region src/web/lib/sessionModel.ts
+const initialSessionState = {
+	hasNewerHistory: false,
+	entries: [],
+	activeTools: [],
+	statuses: {},
+	widgets: [],
+	streaming: false,
+	settled: false,
+	lifecycle: null,
+	stats: null,
+	liveCost: 0,
+	agent: null,
+	commands: [],
+	models: [],
+	fastMode: false,
+	agentLocked: false,
+	thinkingLevels: [],
+	dialog: null,
+	editorTextRequest: null,
+	minorModes: null,
+	context: null,
+	profileIdentity: null,
+	toolsThisRun: 0,
+	restoredIds: [],
+	pendingUserEntries: [],
+	reconciledUserEntries: [],
+	protocolUserEntryIds: {},
+	nextId: 1
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value, fallback = "") {
+	return typeof value === "string" ? value : fallback;
+}
+function asNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** Joins the text blocks of a Pi content array, ignoring non-text parts. */
+function textFromContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((block) => isRecord(block) && block.type === "text" ? asString(block.text) : "").filter(Boolean).join("");
+}
+const SUPPORTED_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+]);
+function isSupportedImageMimeType(mimeType) {
+	return SUPPORTED_IMAGE_MIME_TYPES.has(mimeType);
+}
+/** Keeps only image blocks the cockpit can safely render as data URLs. */
+function imagesFromContent(content) {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => {
+		if (!isRecord(block) || block.type !== "image") return [];
+		const data = asString(block.data);
+		const mimeType = asString(block.mimeType);
+		return data && isSupportedImageMimeType(mimeType) ? [{
+			data,
+			mimeType
+		}] : [];
+	});
+}
+/** A one-line description of a tool call, good enough for a card header. */
+function summariseArgs(args) {
+	if (!isRecord(args)) return "";
+	for (const key of [
+		"command",
+		"file_path",
+		"filePath",
+		"path",
+		"pattern",
+		"query",
+		"url"
+	]) {
+		const value = args[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	const keys = Object.keys(args);
+	return keys.length > 0 ? keys.join(", ") : "";
+}
+function withEntry(state, entry) {
+	return {
+		...state,
+		entries: [...state.entries, entry],
+		nextId: state.nextId + 1
+	};
+}
+function withChronologicalEntry(state, entry) {
+	const timestamp = entry.timestamp;
+	if (timestamp === void 0) return withEntry(state, entry);
+	const index = state.entries.findIndex((existing) => existing.timestamp !== void 0 && existing.timestamp > timestamp);
+	if (index === -1) return withEntry(state, entry);
+	return {
+		...state,
+		entries: [
+			...state.entries.slice(0, index),
+			entry,
+			...state.entries.slice(index)
+		],
+		nextId: state.nextId + 1
+	};
+}
+function replaceEntry(state, id, next) {
+	return {
+		...state,
+		entries: state.entries.map((entry) => entry.id === id ? next : entry)
+	};
+}
+function openAssistant(state) {
+	const last = state.entries[state.entries.length - 1];
+	if (last && last.kind === "assistant" && last.streaming) return {
+		state,
+		entry: last
+	};
+	const entry = {
+		kind: "assistant",
+		id: `a${state.nextId}`,
+		text: "",
+		thinking: "",
+		streaming: true,
+		...state.profileIdentity === null ? {} : { identity: state.profileIdentity }
+	};
+	return {
+		state: withEntry(state, entry),
+		entry
+	};
+}
+function applyAssistantDelta(state, event) {
+	const type = asString(event.type);
+	if (type !== "text_delta" && type !== "thinking_delta" && type !== "text_start" && type !== "thinking_start") return state;
+	const opened = openAssistant(state);
+	const delta = asString(event.delta);
+	if (!delta) return opened.state;
+	const next = type === "thinking_delta" ? {
+		...opened.entry,
+		thinking: opened.entry.thinking + delta
+	} : {
+		...opened.entry,
+		text: opened.entry.text + delta
+	};
+	return replaceEntry(opened.state, opened.entry.id, next);
+}
+function closeAssistant(state, message) {
+	const index = state.entries.findLastIndex((entry) => entry.kind === "assistant" && entry.streaming);
+	if (index === -1) return state;
+	const current = state.entries[index];
+	const content = isRecord(message) ? message.content : void 0;
+	const hasContent = typeof content === "string" || Array.isArray(content);
+	const next = {
+		...current,
+		text: hasContent ? textFromContent(content) : current.text,
+		thinking: hasContent ? thinkingFromContent(Array.isArray(content) ? content.filter(isRecord) : []) : current.thinking,
+		streaming: false
+	};
+	const entries = [...state.entries];
+	if (next.text || next.thinking) entries[index] = next;
+	else entries.splice(index, 1);
+	return {
+		...state,
+		entries
+	};
+}
+function toolEntryFromStart(frame, id) {
+	return {
+		kind: "tool",
+		id,
+		toolCallId: asString(frame.toolCallId),
+		name: asString(frame.toolName, "tool"),
+		args: isRecord(frame.args) ? frame.args : {},
+		argSummary: summariseArgs(frame.args),
+		result: null,
+		output: "",
+		isError: false,
+		running: true
+	};
+}
+function applyToolStart(state, frame) {
+	const closed = closeAssistant(state, void 0);
+	const toolCallId = asString(frame.toolCallId);
+	if (toolCallId !== "" && closed.entries.some((entry) => entry.kind === "tool" && entry.toolCallId === toolCallId)) return {
+		...closed,
+		toolsThisRun: closed.toolsThisRun + 1
+	};
+	const opened = withEntry(closed, toolEntryFromStart(frame, `t${state.nextId}`));
+	return {
+		...opened,
+		toolsThisRun: opened.toolsThisRun + 1
+	};
+}
+/**
+* The result a tool frame carries, kept whole: the text blocks feed the
+* default card, and the content plus details reach the owning plugin's
+* renderer untouched, the way Pi hands them to a TUI renderResult.
+*/
+function toolResult(raw) {
+	if (!isRecord(raw)) return null;
+	return {
+		content: Array.isArray(raw.content) ? raw.content : [],
+		details: raw.details
+	};
+}
+function updateTool(state, toolCallId, patch) {
+	const index = state.entries.findLastIndex((entry) => entry.kind === "tool" && entry.toolCallId === toolCallId);
+	if (index === -1) return state;
+	const entries = [...state.entries];
+	entries[index] = {
+		...entries[index],
+		...patch
+	};
+	return {
+		...state,
+		entries
+	};
+}
+function modelChoice(value) {
+	if (!isRecord(value) || typeof value.id !== "string" || typeof value.provider !== "string") return void 0;
+	return {
+		provider: value.provider,
+		id: value.id,
+		name: asString(value.name, value.id),
+		reasoning: value.reasoning === true
+	};
+}
+function applyResponse(state, frame) {
+	const command = asString(frame.command);
+	if (frame.success === false && command !== "get_state" && command !== "get_session_stats") return withEntry(state, {
+		kind: "notice",
+		id: `n${state.nextId}`,
+		text: asString(frame.error, `The agent refused ${command}.`),
+		tone: "error"
+	});
+	const data = frame.data;
+	if (!isRecord(data)) return state;
+	if (command === "get_state") {
+		const model = isRecord(data.model) ? asString(data.model.id ?? data.model.name, "unknown") : "unknown";
+		const provider = isRecord(data.model) ? asString(data.model.provider) : "";
+		const streaming = state.lifecycle !== null ? state.lifecycle.operation !== null : data.isStreaming === void 0 ? state.streaming : data.isStreaming === true;
+		return {
+			...state,
+			streaming,
+			settled: !streaming,
+			fastMode: data.fastMode === true,
+			agentLocked: data.agentLocked === true,
+			agent: {
+				model,
+				provider,
+				thinkingLevel: asString(data.thinkingLevel, state.agent?.thinkingLevel ?? "unknown"),
+				sessionId: asString(data.sessionId, state.agent?.sessionId ?? ""),
+				sessionName: asString(data.sessionName, state.agent?.sessionName ?? ""),
+				messageCount: asNumber(data.messageCount) ?? state.agent?.messageCount ?? 0,
+				isStreaming: streaming
+			}
+		};
+	}
+	if (command === "navigate_tree" && data.cancelled !== true) {
+		const editorText = asString(data.editorText);
+		return {
+			...state,
+			editorTextRequest: {
+				id: `rewind:${asString(data.leafId, "root")}:${String(state.nextId)}`,
+				text: editorText
+			}
+		};
+	}
+	if (command === "get_available_models") {
+		const models = Array.isArray(data.models) ? data.models.map(modelChoice).filter((m) => m !== void 0) : [];
+		return {
+			...state,
+			models
+		};
+	}
+	if (command === "get_available_thinking_levels") {
+		const levels = Array.isArray(data.levels) ? data.levels.filter((level) => typeof level === "string") : [];
+		return {
+			...state,
+			thinkingLevels: levels
+		};
+	}
+	if (command === "set_model" && state.agent) {
+		const chosen = modelChoice(data);
+		return chosen ? {
+			...state,
+			agent: {
+				...state.agent,
+				model: chosen.id,
+				provider: chosen.provider
+			}
+		} : state;
+	}
+	if (command === "get_session_stats") {
+		const tokens = isRecord(data.tokens) ? asNumber(data.tokens.total) : null;
+		const usage = isRecord(data.contextUsage) ? data.contextUsage : void 0;
+		return {
+			...state,
+			stats: {
+				cost: asNumber(data.cost) ?? 0,
+				totalTokens: tokens ?? 0,
+				contextPercent: usage ? asNumber(usage.percent) : null,
+				contextTokens: usage ? asNumber(usage.tokens) : null,
+				contextWindow: usage ? asNumber(usage.contextWindow) : null
+			},
+			liveCost: 0
+		};
+	}
+	if (command === "get_commands") {
+		const reported = (Array.isArray(data.commands) ? data.commands : []).filter(isRecord).map((entry) => ({
+			name: asString(entry.name),
+			description: asString(entry.description)
+		})).filter((entry) => entry.name.length > 0);
+		const claimed = new Set(reported.map((entry) => entry.name));
+		const commands = [...reported, ...require_commands.BUILTIN_COMMANDS.filter((entry) => !claimed.has(entry.name))];
+		return {
+			...state,
+			commands
+		};
+	}
+	return state;
+}
+/**
+* Folds the streaming message's own cost into the view model.
+*
+* Pi builds `message_update.usage` from the in-progress message's usage, not
+* from a session running total, so this is added to the last figure Pi
+* reported rather than replacing it. Providers that only price a message once
+* it completes report zero here, and the chip then steps at each message
+* instead of streaming, which is the provider's granularity showing through
+* rather than a fault.
+*/
+function applyLiveUsage(state, frame) {
+	if (asString(frame.type) !== "message_update") return state;
+	const usage = isRecord(frame.usage) ? frame.usage : void 0;
+	const cost = usage && isRecord(usage.cost) ? asNumber(usage.cost.total) ?? 0 : 0;
+	if (state.liveCost === cost) return state;
+	return {
+		...state,
+		liveCost: cost
+	};
+}
+function applyStatus(state, frame) {
+	const key = asString(frame.statusKey);
+	if (!key) return state;
+	const text = typeof frame.statusText === "string" ? frame.statusText : "";
+	if (state.statuses[key] === text) return state;
+	return {
+		...state,
+		statuses: {
+			...state.statuses,
+			[key]: text
+		}
+	};
+}
+function applyContextSelection(state, projection) {
+	const selection = projection.selection;
+	if (!selection || !selection.majorMode || !Array.isArray(selection.domains)) return {
+		...state,
+		context: projection
+	};
+	const profile = typeof selection.profile === "string" ? selection.profile : "";
+	const status = [
+		profile ? `*${profile}*` : void 0,
+		`[${selection.majorMode}]`,
+		selection.domains.join(",")
+	].filter(Boolean).join(":");
+	return {
+		...state,
+		context: projection,
+		statuses: {
+			...state.statuses,
+			"doom-major-mode": status,
+			"doom-domain": selection.domains.join(","),
+			"doom-profile": profile
+		}
+	};
+}
+function applyWidget(state, frame) {
+	const key = asString(frame.widgetKey);
+	if (!key) return state;
+	if (!(Array.isArray(frame.widgetLines) && frame.widgetLines.length > 0)) {
+		if (!state.widgets.includes(key)) return state;
+		return {
+			...state,
+			widgets: state.widgets.filter((widget) => widget !== key)
+		};
+	}
+	if (state.widgets.includes(key)) return state;
+	return {
+		...state,
+		widgets: [...state.widgets, key]
+	};
+}
+function applyDialog(state, frame) {
+	const method = asString(frame.method);
+	if (method === "setStatus") return applyStatus(state, frame);
+	if (method === "setWidget") return applyWidget(state, frame);
+	if (method === "append_composer_text") {
+		if (typeof frame.text !== "string") return state;
+		return {
+			...state,
+			editorTextRequest: {
+				id: asString(frame.id),
+				text: frame.text,
+				append: true
+			}
+		};
+	}
+	if (method === "set_editor_text") {
+		if (typeof frame.text !== "string") return state;
+		return {
+			...state,
+			editorTextRequest: {
+				id: asString(frame.id),
+				text: frame.text
+			}
+		};
+	}
+	if (method !== "select" && method !== "confirm" && method !== "input" && method !== "editor") return state;
+	const options = Array.isArray(frame.options) ? frame.options.map((option) => asString(option)).filter(Boolean) : [];
+	return {
+		...state,
+		dialog: {
+			id: asString(frame.id),
+			method,
+			title: asString(frame.title, "The agent needs an answer"),
+			message: asString(frame.message),
+			options,
+			placeholder: asString(frame.placeholder),
+			prefill: asString(frame.prefill)
+		}
+	};
+}
+/** The thinking blocks of a journalled assistant message, joined as one passage. */
+function thinkingFromContent(content) {
+	return content.map((block) => block.type === "thinking" ? asString(block.thinking) : "").filter(Boolean).join("");
+}
+/** Remembers a prompt this page rendered, so the journal's copy of it folds into the same entry. */
+function withPendingUser(state, id, text, images = []) {
+	const pending = {
+		id,
+		text,
+		...images.length > 0 ? { images } : {}
+	};
+	return {
+		...state,
+		pendingUserEntries: [...state.pendingUserEntries, pending]
+	};
+}
+/**
+* Folds a journalled user message into the entry this page already rendered
+* for it, or returns undefined when no such entry exists.
+*
+* A message the cockpit sent is on screen before it reaches the journal, and a
+* queued one is on screen as queued until the run picks it up. Both are the
+* same message the journal later reports, so it settles the entry that stands
+* rather than adding a second copy of the text.
+*
+* A prompt Pi's protocol snapshot already claimed is matched here too. That
+* claim consumed the pending record, so without the second list a journalled
+* copy arriving after the run, which is what happens when transcript
+* ownership falls back to the journal, would read as a new message and be
+* appended below the settled divider.
+*/
+function reconcilePendingUser(state, text, images) {
+	const index = state.pendingUserEntries.findIndex((pending) => pending.text === text);
+	const reconciledIndex = index === -1 ? state.reconciledUserEntries.findIndex((claimed) => claimed.text === text) : -1;
+	if (index === -1 && reconciledIndex === -1) return void 0;
+	const source = index === -1 ? state.reconciledUserEntries : state.pendingUserEntries;
+	const at = index === -1 ? reconciledIndex : index;
+	const pending = source[at];
+	const remaining = index === -1 ? state.reconciledUserEntries : source.filter((_, position) => position !== at);
+	const entries = state.entries.map((entry) => {
+		if (entry.id !== pending.id) return entry;
+		const reconciledImages = images.length > 0 ? images : pending.images;
+		if (entry.kind === "queued") return {
+			kind: "user",
+			id: entry.id,
+			text: entry.text,
+			...reconciledImages ? { images: reconciledImages } : {}
+		};
+		return entry.kind === "user" && images.length > 0 ? {
+			...entry,
+			images
+		} : entry;
+	});
+	return index === -1 ? {
+		...state,
+		entries,
+		reconciledUserEntries: remaining
+	} : {
+		...state,
+		entries,
+		pendingUserEntries: remaining
+	};
+}
+/**
+* Folds one journalled message into the timeline.
+*
+* The journal is the session's own record, so its shape is not the live frame
+* shape: a tool call is a block inside an assistant message (`id`,
+* `arguments`) rather than a tool_execution_start frame, and its result is a
+* message of its own. Mapping them here is what lets a transcript written
+* before this page existed read exactly like one it watched arrive.
+*/
+function applyJournalMessage(state, message, entryId, timestamp) {
+	const role = asString(message.role);
+	const content = typeof message.content === "string" ? [{
+		type: "text",
+		text: message.content
+	}] : Array.isArray(message.content) ? message.content.filter(isRecord) : [];
+	if (role === "user") {
+		const text = textFromContent(content);
+		const images = imagesFromContent(content);
+		if (!text && images.length === 0) return state;
+		return reconcilePendingUser(state, text, images) ?? withEntry(state, {
+			kind: "user",
+			id: entryId ?? `u${state.nextId}`,
+			text,
+			...timestamp === void 0 ? {} : { timestamp },
+			...images.length > 0 ? { images } : {}
+		});
+	}
+	if (role === "assistant") {
+		timestamp ??= asNumber(message.timestamp) ?? void 0;
+		const model = typeof message.model === "string" ? message.model : void 0;
+		const text = textFromContent(content);
+		const thinking = thinkingFromContent(content);
+		const draft = state.entries.findLast((item) => item.kind === "assistant" && item.streaming);
+		if (draft && entryId && !state.entries.some((item) => item.id === entryId)) {
+			state = closeAssistant(state, message);
+			state = {
+				...state,
+				entries: state.entries.map((item) => item.id === draft.id ? {
+					...item,
+					id: entryId,
+					...timestamp === void 0 ? {} : { timestamp },
+					...model === void 0 ? {} : { model }
+				} : item)
+			};
+		}
+		let next = (text || thinking) && !state.entries.some((item) => item.id === entryId) ? withEntry(state, {
+			kind: "assistant",
+			id: entryId ?? `a${state.nextId}`,
+			...timestamp === void 0 ? {} : { timestamp },
+			...model === void 0 ? {} : { model },
+			text,
+			thinking,
+			streaming: false,
+			...state.profileIdentity === null ? {} : { identity: state.profileIdentity }
+		}) : state;
+		for (const block of content) {
+			if (block.type !== "toolCall") continue;
+			if (next.entries.some((item) => item.kind === "tool" && item.toolCallId === asString(block.id))) continue;
+			next = withEntry(next, {
+				kind: "tool",
+				id: entryId ? `tool:${asString(block.id)}` : `t${next.nextId}`,
+				...timestamp === void 0 ? {} : { timestamp },
+				toolCallId: asString(block.id),
+				name: asString(block.name, "tool"),
+				args: isRecord(block.arguments) ? block.arguments : {},
+				argSummary: summariseArgs(block.arguments),
+				result: null,
+				output: "",
+				isError: false,
+				running: true
+			});
+		}
+		return next;
+	}
+	if (role === "toolResult") return updateTool(state, asString(message.toolCallId), {
+		result: {
+			content,
+			details: message.details
+		},
+		output: textFromContent(content),
+		isError: message.isError === true,
+		running: false
+	});
+	return state;
+}
+/**
+* Folds one journal entry, once. Entries without an id are the runtime's own
+* bookkeeping and are left alone; a message already folded is skipped, which
+* is what makes a re-attach idempotent.
+*/
+function applyJournalEntry(state, entry) {
+	if (entry.type !== "message" || !isRecord(entry.message)) return state;
+	const id = asString(entry.id);
+	if (id === "" || state.restoredIds.includes(id)) return state;
+	const next = applyJournalMessage(state, entry.message, id, asNumber(entry.timestamp) ?? void 0);
+	return {
+		...next,
+		restoredIds: [...next.restoredIds, id]
+	};
+}
+/**
+* Records a journal entry the protocol already publishes, without folding it.
+*
+* The hub re-reads the journal at every run boundary and re-publishes user
+* messages, because no live frame carries one. Dropping those copies without a
+* trace left the page with no memory of them, so a copy arriving after protocol
+* ownership lapsed read as a new prompt and landed below the settled divider.
+* Keeping the id is what makes the drop idempotent.
+*/
+function rememberJournalEntry(state, entry) {
+	if (entry.type !== "message" || !isRecord(entry.message)) return state;
+	const id = asString(entry.id);
+	if (id === "" || state.restoredIds.includes(id)) return state;
+	return {
+		...state,
+		restoredIds: [...state.restoredIds, id]
+	};
+}
+/**
+* Folds an older window of transcript above what the page already holds.
+*
+* The reducer is append-only by design: it builds the timeline as the session
+* produces it. Paging backwards is the one case that runs the other way, so
+* the window is reduced on its own and the result is prepended, rather than
+* teaching every case in the reducer about a second direction.
+*
+* Entry ids are positional, so a window reduced from scratch would collide
+* with the live entries. Prefixing by page keeps every key unique and stable
+* across re-renders, which is what a virtualised list needs to keep its
+* measurements.
+*/
+function prependHistory(state, frames, page) {
+	const older = frames.reduce((carried, frame) => reduceSession(carried, frame), initialSessionState);
+	const known = new Set(state.restoredIds);
+	const restored = older.restoredIds.filter((id) => !known.has(id));
+	if (restored.length === 0) return state;
+	const prefix = `h${page}-`;
+	const entries = older.entries.filter((entry) => entry.kind !== "notice").map((entry) => ({
+		...entry,
+		id: `${prefix}${entry.id}`
+	}));
+	return {
+		...state,
+		entries: [...entries, ...state.entries],
+		restoredIds: [...restored, ...state.restoredIds]
+	};
+}
+/**
+* Folds one agent frame into the view model.
+*
+* Pure and total: an unrecognised frame returns the state unchanged, so a Pi
+* protocol addition cannot break the cockpit, it just is not rendered yet.
+*/
+/** Frames whose only product is a timeline entry the protocol now publishes. */
+const TRANSCRIPT_FRAMES = /* @__PURE__ */ new Set([
+	"message_start",
+	"message_update",
+	"message_end",
+	"tool_execution_start",
+	"tool_execution_update",
+	"tool_execution_end"
+]);
+function reduceSession(state, frame, options = {}) {
+	return reduceFrame(applyLiveUsage(state, frame), frame, options);
+}
+function reduceFrame(state, frame, options) {
+	const type = asString(frame.type);
+	if (options.transcriptFromProtocol && TRANSCRIPT_FRAMES.has(type)) {
+		if (type === "tool_execution_start") {
+			const active = toolEntryFromStart(frame, `active:${asString(frame.toolCallId)}`);
+			const activeTools = [...state.activeTools.filter((entry) => entry.toolCallId !== active.toolCallId), active];
+			return {
+				...state,
+				activeTools,
+				toolsThisRun: state.toolsThisRun + 1
+			};
+		}
+		if (type === "tool_execution_end") {
+			const toolCallId = asString(frame.toolCallId);
+			return {
+				...state,
+				activeTools: state.activeTools.filter((entry) => entry.toolCallId !== toolCallId)
+			};
+		}
+		return state;
+	}
+	switch (type) {
+		case "replay": return isRecord(frame.frame) ? reduceSession(state, frame.frame, options) : state;
+		case "agent_start": return {
+			...state,
+			activeTools: [],
+			streaming: state.lifecycle === null ? true : state.lifecycle.operation !== null,
+			settled: false,
+			toolsThisRun: 0
+		};
+		case "message_start":
+		case "message_update": {
+			const event = isRecord(frame.assistantMessageEvent) ? frame.assistantMessageEvent : void 0;
+			const message = isRecord(frame.message) ? frame.message : event?.type === "start" && isRecord(event.partial) ? event.partial : void 0;
+			if (message?.role !== void 0 && message.role !== "assistant") return state;
+			const timestamp = asNumber(message?.timestamp);
+			const model = typeof message?.model === "string" ? message.model : void 0;
+			if (type === "message_start" && timestamp !== null) {
+				const previous = state.entries.findLast((entry) => entry.kind === "assistant" && entry.timestamp !== void 0);
+				if (previous?.kind === "assistant" && previous.timestamp !== void 0) {
+					if (previous.timestamp > timestamp || previous.timestamp === timestamp && (!model || !previous.model || previous.model === model)) return state;
+					if (previous.streaming && previous.timestamp < timestamp) state = closeAssistant(state, void 0);
+				}
+			}
+			if (message && (typeof message.content === "string" || Array.isArray(message.content))) {
+				const opened = openAssistant(state);
+				return replaceEntry(opened.state, opened.entry.id, {
+					...opened.entry,
+					...timestamp === null ? {} : { timestamp },
+					...model === void 0 ? {} : { model },
+					text: textFromContent(message.content),
+					thinking: thinkingFromContent(Array.isArray(message.content) ? message.content.filter(isRecord) : [])
+				});
+			}
+			return isRecord(frame.assistantMessageEvent) ? applyAssistantDelta(state, frame.assistantMessageEvent) : state;
+		}
+		case "message_end": {
+			if (isRecord(frame.message) && frame.message.role !== void 0 && frame.message.role !== "assistant") return state;
+			const id = asString(frame.entryId);
+			if (id && state.entries.some((item) => item.id === id)) return state;
+			const draft = state.entries.findLast((item) => item.kind === "assistant" && item.streaming);
+			const closed = closeAssistant(state, frame.message);
+			if (!id || !draft) return closed;
+			return {
+				...closed,
+				entries: closed.entries.map((item) => item.id === draft.id ? {
+					...item,
+					id
+				} : item)
+			};
+		}
+		case "tool_execution_start": return applyToolStart(state, frame);
+		case "tool_execution_update": return updateTool(state, asString(frame.toolCallId), {
+			result: toolResult(frame.partialResult),
+			output: textFromContent(isRecord(frame.partialResult) ? frame.partialResult.content : void 0)
+		});
+		case "tool_execution_end": return updateTool(state, asString(frame.toolCallId), {
+			result: toolResult(frame.result),
+			output: textFromContent(isRecord(frame.result) ? frame.result.content : void 0),
+			isError: frame.isError === true,
+			running: false
+		});
+		case "agent_settled": {
+			const closed = options.transcriptFromProtocol ? state : closeAssistant(state, void 0);
+			const timestamp = asNumber(frame.timestamp) ?? void 0;
+			const id = typeof frame.runId === "string" ? `settled:${frame.runId}` : `s${closed.nextId}`;
+			return {
+				...closed.entries.some((entry) => entry.id === id) ? closed : withChronologicalEntry(closed, {
+					kind: "settled",
+					id,
+					tools: closed.toolsThisRun,
+					...timestamp === void 0 ? {} : { timestamp }
+				}),
+				activeTools: [],
+				dialog: null,
+				streaming: state.lifecycle === null ? false : state.lifecycle.operation !== null,
+				settled: state.lifecycle === null ? true : state.lifecycle.operation === null
+			};
+		}
+		case "queue_update": {
+			if (state.lifecycle !== null) return state;
+			const steering = Array.isArray(frame.steering) ? frame.steering : [];
+			const followUp = Array.isArray(frame.followUp) ? frame.followUp : [];
+			const queue = [...steering.map((entry) => ({
+				text: asString(entry),
+				delivery: "steer"
+			})), ...followUp.map((entry) => ({
+				text: asString(entry),
+				delivery: "followUp"
+			}))].map((entry, index) => ({
+				kind: "queued",
+				id: `queue-${index}`,
+				...entry
+			})).filter((entry) => entry.text.length > 0);
+			return replaceQueuedEntries(state, queue);
+		}
+		case "extension_ui_request":
+			if (frame.method === "notify") {
+				const text = asString(frame.message, "");
+				if (text === "") return state;
+				return withEntry(state, {
+					kind: "notice",
+					id: `n${state.nextId}`,
+					text,
+					tone: frame.notifyType === "error" ? "error" : "info"
+				});
+			}
+			return applyDialog(state, frame);
+		case require_hub.DIALOG_ANSWERED_TYPE: return state.dialog && state.dialog.id === asString(frame.id) ? {
+			...state,
+			dialog: null
+		} : state;
+		case "fast_mode_changed": return typeof frame.enabled === "boolean" ? {
+			...state,
+			fastMode: frame.enabled
+		} : state;
+		case "agent_lock_changed": return typeof frame.locked === "boolean" ? {
+			...state,
+			agentLocked: frame.locked
+		} : state;
+		case "thinking_level_changed": {
+			if (state.agent === null) return state;
+			const level = asString(frame.level, state.agent.thinkingLevel);
+			return {
+				...state,
+				agent: {
+					...state.agent,
+					thinkingLevel: level
+				}
+			};
+		}
+		case "entry_appended": {
+			const entry = isRecord(frame.entry) ? frame.entry : void 0;
+			if (!entry) return state;
+			const notification = require_notification.parseDoomNotificationEntry(frame);
+			if (notification) {
+				if (state.restoredIds.includes(notification.entryId)) return state;
+				const timestamp = asNumber(entry.timestamp) ?? void 0;
+				const next = withChronologicalEntry(state, {
+					kind: "notice",
+					id: `n${state.nextId}`,
+					text: notification.data.body,
+					tone: notification.data.level === "error" ? "error" : "info",
+					...timestamp === void 0 ? {} : { timestamp }
+				});
+				return {
+					...next,
+					restoredIds: [...next.restoredIds, notification.entryId]
+				};
+			}
+			if (entry.type === "custom" && entry.customType === "doom-minor-modes") {
+				const data = isRecord(entry.data) ? entry.data : void 0;
+				if (!data || !Array.isArray(data.modes)) return state;
+				return {
+					...state,
+					minorModes: data
+				};
+			}
+			if (entry.type === "custom" && entry.customType === "doom-context") {
+				const data = isRecord(entry.data) ? entry.data : void 0;
+				if (!data || !Array.isArray(data.groups)) return state;
+				return applyContextSelection(state, data);
+			}
+			if (entry.type === "custom" && entry.customType === "doom-agent-model") {
+				const data = isRecord(entry.data) ? entry.data : void 0;
+				if (!data || state.agent === null) return state;
+				const id = asString(data.id, "");
+				const provider = asString(data.provider, "");
+				if (id === "" || provider === "") return state;
+				return {
+					...state,
+					agent: {
+						...state.agent,
+						model: id,
+						provider
+					}
+				};
+			}
+			if (entry.type === "custom" && entry.customType === "doom-profile-identity") {
+				const data = isRecord(entry.data) ? entry.data : void 0;
+				const profile = asString(data?.profile, "");
+				if (profile === "") return state;
+				const name = asString(data?.name, "");
+				const icon = asString(data?.icon, "");
+				return {
+					...state,
+					profileIdentity: {
+						profile,
+						...name === "" ? {} : { name },
+						...icon === "" ? {} : { icon }
+					}
+				};
+			}
+			if (entry.type === "custom" && entry.customType === "po.agent-settled") {
+				const data = isRecord(entry.data) ? entry.data : {};
+				const id = `settled:${asString(data.runId)}`;
+				if (state.entries.some((item) => item.id === id)) return state;
+				return withChronologicalEntry(state, {
+					kind: "settled",
+					id,
+					tools: asNumber(data.tools) ?? 0,
+					timestamp: asNumber(data.timestamp) ?? asNumber(entry.timestamp) ?? void 0
+				});
+			}
+			return options.transcriptFromProtocol ? rememberJournalEntry(state, entry) : applyJournalEntry(state, entry);
+		}
+		case "response": return applyResponse(state, frame);
+		case "error":
+		case "extension_error": return withEntry(state, {
+			kind: "notice",
+			id: `n${state.nextId}`,
+			text: asString(frame.message ?? frame.error, "The agent reported an error."),
+			tone: "error"
+		});
+		default: return state;
+	}
+}
+/** Records the prompt locally, because Pi does not echo it back as an event. */
+function appendUserPrompt(state, text, images = []) {
+	const id = `u${state.nextId}`;
+	return withPendingUser(withEntry(state, {
+		kind: "user",
+		id,
+		text,
+		...images.length > 0 ? { images } : {}
+	}), id, text, images);
+}
+/** A follow-up waits for the current run, so it is marked rather than shown as sent. */
+function appendQueued(state, text, images = []) {
+	const id = `q${state.nextId}`;
+	return withPendingUser(withEntry(state, {
+		kind: "queued",
+		id,
+		text,
+		delivery: "followUp",
+		...images.length > 0 ? { images } : {}
+	}), id, text, images);
+}
+/** Uses server IDs as-is: equal text or a snapshot revision is not an item identity. */
+function replaceQueuedEntries(state, queue) {
+	return {
+		...state,
+		entries: [...state.entries.filter((entry) => entry.kind !== "queued"), ...queue]
+	};
+}
+/** Removes queued rows and their reconciliation records after Pi clears the queue. */
+function clearQueuedEntries(state) {
+	const queuedIds = new Set(state.entries.filter((entry) => entry.kind === "queued").map((entry) => entry.id));
+	return {
+		...state,
+		entries: state.entries.filter((entry) => entry.kind !== "queued"),
+		pendingUserEntries: state.pendingUserEntries.filter((entry) => !queuedIds.has(entry.id))
+	};
+}
+/** Removes one queued row and the optimistic reconciliation record tied to it. */
+function removeQueuedEntry(state, id) {
+	return {
+		...state,
+		entries: state.entries.filter((entry) => entry.kind !== "queued" || entry.id !== id),
+		pendingUserEntries: state.pendingUserEntries.filter((entry) => entry.id !== id)
+	};
+}
+function clearDialog(state) {
+	return {
+		...state,
+		dialog: null
+	};
+}
+//#endregion
+exports.appendQueued = appendQueued;
+exports.appendUserPrompt = appendUserPrompt;
+exports.clearDialog = clearDialog;
+exports.clearQueuedEntries = clearQueuedEntries;
+exports.imagesFromContent = imagesFromContent;
+exports.initialSessionState = initialSessionState;
+exports.isSupportedImageMimeType = isSupportedImageMimeType;
+exports.prependHistory = prependHistory;
+exports.reduceSession = reduceSession;
+exports.removeQueuedEntry = removeQueuedEntry;
+exports.replaceQueuedEntries = replaceQueuedEntries;
+exports.summariseArgs = summariseArgs;
+exports.textFromContent = textFromContent;
+
+//# sourceMappingURL=sessionModel.cjs.map