/** Maps omp's per-step transcript onto one stateful agy turn. */ import { createHash } from "node:crypto"; import { prompt, stableStringifyJson } from "@oh-my-pi/pi-utils"; import type { ContentBlock } from "@oh-my-pi/pi-utils/acp"; import type { AntigravityCliCheckpoint, DeveloperMessage, ImageContent, Message, TextContent, ToolResultMessage, UserMessage, } from "../../types"; import lateToolResultTemplate from "./late-tool-result.md" with { type: "text" }; import transcriptTemplate from "./transcript.md" with { type: "text" }; /** The exact leading transcript represented by the live conversation. */ export interface Ledger { count: number; digest: string; pendingToolCallId?: string; } /** New user-side input for agy. */ export type InputMessage = UserMessage | DeveloperMessage; export type TurnPlan = | { kind: "resume"; toolResult?: ToolResultMessage; input: InputMessage[] } | { kind: "restore"; conversationId: string; digest: string; checkpoint: AntigravityCliCheckpoint; replay: Message[]; } | { kind: "fresh"; replay: Message[] }; /** Reuse only an exact visible prefix; otherwise fork a recorded turn end or reseed. */ export function planTurn(messages: readonly Message[], ledger: Ledger | undefined): TurnPlan { if ( ledger && messages.length > ledger.count && transcriptDigest(messages.slice(0, ledger.count)) === ledger.digest ) { const tail = messages.slice(ledger.count); const first = tail[0]; const toolResult = ledger.pendingToolCallId !== undefined && first?.role === "toolResult" && first.toolCallId === ledger.pendingToolCallId ? first : undefined; const input = toolResult ? tail.slice(1) : tail; if ((ledger.pendingToolCallId === undefined || toolResult) && input.every(isInputMessage)) { return { kind: "resume", toolResult, input }; } } for (let index = messages.length - 1; index >= 0; index--) { const message = messages[index]; if (message?.role !== "assistant") continue; const payload = message.providerPayload; if (payload?.type !== "antigravityCli" || !payload.checkpoint) continue; if (transcriptDigest(messages.slice(0, index + 1)) !== payload.digest) continue; return { kind: "restore", conversationId: payload.conversationId, digest: payload.digest, checkpoint: payload.checkpoint, replay: messages.slice(index + 1), }; } return { kind: "fresh", replay: [...messages] }; } /** Fingerprint model-visible ordered content, excluding timestamps, usage and presentation metadata. */ export function transcriptDigest(messages: readonly Message[]): string { const hash = createHash("sha256"); for (const message of messages) { hash.update(stableStringifyJson(messageContent(message))); hash.update("\n"); } return hash.digest("hex"); } /** Replay earlier turns as labelled text and image blocks, then send trailing input directly. */ export function replayPrompt(replay: readonly Message[]): ContentBlock[] { let split = replay.length; while (split > 0 && isInputMessage(replay[split - 1]!)) split--; const blocks: ContentBlock[] = []; if (split > 0) { blocks.push({ type: "text", text: prompt.render(transcriptTemplate, {}) }); for (const message of replay.slice(0, split)) { const tag = message.role === "toolResult" ? "tool_result" : message.role; const attrs = message.role === "toolResult" ? ` id=${JSON.stringify(message.toolCallId)} name=${JSON.stringify(message.toolName)} error=${message.isError}` : ""; blocks.push({ type: "text", text: `<${tag}${attrs}>` }); if (typeof message.content === "string") blocks.push({ type: "text", text: message.content }); else for (const part of message.content) { switch (part.type) { case "text": blocks.push({ type: "text", text: part.text }); break; case "image": blocks.push({ type: "image", data: part.data, mimeType: part.mimeType }); break; case "thinking": blocks.push({ type: "text", text: `${part.thinking}` }); break; case "toolCall": blocks.push({ type: "text", text: `${stableStringifyJson(part.arguments)}`, }); break; } } blocks.push({ type: "text", text: `` }); } blocks.push({ type: "text", text: "" }); } for (const message of replay.slice(split)) { if (isInputMessage(message)) blocks.push(...inputBlocks(message)); } return blocks; } /** Supply the actual delayed result only after agy's old prompt has confirmed cancellation. */ export function lateToolResultPrompt(result: ToolResultMessage): ContentBlock[] { return [ { type: "text", text: prompt.render(lateToolResultTemplate, { toolName: result.toolName, toolCallId: result.toolCallId, isError: result.isError, }), }, ...contentBlocks(result.content), { type: "text", text: "" }, ]; } /** ACP input preserves text/image ordering and the complete image bytes. */ export function inputBlocks(message: InputMessage): ContentBlock[] { return contentBlocks(message.content); } /** Whether a transcript message can be sent directly as ACP user input. */ export function isInputMessage(message: Message): message is InputMessage { return message.role === "user" || message.role === "developer"; } function contentBlocks(content: string | readonly (TextContent | ImageContent)[]): ContentBlock[] { if (typeof content === "string") return [{ type: "text", text: content }]; return content.map(part => part.type === "text" ? { type: "text", text: part.text } : { type: "image", data: part.data, mimeType: part.mimeType }, ); } function messageContent(message: Message): unknown { const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content.flatMap((part): unknown[] => { switch (part.type) { case "text": return [{ type: part.type, text: part.text }]; case "image": return [{ type: part.type, data: part.data, mimeType: part.mimeType }]; case "thinking": return [{ type: part.type, thinking: part.thinking }]; case "toolCall": return [{ type: part.type, id: part.id, name: part.name, arguments: part.arguments }]; // Opaque blocks from other providers are not sent to agy. default: return []; } }); return message.role === "toolResult" ? { role: message.role, toolCallId: message.toolCallId, toolName: message.toolName, isError: message.isError, content, } : { role: message.role, content }; }