@nijaru/pi-provider-compaction 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-provider-compaction",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "description": "Provider-native context compaction adapters for Pi",
   "keywords": [
@@ -12,7 +12,6 @@
     "responses"
   ],
   "license": "MIT",
-
   "publishConfig": {
     "access": "public"
   },
@@ -23,33 +22,36 @@
   },
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./dist/index.js"
     ]
   },
   "scripts": {
+    "build": "bun run build.ts",
+    "prepack": "bun run build",
     "test": "bun test",
-    "lint": "oxlint index.ts protocol.ts policy.ts tests/",
+    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts replay.ts tests/",
     "typecheck": "tsc --noEmit",
-    "check": "bun test && oxlint index.ts protocol.ts policy.ts tests/ && tsc --noEmit"
+    "check": "bun test && bun run lint && tsc --noEmit"
   },
   "files": [
+    "dist",
     "index.ts",
     "protocol.ts",
     "policy.ts",
+    "provider.ts",
+    "replay.ts",
     "README.md",
     "LICENSE"
   ],
-  "dependencies": {
-    "@earendil-works/pi-ai": "0.85.1"
-  },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.85.1",
-    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-ai": "0.87.0",
+    "@earendil-works/pi-agent-core": "0.87.0",
+    "@earendil-works/pi-coding-agent": "0.87.0",
     "@types/bun": "latest",
     "oxlint": "^1.81.0",
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.85.1"
+    "@earendil-works/pi-coding-agent": "*"
   }
 }

package/protocol.ts

@@ -1,9 +1,9 @@
 import type {
 	AssistantMessageEventStream,
-	Context,
 	Model,
 	Provider,
 	ProviderHeaders,
+	TranscriptContext,
 	Usage,
 } from "@earendil-works/pi-ai";
 
@@ -46,13 +46,37 @@ function validateItemSize(item: ResponseItem): void {
 	if (byteLength(item) > MAX_ITEM_BYTES) throw new Error("Native compaction output item exceeded 2 MiB");
 }
 
+function validContent(value: unknown): boolean {
+	return typeof value === "string" || (Array.isArray(value) && value.every((part) => {
+		if (!isObject(part)) return false;
+		if (part.type === "input_text" || part.type === "output_text" || part.type === "summary_text") return typeof part.text === "string";
+		if (part.type === "input_image") return typeof part.image_url === "string" || typeof part.file_id === "string";
+		if (part.type === "refusal") return typeof part.refusal === "string";
+		return false;
+	}));
+}
+
 export function validateCompactedOutput(value: unknown): ResponseItem[] {
 	if (!isObject(value) || !Array.isArray(value.output) || value.output.length === 0) {
 		throw new Error("Responses Compact returned an invalid output window");
 	}
+	if (byteLength(value.output) > MAX_RESPONSE_BYTES) throw new Error("Native compaction output exceeded 8 MiB");
 	const output = value.output.map((item) => {
 		if (!isObject(item)) throw new Error("Responses Compact returned a non-object output item");
 		validateItemSize(item);
+		const type = item.type ?? (typeof item.role === "string" ? "message" : undefined);
+		if (!["compaction", "message", "reasoning", "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output", "tool_search_call", "tool_search_output", "additional_tools"].includes(String(type))) throw new Error("Responses Compact returned an unsupported output item");
+		if (type === "message" && (!["user", "assistant", "system", "developer"].includes(String(item.role)) || !validContent(item.content))) throw new Error("Responses Compact returned an invalid message item");
+		if (type === "compaction" && !isCompactionItem(item)) throw new Error("Responses Compact returned an invalid checkpoint");
+		if (type === "reasoning" && !(typeof item.encrypted_content === "string" || (Array.isArray(item.summary) && validContent(item.summary)))) throw new Error("Responses Compact returned invalid reasoning");
+		if (String(type).includes("call") || type === "tool_search_output") {
+			if (typeof item.call_id !== "string" || !item.call_id) throw new Error("Responses Compact returned an invalid tool id");
+			if (type === "function_call" && (typeof item.name !== "string" || typeof item.arguments !== "string")) throw new Error("Responses Compact returned an invalid function call");
+			if (type === "custom_tool_call" && (typeof item.name !== "string" || typeof item.input !== "string")) throw new Error("Responses Compact returned an invalid custom call");
+			if ((type === "function_call_output" || type === "custom_tool_call_output") && !validContent(item.output)) throw new Error("Responses Compact returned an invalid tool output");
+			if (type === "tool_search_call" && !isObject(item.arguments)) throw new Error("Responses Compact returned an invalid tool search");
+		}
+		if ((type === "additional_tools" || type === "tool_search_output") && (!Array.isArray(item.tools) || !item.tools.every(isObject))) throw new Error("Responses Compact returned invalid tools");
 		return structuredClone(item);
 	});
 	const checkpoints = output.filter(isCompactionItem);
@@ -85,6 +109,7 @@ async function readJsonBounded(response: Response, signal: AbortSignal): Promise
 		}
 	} finally {
 		signal.removeEventListener("abort", onAbort);
+		void reader.cancel().catch(() => undefined);
 		reader.releaseLock();
 	}
 	const bytes = new Uint8Array(total);
