@nijaru/pi-provider-compaction 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nick Russo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# pi-provider-compaction
+
+Provider-native context compaction for [Pi](https://github.com/earendil-works/pi), with a portable Pi summary saved alongside the native checkpoint.
+
+[pi-compactor](https://github.com/nijaru/pi-compactor) owns **when** to compact and post-compaction continuation. This extension owns automatic provider protocol selection, native checkpoint persistence, and replay. `pi-fast-mode` and `pi-usage` remain independent.
+
+## Behavior
+
+No native compaction mode normally needs to be selected. The extension resolves it from the active Pi API adapter:
+
+| Pi API | Automatic native path |
+| --- | --- |
+| `openai-responses` | Standalone Responses `POST .../responses/compact` |
+| `azure-openai-responses` | Standalone Responses `POST .../responses/compact`, preserving the Azure request URL/query/auth produced by Pi |
+| `openai-codex-responses` | Codex Remote V2 via the normal Codex Responses transport plus `compaction_trigger` |
+| other APIs | Not claimed; Pi's normal compaction remains available |
+
+A custom provider using the `openai-responses` API is eligible automatically, but eligibility is not proof that its backend implements `/responses/compact`. A failed native attempt falls back to Pi rather than trying unrelated protocols or providers.
+
+The implementation deliberately uses Pi's active provider transport to construct request URLs, headers, OAuth/account state, deployment names, API versions, tools, and other provider-specific fields. It does not reconstruct Codex or Azure authentication from a provider label.
+
+## Native + portable state
+
+A successful compaction has two representations committed at one boundary:
+
+1. the provider-native opaque/canonical replay window; and
+2. the meaningful text summary Pi would normally save.
+
+The native representation is used when the current provider/API/model and route identity still match. If the model/provider changes, the extension is removed, or a later generic compaction supersedes the native checkpoint, Pi still has the text summary and retained recent messages.
+
+Producing both representations costs more than native-only compaction: the native request and the portable summarization request are both accounted in the saved compaction usage. `details.nativeUsage` and `details.portableUsage` keep the two components inspectable.
+
+Version-1 sessions containing the old opaque placeholder remain readable and replayable on their original compatible route. New compactions use version 2 and no longer write that placeholder. Historical v1 state is not rewritten in bulk.
+
+## Optional generic compaction-model override
+
+Native compaction is the default on supported routes. An explicitly configured generic compaction model still takes precedence, matching `pi-compactor`:
+
+1. `--compaction-model ...`;
+2. trusted `.pi/compaction-policy.json`; then
+3. agent `compaction-policy.json`.
+
+This is an override, not a required mode selector. An empty `models` list means no generic override, so automatic native routing can run.
+
+## Replay identity
+
+Native state is scoped to the producing provider, API, model, endpoint and relevant stable account/deployment metadata. Raw API keys, OAuth access tokens, and headers are never persisted. OAuth refresh for the same Codex account therefore does not invalidate a checkpoint merely because the access token changed.
+
+Azure checkpoints additionally record the effective API version and selected deployment when those values can be resolved from Pi's provider environment.
+
+## In-stream compaction
+
+OpenAI and Azure Responses can emit compaction items during an ordinary request through `context_management`. This extension does **not** enable that path yet.
+
+Pi 0.85.1 exposes a pre-request rewrite hook but no extension hook that receives the provider response body/stream. Adding `context_management` alone would let the server compact without giving the extension a reliable way to validate, persist, and replay the emitted checkpoint. Standalone compaction and Codex Remote V2 are therefore implemented now; in-stream compaction requires a Pi host response/checkpoint hook or equivalent persisted provider metadata.
+
+## Installation
+
+```bash
+pi install npm:@nijaru/pi-provider-compaction
+```
+
+Install [pi-compactor](https://github.com/nijaru/pi-compactor) separately for model-directed timing/context hints.
+
+## Development
+
+```bash
+bun install
+bun run check
+```
+
+Tests cover automatic route selection, standalone request bridging, Azure query preservation, Codex Remote V2 SSE capture, checkpoint validation, legacy parsing, identity-scoped replay, and direct request fixtures. Authenticated smoke tests are still required to claim a particular account/backend as live-verified.
+
+### Protocol references
+
+The transport/validation design was checked against Pi 0.85.1, OpenAI Codex's Remote V2 implementation, and `@narumitw/pi-codex-compact` from `narumiruna/pi-extensions` at tree `1c1ac2c0f371b38957719dc197afb54bc13bda43` (MIT). The owned implementation keeps its own product boundaries and portable-summary contract rather than installing that bundle.
+
+## Related extensions
+
+- [pi-compactor](https://github.com/nijaru/pi-compactor): when to compact and continuation lifecycle.
+- [pi-fast-mode](https://github.com/nijaru/pi-fast-mode): `/fast` and request service-tier policy.
+- [pi-usage](https://github.com/nijaru/pi-usage): read-only balances and quota reporting.
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,511 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { convertResponsesMessages } from "@earendil-works/pi-ai/api/openai-responses-shared";
+import { calculateCost } from "@earendil-works/pi-ai";
+import type { Context, Model, Tool, Usage } from "@earendil-works/pi-ai";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	SessionBeforeCompactEvent,
+	SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import {
+	compact,
+	convertToLlm,
+	sessionEntryToContextMessages,
+} from "@earendil-works/pi-coding-agent";
+import { resolveCompactionModelPolicy } from "./policy";
+import {
+	isCompactionItem,
+	isObject,
+	requestProviderCompaction,
+	resolveNativeProtocol,
+	supportsResponsesApi,
+	type NativeProtocol,
+	type ResponseItem,
+} from "./protocol";
+
+export const NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
+export const NATIVE_COMPACTION_VERSION = 2;
+/** Legacy v1 visible summary, retained only for old sessions/tests. New compactions persist a real portable summary. */
+export const NATIVE_COMPACTION_SUMMARY =
+	"This context was compacted using the provider's native OpenAI Responses state.";
+
+const TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+
+type JsonObject = Record<string, unknown>;
+type FetchImplementation = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+export interface NativeIdentity {
+	endpoint: string;
+	organization?: string;
+	project?: string;
+	accountId?: string;
+	azureApiVersion?: string;
+	azureDeployment?: string;
+}
+
+export interface NativeCompactionDetails {
+	type: typeof NATIVE_COMPACTION_TYPE;
+	version: 1 | typeof NATIVE_COMPACTION_VERSION;
+	provider: string;
+	api: string;
+	model: string;
+	protocol: NativeProtocol;
+	identity?: NativeIdentity;
+	output: ResponseItem[];
+	/** Native protocol usage. `usage` is a legacy alias accepted for v1 compatibility. */
+	nativeUsage?: Usage;
+	usage?: Usage;
+	portableUsage?: Usage;
+	readFiles?: string[];
+	modifiedFiles?: string[];
+}
+
+interface NativeCompactionState extends NativeCompactionDetails {
+	entryId: string;
+}
+
+export function supportsNativeCompaction(model: Model<any> | undefined): model is Model<any> {
+	return supportsResponsesApi(model);
+}
+
+function readUsage(value: unknown): Usage | undefined {
+	if (!isObject(value) || !isObject(value.cost)) return undefined;
+	for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"] as const) {
+		if (typeof value[key] !== "number" || !Number.isFinite(value[key])) return undefined;
+	}
+	for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"] as const) {
+		if (typeof value.cost[key] !== "number" || !Number.isFinite(value.cost[key])) return undefined;
+	}
+	return value as unknown as Usage;
+}
+
+function readIdentity(value: unknown): NativeIdentity | undefined {
+	if (!isObject(value) || typeof value.endpoint !== "string" || !value.endpoint) return undefined;
+	for (const key of ["organization", "project", "accountId", "azureApiVersion", "azureDeployment"] as const) {
+		if (value[key] !== undefined && typeof value[key] !== "string") return undefined;
+	}
+	return {
+		endpoint: value.endpoint,
+		organization: value.organization as string | undefined,
+		project: value.project as string | undefined,
+		accountId: value.accountId as string | undefined,
+		azureApiVersion: value.azureApiVersion as string | undefined,
+		azureDeployment: value.azureDeployment as string | undefined,
+	};
+}
+
+export function readNativeCompactionDetails(value: unknown): NativeCompactionDetails | undefined {
+	if (!isObject(value) || value.type !== NATIVE_COMPACTION_TYPE) return undefined;
+	if (value.version !== 1 && value.version !== NATIVE_COMPACTION_VERSION) return undefined;
+	if (typeof value.provider !== "string" || typeof value.api !== "string" || typeof value.model !== "string") return undefined;
+	if (!Array.isArray(value.output) || !value.output.every(isObject) || !value.output.some(isCompactionItem)) return undefined;
+	const protocol = value.version === 1
+		? "responses-compact"
+		: value.protocol === "responses-compact" || value.protocol === "remote-v2"
+			? value.protocol
+			: undefined;
+	if (!protocol) return undefined;
+	const strings = (candidate: unknown): string[] | undefined =>
+		candidate === undefined ? undefined : Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? [...candidate] : undefined;
+	return {
+		type: NATIVE_COMPACTION_TYPE,
+		version: value.version,
+		provider: value.provider,
+		api: value.api,
+		model: value.model,
+		protocol,
+		identity: value.version === 1 ? undefined : readIdentity(value.identity),
+		output: structuredClone(value.output) as ResponseItem[],
+		nativeUsage: readUsage(value.nativeUsage ?? value.usage),
+		usage: readUsage(value.usage),
+		portableUsage: readUsage(value.portableUsage),
+		readFiles: strings(value.readFiles),
+		modifiedFiles: strings(value.modifiedFiles),
+	};
+}
+
+function identityEqual(left: NativeIdentity | undefined, right: NativeIdentity | undefined): boolean {
+	if (!left) return true;
+	if (!right) return false;
+	return left.endpoint === right.endpoint && left.organization === right.organization && left.project === right.project && left.accountId === right.accountId && left.azureApiVersion === right.azureApiVersion && left.azureDeployment === right.azureDeployment;
+}
+
+export function findLatestNativeCompaction(
+	entries: readonly SessionEntry[],
+	model: Model<any> | undefined,
+	identity?: NativeIdentity,
+): NativeCompactionState | undefined {
+	if (!supportsNativeCompaction(model)) return undefined;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (entry.type !== "compaction") continue;
+		const details = readNativeCompactionDetails(entry.details);
+		if (!details) return undefined;
+		if (details.provider !== model.provider || details.api !== model.api || details.model !== model.id) return undefined;
+		if (!identityEqual(details.identity, identity)) return undefined;
+		return { ...details, entryId: entry.id };
+	}
+	return undefined;
+}
+
+function responseItemsFromMessages(model: Model<any>, messages: AgentMessage[]): ResponseItem[] {
+	const input = convertResponsesMessages(
+		model,
+		{ messages: convertToLlm(messages), tools: [] },
+		TOOL_CALL_PROVIDERS,
+		{ includeSystemPrompt: false },
+	);
+	return input.filter(isObject) as unknown as ResponseItem[];
+}
+
+function responseItemsFromEntries(model: Model<any>, entries: readonly SessionEntry[]): ResponseItem[] {
+	return responseItemsFromMessages(model, entries.flatMap((entry) => sessionEntryToContextMessages(entry)));
+}
+
+function nativeRequestInput(
+	model: Model<any>,
+	branchEntries: readonly SessionEntry[],
+	activeEntries: readonly SessionEntry[],
+	previous: NativeCompactionState | undefined,
+): ResponseItem[] {
+	if (previous) {
+		const previousIndex = branchEntries.findIndex((entry) => entry.id === previous.entryId);
+		if (previousIndex >= 0) {
+			return [...structuredClone(previous.output), ...responseItemsFromEntries(model, branchEntries.slice(previousIndex + 1))];
+		}
+	}
+	return responseItemsFromEntries(model, activeEntries);
+}
+
+function authHeaders(apiKey: string | undefined, headers: Record<string, string | null> | undefined): Record<string, string> {
+	const result: Record<string, string> = { "content-type": "application/json" };
+	let hasAuthorization = false;
+	for (const [name, value] of Object.entries(headers ?? {})) {
+		if (value === null) continue;
+		result[name] = value;
+		if (name.toLowerCase() === "authorization" && value.trim()) hasAuthorization = true;
+	}
+	if (!hasAuthorization && apiKey) result.authorization = `Bearer ${apiKey}`;
+	return result;
+}
+
+export interface CompactRequestOptions {
+	model: Model<any>;
+	baseUrl: string;
+	apiKey?: string;
+	headers?: Record<string, string | null>;
+	input: ResponseItem[];
+	instructions?: string;
+	signal?: AbortSignal;
+	fetchImpl?: FetchImplementation;
+}
+
+export async function compactOpenAIResponses(options: CompactRequestOptions): Promise<NativeCompactionDetails> {
+	const endpoint = `${options.baseUrl.replace(/\/+$/, "")}/responses/compact`;
+	const body: JsonObject = { model: options.model.id, input: options.input };
+	if (options.instructions) body.instructions = options.instructions;
+	const response = await (options.fetchImpl ?? fetch)(endpoint, {
+		method: "POST",
+		headers: authHeaders(options.apiKey, options.headers),
+		body: JSON.stringify(body),
+		signal: options.signal,
+	});
+	if (!response.ok) {
+		const detail = await response.text().catch(() => "");
+		throw new Error(`OpenAI Responses compact request failed (${response.status}${detail ? `: ${detail.slice(0, 400)}` : ""})`);
+	}
+	const result: unknown = await response.json();
+	if (!isObject(result) || !Array.isArray(result.output) || !result.output.every(isObject) || !result.output.some(isCompactionItem)) {
+		throw new Error("OpenAI Responses compact response did not contain opaque compaction state");
+	}
+	const usage = compactUsage(options.model, result);
+	return {
+		type: NATIVE_COMPACTION_TYPE,
+		version: NATIVE_COMPACTION_VERSION,
+		provider: options.model.provider,
+		api: options.model.api,
+		model: options.model.id,
+		protocol: "responses-compact",
+		output: structuredClone(result.output) as ResponseItem[],
+		nativeUsage: usage,
+		usage,
+	};
+}
+
+function compactUsage(model: Model<any>, result: JsonObject): Usage | undefined {
+	const usage = result.usage;
+	if (!isObject(usage)) return undefined;
+	const cached = nestedNumber(usage.input_tokens_details, "cached_tokens");
+	const cacheWrite = nestedNumber(usage.input_tokens_details, "cache_write_tokens");
+	const mapped: Usage = {
+		input: Math.max(0, readNumber(usage.input_tokens) - cached - cacheWrite),
+		output: readNumber(usage.output_tokens),
+		cacheRead: cached,
+		cacheWrite,
+		reasoning: nestedNumber(usage.output_tokens_details, "reasoning_tokens"),
+		totalTokens: readNumber(usage.total_tokens),
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+	try { calculateCost(model, mapped); } catch {}
+	return mapped;
+}
+
+function readNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function nestedNumber(value: unknown, key: string): number {
+	return isObject(value) ? readNumber(value[key]) : 0;
+}
+
+function stableStringify(value: unknown): string {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isObject(value)) {
+		return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+	}
+	return JSON.stringify(value) ?? "null";
+}
+
+function itemMatches(left: ResponseItem, right: ResponseItem): boolean {
+	const leftId = typeof left.id === "string" ? left.id : undefined;
+	const rightId = typeof right.id === "string" ? right.id : undefined;
+	if (leftId && rightId) return leftId === rightId;
+	const leftCallId = typeof left.call_id === "string" ? left.call_id : undefined;
+	const rightCallId = typeof right.call_id === "string" ? right.call_id : undefined;
+	if (leftCallId && rightCallId) return leftCallId === rightCallId && left.type === right.type;
+	if (left.type === "message" && right.type === "message") {
+		return left.role === right.role && stableStringify(left.content) === stableStringify(right.content);
+	}
+	return stableStringify(left) === stableStringify(right);
+}
+
+function findLastSubsequence(items: ResponseItem[], sequence: ResponseItem[]): number {
+	if (sequence.length === 0) return -1;
+	for (let start = items.length - sequence.length; start >= 0; start--) {
+		if (sequence.every((item, offset) => itemMatches(items[start + offset], item))) return start;
+	}
+	return -1;
+}
+
+export function rewriteResponsesPayload(
+	payload: unknown,
+	details: NativeCompactionDetails,
+	postCompactionItems: ResponseItem[],
+): unknown {
+	if (!isObject(payload) || !Array.isArray(payload.input)) return payload;
+	const currentInput = payload.input.filter(isObject) as ResponseItem[];
+	if (currentInput.length !== payload.input.length) return payload;
+	const postStart = findLastSubsequence(currentInput, postCompactionItems);
+	if (postStart >= 0) return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(postStart)] };
+	const retainedOutput = details.output.filter((item) => item.type !== "compaction");
+	const retainedStart = findLastSubsequence(currentInput, retainedOutput);
+	if (retainedStart >= 0) {
+		return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(retainedStart + retainedOutput.length)] };
+	}
+	return { ...payload, input: [...structuredClone(details.output), ...structuredClone(postCompactionItems)] };
+}
+
+function genericCompactionSelected(
+	pi: Pick<ExtensionAPI, "getFlag">,
+	ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted" | "sessionManager">,
+): boolean {
+	return resolveCompactionModelPolicy(pi, ctx).hasSelectors;
+}
+
+function normalizedEndpoint(value: string | undefined): string {
+	if (!value) return "";
+	try {
+		const url = new URL(value);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		url.hash = "";
+		return url.toString().replace(/\/+$/, "");
+	} catch {
+		return value.replace(/\/+$/, "");
+	}
+}
+
+function headerValue(headers: Record<string, string | null> | undefined, name: string): string | undefined {
+	const match = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name.toLowerCase());
+	return typeof match?.[1] === "string" && match[1] ? match[1] : undefined;
+}
+
+function codexAccountId(apiKey: string | undefined): string | undefined {
+	if (!apiKey) return undefined;
+	const parts = apiKey.split(".");
+	if (parts.length !== 3) return undefined;
+	try {
+		const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+		if (!isObject(payload)) return undefined;
+		const auth = payload["https://api.openai.com/auth"];
+		return isObject(auth) && typeof auth.chatgpt_account_id === "string" ? auth.chatgpt_account_id : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function azureDeployment(modelId: string, env: Record<string, string> | undefined): string {
+	const raw = env?.AZURE_OPENAI_DEPLOYMENT_NAME_MAP;
+	if (!raw) return modelId;
+	for (const entry of raw.split(",")) {
+		const [candidate, deployment] = entry.split("=", 2).map((part) => part?.trim());
+		if (candidate === modelId && deployment) return deployment;
+	}
+	return modelId;
+}
+
+function routeIdentity(
+	model: Model<any>,
+	auth: { apiKey?: string; headers?: Record<string, string | null>; baseUrl?: string; env?: Record<string, string> },
+): NativeIdentity {
+	const azure = model.api === "azure-openai-responses";
+	return {
+		endpoint: normalizedEndpoint(auth.baseUrl ?? auth.env?.AZURE_OPENAI_BASE_URL ?? model.baseUrl),
+		organization: headerValue(auth.headers, "openai-organization"),
+		project: headerValue(auth.headers, "openai-project"),
+		accountId: model.api === "openai-codex-responses" ? codexAccountId(auth.apiKey) : undefined,
+		azureApiVersion: azure ? (auth.env?.AZURE_OPENAI_API_VERSION || "v1") : undefined,
+		azureDeployment: azure ? azureDeployment(model.id, auth.env) : undefined,
+	};
+}
+
+function activeTools(pi: ExtensionAPI): Tool[] {
+	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 providerContext(pi: ExtensionAPI, ctx: ExtensionContext, activeEntries: readonly SessionEntry[]): Context {
+	const messages = activeEntries.flatMap((entry) => sessionEntryToContextMessages(entry));
+	return {
+		systemPrompt: ctx.getSystemPrompt(),
+		messages: convertToLlm(messages),
+		tools: activeTools(pi),
+	};
+}
+
+function cleanHeaders(headers: Record<string, string | null> | undefined): Record<string, string> | undefined {
+	if (!headers) return undefined;
+	return Object.fromEntries(Object.entries(headers).filter((entry): entry is [string, string] => entry[1] !== null));
+}
+
+function combineUsage(first: Usage | undefined, second: Usage | undefined): Usage | undefined {
+	if (!first) return second;
+	if (!second) return first;
+	return {
+		input: first.input + second.input,
+		output: first.output + second.output,
+		cacheRead: first.cacheRead + second.cacheRead,
+		cacheWrite: first.cacheWrite + second.cacheWrite,
+		cacheWrite1h: first.cacheWrite1h !== undefined || second.cacheWrite1h !== undefined ? (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) : undefined,
+		reasoning: first.reasoning !== undefined || second.reasoning !== undefined ? (first.reasoning ?? 0) + (second.reasoning ?? 0) : undefined,
+		totalTokens: first.totalTokens + second.totalTokens,
+		cost: {
+			input: first.cost.input + second.cost.input,
+			output: first.cost.output + second.cost.output,
+			cacheRead: first.cost.cacheRead + second.cost.cacheRead,
+			cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
+			total: first.cost.total + second.cost.total,
+		},
+	};
+}
+
+async function nativeAndPortableCompaction(
+	pi: ExtensionAPI,
+	event: SessionBeforeCompactEvent,
+	ctx: ExtensionContext,
+) {
+	const model = ctx.model;
+	const protocol = resolveNativeProtocol(model);
+	if (!model || !protocol || genericCompactionSelected(pi, ctx)) return undefined;
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (!auth.ok) return undefined;
+	const provider = ctx.modelRegistry.getProvider(model.provider);
+	if (!provider) return undefined;
+	const identity = routeIdentity(model, auth);
+	const branchEntries = event.branchEntries;
+	const activeEntries = ctx.sessionManager.buildContextEntries();
+	const previous = findLatestNativeCompaction(branchEntries, model, identity);
+	const input = nativeRequestInput(model, branchEntries, activeEntries, previous);
+	const native = await requestProviderCompaction({
+		provider,
+		model,
+		context: providerContext(pi, ctx, activeEntries),
+		input,
+		protocol,
+		apiKey: auth.apiKey,
+		headers: auth.headers,
+		env: auth.env,
+		signal: event.signal,
+	});
+	const portable = await compact(
+		event.preparation,
+		model,
+		auth.apiKey,
+		cleanHeaders(auth.headers),
+		event.customInstructions,
+		event.signal,
+		ctx.thinkingLevel,
+		provider.streamSimple.bind(provider),
+		auth.env,
+		undefined,
+		undefined,
+		ctx.sessionManager.getSessionId(),
+	);
+	const portableDetails = isObject(portable.details) ? portable.details : {};
+	const details: NativeCompactionDetails = {
+		type: NATIVE_COMPACTION_TYPE,
+		version: NATIVE_COMPACTION_VERSION,
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		protocol,
+		identity,
+		output: native.output,
+		nativeUsage: native.usage,
+		portableUsage: portable.usage,
+		readFiles: Array.isArray(portableDetails.readFiles) ? portableDetails.readFiles.filter((item): item is string => typeof item === "string") : undefined,
+		modifiedFiles: Array.isArray(portableDetails.modifiedFiles) ? portableDetails.modifiedFiles.filter((item): item is string => typeof item === "string") : undefined,
+	};
+	return {
+		compaction: {
+			...portable,
+			usage: combineUsage(native.usage, portable.usage),
+			details,
+		},
+	};
+}
+
+export default function (pi: ExtensionAPI): void {
+	pi.on("before_provider_request", async (event, ctx) => {
+		const model = ctx.model;
+		if (!supportsNativeCompaction(model)) return;
+		const branch = ctx.sessionManager.getBranch();
+		const candidate = findLatestNativeCompaction(branch, model);
+		if (!candidate || genericCompactionSelected(pi, ctx)) return;
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok) return;
+		const latest = findLatestNativeCompaction(branch, model, routeIdentity(model, auth));
+		if (!latest) return;
+		const index = branch.findIndex((entry: SessionEntry) => entry.id === latest.entryId);
+		const postItems = index >= 0 ? responseItemsFromEntries(model, branch.slice(index + 1)) : [];
+		const rewritten = rewriteResponsesPayload(event.payload, latest, postItems);
+		if (rewritten === event.payload || !isObject(rewritten)) return rewritten;
+		const systemPrompt = ctx.getSystemPrompt();
+		return systemPrompt ? { ...rewritten, instructions: systemPrompt } : rewritten;
+	});
+
+	pi.on("session_before_compact", async (event, ctx) => {
+		try {
+			return await nativeAndPortableCompaction(pi, event, ctx);
+		} catch (error) {
+			if (event.signal.aborted || (error instanceof Error && error.name === "AbortError")) return undefined;
+			console.error(`[pi-provider-compaction] native compaction failed: ${error instanceof Error ? error.message : String(error)}`);
+			return undefined;
+		}
+	});
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@nijaru/pi-provider-compaction",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Provider-native context compaction adapters for Pi",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "compaction",
+    "openai",
+    "responses"
+  ],
+  "license": "MIT",
+
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Nick Naru <nick@nijaru.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nijaru/pi-provider-compaction.git"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "bun test",
+    "lint": "oxlint index.ts protocol.ts policy.ts tests/",
+    "typecheck": "tsc --noEmit",
+    "check": "bun test && oxlint index.ts protocol.ts policy.ts tests/ && tsc --noEmit"
+  },
+  "files": [
+    "index.ts",
+    "protocol.ts",
+    "policy.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@earendil-works/pi-agent-core": "0.85.1",
+    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@types/bun": "latest",
+    "oxlint": "^1.81.0",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/policy.ts

@@ -0,0 +1,213 @@
+/**
+ * Generic-compaction-model precedence resolution shared with pi-compactor.
+ *
+ * When pi-compactor's generic compaction model is configured — via the
+ * `compaction-model` flag or a `compaction-policy.json` file — the explicit
+ * generic model takes precedence over provider-native compaction: this
+ * extension must not request a native compaction and must not replay a
+ * previously persisted native window.
+ *
+ * Pi scopes `getFlag` to flags the calling extension registered, and Pi
+ * rejects two extensions registering the same flag name. This extension
+ * therefore never registers `compaction-model` (owned by pi-compactor) and
+ * reads the shared CLI value from `process.argv` instead. The policy-file
+ * fallback mirrors pi-compactor exactly: project policy requires project
+ * trust; the agent-dir policy does not; a valid file with an empty `models`
+ * list disables the generic model. This module must stay in sync with
+ * `readModelSelectors` in pi-compactor's policy.ts (see
+ * tests/policy-parity.test.ts, which checks the two against each other when
+ * the sibling checkout is present).
+ *
+ * Flag-source note (verified against Pi 0.85.1): extension flag values are
+ * populated solely from CLI unknown flags (parseArgs in cli/args.js feeds
+ * extensionFlagValues in main.js, applied by applyExtensionFlagValues in
+ * agent-session-services.js). There is no config-file flag source, so reading
+ * process.argv with Pi's exact parsing rules observes every flag value the
+ * host can deliver. A programmatic SDK host injecting extensionFlagValues
+ * without argv would not be seen here; flag scoping provides no shared read
+ * API for that path.
+ */
+
+import {
+	CONFIG_DIR_NAME,
+	getAgentDir,
+	hasTrustRequiringProjectResources,
+	ProjectTrustStore,
+} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+
+export const COMPACTION_MODEL_FLAG = "compaction-model";
+const PROJECT_POLICY = "compaction-policy.json";
+const AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
+const MAX_POLICY_BYTES = 64 * 1024;
+const MAX_MODEL_SELECTORS = 8;
+const MAX_SELECTOR_LENGTH = 512;
+
+type PolicyContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted"> & {
+	sessionManager?: Pick<ExtensionContext["sessionManager"], "getSessionDir">;
+};
+
+export type CompactionModelSource = "flag" | "project-policy" | "agent-policy";
+
+export interface CompactionModelPolicy {
+	/** True when a generic compaction model takes precedence over native compaction. */
+	hasSelectors: boolean;
+	/** Where the selectors were resolved from, for diagnostics. */
+	source?: CompactionModelSource;
+}
+
+function normalizeSelector(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const selector = value.trim();
+	if (selector.length === 0 || selector.length > MAX_SELECTOR_LENGTH) return undefined;
+	return selector;
+}
+
+function parsePolicySelectors(value: unknown): string[] | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	if (!("models" in value) || !Array.isArray(value.models)) return undefined;
+
+	const selectors: string[] = [];
+	for (const model of value.models) {
+		const selector = normalizeSelector(model);
+		if (selector === undefined || selectors.includes(selector)) continue;
+		selectors.push(selector);
+		if (selectors.length === MAX_MODEL_SELECTORS) break;
+	}
+	return selectors;
+}
+
+function readPolicySelectors(configPath: string): string[] | undefined {
+	let fd: number | undefined;
+	try {
+		fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+		const stat = fstatSync(fd);
+		if (!stat.isFile() || stat.size > MAX_POLICY_BYTES) return undefined;
+
+		// Read a bounded amount from the opened regular file. This avoids both
+		// FIFO blocking and a stat/read TOCTOU defeating the size limit.
+		const buffer = Buffer.allocUnsafe(MAX_POLICY_BYTES + 1);
+		let bytesRead = 0;
+		while (bytesRead < buffer.length) {
+			const count = readSync(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+			if (count === 0) break;
+			bytesRead += count;
+		}
+		if (bytesRead > MAX_POLICY_BYTES) return undefined;
+		return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")) as unknown);
+	} catch {
+		// A malformed or unreadable policy must not prevent native compaction.
+		return undefined;
+	} finally {
+		if (fd !== undefined) {
+			try {
+				closeSync(fd);
+			} catch {
+				// The policy is optional; a close failure must not break compaction.
+			}
+		}
+	}
+}
+
+function activeAgentDir(ctx: PolicyContext): string {
+	const override = process.env[AGENT_DIR_OVERRIDE]?.trim();
+	if (override) return resolve(override);
+
+	try {
+		const sessionDir = ctx.sessionManager?.getSessionDir();
+		if (sessionDir) {
+			const resolvedCwd = resolve(ctx.cwd);
+			const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+			const suffix = `${sep}${join("sessions", safePath)}`;
+			const resolvedSessionDir = resolve(sessionDir);
+			if (resolvedSessionDir.endsWith(suffix)) {
+				return resolvedSessionDir.slice(0, -suffix.length);
+			}
+		}
+	} catch {
+		// Fall back to Pi's configured directory when the SDK session is custom.
+	}
+	return getAgentDir();
+}
+
+function isProjectPolicyTrusted(ctx: PolicyContext, agentDir: string): boolean {
+	try {
+		if (!ctx.isProjectTrusted()) return false;
+		// Pi does not treat this custom filename as a trust-requiring resource.
+		// Also accept an explicit saved trust decision for policy-only projects.
+		return hasTrustRequiringProjectResources(ctx.cwd) || new ProjectTrustStore(agentDir).get(ctx.cwd) === true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Read the shared `--compaction-model` CLI value without registering the flag.
+ * Mirrors Pi's unknown-flag parsing: `--compaction-model value` and
+ * `--compaction-model=value`; a bare flag yields `true`. Stops at `--`.
+ * Last occurrence wins, matching Pi's Map.set behavior.
+ */
+export function readCompactionModelFlagFromArgv(argv: readonly string[] = process.argv.slice(2)): string | boolean | undefined {
+	let value: string | boolean | undefined;
+	const prefix = `--${COMPACTION_MODEL_FLAG}=`;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--") break;
+		if (arg === `--${COMPACTION_MODEL_FLAG}`) {
+			const next = argv[i + 1];
+			if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+				value = next;
+				i++;
+			} else {
+				value = true;
+			}
+		} else if (arg.startsWith(prefix)) {
+			value = arg.slice(prefix.length);
+		}
+	}
+	return value;
+}
+
+/** Resolve whether pi-compactor's generic compaction model takes precedence. */
+export function resolveCompactionModelPolicy(
+	pi: Pick<ExtensionAPI, "getFlag">,
+	ctx: PolicyContext,
+	argv: readonly string[] = process.argv.slice(2),
+): CompactionModelPolicy {
+	const argvRaw = readCompactionModelFlagFromArgv(argv);
+	if (typeof argvRaw === "string" && argvRaw.trim()) {
+		const selector = normalizeSelector(argvRaw);
+		return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+	}
+	// A bare `--compaction-model` (true) or whitespace value falls through like
+	// pi-compactor: Pi reports "requires a value" and the policy files still apply.
+	// An oversized selector above already returned hasSelectors:false.
+	try {
+		const rawFlag = pi.getFlag(COMPACTION_MODEL_FLAG);
+		if (typeof rawFlag === "string" && rawFlag.trim()) {
+			const selector = normalizeSelector(rawFlag);
+			return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+		}
+	} catch {
+		// getFlag can throw on a stale context; fall through to policy files.
+	}
+
+	const agentDir = activeAgentDir(ctx);
+	const candidates: Array<{ path: string; source: CompactionModelSource }> = [];
+	if (isProjectPolicyTrusted(ctx, agentDir)) {
+		candidates.push({ path: join(ctx.cwd, CONFIG_DIR_NAME, PROJECT_POLICY), source: "project-policy" });
+	}
+	candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
+
+	for (const candidate of candidates) {
+		const selectors = readPolicySelectors(candidate.path);
+		// A readable policy stops the search: an empty models list is an
+		// explicit choice to use no generic compaction model.
+		if (selectors !== undefined) {
+			return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+		}
+	}
+	return { hasSelectors: false };
+}

package/protocol.ts

@@ -0,0 +1,402 @@
+import type {
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	Provider,
+	ProviderHeaders,
+	Usage,
+} from "@earendil-works/pi-ai";
+
+export type JsonObject = Record<string, unknown>;
+export type ResponseItem = JsonObject;
+export type NativeProtocol = "responses-compact" | "remote-v2";
+
+const RESPONSES_APIS = new Set([
+	"openai-responses",
+	"openai-codex-responses",
+	"azure-openai-responses",
+]);
+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+const MAX_ITEM_BYTES = 2 * 1024 * 1024;
+const REMOTE_RETAINED_BYTES = 8 * 1024 * 1024;
+const REMOTE_RETAINED_CHARS = 64_000 * 4;
+
+export function isObject(value: unknown): value is JsonObject {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function supportsResponsesApi(model: Model<any> | undefined): model is Model<any> {
+	return model !== undefined && RESPONSES_APIS.has(String(model.api));
+}
+
+export function resolveNativeProtocol(model: Model<any> | undefined): NativeProtocol | undefined {
+	if (!supportsResponsesApi(model)) return undefined;
+	return model.api === "openai-codex-responses" ? "remote-v2" : "responses-compact";
+}
+
+export function isCompactionItem(value: unknown): value is ResponseItem {
+	return isObject(value) && value.type === "compaction" && typeof value.encrypted_content === "string" && value.encrypted_content.length > 0;
+}
+
+function byteLength(value: unknown): number {
+	return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+function validateItemSize(item: ResponseItem): void {
+	if (byteLength(item) > MAX_ITEM_BYTES) throw new Error("Native compaction output item exceeded 2 MiB");
+}
+
+export function validateCompactedOutput(value: unknown): ResponseItem[] {
+	if (!isObject(value) || !Array.isArray(value.output) || value.output.length === 0) {
+		throw new Error("Responses Compact returned an invalid output window");
+	}
+	const output = value.output.map((item) => {
+		if (!isObject(item)) throw new Error("Responses Compact returned a non-object output item");
+		validateItemSize(item);
+		return structuredClone(item);
+	});
+	const checkpoints = output.filter(isCompactionItem);
+	if (checkpoints.length !== 1) {
+		throw new Error(`Responses Compact returned ${checkpoints.length} compaction items; expected exactly one`);
+	}
+	return output;
+}
+
+async function readJsonBounded(response: Response, signal: AbortSignal): Promise<unknown> {
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) {
+		await response.body?.cancel().catch(() => undefined);
+		throw new Error("Native compaction response exceeded 8 MiB");
+	}
+	if (!response.body) throw new Error("Native compaction response did not contain a body");
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let total = 0;
+	const onAbort = () => void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => undefined);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (true) {
+			if (signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
+			const { done, value } = await reader.read();
+			if (done) break;
+			total += value.byteLength;
+			if (total > MAX_RESPONSE_BYTES) throw new Error("Native compaction response exceeded 8 MiB");
+			chunks.push(value);
+		}
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	try {
+		return JSON.parse(new TextDecoder().decode(bytes));
+	} catch {
+		throw new Error("Native compaction response returned malformed JSON");
+	}
+}
+
+function requestUrl(input: string | URL | Request): URL {
+	return new URL(input instanceof Request ? input.url : String(input));
+}
+
+export function responsesCompactUrl(input: string | URL | Request): URL {
+	const original = requestUrl(input);
+	if (!original.pathname.endsWith("/responses")) {
+		throw new Error("Provider request URL does not end with /responses");
+	}
+	const compact = new URL(original);
+	compact.pathname = `${compact.pathname}/compact`;
+	if (compact.origin !== original.origin) throw new Error("Responses Compact URL changed origin");
+	return compact;
+}
+
+function mergedHeaders(input: string | URL | Request, init?: RequestInit): Headers {
+	const headers = new Headers(input instanceof Request ? input.headers : undefined);
+	new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+	headers.delete("content-encoding");
+	headers.delete("content-length");
+	headers.set("accept", "application/json");
+	headers.set("content-type", "application/json");
+	return headers;
+}
+
+function compactPayload(payload: JsonObject): JsonObject {
+	const allowed = [
+		"model",
+		"input",
+		"instructions",
+		"previous_response_id",
+		"prompt_cache_key",
+		"prompt_cache_retention",
+		"service_tier",
+	] as const;
+	const result: JsonObject = {};
+	for (const key of allowed) {
+		if (Object.hasOwn(payload, key) && payload[key] !== undefined) result[key] = structuredClone(payload[key]);
+	}
+	if (typeof result.model !== "string" || !Array.isArray(result.input)) {
+		throw new Error("Provider did not expose a valid Responses payload for compaction");
+	}
+	return result;
+}
+
+function errorResponse(error: unknown): Response {
+	return Response.json(
+		{ error: { message: error instanceof Error ? error.message : String(error), type: "invalid_request_error" } },
+		{ status: 400 },
+	);
+}
+
+function rawUsage(response: JsonObject): JsonObject {
+	if (!isObject(response.usage)) throw new Error("Native compaction response is missing usage");
+	return structuredClone(response.usage);
+}
+
+function syntheticCompletion(response: JsonObject, payload: JsonObject): Response {
+	const completed = {
+		id: typeof response.id === "string" ? response.id : "resp_pi_provider_compaction",
+		object: "response",
+		created_at: typeof response.created_at === "number" ? response.created_at : Math.floor(Date.now() / 1000),
+		status: "completed",
+		model: payload.model,
+		output: [],
+		parallel_tool_calls: false,
+		tool_choice: "auto",
+		tools: [],
+		usage: rawUsage(response),
+	};
+	const body = [
+		{ type: "response.created", response: { ...completed, status: "in_progress" } },
+		{ type: "response.completed", response: completed },
+	]
+		.map((event) => `data: ${JSON.stringify(event)}\n\n`)
+		.join("");
+	return new Response(body, { status: 200, headers: { "content-type": "text/event-stream" } });
+}
+
+async function collectProviderUsage(stream: AssistantMessageEventStream, signal: AbortSignal): Promise<Usage> {
+	let usage: Usage | undefined;
+	for await (const event of stream) {
+		if (signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
+		if (event.type === "error") throw new Error(event.error.errorMessage ?? "Native compaction provider request failed");
+		if (event.type === "done") usage = event.message.usage;
+	}
+	if (!usage) throw new Error("Native compaction provider stream ended without usage");
+	return usage;
+}
+
+interface TransportRequest {
+	provider: Provider;
+	model: Model<any>;
+	context: Context;
+	input: ResponseItem[];
+	apiKey?: string;
+	headers?: ProviderHeaders;
+	env?: Record<string, string>;
+	signal: AbortSignal;
+	fetch?: typeof globalThis.fetch;
+}
+
+export interface TransportResponse {
+	output: ResponseItem[];
+	usage: Usage;
+}
+
+async function requestResponsesCompact(request: TransportRequest): Promise<TransportResponse> {
+	let preparedPayload: JsonObject | undefined;
+	let compacted: { response: JsonObject; output: ResponseItem[] } | undefined;
+	let bridgeError: unknown;
+	let dispatches = 0;
+	const baseFetch = request.fetch ?? globalThis.fetch;
+	const bridgeFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+		if (request.signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
+		dispatches += 1;
+		if (dispatches !== 1 || !preparedPayload) {
+			bridgeError = new Error("Responses Compact provider dispatched an unexpected additional request");
+			return errorResponse(bridgeError);
+		}
+		try {
+			const compactUrl = responsesCompactUrl(input);
+			const response = await baseFetch(compactUrl, {
+				...init,
+				method: "POST",
+				headers: mergedHeaders(input, init),
+				body: JSON.stringify(compactPayload(preparedPayload)),
+				signal: request.signal,
+			});
+			if (!response.ok) return response;
+			const parsed = await readJsonBounded(response, request.signal);
+			if (!isObject(parsed)) throw new Error("Responses Compact returned a non-object response");
+			compacted = { response: parsed, output: validateCompactedOutput(parsed) };
+			return syntheticCompletion(parsed, preparedPayload);
+		} catch (error) {
+			bridgeError = error;
+			return errorResponse(error);
+		}
+	}) as unknown as typeof globalThis.fetch;
+
+	const stream = request.provider.stream(request.model, request.context, {
+		apiKey: request.apiKey,
+		headers: request.headers,
+		env: request.env,
+		signal: request.signal,
+		transport: "sse",
+		cacheRetention: "none",
+		maxRetries: 0,
+		fetch: bridgeFetch,
+		onPayload: (payload: unknown) => {
+			if (!isObject(payload)) throw new Error("Responses provider exposed a non-object payload");
+			preparedPayload = { ...structuredClone(payload), input: structuredClone(request.input) };
+			return preparedPayload;
+		},
+	});
+
+	const usage = await collectProviderUsage(stream, request.signal).catch((error) => {
+		if (bridgeError) throw bridgeError;
+		throw error;
+	});
+	if (bridgeError) throw bridgeError;
+	if (!compacted || dispatches !== 1) throw new Error("Responses Compact did not complete exactly one request");
+	return { output: compacted.output, usage };
+}
+
+interface CollectedSse {
+	item: ResponseItem;
+}
+
+async function collectCompactionSse(stream: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<CollectedSse> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let bytes = 0;
+	let pending = "";
+	let dataLines: string[] = [];
+	let completed = false;
+	const items = new Map<string, ResponseItem>();
+	const onAbort = () => void reader.cancel(new DOMException("Compaction aborted", "AbortError")).catch(() => undefined);
+	signal.addEventListener("abort", onAbort, { once: true });
+	const dispatch = () => {
+		if (dataLines.length === 0) return;
+		const data = dataLines.join("\n");
+		dataLines = [];
+		if (data === "[DONE]") return;
+		let event: unknown;
+		try { event = JSON.parse(data); } catch { throw new Error("Remote V2 returned malformed SSE JSON"); }
+		if (!isObject(event)) return;
+		if (event.type === "response.completed") completed = true;
+		const candidates: unknown[] = [];
+		if (event.type === "response.output_item.done") candidates.push(event.item);
+		if (event.type === "response.completed" && isObject(event.response) && Array.isArray(event.response.output)) {
+			candidates.push(...event.response.output);
+		}
+		for (const candidate of candidates) {
+			if (!isCompactionItem(candidate)) continue;
+			validateItemSize(candidate);
+			items.set(JSON.stringify(candidate), structuredClone(candidate));
+		}
+	};
+	const processLine = (line: string) => {
+		if (line === "") return dispatch();
+		if (line.startsWith(":")) return;
+		if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+	};
+	try {
+		while (true) {
+			if (signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
+			const { done, value } = await reader.read();
+			if (done) break;
+			bytes += value.byteLength;
+			if (bytes > MAX_RESPONSE_BYTES) throw new Error("Remote V2 stream exceeded 8 MiB");
+			pending += decoder.decode(value, { stream: true });
+			let newline = pending.indexOf("\n");
+			while (newline >= 0) {
+				const raw = pending.slice(0, newline);
+				pending = pending.slice(newline + 1);
+				processLine(raw.endsWith("\r") ? raw.slice(0, -1) : raw);
+				newline = pending.indexOf("\n");
+			}
+		}
+		pending += decoder.decode();
+		if (pending) processLine(pending.endsWith("\r") ? pending.slice(0, -1) : pending);
+		dispatch();
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+	if (!completed) throw new Error("Remote V2 stream ended without response.completed");
+	if (items.size !== 1) throw new Error(`Remote V2 returned ${items.size} distinct compaction items; expected exactly one`);
+	return { item: [...items.values()][0] };
+}
+
+function retainedUserMessage(item: ResponseItem): boolean {
+	return (item.type === undefined || item.type === "message") && item.role === "user" && Array.isArray(item.content);
+}
+
+function buildRemoteV2History(input: ResponseItem[], item: ResponseItem): ResponseItem[] {
+	validateItemSize(item);
+	let remainingBytes = REMOTE_RETAINED_BYTES - byteLength(item);
+	let remainingChars = REMOTE_RETAINED_CHARS;
+	const kept: ResponseItem[] = [];
+	for (let index = input.length - 1; index >= 0; index--) {
+		const candidate = input[index];
+		if (!retainedUserMessage(candidate)) continue;
+		const bytes = byteLength(candidate);
+		if (bytes > remainingBytes) continue;
+		const chars = JSON.stringify(candidate).length;
+		if (chars > remainingChars) continue;
+		kept.push(structuredClone(candidate));
+		remainingBytes -= bytes;
+		remainingChars -= chars;
+		if (remainingBytes < 256 || remainingChars < 64) break;
+	}
+	return [...kept.reverse(), structuredClone(item)];
+}
+
+async function requestRemoteV2(request: TransportRequest): Promise<TransportResponse> {
+	const baseFetch = request.fetch ?? globalThis.fetch;
+	let sentInput: ResponseItem[] | undefined;
+	const inspections: Promise<CollectedSse>[] = [];
+	const inspectedFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+		const response = await baseFetch(input, init);
+		if (!response.ok || !response.body) return response;
+		const [providerBody, inspectionBody] = response.body.tee();
+		inspections.push(collectCompactionSse(inspectionBody, request.signal));
+		return new Response(providerBody, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers,
+		});
+	}) as unknown as typeof globalThis.fetch;
+
+	const stream = request.provider.stream(request.model, request.context, {
+		apiKey: request.apiKey,
+		headers: request.headers,
+		env: request.env,
+		signal: request.signal,
+		transport: "sse",
+		cacheRetention: "none",
+		maxRetries: 0,
+		fetch: inspectedFetch,
+		onPayload: (payload: unknown) => {
+			if (!isObject(payload)) throw new Error("Codex provider exposed a non-object payload");
+			sentInput = structuredClone(request.input);
+			return { ...structuredClone(payload), input: [...sentInput, { type: "compaction_trigger" }] };
+		},
+	});
+	const usage = await collectProviderUsage(stream, request.signal);
+	if (!sentInput || inspections.length !== 1) {
+		throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+	}
+	const inspection = await inspections[0];
+	return { output: buildRemoteV2History(sentInput, inspection.item), usage };
+}
+
+export async function requestProviderCompaction(
+	request: TransportRequest & { protocol: NativeProtocol },
+): Promise<TransportResponse> {
+	return request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request);
+}