@pi-in-go/pigpen-ahp 0.1.0

package/proof/oracle/src/pi/history.ts

@@ -0,0 +1,305 @@
+/**
+ * Rebuilds chat history from a pi session file.
+ *
+ * A client lists sessions and then subscribes to one. Everything the host has
+ * seen live is already in memory, but a session from the catalogue exists only
+ * on disk — so subscribing has to reconstruct its state, or the client opens an
+ * empty conversation.
+ *
+ * The window matches what pi itself renders. `buildContextEntries()` starts at
+ * the most recent compaction (`session-manager.ts` builds
+ * `[compaction, …kept entries, …later entries]`), which is exactly the transcript
+ * pi's own TUI shows on resume. Reconstructing more would show the user history
+ * their agent has already forgotten.
+ *
+ * This is a *second* mapper, distinct from the streaming one: it works from
+ * finished messages rather than deltas, so there is no partial state, no
+ * ordering to preserve, and every tool call already has its result.
+ */
+
+import type { SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
+import {
+	type Message,
+	MessageKind,
+	type ResponsePart,
+	ResponsePartKind,
+	ToolCallStatus,
+	type ToolResultContent,
+	ToolResultContentType,
+	type Turn,
+	TurnState,
+	type UsageInfo,
+} from "@microsoft/agent-host-protocol";
+import { userMessageFromPiContent } from "./user-message.ts";
+
+interface ContentBlock {
+	readonly type: string;
+	readonly text?: string;
+	readonly thinking?: string;
+	readonly id?: string;
+	readonly name?: string;
+	readonly arguments?: unknown;
+}
+
+interface StoredMessage {
+	readonly role?: string;
+	readonly content?: string | ContentBlock[];
+	readonly toolCallId?: string;
+	readonly toolName?: string;
+	readonly isError?: boolean;
+	readonly usage?: { input?: number; output?: number; cacheRead?: number };
+	readonly model?: string;
+	readonly command?: string;
+	readonly output?: string;
+}
+
+function blocksOf(message: StoredMessage): ContentBlock[] {
+	if (typeof message.content === "string") {
+		return [{ type: "text", text: message.content }];
+	}
+	return Array.isArray(message.content) ? message.content : [];
+}
+
+function plainText(message: StoredMessage): string {
+	return blocksOf(message)
+		.filter((block) => block.type === "text" && typeof block.text === "string")
+		.map((block) => block.text as string)
+		.join("");
+}
+
+function toUsage(message: StoredMessage): UsageInfo | undefined {
+	const usage = message.usage;
+	if (!usage) {
+		return undefined;
+	}
+	return {
+		...(usage.input !== undefined ? { inputTokens: usage.input } : {}),
+		...(usage.output !== undefined ? { outputTokens: usage.output } : {}),
+		...(usage.cacheRead !== undefined ? { cacheReadTokens: usage.cacheRead } : {}),
+		...(message.model ? { model: message.model } : {}),
+	};
+}
+
+function textContent(text: string): ToolResultContent[] {
+	return [{ type: ToolResultContentType.Text, text }];
+}
+
+/** A turn under construction, before its tool results have been matched up. */
+interface PendingTurn {
+	readonly id: string;
+	readonly startedAt: string;
+	readonly message: Message;
+	readonly parts: ResponsePart[];
+	usage: UsageInfo | undefined;
+}
+
+export interface RebuildOptions {
+	/** Prefix for generated turn ids; only needs to be stable within a chat. */
+	readonly turnIdPrefix?: string;
+}
+
+export interface RebuiltHistory {
+	readonly turns: Turn[];
+	/**
+	 * Turn id → the session entry that turn *ends* on.
+	 *
+	 * This is the anchor truncation needs. `chat/truncated` keeps turns up to
+	 * and including the named one, and pi's `navigateTree` is inclusive for a
+	 * non-user entry — so pointing it at a turn's last entry expresses exactly
+	 * the protocol's meaning.
+	 *
+	 * The first user entry is recorded under the empty key: navigating to it
+	 * lands the leaf on its parent, which is `null`, which is how "clear
+	 * everything" is expressed.
+	 */
+	readonly anchors: ReadonlyMap<string, string>;
+}
+
+/** Key under which the whole-conversation anchor is stored. */
+export const CLEAR_ALL_ANCHOR = "";
+
+/**
+ * Converts session entries into completed turns.
+ *
+ * Turn boundaries come from user messages: each one opens a turn that absorbs
+ * every assistant message and tool result until the next. That mirrors the live
+ * mapper, where a turn spans everything from one prompt to `agent_settled`.
+ */
+function rebuildTurns(entries: readonly SessionEntry[], options: RebuildOptions = {}): Turn[] {
+	return rebuildHistory(entries, options).turns;
+}
+
+/** As {@link rebuildTurns}, but also reporting each turn's truncation anchor. */
+export function rebuildHistory(entries: readonly SessionEntry[], options: RebuildOptions = {}): RebuiltHistory {
+	const prefix = options.turnIdPrefix ?? "turn";
+	const turns: Turn[] = [];
+	const anchors = new Map<string, string>();
+	/** The entry most recently folded into the turn being built. */
+	let lastEntryId: string | undefined;
+	let current: PendingTurn | undefined;
+	/** toolCallId → index in `current.parts`, so a result can find its call. */
+	let toolCallParts = new Map<string, number>();
+
+	const closeTurn = (): void => {
+		if (!current) {
+			return;
+		}
+		if (lastEntryId) {
+			anchors.set(current.id, lastEntryId);
+		}
+		turns.push({
+			id: current.id,
+			startedAt: current.startedAt,
+			message: current.message,
+			responseParts: current.parts,
+			usage: current.usage,
+			state: TurnState.Complete,
+		});
+		current = undefined;
+		toolCallParts = new Map();
+	};
+
+	const openTurn = (id: string, startedAt: string, message: Message): void => {
+		closeTurn();
+		current = { id, startedAt, message, parts: [], usage: undefined };
+	};
+
+	for (const entry of entries) {
+		if (entry.type === "message" && (entry.message as unknown as StoredMessage).role === "user") {
+			anchors.set(CLEAR_ALL_ANCHOR, anchors.get(CLEAR_ALL_ANCHOR) ?? entry.id);
+		}
+
+		if (entry.type === "compaction") {
+			// The summary replaces everything before it. Surfacing it as a turn
+			// of its own tells the user why the history starts where it does.
+			closeTurn();
+			turns.push({
+				id: `${prefix}-compaction-${entry.id}`,
+				startedAt: entry.timestamp,
+				message: { text: "", origin: { kind: MessageKind.User } },
+				responseParts: [
+					{
+						kind: ResponsePartKind.SystemNotification,
+						content: `Conversation compacted.\n\n${entry.summary}`,
+					},
+				],
+				usage: undefined,
+				state: TurnState.Complete,
+			});
+			continue;
+		}
+
+		if (entry.type !== "message") {
+			// Model / thinking-level changes and labels carry no transcript.
+			continue;
+		}
+
+		const message = entry.message as unknown as StoredMessage;
+		switch (message.role) {
+			case "user": {
+				openTurn(`${prefix}-${entry.id}`, entry.timestamp, userMessageFromPiContent(message.content));
+				break;
+			}
+
+			case "assistant": {
+				if (!current) {
+					// An assistant message with no preceding user message (a
+					// truncated file, or history that starts mid-turn). Give it a
+					// turn so the content is not dropped.
+					openTurn(`${prefix}-${entry.id}`, entry.timestamp, userMessageFromPiContent(""));
+				}
+				const turn = current as PendingTurn;
+				let index = 0;
+				for (const block of blocksOf(message)) {
+					if (block.type === "text" && block.text) {
+						turn.parts.push({
+							kind: ResponsePartKind.Markdown,
+							id: `${turn.id}:${entry.id}:${index}`,
+							content: block.text,
+						});
+					} else if (block.type === "thinking" && block.thinking) {
+						turn.parts.push({
+							kind: ResponsePartKind.Reasoning,
+							id: `${turn.id}:${entry.id}:${index}`,
+							content: block.thinking,
+						});
+					} else if (block.type === "toolCall" && block.id) {
+						toolCallParts.set(block.id, turn.parts.length);
+						turn.parts.push({
+							kind: ResponsePartKind.ToolCall,
+							toolCall: {
+								status: ToolCallStatus.Running,
+								toolCallId: block.id,
+								toolName: block.name ?? "tool",
+								displayName: block.name ?? "tool",
+								invocationMessage: block.name ?? "tool",
+								toolInput: block.arguments === undefined ? undefined : JSON.stringify(block.arguments),
+								confirmed: "setting",
+							} as never,
+						});
+					}
+					index += 1;
+				}
+				turn.usage = toUsage(message) ?? turn.usage;
+				break;
+			}
+
+			case "toolResult": {
+				const partIndex = message.toolCallId ? toolCallParts.get(message.toolCallId) : undefined;
+				if (!current || partIndex === undefined) {
+					break;
+				}
+				const existing = current.parts[partIndex] as { toolCall: Record<string, unknown> } | undefined;
+				if (!existing) {
+					break;
+				}
+				const text = plainText(message);
+				const success = message.isError !== true;
+				current.parts[partIndex] = {
+					kind: ResponsePartKind.ToolCall,
+					toolCall: {
+						...existing.toolCall,
+						status: ToolCallStatus.Completed,
+						success,
+						pastTenseMessage: success ? `Ran ${message.toolName ?? "tool"}` : `${message.toolName ?? "tool"} failed`,
+						...(text ? { content: textContent(text) } : {}),
+					},
+				} as ResponsePart;
+				break;
+			}
+
+			case "bashExecution": {
+				// pi records `!command` runs as their own message role; they are
+				// part of the transcript even though no model produced them.
+				if (!current) {
+					openTurn(`${prefix}-${entry.id}`, entry.timestamp, userMessageFromPiContent(`!${message.command ?? ""}`));
+				}
+				(current as PendingTurn).parts.push({
+					kind: ResponsePartKind.SystemNotification,
+					content: `\`${message.command ?? ""}\`\n\n${message.output ?? ""}`,
+				});
+				break;
+			}
+
+			default:
+				break;
+		}
+
+		// Recorded after the entry has been folded in, so a user message that
+		// opens a new turn does not become the previous turn's anchor.
+		lastEntryId = entry.id;
+	}
+
+	closeTurn();
+	return { turns, anchors };
+}
+
+/** Rebuilds the turns of a session file, using the same window pi's TUI shows. */
+export function rebuildTurnsFromSession(manager: SessionManager, options: RebuildOptions = {}): Turn[] {
+	return rebuildTurns(manager.buildContextEntries(), options);
+}
+
+/** As {@link rebuildTurnsFromSession}, with truncation anchors. */
+export function rebuildHistoryFromSession(manager: SessionManager, options: RebuildOptions = {}): RebuiltHistory {
+	return rebuildHistory(manager.buildContextEntries(), options);
+}

package/proof/oracle/src/pi/image-input.ts

@@ -0,0 +1,56 @@
+/**
+ * Normalizes client-provided images before they enter a pi AgentSession.
+ *
+ * AgentSession accepts already-prepared ImageContent blocks; pi's CLI performs
+ * conversion and resizing one layer earlier. This host is another input layer,
+ * so it applies the same public image utilities and honours pi's auto-resize
+ * setting rather than relying on every AHP client to know provider limits.
+ */
+
+import type { ImageContent } from "@earendil-works/pi-ai";
+import { convertToPng, resizeImage } from "@earendil-works/pi-coding-agent";
+import { normalizeImageMimeType } from "./image-mime.ts";
+
+const SUPPORTED_INLINE_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+
+async function prepareImage(image: ImageContent, autoResize: boolean, index: number): Promise<ImageContent> {
+	let data = image.data;
+	let mimeType = normalizeImageMimeType(image.mimeType);
+	if (!mimeType) {
+		throw new Error(`Image ${index + 1} has an invalid MIME type: ${image.mimeType}`);
+	}
+
+	if (!SUPPORTED_INLINE_TYPES.has(mimeType)) {
+		const converted = await convertToPng(data, mimeType);
+		if (!converted) {
+			throw new Error(`Image ${index + 1} could not be converted from ${mimeType}`);
+		}
+		data = converted.data;
+		mimeType = converted.mimeType;
+	}
+
+	if (!autoResize) {
+		return { type: "image", data, mimeType };
+	}
+
+	const resized = await resizeImage(Buffer.from(data, "base64"), mimeType);
+	if (!resized) {
+		throw new Error(`Image ${index + 1} could not be prepared for inline model input`);
+	}
+	return { type: "image", data: resized.data, mimeType: resized.mimeType };
+}
+
+/** Processes sequentially so several large images do not start several WASM workers at once. */
+export async function prepareImagesForPi(
+	images: readonly ImageContent[] | undefined,
+	autoResize: boolean,
+): Promise<ImageContent[] | undefined> {
+	if (!images || images.length === 0) {
+		return undefined;
+	}
+	const prepared: ImageContent[] = [];
+	for (const [index, image] of images.entries()) {
+		prepared.push(await prepareImage(image, autoResize, index));
+	}
+	return prepared;
+}

package/proof/oracle/src/pi/image-mime.ts

@@ -0,0 +1,8 @@
+/** Normalizes MIME values at the AHP/pi image boundary. */
+export function normalizeImageMimeType(mimeType: string): string | undefined {
+	const base = mimeType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+	if (!base.startsWith("image/")) {
+		return undefined;
+	}
+	return base === "image/jpg" ? "image/jpeg" : base;
+}

package/proof/oracle/src/pi/in-process-backend.ts

@@ -0,0 +1,155 @@
+/**
+ * The in-process pi backend.
+ *
+ * Embeds `AgentSession` directly rather than spawning `pi --mode rpc`, reusing
+ * pi's SDK services and configuration. A subprocess would add process lifecycle
+ * and stdio backpressure without isolating provider credentials or user
+ * resources. The narrow {@link PiBackend} seam keeps those concerns out of the
+ * mapper and chat driver.
+ *
+ * @see ../pi/chat-driver.ts for how a backend is driven
+ */
+
+import type { ImageContent } from "@earendil-works/pi-ai";
+import {
+	type AgentSession,
+	type AgentSessionEvent,
+	createAgentSessionFromServices,
+	createAgentSessionServices,
+	type SessionManager,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { ModelSelection } from "@microsoft/agent-host-protocol";
+import type { PiBackend } from "./chat-driver.ts";
+import { prepareImagesForPi } from "./image-input.ts";
+import { findModelBySelectionId, modelSelectionId, THINKING_CONFIG_KEY } from "./models.ts";
+import { type ProjectTrustPolicy, resolveProjectTrust, type TrustDecision } from "./project-trust.ts";
+
+export interface InProcessBackendOptions {
+	readonly cwd: string;
+	/** Reuses the session manager the host already allocated, so ids line up. */
+	readonly sessionManager: SessionManager;
+	/** How to treat project-local pi resources. Defaults to `trust`. */
+	readonly projectTrustPolicy?: ProjectTrustPolicy;
+}
+
+/**
+ * Wraps an `AgentSession` in the narrow surface the driver needs.
+ *
+ * `AgentSession.prompt()` spans the full run. The driver tracks that promise
+ * without blocking action routing, while session events stream protocol state
+ * and `abort()` remains available for cancellation.
+ */
+export class InProcessPiBackend implements PiBackend {
+	readonly #session: AgentSession;
+	readonly #trust: TrustDecision;
+
+	private constructor(session: AgentSession, trust: TrustDecision) {
+		this.#session = session;
+		this.#trust = trust;
+	}
+
+	/** How project trust was resolved, so the host can report it to clients. */
+	get projectTrust(): TrustDecision {
+		return this.#trust;
+	}
+
+	static async create(options: InProcessBackendOptions): Promise<InProcessPiBackend> {
+		// SDK session construction defaults projectTrusted to true and does not run
+		// the CLI's trust prompt, so pass this host's decision explicitly.
+		const trust = resolveProjectTrust(options.cwd, options.projectTrustPolicy);
+		const services = await createAgentSessionServices({
+			cwd: options.cwd,
+			settingsManager: SettingsManager.create(options.cwd, undefined, { projectTrusted: trust.trusted }),
+		});
+		const { session } = await createAgentSessionFromServices({ services, sessionManager: options.sessionManager });
+		return new InProcessPiBackend(session, trust);
+	}
+
+	get session(): AgentSession {
+		return this.#session;
+	}
+
+	subscribe(listener: (event: AgentSessionEvent) => void): () => void {
+		return this.#session.subscribe(listener);
+	}
+
+	async prompt(text: string, images?: ImageContent[], signal?: AbortSignal): Promise<void> {
+		if (signal?.aborted) {
+			return;
+		}
+		const prepared = await prepareImagesForPi(images, this.#session.settingsManager.getImageAutoResize());
+		if (signal?.aborted) {
+			return;
+		}
+		await this.#session.prompt(text, prepared ? { images: prepared } : undefined);
+	}
+
+	async steer(text: string, images?: ImageContent[], signal?: AbortSignal): Promise<void> {
+		if (signal?.aborted) {
+			return;
+		}
+		const prepared = await prepareImagesForPi(images, this.#session.settingsManager.getImageAutoResize());
+		if (signal?.aborted) {
+			return;
+		}
+		await this.#session.steer(text, prepared);
+	}
+
+	async abort(): Promise<void> {
+		await this.#session.abort();
+	}
+
+	/**
+	 * Applies a per-message model selection.
+	 *
+	 * The reasoning effort rides in `config` under the key the model's own
+	 * `configSchema` advertises, so a client that rendered that schema sends
+	 * back exactly what it was offered.
+	 */
+	async selectModel(selection: ModelSelection): Promise<void> {
+		const available = await this.#session.modelRuntime.getAvailable();
+		const current = this.#session.model;
+		const model = findModelBySelectionId(available, selection.id, current);
+		if (!model) {
+			// A stale pick from a client whose model list predates a credential
+			// change. Running on the current model beats failing the turn.
+			return;
+		}
+		if (!current || current.id !== model.id || current.provider !== model.provider) {
+			await this.#session.setModel(model as never);
+		}
+
+		const level = selection.config?.[THINKING_CONFIG_KEY];
+		if (typeof level === "string" && this.#session.getAvailableThinkingLevels().includes(level as never)) {
+			this.#session.setThinkingLevel(level as never);
+		}
+	}
+
+	/**
+	 * Moves the leaf back to `entryId`, dropping everything after it.
+	 *
+	 * pi's sessions are append-only trees: nothing is deleted, the leaf simply
+	 * moves and later appends form a new branch. `buildSessionContext` follows
+	 * leaf→root, so the abandoned path stops being context — which is exactly
+	 * what the protocol means by truncation. `navigateTree` also resyncs the
+	 * agent's in-memory messages, so no reload is needed.
+	 */
+	async truncate(entryId: string): Promise<boolean> {
+		const result = await this.#session.navigateTree(entryId);
+		return !result.cancelled;
+	}
+
+	/** What a new message would run on right now. */
+	currentSelection(): ModelSelection | undefined {
+		const model = this.#session.model;
+		if (!model) {
+			return undefined;
+		}
+		return { id: modelSelectionId(model), config: { [THINKING_CONFIG_KEY]: this.#session.thinkingLevel } };
+	}
+
+	dispose(): void {
+		this.#session.dispose();
+	}
+}