@@ -193,8 +218,10 @@ async function collectProviderUsage(stream: AssistantMessageEventStream, signal:
 interface TransportRequest {
 	provider: Provider;
 	model: Model<any>;
-	context: Context;
+	context: TranscriptContext;
 	input: ResponseItem[];
+	/** Fully prepared request snapshot; only its validated prefix is sent. */
+	preparedPayload?: JsonObject;
 	apiKey?: string;
 	headers?: ProviderHeaders;
 	env?: Record<string, string>;
@@ -251,7 +278,8 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 		fetch: bridgeFetch,
 		onPayload: (payload: unknown) => {
 			if (!isObject(payload)) throw new Error("Responses provider exposed a non-object payload");
-			preparedPayload = { ...structuredClone(payload), input: structuredClone(request.input) };
+			if (request.preparedPayload && request.preparedPayload.model !== payload.model) throw new Error("Native route model changed since capture");
+			preparedPayload = { ...structuredClone(request.preparedPayload ?? payload), input: structuredClone(request.input) };
 			return preparedPayload;
 		},
 	});
@@ -325,6 +353,7 @@ async function collectCompactionSse(stream: ReadableStream<Uint8Array>, signal:
 		dispatch();
 	} finally {
 		signal.removeEventListener("abort", onAbort);
+		void reader.cancel().catch(() => undefined);
 		reader.releaseLock();
 	}
 	if (!completed) throw new Error("Remote V2 stream ended without response.completed");
@@ -359,12 +388,16 @@ function buildRemoteV2History(input: ResponseItem[], item: ResponseItem): Respon
 async function requestRemoteV2(request: TransportRequest): Promise<TransportResponse> {
 	const baseFetch = request.fetch ?? globalThis.fetch;
 	let sentInput: ResponseItem[] | undefined;
-	const inspections: Promise<CollectedSse>[] = [];
+	const controller = new AbortController();
+	const signal = AbortSignal.any([request.signal, controller.signal]);
+	const inspections: Promise<{ result: CollectedSse } | { error: unknown }>[] = [];
 	const inspectedFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
 		const response = await baseFetch(input, init);
 		if (!response.ok || !response.body) return response;
 		const [providerBody, inspectionBody] = response.body.tee();
-		inspections.push(collectCompactionSse(inspectionBody, request.signal));
+		// Attach the rejection handler immediately: inspection can fail before the
+		// provider finishes consuming its half of the stream.
+		inspections.push(collectCompactionSse(inspectionBody, signal).then((result) => ({ result }), (error: unknown) => ({ error })));
 		return new Response(providerBody, {
 			status: response.status,
 			statusText: response.statusText,
@@ -384,19 +417,24 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 		onPayload: (payload: unknown) => {
 			if (!isObject(payload)) throw new Error("Codex provider exposed a non-object payload");
 			sentInput = structuredClone(request.input);
-			return { ...structuredClone(payload), input: [...sentInput, { type: "compaction_trigger" }] };
+			if (request.preparedPayload && request.preparedPayload.model !== payload.model) throw new Error("Native route model changed since capture");
+			return { ...structuredClone(request.preparedPayload ?? payload), stream: true, input: [...sentInput, { type: "compaction_trigger" }] };
 		},
 	});
-	const usage = await collectProviderUsage(stream, request.signal);
-	if (!sentInput || inspections.length !== 1) {
-		throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+	try {
+		const usage = await collectProviderUsage(stream, request.signal);
+		if (!sentInput || inspections.length !== 1) throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+		const inspection = await inspections[0]!;
+		if ("error" in inspection) throw inspection.error;
+		return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
+	} finally {
+		controller.abort();
 	}
-	const inspection = await inspections[0];
-	return { output: buildRemoteV2History(sentInput, inspection.item), usage };
 }
 
 export async function requestProviderCompaction(
 	request: TransportRequest & { protocol: NativeProtocol },
 ): Promise<TransportResponse> {
-	return request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request);
+	const result = await (request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request));
+	return { ...result, output: validateCompactedOutput(result) };
 }

