pi-openai-toolkit 0.11.1 → 0.12.0

package/src/remote-v2-client.ts

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { writeDebugArtifact } from "./debug";
 import { buildResponsesRequestHeaders } from "./responses-headers";
 import type { NativeCompactionRuntime } from "./runtime";
@@ -23,7 +24,8 @@ export type RemoteV2ResponseEnvelope = Record<string, unknown> & {
 	id?: string;
 	created_at?: number | string;
 	status: "completed";
-	output: RemoteV2CompactionItem[];
+	/** Normalized output always includes the reconciled checkpoint. */
+	output: unknown[];
 	usage?: RemoteV2ResponseUsage;
 };
 
@@ -37,7 +39,11 @@ export type RemoteV2CompactionClientFailureReason =
 	| "missing-completed-event"
 	| "incomplete-response"
 	| "invalid-compaction-count"
-	| "malformed-compaction-item";
+	| "malformed-compaction-item"
+	| "conflicting-compaction-item"
+	| "invalid-compaction-metadata"
+	| "invalid-event-order"
+	| "duplicate-completed-event";
 
 export type RemoteV2CompactionClientSuccess = {
 	ok: true;
@@ -230,6 +236,330 @@ function summarizeEvents(events: readonly ParsedSseEvent[]): unknown[] {
 	});
 }
 
