@iowarp/clio-coder 0.4.2 → 0.4.3

package/src/domains/session/compaction/compact.ts

@@ -10,10 +10,11 @@
  * boundary; this module does not import pi-ai directly.
  */
 
-import { stream } from "../../../engine/ai.js";
+import { streamSimple } from "../../../engine/ai.js";
 import type { EngineModel, Usage } from "../../../engine/types.js";
 import { foldWorkingSet } from "../../context/working-set/fold.js";
 import { recallableRefListing } from "../../context/working-set/recall.js";
+import { extractReasoningTokens } from "../context-accounting.js";
 import type { CompactionUsage, SessionEntry } from "../entries.js";
 import { serializeConversation } from "./branch-summary.js";
 import { findCutPoint } from "./cut-point.js";
@@ -86,6 +87,14 @@ In addition to that carried-forward context, summarize ONLY the active-turn deta
 
 Do NOT answer the user. Do NOT summarize unrelated older history.`;
 
+/** One invoked summary stream, including failed calls that produce no checkpoint. */
+export interface CompactionCallObservation {
+	outcome: "success" | "error" | "aborted";
+	usage: unknown;
+	timestamp: string;
+	durationMs: number;
+}
+
 export interface CompactInput {
 	/** Ordered session entries to compact. The caller reads these from the session domain. */
 	entries: ReadonlyArray<SessionEntry>;
@@ -105,6 +114,8 @@ export interface CompactInput {
 	reserveTokens?: number;
 	/** Override the built-in keep-recent default (DEFAULT_KEEP_RECENT_TOKENS). */
 	keepRecentTokens?: number;
+	/** Accounting observer; called once per invoked stream, including failures. */
+	onCall?: (call: CompactionCallObservation) => void;
 }
 
 export interface CompactResult {
@@ -367,6 +378,24 @@ function addCompactionUsage(total: CompactionUsage | undefined, raw: unknown): C
 	};
 }
 
+/** Keep attributable partial facts if a failed terminal object resets missing fields to zero. */
+function retainReportedUsage(previous: Record<string, unknown>, raw: unknown): Record<string, unknown> {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return previous;
+	const usage = raw as Record<string, unknown>;
+	const known = { ...previous };
+	for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+		const value = numberOrZero(usage[field]);
+		if (value > 0) known[field] = value;
+	}
+	const reasoning = extractReasoningTokens({ ...usage, reasoningTokens: undefined });
+	if (reasoning !== null && reasoning > 0) known.reasoning = reasoning;
+	if (usage.cost && typeof usage.cost === "object" && "total" in usage.cost) {
+		const cost = numberOrZero(usage.cost.total);
+		if (cost > 0) known.cost = { total: cost };
+	}
+	return known;
+}
+
 async function runSummaryStream(
 	input: CompactInput,
 	userText: string,
@@ -383,26 +412,47 @@ async function runSummaryStream(
 		messages: [buildUserMessage(userText)],
 	};
 
-	const events = stream(
-		input.model,
-		context as unknown as Parameters<typeof stream>[1],
-		options as unknown as Parameters<typeof stream>[2],
-	);
-
-	let summary = "";
+	const timestamp = new Date().toISOString();
+	const started = performance.now();
 	let usage: unknown;
-	for await (const event of events) {
-		if (event.type === "done") {
-			summary = textFromAssistant(event.message);
-			usage = (event.message as { usage?: unknown }).usage;
-			break;
-		}
-		if (event.type === "error") {
-			const reason = event.error.errorMessage ?? "unknown error";
-			throw new Error(`compaction stream failed: ${reason}`);
+	let reported: Record<string, unknown> = {};
+	let outcome: CompactionCallObservation["outcome"] = "error";
+	try {
+		// Summarization requests thinking off, as its resolver does. Bare stream
+		// infers an active level from model.reasoning and would undo that choice.
+		const events = streamSimple(
+			input.model,
+			context as unknown as Parameters<typeof streamSimple>[1],
+			options as unknown as Parameters<typeof streamSimple>[2],
+		);
+		for await (const event of events) {
+			// Some transports throw after yielding a partial response. Retain the
+			// last reported usage even without a terminal error message.
+			if ("partial" in event) {
+				usage = event.partial.usage ?? usage;
+				reported = retainReportedUsage(reported, usage);
+			}
+			if (event.type === "done") {
+				usage = event.message.usage ?? usage;
+				outcome = "success";
+				return { text: textFromAssistant(event.message).trim(), usage };
+			}
+			if (event.type === "error") {
+				usage = event.error.usage ?? usage;
+				reported = retainReportedUsage(reported, usage);
+				outcome = event.error.stopReason === "aborted" ? "aborted" : "error";
+				throw new Error(`compaction stream failed: ${event.error.errorMessage ?? "unknown error"}`);
+			}
 		}
+		throw new Error("compaction stream ended without a terminal response");
+	} finally {
+		input.onCall?.({
+			outcome: outcome === "error" && input.signal?.aborted ? "aborted" : outcome,
+			usage: outcome === "success" ? usage : reported,
+			timestamp,
+			durationMs: Math.max(0, performance.now() - started),
+		});
 	}
-	return { text: summary.trim(), usage };
 }
 
 /**
@@ -464,16 +514,16 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 		const userText = buildUserText(conversationText, input.instructions, previousContextText);
 		const historySummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
 		usage = addCompactionUsage(usage, historySummary.usage);
-		if (historySummary.text.length > 0) summaryParts.push(historySummary.text);
+		if (historySummary.text.length === 0) throw new Error("compaction returned an empty history summary");
+		summaryParts.push(historySummary.text);
 	}
 	if (turnPrefix.length > 0) {
 		const conversationText = serializeConversation(turnPrefix);
 		const userText = buildTurnPrefixUserText(conversationText, input.instructions, previousContextText);
 		const prefixSummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
 		usage = addCompactionUsage(usage, prefixSummary.usage);
-		if (prefixSummary.text.length > 0) {
-			summaryParts.push(`**Turn Context (split turn):**\n\n${prefixSummary.text}`);
-		}
+		if (prefixSummary.text.length === 0) throw new Error("compaction returned an empty split-turn summary");
+		summaryParts.push(`**Turn Context (split turn):**\n\n${prefixSummary.text}`);
 	}
 
 	const summary = `${summaryParts.join("\n\n---\n\n").trim()}${formatFileOperations(fileOps)}${formatRecallableRefs(

package/src/domains/session/entries.ts

@@ -101,6 +101,10 @@ export type CompactionTrigger = "auto" | "force" | "overflow";
  * `usage` carries and the ledger usage fold reads both from one place.
  */
 export interface CompactionUsage {
+	/** Executing route; absent on legacy checkpoints that used the active chat model. */
+	targetId?: string;
+	/** Requested wire model ID, not a verified physical backend identity. */
+	modelId?: string;
 	input: number;
 	output: number;
 	cacheRead: number;
@@ -515,6 +519,8 @@ function isOptionalCompactionUsage(value: unknown): boolean {
 	if (!isRecord(value)) return false;
 	const cost = value.cost;
 	return (
+		isOptionalString(value.targetId) &&
+		isOptionalString(value.modelId) &&
 		isNumber(value.input) &&
 		isNumber(value.output) &&
 		isNumber(value.cacheRead) &&

package/src/domains/session/usage.ts

@@ -101,9 +101,9 @@ export function ledgerUsageCalls(
 			const usage = entry.usage;
 			if (!usage || usage.totalTokens <= 0) continue;
 			calls.push({
-				providerId: currentTarget ?? "unknown",
-				attributedModelId: currentModel ?? "unknown",
-				requestedModelId: currentModel ?? "unknown",
+				providerId: usage.targetId ?? currentTarget ?? "unknown",
+				attributedModelId: usage.modelId ?? currentModel ?? "unknown",
+				requestedModelId: usage.modelId ?? currentModel ?? "unknown",
 				responseModelIdObservation: { state: "not-observed" },
 				input: usage.input,
 				output: usage.output,

package/src/engine/agent.ts

@@ -14,7 +14,11 @@ import { Agent, type AgentOptions, type StreamFn } from "@earendil-works/pi-agen
 import { isDispositionedToolResultError } from "../tools/result-disposition.js";
 import { engineStreamSimple } from "./api-registry.js";
 
-export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & { streamFn?: StreamFn };
+export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & {
+	streamFn?: StreamFn;
+	/** Called immediately before each native stream delegate invocation. */
+	onStreamInvocation?: () => void;
+};
 
 export interface EngineAgentHandle {
 	agent: Agent;
@@ -34,9 +38,15 @@ function dispositionAwareAfterToolCall(
 }
 
 export function createEngineAgent(options: EngineAgentOptions = {}): EngineAgentHandle {
+	const { streamFn = engineStreamSimple, onStreamInvocation, ...agentOptions } = options;
 	const agent = new Agent({
-		streamFn: engineStreamSimple,
-		...options,
+		...agentOptions,
+		streamFn: onStreamInvocation
+			? (...args) => {
+					onStreamInvocation();
+					return streamFn(...args);
+				}
+			: streamFn,
 		afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall),
 	});
 	return {

package/src/engine/ai.ts

@@ -59,6 +59,8 @@ export interface EngineTextCompletionInput {
 	signal: AbortSignal;
 	timeoutMs: number;
 	apiKey?: string;
+	/** Accounting only: observed before terminal errors throw, never carries response content. */
+	onUsage?: (observation: Pick<EngineTextCompletionResult, "usage" | "backend">) => void;
 }
 
 export interface EngineTextCompletionResult {
@@ -98,16 +100,11 @@ export async function completeEngineText(input: EngineTextCompletionInput): Prom
 			...(input.apiKey === undefined ? {} : { apiKey: input.apiKey }),
 		},
 	);
-	if (response.stopReason === "error" || response.stopReason === "aborted") {
+	const failed = response.stopReason === "error" || response.stopReason === "aborted";
+	if (failed && !response.usage) {
 		throw new Error(response.errorMessage ?? `model completion ${response.stopReason}`);
 	}
-	return {
-		text: response.content
-			.filter((block): block is Extract<(typeof response.content)[number], { type: "text" }> => block.type === "text")
-			.map((block) => block.text)
-			.join(""),
-		inputTokens: response.usage.input,
-		outputTokens: response.usage.output,
+	const observation: Pick<EngineTextCompletionResult, "usage" | "backend"> = {
 		usage: {
 			input: response.usage.input,
 			output: response.usage.output,
@@ -119,6 +116,27 @@ export async function completeEngineText(input: EngineTextCompletionInput): Prom
 		},
 		backend: response.backendTimings ?? null,
 	};
+	// Pi synthesizes all-zero usage for failures with no provider accounting.
+	// Do not turn that placeholder into a measured zero-spend call.
+	if (!failed || Object.values(observation.usage).some((value) => Number.isFinite(value) && value > 0)) {
+		try {
+			input.onUsage?.(observation);
+		} catch {
+			// Accounting observers cannot change completion success/error behavior.
+		}
+	}
+	if (failed) {
+		throw new Error(response.errorMessage ?? `model completion ${response.stopReason}`);
+	}
+	return {
+		text: response.content
+			.filter((block): block is Extract<(typeof response.content)[number], { type: "text" }> => block.type === "text")
+			.map((block) => block.text)
+			.join(""),
+		inputTokens: response.usage.input,
+		outputTokens: response.usage.output,
+		...observation,
+	};
 }
 
 export interface EngineAi {