@narumitw/pi-codex-compact 0.51.3 → 0.52.0

package/src/codex-compact.ts

@@ -18,7 +18,7 @@ import {
 	latestCheckpoint,
 	projectCheckpointContext,
 } from "./checkpoint.js";
-import { usesCodexResponsesApi } from "./model-api.js";
+import { resolveCompactionRoute, usesResponsesCompactionApi } from "./model-api.js";
 import { hasCheckpointMarker, rewriteCheckpointMarker } from "./protocol.js";
 import { requestRemoteCompaction } from "./remote.js";
 import {
@@ -27,6 +27,7 @@ import {
 	type CodexCompactSettingsState,
 	createCodexCompactSettingsRuntime,
 } from "./settings.js";
+import { terminalText } from "./terminal.js";
 
 const STATUS_KEY = "codex-compact";
 
@@ -37,8 +38,10 @@ function activeCheckpoint(ctx: ExtensionContext) {
 function isCheckpointCompatible(
 	details: CodexCheckpointDetails,
 	model: Model<Api> | undefined,
-): model is Model<"openai-codex-responses"> {
-	return usesCodexResponsesApi(model) && model.id === details.modelId;
+): boolean {
+	return (
+		usesResponsesCompactionApi(model) && model.api === details.api && model.id === details.modelId
+	);
 }
 
 function keptMessages(event: SessionBeforeCompactEvent): AgentMessage[] {
@@ -54,27 +57,31 @@ function keptMessages(event: SessionBeforeCompactEvent): AgentMessage[] {
 }
 
 function activeTools(pi: ExtensionAPI): Tool[] {
-	const enabled = new Set(pi.getActiveTools());
-	return pi
-		.getAllTools()
-		.filter((tool) => enabled.has(tool.name))
-		.map((tool) => ({
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters,
-		}));
+	const available = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
+	return pi.getActiveTools().flatMap((name) => {
+		const tool = available.get(name);
+		return tool
+			? [
+					{
+						name: tool.name,
+						description: tool.description,
+						parameters: tool.parameters,
+					},
+				]
+			: [];
+	});
 }
 
 function projectedCurrentMessages(
 	event: SessionBeforeCompactEvent,
-	model: Model<"openai-codex-responses">,
+	model: Model<Api>,
 ): { messages: AgentMessage[]; prior?: CodexCheckpointDetails } {
 	const leafId = event.branchEntries.at(-1)?.id ?? null;
 	const session = buildSessionContext(event.branchEntries, leafId);
 	const prior = latestCheckpoint(event.branchEntries);
 	if (!prior) return { messages: session.messages };
-	if (prior.details.modelId !== model.id) {
-		throw new Error("The active opaque checkpoint belongs to a different Codex model");
+	if (prior.details.api !== model.api || prior.details.modelId !== model.id) {
+		throw new Error("The active opaque checkpoint belongs to a different Responses model");
 	}
 	const projected = projectCheckpointContext(session.messages, prior.details, prior.entry.summary);
 	if (!projected) {
@@ -89,8 +96,8 @@ function notifyFailure(
 	settings: CodexCompactSettings,
 ): void {
 	if (!ctx.hasUI || !settings.notifyOnFallback) return;
-	const message = error instanceof Error ? error.message : String(error);
-	ctx.ui.notify(`Codex remote compaction failed; using Pi compaction. ${message}`, "warning");
+	const message = terminalText(error instanceof Error ? error.message : String(error));
+	ctx.ui.notify(`Responses compaction failed; using Pi compaction. ${message}`, "warning");
 }
 
 function sessionStillOwned(ctx: ExtensionContext, sessionId: string, signal: AbortSignal): boolean {
@@ -102,18 +109,25 @@ async function compactRemotely(
 	event: SessionBeforeCompactEvent,
 	ctx: ExtensionContext,
 	settings: CodexCompactSettings,
+	ownerSignal: AbortSignal,
 	fetch?: typeof globalThis.fetch,
 ) {
 	const model = ctx.model;
-	if (!settings.enabled || !usesCodexResponsesApi(model)) return undefined;
+	const route = resolveCompactionRoute(model, settings);
+	if (route.kind === "native" || !usesResponsesCompactionApi(model)) return undefined;
+	const signal = AbortSignal.any([event.signal, ownerSignal]);
+	if (signal.aborted) return { cancel: true };
 	const sessionId = ctx.sessionManager.getSessionId();
-	ctx.ui.setStatus(STATUS_KEY, "Codex remote compaction…");
+	ctx.ui.setStatus(
+		STATUS_KEY,
+		route.protocol === "remote-v2" ? "Responses Remote V2…" : "Responses Compact API…",
+	);
 	try {
 		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
+		if (!sessionStillOwned(ctx, sessionId, signal)) return { cancel: true };
 		if (!auth.ok) throw new Error(auth.error);
 		const provider = ctx.modelRegistry.getProvider(model.provider);
-		if (!provider) throw new Error("The active Codex Responses provider is unavailable");
+		if (!provider) throw new Error("The active Responses provider is unavailable");
 		const current = projectedCurrentMessages(event, model);
 		const context: Context = {
 			systemPrompt: ctx.getSystemPrompt(),
@@ -124,10 +138,11 @@ async function compactRemotely(
 			provider,
 			model,
 			context,
+			protocol: route.protocol,
 			apiKey: auth.apiKey,
 			headers: auth.headers,
 			env: auth.env,
-			signal: event.signal,
+			signal,
 			priorCheckpoint: current.prior
 				? {
 						marker: checkpointMarker(current.prior.checkpointId),
@@ -138,13 +153,17 @@ async function compactRemotely(
 			maxRetries: settings.maxRetries,
 			fetch,
 		});
-		if (!sessionStillOwned(ctx, sessionId, event.signal)) return { cancel: true };
-		const replacementHistory = buildReplacementHistory(response.promptInput, response.item, {
-			tokenBudget: settings.replacementTokenBudget,
-		});
+		if (!sessionStillOwned(ctx, sessionId, signal)) return { cancel: true };
+		const replacementHistory = buildReplacementHistory(
+			response.compactedOutput?.slice(0, -1) ?? response.promptInput,
+			response.item,
+			{ tokenBudget: settings.replacementTokenBudget },
+		);
 		const details = createCheckpointDetails({
 			provider: model.provider,
+			api: route.api,
 			modelId: model.id,
+			protocol: route.protocol,
 			replacementHistory,
 			keptMessages: keptMessages(event),
 		});
@@ -158,7 +177,7 @@ async function compactRemotely(
 			},
 		};
 	} catch (error) {
-		if (event.signal.aborted || ctx.sessionManager.getSessionId() !== sessionId) {
+		if (signal.aborted || ctx.sessionManager.getSessionId() !== sessionId) {
 			return { cancel: true };
 		}
 		notifyFailure(ctx, error, settings);
@@ -178,8 +197,9 @@ export function createCodexCompactExtension(
 		let generation = 0;
 
 		pi.registerCommand("codex-compact", {
-			description: "Compact now or configure Codex Remote Compaction V2",
-			handler: async (_args, ctx) => {
+			description: "Compact now or configure Responses compaction",
+			handler: async (args, ctx) => {
+				if (args.trim()) throw new Error("Usage: /codex-compact");
 				const ownerGeneration = generation;
 				const controller = sessionController;
 				const { showCodexCompactMenu } = await import("./settings-menu.js");
@@ -205,7 +225,7 @@ export function createCodexCompactExtension(
 				if (sessionController.signal.aborted || ownerGeneration !== generation) return;
 				if (ctx.hasUI) {
 					ctx.ui.notify(
-						`Could not load pi-codex-compact.json; using defaults. ${error instanceof Error ? error.message : String(error)}`,
+						`Could not load pi-codex-compact.json; using defaults. ${terminalText(error instanceof Error ? error.message : String(error))}`,
 						"warning",
 					);
 				}
@@ -220,14 +240,21 @@ export function createCodexCompactExtension(
 			}
 			if (ctx.hasUI && state.kind === "invalid") {
 				ctx.ui.notify(
-					`Invalid pi-codex-compact.json; using defaults without overwriting it. ${state.issue}`,
+					`Invalid pi-codex-compact.json; using defaults without overwriting it. ${terminalText(state.issue ?? "unknown validation error")}`,
 					"warning",
 				);
 			}
 		});
 
 		pi.on("session_before_compact", (event, ctx) =>
-			compactRemotely(pi, event, ctx, settingsRuntime.get().settings, options.fetch),
+			compactRemotely(
+				pi,
+				event,
+				ctx,
+				settingsRuntime.get().settings,
+				sessionController.signal,
+				options.fetch,
+			),
 		);
 
 		pi.on("context", (event, ctx) => {
@@ -260,7 +287,7 @@ export function createCodexCompactExtension(
 			providerWarnings.add(key);
 			if (ctx.hasUI) {
 				ctx.ui.notify(
-					"The active Codex checkpoint cannot replay on this model; Pi will expose only its fallback marker and retained recent messages.",
+					"The active Responses checkpoint cannot replay on this model; Pi will expose only its fallback marker and retained recent messages.",
 					"warning",
 				);
 			}

package/src/model-api.ts

@@ -1,8 +1,48 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { hasApi } from "@earendil-works/pi-ai";
 
-export function usesCodexResponsesApi(
+export const RESPONSES_COMPACTION_APIS = [
+	"openai-codex-responses",
+	"openai-responses",
+	"azure-openai-responses",
+] as const;
+
+export type ResponsesCompactionApi = (typeof RESPONSES_COMPACTION_APIS)[number];
+export type RemoteCompactionProtocol = "remote-v2" | "responses-compact";
+export type RemoteCompactionProtocolSetting = "auto" | RemoteCompactionProtocol;
+
+export type CompactionRoute =
+	| { kind: "remote"; protocol: RemoteCompactionProtocol; api: ResponsesCompactionApi }
+	| { kind: "native"; reason: string };
+
+export function usesResponsesCompactionApi(
+	model: Model<Api> | undefined,
+): model is Model<ResponsesCompactionApi> {
+	return model !== undefined && RESPONSES_COMPACTION_APIS.some((api) => hasApi(model, api));
+}
+
+export function resolveCompactionRouteForApi(
+	api: Api | undefined,
+	options: { enabled: boolean; protocol: RemoteCompactionProtocolSetting },
+): CompactionRoute {
+	if (!options.enabled) return { kind: "native", reason: "remote compaction is disabled" };
+	if (!api) return { kind: "native", reason: "no active model" };
+	if (!RESPONSES_COMPACTION_APIS.includes(api as ResponsesCompactionApi)) {
+		return { kind: "native", reason: `API ${api} does not support Responses compaction` };
+	}
+	const supportedApi = api as ResponsesCompactionApi;
+	const protocol =
+		options.protocol === "auto"
+			? supportedApi === "openai-codex-responses"
+				? "remote-v2"
+				: "responses-compact"
+			: options.protocol;
+	return { kind: "remote", protocol, api: supportedApi };
+}
+
+export function resolveCompactionRoute(
 	model: Model<Api> | undefined,
-): model is Model<"openai-codex-responses"> {
-	return model !== undefined && hasApi(model, "openai-codex-responses");
+	options: { enabled: boolean; protocol: RemoteCompactionProtocolSetting },
+): CompactionRoute {
+	return resolveCompactionRouteForApi(model?.api, options);
 }

package/src/protocol.ts

@@ -1,4 +1,5 @@
 export const MAX_SSE_BYTES = 8 * 1024 * 1024;
+export const MAX_COMPACT_JSON_BYTES = 8 * 1024 * 1024;
 export const MAX_COMPACTION_ITEM_BYTES = 2 * 1024 * 1024;
 
 export type JsonObject = Record<string, unknown>;
@@ -47,6 +48,12 @@ export interface CollectedCompaction {
 	completedResponse?: JsonObject;
 }
 
+export interface CollectedCompactResponse {
+	item: JsonObject;
+	output: JsonObject[];
+	response: JsonObject;
+}
+
 function compactionItemsFromEvent(event: JsonObject): unknown[] {
 	const items: unknown[] = [];
 	if (event.type === "response.output_item.done" && isObject(event.item)) {
@@ -156,6 +163,147 @@ export async function collectCompactionSse(
 	return { item: [...items.values()][0], completedResponse };
 }
 
+function isRetainedCompactContent(value: unknown): value is JsonObject {
+	if (!isObject(value)) return false;
+	if (value.type === "input_text") return typeof value.text === "string";
+	if (value.type !== "input_image") return false;
+	if (
+		value.detail !== undefined &&
+		value.detail !== null &&
+		value.detail !== "auto" &&
+		value.detail !== "low" &&
+		value.detail !== "high" &&
+		value.detail !== "original"
+	) {
+		return false;
+	}
+	if (
+		(value.file_id !== undefined && value.file_id !== null && typeof value.file_id !== "string") ||
+		(value.image_url !== undefined &&
+			value.image_url !== null &&
+			typeof value.image_url !== "string")
+	) {
+		return false;
+	}
+	return (
+		(typeof value.file_id === "string" && value.file_id.length > 0) ||
+		(typeof value.image_url === "string" && value.image_url.length > 0)
+	);
+}
+
+function isRetainedCompactMessage(value: unknown): value is JsonObject {
+	return (
+		isObject(value) &&
+		value.role === "user" &&
+		(value.type === undefined || value.type === "message") &&
+		Array.isArray(value.content) &&
+		value.content.length > 0 &&
+		value.content.every(isRetainedCompactContent)
+	);
+}
+
+export function validateCompactedResponse(
+	value: unknown,
+	options: { maxBytes?: number; maxItemBytes?: number } = {},
+): CollectedCompactResponse {
+	if (!isObject(value) || !Array.isArray(value.output)) {
+		throw new CodexCompactionProtocolError("Responses Compact returned an invalid response object");
+	}
+	const maxBytes = options.maxBytes ?? MAX_COMPACT_JSON_BYTES;
+	const maxItemBytes = options.maxItemBytes ?? MAX_COMPACTION_ITEM_BYTES;
+	if (byteLength(value) > maxBytes) {
+		throw new CodexCompactionProtocolError("Responses Compact response exceeded the size limit");
+	}
+	if (value.output.length === 0) {
+		throw new CodexCompactionProtocolError("Responses Compact returned no output items");
+	}
+	const output = value.output.map((item) => {
+		if (!isObject(item)) {
+			throw new CodexCompactionProtocolError("Responses Compact returned a non-object output item");
+		}
+		if (byteLength(item) > maxItemBytes) {
+			throw new CodexCompactionProtocolError(
+				"Responses Compact output item exceeded the size limit",
+			);
+		}
+		return structuredClone(item);
+	});
+	const compactionItems = output.filter((item) => item.type === "compaction");
+	if (compactionItems.length !== 1 || output.at(-1)?.type !== "compaction") {
+		throw new CodexCompactionProtocolError(
+			"Responses Compact must return retained messages followed by one compaction item",
+		);
+	}
+	for (const item of output.slice(0, -1)) {
+		if (!isRetainedCompactMessage(item)) {
+			throw new CodexCompactionProtocolError(
+				"Responses Compact returned an unsupported retained output item",
+			);
+		}
+	}
+	const item = validateCompactionItem(output.at(-1), maxItemBytes);
+	return { item, output: [...output.slice(0, -1), item], response: structuredClone(value) };
+}
+
+export async function collectCompactResponse(
+	response: Response,
+	options: { signal?: AbortSignal; maxBytes?: number; maxItemBytes?: number } = {},
+): Promise<CollectedCompactResponse> {
+	const maxBytes = options.maxBytes ?? MAX_COMPACT_JSON_BYTES;
+	const declaredLength = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+		const error = new CodexCompactionProtocolError(
+			"Responses Compact response exceeded the size limit",
+		);
+		await response.body?.cancel(error).catch(() => undefined);
+		throw error;
+	}
+	if (!response.body) {
+		throw new CodexCompactionProtocolError("Responses Compact response did not contain a body");
+	}
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let bytes = 0;
+	const onAbort = () => {
+		void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => undefined);
+	};
+	options.signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			if (options.signal?.aborted) throw new DOMException("Compaction aborted", "AbortError");
+			const { done, value } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > maxBytes) {
+				throw new CodexCompactionProtocolError(
+					"Responses Compact response exceeded the size limit",
+				);
+			}
+			chunks.push(value);
+		}
+		if (options.signal?.aborted) throw new DOMException("Compaction aborted", "AbortError");
+	} catch (error) {
+		await reader.cancel(error).catch(() => undefined);
+		throw error;
+	} finally {
+		options.signal?.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+	const body = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(new TextDecoder().decode(body));
+	} catch {
+		throw new CodexCompactionProtocolError("Responses Compact returned malformed JSON");
+	}
+	return validateCompactedResponse(parsed, options);
+}
+
 function markerTextFromItem(item: unknown): string | undefined {
 	if (!isObject(item) || item.role !== "user" || !Array.isArray(item.content)) return undefined;
 	if (item.content.length !== 1) return undefined;
@@ -205,14 +353,24 @@ export function appendCompactionTrigger(payload: unknown): JsonObject {
 	return { ...payload, input: [...payload.input, { type: "compaction_trigger" }] };
 }
 
+export function expandRemoteCompactionPayload(
+	payload: unknown,
+	checkpoint?: { marker: string; replacementHistory: readonly unknown[] },
+): JsonObject {
+	if (checkpoint) {
+		return rewriteCheckpointMarker(payload, checkpoint.marker, checkpoint.replacementHistory);
+	}
+	if (!isObject(payload) || !Array.isArray(payload.input)) {
+		throw new CodexCompactionProtocolError("Responses payload is missing an input array");
+	}
+	return structuredClone(payload);
+}
+
 export function prepareRemoteCompactionPayload(
 	payload: unknown,
 	checkpoint?: { marker: string; replacementHistory: readonly unknown[] },
 ): JsonObject {
-	const expanded = checkpoint
-		? rewriteCheckpointMarker(payload, checkpoint.marker, checkpoint.replacementHistory)
-		: payload;
-	return appendCompactionTrigger(expanded);
+	return appendCompactionTrigger(expandRemoteCompactionPayload(payload, checkpoint));
 }
 
 export function hasCheckpointMarker(payload: unknown, marker: string): boolean {