pi-openai-toolkit 0.20.8 → 0.21.1

package/src/config.ts

@@ -7,6 +7,7 @@ import { CONFIG_PATH, normalizeLegacyConfig } from "./config/legacy";
 import { resolveV2Config } from "./config/v2";
 import {
 	CONFIG_FEATURES,
+	RETIRED_AUTO_MODE_ISSUE,
 	createPolicyDefaults,
 	type ConfigDocumentSnapshot,
 	type ConfigFeature,
@@ -116,7 +117,6 @@ const LEGACY_PATHS: Record<string, string> = {
 	"imageGeneration.enabled": "imageGeneration.enabled",
 	"imageGeneration.defaultModel": "imageGeneration.models",
 	"imageGeneration.allowedModels": "imageGeneration.models",
-	"autoMode.available": "autoMode.models",
 	"compatibility.transport": "compaction.gatewayContextModels",
 	"diagnostics.level": "compaction.debug",
 	"diagnostics.notifyOnLoad": "compaction.notifyOnLoad",
@@ -155,13 +155,17 @@ function legacyIssues(loaded: LoadedToolkitConfig, modelKey: string | undefined)
 		}
 	}
 	const issues = loaded.warnings.filter((warning) => !warning.startsWith("Ignoring webSearch.routes.")).map((warning): ConfigIssue => {
+		// A removed feature is retired, not invalid: it never blocks another feature.
+		if (warning.startsWith("Ignoring autoMode:")) {
+			return { severity: "warning", code: RETIRED_AUTO_MODE_ISSUE, path: "autoMode", feature: "document" };
+		}
 		const match = /^Ignoring ([^:]+):/.exec(warning);
 		const field = warning.startsWith("Ignoring compaction.responsesApis entry ") ? "compaction.responsesApis" : match?.[1] ?? "$";
 		const root = field.split(".")[0];
 		const diagnostic = Object.entries(LEGACY_PATHS).some(([leaf, input]) => leaf.startsWith("diagnostics.") && input === field);
 		const feature: ConfigFeature | "document" = diagnostic ? "diagnostics"
 			: field === "compaction.gatewayContextModels" ? "compatibility" : root === "compaction" ? "context"
-			: root === "webSearch" || root === "imageGeneration" || root === "autoMode" ? root : "document";
+			: root === "webSearch" || root === "imageGeneration" ? root : "document";
 		const supersededDefault = field === "webSearch.defaultRoute" && legacyRouteKey(raw, modelKey) !== undefined;
 		const warningOnly = warning.endsWith("unknown field.") || !match
 			|| warning.includes("expected at least one model id") || supersededDefault;
@@ -209,13 +213,6 @@ function fromLegacy(loaded: LoadedToolkitConfig, model: WebSearchModel | undefin
 		allowedModels: [...config.imageGeneration.models],
 	};
 	policy.responsesWebSocket = { enabled: false };
-	const { enabled, models, reviewerModel, classifier, ...auto } = config.autoMode;
-	policy.autoMode = {
-		...structuredClone(auto),
-		available: enabled && modelKey !== undefined && models.includes(modelKey),
-		reviewerModel: reviewerModel ?? null,
-		classifier: { ...classifier, model: classifier.model ?? null },
-	};
 	policy.compatibility.transport = modelKey && compaction.gatewayContextModels.includes(modelKey) ? "codex-gateway" : "standard";
 	policy.diagnostics = {
 		level: compaction.debug ? "debug" : "info",
@@ -230,7 +227,6 @@ function fromLegacy(loaded: LoadedToolkitConfig, model: WebSearchModel | undefin
 	for (const leaf of leafPaths(policy)) {
 		let input = LEGACY_PATHS[leaf] ?? leaf;
 		if (leaf === "context.mode" && !compaction.enabled) input = "compaction.enabled";
-		if (leaf === "autoMode.available" && !enabled) input = "autoMode.enabled";
 		if (leaf === "webSearch.route") {
 			if (!config.webSearch.enabled) input = "webSearch.enabled";
 			else if (route.source === "exact") {
@@ -251,9 +247,8 @@ function fromLegacy(loaded: LoadedToolkitConfig, model: WebSearchModel | undefin
 }
 
 /** Internal engine adapter. All interpretation of document names stays in this module. */
-function engineConfig(policy: EffectiveToolkitPolicy, modelKey: string | undefined, gatewayKeys: string[]): ToolkitConfig {
-	const { context, diagnostics, imageGeneration, autoMode } = policy;
-	const { available, reviewerModel, classifier, ...auto } = autoMode;
+function engineConfig(policy: EffectiveToolkitPolicy, gatewayKeys: string[]): ToolkitConfig {
+	const { context, diagnostics, imageGeneration } = policy;
 	return {
 		compaction: {
 			enabled: context.mode !== "pi",
@@ -276,10 +271,6 @@ function engineConfig(policy: EffectiveToolkitPolicy, modelKey: string | undefin
 		webSearch: policy.webSearch.route === "unmanaged" ? { enabled: false, models: [] }
 			: { enabled: true, models: [], defaultRoute: policy.webSearch.route },
 		imageGeneration: { enabled: imageGeneration.enabled, models: [...imageGeneration.allowedModels] },
-		autoMode: {
-			...structuredClone(auto), enabled: available, models: available && modelKey ? [modelKey] : [],
-			reviewerModel: reviewerModel ?? undefined, classifier: { ...classifier, model: classifier.model ?? undefined },
-		},
 	};
 }
 
@@ -302,7 +293,7 @@ export function resolveToolkitConfig(loaded: LoadedToolkitConfig, model?: ExactM
 		for (const origin of Object.values(resolution.origins)) if (origin.kind !== "builtin") origin.source = source;
 	}
 	const gatewayModelKeys = v2 ? v2.gatewayModelKeys : [...loaded.config.compaction.gatewayContextModels];
-	const config = format === "v2" ? engineConfig(resolution.policy, modelKey, gatewayModelKeys) : structuredClone(loaded.config);
+	const config = format === "v2" ? engineConfig(resolution.policy, gatewayModelKeys) : structuredClone(loaded.config);
 	return freeze({ ...resolution, config, format, source, modelKey, gatewayModelKeys, snapshot: structuredClone(loaded) });
 }
 

package/src/context-management/manual-compact.ts

@@ -2,8 +2,6 @@ import { randomUUID } from "node:crypto";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { buildSessionContext, estimateTokens, type ExtensionAPI, type ExtensionContext, type SessionBeforeCompactEvent, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { resolveToolkitConfig, type ResolvedToolkitConfig } from "../config";
-import { isAutoModeEligible } from "../auto-mode/policy";
-import { protectAutoModeSelection } from "../auto-mode/model-selection-guard";
 import { parseModelSpec } from "../runtime";
 import { THINKING_LEVELS } from "../types";
 import { resolveCodexContextProvider } from "./codex-provider";
@@ -88,7 +86,6 @@ export class ManagedManualCompact implements ContextRolloverHandoff {
 	private sourcePolicy: ResolvedToolkitConfig | undefined;
 	private instructions = "";
 	private attemptSignal: AbortSignal | undefined;
-	private releaseApproval: (() => void) | undefined;
 	private selecting: string | undefined;
 	private selectionPromise: Promise<boolean> | undefined;
 	private expectedThinking: ThinkingLevel | undefined;
@@ -123,8 +120,6 @@ export class ManagedManualCompact implements ContextRolloverHandoff {
 	private clearActivity(): void {
 		clearTimeout(this.deliveryTimer);
 		this.deliveryTimer = undefined;
-		this.releaseApproval?.();
-		this.releaseApproval = undefined;
 		this.sourcePolicy = undefined;
 	}
 	private belongs(ctx: ExtensionContext, record = this.record): boolean {
@@ -193,12 +188,6 @@ export class ManagedManualCompact implements ContextRolloverHandoff {
 			if (!originalProvider.ok || !targetProvider.ok || !sameContextScope(originalProvider.provider, targetProvider.provider)) {
 				throw new Error("checkpoint model must authenticate to the same context backend/account");
 			}
-			const protection = protectAutoModeSelection(this.pi, {
-				sessionId: this.record!.sessionId, operationId: this.record!.operationId, target,
-				eligible: !targetPolicy.invalidFeatures.includes("autoMode") && isAutoModeEligible(target, targetPolicy.config.autoMode),
-			});
-			this.releaseApproval = protection.release;
-			if (!protection.allowed) throw new Error("checkpoint model would disable the engaged approval gate; allowlist it or choose another model");
 			this.notify(ctx, `checkpoint handoff requested (${this.record!.originalModel} → ${targetKey}); native compaction is intentionally cancelled.`);
 		} catch (error) {
 			if (!this.current(ctx, generation)) return;

package/src/debug.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -157,7 +158,7 @@ export function writeDebugArtifact(
 	ensureDir(targetDir);
 
 	const timestamp = new Date().toISOString();
-	const fileName = `${timestamp.replace(/[.:]/g, "-")}-${kind}.json`;
+	const fileName = `${timestamp.replace(/[.:]/g, "-")}-${kind}-${randomUUID()}.json`;
 	const filePath = path.join(targetDir, fileName);
 	const criticallyRedactedData = redactCriticalValue(data);
 	const envelope: DebugArtifactEnvelope = {
@@ -174,7 +175,7 @@ export function writeDebugArtifact(
 		data: settings.redactSensitiveData ? redactValue(criticallyRedactedData) : criticallyRedactedData,
 	};
 
-	fs.writeFileSync(filePath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+	fs.writeFileSync(filePath, `${JSON.stringify(envelope, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
 	return filePath;
 }
 
@@ -206,7 +207,7 @@ export function writeReplayFailureArtifact(
 		ensureDir(targetDir);
 
 		const timestamp = new Date().toISOString();
-		const filePath = path.join(targetDir, `${timestamp.replace(/[.:]/g, "-")}-replay-failure.json`);
+		const filePath = path.join(targetDir, `${timestamp.replace(/[.:]/g, "-")}-replay-failure-${randomUUID()}.json`);
 		const data = redactCriticalValue({
 			event: "before_provider_request.rewrite-failed",
 			reason: details.reason,
@@ -227,7 +228,7 @@ export function writeReplayFailureArtifact(
 			redaction: { enabled: true },
 			data,
 		};
-		fs.writeFileSync(filePath, `${JSON.stringify(envelope, null, 2)}\n`, "utf8");
+		fs.writeFileSync(filePath, `${JSON.stringify(envelope, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
 		return filePath;
 	} catch {
 		// The replay failure path itself must never be masked by an artifact write

package/src/extension-runtime.ts

@@ -35,6 +35,8 @@ import {
 	type UnprojectedCompactionReason,
 } from "./compaction-projection";
 import { CODEX_GATEWAY_FORWARD_HEADERS } from "./responses-headers";
+import { executeNativeCompaction, type NativeCompactionClientResult } from "./compact-client";
+import { qualifiesForStandaloneCompaction, type CompactionErrorInfo } from "./compaction-errors";
 import { resolveLatestNativeCompactionEntry } from "./details-store";
 import {
 	getPiContextHookProjector,
@@ -57,6 +59,7 @@ import {
 	resolveEffectiveModel,
 	resolveNativeCompactionEnvironment,
 	resolveRemoteCompactionExecution,
+	isStandaloneCompactionEligible,
 	parseModelSpec,
 	type RemoteCompactionExecution,
 } from "./runtime";
@@ -70,6 +73,8 @@ import {
 	createNativeCompactionDetails,
 	createNativeCompactionResult,
 	COMPACTION_EXTENSION_ID,
+	LEGACY_NATIVE_COMPACTION_STRATEGY,
+	REMOTE_V2_COMPACTION_STRATEGY,
 	getLatestDeferredToolCarryover,
 	getRemoteV2InputProvenance,
 	isNativeCompactionDetails,
@@ -107,6 +112,7 @@ function compactGatewayModels(resolved: ResolvedToolkitConfig): readonly string[
 type CompactionDependencies = {
 	loadConfig: typeof loadToolkitConfig;
 	remoteCompact: typeof executeRemoteV2Compaction;
+	standaloneCompact: typeof executeNativeCompaction;
 	nativeFallback: typeof runNativeFallbackCompaction;
 	contextWindows: CodexContextWindowManager;
 	manualCompact?: ManagedManualCompact;
@@ -132,7 +138,7 @@ type ContextToolSyncOutcome = {
 type ResponsesCompactOutcome =
 	| { outcome: "success"; compaction: CompactionResult<NativeCompactionDetails> }
 	| { outcome: "aborted" }
-	| { outcome: "failed" }
+	| { outcome: "failed"; remoteFailure?: CompactionErrorInfo & { reason: string; status?: number }; protocol?: string }
 	| {
 			outcome: "unprojected-input";
 			reason: UnprojectedCompactionReason;
@@ -343,6 +349,8 @@ async function runResponsesNativeCompact(
 	execution: RemoteCompactionExecution,
 	remoteCompact: typeof executeRemoteV2Compaction,
 	projectCompactionContext: CompactionContextProjection | undefined,
+	/** Only ordinary compaction supplies this; managed recovery remains V2-only. */
+	standaloneCompact?: typeof executeNativeCompaction,
 ): Promise<ResponsesCompactOutcome> {
 	const { consumer, compactor } = execution;
 	const instructions = buildCompactionInstructions(ctx.getSystemPrompt(), event.customInstructions);
@@ -477,7 +485,9 @@ async function runResponsesNativeCompact(
 		request = { ...request, ...extras };
 	}
 
-	const compactResult = await remoteCompact({
+	if (event.signal?.aborted) return { outcome: "aborted" };
+	let protocol: "remote-v2" | "standalone-compact" = "remote-v2";
+	let compactResult: Awaited<ReturnType<typeof executeRemoteV2Compaction>> | NativeCompactionClientResult = await remoteCompact({
 		runtime: compactor,
 		request,
 		signal: event.signal,
@@ -485,24 +495,46 @@ async function runResponsesNativeCompact(
 		context: ctx,
 	});
 
-	if (compactResult.ok === false) {
-		writeDebugArtifact(
-			"compaction-event",
-			{
-				event: "session_before_compact.remote-v2-failure",
+	if (!compactResult.ok) {
+		if (compactResult.reason === "aborted" || event.signal?.aborted) return { outcome: "aborted" };
+		const tryStandalone = !!standaloneCompact && isStandaloneCompactionEligible(compactor) && qualifiesForStandaloneCompaction(compactResult);
+		writeDebugArtifact("compaction-event", {
+			event: "session_before_compact.remote-v2-failure",
+			protocol,
+			reason: compactResult.reason,
+			status: compactResult.status,
+			errorCode: compactResult.errorCode,
+			errorType: compactResult.errorType,
+			errorParam: compactResult.errorParam,
+			errorMessage: compactResult.errorMessage,
+			nextStep: tryStandalone ? "standalone-compact" : "native-summary",
+		}, config, ctx);
+		if (tryStandalone && standaloneCompact) {
+			if (event.signal?.aborted) return { outcome: "aborted" };
+			protocol = "standalone-compact";
+			compactResult = await standaloneCompact({ runtime: compactor, request, signal: event.signal, settings: config, context: ctx });
+		}
+		if (!compactResult.ok) {
+			if (compactResult.reason === "aborted" || event.signal?.aborted) return { outcome: "aborted" };
+			const remoteFailure = {
 				reason: compactResult.reason,
 				status: compactResult.status,
+				errorCode: compactResult.errorCode,
+				errorType: compactResult.errorType,
+				errorParam: compactResult.errorParam,
 				errorMessage: compactResult.errorMessage,
-			},
-			config,
-			ctx,
-		);
-		return compactResult.reason === "aborted" ? { outcome: "aborted" } : { outcome: "failed" };
+			};
+			if (protocol === "standalone-compact") writeDebugArtifact("compaction-event", {
+				event: "session_before_compact.standalone-compact-failure", protocol, ...remoteFailure, nextStep: "native-summary",
+			}, config, ctx);
+			return { outcome: "failed", remoteFailure, protocol };
+		}
 	}
 
 	let details: NativeCompactionDetails;
 	try {
 		details = createNativeCompactionDetails({
+			strategy: protocol === "standalone-compact" ? LEGACY_NATIVE_COMPACTION_STRATEGY : REMOTE_V2_COMPACTION_STRATEGY,
 			provider: consumer.provider,
 			api: consumer.api,
 			model: consumer.model,
@@ -542,7 +574,7 @@ async function runResponsesNativeCompact(
 			config,
 			ctx,
 		);
-		return { outcome: "failed" };
+		return { outcome: "failed", remoteFailure: { reason: "invalid-native-details" }, protocol };
 	}
 
 	const compaction = createNativeCompactionResult({
@@ -554,7 +586,8 @@ async function runResponsesNativeCompact(
 	writeDebugArtifact(
 		"compaction-event",
 		{
-			event: "session_before_compact.remote-v2-success",
+			event: `session_before_compact.${protocol}-success`,
+			protocol,
 			consumer: {
 				provider: consumer.provider,
 				api: consumer.api,
@@ -829,6 +862,7 @@ async function handleSessionBeforeCompact(
 			resolution.execution,
 			dependencies.remoteCompact,
 			dependencies.projectCompactionContext,
+			dependencies.standaloneCompact,
 		);
 		if (responsesOutcome.outcome === "success") {
 			return { compaction: responsesOutcome.compaction };
@@ -865,7 +899,18 @@ async function handleSessionBeforeCompact(
 			);
 			return { cancel: true };
 		}
-		// failed: fall through to the configured-model fallback below.
+		// Only an actual exhausted remote attempt warns, never an input/routing skip.
+		if (event.signal?.aborted) return { cancel: true };
+		if (responsesOutcome.remoteFailure) {
+			const failure = responsesOutcome.remoteFailure;
+			writeDebugArtifact("compaction-event", {
+				event: "session_before_compact.remote-to-native-summary",
+				protocol: responsesOutcome.protocol,
+				...failure,
+				nextStep: "native-summary",
+			}, config, ctx);
+			notifyWarning(ctx, `Remote compaction failed (${failure.reason}${failure.status ? `, HTTP ${failure.status}` : ""}${failure.errorCode ? `, ${failure.errorCode}` : ""}); continuing with a native text summary. No encrypted remote checkpoint was produced.${failure.errorMessage ? ` ${failure.errorMessage}` : ""}`);
+		}
 	} else {
 		writeDebugArtifact(
 			"compaction-event",
@@ -1380,6 +1425,7 @@ export default function registerCompactionExtension(
 	const manualCompact = new ManagedManualCompact(pi, contextWindows);
 	const dependencies: CompactionDependencies = {
 		remoteCompact: executeRemoteV2Compaction,
+		standaloneCompact: executeNativeCompaction,
 		nativeFallback: runNativeFallbackCompaction,
 		contextWindows,
 		...overrides,

package/src/payload-rewrite.ts

@@ -118,11 +118,8 @@ function cloneStructuredValue(value: unknown): unknown {
 	}
 
 	if (isRecord(value)) {
-		const clone: Record<string, unknown> = {};
-		for (const [key, nested] of Object.entries(value)) {
-			clone[key] = cloneStructuredValue(nested);
-		}
-		return clone;
+		// Define own data properties, including provider JSON keys such as __proto__.
+		return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, cloneStructuredValue(nested)]));
 	}
 
 	throw new Error(`Unsupported structured value: ${typeof value}`);

package/src/remote-v2-client.ts

@@ -1,5 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { writeDebugArtifact } from "./debug";
+import { decodeCompactionError, readCompactionResponseText, type CompactionErrorInfo } from "./compaction-errors";
 import { buildResponsesRequestHeaders } from "./responses-headers";
 import type { NativeCompactionRuntime } from "./runtime";
 import type { NativeCompactionRequestBody, ResponsesInputItem } from "./serializer";
@@ -55,7 +56,7 @@ export type RemoteV2CompactionClientSuccess = {
 	response: RemoteV2ResponseEnvelope;
 };
 
-export type RemoteV2CompactionClientFailure = {
+export type RemoteV2CompactionClientFailure = CompactionErrorInfo & {
 	ok: false;
 	reason: RemoteV2CompactionClientFailureReason;
 	status?: number;
@@ -213,14 +214,6 @@ function getEventType(event: ParsedSseEvent): string | undefined {
 	return isRecord(event.data) && isNonEmptyString(event.data.type) ? event.data.type : event.event;
 }
 
-function getErrorMessage(value: unknown): string | undefined {
-	if (!isRecord(value)) return undefined;
-	if (isNonEmptyString(value.message)) return value.message;
-	if (isRecord(value.error) && isNonEmptyString(value.error.message)) return value.error.message;
-	if (isNonEmptyString(value.error)) return value.error;
-	return undefined;
-}
-
 function writeCompactArtifact(
 	data: unknown,
 	settings: CompactionConfig | undefined,
@@ -397,7 +390,7 @@ function reconcileSseCheckpoint(events: readonly ParsedSseEvent[]): CheckpointRe
 			ok: false,
 			reason: "error-event",
 			responseJson: errorEvent.data,
-			errorMessage: getErrorMessage(errorEvent.data),
+			errorMessage: decodeCompactionError(errorEvent.data).errorMessage,
 		};
 	}
 
@@ -668,7 +661,7 @@ export async function executeRemoteV2Compaction(
 		});
 
 		if (!response.ok) {
-			const responseText = await response.text();
+			const responseText = await readCompactionResponseText(response, signal);
 			let responseJson: unknown;
 			if (responseText.trim()) {
 				try {
@@ -681,6 +674,7 @@ export async function executeRemoteV2Compaction(
 				ok: false,
 				reason: "non-2xx",
 				status: response.status,
+				...decodeCompactionError(responseJson),
 				responseText: responseText || undefined,
 				responseJson,
 			};
@@ -719,10 +713,13 @@ export async function executeRemoteV2Compaction(
 		}
 
 		if (!events) {
+			let bodyError: CompactionErrorInfo = {};
+			try { bodyError = decodeCompactionError(JSON.parse(responseText)); } catch { /* Not a JSON error. */ }
 			const failure: RemoteV2CompactionClientFailure = {
 				ok: false,
 				reason: "invalid-sse",
 				status: response.status,
+				...bodyError,
 				responseText,
 			};
 			writeCompactArtifact(
@@ -744,7 +741,7 @@ export async function executeRemoteV2Compaction(
 				ok: false,
 				reason: reconciliation.reason,
 				status: response.status,
-				errorMessage: reconciliation.errorMessage,
+				...decodeCompactionError(reconciliation.responseJson),
 				responseJson: reconciliation.responseJson,
 			};
 			writeCompactArtifact(
@@ -793,12 +790,12 @@ export async function executeRemoteV2Compaction(
 		);
 		return success;
 	} catch (error) {
-		const failure: RemoteV2CompactionClientFailure = isAbortError(error)
+		const failure: RemoteV2CompactionClientFailure = signal?.aborted || isAbortError(error)
 			? { ok: false, reason: "aborted" }
 			: {
 					ok: false,
 					reason: "network-error",
-					errorMessage: error instanceof Error ? error.message : String(error),
+					errorMessage: "Compaction transport failed; no remote checkpoint was produced.",
 				};
 		writeCompactArtifact(
 			{