@howaboua/pi-codex-conversion 1.5.10-dev.41.7e2d8d2 → 1.5.10-dev.44.ec03884

package/README.md

@@ -57,6 +57,8 @@ The settings UI also has **Usage**, **Overrides**, and **About** tabs. **Usage**
 
 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.
 
+For OpenAI Codex subscription models, the extension also adjusts Pi's registered model context windows so Pi's fixed reserve-token compaction heuristic trips at roughly Codex's native auto-compact budget: 90% of Pi's resolved model window. This is calculated from Pi's current model metadata instead of hardcoded per-model limits.
+
 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.41.7e2d8d2",
+  "version": "1.5.10-dev.44.ec03884",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -60,9 +60,10 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.75.3",
-    "@earendil-works/pi-coding-agent": "^0.75.3",
-    "@earendil-works/pi-tui": "^0.75.3",
+    "@earendil-works/pi-agent-core": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-tui": "^0.75.4",
     "tsx": "^4.20.5",
     "typebox": "^1.1.24",
     "typescript": "^5.9.3"

package/src/adapter/codex-context-budget.ts

@@ -0,0 +1,93 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { AdapterState } from "./state.ts";
+
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+const OPENAI_CODEX_API = "openai-codex-responses";
+const CODEX_AUTO_COMPACT_NUMERATOR = 9;
+const CODEX_AUTO_COMPACT_DENOMINATOR = 10;
+const PI_DEFAULT_COMPACTION_RESERVE_TOKENS = 16_384;
+
+export function getCodexAutoCompactBudget(contextWindow: number): number {
+	return Math.floor((contextWindow * CODEX_AUTO_COMPACT_NUMERATOR) / CODEX_AUTO_COMPACT_DENOMINATOR);
+}
+
+export function getPiContextWindowForCodexAutoCompact(contextWindow: number, reserveTokens = PI_DEFAULT_COMPACTION_RESERVE_TOKENS): number {
+	return Math.min(contextWindow, getCodexAutoCompactBudget(contextWindow) + reserveTokens);
+}
+
+function readSettings(path: string): Record<string, unknown> | undefined {
+	if (!existsSync(path)) return undefined;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function getReserveTokens(settings: Record<string, unknown> | undefined): number | undefined {
+	const compaction = settings?.compaction;
+	if (!compaction || typeof compaction !== "object" || Array.isArray(compaction)) return undefined;
+	const reserveTokens = (compaction as { reserveTokens?: unknown }).reserveTokens;
+	return typeof reserveTokens === "number" && Number.isFinite(reserveTokens) && reserveTokens >= 0 ? reserveTokens : undefined;
+}
+
+export function readPiCompactionReserveTokens(cwd: string): number {
+	return (
+		getReserveTokens(readSettings(join(cwd, ".pi", "settings.json"))) ??
+		getReserveTokens(readSettings(join(getAgentDir(), "settings.json"))) ??
+		PI_DEFAULT_COMPACTION_RESERVE_TOKENS
+	);
+}
+
+export function shouldUseCodexContextBudgetModel(model: Model<Api> | undefined): model is Model<Api> {
+	return model?.provider === OPENAI_CODEX_PROVIDER && model.api === OPENAI_CODEX_API;
+}
+
+function getModelKey(model: Model<Api>): string {
+	return `${model.provider}:${model.api}:${model.id}`;
+}
+
+function resolveRawContextWindow<TApi extends Api>(model: Model<TApi>, state: AdapterState | undefined): number {
+	if (!state) return model.contextWindow;
+	const key = getModelKey(model);
+	const cachedRaw = state.codexContextBudgetRawWindows?.[key];
+	if (cachedRaw === undefined) {
+		state.codexContextBudgetRawWindows ??= {};
+		state.codexContextBudgetRawWindows[key] = model.contextWindow;
+		return model.contextWindow;
+	}
+
+	const cachedAdjusted = getPiContextWindowForCodexAutoCompact(cachedRaw, state.codexContextBudgetReserveTokens);
+	const previousAdjusted = state.codexContextBudgetAdjustedWindows?.[key];
+	if (model.contextWindow !== cachedRaw && model.contextWindow !== cachedAdjusted && model.contextWindow !== previousAdjusted) {
+		state.codexContextBudgetRawWindows ??= {};
+		state.codexContextBudgetRawWindows[key] = model.contextWindow;
+		delete state.codexContextBudgetAdjustedWindows?.[key];
+		return model.contextWindow;
+	}
+	return cachedRaw;
+}
+
+export function getCodexContextBudgetAdjustedModel<TApi extends Api>(model: Model<TApi>, state?: AdapterState): Model<TApi> {
+	if (!shouldUseCodexContextBudgetModel(model)) return model;
+	const rawContextWindow = resolveRawContextWindow(model, state);
+	const contextWindow = getPiContextWindowForCodexAutoCompact(rawContextWindow, state?.codexContextBudgetReserveTokens);
+	if (state) {
+		state.codexContextBudgetAdjustedWindows ??= {};
+		state.codexContextBudgetAdjustedWindows[getModelKey(model)] = contextWindow;
+	}
+	return contextWindow === model.contextWindow ? model : { ...model, contextWindow };
+}
+
+export function applyCodexContextBudgetToModel<TApi extends Api>(model: Model<TApi> | undefined, state: AdapterState): void {
+	if (!model) return;
+	state.codexContextBudgetReserveTokens ??= readPiCompactionReserveTokens(state.cwd);
+	const adjustedModel = getCodexContextBudgetAdjustedModel(model, state);
+	if (adjustedModel !== model) {
+		model.contextWindow = adjustedModel.contextWindow;
+	}
+}

package/src/adapter/compaction.ts

@@ -95,12 +95,20 @@ function clampCodexReasoningEffort(modelId: string, effort: string): string {
 	return effort;
 }
 
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+
+function clampOpenAIPromptCacheKey(key: string): string {
+	const chars = Array.from(key);
+	if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return key;
+	return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
+
 function buildCompactionRequestOptions(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState, compactionModel: string): NativeCompactionRequestOptions {
 	const tools = buildCompactionTools(pi, ctx, state);
 	const reasoning = buildCompactionReasoning(pi, ctx, state, compactionModel);
 	return {
 		parallel_tool_calls: true,
-		prompt_cache_key: ctx.sessionManager.getSessionId(),
+		prompt_cache_key: clampOpenAIPromptCacheKey(ctx.sessionManager.getSessionId()),
 		...(isOpenAICodexContext(ctx) && state.config.fast ? { service_tier: "priority" } : {}),
 		text: { verbosity: state.config.verbosity },
 		...(tools ? { tools } : {}),

package/src/adapter/state.ts

@@ -19,4 +19,7 @@ export interface AdapterState {
 	promptSkills: PromptSkill[];
 	config: CodexConversionConfig;
 	pendingPiCompactionNativeWindow?: PendingPiCompactionNativeWindow;
+	codexContextBudgetRawWindows?: Record<string, number>;
+	codexContextBudgetAdjustedWindows?: Record<string, number>;
+	codexContextBudgetReserveTokens?: number;
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Model } from "@earendil-works/pi-ai";
 import { Box, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
 import { clearApplyPatchRenderState, registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
@@ -22,6 +23,7 @@ import { getCodexSkillPaths, hasNoSkillsFlag } from "./adapter/skills.ts";
 import type { AdapterState } from "./adapter/state.ts";
 import { registerCodexCommand } from "./codex-settings/command.ts";
 import { WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
+import { applyCodexContextBudgetToModel, readPiCompactionReserveTokens } from "./adapter/codex-context-budget.ts";
 
 function getCommandArg(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || !("cmd" in args) || typeof args.cmd !== "string") {
@@ -62,6 +64,10 @@ export default function codexConversion(pi: ExtensionAPI) {
 		}
 	}
 
+	function ensureCodexContextBudgetModel(ctx: { model: Model<any> | undefined }): void {
+		applyCodexContextBudgetToModel(ctx.model, state);
+	}
+
 	registerOpenAICodexCustomProvider(pi, {
 		getCurrentCwd: () => state.cwd,
 		getNativeToolRewriteConfig: () => ({
@@ -92,6 +98,8 @@ export default function codexConversion(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
 		state.config = readCodexConversionConfig();
+		state.codexContextBudgetReserveTokens = readPiCompactionReserveTokens(ctx.cwd);
+		ensureCodexContextBudgetModel(ctx);
 		ensureOptionalNativeToolsRegistered();
 		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
 		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
@@ -108,6 +116,8 @@ export default function codexConversion(pi: ExtensionAPI) {
 
 	pi.on("model_select", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
+		state.codexContextBudgetReserveTokens = readPiCompactionReserveTokens(ctx.cwd);
+		ensureCodexContextBudgetModel(ctx);
 		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
 		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
 		syncAdapter(pi, ctx, state);

package/src/providers/openai-codex-custom-provider.ts

@@ -37,6 +37,14 @@ const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
 const dynamicImport = (specifier: string) => import(specifier);
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+
+function clampOpenAIPromptCacheKey(key: string | undefined): string | undefined {
+	if (key === undefined) return undefined;
+	const chars = Array.from(key);
+	if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH) return key;
+	return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
 let _os: { platform(): string; release(): string; arch(): string } | null = null;
 
 if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
@@ -87,6 +95,7 @@ interface QueuedWebSearchActivity {
 }
 
 type PendingActivity = QueuedImageActivity | QueuedWebSearchActivity;
+type SendActivityMessage = ExtensionAPI["sendMessage"];
 
 interface CachedImagePreview {
 	data: string;
@@ -577,7 +586,7 @@ export function buildRequestBody<TApi extends Api>(model: Model<TApi>, context:
 		input: messages,
 		text: { verbosity: ((options as { textVerbosity?: string } | undefined)?.textVerbosity ?? "low") as string },
 		include: ["reasoning.encrypted_content"],
-		prompt_cache_key: options?.sessionId,
+		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
 		tool_choice: "auto",
 		parallel_tool_calls: true,
 	};
@@ -1449,6 +1458,87 @@ export function buildWebSearchSummaryText(searches: SurfacedWebSearch[]): string
 	return searches.length === 1 ? "Searched the web once" : `Searched the web ${searches.length} times`;
 }
 
+function sendActivityMessages(
+	sendMessage: SendActivityMessage,
+	imagePreviewCache: Map<string, CachedImagePreview>,
+	activities: PendingActivity[],
+): void {
+	for (let index = 0; index < activities.length; index++) {
+		const activity = activities[index];
+		if (activity.kind === "image") {
+			imagePreviewCache.set(activity.savedImage.absolutePath, activity.imageData);
+			sendMessage(
+				{
+					customType: IMAGE_SAVE_DISPLAY_MESSAGE_TYPE,
+					content: [{ type: "text", text: buildGeneratedImageDisplayText(activity.savedImage, { expanded: false }) }],
+					display: true,
+					details: { savedImages: [activity.savedImage] } satisfies ImageDisplayMessageDetails,
+				},
+				{ triggerTurn: false },
+			);
+			continue;
+		}
+
+		const searches = [activity.search];
+		while (index + 1 < activities.length && activities[index + 1]?.kind === "web-search") {
+			searches.push((activities[++index] as QueuedWebSearchActivity).search);
+		}
+		sendMessage(
+			{
+				customType: WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
+				content: buildWebSearchActivityMessage(searches),
+				display: true,
+				details: { searches },
+			},
+			{ triggerTurn: false },
+		);
+	}
+}
+
+export function createActivityMessageDispatcher(sendMessage: SendActivityMessage): {
+	imagePreviewCache: Map<string, CachedImagePreview>;
+	enqueueSettledActivities(activities: PendingActivity[]): void;
+	flushNow(): void;
+	scheduleFlush(): void;
+	clear(): void;
+} {
+	const completedActivities: PendingActivity[] = [];
+	const imagePreviewCache = new Map<string, CachedImagePreview>();
+	let pendingFlushTimer: ReturnType<typeof setTimeout> | undefined;
+
+	const flush = () => {
+		pendingFlushTimer = undefined;
+		const activities = completedActivities.splice(0, completedActivities.length);
+		if (activities.length > 0) sendActivityMessages(sendMessage, imagePreviewCache, activities);
+	};
+
+	return {
+		imagePreviewCache,
+		enqueueSettledActivities(activities) {
+			completedActivities.push(...activities);
+		},
+		flushNow() {
+			if (pendingFlushTimer) {
+				clearTimeout(pendingFlushTimer);
+				pendingFlushTimer = undefined;
+			}
+			flush();
+		},
+		scheduleFlush() {
+			if (pendingFlushTimer || completedActivities.length === 0) return;
+			pendingFlushTimer = setTimeout(flush, 0);
+		},
+		clear() {
+			if (pendingFlushTimer) {
+				clearTimeout(pendingFlushTimer);
+				pendingFlushTimer = undefined;
+			}
+			completedActivities.length = 0;
+			imagePreviewCache.clear();
+		},
+	};
+}
+
 function loadCachedImagePreview(savedImage: SavedGeneratedImage, imagePreviewCache: Map<string, CachedImagePreview>): CachedImagePreview | undefined {
 	const cached = imagePreviewCache.get(savedImage.absolutePath);
 	if (cached) return cached;
@@ -1543,6 +1633,7 @@ function createCodexStream<TApi extends Api>(
 		getNativeToolRewriteConfig?: () => { webSearch: boolean; imageGeneration: boolean };
 		onImageSaved?: (savedImage: SavedGeneratedImage, imageData: { data: string; mimeType: string }) => void;
 		onWebSearchCaptured?: (search: SurfacedWebSearch) => void;
+		onStreamSettled?: () => void;
 	},
 ): AssistantMessageEventStream {
 	const stream = createAssistantMessageEventStream();
@@ -1696,6 +1787,8 @@ function createCodexStream<TApi extends Api>(
 				error: createErrorMessage(output, error, !!options?.signal?.aborted),
 			});
 			stream.end();
+		} finally {
+			deps.onStreamSettled?.();
 		}
 	})();
 
@@ -1703,75 +1796,31 @@ function createCodexStream<TApi extends Api>(
 }
 
 export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { getCurrentCwd: () => string; getNativeToolRewriteConfig?: () => { webSearch: boolean; imageGeneration: boolean } }): void {
-	const pendingActivities: PendingActivity[] = [];
-	const imagePreviewCache = new Map<string, CachedImagePreview>();
-	let pendingFlushTimer: ReturnType<typeof setTimeout> | undefined;
-
-	const flushPendingMessages = () => {
-		pendingFlushTimer = undefined;
-		const activities = pendingActivities.splice(0, pendingActivities.length);
-
-		for (let index = 0; index < activities.length; index++) {
-			const activity = activities[index];
-			if (activity.kind === "image") {
-				imagePreviewCache.set(activity.savedImage.absolutePath, activity.imageData);
-				pi.sendMessage(
-					{
-						customType: IMAGE_SAVE_DISPLAY_MESSAGE_TYPE,
-						content: [{ type: "text", text: buildGeneratedImageDisplayText(activity.savedImage, { expanded: false }) }],
-						display: true,
-						details: { savedImages: [activity.savedImage] } satisfies ImageDisplayMessageDetails,
-					},
-					{ triggerTurn: false },
-				);
-				continue;
-			}
-
-			const searches = [activity.search];
-			while (index + 1 < activities.length && activities[index + 1]?.kind === "web-search") {
-				searches.push((activities[++index] as QueuedWebSearchActivity).search);
-			}
-			pi.sendMessage(
-				{
-					customType: WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
-					content: buildWebSearchActivityMessage(searches),
-					display: true,
-					details: { searches },
-				},
-				{ triggerTurn: false },
-			);
-		}
-	};
-
-	const schedulePendingMessageFlush = () => {
-		if (pendingFlushTimer || pendingActivities.length === 0) {
-			return;
-		}
-		pendingFlushTimer = setTimeout(flushPendingMessages, 0);
-	};
+	const activityDispatcher = createActivityMessageDispatcher(pi.sendMessage.bind(pi));
 
 	const clearPendingMessages = () => {
-		if (pendingFlushTimer) {
-			clearTimeout(pendingFlushTimer);
-			pendingFlushTimer = undefined;
-		}
-		pendingActivities.length = 0;
-		imagePreviewCache.clear();
+		activityDispatcher.clear();
 	};
 
 	pi.registerProvider("openai-codex", {
 		api: "openai-codex-responses",
-		streamSimple: (model, context, streamOptions) =>
-			createCodexStream(model, context, streamOptions, {
+		streamSimple: (model, context, streamOptions) => {
+			const turnActivities: PendingActivity[] = [];
+			return createCodexStream(model, context, streamOptions, {
 				getCurrentCwd: options.getCurrentCwd,
 				getNativeToolRewriteConfig: options.getNativeToolRewriteConfig,
 				onImageSaved: (savedImage, imageData) => {
-					pendingActivities.push({ kind: "image", savedImage, imageData });
+					turnActivities.push({ kind: "image", savedImage, imageData });
 				},
 				onWebSearchCaptured: (search) => {
-					pendingActivities.push({ kind: "web-search", search });
+					turnActivities.push({ kind: "web-search", search });
+				},
+				onStreamSettled: () => {
+					const activities = turnActivities.splice(0, turnActivities.length);
+					if (activities.length > 0) activityDispatcher.enqueueSettledActivities(activities);
 				},
-			}),
+			});
+		},
 	});
 
 	pi.on("session_start", async () => {
@@ -1779,15 +1828,13 @@ export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { g
 	});
 
 	pi.on("session_shutdown", async () => {
-		if (pendingActivities.length > 0) {
-			flushPendingMessages();
-		}
+		activityDispatcher.flushNow();
 		clearPendingMessages();
 		closeOpenAICodexWebSocketSessions();
 	});
 
 	pi.on("agent_end", async () => {
-		schedulePendingMessageFlush();
+		activityDispatcher.scheduleFlush();
 	});
 
 	pi.registerMessageRenderer<ImageDisplayMessageDetails>(IMAGE_SAVE_DISPLAY_MESSAGE_TYPE, (message, options, theme) => {
@@ -1804,7 +1851,7 @@ export function registerOpenAICodexCustomProvider(pi: ExtensionAPI, options: { g
 						.join("\n");
 		box.addChild(new Text(`\n${theme.fg("customMessageText", textContent)}`, 0, 0));
 		if (savedImage) {
-			const preview = loadCachedImagePreview(savedImage, imagePreviewCache);
+			const preview = loadCachedImagePreview(savedImage, activityDispatcher.imagePreviewCache);
 			if (preview) {
 				box.addChild(new Spacer(1));
 				box.addChild(