pi-openai-toolkit 0.6.0 → 0.7.1

package/src/payload-rewrite.ts

@@ -7,6 +7,7 @@ import type {
 	SessionMessageEntry,
 } from "@earendil-works/pi-coding-agent";
 import type { ResponsesCompatibleRequestPayload } from "./runtime";
+import { rewritePayloadWithDeferredToolCarryover } from "./deferred-tool-carryover";
 import type { NativeCompactionEntry } from "./types";
 import {
 	compareResponsesInputParity,
@@ -16,12 +17,6 @@ import {
 	type ResponsesInputMessageItem,
 } from "./serializer";
 
-export type FreshAuthoritativePreamble = {
-	instructions?: string;
-	leadingInput: ResponsesInputMessageItem[];
-	trailingInput: ResponsesInputMessageItem[];
-};
-
 export type SerializedReplaySlice = {
 	entries: SessionEntry[];
 	messages: AgentMessage[];
@@ -51,10 +46,10 @@ export type NativeReplayPayloadRewrite = {
 export type NativeReplayPayloadRewriteFailureReason =
 	| "compaction-boundary-not-found"
 	| "first-kept-entry-not-found"
-	| "unsupported-instructions"
 	| "invalid-compacted-window"
 	| "unexpected-compaction-after-boundary"
-	| "expected-pi-replay-mismatch";
+	| "expected-pi-replay-mismatch"
+	| "compaction-summary-not-found";
 
 export type NativeReplayPayloadRewriteFailure = {
 	ok: false;
@@ -267,44 +262,50 @@ function toReplayAgentMessage(entry: SessionEntry): AgentMessage | undefined {
 	return undefined;
 }
 
-function isPromptEnvelopeItem(item: unknown): item is ResponsesInputMessageItem {
-	return isResponsesInputMessageItem(item) && isPreambleRole(item.role);
-}
-
-export function extractFreshAuthoritativePreamble(
-	payload: ResponsesCompatibleRequestPayload,
-): FreshAuthoritativePreamble | undefined {
-	if (payload.instructions !== undefined && typeof payload.instructions !== "string") {
-		return undefined;
+function extractUserItemText(item: Record<string, unknown>): unknown {
+	const { content } = item;
+	if (typeof content === "string") {
+		return content;
 	}
 
-	// Developer/system items in Pi's Responses payload are prompt-level instructions,
-	// not transcript entries from session history. Preserve them in the same leading
-	// or trailing position that Pi authored so provider-added suffix prompts like
-	// GPT-5's trailing developer "# Juice: 0 !important" survive replay unchanged.
-	let leadingBoundary = 0;
-	while (leadingBoundary < payload.input.length && isPromptEnvelopeItem(payload.input[leadingBoundary])) {
-		leadingBoundary += 1;
+	if (Array.isArray(content)) {
+		const first = content[0];
+		if (isRecord(first) && first.type === "input_text" && typeof first.text === "string") {
+			return first.text;
+		}
 	}
 
-	let trailingBoundary = payload.input.length;
-	while (trailingBoundary > leadingBoundary && isPromptEnvelopeItem(payload.input[trailingBoundary - 1])) {
-		trailingBoundary -= 1;
-	}
+	return undefined;
+}
 
-	for (let index = leadingBoundary; index < trailingBoundary; index++) {
-		if (isPromptEnvelopeItem(payload.input[index])) {
-			return undefined;
+/**
+ * Locate the Pi-authored compaction summary item. The marker text is unique to
+ * this compaction entry, so a content match on the user item is a reliable
+ * single anchor; nothing else in the payload needs to be prefixed or counted.
+ */
+function findCompactionSummaryIndex(input: readonly unknown[], summaryMarker: string): number {
+	return input.findIndex((item) => {
+		if (!isRecord(item) || item.role !== "user") {
+			return false;
 		}
-	}
 
-	return {
-		...(typeof payload.instructions === "string" ? { instructions: payload.instructions } : {}),
-		leadingInput: payload.input.slice(0, leadingBoundary).map((item) => cloneResponsesInputMessageItem(item as ResponsesInputMessageItem)),
-		trailingInput: payload.input
-			.slice(trailingBoundary)
-			.map((item) => cloneResponsesInputMessageItem(item as ResponsesInputMessageItem)),
-	};
+		const text = extractUserItemText(item);
+		return typeof text === "string" && text.includes("<summary>") && text.includes(summaryMarker);
+	});
+}
+
+/** Count consecutive provider-authored developer/system items at the end of the input. */
+function countTrailingPreambleItems(items: readonly unknown[]): number {
+	let count = 0;
+	for (let index = items.length - 1; index >= 0; index--) {
+		const item = items[index];
+		if (isResponsesInputMessageItem(item) && isPreambleRole(item.role)) {
+			count += 1;
+			continue;
+		}
+		break;
+	}
+	return count;
 }
 
 function collectReplayMessages(entries: readonly SessionEntry[]): AgentMessage[] {
@@ -407,14 +408,6 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		};
 	}
 
-	const freshPreamble = extractFreshAuthoritativePreamble(args.payload);
-	if (!freshPreamble) {
-		return {
-			ok: false,
-			reason: "unsupported-instructions",
-		};
-	}
-
 	const newerCompactionEntry = args.branchEntries
 		.slice(boundaryIndex + 1)
 		.some((entry) => entry.type === "compaction");
@@ -446,19 +439,38 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 	const preCompactionKeptMessages = collectReplayMessages(preCompactionEntries);
 	const postCompactionTailMessages = collectReplayMessages(postCompactionEntries);
 	const compactionSummaryMessage = createCompactionSummaryAgentMessage(args.compactionEntry);
-	const serializedPiHistoryInput = serializeMessagesToResponsesInput(args.model, [
-		compactionSummaryMessage,
-		...preCompactionKeptMessages,
-		...postCompactionTailMessages,
-	]);
-	const originalPiReplayInput: ResponsesInputItem[] = [
-		...freshPreamble.leadingInput,
-		...serializedPiHistoryInput,
-		...freshPreamble.trailingInput,
-	];
+	const keptWindowSerialized = serializeMessagesToResponsesInput(args.model, preCompactionKeptMessages);
 
-	if (!areEquivalentValues(args.payload.input, originalPiReplayInput)) {
-		const parity = compareResponsesInputParity(args.payload.input, originalPiReplayInput);
+	// Pi-authored compaction summary item. Everything outside the replaced region
+	// is preserved verbatim, so this content anchor is the only location probe
+	// needed; the marker text is unique to this compaction entry.
+	const summaryIndex = findCompactionSummaryIndex(args.payload.input, args.compactionEntry.summary);
+	if (summaryIndex < 0) {
+		return {
+			ok: false,
+			reason: "compaction-summary-not-found",
+		};
+	}
+
+	const keptStart = summaryIndex + 1;
+	const keptEnd = keptStart + keptWindowSerialized.length;
+	const actualKeptWindow = cloneResponsesInputSlice(args.payload.input.slice(keptStart, keptEnd));
+	if (!actualKeptWindow) {
+		return {
+			ok: false,
+			reason: "expected-pi-replay-mismatch",
+		};
+	}
+
+	// The only hard verification: the region immediately after the sentinel must be
+	// exactly the kept pre-compaction window derived from session entries. Content
+	// after this region is preserved as-is, so transient messages injected by other
+	// extensions (which have no session entries) no longer break replay.
+	if (!areEquivalentValues(actualKeptWindow, keptWindowSerialized)) {
+		const parity = compareResponsesInputParity(
+			args.payload.input.slice(keptStart, keptEnd),
+			keptWindowSerialized,
+		);
 		return {
 			ok: false,
 			reason: "expected-pi-replay-mismatch",
@@ -470,70 +482,77 @@ function buildNativeReplaySegmentsInternal<TApi extends Api>(args: {
 		};
 	}
 
-	const freshPreambleCount = freshPreamble.leadingInput.length;
-	const trailingPreambleCount = freshPreamble.trailingInput.length;
-	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 actualPostCompactionTail = cloneResponsesInputSlice(args.payload.input.slice(tailStartIndex, tailEndIndex));
-	if (!actualCompactionSummary || !actualPreCompactionKeptWindow || !actualPostCompactionTail) {
+	const actualCompactionSummary = cloneResponsesInputSlice([args.payload.input[summaryIndex]]);
+	const actualPostCompactionTail = cloneResponsesInputSlice(args.payload.input.slice(keptEnd));
+	if (!actualCompactionSummary || !actualPostCompactionTail) {
 		return {
 			ok: false,
 			reason: "expected-pi-replay-mismatch",
 		};
 	}
 
-	const preCompactionKeptWindow = createReplaySlice(
-		preCompactionEntries,
-		preCompactionKeptMessages,
-		actualPreCompactionKeptWindow,
-	);
-	const postCompactionTail = createReplaySlice(
-		postCompactionEntries,
-		postCompactionTailMessages,
-		actualPostCompactionTail,
-	);
+	// Keep provider-authored trailing developer/system prompts in place.
+	const trailingCount = countTrailingPreambleItems(actualPostCompactionTail);
+	const trailingPreamble = actualPostCompactionTail.slice(actualPostCompactionTail.length - trailingCount);
+	const liveTail = actualPostCompactionTail.slice(0, actualPostCompactionTail.length - trailingCount);
+
+	const leadingInput = cloneResponsesInputSlice(args.payload.input.slice(0, summaryIndex));
+	if (!leadingInput) {
+		return {
+			ok: false,
+			reason: "expected-pi-replay-mismatch",
+		};
+	}
+
+	const baseRewrittenPayload: ResponsesCompatibleRequestPayload = {
+		...args.payload,
+		input: [
+			...leadingInput,
+			...compactedWindow,
+			...liveTail,
+			...trailingPreamble,
+		],
+	};
+	const carryoverRewrite = rewritePayloadWithDeferredToolCarryover({
+		payload: baseRewrittenPayload,
+		carryover: details.deferredToolCarryover,
+		compactionEntryId: args.compactionEntry.id,
+		checkpointEndIndex: leadingInput.length + compactedWindow.length,
+		compat: args.model.compat as
+			| { supportsAdditionalTools?: boolean; supportsToolSearch?: boolean }
+			| undefined,
+	});
+
+	const sentinelSerialized = serializeMessagesToResponsesInput(args.model, [compactionSummaryMessage]);
+	const serializedTailInput = serializeMessagesToResponsesInput(args.model, postCompactionTailMessages);
+	const originalPiReplayInput: ResponsesInputItem[] = [
+		...leadingInput,
+		...sentinelSerialized,
+		...keptWindowSerialized,
+		...serializedTailInput,
+		...trailingPreamble,
+	];
 
 	return {
 		ok: true,
 		segments: {
 			boundaryIndex,
 			firstKeptEntryIndex,
-			instructions: freshPreamble.instructions,
-			freshPreamble: freshPreamble.leadingInput,
-			trailingPreamble: freshPreamble.trailingInput,
+			instructions: typeof args.payload.instructions === "string" ? args.payload.instructions : undefined,
+			freshPreamble: leadingInput as ResponsesInputMessageItem[],
+			trailingPreamble: trailingPreamble as ResponsesInputMessageItem[],
 			compactionSummary: actualCompactionSummary,
-			preCompactionKeptWindow,
+			preCompactionKeptWindow: createReplaySlice(
+				preCompactionEntries,
+				preCompactionKeptMessages,
+				actualKeptWindow,
+			),
 			compactedWindow,
-			postCompactionTail,
+			postCompactionTail: createReplaySlice(postCompactionEntries, postCompactionTailMessages, liveTail),
 			originalPiReplayInput,
-			replayInput: [
-				...freshPreamble.leadingInput,
-				...compactedWindow,
-				...actualPostCompactionTail,
-				...freshPreamble.trailingInput,
-			],
-		},
-		rewrittenPayload: {
-			...args.payload,
-			...(freshPreamble.instructions !== undefined ? { instructions: freshPreamble.instructions } : {}),
-			input: [
-				...freshPreamble.leadingInput,
-				...compactedWindow,
-				...actualPostCompactionTail,
-				...freshPreamble.trailingInput,
-			],
+			replayInput: carryoverRewrite.payload.input,
 		},
+		rewrittenPayload: carryoverRewrite.payload,
 	};
 }
 

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { CompactionEntry, CompactionResult, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CompactionEntry, CompactionResult, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 
 export const TOOLKIT_ID = "pi-openai-toolkit";
 export const COMPACTION_EXTENSION_ID = `${TOOLKIT_ID}:compaction`;
@@ -36,6 +36,15 @@ export type DebugArtifactKind =
 	| "compaction-event"
 	| "lifecycle";
 
+export type CompactionContinuationMode = "inline" | "followUp" | "off";
+
+export type AutoCompactionConfig = {
+	enabled: boolean;
+	continuation: CompactionContinuationMode;
+	unsupportedFallback: "followUp" | "off";
+	reserveTokens?: number;
+};
+
 export type CompactionConfig = {
 	enabled: boolean;
 	/**
@@ -55,6 +64,8 @@ export type CompactionConfig = {
 	model?: string;
 	/** Thinking level passed to pi's native compact() when the fallback model runs. */
 	thinkingLevel: ThinkingLevel;
+	/** 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;
@@ -135,10 +146,21 @@ export type NativeCompactionIdentity = {
 	baseUrl: string;
 };
 
+export const CACHE_STACK_ACTIVATION_ENTRY_TYPE = "pi-cache-stack.activation-state.v1" as const;
+
+export type DeferredToolCarryoverV1 = {
+	version: 1;
+	source: typeof CACHE_STACK_ACTIVATION_ENTRY_TYPE;
+	toolNames: string[];
+	catalogHash?: string;
+};
+
 export type NativeCompactionDetails = NativeCompactionIdentity & {
 	strategy: NativeCompactionStrategy;
 	/** Actual producer of the opaque checkpoint; absent on legacy same-model entries. */
 	compactionModel?: NativeCompactionIdentity;
+	/** Cache-stack activation state captured at this opaque checkpoint. */
+	deferredToolCarryover?: DeferredToolCarryoverV1;
 	compactedWindow: unknown[];
 	compactResponseId?: string;
 	createdAt: string;
@@ -149,6 +171,7 @@ export type NativeCompactionEntry = CompactionEntry<NativeCompactionDetails>;
 
 export type CreateNativeCompactionDetailsInput = NativeCompactionIdentity & {
 	compactionModel?: NativeCompactionIdentity;
+	deferredToolCarryover?: DeferredToolCarryoverV1;
 	compactedWindow: unknown[];
 	compactResponseId?: string;
 	createdAt?: string;
@@ -262,6 +285,64 @@ export function isNativeCompactionIdentity(value: unknown): value is NativeCompa
 	);
 }
 
+export function isDeferredToolCarryover(value: unknown): value is DeferredToolCarryoverV1 {
+	if (!isRecord(value) || value.version !== 1 || value.source !== CACHE_STACK_ACTIVATION_ENTRY_TYPE) {
+		return false;
+	}
+
+	return (
+		Array.isArray(value.toolNames) &&
+		value.toolNames.every((name) => isNonEmptyString(name)) &&
+		(value.catalogHash === undefined || typeof value.catalogHash === "string")
+	);
+}
+
+function normalizeDeferredToolCarryover(value: DeferredToolCarryoverV1): DeferredToolCarryoverV1 {
+	if (!isDeferredToolCarryover(value)) {
+		throw new Error("Invalid deferred tool carryover");
+	}
+
+	return {
+		version: 1,
+		source: CACHE_STACK_ACTIVATION_ENTRY_TYPE,
+		toolNames: [...new Set(value.toolNames.map((name) => name.trim()).filter(Boolean))].sort(),
+		...(typeof value.catalogHash === "string" ? { catalogHash: value.catalogHash } : {}),
+	};
+}
+
+function decodeCacheStackActivationState(value: unknown): DeferredToolCarryoverV1 | undefined {
+	if (!isRecord(value) || value.version !== 1 || typeof value.catalogHash !== "string") {
+		return undefined;
+	}
+	if (!Array.isArray(value.activatedTools) || !value.activatedTools.every((name) => typeof name === "string")) {
+		return undefined;
+	}
+
+	return normalizeDeferredToolCarryover({
+		version: 1,
+		source: CACHE_STACK_ACTIVATION_ENTRY_TYPE,
+		toolNames: value.activatedTools,
+		catalogHash: value.catalogHash,
+	});
+}
+
+/** Read only the latest valid cache-stack activation snapshot on this branch. */
+export function getLatestDeferredToolCarryover(
+	entries: readonly SessionEntry[],
+): DeferredToolCarryoverV1 | undefined {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (entry?.type !== "custom" || entry.customType !== CACHE_STACK_ACTIVATION_ENTRY_TYPE) {
+			continue;
+		}
+
+		const decoded = decodeCacheStackActivationState(entry.data);
+		if (decoded) return decoded;
+	}
+
+	return undefined;
+}
+
 export function isNativeCompactionDetails(value: unknown): value is NativeCompactionDetails {
 	if (!isRecord(value) || !isNativeCompactionIdentity(value)) {
 		return false;
@@ -272,6 +353,7 @@ export function isNativeCompactionDetails(value: unknown): value is NativeCompac
 		(candidate.strategy === LEGACY_NATIVE_COMPACTION_STRATEGY ||
 			candidate.strategy === REMOTE_V2_COMPACTION_STRATEGY) &&
 		(candidate.compactionModel === undefined || isNativeCompactionIdentity(candidate.compactionModel)) &&
+		(candidate.deferredToolCarryover === undefined || isDeferredToolCarryover(candidate.deferredToolCarryover)) &&
 		Array.isArray(candidate.compactedWindow) &&
 		candidate.compactedWindow.every(isCompactedWindowItem) &&
 		isNonEmptyString(candidate.createdAt) &&
@@ -299,6 +381,9 @@ export function createNativeCompactionDetails(input: CreateNativeCompactionDetai
 				baseUrl: normalizeString(input.compactionModel.baseUrl),
 			}
 			: undefined,
+		deferredToolCarryover: input.deferredToolCarryover
+			? normalizeDeferredToolCarryover(input.deferredToolCarryover)
+			: undefined,
 		compactedWindow: input.compactedWindow.map((item) => cloneStructuredValue(item)),
 		compactResponseId: isNonEmptyString(input.compactResponseId) ? normalizeString(input.compactResponseId) : undefined,
 		createdAt: isNonEmptyString(input.createdAt) ? normalizeString(input.createdAt) : new Date().toISOString(),
@@ -325,12 +410,20 @@ export function createNativeCompactionResult(
 	};
 }
 
+export const DEFAULT_AUTO_COMPACTION_CONFIG: AutoCompactionConfig = {
+	enabled: true,
+	continuation: "inline",
+	unsupportedFallback: "followUp",
+	reserveTokens: undefined,
+};
+
 export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	enabled: true,
 	allowCompactionContinuityBreak: false,
 	remoteCompactModel: undefined,
 	model: undefined,
 	thinkingLevel: "off",
+	autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 	responsesApis: [...RESPONSES_COMPACT_CAPABLE_APIS],
 	notifyOnLoad: false,
 	debug: false,

package/tsconfig.check.json

@@ -18,6 +18,8 @@
     "src/config.ts",
     "src/debug.ts",
     "src/details-store.ts",
+    "src/deferred-tool-carryover.ts",
+    "src/inline-compaction.ts",
     "src/extension-runtime.ts",
     "src/native-fallback.ts",
     "src/payload-rewrite.ts",