@howaboua/pi-codex-conversion 1.5.5-dev.25.f80a775 → 1.5.5

package/src/adapter/compaction.ts

@@ -1,261 +0,0 @@
-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/context-filter.ts

@@ -1,20 +0,0 @@
-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);
-}

package/src/adapter/details-store.ts

@@ -1,151 +0,0 @@
-import type { CompactionEntry, SessionEntry } from "@earendil-works/pi-coding-agent";
-import {
-	isNativeCompactionDetails,
-	isNativeCompactionEntry,
-	type NativeCompactionDetails,
-	type NativeCompactionEntry,
-	type NativeCompactionIdentity,
-} from "./types";
-
-export type NativeCompactionEntryMatch = Partial<NativeCompactionIdentity>;
-
-export type LatestNativeCompactionResolutionFailureReason =
-	| "no-compaction"
-	| "latest-compaction-not-native"
-	| "latest-native-compaction-mismatch";
-
-export type LatestNativeCompactionResolution =
-	| {
-			ok: true;
-			entry: NativeCompactionEntry;
-			index: number;
-			latestCompactionIndex: number;
-	  }
-	| {
-			ok: false;
-			reason: LatestNativeCompactionResolutionFailureReason;
-			latestCompactionIndex?: number;
-			latestCompaction?: CompactionEntry;
-	  };
-
-function entryMatches(entry: NativeCompactionEntry, match: NativeCompactionEntryMatch): boolean {
-	const details = entry.details;
-	if (!details) {
-		return false;
-	}
-
-	return (
-		(match.provider === undefined || details.provider === match.provider) &&
-		(match.api === undefined || details.api === match.api) &&
-		(match.model === undefined || details.model === match.model) &&
-		(match.baseUrl === undefined || details.baseUrl === match.baseUrl)
-	);
-}
-
-export function getNativeCompactionDetails(
-	entry: CompactionEntry | SessionEntry | undefined,
-): NativeCompactionDetails | undefined {
-	if (!entry || entry.type !== "compaction") {
-		return undefined;
-	}
-
-	return isNativeCompactionDetails(entry.details) ? entry.details : undefined;
-}
-
-export function isPersistedNativeCompactionEntry(
-	entry: CompactionEntry | SessionEntry | undefined,
-): entry is NativeCompactionEntry {
-	return isNativeCompactionEntry(entry);
-}
-
-export function findLatestCompactionEntryIndex(entries: readonly SessionEntry[]): number | undefined {
-	for (let index = entries.length - 1; index >= 0; index--) {
-		if (entries[index]?.type === "compaction") {
-			return index;
-		}
-	}
-
-	return undefined;
-}
-
-export function findLatestCompactionEntry(entries: readonly SessionEntry[]): CompactionEntry | undefined {
-	const index = findLatestCompactionEntryIndex(entries);
-	return index === undefined ? undefined : (entries[index] as CompactionEntry);
-}
-
-export function findLatestNativeCompactionEntryIndex(
-	entries: readonly SessionEntry[],
-	match: NativeCompactionEntryMatch = {},
-): number | undefined {
-	for (let index = entries.length - 1; index >= 0; index--) {
-		const entry = entries[index];
-		if (!isPersistedNativeCompactionEntry(entry)) {
-			continue;
-		}
-
-		if (!entryMatches(entry, match)) {
-			continue;
-		}
-
-		return index;
-	}
-
-	return undefined;
-}
-
-export function findLatestNativeCompactionEntry(
-	entries: readonly SessionEntry[],
-	match: NativeCompactionEntryMatch = {},
-): NativeCompactionEntry | undefined {
-	const index = findLatestNativeCompactionEntryIndex(entries, match);
-	return index === undefined ? undefined : (entries[index] as NativeCompactionEntry);
-}
-
-export function findLatestNativeCompactionDetails(
-	entries: readonly SessionEntry[],
-	match: NativeCompactionEntryMatch = {},
-): NativeCompactionDetails | undefined {
-	return findLatestNativeCompactionEntry(entries, match)?.details;
-}
-
-export function resolveLatestNativeCompactionEntry(
-	entries: readonly SessionEntry[],
-	match: NativeCompactionEntryMatch = {},
-): LatestNativeCompactionResolution {
-	const latestCompactionIndex = findLatestCompactionEntryIndex(entries);
-	if (latestCompactionIndex === undefined) {
-		return {
-			ok: false,
-			reason: "no-compaction",
-		};
-	}
-
-	const latestCompaction = entries[latestCompactionIndex];
-	if (!latestCompaction || latestCompaction.type !== "compaction" || !isPersistedNativeCompactionEntry(latestCompaction)) {
-		return {
-			ok: false,
-			reason: "latest-compaction-not-native",
-			latestCompactionIndex,
-			latestCompaction:
-				latestCompaction && latestCompaction.type === "compaction"
-					? (latestCompaction as CompactionEntry)
-					: undefined,
-		};
-	}
-
-	if (!entryMatches(latestCompaction, match)) {
-		return {
-			ok: false,
-			reason: "latest-native-compaction-mismatch",
-			latestCompactionIndex,
-			latestCompaction,
-		};
-	}
-
-	return {
-		ok: true,
-		entry: latestCompaction,
-		index: latestCompactionIndex,
-		latestCompactionIndex,
-	};
-}