@lll9p/pi-better-compaction 0.6.1 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ English | [中文](README.zh-CN.md)
 
 A [pi](https://github.com/nicepkg/pi) extension that upgrades context compaction with two coordinated strategies:
 
-1. **OpenAI Responses APIs** use the provider's native compaction endpoint, preserving opaque context that plain text summaries lose.
+1. **OpenAI Responses APIs**, including supported GitHub Copilot models, use the provider's native compaction endpoint, preserving opaque context that plain text summaries lose.
 2. **All other APIs** (Anthropic, Gemini, etc.) can run pi's built-in compaction with a **dedicated cheaper/faster model**, so summarization doesn't consume quota on your primary model.
 
 Everything fails open — if any step cannot proceed, pi's default compaction takes over.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lll9p/pi-better-compaction",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "type": "module",
   "description": "Better compaction for pi: native /responses/compact replay for OpenAI Responses APIs, plus a configurable compaction model driving pi's native summarization everywhere else.",
   "author": "Lilin Lao",

package/src/compact-client-v2.ts

@@ -67,6 +67,8 @@ export type ExecuteV2CompactionOptions = {
 
 const DEFAULT_MAX_RETRIES = 2;
 const SSE_ACCEPT = "text/event-stream";
+// Copilot rejects compaction_trigger with a smaller explicit output ceiling.
+const COPILOT_COMPACTION_OUTPUT_CEILING = 20_000;
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
@@ -123,7 +125,7 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 	let buffer = "";
 
 	try {
-		while (true) {
+		stream: while (true) {
 			if (signal?.aborted) {
 				reader.cancel();
 				return { ok: false, reason: "aborted" as const };
@@ -176,7 +178,7 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 							usage = resp.usage as V2CompactionUsage;
 						}
 					}
-					continue;
+					break stream;
 				}
 
 				if (eventType === "response.failed" || eventType === "error") {
@@ -184,16 +186,18 @@ async function collectStreamOutput(response: Response, signal?: AbortSignal): Pr
 					serverError = isRecord(errorObj)
 						? (typeof errorObj.message === "string" ? errorObj.message : JSON.stringify(errorObj))
 						: String(errorObj);
-					continue;
+					break stream;
 				}
 			}
 		}
 	} catch (error) {
-		if (isAbortError(error)) {
+		if (signal?.aborted || isAbortError(error)) {
 			return { ok: false, reason: "aborted" as const };
 		}
 		return { ok: false, reason: "stream-parse-error", errorMessage: error instanceof Error ? error.message : String(error) };
 	} finally {
+		// Completion is terminal even when a gateway keeps the HTTP body open.
+		try { await reader.cancel(); } catch { /* noop */ }
 		try { reader.releaseLock(); } catch { /* noop */ }
 	}
 
@@ -237,7 +241,7 @@ async function executeV2Attempt(
 			signal,
 		});
 	} catch (error) {
-		if (isAbortError(error)) {
+		if (signal?.aborted || isAbortError(error)) {
 			return { failure: { ok: false, reason: "aborted" } };
 		}
 		return {
@@ -294,14 +298,25 @@ function isRetryable(result: V2CompactionFailure): boolean {
  * to the input, streams the SSE response, and collects the compaction blob.
  *
  * Retries recoverable failures up to `maxRetries` times (default 2).
+ *
+ * Copilot routes in Pi 0.84.4; tested means live native compaction and replay.
+ *
+ * | Provider (via Copilot) | API | Tested |
+ * | --- | --- | --- |
+ * | OpenAI (Astra) | Responses | Yes |
+ * | xAI (Grok 4.6) | Responses | Failed (HTTP 422) |
+ * | Google (Gemini) | Chat Completions | No; outside this path |
+ * | Anthropic (Opus) | Messages | No; outside this path |
  */
 export async function executeV2Compaction(
 	options: ExecuteV2CompactionOptions,
 ): Promise<V2CompactionResult> {
-	const { runtime, request, signal, settings, context } = options;
+	const { runtime, request, settings, context } = options;
+	const deadline = AbortSignal.timeout(600_000);
+	const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
 	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
 
-	const headers = toHeaders(runtime, SSE_ACCEPT);
+	const headers = toHeaders(runtime, SSE_ACCEPT, request.input);
 	const url = runtime.responsesUrl;
 
 	// Build request body: input + compaction_trigger, stream=true.
@@ -310,6 +325,9 @@ export async function executeV2Compaction(
 		input: [...request.input, { type: "compaction_trigger" }],
 		store: false,
 		stream: true,
+		...(runtime.provider === "github-copilot" ? {
+			max_output_tokens: COPILOT_COMPACTION_OUTPUT_CEILING,
+		} : {}),
 	};
 
 	let lastFailure: V2CompactionFailure | undefined;

package/src/compact-client.ts

@@ -121,7 +121,7 @@ export async function executeNativeCompaction(
 	options: ExecuteNativeCompactionOptions,
 ): Promise<NativeCompactionClientResult> {
 	const { runtime, request, signal, settings, context } = options;
-	const headers = toHeaders(runtime);
+	const headers = toHeaders(runtime, JSON_CONTENT_TYPE, request.input);
 
 	if (signal?.aborted) {
 		const aborted: NativeCompactionClientFailure = {

package/src/payload-rewrite.ts

@@ -227,6 +227,43 @@ function areEquivalentValues(left: unknown, right: unknown): boolean {
 	return false;
 }
 
+// Match pruned output runs by call ID; all other items must stay unchanged. -- PI/gpt-6-astra
+/** @internal — exported for unit testing only */
+export function alignPrunedInput(actual: readonly unknown[], expected: readonly unknown[]): number[] | undefined {
+	const indices: number[] = [];
+	let actualIndex = 0;
+	for (let expectedIndex = 0; expectedIndex < expected.length;) {
+		const item = expected[expectedIndex];
+		if (isRecord(item) && item.type === "function_call_output") {
+			const outputs = new Map<string, number>();
+			while (expectedIndex < expected.length) {
+				const output = expected[expectedIndex];
+				if (!isRecord(output) || output.type !== "function_call_output") break;
+				if (typeof output.call_id !== "string" || outputs.has(output.call_id)) return undefined;
+				outputs.set(output.call_id, expectedIndex++);
+			}
+			while (actualIndex < actual.length) {
+				const output = actual[actualIndex];
+				if (!isRecord(output) || output.type !== "function_call_output") break;
+				const index = typeof output.call_id === "string" ? outputs.get(output.call_id) : undefined;
+				if (index === undefined || !areEquivalentValues(
+					{ ...output, output: undefined },
+					{ ...(expected[index] as Record<string, unknown>), output: undefined },
+				)) return undefined;
+				outputs.delete(output.call_id as string);
+				indices.push(index);
+				actualIndex++;
+			}
+			if (outputs.size > 0) return undefined;
+		} else {
+			if (!areEquivalentValues(actual[actualIndex], item)) return undefined;
+			indices.push(expectedIndex++);
+			actualIndex++;
+		}
+	}
+	return actualIndex === actual.length ? indices : undefined;
+}
+
 function toBranchSummaryMessage(entry: BranchSummaryEntry): AgentMessage {
 	return {
 		role: "branchSummary",
@@ -449,7 +486,8 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		...freshPreamble.trailingInput,
 	];
 
-	if (!areEquivalentValues(args.payload.input, originalPiReplayInput)) {
+	const originalIndices = alignPrunedInput(args.payload.input, originalPiReplayInput);
+	if (!originalIndices) {
 		const parity = compareResponsesInputParity(args.payload.input, originalPiReplayInput);
 		return {
 			ok: false,
@@ -467,17 +505,13 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 	const compactionSummaryCount = serializeMessagesToResponsesInput(args.model, [compactionSummaryMessage]).length;
 	const preCompactionKeptCount = serializeMessagesToResponsesInput(args.model, preCompactionKeptMessages).length;
 	const tailStartIndex = freshPreambleCount + compactionSummaryCount + preCompactionKeptCount;
-	const tailEndIndex = args.payload.input.length - trailingPreambleCount;
-	const actualCompactionSummary = cloneResponsesInputSlice(
-		args.payload.input.slice(freshPreambleCount, freshPreambleCount + compactionSummaryCount),
-	);
-	const actualPreCompactionKeptWindow = cloneResponsesInputSlice(
-		args.payload.input.slice(
-			freshPreambleCount + compactionSummaryCount,
-			freshPreambleCount + compactionSummaryCount + preCompactionKeptCount,
-		),
+	const tailEndIndex = originalPiReplayInput.length - trailingPreambleCount;
+	const actualSlice = (start: number, end: number) => cloneResponsesInputSlice(
+		args.payload.input.filter((_, index) => originalIndices[index] >= start && originalIndices[index] < end),
 	);
-	const actualPostCompactionTail = cloneResponsesInputSlice(args.payload.input.slice(tailStartIndex, tailEndIndex));
+	const actualCompactionSummary = actualSlice(freshPreambleCount, freshPreambleCount + compactionSummaryCount);
+	const actualPreCompactionKeptWindow = actualSlice(freshPreambleCount + compactionSummaryCount, tailStartIndex);
+	const actualPostCompactionTail = actualSlice(tailStartIndex, tailEndIndex);
 	if (!actualCompactionSummary || !actualPreCompactionKeptWindow || !actualPostCompactionTail) {
 		return {
 			ok: false,

package/src/runtime.ts

@@ -39,7 +39,7 @@ export type NativeCompactionRuntime = {
 	model: string;
 	baseUrl: string;
 	apiKey: string;
-	headers?: Record<string, string>;
+	headers?: Record<string, string | null>;
 	compactPath: string;
 	compactUrl: string;
 	responsesUrl: string;
@@ -127,25 +127,13 @@ export function buildCompactPath(api: ResponsesCompactApi): string {
 	return api === "openai-codex-responses" ? CODEX_COMPACT_PATH : OPENAI_COMPACT_PATH;
 }
 
-/** Strip null-valued entries so downstream consumers receive a clean Record<string, string>. */
-function filterNullHeaders(headers: Record<string, string | null> | undefined): Record<string, string> | undefined {
-	if (!headers) return undefined;
-	const filtered: Record<string, string> = {};
-	for (const [key, value] of Object.entries(headers)) {
-		if (value !== null) {
-			filtered[key] = value;
-		}
-	}
-	return Object.keys(filtered).length > 0 ? filtered : undefined;
-}
-
 async function resolveRequestAuth(
 	ctx: ExtensionContext,
 	model: RuntimeModel,
-): Promise<{ apiKey?: string; headers?: Record<string, string> }> {
+): Promise<{ apiKey?: string; headers?: Record<string, string | null>; baseUrl?: string }> {
 	const modelRegistry = ctx.modelRegistry as {
 		getApiKeyAndHeaders?: (currentModel: RuntimeModel) => Promise<
-			| { ok: true; apiKey?: string; headers?: Record<string, string | null> }
+			| { ok: true; apiKey?: string; headers?: Record<string, string | null>; baseUrl?: string }
 			| { ok: false; error: string }
 		>;
 	};
@@ -155,7 +143,7 @@ async function resolveRequestAuth(
 	}
 
 	const auth = await modelRegistry.getApiKeyAndHeaders(model);
-	return auth.ok ? { apiKey: auth.apiKey, headers: filterNullHeaders(auth.headers) } : {};
+	return auth.ok ? { apiKey: auth.apiKey, headers: auth.headers, baseUrl: auth.baseUrl } : {};
 }
 
 export function isSupportedApi(api: string): api is ResponsesCompactApi {
@@ -202,7 +190,7 @@ export async function resolveNativeCompactionEnvironment(
 	}
 
 	let sessionModel: RuntimeModel | undefined;
-	const branch = ctx.sessionManager.getBranch();
+	const branch = ctx.sessionManager?.getBranch?.() ?? [];
 	for (let index = branch.length - 1; index >= 0; index -= 1) {
 		const entry = branch[index];
 		if (entry?.type === "model_change") {
@@ -232,14 +220,6 @@ export async function resolveNativeCompactionEnvironment(
 		};
 	}
 
-	if (!descriptor.baseUrl) {
-		return {
-			ok: false,
-			reason: "missing-base-url",
-			...descriptor,
-		};
-	}
-
 	let requestPayload: ResponsesCompatibleRequestPayload | undefined;
 	if (payload !== undefined) {
 		if (!isResponsesCompatiblePayload(payload)) {
@@ -261,7 +241,13 @@ export async function resolveNativeCompactionEnvironment(
 		requestPayload = payload;
 	}
 
-	const { apiKey, headers } = await resolveRequestAuth(ctx, currentModel);
+	const { apiKey, headers, baseUrl: authBaseUrl } = await resolveRequestAuth(ctx, currentModel);
+	// OAuth can route a configured Individual model to an Enterprise endpoint.
+	// Use the same resolved endpoint for transport AND persisted replay identity.
+	const baseUrl = normalizeBaseUrl(authBaseUrl) ?? descriptor.baseUrl;
+	if (!baseUrl) {
+		return { ok: false, reason: "missing-base-url", ...descriptor };
+	}
 	if (!apiKey) {
 		return {
 			ok: false,
@@ -276,14 +262,14 @@ export async function resolveNativeCompactionEnvironment(
 			provider: descriptor.provider,
 			api: descriptor.api,
 			model: descriptor.model,
-			baseUrl: descriptor.baseUrl,
+			baseUrl,
 			apiKey,
 			headers,
 			compactPath: buildCompactPath(descriptor.api),
-			compactUrl: buildCompactUrl(descriptor.baseUrl, descriptor.api),
-			responsesUrl: buildResponsesUrl(descriptor.baseUrl, descriptor.api),
+			compactUrl: buildCompactUrl(baseUrl, descriptor.api),
+			responsesUrl: buildResponsesUrl(baseUrl, descriptor.api),
 			payload: requestPayload,
-			currentModel,
+			currentModel: { ...currentModel, baseUrl },
 		},
 	};
 }

package/src/shared-headers.ts

@@ -55,31 +55,25 @@ function buildCodexUserAgent(): string {
  * and Codex-specific headers (account ID, originator, user-agent, beta flag).
  *
  * @param accept - The Accept header value. Defaults to `application/json`.
+ * @param input - The request input items, used for Copilot vision detection.
  */
 export function toHeaders(
 	runtime: NativeCompactionRuntime,
 	accept: string = JSON_CONTENT_TYPE,
+	input: readonly unknown[] = [],
 ): Record<string, string> {
 	const headers = new Headers();
-	// Model-level headers may contain null values (ProviderHeaders); null means "unset".
-	for (const [key, value] of Object.entries(runtime.currentModel.headers ?? {})) {
-		if (value != null) {
-			headers.set(key, String(value));
+	headers.set("authorization", `Bearer ${runtime.apiKey}`);
+	if (runtime.provider === "github-copilot") {
+		// Compaction is an agent-initiated request, even when history ends with a user.
+		headers.set("x-initiator", "agent");
+		headers.set("openai-intent", "conversation-edits");
+		if (input.some((item) => isRecord(item) && [item.content, item.output].some((blocks) =>
+			Array.isArray(blocks) && blocks.some((block) => isRecord(block) && block.type === "input_image"),
+		))) {
+			headers.set("copilot-vision-request", "true");
 		}
 	}
-	// Extension-resolved headers (already filtered by resolveRequestAuth, but defensive).
-	for (const [key, value] of Object.entries(runtime.headers ?? {})) {
-		if (value == null) {
-			headers.delete(key);
-		} else {
-			headers.set(key, value);
-		}
-	}
-	headers.set("accept", accept);
-	headers.set("content-type", JSON_CONTENT_TYPE);
-	if (!headers.has("authorization")) {
-		headers.set("authorization", `Bearer ${runtime.apiKey}`);
-	}
 
 	if (runtime.api === "openai-codex-responses") {
 		const accountId = extractCodexAccountId(runtime.apiKey);
@@ -91,6 +85,18 @@ export function toHeaders(
 		headers.set("openai-beta", "responses=experimental");
 	}
 
+	// Defaults first, then model headers, then resolved request auth. Null means
+	// remove, even for Authorization and Codex-specific headers.
+	for (const source of [runtime.currentModel.headers, runtime.headers]) {
+		for (const [key, value] of Object.entries(source ?? {})) {
+			if (value == null) headers.delete(key);
+			else headers.set(key, value);
+		}
+	}
+	// These two are mandatory transport invariants, not overridable auth defaults.
+	headers.set("accept", accept);
+	headers.set("content-type", JSON_CONTENT_TYPE);
+
 	return Object.fromEntries(headers.entries());
 }