pi-openai-toolkit 0.20.8 → 0.21.1

package/src/responses-websocket/transport.ts

@@ -199,10 +199,69 @@ function buildCacheKey(model: Model<Api>, options: StreamOptions, requestHeaders
 	return [model.provider, model.id, cleanBaseUrl(model.baseUrl), options.sessionId, stableHash(JSON.stringify(identity))].join("\u0000");
 }
 
+// Only transport failures (not arbitrary caught errors) authorize auto fallback.
+class RecoverableWebSocketError extends Error {}
+
+const STREAM_INTERRUPTION = /\bstream closed before response\.completed\b/iu;
+const TERMINAL_FAILURE_TEXT = /quota|billing|budget|usage.?limit|api.?key|unauthori[sz]ed|forbidden|authenticat|permission|invalid|malformed|unsupported|policy|context.?length|context.?overflow|\babort(?:ed)?\b|\bcancell?ed\b/iu;
+const TRANSIENT_ERROR_CODES = new Set(["stream_error", "server_error", "request_timeout"]);
+
+function transportError(error: unknown): Error {
+	const message = error instanceof Error ? error.message : String(error);
+	if ((error instanceof Error && error.name === "AbortError") || TERMINAL_FAILURE_TEXT.test(message)) {
+		return error instanceof Error ? error : new Error(message);
+	}
+	return new RecoverableWebSocketError(/^WebSocket (?:error|closed|.*timeout)/iu.test(message)
+		? message : `WebSocket error: ${message}`);
+}
+
 function socketError(event: WebSocketEvent): Error {
-	if (typeof event.message === "string" && event.message.length > 0) return new Error(event.message);
-	if (event.error instanceof Error) return event.error;
-	return new Error("WebSocket transport failed");
+	if (typeof event.message === "string" && event.message.length > 0) return transportError(event.message);
+	if (event.error instanceof Error) return transportError(event.error);
+	return transportError("WebSocket transport failed");
+}
+
+function socketCloseError(event: WebSocketEvent, streaming: boolean): Error {
+	const suffix = event.reason ? `: ${event.reason}` : "";
+	if ([1002, 1003, 1007, 1008].includes(event.code ?? 0) || TERMINAL_FAILURE_TEXT.test(event.reason ?? "")) {
+		return new Error(`Responses connection rejected${event.code ? ` (${event.code})` : ""}${suffix}`);
+	}
+	return transportError(streaming
+		? `WebSocket closed before response completion${suffix}`
+		: `WebSocket closed${event.code ? ` ${event.code}` : ""}${suffix}`);
+}
+
+function compatibleFailureMetadata(error: Record<string, unknown>): boolean {
+	if (typeof error.message === "string" && TERMINAL_FAILURE_TEXT.test(error.message)) return false;
+	for (const field of ["code", "type"]) {
+		const value = error[field];
+		if (value !== undefined && value !== null && value !== "" &&
+			(typeof value !== "string" || !TRANSIENT_ERROR_CODES.has(value.toLowerCase()))) return false;
+	}
+	for (const field of ["status", "status_code"]) {
+		const value = error[field];
+		if (value !== undefined && value !== null &&
+			(typeof value !== "number" || ![408, 429, 500, 502, 503, 504].includes(value))) return false;
+	}
+	return true;
+}
+
+function normalizeStreamInterruption(event: Record<string, unknown>): Record<string, unknown> | undefined {
+	const response = isRecord(event.response) ? event.response : undefined;
+	const error = event.type === "error" ? event : event.type === "response.failed" && isRecord(response?.error) ? response.error : undefined;
+	if (!error || typeof error.message !== "string" || !STREAM_INTERRUPTION.test(error.message) ||
+		TERMINAL_FAILURE_TEXT.test(error.message)) return undefined;
+	// Envelope type/status describe the event/response, not its failure category.
+	// Still check their code/HTTP status so a nested transient message cannot
+	// override explicit fatal metadata on an enclosing envelope.
+	const metadata: Record<string, unknown>[] = [{ ...event, type: undefined }];
+	if (event.type === "response.failed") {
+		metadata.push({ ...response, type: undefined, status: response?.status === "failed" ? undefined : response?.status }, error);
+	}
+	if (isRecord(error.error)) metadata.push(error.error);
+	if (metadata.some((value) => !compatibleFailureMetadata(value))) return undefined;
+	const normalized = { ...error, message: `WebSocket error: ${error.message}` };
+	return event.type === "error" ? normalized : { ...event, response: { ...response, error: normalized } };
 }
 
 function closeSocket(socket: WebSocketLike | undefined, reason = "done"): void {
@@ -247,8 +306,9 @@ export function closeResponsesWebSocketSessions(sessionId?: string): void {
 }
 
 
-function liveSignals(options: StreamOptions, init?: RequestInit): AbortSignal[] {
-	return [options.signal, init?.signal].filter((signal): signal is AbortSignal => signal !== undefined);
+function liveSignals(options: StreamOptions, input: RequestInfo | URL, init?: RequestInit): AbortSignal[] {
+	return [...new Set([options.signal, init?.signal, input instanceof Request ? input.signal : undefined]
+		.filter((signal): signal is AbortSignal => signal !== undefined && signal !== null))];
 }
 
 async function connectWebSocket(
@@ -258,7 +318,7 @@ async function connectWebSocket(
 	timeoutMs: number,
 ): Promise<WebSocketLike> {
 	const WebSocketCtor = globalThis.WebSocket as unknown as WebSocketConstructor | undefined;
-	if (typeof WebSocketCtor !== "function") throw new Error("WebSocket transport is not available in this runtime");
+	if (typeof WebSocketCtor !== "function") throw transportError("WebSocket transport is not available in this runtime");
 	if (signals.some((signal) => signal.aborted)) throw new Error("Request was aborted");
 
 	return new Promise((resolve, reject) => {
@@ -286,9 +346,7 @@ async function connectWebSocket(
 			resolve(socket!);
 		};
 		const onError = (event: WebSocketEvent) => fail(socketError(event));
-		const onClose = (event: WebSocketEvent) => fail(new Error(
-			`WebSocket closed${typeof event.code === "number" ? ` ${event.code}` : ""}${event.reason ? ` ${event.reason}` : ""}`,
-		));
+		const onClose = (event: WebSocketEvent) => fail(socketCloseError(event, false));
 		const onAbort = () => fail(new Error("Request was aborted"));
 
 		try {
@@ -301,7 +359,8 @@ async function connectWebSocket(
 		socket.addEventListener("error", onError);
 		socket.addEventListener("close", onClose);
 		for (const signal of signals) signal.addEventListener("abort", onAbort, { once: true });
-		if (timeoutMs > 0) timeout = setTimeout(() => fail(new Error(`WebSocket connect timeout after ${timeoutMs}ms`)), timeoutMs);
+		if (signals.some((signal) => signal.aborted)) { onAbort(); return; }
+		if (timeoutMs > 0) timeout = setTimeout(() => fail(transportError(`WebSocket connect timeout after ${timeoutMs}ms`)), timeoutMs);
 	});
 }
 
@@ -439,22 +498,26 @@ function completedContinuation(entry: CachedSocketEntry | undefined, fullPayload
 	return true;
 }
 
-function createSseResponse(
+async function createSseResponse(
 	socket: WebSocketLike,
 	signals: AbortSignal[],
 	idleTimeoutMs: number,
 	requestFrame: string,
 	onTerminal: (event: Record<string, unknown>) => boolean,
 	onRelease: (keep: boolean) => void,
-): Response {
+	allowBootstrapFallback: boolean,
+): Promise<Response> {
 	const encoder = new TextEncoder();
-	let cancelBody: (reason?: unknown) => void = () => closeSocket(socket, "consumer_cancelled");
+	let resolveReady!: () => void;
+	let rejectReady!: (error: unknown) => void;
+	const ready = new Promise<void>((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });
+	let cancelBody: (reason?: unknown) => void = () => {};
 	const body = new ReadableStream<Uint8Array>({
 		start(controller) {
 			let closed = false;
-			let released = false;
+			let committed = false;
 			let idleTimer: ReturnType<typeof setTimeout> | undefined;
-			let sawTerminal = false;
+			let pending = Promise.resolve();
 			const cleanup = () => {
 				if (idleTimer) clearTimeout(idleTimer);
 				socket.removeEventListener("message", onMessage);
@@ -462,73 +525,75 @@ function createSseResponse(
 				socket.removeEventListener("close", onClose);
 				for (const signal of signals) signal.removeEventListener("abort", onAbort);
 			};
-			const release = (keep: boolean) => {
-				if (released) return;
-				released = true;
-				onRelease(keep);
-			};
-			const finish = () => {
-				if (closed) return;
-				closed = true;
-				cleanup();
-				controller.close();
-			};
 			const fail = (error: unknown) => {
 				if (closed) return;
 				closed = true;
 				cleanup();
-				release(false);
-				closeSocket(socket, "stream_failed");
+				onRelease(false);
+				if (!committed) {
+					if (signals.some((signal) => signal.aborted) || (allowBootstrapFallback && error instanceof RecoverableWebSocketError)) {
+						rejectReady(error);
+					} else {
+						// Return an errored body for deterministic failures/explicit WS.
+						// Rejecting fetch would make the SDK recast these as connection errors.
+						resolveReady();
+					}
+				}
 				controller.error(error);
 			};
 			const armIdleTimer = () => {
 				if (idleTimeoutMs <= 0) return;
 				if (idleTimer) clearTimeout(idleTimer);
-				idleTimer = setTimeout(() => fail(new Error(`WebSocket idle timeout after ${idleTimeoutMs}ms`)), idleTimeoutMs);
-			};
-			const onMessage = (event: WebSocketEvent) => {
-				void (async () => {
-					try {
-						const text = await decodeSocketData(event.data);
-						if (!text) return;
-						const parsed: unknown = JSON.parse(text);
-						if (!isRecord(parsed) || typeof parsed.type !== "string") throw new Error("Invalid Responses WebSocket event");
-						controller.enqueue(encoder.encode(`event: ${parsed.type}\ndata: ${JSON.stringify(parsed)}\n\n`));
-						armIdleTimer();
-						if (TERMINAL_EVENTS.has(parsed.type)) {
-							sawTerminal = true;
-							const keep = onTerminal(parsed);
-							release(keep);
-							finish();
-						}
-					} catch (error) {
-						fail(error);
-					}
-				})();
+				idleTimer = setTimeout(() => fail(transportError(`WebSocket idle timeout after ${idleTimeoutMs}ms`)), idleTimeoutMs);
 			};
-			const onError = (event: WebSocketEvent) => fail(socketError(event));
-			const onClose = (event: WebSocketEvent) => {
-				if (sawTerminal) finish();
-				else fail(new Error(`WebSocket closed before response completion${event.reason ? `: ${event.reason}` : ""}`));
+			const enqueue = (operation: () => Promise<void> | void) => {
+				pending = pending.then(() => { if (!closed) return operation(); }).catch(fail);
 			};
+			const onMessage = (event: WebSocketEvent) => enqueue(async () => {
+				const text = await decodeSocketData(event.data);
+				if (closed) return;
+				if (text === undefined) throw new Error("Invalid Responses WebSocket frame");
+				const parsed: unknown = JSON.parse(text);
+				if (!isRecord(parsed) || typeof parsed.type !== "string" || !parsed.type) throw new Error("Invalid Responses WebSocket event");
+				const normalized = normalizeStreamInterruption(parsed);
+				if (!committed && allowBootstrapFallback && normalized) {
+					fail(transportError("stream closed before response.completed"));
+					return;
+				}
+				const forwarded = normalized ?? parsed;
+				controller.enqueue(encoder.encode(`event: ${forwarded.type}\ndata: ${JSON.stringify(forwarded)}\n\n`));
+				committed = true;
+				resolveReady();
+				armIdleTimer();
+				if (TERMINAL_EVENTS.has(parsed.type)) {
+					closed = true;
+					cleanup();
+					const keep = onTerminal(parsed);
+					onRelease(keep);
+					controller.close();
+				}
+			});
+			const onError = (event: WebSocketEvent) => enqueue(() => fail(socketError(event)));
+			const onClose = (event: WebSocketEvent) => enqueue(() => fail(socketCloseError(event, true)));
+			// Abort/timeout deliberately bypass decoding: a stuck decoder must not
+			// prevent cancellation. Its late result sees closed and is discarded.
 			const onAbort = () => fail(new Error("Request was aborted"));
-
 			cancelBody = (reason) => fail(reason instanceof Error ? reason : new Error("Response stream was cancelled"));
 			socket.addEventListener("message", onMessage);
 			socket.addEventListener("error", onError);
 			socket.addEventListener("close", onClose);
 			for (const signal of signals) signal.addEventListener("abort", onAbort, { once: true });
+			if (signals.some((signal) => signal.aborted)) { onAbort(); return; }
 			armIdleTimer();
 			try {
 				socket.send(requestFrame);
 			} catch (error) {
-				fail(error);
+				fail(transportError(error));
 			}
 		},
-		cancel(reason) {
-			cancelBody(reason);
-		},
+		cancel(reason) { cancelBody(reason); },
 	});
+	await ready;
 	return new Response(body, {
 		status: 200,
 		headers: { "content-type": "text/event-stream", connection: "keep-alive" },
@@ -573,12 +638,12 @@ export function createResponsesWebSocketFetch(model: Model<Api>, options: Stream
 		}
 		if (!isRecord(payload)) return fallback(input, init);
 
-		const signals = liveSignals(options, init);
+		const signals = liveSignals(options, input, init);
 		const requestId = options.sessionId?.slice(0, 64) || crypto.randomUUID();
 		const fetchHeaders = requestHeaders(input, init);
 		const headers = buildWebSocketHeaders(model, options, fetchHeaders, requestId);
 		const cacheKey = shouldCacheSocket(options) ? buildCacheKey(model, options, fetchHeaders) : undefined;
-		let acquired: AcquiredSocket | undefined;
+		let release: ((keep: boolean) => void) | undefined;
 		try {
 			const lease = await acquireWebSocket(
 				buildResponsesWebSocketUrl(model),
@@ -588,21 +653,27 @@ export function createResponsesWebSocketFetch(model: Model<Api>, options: Stream
 				cacheKey,
 				options.sessionId,
 			);
-			acquired = lease;
+			let released = false;
+			release = (keep) => {
+				if (released) return;
+				released = true;
+				lease.release(keep);
+			};
 			const fullPayload = payload;
 			const requestPayload = lease.entry ? buildCachedRequestBody(lease.entry, fullPayload) : fullPayload;
 			const requestFrame = JSON.stringify({ type: "response.create", ...requestPayload });
-			return createSseResponse(
+			return await createSseResponse(
 				lease.socket,
 				signals,
 				options.timeoutMs ?? 0,
 				requestFrame,
 				(event) => completedContinuation(lease.entry, fullPayload, event),
-				(keep) => lease.release(keep),
+				release,
+				transportMode(options) === "auto",
 			);
 		} catch (error) {
-			acquired?.release(false);
-			if (transportMode(options) === "auto" && !signals.some((signal) => signal.aborted)) {
+			release?.(false);
+			if (error instanceof RecoverableWebSocketError && transportMode(options) === "auto" && !signals.some((signal) => signal.aborted)) {
 				return fallback(input, init);
 			}
 			throw error;

package/src/runtime.ts

@@ -4,6 +4,7 @@ import { convertToLlm, type ExtensionAPI, type ExtensionContext } from "@earendi
 import { isExactModelAllowed } from "./model-scope";
 import {
 	CODEX_AFFINITY_SCOPE,
+	buildResponsesRequestHeaders,
 	type CodexAffinity,
 } from "./responses-headers";
 import { RESPONSES_COMPACT_CAPABLE_APIS } from "./types";
@@ -86,6 +87,8 @@ export type ResponsesRuntime = {
 };
 
 export type NativeCompactionRuntime = ResponsesRuntime & {
+	/** Public host snapshot for the resolved physical model; never inferred from token text. */
+	authMode?: "oauth" | "non-oauth" | "unknown";
 	compactPath: string;
 	compactUrl: string;
 	payload?: ResponsesCompatibleRequestPayload;
@@ -503,6 +506,35 @@ async function resolveRequestAuth(ctx: ExtensionContext, model: RuntimeModel): P
 	return modelRegistry.getApiKeyAndHeaders(model);
 }
 
+function resolveAuthMode(ctx: ExtensionContext, model: RuntimeModel): NativeCompactionRuntime["authMode"] {
+	const registry = ctx.modelRegistry as unknown as {
+		isUsingOAuth?: (model: RuntimeModel) => unknown;
+		hasConfiguredAuth?: (model: RuntimeModel) => unknown;
+	};
+	try {
+		if (typeof registry.isUsingOAuth !== "function" || typeof registry.hasConfiguredAuth !== "function" ||
+			registry.hasConfiguredAuth(model) !== true) return "unknown";
+		const oauth = registry.isUsingOAuth(model);
+		return oauth === true ? "oauth" : oauth === false ? "non-oauth" : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+
+/** Conservative automatic standalone routing; provider aliases alone prove nothing. */
+export function isStandaloneCompactionEligible(runtime: NativeCompactionRuntime): boolean {
+	if (runtime.api !== "openai-responses" || runtime.codexAffinity || runtime.authMode !== "non-oauth") return false;
+	try {
+		const url = new URL(runtime.compactUrl);
+		if (url.protocol !== "https:" || url.hostname !== "api.openai.com" || url.port ||
+			url.pathname !== "/v1/responses/compact" || url.username || url.password || url.search || url.hash) return false;
+		const headers = buildResponsesRequestHeaders(runtime, { accept: "application/json" });
+		return headers.get("authorization") === `Bearer ${runtime.apiKey}`;
+	} catch {
+		return false;
+	}
+}
+
 export function isSupportedApi(api: string): api is ResponsesCompactApi {
 	return (RESPONSES_COMPACT_CAPABLE_APIS as readonly string[]).includes(api);
 }
@@ -696,6 +728,7 @@ async function resolveNativeCompactionEnvironmentForModel(
 			requestModel,
 			baseUrl,
 			apiKey: auth.apiKey,
+			authMode: resolveAuthMode(ctx, effectiveModel),
 			env: auth.env,
 			headers: auth.headers,
 			responsesPath: buildResponsesPath(descriptor.api),

package/src/types.ts

@@ -6,7 +6,6 @@ export const TOOLKIT_ID = "pi-openai-toolkit";
 export const COMPACTION_EXTENSION_ID = `${TOOLKIT_ID}:compaction`;
 export const WEB_SEARCH_EXTENSION_ID = `${TOOLKIT_ID}:web-search`;
 export const IMAGE_GENERATION_EXTENSION_ID = `${TOOLKIT_ID}:image-generation`;
-export const AUTO_MODE_EXTENSION_ID = `${TOOLKIT_ID}:auto-mode`;
 export const DEFAULT_ARTIFACT_ROOT = "~/.pi/agent/artifacts/pi-openai-toolkit/compaction";
 export const REDACTED_VALUE = "[REDACTED]";
 /**
@@ -43,6 +42,7 @@ export type NativeCompactionInputProvenance =
  * replay shim; the provider receives the opaque item from details.compactedWindow.
  */
 export const NATIVE_COMPACTION_FALLBACK_SUMMARY = "[OpenAI remote v2 opaque compaction checkpoint]";
+export const STANDALONE_COMPACTION_FALLBACK_SUMMARY = "[OpenAI standalone opaque compaction window]";
 
 export const THINKING_LEVELS: readonly ThinkingLevel[] = [
 	"off",
@@ -165,71 +165,10 @@ export type ImageGenerationConfig = {
 	models: string[];
 };
 
-/** `side-effect` reviews bash/write/edit plus extras; `all` reviews every tool call. */
-export type AutoModeGate = "side-effect" | "all";
-
-export type AutoModeConfig = {
-	enabled: boolean;
-	/** Exact provider/model keys whose sessions may engage auto mode. */
-	models: string[];
-	/** "provider/model-id" that approves gated tool calls while auto mode is engaged. */
-	reviewerModel?: string;
-	gate: AutoModeGate;
-	/** Extra tool names reviewed on top of the side-effect default set. */
-	extraTools: string[];
-	/** Reviewer deadline in ms; expiry degrades to human confirmation or fail-closed. */
-	timeoutMs: number;
-	/** Give the reviewer a bounded transcript so it can judge user authorization. */
-	transcript: boolean;
-	/** Let the reviewer spend read-only tool calls establishing facts before deciding. */
-	evidenceTools: boolean;
-	maxEvidenceRounds: number;
-	/** Non-blocking trajectory pre-scorer that can satisfy ordinary gated calls. */
-	classifier: AutoModeClassifierConfig;
-	/** End a turn that keeps getting denied instead of negotiating forever. */
-	circuitBreaker: AutoModeCircuitBreakerConfig;
-};
-
-export type AutoModeClassifierConfig = {
-	enabled: boolean;
-	/** "provider/model-id"; falls back to `autoMode.reviewerModel` when unset. */
-	model?: string;
-	timeoutMs: number;
-	/** How many tool calls may elapse between scoring and use before a score is stale. */
-	maxLag: number;
-};
-
-export type AutoModeCircuitBreakerConfig = {
-	/** Consecutive reviewer denials in one turn that end the turn. 0 disables. */
-	consecutiveDenials: number;
-	/** Denials inside `windowSize` reviewed calls that end the turn. 0 disables. */
-	recentDenials: number;
-	windowSize: number;
-};
-
-export const REVIEWER_TIMEOUT_MIN_MS = 1_000;
-export const REVIEWER_TIMEOUT_MAX_MS = 120_000;
-
-/** Read-only investigation rounds the reviewer may spend before it must answer. */
-export const EVIDENCE_ROUNDS_MIN = 0;
-export const EVIDENCE_ROUNDS_MAX = 8;
-
-export const CLASSIFIER_MAX_LAG_MIN = 0;
-export const CLASSIFIER_MAX_LAG_MAX = 20;
-
-export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15_000;
-
-/** Denial counts are small integers; 0 disables the matching trigger. */
-export const BREAKER_LIMIT_MIN = 0;
-export const BREAKER_LIMIT_MAX = 100;
-export const BREAKER_WINDOW_MIN = 1;
-export const BREAKER_WINDOW_MAX = 200;
-
 export type ToolkitConfig = {
 	compaction: CompactionConfig;
 	webSearch: WebSearchConfig;
 	imageGeneration: ImageGenerationConfig;
-	autoMode: AutoModeConfig;
 };
 
 export type LoadedToolkitConfig = {
@@ -324,6 +263,7 @@ export type NativeCompactionDetails = NativeCompactionIdentity & {
 export type NativeCompactionEntry = CompactionEntry<NativeCompactionDetails>;
 
 export type CreateNativeCompactionDetailsInput = NativeCompactionIdentity & {
+	strategy?: NativeCompactionStrategy;
 	inputProvenance: NativeCompactionInputProvenance;
 	compactionModel?: NativeCompactionIdentity;
 	deferredToolCarryover?: DeferredToolCarryoverV1;
@@ -338,8 +278,8 @@ export type CreateNativeCompactionResultInput = {
 	tokensBefore: number;
 	details: NativeCompactionDetails;
 	/**
-	 * Summary text extracted from the compact response. Stored as the entry summary so
-	 * pi's default replay still has real context after switching to an unsupported model.
+	 * An explicitly supplied genuine summary. Retained standalone assistant text is
+	 * not a summary of the sealed history; ordinary remote success uses an opaque marker.
 	 */
 	summary?: string;
 };
@@ -364,7 +304,7 @@ function isStructuredValue(value: unknown): boolean {
 	if (
 		value === null ||
 		typeof value === "string" ||
-		typeof value === "number" ||
+		(typeof value === "number" && Number.isFinite(value)) ||
 		typeof value === "boolean"
 	) {
 		return true;
@@ -396,17 +336,13 @@ 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;
+		return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, cloneStructuredValue(nested)]));
 	}
 
 	throw new Error(`Unsupported structured value: ${typeof value}`);
 }
 
-function isCompactedWindowItem(value: unknown): value is Record<string, unknown> {
+export function isCompactedWindowItem(value: unknown): value is Record<string, unknown> {
 	return isRecord(value) && Object.values(value).every(isStructuredValue);
 }
 
@@ -533,8 +469,11 @@ export function isNativeCompactionEntry(value: unknown): value is NativeCompacti
 }
 
 export function createNativeCompactionDetails(input: CreateNativeCompactionDetailsInput): NativeCompactionDetails {
+	if (input.strategy !== undefined && input.strategy !== LEGACY_NATIVE_COMPACTION_STRATEGY && input.strategy !== REMOTE_V2_COMPACTION_STRATEGY) {
+		throw new Error("Invalid native compaction strategy");
+	}
 	return {
-		strategy: NATIVE_COMPACTION_STRATEGY,
+		strategy: input.strategy ?? NATIVE_COMPACTION_STRATEGY,
 		inputProvenance: input.inputProvenance,
 		provider: normalizeString(input.provider),
 		api: normalizeString(input.api),
@@ -570,7 +509,9 @@ export function createNativeCompactionResult(
 ): CompactionResult<NativeCompactionDetails> {
 	const summary = input.summary?.trim();
 	return {
-		summary: summary && summary.length > 0 ? summary : NATIVE_COMPACTION_FALLBACK_SUMMARY,
+		summary: summary && summary.length > 0 ? summary
+			: input.details.strategy === LEGACY_NATIVE_COMPACTION_STRATEGY ? STANDALONE_COMPACTION_FALLBACK_SUMMARY
+			: NATIVE_COMPACTION_FALLBACK_SUMMARY,
 		firstKeptEntryId: input.firstKeptEntryId,
 		tokensBefore: input.tokensBefore,
 		details: input.details,
@@ -617,32 +558,8 @@ export const DEFAULT_IMAGE_GENERATION_CONFIG: ImageGenerationConfig = {
 	models: [...DEFAULT_IMAGE_GENERATION_MODELS],
 };
 
-export const DEFAULT_AUTO_MODE_CONFIG: AutoModeConfig = {
-	enabled: true,
-	models: [],
-	reviewerModel: undefined,
-	gate: "side-effect",
-	extraTools: [],
-	timeoutMs: 30_000,
-	transcript: true,
-	evidenceTools: true,
-	maxEvidenceRounds: 3,
-	classifier: {
-		enabled: false,
-		model: undefined,
-		timeoutMs: DEFAULT_CLASSIFIER_TIMEOUT_MS,
-		maxLag: 2,
-	},
-	circuitBreaker: {
-		consecutiveDenials: 3,
-		recentDenials: 10,
-		windowSize: 50,
-	},
-};
-
 export const DEFAULT_TOOLKIT_CONFIG: ToolkitConfig = {
 	compaction: DEFAULT_COMPACTION_CONFIG,
 	webSearch: DEFAULT_WEB_SEARCH_CONFIG,
 	imageGeneration: DEFAULT_IMAGE_GENERATION_CONFIG,
-	autoMode: DEFAULT_AUTO_MODE_CONFIG,
 };

package/tsconfig.check.json

@@ -29,10 +29,6 @@
     "src/image-generation/render.ts",
     "src/image-generation/service.ts",
     "src/image-generation/types.ts",
-    "src/auto-mode/extension.ts",
-    "src/auto-mode/policy.ts",
-    "src/auto-mode/reviewer.ts",
-    "src/auto-mode/types.ts",
     "src/responses-websocket/extension.ts",
     "src/responses-websocket/transport.ts",
     "src/model-scope.ts",