@howaboua/pi-codex-conversion 1.5.5 → 1.5.6-dev.32.699e826

package/src/adapter/compaction-runtime.ts

@@ -0,0 +1,272 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const DEFAULT_SUPPORTED_PROVIDERS = ["openai", "openai-codex"] as const;
+export const DEFAULT_SUPPORTED_APIS = ["openai-responses", "openai-codex-responses"] as const;
+const OPENAI_COMPACT_PATH = "responses/compact";
+const CODEX_COMPACT_PATH = "codex/responses/compact";
+
+type BuiltInSupportedProvider = (typeof DEFAULT_SUPPORTED_PROVIDERS)[number];
+type DefaultSupportedApi = (typeof DEFAULT_SUPPORTED_APIS)[number];
+
+type RuntimeModel = Model<Api>;
+
+type NativeCompactionFailureReason =
+	| "disabled"
+	| "missing-model"
+	| "unsupported-provider"
+	| "unsupported-api"
+	| "missing-base-url"
+	| "missing-api-key"
+	| "unsupported-payload"
+	| "payload-model-mismatch";
+
+export type NativeCompactionSupportOptions = {
+	enabled?: boolean;
+	supportedProviders?: readonly string[];
+	supportedApis?: readonly string[];
+};
+
+export type ResponsesCompatibleRequestPayload = {
+	model: string;
+	input: unknown[];
+	instructions?: unknown;
+	[key: string]: unknown;
+};
+
+export type NativeCompactionRuntime = {
+	provider: string;
+	api: DefaultSupportedApi;
+	apiFamily: DefaultSupportedApi;
+	model: string;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string>;
+	compactPath: string;
+	compactUrl: string;
+	payload?: ResponsesCompatibleRequestPayload;
+	currentModel: RuntimeModel;
+};
+
+export type NativeCompactionEnvironmentFailure = {
+	ok: false;
+	reason: NativeCompactionFailureReason;
+	provider?: string;
+	api?: string;
+	model?: string;
+	baseUrl?: string;
+};
+
+export type NativeCompactionEnvironmentSuccess = {
+	ok: true;
+	runtime: NativeCompactionRuntime;
+};
+
+export type NativeCompactionEnvironmentResolution =
+	| NativeCompactionEnvironmentFailure
+	| NativeCompactionEnvironmentSuccess;
+
+function normalizeConfiguredSet(values: readonly string[] | undefined, defaults: readonly string[]): Set<string> {
+	const source = values && values.length > 0 ? values : defaults;
+	return new Set(source.map((value) => value.trim()).filter((value) => value.length > 0));
+}
+
+export function normalizeBaseUrl(baseUrl: string | undefined | null): string | undefined {
+	const normalized = baseUrl?.trim().replace(/\/+$/, "");
+	return normalized ? normalized : undefined;
+}
+
+function buildOpenAICompactUrl(baseUrl: string): string {
+	const normalized = normalizeBaseUrl(baseUrl) ?? baseUrl;
+	if (normalized.endsWith("/responses")) {
+		return `${normalized}/compact`;
+	}
+	return `${normalized}/${OPENAI_COMPACT_PATH}`;
+}
+
+function buildCodexCompactUrl(baseUrl: string): string {
+	const normalized = normalizeBaseUrl(baseUrl) ?? baseUrl;
+	if (normalized.endsWith("/codex/responses")) {
+		return `${normalized}/compact`;
+	}
+	if (normalized.endsWith("/codex")) {
+		return `${normalized}/responses/compact`;
+	}
+	return `${normalized}/${CODEX_COMPACT_PATH}`;
+}
+
+export function buildCompactUrl(baseUrl: string, api: DefaultSupportedApi): string {
+	return api === "openai-codex-responses" ? buildCodexCompactUrl(baseUrl) : buildOpenAICompactUrl(baseUrl);
+}
+
+export function buildCompactPath(api: DefaultSupportedApi): string {
+	return api === "openai-codex-responses" ? CODEX_COMPACT_PATH : OPENAI_COMPACT_PATH;
+}
+
+export function isSupportedProvider(provider: string): provider is BuiltInSupportedProvider {
+	return (DEFAULT_SUPPORTED_PROVIDERS as readonly string[]).includes(provider);
+}
+
+async function resolveRequestAuth(
+	ctx: ExtensionContext,
+	model: RuntimeModel,
+): Promise<{ apiKey?: string; headers?: Record<string, string> }> {
+	const modelRegistry = ctx.modelRegistry as {
+		getApiKeyAndHeaders?: (currentModel: RuntimeModel) => Promise<
+			| { ok: true; apiKey?: string; headers?: Record<string, string> }
+			| { ok: false; error: string }
+		>;
+	};
+
+	if (typeof modelRegistry.getApiKeyAndHeaders !== "function") {
+		return {};
+	}
+
+	const auth = await modelRegistry.getApiKeyAndHeaders(model);
+	return auth.ok ? { apiKey: auth.apiKey, headers: auth.headers } : {};
+}
+
+export function isSupportedApi(api: string): api is DefaultSupportedApi {
+	return (DEFAULT_SUPPORTED_APIS as readonly string[]).includes(api);
+}
+
+export function isResponsesCompatiblePayload(payload: unknown): payload is ResponsesCompatibleRequestPayload {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+		return false;
+	}
+
+	const candidate = payload as Record<string, unknown>;
+	return typeof candidate.model === "string" && Array.isArray(candidate.input);
+}
+
+export function getRuntimeModelDescriptor(model: RuntimeModel | undefined): {
+	provider?: string;
+	api?: string;
+	model?: string;
+	baseUrl?: string;
+} {
+	if (!model) {
+		return {};
+	}
+
+	return {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		baseUrl: normalizeBaseUrl(model.baseUrl),
+	};
+}
+
+export async function resolveNativeCompactionEnvironment(
+	ctx: ExtensionContext,
+	options: NativeCompactionSupportOptions = {},
+	payload?: unknown,
+): Promise<NativeCompactionEnvironmentResolution> {
+	if (options.enabled === false) {
+		return {
+			ok: false,
+			reason: "disabled",
+		};
+	}
+
+	const currentModel = ctx.model;
+	const descriptor = getRuntimeModelDescriptor(currentModel);
+	if (!currentModel || !descriptor.provider || !descriptor.api || !descriptor.model) {
+		return {
+			ok: false,
+			reason: "missing-model",
+			...descriptor,
+		};
+	}
+
+	const supportedProviders = normalizeConfiguredSet(options.supportedProviders, DEFAULT_SUPPORTED_PROVIDERS);
+	if (!supportedProviders.has(descriptor.provider)) {
+		return {
+			ok: false,
+			reason: "unsupported-provider",
+			...descriptor,
+		};
+	}
+
+	const supportedApis = normalizeConfiguredSet(options.supportedApis, DEFAULT_SUPPORTED_APIS);
+	if (!supportedApis.has(descriptor.api)) {
+		return {
+			ok: false,
+			reason: "unsupported-api",
+			...descriptor,
+		};
+	}
+
+	if (!isSupportedApi(descriptor.api)) {
+		return {
+			ok: false,
+			reason: "unsupported-api",
+			...descriptor,
+		};
+	}
+
+	if (!descriptor.baseUrl) {
+		return {
+			ok: false,
+			reason: "missing-base-url",
+			...descriptor,
+		};
+	}
+
+	let requestPayload: ResponsesCompatibleRequestPayload | undefined;
+	if (payload !== undefined) {
+		if (!isResponsesCompatiblePayload(payload)) {
+			return {
+				ok: false,
+				reason: "unsupported-payload",
+				...descriptor,
+			};
+		}
+
+		if (payload.model !== descriptor.model) {
+			return {
+				ok: false,
+				reason: "payload-model-mismatch",
+				...descriptor,
+			};
+		}
+
+		requestPayload = payload;
+	}
+
+	const { apiKey, headers } = await resolveRequestAuth(ctx, currentModel);
+	const hasAuthorizationHeader = Object.entries(headers ?? {}).some(([key, value]) => key.toLowerCase() === "authorization" && value.trim().length > 0);
+	if (!apiKey && !hasAuthorizationHeader) {
+		return {
+			ok: false,
+			reason: "missing-api-key",
+			...descriptor,
+		};
+	}
+
+	return {
+		ok: true,
+		runtime: {
+			provider: descriptor.provider,
+			api: descriptor.api,
+			apiFamily: descriptor.api,
+			model: descriptor.model,
+			baseUrl: descriptor.baseUrl,
+			apiKey,
+			headers,
+			compactPath: buildCompactPath(descriptor.api),
+			compactUrl: buildCompactUrl(descriptor.baseUrl, descriptor.api),
+			payload: requestPayload,
+			currentModel,
+		},
+	};
+}
+
+export async function getNativeCompactionRuntime(
+	ctx: ExtensionContext,
+	options: NativeCompactionSupportOptions = {},
+	payload?: unknown,
+): Promise<NativeCompactionRuntime | undefined> {
+	const resolution = await resolveNativeCompactionEnvironment(ctx, options, payload);
+	return resolution.ok ? resolution.runtime : undefined;
+}