package/provider.ts

@@ -0,0 +1,85 @@
+import type { Provider, StreamOptions, Model, TranscriptContext } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type ObserveRequest = (model: Model<any>, context: TranscriptContext, options: StreamOptions) => ((payload: unknown) => unknown | Promise<unknown>) | undefined;
+
+function optionsWithObserver<T extends StreamOptions>(model: Model<any>, context: TranscriptContext, options: T | undefined, observe: ObserveRequest): T | undefined {
+	const handler = observe(model, context, options ?? {});
+	if (!handler) return options;
+	return {
+		...options,
+		onPayload: async (payload: unknown, requestModel: Model<any>) => {
+			const replacement = await options?.onPayload?.(payload, requestModel);
+			const prepared = replacement === undefined ? payload : replacement;
+			// Observation failures must not suppress or alter the portable request.
+			try { return await handler(prepared); } catch { return prepared; }
+		},
+	} as T;
+}
+
+/** Preserve method receivers, getters, optional members and dynamic catalogs. */
+export function decorateProvider(base: Provider, observe: ObserveRequest): Provider {
+	const stream: Provider["stream"] = (model, context, options) => base.stream(model, context, optionsWithObserver(model, context, options, observe));
+	const streamSimple: Provider["streamSimple"] = (model, context, options) => base.streamSimple(model, context, optionsWithObserver(model, context, options, observe));
+	const bound = new Map<PropertyKey, unknown>();
+	return new Proxy(base, {
+		get(target, key) {
+			if (key === "stream") return stream;
+			if (key === "streamSimple") return streamSimple;
+			const value = Reflect.get(target, key, target);
+			if (typeof value !== "function") return value;
+			if (!bound.has(key)) bound.set(key, value.bind(target));
+			return bound.get(key);
+		},
+	});
+}
+
+/**
+	* Pi 0.87 has replacement registration, not middleware. Native BASE providers can
+	* be decorated directly. Legacy stream overlays retain their configuration and
+	* delegate their original callback (including /fast). Never register an effective
+	* composed provider as a native base: that loses model headers and freezes config.
+	*/
+export function installObserver(pi: ExtensionAPI, ctx: ExtensionContext, observe: ObserveRequest): (() => void) | undefined {
+	const model = ctx.model;
+	if (!model) return;
+	const registry = ctx.modelRegistry;
+	const id = model.provider;
+	const native = registry.getRegisteredNativeProvider(id);
+	if (native) {
+		const guarded: ObserveRequest = (...args) => {
+			const handler = observe(...args);
+			return handler ? (payload) => registry.getRegisteredNativeProvider(id) === wrapper ? handler(payload) : payload : undefined;
+		};
+		const wrapper = decorateProvider(native, guarded);
+		pi.registerProvider(wrapper);
+		return () => {
+			if (registry.getRegisteredNativeProvider(id) === wrapper) pi.registerProvider(native);
+		};
+	}
+	const original = registry.getRegisteredProviderConfig(id);
+	// Refresh callbacks own mutable catalog state inside the composer. Replacing
+	// that composer cannot promise preservation, so leave it alone.
+	if (!original?.streamSimple || original.refreshModels || original.oauth?.modifyModels) return;
+	if (original.api !== model.api) return;
+	// An injected legacy streamSimple overlay would also intercept full stream()
+	// calls and change reasoning semantics. Only decorate an existing stream owner.
+	const delegate = original.streamSimple.bind(original);
+	const guarded: ObserveRequest = (...args) => {
+		const handler = observe(...args);
+		return handler ? (payload) => registry.getRegisteredProviderConfig(id)?.streamSimple === wrapper ? handler(payload) : payload : undefined;
+	};
+	const wrapper: Provider["streamSimple"] = (requestModel, context, options) => delegate(requestModel, context, optionsWithObserver(requestModel, context, options, guarded));
+	pi.registerProvider(id, { ...original, api: original?.api ?? model.api, streamSimple: wrapper });
+	return () => {
+		const current = registry.getRegisteredProviderConfig(id);
+		if (current?.streamSimple !== wrapper || registry.getRegisteredNativeProvider(id)) return;
+		// registerProvider merges undefined properties: remove our layer before restore.
+		const restored = { ...current };
+		if (original?.streamSimple) restored.streamSimple = original.streamSimple;
+		else delete restored.streamSimple;
+		if (!original?.api && restored.api === model.api) delete restored.api;
+		pi.unregisterProvider(id);
+		if (Object.keys(restored).length) pi.registerProvider(id, restored);
+	};
+}

