@howaboua/pi-codex-conversion 1.5.10-dev.39.e39a154 → 1.5.10-dev.41.7e2d8d2

package/README.md

@@ -9,7 +9,7 @@ GPT/Codex models are strongest when the tool surface looks like the Codex CLI th
 
 The point is to give the model tools it already knows how to use well: shell-first inspection, resumable command sessions, and large one-shot patch edits instead of piecemeal read/edit/write steps.
 
-You can also opt into using the adapter on every provider/model. YMMV: Codex-tuned models are still the best fit, but the shell/patch workflow can help elsewhere too. The extension also has a small `/codex` settings UI for toggling adapter behavior, web search, image generation, fast mode, and verbosity. See [Settings](#settings).
+You can also opt into using the adapter on every provider/model. YMMV: Codex-tuned models are still the best fit, but the shell/patch workflow can help elsewhere too. The extension also has a small `/codex` settings UI for toggling adapter behavior, web search, image generation, fast mode, native Responses compaction, and verbosity. See [Settings](#settings).
 
 ## Install
 
@@ -55,6 +55,8 @@ The settings UI also has **Usage**, **Overrides**, and **About** tabs. **Usage**
 
 - add only the Pi `apply_patch` tool for GPT/Codex models while keeping Pi's default toolkit, prompt, provider behavior, and compaction flow
 
+The **Compaction** tab can enable native OpenAI Responses compaction and choose the compaction model/reasoning. If native compaction fails, the extension falls back to Pi's normal compaction flow; when an older native compacted window exists, it is included in that Pi fallback summarization request so OpenAI can still use the prior opaque context server-side.
+
 When `all` is on, non-Codex providers get the shell, patch, skill, and prompt-adapter behavior, but keep their normal Pi provider path. Native web search, native image generation, and priority service tier stay limited to the OpenAI Codex provider. Verbosity is applied to Responses API providers.
 
 The footer shows the active state, for example:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.5.10-dev.39.e39a154",
+  "version": "1.5.10-dev.41.7e2d8d2",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/adapter/compaction.ts

@@ -2,9 +2,9 @@ import type { ExtensionAPI, ExtensionContext, SessionBeforeCompactEvent } from "
 import { clampThinkingLevel, type ModelThinkingLevel, type Tool } from "@earendil-works/pi-ai";
 import { executeNativeCompaction } from "./compact-client.ts";
 import { extractCompactionSummaryText, hasCompactionOutputItem, sanitizeCompactedWindow, summarizeCompactionOutputForDiagnostics } from "./compaction-output.ts";
-import { resolveLatestNativeCompactionEntry } from "./details-store.ts";
+import { findLatestNativeCompactionEntry, findLatestNativeCompactionEntryIndex, resolveLatestNativeCompactionEntry } from "./details-store.ts";
 import { rewriteResponsesPayloadWithNativeReplay, serializeLiveTailToResponsesInput } from "./payload-rewrite.ts";
-import { resolveNativeCompactionEnvironment } from "./compaction-runtime.ts";
+import { isResponsesCompatiblePayload, resolveNativeCompactionEnvironment, type ResponsesCompatibleRequestPayload } from "./compaction-runtime.ts";
 import { convertResponsesTools } from "../providers/openai-responses-shared.ts";
 import {
 	serializeCompactionPreparationToRequest,
@@ -12,7 +12,7 @@ import {
 	type NativeCompactionRequestOptions,
 	type ResponsesInputItem,
 } from "./serializer.ts";
-import { createNativeCompactionDetails, createNativeCompactionShimResult, isNativeCompactionDetails, NATIVE_COMPACTION_SHIM_SUMMARY } from "./types.ts";
+import { createNativeCompactionDetails, createNativeCompactionShimResult, isNativeCompactionDetails, NATIVE_COMPACTION_SHIM_SUMMARY, type NativeCompactionEntry } from "./types.ts";
 import { isOpenAICodexContext, isResponsesContext } from "./codex-model.ts";
 import { shouldUseCodexAdapter } from "./activation.ts";
 import type { AdapterState } from "./state.ts";
@@ -23,6 +23,31 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function stashLatestNativeWindowForPiCompactionFallback(
+	ctx: ExtensionContext,
+	branchEntries: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>,
+	runtime: { provider: string; api: string; baseUrl: string },
+	state: AdapterState,
+): boolean {
+	state.pendingPiCompactionNativeWindow = undefined;
+	const nativeEntry = findLatestNativeCompactionEntry(branchEntries, {
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+	});
+	const compactedWindow = cloneCompactedWindow(nativeEntry?.details?.compactedWindow ?? []);
+	if (!compactedWindow || compactedWindow.length === 0) return false;
+	state.pendingPiCompactionNativeWindow = {
+		window: compactedWindow,
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+		sessionId: ctx.sessionManager.getSessionId(),
+		sourceCompactionEntryId: nativeEntry?.id,
+	};
+	return true;
+}
+
 function cloneCompactedWindow(window: readonly unknown[]): ResponsesInputItem[] | undefined {
 	if (!window.every(isRecord)) return undefined;
 	return window.map((item) => structuredClone(item));
@@ -94,7 +119,7 @@ function formatCompactFailureMessage(compactResult: Awaited<ReturnType<typeof ex
 	const status = compactResult.status ? ` HTTP ${compactResult.status}` : "";
 	const response = compactResult.responseText?.trim();
 	const detail = response ? `: ${response.slice(0, 500)}` : compactResult.errorMessage ? `: ${compactResult.errorMessage}` : "";
-	return `OpenAI native compaction failed (${compactResult.reason}${status})${detail}; Pi compaction was not run.`;
+	return `OpenAI native compaction failed (${compactResult.reason}${status})${detail}`;
 }
 
 function formatCompactRequestDiagnostics(request: NativeCompactionRequestBody): string {
@@ -104,6 +129,11 @@ function formatCompactRequestDiagnostics(request: NativeCompactionRequestBody):
 	return `model=${request.model}, input=${request.input.length}, tools=${tools}, reasoning=${reasoning}, service_tier=${serviceTier}`;
 }
 
+function notifyNativeCompactionFallback(ctx: ExtensionContext, state: AdapterState, branchEntries: ReturnType<ExtensionContext["sessionManager"]["getBranch"]>, runtime: { provider: string; api: string; baseUrl: string }, message: string): void {
+	const stashed = stashLatestNativeWindowForPiCompactionFallback(ctx, branchEntries, runtime, state);
+	ctx.ui.notify(`${message}; Pi compaction will run.${stashed ? " Previous native compacted window will be included in Pi compaction fallback." : ""}`, "error");
+}
+
 export async function handleCodexSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx: ExtensionContext, state: AdapterState, pi: ExtensionAPI) {
 	if (!state.config.responsesCompaction || !shouldUseCodexAdapter(ctx, state.config)) {
 		return undefined;
@@ -203,23 +233,23 @@ async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactE
 	const compactResult = await executeNativeCompaction({ runtime, request, signal: event.signal });
 	if (!compactResult.ok) {
 		if (compactResult.reason !== "aborted") {
-			ctx.ui.notify(formatCompactFailureMessage(compactResult), "error");
+			notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, formatCompactFailureMessage(compactResult));
 		}
-		return { cancel: true };
+		return compactResult.reason === "aborted" ? { cancel: true } : undefined;
 	}
 	const compactedWindow = sanitizeCompactedWindow(compactResult.compactedWindow);
 	if (compactedWindow.length === 0) {
-		ctx.ui.notify(`OpenAI native compaction returned no installable compacted context; Pi compaction was not run. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction returned no installable compacted context. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	if (!hasCompactionOutputItem(compactedWindow)) {
-		ctx.ui.notify(`OpenAI native compaction did not return a compaction item; Pi compaction was not run. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction did not return a compaction item. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	const encryptedSummary = extractCompactionSummaryText(compactedWindow);
 	if (!encryptedSummary) {
-		ctx.ui.notify(`OpenAI native compaction returned compacted context without a displayable summary; Pi compaction was not run. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`, "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, `OpenAI native compaction returned compacted context without a displayable summary. Response=${compactResult.compactResponseId ?? "<none>"}. Request: ${formatCompactRequestDiagnostics(request)}. Output: ${summarizeCompactionOutputForDiagnostics(compactResult.compactedWindow, compactedWindow)}`);
+		return undefined;
 	}
 	try {
 		const details = createNativeCompactionDetails({
@@ -234,8 +264,8 @@ async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactE
 		});
 		return { compaction: createNativeCompactionShimResult({ summary: NATIVE_COMPACTION_SHIM_SUMMARY, firstKeptEntryId: event.preparation.firstKeptEntryId, tokensBefore: event.preparation.tokensBefore, details }) };
 	} catch {
-		ctx.ui.notify("OpenAI native compaction produced details Pi could not store; Pi compaction was not run.", "error");
-		return { cancel: true };
+		notifyNativeCompactionFallback(ctx, state, branchEntries, runtime, "OpenAI native compaction produced details Pi could not store");
+		return undefined;
 	}
 }
 
@@ -245,17 +275,49 @@ export async function rewriteCodexCompactedProviderRequest(payload: unknown, ctx
 	if (!resolution.ok) return undefined;
 	const runtime = resolution.runtime;
 	const branchEntries = ctx.sessionManager.getBranch();
-	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
+	const latestNativeCompactionIndex = findLatestNativeCompactionEntryIndex(branchEntries, {
 		provider: runtime.provider,
 		api: runtime.api,
 		baseUrl: runtime.baseUrl,
 	});
-	if (!latestNativeCompaction.ok) return undefined;
+	if (latestNativeCompactionIndex === undefined) return undefined;
 	if (!runtime.payload) return undefined;
-	const rewrite = rewriteResponsesPayloadWithNativeReplay({ model: runtime.currentModel, payload: runtime.payload, branchEntries, compactionEntry: latestNativeCompaction.entry });
+	const rewrite = rewriteResponsesPayloadWithNativeReplay({ model: runtime.currentModel, payload: runtime.payload, branchEntries, compactionEntry: branchEntries[latestNativeCompactionIndex] as NativeCompactionEntry });
 	if (rewrite.ok) return rewrite.rewrittenPayload;
 	const detail = rewrite.parity?.mismatches.slice(0, 3).join("; ");
 	const message = `OpenAI native compaction replay failed (${rewrite.reason})${detail ? `: ${detail}` : ""}; request was not sent with placeholder compaction context.`;
 	ctx.ui.notify(message, "error");
 	throw new Error(message);
 }
+
+export async function injectPendingNativeWindowIntoPiCompactionRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
+	const pending = state.pendingPiCompactionNativeWindow;
+	if (!pending || pending.window.length === 0) return undefined;
+	if (!isResponsesCompatiblePayload(payload)) return undefined;
+	if (pending.sessionId !== ctx.sessionManager.getSessionId()) {
+		state.pendingPiCompactionNativeWindow = undefined;
+		return undefined;
+	}
+
+	const resolution = await resolveNativeCompactionEnvironment(ctx, { enabled: true }, payload);
+	if (!resolution.ok) return undefined;
+	const runtime = resolution.runtime;
+	if (pending.provider !== runtime.provider || pending.api !== runtime.api || pending.baseUrl !== runtime.baseUrl) return undefined;
+
+	const input = [...payload.input];
+	let insertAt = 0;
+	while (insertAt < input.length) {
+		const item = input[insertAt];
+		if (!isRecord(item) || (item.role !== "system" && item.role !== "developer")) break;
+		insertAt++;
+	}
+
+	return {
+		...payload,
+		input: [
+			...input.slice(0, insertAt),
+			...pending.window.map((item) => structuredClone(item)),
+			...input.slice(insertAt),
+		],
+	};
+}

package/src/adapter/provider-request.ts

@@ -5,7 +5,7 @@ import type { AdapterState } from "./state.ts";
 import { rewriteNativeImageGenerationTool } from "../tools/image-generation-tool.ts";
 import { rewriteNativeWebSearchTool } from "../tools/web-search-tool.ts";
 import { shouldUseCodexAdapter } from "./activation.ts";
-import { rewriteCodexCompactedProviderRequest } from "./compaction.ts";
+import { injectPendingNativeWindowIntoPiCompactionRequest, rewriteCodexCompactedProviderRequest } from "./compaction.ts";
 
 export async function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
 	if (!shouldUseCodexAdapter(ctx, state.config) || (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx))) {
@@ -21,5 +21,7 @@ export async function rewriteCodexProviderRequest(payload: unknown, ctx: Extensi
 		serviceTier: isOpenAICodex,
 		verbosity: true,
 	});
+	const piCompactionPayload = await injectPendingNativeWindowIntoPiCompactionRequest(configuredPayload, ctx, state);
+	if (piCompactionPayload !== undefined) return piCompactionPayload;
 	return (await rewriteCodexCompactedProviderRequest(configuredPayload, ctx, state)) ?? configuredPayload;
 }

package/src/adapter/state.ts

@@ -1,5 +1,15 @@
 import type { PromptSkill } from "../prompt/build-system-prompt.ts";
 import type { CodexConversionConfig } from "./config.ts";
+import type { ResponsesInputItem } from "./serializer.ts";
+
+export interface PendingPiCompactionNativeWindow {
+	window: ResponsesInputItem[];
+	provider: string;
+	api: string;
+	baseUrl: string;
+	sessionId: string;
+	sourceCompactionEntryId?: string;
+}
 
 export interface AdapterState {
 	enabled: boolean;
@@ -8,4 +18,5 @@ export interface AdapterState {
 	previousToolNames?: string[];
 	promptSkills: PromptSkill[];
 	config: CodexConversionConfig;
+	pendingPiCompactionNativeWindow?: PendingPiCompactionNativeWindow;
 }

package/src/index.ts

@@ -163,6 +163,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("session_compact", async (event) => {
+		state.pendingPiCompactionNativeWindow = undefined;
 		if (!event.fromExtension || !isNativeCompactionDetails(event.compactionEntry.details)) return;
 		pi.sendMessage(
 			{