@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/services/rpcTranscript/index.d.cts

@@ -0,0 +1,50 @@
+import { SessionPhase, SessionSnapshot, TranscriptProgress } from "../../schemas/sessionProtocol.cjs";
+import "../../session-protocol.cjs";
+import { SessionFrame } from "../../types/server/session.cjs";
+//#region src/services/rpcTranscript/index.d.ts
+/**
+ * What one agent frame changed.
+ *
+ * A frame can do both: finishing a message publishes the completed item as
+ * progress and appends it to the authoritative transcript.
+ */
+export interface TranscriptReduction {
+  /** Present when the frame changed authoritative state. */
+  snapshot?: SessionSnapshot;
+  /** Present when the frame produced transient activity. */
+  /** Coarse assistant usage totals. Never includes message or tool content. */
+  aggregate?: Record<string, number>;
+  progress?: TranscriptProgress;
+}
+export interface RpcTranscript {
+  snapshot(): SessionSnapshot;
+  phase(): SessionPhase;
+  apply(frame: SessionFrame): TranscriptReduction;
+}
+export interface RpcTranscriptOptions {
+  id: string;
+  cwd: string;
+  name?: string;
+  /** Server streaming projections do not retain committed history. */
+  retainEntries?: number;
+  /**
+   * Supplies every timestamp this projection stamps.
+   *
+   * Required rather than defaulted: a service that reaches for the clock is
+   * one a test cannot pin, and the snapshot's timestamps are compared.
+   */
+  now: () => number;
+}
+/**
+ * Projects Pi's rpc event stream onto the protocol's session model.
+ *
+ * The protocol is snapshot-authoritative: the snapshot is the truth and
+ * progress is a transient hint that must never be reduced into it. That split
+ * is the reason this exists at all, because Pi's rpc stream makes no such
+ * distinction and reports a running message the same way it reports a settled
+ * one. Frames with no protocol meaning reduce to nothing rather than being
+ * forced into a shape the schema would reject.
+ */
+export declare function createRpcTranscript(options: RpcTranscriptOptions): RpcTranscript;
+//#endregion
+//# sourceMappingURL=index.d.cts.map

package/dist/services/rpcTranscript/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/services/rpcTranscript/index.ts"],"mappings":";;;;;;;;;;iBAuBiB;;EAEf,WAAW;;;EAGX,YAAY;EACZ,WAAW;;iBAGI;EACf,YAAY;EACZ,SAAS;EACT,MAAM,OAAO,eAAe;;iBA2Qb;EACf;EACA;EACA;;EAEA;;;;;;;EAOA;;;;;;;;;;;;wBAac,oBAAoB,SAAS,uBAAuB"}

package/dist/services/rpcTranscript/index.d.mts

@@ -0,0 +1,50 @@
+import { SessionPhase, SessionSnapshot, TranscriptProgress } from "../../schemas/sessionProtocol.mjs";
+import "../../session-protocol.mjs";
+import { SessionFrame } from "../../types/server/session.mjs";
+//#region src/services/rpcTranscript/index.d.ts
+/**
+ * What one agent frame changed.
+ *
+ * A frame can do both: finishing a message publishes the completed item as
+ * progress and appends it to the authoritative transcript.
+ */
+export interface TranscriptReduction {
+  /** Present when the frame changed authoritative state. */
+  snapshot?: SessionSnapshot;
+  /** Present when the frame produced transient activity. */
+  /** Coarse assistant usage totals. Never includes message or tool content. */
+  aggregate?: Record<string, number>;
+  progress?: TranscriptProgress;
+}
+export interface RpcTranscript {
+  snapshot(): SessionSnapshot;
+  phase(): SessionPhase;
+  apply(frame: SessionFrame): TranscriptReduction;
+}
+export interface RpcTranscriptOptions {
+  id: string;
+  cwd: string;
+  name?: string;
+  /** Server streaming projections do not retain committed history. */
+  retainEntries?: number;
+  /**
+   * Supplies every timestamp this projection stamps.
+   *
+   * Required rather than defaulted: a service that reaches for the clock is
+   * one a test cannot pin, and the snapshot's timestamps are compared.
+   */
+  now: () => number;
+}
+/**
+ * Projects Pi's rpc event stream onto the protocol's session model.
+ *
+ * The protocol is snapshot-authoritative: the snapshot is the truth and
+ * progress is a transient hint that must never be reduced into it. That split
+ * is the reason this exists at all, because Pi's rpc stream makes no such
+ * distinction and reports a running message the same way it reports a settled
+ * one. Frames with no protocol meaning reduce to nothing rather than being
+ * forced into a shape the schema would reject.
+ */
+export declare function createRpcTranscript(options: RpcTranscriptOptions): RpcTranscript;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/services/rpcTranscript/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/services/rpcTranscript/index.ts"],"mappings":";;;;;;;;;;iBAuBiB;;EAEf,WAAW;;;EAGX,YAAY;EACZ,WAAW;;iBAGI;EACf,YAAY;EACZ,SAAS;EACT,MAAM,OAAO,eAAe;;iBA2Qb;EACf;EACA;EACA;;EAEA;;;;;;;EAOA;;;;;;;;;;;;wBAac,oBAAoB,SAAS,uBAAuB"}