+type OptionalMetadata<T> =
+	| { valid: true; value?: T }
+	| { valid: false };
+
+type CompactionCheckpointCandidate = {
+	item: RemoteV2CompactionItem;
+	responseId?: string;
+	outputIndex?: number;
+	outputPosition?: number;
+};
+
+type CheckpointReconciliation =
+	| {
+			ok: true;
+			response: RemoteV2ResponseEnvelope;
+			compactedWindow: [RemoteV2CompactionItem];
+	  }
+	| {
+			ok: false;
+			reason:
+				| "error-event"
+				| "missing-completed-event"
+				| "incomplete-response"
+				| "invalid-compaction-count"
+				| "malformed-compaction-item"
+				| "conflicting-compaction-item"
+				| "invalid-compaction-metadata"
+				| "invalid-event-order"
+				| "duplicate-completed-event";
+			responseJson?: unknown;
+			errorMessage?: string;
+	  };
+
+function hasOwn(value: Record<string, unknown>, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function readOptionalNonEmptyString(value: Record<string, unknown>, key: string): OptionalMetadata<string> {
+	if (!hasOwn(value, key)) {
+		return { valid: true };
+	}
+	return isNonEmptyString(value[key]) ? { valid: true, value: value[key] } : { valid: false };
+}
+
+function readOptionalOutputIndex(value: Record<string, unknown>): OptionalMetadata<number> {
+	if (!hasOwn(value, "output_index")) {
+		return { valid: true };
+	}
+
+	const outputIndex = value.output_index;
+	return typeof outputIndex === "number" && Number.isSafeInteger(outputIndex) && outputIndex >= 0
+		? { valid: true, value: outputIndex }
+		: { valid: false };
+}
+
+function mergeCompactionItems(
+	itemDone: RemoteV2CompactionItem,
+	terminalOutput: RemoteV2CompactionItem,
+): RemoteV2CompactionItem | undefined {
+	for (const [key, value] of Object.entries(itemDone)) {
+		if (hasOwn(terminalOutput, key) && !isDeepStrictEqual(value, terminalOutput[key])) return undefined;
+	}
+	return structuredClone({ ...itemDone, ...terminalOutput });
+}
+
+function readResponseId(value: Record<string, unknown>): OptionalMetadata<string> {
+	const direct = readOptionalNonEmptyString(value, "response_id");
+	if (!direct.valid) {
+		return direct;
+	}
+
+	const nestedResponse: OptionalMetadata<string> = isRecord(value.response) ? readOptionalNonEmptyString(value.response, "id") : { valid: true };
+	if (!nestedResponse.valid) {
+		return nestedResponse;
+	}
+	if (direct.value !== undefined && nestedResponse.value !== undefined && direct.value !== nestedResponse.value) {
+		return { valid: false };
+	}
+	return { valid: true, value: direct.value ?? nestedResponse.value };
+}
+
+function readCheckpointCandidate(
+	item: Record<string, unknown>,
+	metadataSource: Record<string, unknown> | undefined,
+	outputPosition?: number,
+): { ok: true; candidate: CompactionCheckpointCandidate } | { ok: false; reason: "malformed-compaction-item" | "invalid-compaction-metadata" } {
+	if (!isRemoteV2CompactionItem(item)) {
+		return { ok: false, reason: "malformed-compaction-item" };
+	}
+
+	const itemId = readOptionalNonEmptyString(item, "id");
+	const itemResponseId = readResponseId(item);
+	const itemOutputIndex = readOptionalOutputIndex(item);
+	if (!itemId.valid || !itemResponseId.valid || !itemOutputIndex.valid) {
+		return { ok: false, reason: "invalid-compaction-metadata" };
+	}
+
+	const sourceResponseId: OptionalMetadata<string> = metadataSource ? readResponseId(metadataSource) : { valid: true };
+	const sourceOutputIndex: OptionalMetadata<number> = metadataSource ? readOptionalOutputIndex(metadataSource) : { valid: true };
+	if (!sourceResponseId.valid || !sourceOutputIndex.valid) {
+		return { ok: false, reason: "invalid-compaction-metadata" };
+	}
+	if (
+		itemResponseId.value !== undefined &&
+		sourceResponseId.value !== undefined &&
+		itemResponseId.value !== sourceResponseId.value
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata" };
+	}
+	if (
+		itemOutputIndex.value !== undefined &&
+		sourceOutputIndex.value !== undefined &&
+		itemOutputIndex.value !== sourceOutputIndex.value
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata" };
+	}
+
+	const outputIndex = sourceOutputIndex.value ?? itemOutputIndex.value;
+	if (outputPosition !== undefined && outputIndex !== undefined && outputIndex !== outputPosition) {
+		return { ok: false, reason: "invalid-compaction-metadata" };
+	}
+	return {
+		ok: true,
+		candidate: {
+			item: structuredClone(item),
+			responseId: sourceResponseId.value ?? itemResponseId.value,
+			outputIndex,
+			outputPosition,
+		},
+	};
+}
+
+function isPostTerminalEvent(event: ParsedSseEvent): boolean {
+	if (event.dataText === "[DONE]") {
+		return true;
+	}
+	return getEventType(event) === "keepalive";
+}
+
+function reconcileSseCheckpoint(events: readonly ParsedSseEvent[]): CheckpointReconciliation {
+	const errorEvent = events.find((event) => {
+		const type = getEventType(event);
+		return type === "error" || type === "response.failed" || type === "response.incomplete";
+	});
+	if (errorEvent) {
+		return {
+			ok: false,
+			reason: "error-event",
+			responseJson: errorEvent.data,
+			errorMessage: getErrorMessage(errorEvent.data),
+		};
+	}
+
+	const completedIndexes = events.flatMap((event, index) => (getEventType(event) === "response.completed" ? [index] : []));
+	if (completedIndexes.length === 0) {
+		return { ok: false, reason: "missing-completed-event" };
+	}
+	if (completedIndexes.length > 1) {
+		return { ok: false, reason: "duplicate-completed-event" };
+	}
+	const terminalIndex = completedIndexes[0]!;
+
+	for (let index = 0; index < events.length; index += 1) {
+		const event = events[index]!;
+		if (index < terminalIndex && event.dataText === "[DONE]") {
+			return { ok: false, reason: "invalid-event-order", responseJson: event.dataText };
+		}
+		if (index > terminalIndex && !isPostTerminalEvent(event)) {
+			return { ok: false, reason: "invalid-event-order", responseJson: event.data };
+		}
+	}
+
+	const completedEvent = events[terminalIndex]!;
+	const completedData = isRecord(completedEvent.data) ? completedEvent.data : undefined;
+	const completedResponse = completedData && isRecord(completedData.response) ? completedData.response : undefined;
+	if (!completedResponse) {
+		return { ok: false, reason: "incomplete-response" };
+	}
+
+	if (completedResponse.status !== "completed") {
+		return { ok: false, reason: "incomplete-response", responseJson: completedResponse };
+	}
+	const hasOutput = hasOwn(completedResponse, "output");
+	if (hasOutput && !Array.isArray(completedResponse.output)) {
+		return { ok: false, reason: "incomplete-response", responseJson: completedResponse };
+	}
+	const terminalOutput: unknown[] | undefined = Array.isArray(completedResponse.output) ? completedResponse.output : undefined;
+
+	const terminalResponseId = readOptionalNonEmptyString(completedResponse, "id");
+	const completedEventResponseId: OptionalMetadata<string> = completedData ? readResponseId(completedData) : { valid: true };
+	if (!terminalResponseId.valid || !completedEventResponseId.valid) {
+		return { ok: false, reason: "invalid-compaction-metadata", responseJson: completedResponse };
+	}
+	if (
+		terminalResponseId.value !== undefined &&
+		completedEventResponseId.value !== undefined &&
+		terminalResponseId.value !== completedEventResponseId.value
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata", responseJson: completedResponse };
+	}
+	let responseId = terminalResponseId.value ?? completedEventResponseId.value;
+	for (const event of events.slice(0, terminalIndex)) {
+		if (getEventType(event) !== "response.created" || !isRecord(event.data)) continue;
+		const createdId = readResponseId(event.data);
+		if (!createdId.valid || (createdId.value !== undefined && responseId !== undefined && createdId.value !== responseId)) {
+			return { ok: false, reason: "invalid-compaction-metadata", responseJson: event.data };
+		}
+		responseId ??= createdId.value;
+	}
+
+	let itemDoneCandidate: CompactionCheckpointCandidate | undefined;
+	for (let index = 0; index < terminalIndex; index += 1) {
+		const event = events[index]!;
+		if (getEventType(event) !== "response.output_item.done") {
+			continue;
+		}
+		if (!isRecord(event.data) || !isRecord(event.data.item)) {
+			return { ok: false, reason: "malformed-compaction-item", responseJson: event.data };
+		}
+		if (event.data.item.type !== "compaction") {
+			continue;
+		}
+		if (itemDoneCandidate) {
+			return { ok: false, reason: "invalid-compaction-count", responseJson: event.data.item };
+		}
+		const candidate = readCheckpointCandidate(event.data.item, event.data);
+		if (!candidate.ok) {
+			return { ok: false, reason: candidate.reason, responseJson: event.data.item };
+		}
+		itemDoneCandidate = candidate.candidate;
+	}
+
+	let terminalCandidate: CompactionCheckpointCandidate | undefined;
+	let terminalPosition: number | undefined;
+	if (terminalOutput) {
+		const compactionPositions = terminalOutput.flatMap((item, index) =>
+			isRecord(item) && item.type === "compaction" ? [index] : [],
+		);
+		if (compactionPositions.length > 1) {
+			return { ok: false, reason: "invalid-compaction-count", responseJson: completedResponse };
+		}
+		if (compactionPositions.length === 1) {
+			terminalPosition = compactionPositions[0]!;
+			const outputItem = terminalOutput[terminalPosition];
+			if (!isRecord(outputItem)) {
+				return { ok: false, reason: "malformed-compaction-item", responseJson: outputItem };
+			}
+			const candidate = readCheckpointCandidate(outputItem, undefined, terminalPosition);
+			if (!candidate.ok) {
+				return { ok: false, reason: candidate.reason, responseJson: outputItem };
+			}
+			terminalCandidate = candidate.candidate;
+		}
+	}
+
+	if (!itemDoneCandidate && !terminalCandidate) {
+		return { ok: false, reason: "invalid-compaction-count", responseJson: completedResponse };
+	}
+
+	for (const candidate of [itemDoneCandidate, terminalCandidate]) {
+		if (
+			candidate?.responseId !== undefined &&
+			responseId !== undefined &&
+			candidate.responseId !== responseId
+		) {
+			return { ok: false, reason: "invalid-compaction-metadata", responseJson: candidate.item };
+		}
+	}
+	if (
+		itemDoneCandidate?.responseId !== undefined &&
+		terminalCandidate?.responseId !== undefined &&
+		itemDoneCandidate.responseId !== terminalCandidate.responseId
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata", responseJson: terminalCandidate.item };
+	}
+	if (
+		itemDoneCandidate?.outputIndex !== undefined &&
+		terminalCandidate?.outputPosition !== undefined &&
+		itemDoneCandidate.outputIndex !== terminalCandidate.outputPosition
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata", responseJson: terminalCandidate.item };
+	}
+	if (
+		itemDoneCandidate?.outputIndex !== undefined &&
+		terminalOutput !== undefined &&
+		terminalOutput.length > 0 &&
+		terminalCandidate === undefined &&
+		itemDoneCandidate.outputIndex > terminalOutput.length
+	) {
+		return { ok: false, reason: "invalid-compaction-metadata", responseJson: completedResponse };
+	}
+
+	let canonicalItem: RemoteV2CompactionItem;
+	if (itemDoneCandidate && terminalCandidate) {
+		const merged = mergeCompactionItems(itemDoneCandidate.item, terminalCandidate.item);
+		if (!merged) {
+			return { ok: false, reason: "conflicting-compaction-item", responseJson: terminalCandidate.item };
+		}
+		canonicalItem = merged;
+	} else {
+		canonicalItem = structuredClone((itemDoneCandidate ?? terminalCandidate)!.item);
+	}
+
+	const responseEnvelope = structuredClone(completedResponse) as RemoteV2ResponseEnvelope;
+	if (terminalOutput) {
+		const output = structuredClone(terminalOutput);
+		if (terminalPosition !== undefined) {
+			output[terminalPosition] = structuredClone(canonicalItem);
+		} else {
+			const insertionIndex = itemDoneCandidate?.outputIndex ?? output.length;
+			output.splice(insertionIndex, 0, structuredClone(canonicalItem));
+		}
+		responseEnvelope.output = output;
+	} else {
+		responseEnvelope.output = [structuredClone(canonicalItem)];
+	}
+
+	return {
+		ok: true,
+		response: responseEnvelope,
+		compactedWindow: [structuredClone(canonicalItem)],
+	};
+}
+
 export async function executeRemoteV2Compaction(
 	options: ExecuteRemoteV2CompactionOptions,
 ): Promise<RemoteV2CompactionClientResult> {
@@ -333,103 +663,14 @@ export async function executeRemoteV2Compaction(
 			return failure;
 		}
 
-		const errorEvent = events.find((event) => {
-			const type = getEventType(event);
-			return type === "error" || type === "response.failed" || type === "response.incomplete";
-		});
-		if (errorEvent) {
-			const failure: RemoteV2CompactionClientFailure = {
-				ok: false,
-				reason: "error-event",
-				status: response.status,
-				errorMessage: getErrorMessage(errorEvent.data),
-				responseJson: errorEvent.data,
-			};
-			writeCompactArtifact(
-				{
-					protocol: "remote_compaction_v2",
-					request: { url: runtime.responsesUrl, headers, body: request },
-					response: { status: response.status, headers: responseHeaders, events: summarizeEvents(events) },
-					outcome: failure,
-				},
-				settings,
-				context,
-			);
-			return failure;
-		}
-
-		const completedEvent = events.find((event) => getEventType(event) === "response.completed");
-		const completedData = completedEvent && isRecord(completedEvent.data) ? completedEvent.data : undefined;
-		const completedResponse = completedData && isRecord(completedData.response) ? completedData.response : undefined;
-		if (!completedResponse) {
-			const failure: RemoteV2CompactionClientFailure = {
-				ok: false,
-				reason: "missing-completed-event",
-				status: response.status,
-			};
-			writeCompactArtifact(
-				{
-					protocol: "remote_compaction_v2",
-					request: { url: runtime.responsesUrl, headers, body: request },
-					response: { status: response.status, headers: responseHeaders, events: summarizeEvents(events) },
-					outcome: failure,
-				},
-				settings,
-				context,
-			);
-			return failure;
-		}
-
-		if (completedResponse.status !== "completed" || !Array.isArray(completedResponse.output)) {
-			const failure: RemoteV2CompactionClientFailure = {
-				ok: false,
-				reason: "incomplete-response",
-				status: response.status,
-				responseJson: completedResponse,
-			};
-			writeCompactArtifact(
-				{
-					protocol: "remote_compaction_v2",
-					request: { url: runtime.responsesUrl, headers, body: request },
-					response: { status: response.status, headers: responseHeaders, events: summarizeEvents(events) },
-					outcome: failure,
-				},
-				settings,
-				context,
-			);
-			return failure;
-		}
-
-		const compactionItems = completedResponse.output.filter(
-			(item): item is Record<string, unknown> => isRecord(item) && item.type === "compaction",
-		);
-		if (compactionItems.length !== 1) {
-			const failure: RemoteV2CompactionClientFailure = {
-				ok: false,
-				reason: "invalid-compaction-count",
-				status: response.status,
-				responseJson: completedResponse,
-			};
-			writeCompactArtifact(
-				{
-					protocol: "remote_compaction_v2",
-					request: { url: runtime.responsesUrl, headers, body: request },
-					response: { status: response.status, headers: responseHeaders, events: summarizeEvents(events) },
-					outcome: failure,
-				},
-				settings,
-				context,
-			);
-			return failure;
-		}
-
-		const compactionItem = compactionItems[0];
-		if (!isRemoteV2CompactionItem(compactionItem)) {
+		const reconciliation = reconcileSseCheckpoint(events);
+		if (!reconciliation.ok) {
 			const failure: RemoteV2CompactionClientFailure = {
 				ok: false,
-				reason: "malformed-compaction-item",
+				reason: reconciliation.reason,
 				status: response.status,
-				responseJson: compactionItem,
+				errorMessage: reconciliation.errorMessage,
+				responseJson: reconciliation.responseJson,
 			};
 			writeCompactArtifact(
 				{
@@ -444,15 +685,15 @@ export async function executeRemoteV2Compaction(
 			return failure;
 		}
 
-		const responseEnvelope = completedResponse as RemoteV2ResponseEnvelope;
+		const responseEnvelope = reconciliation.response;
 		const success: RemoteV2CompactionClientSuccess = {
 			ok: true,
 			status: response.status,
-			compactedWindow: [structuredClone(compactionItem)],
+			compactedWindow: reconciliation.compactedWindow,
 			compactResponseId: isNonEmptyString(responseEnvelope.id) ? responseEnvelope.id.trim() : undefined,
 			createdAt: normalizeResponseTimestamp(responseEnvelope.created_at),
 			usage: isRecord(responseEnvelope.usage) ? (structuredClone(responseEnvelope.usage) as RemoteV2ResponseUsage) : undefined,
-			response: structuredClone(responseEnvelope),
+			response: responseEnvelope,
 		};
 		writeCompactArtifact(
 			{

package/src/request-context-cache.ts

@@ -12,6 +12,8 @@ export type CompactionRequestExtras = {
 	reasoning?: Record<string, unknown>;
 	service_tier?: string;
 	prompt_cache_key?: string;
+	prompt_cache_retention?: "in_memory" | "24h";
+	prompt_cache_options?: Record<string, unknown>;
 	text?: Record<string, unknown>;
 };
 
@@ -75,6 +77,12 @@ export function rememberRequestContext(
 		if (typeof payload.prompt_cache_key === "string" && payload.prompt_cache_key.trim().length > 0) {
 			extras.prompt_cache_key = payload.prompt_cache_key;
 		}
+		if (payload.prompt_cache_retention === "in_memory" || payload.prompt_cache_retention === "24h") {
+			extras.prompt_cache_retention = payload.prompt_cache_retention;
+		}
+		if (isRecord(payload.prompt_cache_options)) {
+			extras.prompt_cache_options = structuredClone(payload.prompt_cache_options);
+		}
 		if (isRecord(payload.text)) {
 			extras.text = structuredClone(payload.text);
 		}
@@ -88,14 +96,39 @@ export function rememberRequestContext(
 	}
 }
 
-/** Return cached extras only for the exact provider/API/model/base URL/session identity. */
-export function getCompactionRequestExtras(identity: RequestContextIdentity): CompactionRequestExtras | undefined {
+/**
+ * Look up the exact live-request identity. When building a synthetic request,
+ * supply its producer to omit cache fields unsupported by that model/API.
+ * No TTL conversion or implicit cache policy is applied.
+ */
+export function getCompactionRequestExtras(
+	identity: RequestContextIdentity,
+	producer?: { api: string; compat?: unknown },
+): CompactionRequestExtras | undefined {
 	if (!cached || !sameIdentity(cached.identity, identity)) {
 		return undefined;
 	}
 
 	try {
-		return structuredClone(cached.extras);
+		const extras = structuredClone(cached.extras);
+		if (producer) {
+			const compat = isRecord(producer.compat) ? producer.compat : {};
+			if (producer.api !== "openai-responses") {
+				delete extras.prompt_cache_options;
+				delete extras.prompt_cache_retention;
+			} else {
+				if (compat.supportsExplicitPromptCacheMode === true) {
+					delete extras.prompt_cache_retention;
+				} else {
+					delete extras.prompt_cache_options;
+				}
+				if (compat.supportsLongCacheRetention === false) {
+					if (extras.prompt_cache_options?.ttl !== undefined) delete extras.prompt_cache_options;
+					if (extras.prompt_cache_retention === "24h") delete extras.prompt_cache_retention;
+				}
+			}
+		}
+		return extras;
 	} catch {
 		return undefined;
 	}

package/src/serializer.ts

@@ -14,6 +14,7 @@ import type {
 	UserMessage,
 } from "@earendil-works/pi-ai";
 import type { ResponsesCompatibleRequestPayload } from "./runtime";
+import type { CompactionRequestExtras } from "./request-context-cache";
 
 /**
  * pi stopped exporting the CompactionPreparation type name in 0.80.x, but it is still
@@ -95,21 +96,11 @@ export type ResponsesInputItem =
 	| ResponsesFunctionCallOutputItem
 	| ResponsesReasoningItem;
 
-export type NativeCompactionRequestBody = {
+/** The synthetic request shares the live-request extras allowlist. */
+export type NativeCompactionRequestBody = CompactionRequestExtras & {
 	model: string;
 	input: ResponsesInputItem[];
 	instructions: string;
-	/**
-	 * Optional passthrough fields mirroring the latest codex_rs CompactionInput.
-	 * Sourced from the most recent provider request payload when available;
-	 * undefined fields are omitted from the serialized JSON body.
-	 */
-	tools?: unknown[];
-	parallel_tool_calls?: boolean;
-	reasoning?: Record<string, unknown>;
-	service_tier?: string;
-	prompt_cache_key?: string;
-	text?: Record<string, unknown>;
 };
 
 export type SerializeResponsesMessagesOptions = {
@@ -308,6 +299,7 @@ function transformMessagesForResponses(messages: Message[]): Message[] {
 		transformed.push(message);
 	}
 
+	transformed.push(...createSyntheticToolResults(pendingToolCalls, existingToolResultIds));
 	return transformed;
 }
 

package/src/types.ts

@@ -38,8 +38,6 @@ export type DebugArtifactKind =
 	| "compaction-event"
 	| "lifecycle";
 
-export type CompactionContinuationMode = "inline" | "followUp" | "off";
-
 /** Native-method fallback compaction: which model runs pi's compact() and how deeply. */
 export type NativeFallbackConfig = {
 	enabled: boolean;
@@ -54,13 +52,6 @@ export type NativeFallbackConfig = {
 	thinkingLevel: ThinkingLevel;
 };
 
-export type AutoCompactionConfig = {
-	enabled: boolean;
-	continuation: CompactionContinuationMode;
-	unsupportedFallback: "followUp" | "off";
-	reserveTokens?: number;
-};
-
 export type CompactionConfig = {
 	enabled: boolean;
 	/**
@@ -75,8 +66,6 @@ export type CompactionConfig = {
 	remoteCompactModel?: string;
 	/** Native-method fallback compaction policy (non-Responses APIs, or when the compact endpoint fails). */
 	nativeFallback: NativeFallbackConfig;
-	/** Threshold-triggered compaction and same-tool-loop continuation policy. */
-	autoCompaction: AutoCompactionConfig;
 	/** Subset of RESPONSES_COMPACT_CAPABLE_APIS that should use remote compaction. */
 	responsesApis: string[];
 	notifyOnLoad: boolean;
@@ -494,13 +483,6 @@ export function createNativeCompactionResult(
 	};
 }
 
-export const DEFAULT_AUTO_COMPACTION_CONFIG: AutoCompactionConfig = {
-	enabled: true,
-	continuation: "inline",
-	unsupportedFallback: "followUp",
-	reserveTokens: undefined,
-};
-
 export const DEFAULT_NATIVE_FALLBACK_CONFIG: NativeFallbackConfig = {
 	enabled: true,
 	model: undefined,
@@ -512,7 +494,6 @@ export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	allowCompactionContinuityBreak: false,
 	remoteCompactModel: undefined,
 	nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
-	autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 	responsesApis: [...RESPONSES_COMPACT_CAPABLE_APIS],
 	notifyOnLoad: false,
 	debug: false,

package/tsconfig.check.json

@@ -21,7 +21,6 @@
     "src/debug.ts",
     "src/details-store.ts",
     "src/deferred-tool-carryover.ts",
-    "src/inline-compaction.ts",
     "src/extension-runtime.ts",
     "src/image-generation/artifacts.ts",
     "src/image-generation/client.ts",