@nijaru/pi-provider-compaction 0.0.9 → 0.0.11

package/index.ts

@@ -4,7 +4,8 @@ import { normalizeContext, registerSessionResourceCleanup, type Model, type Prov
 import { compact, convertToLlm, type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { resolveCompactionModelPolicy } from "./policy";
 import { cacheConfig, cachedSummary, captureCachedRequest, finishCachedRequest, requestCacheState, sameCachedPrompt, supportsCachedSummary, withFileTracking, type CachedRequest } from "./cached-summary";
-import { installObserver, type InstalledObserver, type ObserveRequest } from "./provider";
+import { bindUsageHeaders, installObserver, type InstalledObserver, type ObserveRequest } from "./provider";
+import { serveUsageObservers } from "./usage-observer";
 import { capturePreparedRequest, equal, requestPolicy, selectCoveredPrefix, substituteSummary, summarySlot, type PreparedRequest } from "./replay";
 import { isObject, NativeCompactionValidationError, requestProviderCompaction, resolveNativeProtocol, supportsResponsesApi, validateCompactedOutput, type NativeProtocol, type ResponseItem } from "./protocol";
 
@@ -161,9 +162,10 @@ export default function (pi: ExtensionAPI): void {
 	const routeDigest = (value: unknown) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
 	let runtimeId = randomUUID();
 	let ctx: ExtensionContext | undefined;
+	let usageObservers = serveUsageObservers(pi, () => ctx);
 	let snapshot: Captured | undefined;
 	let cache: CachedRequest | undefined;
-	let summarizing = false;
+	let compactionRequest = false;
 	let expiryAttempt: ExpiryAttempt | undefined;
 	let lastOutcome: { path: string; elapsedMs: number; usage?: Usage; reason?: string } | undefined;
 	let active: Active | undefined;
@@ -172,22 +174,11 @@ export default function (pi: ExtensionAPI): void {
 	let unregisterCleanup: (() => void) | undefined;
 	let generation = 0;
 	let requestSequence = 0;
-	let captureStatus = "no request observed";
-	let compactionStatus = "not attempted in this runtime";
 	let fallbackReason: string | undefined;
-	const captureRejected = (reason: string) => { captureStatus = reason; };
-	const fallback = (reason: string) => { fallbackReason = reason; compactionStatus = `portable: ${reason}`; };
-	pi.registerCommand("provider-compaction-status", {
-		description: "Show cache/native eligibility and measured compaction usage",
-		handler: async (_args, context) => {
-			const state = cacheState(context);
-			const remaining = state.expiresAt === undefined ? "unknown lifetime" : `estimated ${Math.max(0, Math.ceil((state.expiresAt - Date.now()) / 1000))}s remaining (model declaration; best effort)`;
-			const usage = lastOutcome?.usage;
-			context.ui.notify(`Provider compaction\nObserver: ${observer?.isInstalled() ? "installed" : "unavailable for current registration"}\nCapture: ${captureStatus}\nCache: ${state.reason}; ${remaining}\nLast attempt: ${compactionStatus}${lastOutcome ? `\nOutcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usage.input}, cache read ${usage.cacheRead}, write ${usage.cacheWrite}, output ${usage.output}; catalog cost $${usage.cost.total.toFixed(6)}` : "; usage unavailable"}${lastOutcome.reason ? `; ${lastOutcome.reason}` : ""}` : ""}`, "info");
-		},
-	});
-	const invalidate = () => { generation++; runtimeId = randomUUID(); snapshot = undefined; cache = undefined; active = undefined; pending = undefined; expiryAttempt = undefined; captureStatus = "invalidated by lifecycle/history/policy change"; };
+	const fallback = (reason: string) => { fallbackReason = reason; };
+	const invalidate = () => { generation++; runtimeId = randomUUID(); snapshot = undefined; cache = undefined; active = undefined; pending = undefined; expiryAttempt = undefined; };
 	const retire = () => {
+		usageObservers.clear();
 		invalidate();
 		const installed = observer;
 		observer = undefined; ctx = undefined;
@@ -195,6 +186,12 @@ export default function (pi: ExtensionAPI): void {
 		installed?.remove();
 		lastOutcome = undefined;
 	};
+	pi.on("before_provider_headers", (event, context) => {
+		bindUsageHeaders(event.headers, context.sessionManager.getSessionId());
+		// Lazy API loading or catalog refresh can recompose effective providers
+		// between auxiliary calls that have no before_agent_start boundary.
+		usageObservers.ready(context);
+	});
 	const generic = (context: ExtensionContext) => resolveCompactionModelPolicy(pi, context).hasSelectors;
 	const route = (model: Model<any>, options: ProviderStreamOptions | SimpleStreamOptions) => routeDigest({ model, apiKey: options.apiKey, headers: options.headers, env: options.env });
 	const unchanged = (branch: readonly SessionEntry[], length: number, hash: string) => branch.length >= length && digest(branch.slice(0, length)) === hash && !branch.slice(length).some((entry) => entry.type === "context_edit");
@@ -250,18 +247,12 @@ export default function (pi: ExtensionAPI): void {
 			return;
 		}
 		if (options.sessionId !== manager.getSessionId()) return;
-		if (summarizing) return;
-		if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) { captureRejected("unsupported API"); return; }
-		if (!options.onPayload) {
-			// The portable-summary request re-enters this observer without a payload
-			// callback. Do not overwrite the main request's capture diagnostic.
-			if (captureStatus !== "eligible prepared request captured") captureRejected("no payload callback");
-			return;
-		}
-		if (generic(owner)) { captureRejected("generic compaction model takes precedence"); return; }
+		if (compactionRequest) return;
+		if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) return;
+		if (!options.onPayload || generic(owner)) return;
 		// The Azure adapter also accepts API-specific overrides and process-env
 		// fallbacks. Those must not silently select a route absent from our evidence.
-		if (!supportedRouteOptions(model, options)) { captureRejected("unsupported route overrides"); return; }
+		if (!supportedRouteOptions(model, options)) return;
 		const ticket = generation;
 		const startedAt = Date.now();
 		const sequence = ++requestSequence;
@@ -287,11 +278,10 @@ export default function (pi: ExtensionAPI): void {
 			const normalizedHeaders = (headers: ProviderHeaders | undefined) => Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([a], [b]) => String(a).localeCompare(String(b)));
 			if (!auth.ok || generic(owner) || auth.apiKey !== options.apiKey || (auth.baseUrl ?? model.baseUrl) !== model.baseUrl || !equal(normalizedHeaders(auth.headers), normalizedHeaders(options.headers)) || !equal(auth.env ?? {}, options.env ?? {})) {
 				active = undefined; cache = undefined;
-				captureRejected("resolved auth/route differs from prepared request, or generic policy changed");
 				return payload;
 			}
 			const provider = owner.modelRegistry.getProvider(model.provider);
-			if (!provider) { captureRejected("provider unavailable"); return payload; }
+			if (!provider) return payload;
 			const routeHash = route(model, options);
 			if (config.cachedSummaries && supportsCachedSummary(model)) {
 				const warming = options.maxTokens === 1 && cache && cache.authHash === routeDigest(auth) && sameCachedPrompt(cache.payload, payload) && equal(cache.context, context);
@@ -301,8 +291,8 @@ export default function (pi: ExtensionAPI): void {
 				}, payload);
 				if (!warming) cache = undefined;
 			}
-			if (!supportsNativeCompaction(model)) { captureStatus = candidate ? "eligible cached request captured" : "cached request ineligible"; return payload; }
-			const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
+			if (!supportsNativeCompaction(model)) return payload;
+			const prepared = capturePreparedRequest(model, context, canonical, payload);
 			if (!prepared) { active = undefined; return payload; }
 			const policyHash = digest(requestPolicy(model, prepared));
 			const latest = latestCompaction(branch);
@@ -325,7 +315,6 @@ export default function (pi: ExtensionAPI): void {
 					} else active = undefined;
 				} else active = undefined;
 			} else active = undefined;
-			captureStatus = "eligible prepared request captured";
 			snapshot = {
 				prepared, model: structuredClone(model), provider,
 				options: { apiKey: options.apiKey, headers: structuredClone(options.headers), env: structuredClone(options.env), fetch: options.fetch, ...(typeof (options as { serviceTier?: unknown }).serviceTier === "string" ? { serviceTier: (options as { serviceTier: string }).serviceTier } : {}) },
@@ -346,42 +335,51 @@ export default function (pi: ExtensionAPI): void {
 
 	const install = (context: ExtensionContext) => {
 		ctx = context;
-		if (observer?.provider === context.model?.provider && observer?.isInstalled()) return;
+		if (observer?.provider === context.model?.provider && observer?.api === context.model?.api && observer?.isInstalled()) return;
 		if (observer) { invalidate(); observer.remove(); observer = undefined; }
 		if (!supportsNativeCompaction(context.model) && !supportsCachedSummary(context.model)) return;
 		observer = installObserver(pi, context, observe);
-		captureStatus = observer ? "awaiting prepared request" : "unsupported provider registration";
 	};
 	pi.on("session_start", (_event, context) => {
-		retire(); install(context);
+		retire();
+		usageObservers.dispose();
+		usageObservers = serveUsageObservers(pi, () => ctx);
+		install(context);
+		usageObservers.ready(context);
 		const sessionId = context.sessionManager.getSessionId();
 		// AgentSession.dispose() cleans session resources even without emitting
 		// session_shutdown. The captured registry keeps owned cleanup usable.
 		unregisterCleanup = registerSessionResourceCleanup((disposedId) => {
-			if (disposedId === undefined || disposedId === sessionId) retire();
+			if (disposedId === undefined || disposedId === sessionId) { retire(); usageObservers.dispose(); }
 		});
 		const latest = latestCompaction(context.sessionManager.getBranch());
 		if (latest?.summary === NATIVE_COMPACTION_SUMMARY) context.ui.notify("Legacy native compaction has no portable summary. Native replay is disabled; recover from earlier history or start a new session.", "warning");
 	});
-	pi.on("before_agent_start", (_event, context) => { install(context); });
-	pi.on("model_select", (_event, context) => { invalidate(); install(context); });
+	pi.on("before_agent_start", (_event, context) => { install(context); usageObservers.ready(context); });
+	pi.on("model_select", (_event, context) => { invalidate(); install(context); usageObservers.ready(context); });
 	pi.on("session_tree", () => { invalidate(); });
-	pi.on("session_shutdown", retire);
+	pi.on("session_shutdown", () => { retire(); usageObservers.dispose(); });
 	// Privacy-policy owners must invalidate before changing a policy that can affect
 	// hidden covered history. Arbitrary dynamic privacy compositions are unsupported.
 	const removeInvalidation = pi.events.on("pi-provider-compaction:invalidate", invalidate);
 	pi.on("session_shutdown", () => { if (typeof removeInvalidation === "function") removeInvalidation(); });
 
 	pi.on("session_before_compact", async (event, context) => {
-		const began = Date.now();
-		compactionStatus = "preparing compaction";
+		const began = Date.now(), ticket = generation;
+		const sessionId = context.sessionManager.getSessionId();
 		fallbackReason = undefined;
 		const attempt = expiryAttempt;
 		const capture = snapshot;
 		const cached = cacheState(context).available ? cache : undefined;
 		snapshot = undefined; cache = undefined; pending = undefined;
 		const cancelled = (usage?: Usage, reason = "compaction ownership or input changed") => {
-			lastOutcome = { path: attempt ? "expiry cancelled" : "cancelled", elapsedMs: Date.now() - began, usage, reason };
+			// A cancelled attempt has no checkpoint to carry its known bill. Retain
+			// that usage in the existing session diagnostic, not a command-only cache.
+			if (usage && ticket === generation && ctx) {
+				try {
+					if (ctx.sessionManager.getSessionId() === sessionId) pi.appendEntry("pi-provider-compaction:diagnostic", { status: `${attempt ? "expiry cancelled" : "cancelled"}: ${reason}`, usage });
+				} catch { /* A disposed session cannot accept a diagnostic. */ }
+			}
 			return { cancel: true as const };
 		};
 		const reject = (reason: string) => {
@@ -395,7 +393,6 @@ export default function (pi: ExtensionAPI): void {
 			attempt.signal = event.signal;
 		}
 		if ((!capture && !cached) || !context.model || generic(context) || event.signal.aborted) return reject("no eligible snapshot, explicit model override, or aborted attempt");
-		const ticket = generation;
 		const branch = context.sessionManager.getBranch();
 		const branchHash = digest(branch);
 		const source = cached ?? capture!;
@@ -418,22 +415,20 @@ export default function (pi: ExtensionAPI): void {
 		let summaryPath = "standard";
 		let summaryReason: string | undefined;
 		if (cached) {
-			compactionStatus = "generating cached portable summary";
-			summarizing = true;
+			compactionRequest = true;
 			try {
 				const result = await cachedSummary(cached, context, event.preparation, event.customInstructions, event.signal, current);
 				portable = result.result;
 				attemptedUsage = result.usage;
 				summaryReason = result.reason;
 				if (portable) summaryPath = "cached";
-			} finally { summarizing = false; }
+			} finally { compactionRequest = false; }
 			if (!current()) return cancelled(attemptedUsage);
 		}
 		if (!portable) {
 			if (attempt) return cancelled(attemptedUsage, summaryReason ?? "warm cache unavailable");
 			// Without native coverage or a dispatched cached attempt, Pi can own fallback.
 			if (!input && !attemptedUsage) return reject(summaryReason ?? fallbackReason ?? "native coverage unavailable");
-			compactionStatus = "generating portable summary";
 			try {
 				portable = await compact(event.preparation, source.model, auth.apiKey, auth.headers as Record<string, string> | undefined, event.customInstructions, event.signal, context.thinkingLevel, source.provider.streamSimple.bind(source.provider), auth.env, undefined, undefined, source.sessionId);
 				portable = withFileTracking(portable, event.preparation);
@@ -450,25 +445,33 @@ export default function (pi: ExtensionAPI): void {
 			return { compaction: result! };
 		};
 		if (!capture || !protocol || !input) {
-			compactionStatus = `${summaryPath} portable summary prepared`;
 			return outcome(summaryPath, portable, summaryReason);
 		}
 		try {
 			const freshAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
 			if (!current()) return cancelled(portable.usage);
 			if (!freshAuth.ok || routeDigest(freshAuth) !== capture.authHash) { fallback("auth changed after portable generation"); return outcome(summaryPath, portable, "native auth changed"); }
-			compactionStatus = "requesting native checkpoint";
-			const native = await requestProviderCompaction({
-				provider: capture.provider, model: capture.model, context: capture.prepared.context,
-				input, preparedPayload: capture.prepared.payload, protocol,
-				apiKey: capture.options.apiKey, headers: capture.options.headers, env: capture.options.env,
-				signal: event.signal, isCurrent: current, fetch: capture.options.fetch,
-				...(capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }),
-			});
+			let native: Awaited<ReturnType<typeof requestProviderCompaction>>;
+			compactionRequest = true;
+			try {
+				native = await requestProviderCompaction({
+					provider: capture.provider, model: capture.model, context: capture.prepared.context,
+					input, preparedPayload: capture.prepared.payload, protocol,
+					apiKey: capture.options.apiKey, headers: capture.options.headers, env: capture.options.env,
+					signal: event.signal, isCurrent: current, fetch: capture.options.fetch, sessionId: source.sessionId,
+					...(capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }),
+				});
+			} finally { compactionRequest = false; }
 			if (!current()) return cancelled(combineUsage(native.usage, portable.usage));
 			const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
 			if (!current()) return cancelled(combineUsage(native.usage, portable.usage));
-			if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) { fallback("auth changed after native generation"); return outcome(summaryPath, portable, "native auth changed"); }
+			if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) {
+				// The checkpoint is no longer safe to commit, but both requests
+				// completed and their known usage still belongs in the session.
+				portable.usage = combineUsage(native.usage, portable.usage);
+				fallback("auth changed after native generation");
+				return outcome(summaryPath, portable, "native auth changed");
+			}
 			const details: NativeCompactionDetails = {
 				...(isObject(portable.details) ? portable.details : {}),
 				type: NATIVE_COMPACTION_TYPE, version: 3, provider: capture.model.provider, api: capture.model.api, model: capture.model.id,
@@ -489,13 +492,10 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("session_compact", (event, context) => {
 		const recorded = isObject(event.compactionEntry.details) ? event.compactionEntry.details.providerCompaction : undefined;
 		const owned = isObject(recorded) && equal(recorded, lastOutcome);
-		if (readNativeCompactionDetails(event.compactionEntry.details)?.version === 3) compactionStatus = "native checkpoint committed";
-		else if (fallbackReason) compactionStatus = `portable: ${fallbackReason}`;
-		else if (owned) compactionStatus = `${lastOutcome!.path} portable summary committed`;
-		else fallback("another handler supplied the committed result");
+		if (!owned && !fallbackReason && readNativeCompactionDetails(event.compactionEntry.details)?.version !== 3) fallback("another handler supplied the committed result");
 		if (owned) {
-			if (configuration().outcomeNotifications && lastOutcome) context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; catalog cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
-		} else lastOutcome = { path: "Pi/other handler", elapsedMs: 0, usage: event.compactionEntry.usage, reason: compactionStatus };
+			if (configuration().outcomeNotifications && lastOutcome) context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; estimated cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
+		}
 		// Only static diagnostics are persisted, never request/auth data or error text.
 		if (fallbackReason) pi.appendEntry("pi-provider-compaction:diagnostic", { status: `portable: ${fallbackReason}` });
 		active = undefined; snapshot = undefined; cache = undefined;
@@ -515,5 +515,5 @@ export default function (pi: ExtensionAPI): void {
 			...(typeof candidate.capture.prepared.payload.model === "string" ? { payloadModel: candidate.capture.prepared.payload.model } : {}),
 		};
 	});
-	pi.on("session_compact_failed", () => { pending = undefined; snapshot = undefined; cache = undefined; compactionStatus = "compaction failed or cancelled"; });
+	pi.on("session_compact_failed", () => { pending = undefined; snapshot = undefined; cache = undefined; });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-provider-compaction",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "type": "module",
   "description": "Provider-native context compaction adapters for Pi",
   "keywords": [
@@ -29,7 +29,7 @@
     "build": "bun run build.ts",
     "prepack": "bun run build",
     "test": "bun test",
-    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts replay.ts cached-summary.ts tests/",
+    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts usage-observer.ts replay.ts cached-summary.ts tests/",
     "typecheck": "tsc --noEmit",
     "check": "bun run build && bun test && bun run lint && tsc --noEmit"
   },
@@ -39,6 +39,7 @@
     "protocol.ts",
     "policy.ts",
     "provider.ts",
+    "usage-observer.ts",
     "replay.ts",
     "cached-summary.ts",
     "README.md",

package/policy.ts

@@ -20,7 +20,6 @@ export const COMPACTION_MODEL_FLAG = "compaction-model";
 const PROJECT_POLICY = "compaction-policy.json";
 const AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
 const MAX_POLICY_BYTES = 64 * 1024;
-const MAX_MODEL_SELECTORS = 8;
 const MAX_SELECTOR_LENGTH = 512;
 
 type PolicyContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted"> & {
@@ -43,21 +42,15 @@ function normalizeSelector(value: unknown): string | undefined {
 	return selector;
 }
 
-function parsePolicySelectors(value: unknown): string[] | undefined {
+function policyHasSelectors(value: unknown): boolean | undefined {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
 	if (!("models" in value) || !Array.isArray(value.models)) return undefined;
-
-	const selectors: string[] = [];
-	for (const model of value.models) {
-		const selector = normalizeSelector(model);
-		if (selector === undefined || selectors.includes(selector)) continue;
-		selectors.push(selector);
-		if (selectors.length === MAX_MODEL_SELECTORS) break;
-	}
-	return selectors;
+	// This extension only decides precedence. The companion owns the actual
+	// selector list, including deduplication and its model-attempt limit.
+	return value.models.some(model => normalizeSelector(model) !== undefined);
 }
 
-function readPolicySelectors(configPath: string): string[] | undefined {
+function readPolicySelection(configPath: string): boolean | undefined {
 	let fd: number | undefined;
 	try {
 		fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
@@ -74,7 +67,7 @@ function readPolicySelectors(configPath: string): string[] | undefined {
 			bytesRead += count;
 		}
 		if (bytesRead > MAX_POLICY_BYTES) return undefined;
-		return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")) as unknown);
+		return policyHasSelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")) as unknown);
 	} catch {
 		// A malformed or unreadable policy must not prevent native compaction.
 		return undefined;
@@ -177,11 +170,11 @@ export function resolveCompactionModelPolicy(
 	candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
 
 	for (const candidate of candidates) {
-		const selectors = readPolicySelectors(candidate.path);
+		const hasSelectors = readPolicySelection(candidate.path);
 		// A readable policy stops the search: an empty models list is an
 		// explicit choice to use no generic compaction model.
-		if (selectors !== undefined) {
-			return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+		if (hasSelectors !== undefined) {
+			return hasSelectors ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
 		}
 	}
 	return { hasSelectors: false };

package/protocol.ts

@@ -208,7 +208,7 @@ async function collectProviderUsage(stream: AssistantMessageEventStream, signal:
 	let usage: Usage | undefined;
 	for await (const event of stream) {
 		if (signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
-		if (event.type === "error") throw new Error(event.error.errorMessage ?? "Native compaction provider request failed");
+		if (event.type === "error") throw new NativeCompactionValidationError("Native compaction provider stream failed", event.error.usage);
 		if (event.type === "done") usage = event.message.usage;
 	}
 	if (!usage) throw new Error("Native compaction provider stream ended without usage");
@@ -227,6 +227,7 @@ interface TransportRequest {
 	env?: Record<string, string>;
 	/** Cost-relevant request option captured with the original request. */
 	serviceTier?: string;
+	sessionId?: string;
 	signal: AbortSignal;
 	/** Revalidate request ownership after asynchronous provider preparation. */
 	isCurrent?: () => boolean;
@@ -252,7 +253,7 @@ export interface TransportResponse {
 
 async function requestResponsesCompact(request: TransportRequest): Promise<TransportResponse> {
 	let preparedPayload: JsonObject | undefined;
-	let compacted: { response: JsonObject; output: ResponseItem[] } | undefined;
+	let compacted: ResponseItem[] | undefined;
 	let bridgeError: unknown;
 	let dispatches = 0;
 	const baseFetch = request.fetch ?? globalThis.fetch;
@@ -274,13 +275,13 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 			});
 			if (!response.ok) return response;
 			const parsed = await readJsonBounded(response, request.signal);
-			try {
-				if (!isObject(parsed)) throw new Error("Responses Compact returned a non-object response");
-				compacted = { response: parsed, output: validateCompactedOutput(parsed) };
-			} catch (error) {
-				throw new NativeCompactionValidationError(error instanceof Error ? error.message : String(error));
-			}
-			return syntheticCompletion(parsed, preparedPayload);
+			if (!isObject(parsed)) throw new Error("Responses Compact returned a non-object response");
+			// Let the SDK normalize and price reported usage even when the returned
+			// checkpoint is invalid. A synthetic HTTP error would discard that bill.
+			const completion = syntheticCompletion(parsed, preparedPayload);
+			try { compacted = validateCompactedOutput(parsed); }
+			catch (error) { bridgeError = new NativeCompactionValidationError(error instanceof Error ? error.message : String(error)); }
+			return completion;
 		} catch (error) {
 			bridgeError = error;
 			return errorResponse(error);
@@ -296,6 +297,7 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
+		sessionId: request.sessionId,
 		fetch: bridgeFetch,
 		onPayload: (payload: unknown) => {
 			assertCurrent(request);
@@ -307,13 +309,13 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 	});
 
 	const usage = await collectProviderUsage(stream, request.signal).catch((error) => {
-		if (bridgeError) throw bridgeError;
+		if (bridgeError) throw new NativeCompactionValidationError("Native compaction transport or validation failed", error instanceof NativeCompactionValidationError ? error.usage : undefined);
 		throw error;
 	});
 	if (bridgeError instanceof NativeCompactionValidationError) throw new NativeCompactionValidationError(bridgeError.message, usage);
 	if (bridgeError) throw bridgeError;
 	if (!compacted || dispatches !== 1) throw new Error("Responses Compact did not complete exactly one request");
-	return { output: compacted.output, usage };
+	return { output: compacted, usage };
 }
 
 interface CollectedSse {
@@ -438,6 +440,7 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
+		sessionId: request.sessionId,
 		fetch: inspectedFetch,
 		onPayload: (payload: unknown) => {
 			assertCurrent(request);
@@ -449,9 +452,9 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 	});
 	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`);
+		if (!sentInput || inspections.length !== 1) throw new NativeCompactionValidationError(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`, usage);
 		const inspection = await inspections[0]!;
-		if ("error" in inspection) throw inspection.error;
+		if ("error" in inspection) throw new NativeCompactionValidationError("Remote V2 checkpoint validation failed", usage);
 		return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
 	} finally {
 		controller.abort();