@matthewfl/pi-contemplator 0.1.20 → 0.3.0

package/README.md

@@ -157,6 +157,8 @@ The observer and summarizer provide the durable memory substrate. The contemplat
 
 ## Installation
 
+`pi-contemplator` 0.3.0 requires **Pi 0.87.x**.
+
 Install the published package through Pi:
 
 ```bash
@@ -201,4 +203,4 @@ npm run typecheck
 
 ## License
 
-MIT. See [LICENSE](LICENSE).
+MIT. See [LICENSE](LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.20",
+  "version": "0.3.0",
   "description": "A Pi extension that keeps long-running agentic sessions on track with background memory, contemplation, and structural review.",
   "type": "module",
   "license": "MIT",
@@ -44,17 +44,17 @@
     "test:e2e": "node tests/e2e/rpc-contemplator.mjs && node tests/e2e/rpc-contemplator-history.mjs && node tests/e2e/rpc-summarizer.mjs && node tests/e2e/rpc-delivery.mjs && node tests/e2e/rpc-restore-review.mjs && node tests/e2e/rpc-compaction.mjs && node tests/e2e/rpc-compaction-resilience.mjs && node tests/e2e/rpc-memory-edges.mjs && node tests/e2e/rpc-observer-length.mjs && node tests/e2e/rpc-routing-isolation.mjs"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "*",
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-agent-core": "^0.87.0",
+    "@earendil-works/pi-ai": "^0.87.0",
+    "@earendil-works/pi-coding-agent": "^0.87.0",
+    "@earendil-works/pi-tui": "^0.87.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.85.1",
-    "@earendil-works/pi-ai": "^0.85.1",
-    "@earendil-works/pi-coding-agent": "^0.85.1",
-    "@earendil-works/pi-server": "^0.85.1",
-    "@earendil-works/pi-tui": "^0.85.1",
+    "@earendil-works/pi-agent-core": "^0.87.0",
+    "@earendil-works/pi-ai": "^0.87.0",
+    "@earendil-works/pi-coding-agent": "^0.87.0",
+    "@earendil-works/pi-server": "^0.87.0",
+    "@earendil-works/pi-tui": "^0.87.0",
     "@types/node": "^22.0.0",
     "typebox": "^1.1.38",
     "typescript": "^5.6.0",

package/src/agents/contemplator/agent.ts

@@ -1,7 +1,6 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool } from "@earendil-works/pi-agent-core";
+import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import { Type, type Message, type Model } from "@earendil-works/pi-ai";
 import type { Static } from "typebox";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { estimateTokens as estimateAgentMessageTokens, generateSummaryWithUsage } from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
@@ -9,7 +8,7 @@ import { agentActiveTimeMs, assistantOutputTokens, assistantToolCallCount, fullP
 import { hashId } from "../../ids.js";
 import { createSearchMemoriesAgentTool } from "../../tools/search-memories.js";
 import { createRecallAgentTool } from "../../tools/recall-observation.js";
-import type { MemoryUpdateCtx, Runtime } from "../../runtime.js";
+import { modelRegistryStream, type MemoryUpdateCtx, type Runtime } from "../../runtime.js";
 import { logAgentStreamError } from "../stream-errors.js";
 import { debugLog, withDebugLogContext } from "../../debug-log.js";
 import { boundedMaxTokens, AGENT_LOOP_MAX_TOKENS } from "../../model-budget.js";
@@ -92,6 +91,10 @@ type Intervention =
 	| { kind: "review"; request: Omit<StructuralReviewRequest, "createdAt" | "requestedBy"> }
 	| { kind: "none" };
 
+function isResumableReviewerMessage(message: unknown): message is AgentMessage {
+	return !!message && typeof message === "object" && (message as { role?: unknown }).role !== "system";
+}
+
 type ReviewerSession = {
 	scope: StructuralReviewRequest["scope"];
 	history: AgentMessage[];
@@ -108,8 +111,7 @@ type QueueStructuralReviewOptions = {
 	requestArgs: Extract<Intervention, { kind: "review" }>["request"];
 	branchEntries: Entry[];
 	model: Model<any>;
-	apiKey: string;
-	headers: Record<string, string> | undefined;
+	streamFn: StreamFn;
 	sessionGeneration: number;
 };
 
@@ -117,8 +119,7 @@ type LaunchStructuralReviewOptions = {
 	ctx: MemoryUpdateCtx;
 	request: StructuralReviewRequest;
 	model: Model<any>;
-	apiKey: string;
-	headers: Record<string, string> | undefined;
+	streamFn: StreamFn;
 	sessionGeneration: number;
 	key?: string;
 	history?: AgentMessage[];
@@ -567,7 +568,7 @@ export class Contemplator {
 						// Backward compatibility for the old, expensive full-transcript snapshots.
 						this.reviewerSessions.set(state.reviewRequestId, {
 							scope: state.scope,
-							history: state.history.filter((message): message is AgentMessage => !!message && typeof message === "object"),
+							history: state.history.filter(isResumableReviewerMessage),
 							checkpointEntryId: entry.id,
 							messageEntryIds: [],
 							foldedEntryIds: new Set(),
@@ -594,8 +595,10 @@ export class Contemplator {
 					// (turn_end), so fold each message entry at most once per live session.
 					if (!session.foldedEntryIds.has(entry.id)) {
 						session.foldedEntryIds.add(entry.id);
-						session.history.push(data.message as AgentMessage);
-						session.messageEntryIds.push(entry.id);
+						if (isResumableReviewerMessage(data.message)) {
+							session.history.push(data.message);
+							session.messageEntryIds.push(entry.id);
+						}
 					}
 				}
 			}
@@ -807,6 +810,7 @@ export class Contemplator {
 				debugLog("contemplator.flush_stale", { reason: "session_changed" });
 				return;
 			}
+			const streamFn = modelRegistryStream(ctx.modelRegistry);
 			const selectedModel = resolved.model as { provider?: unknown; id?: unknown; contextWindow?: unknown };
 			debugLog("contemplator.model_resolved", {
 				provider: selectedModel.provider,
@@ -875,33 +879,34 @@ export class Contemplator {
 			const supportsReasoning = (resolved.model as { reasoning?: unknown }).reasoning === true;
 			const config: AgentLoopConfig & { onPayload?: (payload: unknown) => unknown } = {
 				model: resolved.model as Model<any>,
-				apiKey: resolved.apiKey,
-				headers: resolved.headers,
 				maxTokens: boundedMaxTokens(resolved.model as Model<any>, AGENT_LOOP_MAX_TOKENS),
 				convertToLlm: (messages) => messages as Message[],
 				toolExecution: "sequential",
 				// A clean final-action call is the end of the contemplator turn. Do not
 				// spend another model request asking it to narrate after its decision.
 				// Citation warnings leave the loop open so it can correct the action.
-				shouldStopAfterTurn: () => intervention !== undefined && !finalActionWarned,
+				finishTurn: ({ message }) => {
+					if (message.stopReason === "error" || message.stopReason === "aborted") return undefined;
+					return intervention !== undefined && !finalActionWarned ? { action: "end" } : undefined;
+				},
 				...(supportsReasoning && selectedThinkingLevel !== "off" ? { reasoning: selectedThinkingLevel } : {}),
 			};
 			const runMessages: AgentMessage[] = [];
 			let nextPrompt = prompt;
 			for (let invocation = 1; invocation <= CONTEMPLATOR_MAX_INVOCATIONS && !intervention; invocation++) {
 				runMessages.push(nextPrompt);
-				const context: AgentContext = { systemPrompt: buildContemplatorSystemPrompt(reviewerEnabled), messages: [...this.history, ...runMessages.slice(0, -1)], tools };
+				const context: AgentContext = { messages: [{ role: "system", content: buildContemplatorSystemPrompt(reviewerEnabled), toolsAdded: tools, timestamp: Date.now() }, ...this.history, ...runMessages.slice(0, -1)], tools };
 				const api = (resolved.model as Model<any>).api;
 				const invocationConfig: AgentLoopConfig & { onPayload?: (payload: unknown) => unknown } = invocation === 1 ? config : {
 					...config,
 					onPayload: (payload) => forceRequiredToolPayload(payload, api),
 				};
-				// SimpleStreamOptions 0.84.3 types provider-neutral choice as auto/none,
-				// while individual provider APIs also support required/any. Preserve the
+				// Provider-neutral SimpleStreamOptions types choice as auto/none, while
+				// individual provider APIs also support required/any. Preserve the
 				// runtime hint and final-payload enforcement without weakening base types.
 				if (invocation > 1) (invocationConfig as any).toolChoice = requiredToolChoice(api);
 				workerWatchdog.progress();
-				const stream = agentLoop([nextPrompt], context, invocationConfig, workerWatchdog.signal, streamSimple);
+				const stream = agentLoop([nextPrompt], context, invocationConfig, workerWatchdog.signal, streamFn);
 				const result = await workerWatchdog.race((async () => {
 					for await (const event of stream) {
 						workerWatchdog!.progress();
@@ -966,8 +971,7 @@ export class Contemplator {
 						requestArgs: intervention.request,
 						branchEntries,
 						model: reviewerModel.model as Model<any>,
-						apiKey: reviewerModel.apiKey,
-						headers: reviewerModel.headers,
+						streamFn,
 						sessionGeneration,
 					});
 				}
@@ -975,7 +979,7 @@ export class Contemplator {
 			if (sessionGeneration === this.sessionGeneration) {
 				workerWatchdog.progress();
 				try {
-					await workerWatchdog.race(this.compactHistory(ctx, resolved.model as Model<any>, resolved.apiKey, resolved.headers, sessionGeneration, flushEpoch, workerWatchdog.signal));
+					await workerWatchdog.race(this.compactHistory(ctx, resolved.model as Model<any>, streamFn, sessionGeneration, flushEpoch, workerWatchdog.signal));
 				} catch (compactionError) {
 					// The intervention and its durable messages are already complete. Private
 					// history maintenance must never relabel that successful work as failed.
@@ -1056,10 +1060,10 @@ export class Contemplator {
 		// designed for agents that run for hours; a probe must be injected after
 		// the current tool-call batch, before the very next model request. Never
 		// change this to nextTurn: that can postpone delivery until a user prompt.
-		// IMPORTANT: omit triggerTurn entirely. Pi 0.84+ interprets an explicit
-		// triggerTurn:false as "do not queue while streaming" and inserts directly
-		// into agent.state, outside the active run's context snapshot. Omitting it
-		// still does not start a turn while idle, but allows steer to work in-run.
+		// IMPORTANT: omit triggerTurn entirely. Pi queues a streaming steer only
+		// when triggerTurn is not explicitly false; false uses the deferred custom-
+		// message path instead of steering the active run. When idle, omission merely
+		// appends the message and does not manufacture a new agent turn.
 		// Whether Pi is currently running or idle, sendMessage owns this probe in an
 		// in-memory steer queue until message_end drains it. Track both cases so an
 		// unrelated observer update or compaction callback cannot restore and enqueue
@@ -1084,7 +1088,7 @@ export class Contemplator {
 	}
 
 	private queueStructuralReview(options: QueueStructuralReviewOptions): void {
-		const { ctx, requestArgs, branchEntries, model, apiKey, headers, sessionGeneration } = options;
+		const { ctx, requestArgs, branchEntries, model, streamFn, sessionGeneration } = options;
 		const requestForKey: RequestReviewArgs = { scope: requestArgs.scope, evidence: requestArgs.evidence, concern: requestArgs.concern, review_focus: requestArgs.reviewFocus, constraints: requestArgs.constraints };
 		const key = reviewRequestKey(requestForKey);
 		const duplicateRequest = branchEntries.some((entry) => isReviewRequestEntry(entry) && reviewRequestKey({ scope: entry.data.request.scope, evidence: entry.data.request.evidence, concern: entry.data.request.concern, review_focus: entry.data.request.reviewFocus, constraints: entry.data.request.constraints }) === key);
@@ -1095,11 +1099,11 @@ export class Contemplator {
 		const request: StructuralReviewRequest = { ...requestArgs, id: requestArgs.id, createdAt: Date.now(), requestedBy: "contemplator" };
 		this.pi.appendEntry(OM_REVIEW_REQUEST, { version: 1, request });
 		this.markTipPersisted(ctx);
-		this.launchStructuralReview({ ctx, request, model, apiKey, headers, sessionGeneration, key });
+		this.launchStructuralReview({ ctx, request, model, streamFn, sessionGeneration, key });
 	}
 
 	private launchStructuralReview(options: LaunchStructuralReviewOptions): boolean {
-		const { ctx, request, model, apiKey, headers, sessionGeneration, key } = options;
+		const { ctx, request, model, streamFn, sessionGeneration, key } = options;
 		if (this.runtime.reviewInFlight || this.inFlightReviewIds.has(request.id)) return false;
 		// Do not spin a no-progress reviewer repeatedly in one live session. The
 		// request stays pending and a later session/tree restoration resumes it.
@@ -1114,7 +1118,7 @@ export class Contemplator {
 			try {
 				debugLog("reviewer.started", { reviewRequestId: request.id, scope: request.scope, resumed: session.history.length > 0 });
 				const result = await watchdog.race(runStructuralReview({
-					request, model, apiKey, headers,
+					request, model, streamFn,
 					signal: watchdog.signal,
 					onProgress: watchdog.progress,
 					getBranch: () => ctx.sessionManager.getBranch() as Entry[],
@@ -1124,6 +1128,7 @@ export class Contemplator {
 						watchdog.progress();
 						if (!acceptsMessages || sessionGeneration !== this.sessionGeneration || !this.reviewIsPending(ctx, request.id)) return;
 						for (const message of messages) {
+							if (!isResumableReviewerMessage(message)) continue;
 							session.history.push(message);
 							const entryId = this.appendEntryWithId(ctx, OM_REVIEWER_MESSAGE, { version: 1, reviewRequestId: request.id, scope: request.scope, message }, request.id);
 							if (entryId) {
@@ -1151,8 +1156,8 @@ export class Contemplator {
 				debugLog(result.outcome === "proposal" ? "reviewer.proposal_created" : "reviewer.no_proposal", { reviewRequestId: request.id, reviewMemoryId: result.id, scope: result.scope });
 				if (result.outcome === "proposal") {
 					const notice = `BACKGROUND ${result.scope.toUpperCase()} REVIEW PROPOSAL [${result.id}]\n\nIMPORTANT: This is only an abbreviated notice, not the full proposal. When this proposal is relevant to the current work, call the recall tool with memory id [${result.id}] before deciding whether or how to act on it.\n\nSUMMARY:\n${result.summary}\n\nThis is advisory. After recalling memory [${result.id}], evaluate the full proposal against the actual environment and current work.`;
-					// As with probes, triggerTurn must be omitted or Pi 0.84+ bypasses
-					// the streaming steer queue and the active run never sees this message.
+					// As with probes, omit triggerTurn so a streaming run receives this
+					// through its steer queue without manufacturing a turn while idle.
 					this.pi.sendMessage({ customType: REVIEW_PROPOSAL_MESSAGE, content: notice, display: this.runtime.config.showContemplatorMessages, details: { version: 1, reviewRequestId: request.id, reviewMemoryId: result.id, scope: result.scope } }, { deliverAs: "steer" });
 					this.pi.appendEntry(OM_REVIEWER_NOTICE, { version: 1, reviewRequestId: request.id, reviewMemoryId: result.id, scope: result.scope, content: notice });
 					this.markTipPersisted(ctx);
@@ -1216,7 +1221,7 @@ export class Contemplator {
 				debugLog("reviewer.resume_skipped", { reviewRequestId: request.id, reason: resolved.ok ? "session_changed" : resolved.reason });
 				return;
 			}
-			this.launchStructuralReview({ ctx, request, model: resolved.model as Model<any>, apiKey: resolved.apiKey, headers: resolved.headers, sessionGeneration: generation, history: this.reviewerSessions.get(request.id)?.history ?? [] });
+			this.launchStructuralReview({ ctx, request, model: resolved.model as Model<any>, streamFn: modelRegistryStream(ctx.modelRegistry), sessionGeneration: generation, history: this.reviewerSessions.get(request.id)?.history ?? [] });
 		} finally {
 			this.resolvingReviewIds.delete(request.id);
 		}
@@ -1263,7 +1268,7 @@ export class Contemplator {
 		return own?.id;
 	}
 
-	private async compactHistory(ctx: MemoryUpdateCtx, model: Model<any>, apiKey: string, headers: Record<string, string> | undefined, sessionGeneration: number, flushEpoch: number, signal?: AbortSignal): Promise<void> {
+	private async compactHistory(ctx: MemoryUpdateCtx, model: Model<any>, streamFn: StreamFn, sessionGeneration: number, flushEpoch: number, signal?: AbortSignal): Promise<void> {
 		const history = this.history.slice();
 		const historyEntryIds = this.historyEntryIds.slice();
 		const historyTokens = contemplatorHistoryTokens(history);
@@ -1287,10 +1292,13 @@ export class Contemplator {
 			history.slice(0, prefixEnd),
 			model,
 			CONTEMPLATOR_HISTORY_SUMMARY_RESERVE_TOKENS,
-			apiKey,
-			headers,
+			undefined,
+			undefined,
 			signal,
 			CONTEMPLATOR_HISTORY_SUMMARY_INSTRUCTIONS,
+			undefined,
+			undefined,
+			streamFn,
 		);
 
 		let prefixEnd = initialPrefixEnd;

package/src/agents/observer/agent.ts

@@ -1,7 +1,6 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool } from "@earendil-works/pi-agent-core";
+import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import type { Message, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "@earendil-works/pi-ai";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { Static } from "typebox";
 import { hashId } from "../../ids.js";
 import { replayTruncatedThinkingAsText } from "../replay-truncated-thinking.js";
@@ -15,8 +14,7 @@ import type { LlmUsageInput } from "../../runtime.js";
 
 interface RunObserverArgs {
 	model: Model<any>;
-	apiKey: string;
-	headers?: Record<string, string>;
+	streamFn: StreamFn;
 	priorSummaries?: string[];
 	priorObservations: string[];
 	chunk: string;
@@ -108,7 +106,7 @@ export function normalizeSourceEntryIds(
 }
 
 export async function runObserver(args: RunObserverArgs): Promise<Observation[] | undefined> {
-	const { model, apiKey, headers, priorSummaries = [], priorObservations, chunk, allowedSourceEntryIds, signal } = args;
+	const { model, priorSummaries = [], priorObservations, chunk, allowedSourceEntryIds, signal } = args;
 	const conversation = chunk.trim();
 	if (!conversation) return undefined;
 
@@ -205,14 +203,15 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 	let turnCount = 0;
 	const baseConfig: AgentLoopConfig = {
 		model,
-		apiKey,
-		headers,
 		maxTokens: boundedMaxTokens(model, OBSERVER_AGENT_LOOP_MAX_TOKENS),
 		convertToLlm: replayTruncatedThinkingAsText,
 		toolExecution: "sequential",
-		shouldStopAfterTurn: () => {
+		finishTurn: ({ message }) => {
+			if (message.stopReason === "error" || message.stopReason === "aborted") return undefined;
 			turnCount++;
-			return doneCalled || (effectiveMaxTurns !== undefined && turnCount >= effectiveMaxTurns);
+			return doneCalled || (effectiveMaxTurns !== undefined && turnCount >= effectiveMaxTurns)
+				? { action: "end" }
+				: undefined;
 		},
 		...(reasoning && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
 	};
@@ -222,10 +221,10 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 	let terminalFailure: { stopReason: string; errorMessage?: string } | undefined;
 	let lengthAttempts = 0;
 	const runInvocation = async (prompt: Message, afterLength = false): Promise<void> => {
+		const tools = [recordObservations as AgentTool<any>, doneTool];
 		const context: AgentContext = {
-			systemPrompt: OBSERVER_SYSTEM,
-			messages: history.slice(),
-			tools: [recordObservations as AgentTool<any>, doneTool],
+			messages: [{ role: "system", content: OBSERVER_SYSTEM, toolsAdded: tools, timestamp: Date.now() }, ...history],
+			tools,
 		};
 		// Publish a live launch-local transcript for /om:view observer. Keep an
 		// invocation-local list because agentLoop owns its internal context copy.
@@ -234,7 +233,7 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 		const invocationConfig: AgentLoopConfig = afterLength && reasoning
 			? { ...baseConfig, reasoning: "minimal" }
 			: baseConfig;
-		const stream = loop([prompt], context, invocationConfig, signal, streamSimple);
+		const stream = loop([prompt], context, invocationConfig, signal, args.streamFn);
 		for await (const event of stream) {
 			args.onProgress?.();
 			logAgentStreamError("observer", event);

package/src/agents/reviewer/agent.ts

@@ -1,6 +1,5 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool } from "@earendil-works/pi-agent-core";
+import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import type { Message, Model } from "@earendil-works/pi-ai";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { hashId } from "../../ids.js";
 import { boundedMaxTokens, REVIEWER_TOTAL_TOKEN_LIMIT } from "../../model-budget.js";
 import type { LlmUsageInput } from "../../runtime.js";
@@ -22,8 +21,7 @@ export const REVIEWER_MAX_INVOCATIONS_PER_LAUNCH = 5;
 export interface RunStructuralReviewArgs {
 	request: StructuralReviewRequest;
 	model: Model<any>;
-	apiKey: string;
-	headers?: Record<string, string>;
+	streamFn: StreamFn;
 	getBranch: () => Entry[];
 	signal?: AbortSignal;
 	agentLoop?: typeof agentLoop;
@@ -144,8 +142,8 @@ export async function runStructuralReview(args: RunStructuralReviewArgs): Promis
 		// agentLoop can make several model calls while following tool calls. Wrap its
 		// stream function so every internal response gets only the lifetime budget
 		// remaining after earlier responses, not a fresh per-turn allowance.
-		const budgetedStreamSimple: typeof streamSimple = ((model: Model<any>, context: any, options: any) => {
-			const response = streamSimple(model, context, {
+		const budgetedStreamSimple: StreamFn = async (model: Model<any>, context: any, options: any) => {
+			const response = await args.streamFn(model, context, {
 				...options,
 				maxTokens: boundedMaxTokens(model, remainingBudget()),
 			});
@@ -160,21 +158,22 @@ export async function runStructuralReview(args: RunStructuralReviewArgs): Promis
 				}
 				return message;
 			};
-			return { [Symbol.asyncIterator]: () => response[Symbol.asyncIterator](), result } as ReturnType<typeof streamSimple>;
-		}) as typeof streamSimple;
+			return { [Symbol.asyncIterator]: () => response[Symbol.asyncIterator](), result } as typeof response;
+		};
 		const config: AgentLoopConfig = {
 			model: args.model,
-			apiKey: args.apiKey,
-			headers: args.headers,
 			maxTokens: boundedMaxTokens(args.model, remainingBudget()),
 			convertToLlm: (messages) => messages as Message[],
 			toolExecution: "sequential",
-			shouldStopAfterTurn: () => terminal !== undefined || remainingBudget() === 0,
+			finishTurn: ({ message }) => {
+				if (message.stopReason === "error" || message.stopReason === "aborted") return undefined;
+				return terminal !== undefined || remainingBudget() === 0 ? { action: "end" } : undefined;
+			},
 		};
 		const promptMessage = prompt as AgentMessage;
 		// agentLoop receives the new prompt separately. Its context must therefore
 		// contain only prior messages, otherwise a resumed prompt is sent twice.
-		const context: AgentContext = { systemPrompt: buildReviewerSystemPrompt(args.request.scope), messages: history.slice(), tools };
+		const context: AgentContext = { messages: [{ role: "system", content: buildReviewerSystemPrompt(args.request.scope), toolsAdded: tools, timestamp: Date.now() }, ...history], tools };
 		history.push(promptMessage);
 		args.onMessages?.([promptMessage]);
 		const stream = loop([prompt], context, config, args.signal, budgetedStreamSimple);
@@ -183,9 +182,14 @@ export async function runStructuralReview(args: RunStructuralReviewArgs): Promis
 			logAgentStreamError("reviewer", event);
 		}
 		const newMessages = await stream.result();
-		history.push(...newMessages);
-		args.onMessages?.(newMessages);
-		const assistants = newMessages.filter((message): message is AgentMessage => message.role === "assistant");
+		// agentLoop returns the supplied prompt in its per-invocation result. It is
+		// already persisted above, so exclude that exact input alongside any
+		// synthesized tool-declaration system messages. declareToolChanges preserves
+		// non-system prompt object identity even when it inserts a system delta.
+		const resumableMessages = newMessages.filter((message) => message !== promptMessage && message.role !== "system");
+		history.push(...resumableMessages);
+		args.onMessages?.(resumableMessages);
+		const assistants = resumableMessages.filter((message) => message.role === "assistant");
 		if (args.recordUsage) {
 			for (const message of assistants) {
 				const usage = (message as { usage?: LlmUsageInput }).usage;
@@ -196,8 +200,8 @@ export async function runStructuralReview(args: RunStructuralReviewArgs): Promis
 		// assistant usage that the real stream wrapper did not already account for.
 		const reportedOutputTokens = assistantOutputTokens(assistants);
 		totalOutputTokens += Math.max(0, reportedOutputTokens - streamedOutputTokens);
-		// A warned terminal call deliberately leaves shouldStopAfterTurn false so
-		// the reviewer can search/recall and replace it. If the reviewer instead
+		// A warned terminal call deliberately leaves finishTurn undecided so the
+		// reviewer can search/recall and replace it. If the reviewer instead
 		// ends its turn, honor the staged outcome exactly as the warning promised.
 		if (!terminal && warnedTerminal) {
 			terminal = warnedTerminal;

package/src/agents/summarizer/agent.ts

@@ -1,7 +1,6 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool } from "@earendil-works/pi-agent-core";
+import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import type { Message, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "@earendil-works/pi-ai";
-import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { Static } from "typebox";
 import { debugLog } from "../../debug-log.js";
 import { hashId } from "../../ids.js";
@@ -48,8 +47,7 @@ const MEMORY_ID_GLOBAL = new RegExp(MEMORY_ID_SOURCE, "g");
 
 export type RunSummarizerArgs = {
 	model: Model<any>;
-	apiKey: string;
-	headers?: Record<string, string>;
+	streamFn: StreamFn;
 	getBranch: () => Entry[];
 	/** Target size for the old, summarizer-eligible memory pool. */
 	targetTokens: number;
@@ -531,15 +529,13 @@ export async function runSummarizer(args: RunSummarizerArgs): Promise<Summarizer
 
 	const runOnce = async (text: string, requireToolCall: boolean): Promise<string | undefined> => {
 		const prompt: Message = { role: "user", content: [{ type: "text", text }], timestamp: Date.now() };
-		const context: AgentContext = { systemPrompt: SUMMARIZER_SYSTEM, messages: history.slice(), tools };
+		const context: AgentContext = { messages: [{ role: "system", content: SUMMARIZER_SYSTEM, toolsAdded: tools, timestamp: Date.now() }, ...history], tools };
 		const estimatedInputTokens = estimateStringTokens(SUMMARIZER_SYSTEM) + toolDefinitionTokens + estimateStringTokens(JSON.stringify([...history, prompt]));
 		const contextAvailableOutput = Math.max(1, contextWindow - estimatedInputTokens - SUMMARIZER_CONTEXT_RESERVE_TOKENS);
 		const maxOutputTokens = Math.min(SUMMARIZER_MAX_OUTPUT_TOKENS, contextAvailableOutput);
 		let turnCount = 0;
 		const config: AgentLoopConfig = {
 			model: args.model,
-			apiKey: args.apiKey,
-			headers: args.headers,
 			maxTokens: boundedMaxTokens(args.model, maxOutputTokens),
 			convertToLlm: replayTruncatedThinkingAsText,
 			toolExecution: "sequential",
@@ -550,7 +546,12 @@ export async function runSummarizer(args: RunSummarizerArgs): Promise<Summarizer
 				if (calls.length > 1) return { block: true, reason: "Call done alone in a later response after sibling tool results are visible." };
 				return undefined;
 			},
-			shouldStopAfterTurn: () => completedWithDone || (effectiveMaxTurns !== undefined && ++turnCount >= effectiveMaxTurns),
+			finishTurn: ({ message }) => {
+				if (message.stopReason === "error" || message.stopReason === "aborted") return undefined;
+				return completedWithDone || (effectiveMaxTurns !== undefined && ++turnCount >= effectiveMaxTurns)
+					? { action: "end" }
+					: undefined;
+			},
 			...(requireToolCall ? { onPayload: (payload: unknown) => forceRequiredToolPayload(payload, args.model.api) } : {}),
 			...(reasoning && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
 		};
@@ -560,7 +561,7 @@ export async function runSummarizer(args: RunSummarizerArgs): Promise<Summarizer
 		if (requireToolCall) (config as any).toolChoice = requiredToolChoice(args.model.api);
 		history.push(prompt as AgentMessage);
 		args.onMessages?.(history.slice());
-		const stream = loop([prompt], context, config, args.signal, streamSimple);
+		const stream = loop([prompt], context, config, args.signal, args.streamFn);
 		// agentLoop emits message_start/message_end for the supplied prompt, so
 		// seed live checkpoints without our already-pushed copy of that prompt.
 		const liveMessages = history.slice(0, -1);

package/src/hooks/consolidation-trigger.ts

@@ -1,9 +1,9 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { runSummarizer } from "../agents/summarizer/agent.js";
 import { runObserver } from "../agents/observer/agent.js";
 import { debugLog, withDebugLogContext } from "../debug-log.js";
 import { resolveObserverChunkMaxTokens } from "../config.js";
-import type { ResolveResult, Runtime } from "../runtime.js";
+import { modelRegistryStream, type ResolveResult, type Runtime } from "../runtime.js";
 import { createWorkerStallWatchdog } from "../worker-watchdog.js";
 import { boundedMaxTokens, OBSERVER_AGENT_LOOP_MAX_TOKENS } from "../model-budget.js";
 import { serializeSourceAddressedBranchEntries } from "../serialize.js";
@@ -30,7 +30,7 @@ export type ConsolidationCtx = {
 	hasUI: boolean;
 	ui?: { notify: (message: string, type?: "warning" | "info" | "error") => void };
 	model: unknown;
-	modelRegistry: any;
+	modelRegistry: ExtensionContext["modelRegistry"];
 	sessionManager: {
 		getBranch: () => readonly unknown[];
 		getSessionId?: () => string;
@@ -400,8 +400,7 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 			const result = await watchdog.race(runSummarizer({
 				signal: watchdog.signal,
 				model: resolved.model as any,
-				apiKey: resolved.apiKey,
-				headers: resolved.headers,
+				streamFn: modelRegistryStream(ctx.modelRegistry),
 				getBranch: () => ctx.sessionManager.getBranch() as Entry[],
 				targetTokens: runtime.config.oldMemoryPoolTargetTokens,
 				newPoolMaxTokens: runtime.config.newMemoryPoolMaxTokens,
@@ -569,8 +568,7 @@ async function runObserverStage(
 	try {
 		observations = await observerWatchdog.race(runObserver({
 			model: resolved.model as any,
-			apiKey: resolved.apiKey,
-			headers: resolved.headers,
+			streamFn: modelRegistryStream(ctx.modelRegistry),
 			priorSummaries,
 			priorObservations,
 			chunk,

package/src/runtime.ts

@@ -1,9 +1,16 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Config, type ConfiguredModel, DEFAULTS, loadConfig } from "./config.js";
 
 export type ResolveResult =
-	| { ok: true; model: unknown; apiKey: string; headers?: Record<string, string> }
+	| { ok: true; model: unknown }
 	| { ok: false; reason: string };
 
+/** Route background model calls through Pi's configured providers and request-time authentication. */
+export function modelRegistryStream(modelRegistry: ExtensionContext["modelRegistry"]): StreamFn {
+	return (model, context, options) => modelRegistry.streamSimple(model, context, options);
+}
+
 type NotifyLevel = "warning" | "info" | "error";
 type Notify = (message: string, type?: NotifyLevel) => void;
 export type ConsolidationPhase = "observer";
@@ -39,7 +46,7 @@ export type SessionSettings = Partial<Pick<Config,
 
 export interface ResolveCtx {
 	model: unknown;
-	modelRegistry: any;
+	modelRegistry: ExtensionContext["modelRegistry"];
 	hasUI: boolean;
 	ui?: { notify: Notify };
 }
@@ -342,13 +349,10 @@ export class Runtime {
 				);
 			}
 		}
-		if (!model) return { ok: false, reason: "no model available (session has no model and no observational-memory model configured)" };
-		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!auth.ok || !auth.apiKey) {
-			const provider = (model as { provider?: string }).provider ?? "unknown";
-			return { ok: false, reason: `no API key for provider "${provider}"` };
-		}
-		return { ok: true, model, apiKey: auth.apiKey as string, headers: auth.headers as Record<string, string> | undefined };
+		if (!model) return { ok: false, reason: "no model available (session has no model and no pi-contemplator model configured)" };
+		// Authentication, provider composition, OAuth refresh, headers, and endpoint
+		// selection are deliberately resolved by ModelRegistry at request time.
+		return { ok: true, model };
 	}
 
 	setMemoryUpdateListener(listener: (ctx: MemoryUpdateCtx) => void): void {