package/dist/services/rpcTranscript/index.mjs

@@ -0,0 +1,589 @@
+//#region src/services/rpcTranscript/index.ts
+const THINKING_LEVELS = /* @__PURE__ */ new Set([
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high"
+]);
+const STOP_REASONS = /* @__PURE__ */ new Set([
+	"stop",
+	"length",
+	"toolUse"
+]);
+const UNKNOWN_MODEL = {
+	provider: "unknown",
+	id: "unknown"
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value, fallback = "") {
+	return typeof value === "string" ? value : fallback;
+}
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function assistantAggregate(message) {
+	const aggregate = { assistant_messages: 1 };
+	const usage = isRecord(message.usage) ? message.usage : {};
+	const cost = isRecord(usage.cost) ? usage.cost : {};
+	const fields = [
+		["input_tokens", usage.input ?? usage.inputTokens],
+		["output_tokens", usage.output ?? usage.outputTokens],
+		["cache_read_tokens", usage.cacheRead ?? usage.cacheReadTokens],
+		["cache_write_tokens", usage.cacheWrite ?? usage.cacheWriteTokens],
+		["total_tokens", usage.totalTokens],
+		["cost_usd", cost.total ?? message.cost]
+	];
+	for (const [name, value] of fields) {
+		const numeric = finiteNumber(value);
+		if (numeric !== void 0) aggregate[name] = numeric;
+	}
+	return aggregate;
+}
+/** Coerces to the protocol's JSON subset, which rejects undefined and non-plain objects. */
+function normalizeJson(value) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (Array.isArray(value)) return value.map((entry) => normalizeJson(entry));
+	if (!isRecord(value)) return null;
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, normalizeJson(entry)]));
+}
+function thinkingLevel(value, fallback) {
+	return typeof value === "string" && THINKING_LEVELS.has(value) ? value : fallback;
+}
+function modelRef(value) {
+	if (!isRecord(value)) return UNKNOWN_MODEL;
+	const provider = text(value.provider);
+	const id = text(value.id);
+	return provider && id ? {
+		provider,
+		id
+	} : UNKNOWN_MODEL;
+}
+/** Maps pi-ai assistant content onto the protocol's closed part union. */
+function assistantContent(value) {
+	if (!Array.isArray(value)) return [];
+	const parts = [];
+	for (const part of value) {
+		if (!isRecord(part)) continue;
+		if (part.type === "text") parts.push({
+			type: "text",
+			text: text(part.text)
+		});
+		else if (part.type === "thinking") parts.push({
+			type: "thinking",
+			thinking: text(part.thinking),
+			...part.redacted === true ? { redacted: true } : {}
+		});
+		else if (part.type === "toolCall") {
+			const toolCallId = text(part.id, text(part.toolCallId));
+			const toolName = text(part.name, text(part.toolName));
+			if (!toolCallId || !toolName) continue;
+			parts.push({
+				type: "toolCall",
+				toolCallId,
+				toolName,
+				input: normalizeJson(part.arguments ?? part.input)
+			});
+		}
+	}
+	return parts;
+}
+/** Applies Pi RPC's delta-only assistant event to the live protocol item. */
+function applyAssistantEvent(content, value) {
+	if (!isRecord(value) || !Number.isInteger(value.contentIndex) || value.contentIndex < 0) return content;
+	const index = value.contentIndex;
+	const parts = [...content];
+	const existing = parts[index];
+	switch (value.type) {
+		case "text_start":
+			parts[index] = existing?.type === "text" ? existing : {
+				type: "text",
+				text: ""
+			};
+			break;
+		case "text_delta":
+			parts[index] = {
+				type: "text",
+				text: (existing?.type === "text" ? existing.text : "") + text(value.delta)
+			};
+			break;
+		case "text_end":
+			parts[index] = {
+				type: "text",
+				text: text(value.content, existing?.type === "text" ? existing.text : "")
+			};
+			break;
+		case "thinking_start":
+			parts[index] = existing?.type === "thinking" ? existing : {
+				type: "thinking",
+				thinking: ""
+			};
+			break;
+		case "thinking_delta":
+			parts[index] = {
+				type: "thinking",
+				thinking: (existing?.type === "thinking" ? existing.thinking : "") + text(value.delta)
+			};
+			break;
+		case "thinking_end":
+			parts[index] = {
+				type: "thinking",
+				thinking: text(value.content, existing?.type === "thinking" ? existing.thinking : "")
+			};
+			break;
+		case "toolcall_start": {
+			const toolCallId = text(value.id);
+			const toolName = text(value.toolName);
+			if (toolCallId && toolName) parts[index] = {
+				type: "toolCall",
+				toolCallId,
+				toolName,
+				input: {}
+			};
+			break;
+		}
+		case "toolcall_end": {
+			const completed = assistantContent([value.toolCall])[0];
+			if (completed) parts[index] = completed;
+			break;
+		}
+	}
+	return parts.filter((part) => part !== void 0);
+}
+/** Maps a user or tool payload onto the protocol's text-and-image union. */
+function plainContent(value) {
+	if (typeof value === "string") return [{
+		type: "text",
+		text: value
+	}];
+	if (!Array.isArray(value)) return [];
+	const parts = [];
+	for (const part of value) {
+		if (!isRecord(part)) continue;
+		if (part.type === "text") parts.push({
+			type: "text",
+			text: text(part.text)
+		});
+		else if (part.type === "image") {
+			const data = text(part.data);
+			const mimeType = text(part.mimeType);
+			if (data && mimeType) parts.push({
+				type: "image",
+				data,
+				mimeType
+			});
+		}
+	}
+	return parts;
+}
+function timestampFrom(entry, message, now) {
+	const messageTimestamp = finiteNumber(message.timestamp);
+	if (messageTimestamp !== void 0) return messageTimestamp;
+	const entryTimestamp = finiteNumber(entry.timestamp);
+	if (entryTimestamp !== void 0) return entryTimestamp;
+	const parsed = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+	return Number.isFinite(parsed) ? parsed : now();
+}
+/** Selects the active branch from a complete get_entries response. */
+function activeBranch(data) {
+	if (!Array.isArray(data.entries)) return void 0;
+	if (data.leafId === null) return [];
+	if (typeof data.leafId !== "string") return void 0;
+	const entries = new Map(data.entries.filter(isRecord).map((entry) => [entry.id, entry]));
+	const branch = [];
+	const visited = /* @__PURE__ */ new Set();
+	let id = data.leafId;
+	while (id !== null) {
+		if (typeof id !== "string" || visited.has(id)) return void 0;
+		const entry = entries.get(id);
+		if (!entry) return void 0;
+		visited.add(id);
+		branch.push(entry);
+		id = entry.parentId;
+	}
+	return branch.reverse();
+}
+/** Rebuilds the active protocol transcript from journal messages. */
+function transcriptFromBranch(value, fallbackModel, now) {
+	if (!Array.isArray(value)) return void 0;
+	const items = [];
+	const toolCalls = /* @__PURE__ */ new Map();
+	for (const candidate of value) {
+		if (!isRecord(candidate) || candidate.type !== "message" || !isRecord(candidate.message)) continue;
+		const message = candidate.message;
+		const role = text(message.role);
+		const timestamp = timestampFrom(candidate, message, now);
+		if (role === "user") {
+			const content = plainContent(message.content);
+			if (content.length === 0) continue;
+			const stamp = finiteNumber(message.timestamp);
+			items.push({
+				id: stamp === void 0 ? text(candidate.id, `user-${String(timestamp)}`) : `user-${String(stamp)}`,
+				role: "user",
+				content,
+				timestamp
+			});
+			continue;
+		}
+		if (role === "assistant") {
+			const content = assistantContent(message.content);
+			for (const part of content) if (part.type === "toolCall") toolCalls.set(part.toolCallId, {
+				name: part.toolName,
+				input: part.input
+			});
+			const stopReason = text(message.stopReason);
+			const errorMessage = text(message.errorMessage);
+			const base = {
+				id: text(message.id, text(candidate.id, `assistant-${String(timestamp)}`)),
+				role: "assistant",
+				content,
+				model: modelRef(message.model ?? fallbackModel),
+				timestamp
+			};
+			items.push(stopReason === "aborted" ? {
+				...base,
+				status: "aborted",
+				stopReason: "aborted",
+				...errorMessage ? { errorMessage } : {}
+			} : stopReason === "error" ? {
+				...base,
+				status: "error",
+				stopReason: "error",
+				...errorMessage ? { errorMessage } : {}
+			} : {
+				...base,
+				status: "complete",
+				stopReason: STOP_REASONS.has(stopReason) ? stopReason : "stop"
+			});
+			continue;
+		}
+		if (role === "toolResult") {
+			const toolCallId = text(message.toolCallId);
+			const call = toolCalls.get(toolCallId);
+			if (!call) continue;
+			const isError = message.isError === true;
+			const base = {
+				id: toolCallId,
+				role: "tool",
+				toolCallId,
+				toolName: call.name,
+				input: call.input,
+				content: plainContent(message.content),
+				...message.details === void 0 ? {} : { details: normalizeJson(message.details) },
+				timestamp
+			};
+			items.push(isError ? {
+				...base,
+				status: "error",
+				isError: true
+			} : {
+				...base,
+				status: "complete",
+				isError: false
+			});
+		}
+	}
+	return items;
+}
+/**
+* Projects Pi's rpc event stream onto the protocol's session model.
+*
+* The protocol is snapshot-authoritative: the snapshot is the truth and
+* progress is a transient hint that must never be reduced into it. That split
+* is the reason this exists at all, because Pi's rpc stream makes no such
+* distinction and reports a running message the same way it reports a settled
+* one. Frames with no protocol meaning reduce to nothing rather than being
+* forced into a shape the schema would reject.
+*/
+function createRpcTranscript(options) {
+	const now = options.now;
+	const created = now();
+	let snapshot = {
+		id: options.id,
+		cwd: options.cwd,
+		createdAt: created,
+		updatedAt: created,
+		phase: "idle",
+		model: UNKNOWN_MODEL,
+		thinkingLevel: "medium",
+		attached: false,
+		locked: false,
+		revision: 0,
+		transcript: [],
+		queuedSteer: [],
+		queuedSteerCount: 0,
+		...options.name === void 0 ? {} : { name: options.name }
+	};
+	/** Assistant messages still streaming, by message id. */
+	const streaming = /* @__PURE__ */ new Map();
+	let activeAssistantId;
+	/** Tool calls still running, by tool call id. */
+	const running = /* @__PURE__ */ new Map();
+	const commit = (updates) => {
+		snapshot = {
+			...snapshot,
+			...updates,
+			revision: snapshot.revision + 1,
+			updatedAt: now()
+		};
+		if (options.retainEntries !== void 0) snapshot.transcript = options.retainEntries === 0 ? [] : snapshot.transcript.slice(-options.retainEntries);
+		return snapshot;
+	};
+	const append = (item) => commit({ transcript: [...snapshot.transcript, item] });
+	/**
+	* Appends unless the transcript already holds that id.
+	*
+	* A user message reaches this twice: once as the message the agent started,
+	* and again when the session journals it. Only one belongs in the
+	* transcript, and the id is what decides which arrival was first.
+	*/
+	const appendUnique = (item) => snapshot.transcript.some((existing) => existing.id === item.id) ? void 0 : append(item);
+	/**
+	* A user message keyed by when it was written.
+	*
+	* pi-ai gives a user message no id of its own, so the timestamp is the only
+	* thing both arrivals of the same message agree on.
+	*/
+	const userFrom = (message, fallbackId, fallbackTimestamp) => {
+		const content = plainContent(message.content);
+		if (content.length === 0) return void 0;
+		const stamp = typeof message.timestamp === "number" ? message.timestamp : fallbackTimestamp;
+		return {
+			id: stamp === void 0 ? fallbackId : `user-${stamp}`,
+			role: "user",
+			content,
+			timestamp: stamp ?? now()
+		};
+	};
+	const assistantFrom = (message, id) => ({
+		id,
+		role: "assistant",
+		content: assistantContent(isRecord(message) ? message.content : void 0),
+		model: isRecord(message) ? modelRef(message.model ?? snapshot.model) : snapshot.model,
+		status: "streaming",
+		timestamp: now()
+	});
+	return {
+		snapshot: () => structuredClone(snapshot),
+		phase: () => snapshot.phase,
+		apply(frame) {
+			switch (text(frame.type)) {
+				case "agent_start": return { snapshot: commit({ phase: "turn" }) };
+				case "agent_settled": return { snapshot: commit({ phase: "idle" }) };
+				case "compaction_start": return { snapshot: commit({ phase: "compaction" }) };
+				case "compaction_end": return { snapshot: commit({ phase: "idle" }) };
+				case "auto_retry_start": return { snapshot: commit({ phase: "retry" }) };
+				case "auto_retry_end": return { snapshot: commit({ phase: "turn" }) };
+				case "thinking_level_changed": return { snapshot: commit({ thinkingLevel: thinkingLevel(frame.level, snapshot.thinkingLevel) }) };
+				case "session_info_changed": {
+					const name = text(frame.name);
+					return { snapshot: commit(name ? { name } : {}) };
+				}
+				case "queue_update": {
+					const steering = Array.isArray(frame.steering) ? frame.steering : [];
+					const followUp = Array.isArray(frame.followUp) ? frame.followUp : [];
+					const queuedSteer = [...steering, ...followUp].map((entry, index) => ({
+						id: `steer-${snapshot.revision}-${index}`,
+						role: "user",
+						content: [{
+							type: "text",
+							text: text(entry)
+						}],
+						timestamp: now()
+					}));
+					return { snapshot: commit({
+						queuedSteer,
+						queuedSteerCount: queuedSteer.length
+					}) };
+				}
+				case "message_start": {
+					const message = isRecord(frame.message) ? frame.message : {};
+					if (message.role === "user") {
+						const item = userFrom(message, `user-${snapshot.revision}`);
+						if (!item) return {};
+						const committed = appendUnique(item);
+						return committed ? { snapshot: committed } : {};
+					}
+					if (message.role !== "assistant") return {};
+					const id = text(message.id, `assistant-${snapshot.revision}`);
+					const item = assistantFrom(frame.message, id);
+					streaming.set(id, item);
+					activeAssistantId = id;
+					return { progress: {
+						type: "item_started",
+						item
+					} };
+				}
+				case "message_update": {
+					const id = text(isRecord(frame.message) ? frame.message.id : void 0, activeAssistantId);
+					const existing = streaming.get(id);
+					if (!existing) return {};
+					const item = {
+						...existing,
+						content: isRecord(frame.message) ? assistantContent(frame.message.content) : applyAssistantEvent(existing.content, frame.assistantMessageEvent)
+					};
+					streaming.set(id, item);
+					return { progress: {
+						type: "item_updated",
+						item
+					} };
+				}
+				case "message_end": {
+					const ended = isRecord(frame.message) ? frame.message : {};
+					if (ended.role === "user") {
+						const item = userFrom(ended, `user-${snapshot.revision}`);
+						if (!item) return {};
+						const committed = appendUnique(item);
+						return committed ? { snapshot: committed } : {};
+					}
+					if (ended.role !== "assistant") return {};
+					const id = text(ended.id, activeAssistantId);
+					const started = streaming.get(id) ?? assistantFrom(frame.message, id || `assistant-${snapshot.revision}`);
+					streaming.delete(started.id);
+					if (activeAssistantId === started.id) activeAssistantId = void 0;
+					const message = ended;
+					const stopReason = text(message.stopReason);
+					const errorMessage = text(message.errorMessage);
+					const base = {
+						...started,
+						content: assistantContent(message.content ?? started.content)
+					};
+					const item = stopReason === "aborted" ? {
+						...base,
+						status: "aborted",
+						stopReason: "aborted",
+						...errorMessage ? { errorMessage } : {}
+					} : stopReason === "error" ? {
+						...base,
+						status: "error",
+						stopReason: "error",
+						...errorMessage ? { errorMessage } : {}
+					} : {
+						...base,
+						status: "complete",
+						stopReason: STOP_REASONS.has(stopReason) ? stopReason : "stop"
+					};
+					return {
+						snapshot: append(item),
+						progress: {
+							type: "item_finished",
+							item
+						},
+						aggregate: assistantAggregate(message)
+					};
+				}
+				case "tool_execution_start": {
+					const toolCallId = text(frame.toolCallId);
+					const toolName = text(frame.toolName);
+					if (!toolCallId || !toolName) return {};
+					const item = {
+						id: toolCallId,
+						role: "tool",
+						toolCallId,
+						toolName,
+						input: normalizeJson(frame.args),
+						content: [],
+						status: "running",
+						isError: false,
+						timestamp: now()
+					};
+					running.set(toolCallId, item);
+					return { progress: {
+						type: "item_started",
+						item
+					} };
+				}
+				case "tool_execution_update": {
+					const existing = running.get(text(frame.toolCallId));
+					if (!existing) return {};
+					const item = {
+						...existing,
+						details: normalizeJson(frame.partialResult)
+					};
+					running.set(existing.toolCallId, item);
+					return { progress: {
+						type: "item_updated",
+						item
+					} };
+				}
+				case "tool_execution_end": {
+					const toolCallId = text(frame.toolCallId);
+					const existing = running.get(toolCallId);
+					if (!existing) return {};
+					running.delete(toolCallId);
+					const result = isRecord(frame.result) ? frame.result : {};
+					const isError = frame.isError === true;
+					const item = {
+						...existing,
+						content: plainContent(result.content ?? result.output),
+						...result.details === void 0 ? {} : { details: normalizeJson(result.details) },
+						...isError ? {
+							status: "error",
+							isError: true
+						} : {
+							status: "complete",
+							isError: false
+						}
+					};
+					return {
+						snapshot: append(item),
+						progress: {
+							type: "item_finished",
+							item
+						}
+					};
+				}
+				case "entry_appended": {
+					const entry = isRecord(frame.entry) ? frame.entry : void 0;
+					if (!entry || entry.type !== "message") return {};
+					const message = isRecord(entry.message) ? entry.message : void 0;
+					if (!message || message.role !== "user") return {};
+					const item = userFrom(message, text(entry.id, `user-${snapshot.revision}`), typeof entry.timestamp === "number" ? entry.timestamp : void 0);
+					if (!item) return {};
+					const committed = appendUnique(item);
+					return committed ? { snapshot: committed } : {};
+				}
+				case "response": {
+					if (frame.command === "get_state") return applyState(frame.data);
+					if (frame.command === "get_entries" && frame.success === true && isRecord(frame.data)) {
+						const rebuilt = transcriptFromBranch(activeBranch(frame.data), snapshot.model, now);
+						return rebuilt ? { snapshot: commit({ transcript: rebuilt }) } : {};
+					}
+					if (frame.command !== "navigate_tree" || frame.success !== true || !isRecord(frame.data)) return {};
+					if (frame.data.cancelled === true) return {};
+					const rebuilt = transcriptFromBranch(frame.data.entries, snapshot.model, now);
+					if (!rebuilt) return {};
+					streaming.clear();
+					running.clear();
+					activeAssistantId = void 0;
+					return { snapshot: commit({
+						transcript: rebuilt,
+						queuedSteer: [],
+						queuedSteerCount: 0,
+						phase: "idle"
+					}) };
+				}
+				default: return {};
+			}
+		}
+	};
+	function applyState(data) {
+		if (!isRecord(data)) return {};
+		const streamingNow = data.isStreaming === true;
+		const compacting = data.isCompacting === true;
+		const name = text(data.sessionName);
+		return { snapshot: commit({
+			model: modelRef(data.model),
+			thinkingLevel: thinkingLevel(data.thinkingLevel, snapshot.thinkingLevel),
+			phase: compacting ? "compaction" : streamingNow ? "turn" : "idle",
+			...name ? { name } : {}
+		}) };
+	}
+}
+//#endregion
+export { activeBranch, createRpcTranscript };
+
+//# sourceMappingURL=index.mjs.map