@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/src/services/rpcTranscript/index.mjs

@@ -1,632 +0,0 @@
-//#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",
-		fastMode: false,
-		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;
-	let lastCompletedAssistant;
-	const rememberCompletion = (item) => {
-		lastCompletedAssistant = item ? {
-			id: item.id,
-			role: item.role,
-			timestamp: item.timestamp,
-			model: item.model
-		} : void 0;
-	};
-	/** 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 = (value, id) => {
-		const message = isRecord(value) ? value : {};
-		const model = typeof message.model === "string" ? {
-			provider: text(message.provider, snapshot.model.provider),
-			id: message.model
-		} : modelRef(message.model ?? snapshot.model);
-		const timestamp = finiteNumber(message.timestamp) ?? now();
-		return {
-			id: id ?? `assistant-${timestamp}-${model.provider}-${model.id}`,
-			role: "assistant",
-			content: assistantContent(message.content),
-			model,
-			status: "streaming",
-			timestamp
-		};
-	};
-	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 item = assistantFrom(message, text(message.id) || void 0);
-					const id = item.id;
-					const previous = streaming.get(activeAssistantId ?? "") ?? lastCompletedAssistant ?? snapshot.transcript.findLast((entry) => entry.role === "assistant");
-					const timestamp = finiteNumber(message.timestamp);
-					if (previous?.role === "assistant" && (timestamp === void 0 && previous.id === id || timestamp !== void 0 && (previous.timestamp > timestamp || previous.timestamp === timestamp && (!message.model || previous.model.id === "unknown" || previous.model.id === item.model.id)))) return {};
-					streaming.set(id, item);
-					activeAssistantId = id;
-					return { progress: {
-						type: "item_started",
-						item
-					} };
-				}
-				case "message_update": {
-					const event = isRecord(frame.assistantMessageEvent) ? frame.assistantMessageEvent : void 0;
-					const message = isRecord(frame.message) ? frame.message : isRecord(event?.partial) ? event.partial : void 0;
-					if (message?.role !== void 0 && message.role !== "assistant") return {};
-					const incoming = message ? assistantFrom(message, text(message.id, activeAssistantId) || void 0) : void 0;
-					const id = incoming?.id ?? activeAssistantId ?? "";
-					const existing = streaming.get(id);
-					if (!existing && (message?.role !== "assistant" || !Array.isArray(message.content) || message.content.length === 0 && event?.type !== "start")) return {};
-					const completed = lastCompletedAssistant ?? snapshot.transcript.findLast((item) => item.role === "assistant");
-					const timestamp = finiteNumber(message?.timestamp);
-					if (!existing && completed?.role === "assistant" && (completed.id === id || timestamp !== void 0 && (completed.timestamp > timestamp || completed.timestamp === timestamp && (!message?.model || completed.model.id === incoming?.model.id)))) return {};
-					const item = {
-						...existing ?? incoming,
-						...timestamp === void 0 ? {} : { timestamp },
-						...message?.model === void 0 ? {} : { model: typeof message.model === "string" && message.provider === void 0 && existing ? {
-							provider: existing.model.provider,
-							id: message.model
-						} : incoming.model },
-						content: Array.isArray(message?.content) ? assistantContent(message.content) : applyAssistantEvent(existing?.content ?? incoming.content, event)
-					};
-					streaming.set(id, item);
-					activeAssistantId = id;
-					return { progress: {
-						type: existing ? "item_updated" : "item_started",
-						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 timestamp = finiteNumber(ended.timestamp);
-					const completed = lastCompletedAssistant?.timestamp === timestamp ? lastCompletedAssistant : snapshot.transcript.findLast((item) => item.role === "assistant" && item.timestamp === timestamp);
-					const id = text(ended.id, activeAssistantId ?? completed?.id ?? `assistant-${finiteNumber(ended.timestamp) ?? snapshot.revision}`);
-					if (!streaming.has(id) && (lastCompletedAssistant?.id === id || snapshot.transcript.some((item) => item.id === id))) return {};
-					const started = streaming.get(id) ?? assistantFrom(frame.message, id);
-					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"
-					};
-					rememberCompletion(item);
-					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 result = isRecord(frame.partialResult) ? frame.partialResult : {};
-					const item = {
-						...existing,
-						...result.content === void 0 && result.output === void 0 ? {} : { content: plainContent(result.content ?? result.output) },
-						details: normalizeJson(result.details ?? 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),
-						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);
-						if (!rebuilt) return {};
-						rememberCompletion(rebuilt.findLast((item) => item.role === "assistant"));
-						return { 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;
-					rememberCompletion(rebuilt.findLast((item) => item.role === "assistant"));
-					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