package/replay.ts

@@ -0,0 +1,140 @@
+import type { Model, TranscriptContext } from "@earendil-works/pi-ai";
+import { getCurrentSystemPrompt, getCurrentTools, getDeclaredTools, normalizeContext, resolveTranscript } from "@earendil-works/pi-ai";
+import { createGrammarToolInputProperties } from "@earendil-works/pi-ai/api/constrained-sampling";
+import { convertResponsesMessages } from "@earendil-works/pi-ai/api/openai-responses-shared";
+import { isObject, type JsonObject, type ResponseItem } from "./protocol";
+
+const TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+export const MAX_SNAPSHOT_BYTES = 8 * 1024 * 1024;
+export const SNAPSHOT_TTL_MS = 5 * 60_000;
+
+export function equal(left: unknown, right: unknown): boolean {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+
+/** Validator only. No serialized item from this function is transmitted. */
+export function serializeInput(model: Model<any>, context: TranscriptContext, declarations = context): ResponseItem[] {
+	const compat = model.compat as Record<string, unknown> | undefined;
+	const flag = (name: string) => compat?.[name] === true;
+	const codex = model.api === "openai-codex-responses";
+	const normalized = resolveTranscript(context, flag("supportsMidConvoSystemMessages"));
+	const tools = resolveTranscript(declarations, flag("supportsMidConvoSystemMessages"));
+	return convertResponsesMessages(model, normalized, model.api === "azure-openai-responses" ? new Set([...TOOL_CALL_PROVIDERS, "azure-openai-responses"]) : TOOL_CALL_PROVIDERS, {
+		includeSystemPrompt: !codex,
+		grammarToolInputProperties: createGrammarToolInputProperties(getDeclaredTools(tools.messages), flag("supportsOpenAIGrammarTools")),
+		supportsMidConvoSystemMessages: flag("supportsMidConvoSystemMessages"),
+		supportsAdditionalTools: flag("supportsAdditionalTools"),
+		supportsToolSearch: flag("supportsToolSearch"),
+		toolOptions: {
+			...(codex ? { strict: null } : {}),
+			supportsStrictMode: (compat?.supportsStrictMode as boolean | undefined) ?? model.api !== "openai-responses",
+			supportsOpenAIGrammarTools: flag("supportsOpenAIGrammarTools"),
+		},
+	}) as unknown as ResponseItem[];
+}
+
+export interface PreparedRequest {
+	context: TranscriptContext;
+	canonical: TranscriptContext;
+	payload: JsonObject & { input: ResponseItem[] };
+	/** The portable wire input before our sole summary substitution. */
+	portableInput: ResponseItem[];
+	replacement?: { index: number; count: number };
+	createdAt: number;
+}
+
+export function capturePreparedRequest(
+	model: Model<any>, context: TranscriptContext, canonical: TranscriptContext, payload: unknown,
+	reject: (reason: string) => void = () => {},
+): PreparedRequest | undefined {
+	if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject)) { reject("unsupported payload shape"); return; }
+	// Reject stateful provider requests: coverage must be the complete visible input.
+	if (payload.previous_response_id || payload.conversation) { reject("stateful request"); return; }
+	if (Buffer.byteLength(JSON.stringify({ context, payload })) > MAX_SNAPSHOT_BYTES) { reject("snapshot exceeds size limit"); return; }
+	const expected = serializeInput(model, context);
+	if (!equal(expected, payload.input)) { reject("prepared input differs from serializer"); return; }
+	return { context: structuredClone(context), canonical: structuredClone(canonical), payload: structuredClone(payload) as PreparedRequest["payload"], portableInput: expected, createdAt: Date.now() };
+}
+
+function promptCount(input: readonly ResponseItem[]): number {
+	let count = 0;
+	while (input[count]?.role === "system" || input[count]?.role === "developer") count++;
+	return count;
+}
+
+/** No open/synthetic tool exchange may cross the coverage boundary. */
+function closedTools(context: TranscriptContext): boolean {
+	const pending = new Set<string>();
+	for (const message of context.messages) {
+		if (message.role === "assistant") {
+			if (message.stopReason === "error" || message.stopReason === "aborted") return false;
+			for (const block of message.content) if (block.type === "toolCall") {
+				if (pending.has(block.id)) return false;
+				pending.add(block.id);
+			}
+		} else if (message.role === "toolResult") {
+			if (!pending.delete(message.toolCallId)) return false;
+		}
+	}
+	return pending.size === 0;
+}
+
+/** Only the head may differ (forced/request-only prompt); conversation mapping is exact. */
+function mappedPrefix(snapshot: PreparedRequest, prefix: TranscriptContext): TranscriptContext | undefined {
+	if (!equal(snapshot.canonical.messages.slice(0, prefix.messages.length), prefix.messages)) return;
+	const head = prefix.messages[0]?.role === "system" ? 1 : 0;
+	if (head && snapshot.context.messages[0]?.role !== "system") return;
+	if (!equal(snapshot.context.messages.slice(head, prefix.messages.length), prefix.messages.slice(head))) return;
+	return normalizeContext({ messages: snapshot.context.messages.slice(0, prefix.messages.length) });
+}
+
+export function selectCoveredPrefix(model: Model<any>, snapshot: PreparedRequest, prefix: TranscriptContext, reject: (reason: string) => void = () => {}): ResponseItem[] | undefined {
+	if (Date.now() - snapshot.createdAt > SNAPSHOT_TTL_MS) { reject("snapshot expired"); return; }
+	if (!closedTools(prefix)) { reject("prefix has an incomplete tool exchange or failed assistant"); return; }
+	const mapped = mappedPrefix(snapshot, prefix);
+	if (!mapped) { reject("projected prefix differs from request context"); return; }
+	const expected = serializeInput(model, mapped, snapshot.context);
+	if (!equal(snapshot.portableInput.slice(0, expected.length), expected)) { reject("serialized prefix does not match prepared input"); return; }
+	const start = promptCount(expected);
+	let end = expected.length;
+	if (snapshot.replacement) {
+		if (snapshot.replacement.index < start || snapshot.replacement.index >= end) { reject("previous native slot is outside covered prefix"); return; }
+		end += snapshot.replacement.count - 1;
+	}
+	if (end <= start) { reject("empty covered prefix"); return; }
+	// Source is the prepared request, never the validator's reconstruction.
+	return structuredClone(snapshot.payload.input.slice(start, end));
+}
+
+/** Exact positional replacement, not a subsequence search or a suffix rebuild. */
+export function substituteSummary(
+	payload: unknown, index: number, summary: ResponseItem, output: ResponseItem[],
+): (JsonObject & { input: ResponseItem[] }) | undefined {
+	if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject)) return;
+	if (!equal(payload.input[index], summary)) return;
+	if (payload.input.filter((item) => equal(item, summary)).length !== 1) return;
+	return { ...payload, input: [...payload.input.slice(0, index), ...structuredClone(output), ...payload.input.slice(index + 1)] };
+}
+
+/** Pin the one portable-summary slot using the canonical prefix, not text search. */
+export function summarySlot(model: Model<any>, snapshot: PreparedRequest, summaryPrefix: TranscriptContext): number | undefined {
+	const mapped = mappedPrefix(snapshot, summaryPrefix);
+	if (!mapped) return;
+	const prefix = serializeInput(model, mapped, snapshot.context);
+	const index = promptCount(prefix);
+	if (prefix.length !== index + 1 || !equal(snapshot.portableInput.slice(0, prefix.length), prefix)) return;
+	return index;
+}
+
+/** Changes to prompt, tools or model compatibility revoke opaque state. */
+export function requestPolicy(model: Model<any>, snapshot: PreparedRequest): unknown {
+	return {
+		model,
+		system: getCurrentSystemPrompt(snapshot.context.messages),
+		currentTools: getCurrentTools(snapshot.context.messages),
+		declarations: getDeclaredTools(resolveTranscript(snapshot.context, (model.compat as { supportsMidConvoSystemMessages?: boolean } | undefined)?.supportsMidConvoSystemMessages).messages),
+		instructions: snapshot.payload.instructions,
+		tools: snapshot.payload.tools,
+		prompt: snapshot.portableInput.slice(0, promptCount(snapshot.portableInput)),
+	};
+}