package/src/adapter/compaction.ts

@@ -0,0 +1,261 @@
+import type { ExtensionAPI, ExtensionContext, SessionBeforeCompactEvent } from "@earendil-works/pi-coding-agent";
+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 { rewriteResponsesPayloadWithNativeReplay, serializeLiveTailToResponsesInput } from "./payload-rewrite.ts";
+import { resolveNativeCompactionEnvironment } from "./compaction-runtime.ts";
+import { convertResponsesTools } from "../providers/openai-responses-shared.ts";
+import {
+	serializeCompactionPreparationToRequest,
+	type NativeCompactionRequestBody,
+	type NativeCompactionRequestOptions,
+	type ResponsesInputItem,
+} from "./serializer.ts";
+import { createNativeCompactionDetails, createNativeCompactionShimResult, isNativeCompactionDetails, NATIVE_COMPACTION_SHIM_SUMMARY } from "./types.ts";
+import { isOpenAICodexContext, isResponsesContext } from "./codex-model.ts";
+import { shouldUseCodexAdapter } from "./activation.ts";
+import type { AdapterState } from "./state.ts";
+import { rewriteNativeImageGenerationTool } from "../tools/image-generation-tool.ts";
+import { rewriteNativeWebSearchTool } from "../tools/web-search-tool.ts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function cloneCompactedWindow(window: readonly unknown[]): ResponsesInputItem[] | undefined {
+	if (!window.every(isRecord)) return undefined;
+	return window.map((item) => structuredClone(item));
+}
+
+function buildCompactionInstructions(systemPrompt: string, customInstructions?: string): string {
+	const guidance = customInstructions?.trim();
+	return guidance ? `${systemPrompt}\n\nAdditional user guidance for this manual /compact request:\n${guidance}` : systemPrompt;
+}
+
+function buildCompactionTools(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): unknown[] | undefined {
+	const activeToolNames = new Set(pi.getActiveTools());
+	const tools = pi
+		.getAllTools()
+		.filter((tool) => activeToolNames.has(tool.name))
+		.map((tool): Tool => ({ name: tool.name, description: tool.description, parameters: tool.parameters }));
+	if (tools.length === 0) return undefined;
+	let payload: { tools: unknown[] } = { tools: convertResponsesTools(tools, { strict: null }) };
+	if (isOpenAICodexContext(ctx) && state.config.webSearch) {
+		payload = rewriteNativeWebSearchTool(payload, ctx.model) as { tools: unknown[] };
+	}
+	if (isOpenAICodexContext(ctx) && state.config.imageGeneration) {
+		payload = rewriteNativeImageGenerationTool(payload, ctx.model) as { tools: unknown[] };
+	}
+	return payload.tools;
+}
+
+function buildCompactionReasoning(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState, compactionModel: string): NativeCompactionRequestOptions["reasoning"] {
+	const model = ctx.model;
+	const level = state.config.compactionReasoning === "current" ? pi.getThinkingLevel() : state.config.compactionReasoning;
+	if (!model?.reasoning || level === "off") return undefined;
+	const clampedLevel = clampThinkingLevel(model, level as ModelThinkingLevel);
+	const rawEffort = model.thinkingLevelMap?.[clampedLevel] ?? clampedLevel;
+	const effort = typeof rawEffort === "string" && isOpenAICodexContext(ctx) ? clampCodexReasoningEffort(compactionModel, rawEffort) : rawEffort;
+	return effort === null ? undefined : { effort, summary: "auto" };
+}
+
+function clampCodexReasoningEffort(modelId: string, effort: string): string {
+	const id = modelId.includes("/") ? (modelId.split("/").pop() ?? modelId) : modelId;
+	const gpt5MinorMatch = /^gpt-5\.(\d+)/.exec(id);
+	const gpt5Minor = gpt5MinorMatch ? Number.parseInt(gpt5MinorMatch[1], 10) : undefined;
+	if (gpt5Minor !== undefined && gpt5Minor >= 2 && effort === "minimal") return "low";
+	if (id === "gpt-5.1" && effort === "xhigh") return "high";
+	if (id === "gpt-5.1-codex-mini") return effort === "high" || effort === "xhigh" ? "high" : "medium";
+	return effort;
+}
+
+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(),
+		...(isOpenAICodexContext(ctx) && state.config.fast ? { service_tier: "priority" } : {}),
+		text: { verbosity: state.config.verbosity },
+		...(tools ? { tools } : {}),
+		...(reasoning ? { reasoning } : {}),
+	};
+}
+
+function getCompactionIdentity(entry: { details?: unknown } | undefined) {
+	return isNativeCompactionDetails(entry?.details)
+		? { provider: entry.details.provider, api: entry.details.api, model: entry.details.model, baseUrl: entry.details.baseUrl }
+		: undefined;
+}
+
+function formatCompactFailureMessage(compactResult: Awaited<ReturnType<typeof executeNativeCompaction>>): string {
+	if (compactResult.ok) return "OpenAI native compaction succeeded";
+	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.`;
+}
+
+function formatCompactRequestDiagnostics(request: NativeCompactionRequestBody): string {
+	const reasoning = isRecord(request.reasoning) && typeof request.reasoning.effort === "string" ? request.reasoning.effort : "none";
+	const serviceTier = typeof request.service_tier === "string" ? request.service_tier : "none";
+	const tools = Array.isArray(request.tools) ? request.tools.length : 0;
+	return `model=${request.model}, input=${request.input.length}, tools=${tools}, reasoning=${reasoning}, service_tier=${serviceTier}`;
+}
+
+export async function handleCodexSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx: ExtensionContext, state: AdapterState, pi: ExtensionAPI) {
+	if (!state.config.responsesCompaction || !shouldUseCodexAdapter(ctx, state.config)) {
+		return undefined;
+	}
+
+	try {
+		return await handleCodexSessionBeforeCompactInner(event, ctx, state, pi);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		ctx.ui.notify(`OpenAI native compaction failed unexpectedly: ${message}; Pi compaction was not run.`, "error");
+		return { cancel: true };
+	}
+}
+
+async function handleCodexSessionBeforeCompactInner(event: SessionBeforeCompactEvent, ctx: ExtensionContext, state: AdapterState, pi: ExtensionAPI) {
+	if (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx)) {
+		ctx.ui.notify("OpenAI native compaction is enabled, but the current model is not Responses-compatible; Pi compaction was not run.", "error");
+		return { cancel: true };
+	}
+	if (event.signal.aborted) return { cancel: true };
+
+	const resolution = await resolveNativeCompactionEnvironment(ctx, { enabled: true });
+	if (!resolution.ok) {
+		ctx.ui.notify(`OpenAI native compaction is enabled but unavailable (${resolution.reason}); Pi compaction was not run.`, "error");
+		return { cancel: true };
+	}
+
+	const runtime = resolution.runtime;
+	const compactionModel = state.config.compactionModel;
+	const compactionTargetModel = { ...runtime.currentModel, id: compactionModel };
+	const requestOptions = buildCompactionRequestOptions(pi, ctx, state, compactionModel);
+	const branchEntries = ctx.sessionManager.getBranch();
+	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+	});
+
+	let request: NativeCompactionRequestBody;
+	let compactedKeptWindow = false;
+	if (latestNativeCompaction.ok) {
+		const compactedWindow = cloneCompactedWindow(latestNativeCompaction.entry.details?.compactedWindow ?? []);
+		if (!compactedWindow) {
+			ctx.ui.notify("OpenAI native compaction could not clone the previous compacted window; Pi compaction was not run.", "error");
+			return { cancel: true };
+		}
+		const liveTailEntries = branchEntries.slice(latestNativeCompaction.index + 1);
+		request = {
+			model: compactionModel,
+			input: [
+				...compactedWindow,
+				...serializeLiveTailToResponsesInput({ model: compactionTargetModel, entries: liveTailEntries }),
+			],
+			instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+			...requestOptions,
+		};
+	} else if (latestNativeCompaction.reason === "no-compaction") {
+		request = serializeCompactionPreparationToRequest({
+			model: compactionTargetModel,
+			preparation: event.preparation,
+			instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+			requestOptions,
+		});
+		if (request.input.length === 0) {
+			request = {
+				model: compactionModel,
+				input: serializeLiveTailToResponsesInput({ model: compactionTargetModel, entries: branchEntries }),
+				instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+				...requestOptions,
+			};
+			compactedKeptWindow = true;
+		}
+	} else {
+		void getCompactionIdentity(latestNativeCompaction.latestCompaction);
+		request = serializeCompactionPreparationToRequest({
+			model: compactionTargetModel,
+			preparation: event.preparation,
+			instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+			requestOptions,
+		});
+		if (request.input.length === 0) {
+			request = {
+				model: compactionModel,
+				input: serializeLiveTailToResponsesInput({ model: compactionTargetModel, entries: branchEntries }),
+				instructions: buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions),
+				...requestOptions,
+			};
+			compactedKeptWindow = true;
+		}
+	}
+
+	if (request.input.length === 0) {
+		ctx.ui.notify("OpenAI native compaction had no serializable conversation items; Pi compaction was not run.", "error");
+		return { cancel: true };
+	}
+
+	const compactResult = await executeNativeCompaction({ runtime, request, signal: event.signal });
+	if (!compactResult.ok) {
+		if (compactResult.reason !== "aborted") {
+			ctx.ui.notify(formatCompactFailureMessage(compactResult), "error");
+		}
+		return { cancel: true };
+	}
+	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 };
+	}
+	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 };
+	}
+	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 };
+	}
+	try {
+		const details = createNativeCompactionDetails({
+			provider: runtime.provider,
+			api: runtime.api,
+			model: compactionModel,
+			baseUrl: runtime.baseUrl,
+			compactedWindow,
+			compactResponseId: compactResult.compactResponseId,
+			createdAt: compactResult.createdAt,
+			requestMeta: { tokensBefore: event.preparation.tokensBefore, previousSummaryPresent: Boolean(event.preparation.previousSummary), compactedKeptWindow },
+		});
+		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 };
+	}
+}
+
+export async function rewriteCodexCompactedProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): Promise<unknown | undefined> {
+	if (!state.config.responsesCompaction || !shouldUseCodexAdapter(ctx, state.config) || (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx))) return undefined;
+	const resolution = await resolveNativeCompactionEnvironment(ctx, { enabled: true }, payload);
+	if (!resolution.ok) return undefined;
+	const runtime = resolution.runtime;
+	const branchEntries = ctx.sessionManager.getBranch();
+	const latestNativeCompaction = resolveLatestNativeCompactionEntry(branchEntries, {
+		provider: runtime.provider,
+		api: runtime.api,
+		baseUrl: runtime.baseUrl,
+	});
+	if (!latestNativeCompaction.ok) return undefined;
+	if (!runtime.payload) return undefined;
+	const rewrite = rewriteResponsesPayloadWithNativeReplay({ model: runtime.currentModel, payload: runtime.payload, branchEntries, compactionEntry: latestNativeCompaction.entry });
+	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);
+}

package/src/adapter/config.ts

@@ -3,10 +3,19 @@ import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
 export type CodexVerbosity = "low" | "medium" | "high";
+export type CompactionModel = "gpt-5.5" | "gpt-5.3-codex-spark" | "gpt-5.4-mini";
+export type CompactionReasoning = "current" | "minimal" | "low" | "medium" | "high" | "xhigh";
+
+export const COMPACTION_MODELS: readonly CompactionModel[] = ["gpt-5.5", "gpt-5.3-codex-spark", "gpt-5.4-mini"];
+export const COMPACTION_REASONING_LEVELS: readonly CompactionReasoning[] = ["current", "minimal", "low", "medium", "high", "xhigh"];
 
 export interface CodexConversionConfig {
+	applyPatchOnly: boolean;
 	fast: boolean;
 	imageGeneration: boolean;
+	compactionModel: CompactionModel;
+	compactionReasoning: CompactionReasoning;
+	responsesCompaction?: boolean;
 	statusLine: boolean;
 	useOnAllModels: boolean;
 	webSearch: boolean;
@@ -15,8 +24,12 @@ export interface CodexConversionConfig {
 
 export const CODEX_CONVERSION_CONFIG_BASENAME = "pi-codex-conversion.json";
 export const DEFAULT_CODEX_CONVERSION_CONFIG: CodexConversionConfig = {
+	applyPatchOnly: false,
 	fast: false,
 	imageGeneration: true,
+	compactionModel: "gpt-5.5",
+	compactionReasoning: "current",
+	responsesCompaction: false,
 	statusLine: true,
 	useOnAllModels: false,
 	webSearch: true,
@@ -33,6 +46,16 @@ export function normalizeCodexVerbosity(value: unknown): CodexVerbosity | undefi
 	return normalized === "low" || normalized === "medium" || normalized === "high" ? normalized : undefined;
 }
 
+export function normalizeCompactionModel(value: unknown): CompactionModel | undefined {
+	if (typeof value !== "string") return undefined;
+	return (COMPACTION_MODELS as readonly string[]).includes(value) ? (value as CompactionModel) : undefined;
+}
+
+export function normalizeCompactionReasoning(value: unknown): CompactionReasoning | undefined {
+	if (typeof value !== "string") return undefined;
+	return (COMPACTION_REASONING_LEVELS as readonly string[]).includes(value) ? (value as CompactionReasoning) : undefined;
+}
+
 export function getCodexConversionConfigPath(agentDir: string = getAgentDir()): string {
 	return join(agentDir, CODEX_CONVERSION_CONFIG_BASENAME);
 }
@@ -47,8 +70,12 @@ export function readCodexConversionConfig(configPath: string = getCodexConversio
 		const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as unknown;
 		if (!isObject(parsed)) return { ...DEFAULT_CODEX_CONVERSION_CONFIG };
 		return {
+			applyPatchOnly: typeof parsed.applyPatchOnly === "boolean" ? parsed.applyPatchOnly : DEFAULT_CODEX_CONVERSION_CONFIG.applyPatchOnly,
 			fast: typeof parsed.fast === "boolean" ? parsed.fast : DEFAULT_CODEX_CONVERSION_CONFIG.fast,
 			imageGeneration: typeof parsed.imageGeneration === "boolean" ? parsed.imageGeneration : DEFAULT_CODEX_CONVERSION_CONFIG.imageGeneration,
+			compactionModel: normalizeCompactionModel(parsed.compactionModel) ?? DEFAULT_CODEX_CONVERSION_CONFIG.compactionModel,
+			compactionReasoning: normalizeCompactionReasoning(parsed.compactionReasoning) ?? DEFAULT_CODEX_CONVERSION_CONFIG.compactionReasoning,
+			responsesCompaction: typeof parsed.responsesCompaction === "boolean" ? parsed.responsesCompaction : DEFAULT_CODEX_CONVERSION_CONFIG.responsesCompaction,
 			statusLine: typeof parsed.statusLine === "boolean" ? parsed.statusLine : DEFAULT_CODEX_CONVERSION_CONFIG.statusLine,
 			useOnAllModels: typeof parsed.useOnAllModels === "boolean" ? parsed.useOnAllModels : DEFAULT_CODEX_CONVERSION_CONFIG.useOnAllModels,
 			webSearch: typeof parsed.webSearch === "boolean" ? parsed.webSearch : DEFAULT_CODEX_CONVERSION_CONFIG.webSearch,

package/src/adapter/context-filter.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { CustomMessageEntry } from "@earendil-works/pi-coding-agent";
+import { IMAGE_SAVE_DISPLAY_MESSAGE_TYPE, WEB_SEARCH_ACTIVITY_MESSAGE_TYPE } from "../providers/openai-codex-custom-provider.ts";
+import { WEB_SEARCH_SESSION_NOTE_TYPE } from "../tools/web-search-tool.ts";
+import { NATIVE_COMPACTION_DISPLAY_MESSAGE_TYPE } from "./types.ts";
+
+const ADAPTER_CONTEXT_EXCLUDED_CUSTOM_MESSAGE_TYPES = new Set([
+	WEB_SEARCH_SESSION_NOTE_TYPE,
+	WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
+	IMAGE_SAVE_DISPLAY_MESSAGE_TYPE,
+	NATIVE_COMPACTION_DISPLAY_MESSAGE_TYPE,
+]);
+
+export function isAdapterContextExcludedCustomMessage(message: Pick<AgentMessage, "role"> & { customType?: string }): boolean {
+	return message.role === "custom" && typeof message.customType === "string" && ADAPTER_CONTEXT_EXCLUDED_CUSTOM_MESSAGE_TYPES.has(message.customType);
+}
+
+export function isAdapterContextExcludedCustomMessageEntry(entry: CustomMessageEntry): boolean {
+	return ADAPTER_CONTEXT_EXCLUDED_CUSTOM_MESSAGE_TYPES.has(entry.customType);
+}