pi-claude-agent-sdk 0.8.4 → 0.8.6

package/README.md

@@ -21,7 +21,7 @@ pi install npm:pi-claude-agent-sdk
 
 ## Provider
 
-Use `/model` to select `claude-bridge/claude-fable-5-1`, `claude-bridge/claude-fable-5`, `claude-bridge/claude-opus-5`, `claude-bridge/claude-opus-4-8`, `claude-bridge/claude-opus-4-7`, `claude-bridge/claude-opus-4-6`, `claude-bridge/claude-sonnet-5`, `claude-bridge/claude-sonnet-4-6`, or `claude-bridge/claude-haiku-4-5`. The `fable` shortcut resolves to Fable 5.1. Fable 5.1 needs Claude Code **2.1.251 or newer**; if the SDK's bundled CLI is older, set `provider.pathToClaudeCodeExecutable` to a current `claude` binary.
+Use `/model` to select `claude-bridge/claude-fable-5-1`, `claude-bridge/claude-fable-5`, `claude-bridge/claude-opus-5`, `claude-bridge/claude-opus-4-8`, `claude-bridge/claude-opus-4-7`, `claude-bridge/claude-opus-4-6`, `claude-bridge/claude-sonnet-5`, `claude-bridge/claude-sonnet-4-6`, or `claude-bridge/claude-haiku-4-5`. The `fable` shortcut resolves to Fable 5.1. Fable 5.1 needs Claude Code **2.1.251 or newer** (the SDK's bundled CLI is 2.1.257). If you point `provider.pathToClaudeCodeExecutable` at an older binary, or a later model outruns the bundle, the bridge uses a current `claude` on PATH when it finds one.
 
 Behind the scenes, pi's tools are bridged to Claude Code but it should all work like normal in pi. Bash commands get a 120-second default timeout (matching Claude Code's default) since pi's bash has no timeout by default. Skills in pi are copied over to Claude Code's system prompt so should work as they would with any other pi provider. Steering works mid-turn: a message sent while Claude is running a tool reaches it at that tool boundary, not after the whole turn finishes.
 
@@ -49,7 +49,7 @@ Config: `~/.pi/agent/claude-bridge.json` (global) or the project Pi config direc
 - `longContextExtraUsage` — set to `true` to enable 1M models that cost money through Extra Usage. It enables Sonnet 4.6 with 1M on every plan and Opus 4.6 with 1M on Pro. Not needed for Opus 4.7 or 4.8.
 - `strictMcpConfig` — block MCP servers from `~/.claude.json` / `.mcp.json` (default `true`). Cloud MCP (Gmail/Drive via claude.ai OAuth) is always blocked.
 - `autoMemoryEnabled` — enable Claude Code's auto-memory system (default `false`)
-- `pathToClaudeCodeExecutable` — path to the `claude` binary. Useful if your OS/filesystem has the SDK's bundled musl/glibc binaries in a place where they can't run. For example, with Nix you can set the binary to e.g. `"/home/you/.nix-profile/bin/claude"`.
+- `pathToClaudeCodeExecutable` — path to the `claude` binary. Useful if your OS/filesystem has the SDK's bundled musl/glibc binaries in a place where they can't run, or to pin a specific CLI. For example, with Nix you can set the binary to e.g. `"/home/you/.nix-profile/bin/claude"`.
 
 **Extension providers and models.json:** pi's `modelOverrides` in `~/.pi/agent/models.json` do not currently apply to extension-registered providers (like claude-bridge). Overriding `contextWindow` or other fields requires editing `src/models.ts` directly.
 
@@ -66,7 +66,7 @@ Integration tests spawn real `pi` and Claude Code subprocesses, so they need wri
 Set `CLAUDE_BRIDGE_DEBUG=1` to enable debug output:
 
 - **Bridge log** at `~/.pi/agent/claude-bridge.log` — every provider call, session sync decision, tool result delivery, and CC's stderr. Override location with `CLAUDE_BRIDGE_DEBUG_PATH`.
-- **Per-query Claude Code CLI logs** at `~/.pi/agent/cc-cli-logs/<timestamp>-<tag>-<seq>.log` — the CC subprocess's own debug stream, one file per `query()` call. Tags are `provider` (main turn) or `compact-summary`. Useful when a resume fails or CC misbehaves internally — shows the CLI's own view of session loading, API requests, and tool calls.
+- **Per-query Claude Code CLI logs** at `~/.pi/agent/cc-cli-logs/<timestamp>-<tag>-<seq>.log` — the CC subprocess's own debug stream, one file per `query()` call. Tags are `provider` (resumable main turn) or `standalone` (compaction, branch summary, and tool-free extension-owned no-cache completion). Useful when a resume fails or CC misbehaves internally — shows the CLI's own view of session loading, API requests, and tool calls.
 
 When filing a bug about a session-resume failure (e.g. "No conversation found"), the most useful attachments are the `syncResult:` lines from the bridge log plus the matching `cc-cli-logs/` file for the failing query.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-agent-sdk",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "private": false,
   "description": "Pi extension that uses Claude Code (via Agent SDK) as a model provider.",
   "keywords": [
@@ -40,7 +40,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.257",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "cc-session-io": "^0.4.0",
     "change-case": "^5.4.4"
@@ -50,7 +50,7 @@
     "@earendil-works/pi-coding-agent": ">=0.82.1"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.73.0",
+    "@anthropic-ai/sdk": "^0.93.0",
     "@earendil-works/pi-ai": "^0.83.0",
     "@earendil-works/pi-coding-agent": "^0.83.0",
     "@types/node": "^24.13.2",

package/src/claude-executable.ts

@@ -0,0 +1,149 @@
+// Pick a Claude Code CLI that can actually serve the selected model.
+// The Agent SDK bundles its own binary (`claudeCodeVersion` in its package.json).
+// Some models (Fable 5.1) 400 against an older CLI; when the bundle is below
+// the model's minimum we use a current `claude` on PATH, matching what the
+// README already told people to set via pathToClaudeCodeExecutable.
+
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, join } from "node:path";
+import { minClaudeCodeVersionForModel } from "./models.js";
+
+const require = createRequire(import.meta.url);
+
+export type ClaudeVersion = { major: number; minor: number; patch: number };
+
+export type ClaudeExecutableSource = "configured" | "bundled" | "path";
+
+export type ClaudeExecutableResolution = {
+	/** Absolute path for the SDK, or undefined to use the bundled CLI. */
+	path?: string;
+	source: ClaudeExecutableSource;
+	/** Set when no available CLI meets the model's minimum version. */
+	error?: string;
+};
+
+export type ClaudeExecutableDeps = {
+	bundledVersion?: () => ClaudeVersion | undefined;
+	findOnPath?: () => string | undefined;
+	readVersion?: (executable: string) => ClaudeVersion | undefined;
+};
+
+const versionCache = new Map<string, ClaudeVersion | undefined>();
+
+export function parseClaudeVersion(text: string): ClaudeVersion | undefined {
+	const match = text.match(/(\d+)\.(\d+)\.(\d+)/);
+	if (!match) return undefined;
+	return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
+}
+
+export function formatClaudeVersion(version: ClaudeVersion): string {
+	return `${version.major}.${version.minor}.${version.patch}`;
+}
+
+export function compareClaudeVersion(a: ClaudeVersion, b: ClaudeVersion): number {
+	return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+
+export function readBundledClaudeCodeVersion(): ClaudeVersion | undefined {
+	try {
+		// The SDK does not export ./package.json; read the file next to its entry.
+		const pkgPath = join(dirname(require.resolve("@anthropic-ai/claude-agent-sdk")), "package.json");
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { claudeCodeVersion?: string };
+		return parseClaudeVersion(pkg.claudeCodeVersion ?? "");
+	} catch {
+		return undefined;
+	}
+}
+
+export function findExecutableOnPath(name: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
+	const pathEnv = env.PATH ?? env.Path;
+	if (!pathEnv) return undefined;
+	const exts = process.platform === "win32"
+		? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean)
+		: [""];
+	const names = process.platform === "win32" && !exts.some((ext) => name.toUpperCase().endsWith(ext.toUpperCase()))
+		? [name, ...exts.map((ext) => name + ext)]
+		: [name];
+	for (const dir of pathEnv.split(delimiter)) {
+		if (!dir) continue;
+		for (const candidateName of names) {
+			const candidate = join(dir, candidateName);
+			try {
+				accessSync(candidate, constants.X_OK);
+				return candidate;
+			} catch {}
+		}
+	}
+	return undefined;
+}
+
+export function readClaudeCliVersion(executable: string): ClaudeVersion | undefined {
+	if (versionCache.has(executable)) return versionCache.get(executable);
+	try {
+		const result = spawnSync(executable, ["--version"], {
+			encoding: "utf8",
+			timeout: 8000,
+			env: process.env,
+			windowsHide: true,
+		});
+		const version = parseClaudeVersion(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
+		versionCache.set(executable, version);
+		return version;
+	} catch {
+		versionCache.set(executable, undefined);
+		return undefined;
+	}
+}
+
+function tooOldError(modelId: string, min: ClaudeVersion, found: string): string {
+	return `${modelId} requires Claude Code ${formatClaudeVersion(min)} or newer (${found}). Install a current claude on PATH, or set provider.pathToClaudeCodeExecutable in ~/.pi/agent/claude-bridge.json.`;
+}
+
+export function resolveClaudeCodeExecutable(
+	modelId: string,
+	configured?: string,
+	deps: ClaudeExecutableDeps = {},
+): ClaudeExecutableResolution {
+	const bundledVersion = deps.bundledVersion ?? readBundledClaudeCodeVersion;
+	const findOnPath = deps.findOnPath ?? (() => findExecutableOnPath("claude"));
+	const readVersion = deps.readVersion ?? readClaudeCliVersion;
+	const minText = minClaudeCodeVersionForModel(modelId);
+	const min = minText ? parseClaudeVersion(minText) : undefined;
+
+	if (configured) {
+		if (min) {
+			const version = readVersion(configured);
+			if (version && compareClaudeVersion(version, min) < 0) {
+				return {
+					source: "configured",
+					error: tooOldError(modelId, min, `provider.pathToClaudeCodeExecutable is ${formatClaudeVersion(version)} at ${configured}`),
+				};
+			}
+		}
+		return { path: configured, source: "configured" };
+	}
+
+	if (!min) return { source: "bundled" };
+
+	const bundled = bundledVersion();
+	if (bundled && compareClaudeVersion(bundled, min) >= 0) {
+		return { source: "bundled" };
+	}
+
+	const pathClaude = findOnPath();
+	if (pathClaude) {
+		const version = readVersion(pathClaude);
+		if (version && compareClaudeVersion(version, min) >= 0) {
+			return { path: pathClaude, source: "path" };
+		}
+	}
+
+	if (bundled) {
+		return { source: "bundled", error: tooOldError(modelId, min, `bundled CLI is ${formatClaudeVersion(bundled)}`) };
+	}
+
+	// Bundle version unknown and PATH missing/unreadable: let the SDK try.
+	return { source: "bundled" };
+}

package/src/index.ts

@@ -1,7 +1,7 @@
 import { calculateCost, type AssistantMessage, type AssistantMessageEventStream, type Context, type ImageContent, type Model, type SimpleStreamOptions, type TextContent, type Tool, type UserMessage } from "@earendil-works/pi-ai";
 import * as piAi from "@earendil-works/pi-ai";
 import { getModels } from "@earendil-works/pi-ai/compat";
-import { compact, generateBranchSummary, type BranchSummaryResult, type CompactionEntry, type ExtensionAPI, type ExtensionContext, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionContext, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { query, type EffortLevel, type SDKMessage, type SettingSource } from "@anthropic-ai/claude-agent-sdk";
 import type { Base64ImageSource, ContentBlockParam } from "@anthropic-ai/sdk/resources";
 import { createSession, deleteSession, openSession, repairToolPairing } from "cc-session-io";
@@ -24,6 +24,7 @@ import {
 import { collectCarriedAttachments, placeCarriedAttachments, type CarriedAttachment } from "./attachments.js";
 import { createToolServer } from "./mcp-server.js";
 import { CC_CHILD_ENV, resolveClaudeChildEnv, type AnthropicAuthRegistry } from "./child-env.js";
+import { resolveClaudeCodeExecutable } from "./claude-executable.js";
 
 // Compat (#2): use factory if available (pi-ai ≥0.66), else fall back to constructor (gsd-pi etc.)
 const _piAi = piAi as any;
@@ -87,7 +88,7 @@ function debug(...args: unknown[]) {
 // Per-query CLI debug capture. When CLAUDE_BRIDGE_DEBUG=1, ask the Claude Code
 // CLI subprocess to write its own debug log to a file we choose, and also
 // forward its stderr into our debug stream. Drops straight into the real SDK's
-// Options — see @anthropic-ai/claude-agent-sdk sdk.d.ts:1245 (debug, debugFile,
+// Options — see @anthropic-ai/claude-agent-sdk sdk.d.ts:2091 (debug, debugFile,
 // stderr). Without this, CC's internal view of the world is invisible to us
 // and "No conversation found" / empty-error reports are unactionable.
 let nextCliDebugSeq = 1;
@@ -365,18 +366,33 @@ function newAssistantOutput(model: Model<any>, text: string, stopReason: Assista
 	};
 }
 
-function extractIsolatedSummaryPrompt(messages: Context["messages"]): string {
+function extractStandalonePrompt(context: Context): string {
+	if (context.tools?.length) {
+		throw new Error(`standalone provider requests do not support tools (got ${context.tools.length})`);
+	}
+	const messages = context.messages;
 	if (messages.length !== 1 || messages[0].role !== "user") {
 		throw new Error(
-			`isolatedStreamFn: expected exactly 1 user message, got ${messages.length} ` +
+			`standalone provider request expected exactly 1 user message, got ${messages.length} ` +
 			`(${messages.map((m) => m.role).join(",")})`,
 		);
 	}
 	const promptText = extractUserPrompt(messages);
-	if (!promptText) throw new Error("isolatedStreamFn: summarization prompt is empty");
+	if (!promptText) throw new Error("standalone provider request prompt is empty");
 	return promptText;
 }
 
+/** Pi marks summaries and extension-owned nested completions as no-cache,
+ * standalone requests. They must never enter the resumable provider path: its
+ * prompt capture and shared Claude Code session belong to the interactive
+ * agent, not to an unrelated planner or summarizer. */
+function isStandaloneRequest(context: Context, options?: SimpleStreamOptions): boolean {
+	return options?.cacheRetention === "none"
+		&& context.tools === undefined
+		&& context.messages.length === 1
+		&& context.messages[0]?.role === "user";
+}
+
 /** Failure text for an SDK result, or undefined when it succeeded. CC reports API failures
  *  (429 capacity, overload, prompt-too-long) with `is_error` on an otherwise success-shaped
  *  result; the dedicated error subtypes carry `errors` instead. */
@@ -406,13 +422,13 @@ function describeRateLimitFailure(rejection: { rateLimitType?: string; resetsAt?
 	return `Claude rate limit${kind}${resets}: ${failure}`;
 }
 
-function isolatedStreamFn(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+function standaloneStreamFn(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
 	const stream = newAssistantMessageEventStream();
-	void runIsolatedSummary(model, context, options, stream);
+	void runStandaloneRequest(model, context, options, stream);
 	return stream;
 }
 
-async function runIsolatedSummary(
+async function runStandaloneRequest(
 	model: Model<any>,
 	context: Context,
 	options: SimpleStreamOptions | undefined,
@@ -427,12 +443,20 @@ async function runIsolatedSummary(
 	};
 
 	try {
-		const promptText = extractIsolatedSummaryPrompt(context.messages);
+		const promptText = extractStandalonePrompt(context);
 		const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-		const compactProviderSettings = loadConfig(cwd).provider;
-		const claudeExecutable = compactProviderSettings?.pathToClaudeCodeExecutable;
+		const standaloneProviderSettings = loadConfig(cwd).provider;
+		const claudeExecutableResolution = resolveClaudeCodeExecutable(model.id, standaloneProviderSettings?.pathToClaudeCodeExecutable);
+		if (claudeExecutableResolution.error) throw new Error(claudeExecutableResolution.error);
+		const claudeExecutable = claudeExecutableResolution.path;
 		const cliModel = claudeCodeModelId(model, longContextSettings);
-		debug(`compact summary: spawn model=${cliModel} registeredModel=${model.id} promptLen=${promptText.length}`);
+		const effort = options?.reasoning
+			? ((model as any).thinkingLevelMap?.[options.reasoning] as EffortLevel | undefined)
+				?? REASONING_TO_EFFORT[options.reasoning]
+			: undefined;
+		const extraArgs: Record<string, string | null> = {};
+		if (effort || adaptiveThinkingAlwaysOn(model.id)) extraArgs["thinking-display"] = "summarized";
+		debug(`standalone: spawn model=${cliModel} registeredModel=${model.id} promptLen=${promptText.length} effort=${effort ?? "default"}`);
 		const childEnv = await resolveClaudeChildEnv(piModelRegistry);
 
 		sdkQuery = query({
@@ -449,8 +473,10 @@ async function runIsolatedSummary(
 				systemPrompt: context.systemPrompt,
 				model: cliModel,
 				maxTurns: 1,
+				extraArgs,
+				...(effort ? { effort } : {}),
 				...(claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {}),
-				...makeCliDebugOptions("compact-summary"),
+				...makeCliDebugOptions("standalone"),
 			},
 		});
 
@@ -462,11 +488,12 @@ async function runIsolatedSummary(
 		let assistantText = "";
 		let finalText = "";
 		let errorText: string | undefined;
+		let resultUsage: Record<string, number | undefined> | undefined;
 		let firstEventLogged = false;
 
 		for await (const message of sdkQuery) {
 			if (!firstEventLogged) {
-				debug(`compact summary: first event type=${message.type}`);
+				debug(`standalone: first event type=${message.type}`);
 				firstEventLogged = true;
 			}
 			if (wasAborted) break;
@@ -476,15 +503,16 @@ async function runIsolatedSummary(
 					if (block.type === "text" && typeof block.text === "string") assistantText += block.text;
 				}
 			} else if (message.type === "result") {
-				logServedContextWindow("compact summary", message, model);
+				logServedContextWindow("standalone", message, model);
 				errorText = resultErrorText(message);
+				resultUsage = (message as SDKMessage & { usage?: Record<string, number | undefined> }).usage;
 				if (!errorText && message.subtype === "success") finalText = message.result || assistantText;
 			}
 		}
 
 		if (wasAborted) {
 			const output = newAssistantOutput(model, "", "aborted", "Operation aborted");
-			debug("compact summary: aborted");
+			debug("standalone: aborted");
 			stream.push({ type: "error", reason: "aborted", error: output });
 			stream.end();
 			return;
@@ -492,19 +520,21 @@ async function runIsolatedSummary(
 
 		const text = finalText || assistantText;
 		if (errorText || !text.trim()) {
-			const msg = errorText ?? "Claude Code summary returned empty text";
-			debug(`compact summary: error ${msg}`);
+			const msg = errorText ?? "Claude Code standalone request returned empty text";
+			debug(`standalone: error ${msg}`);
 			stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", msg) });
 			stream.end();
 			return;
 		}
 
-		debug(`compact summary: done textLen=${text.length}`);
-		stream.push({ type: "done", reason: "stop", message: newAssistantOutput(model, text, "stop") });
+		const output = newAssistantOutput(model, text, "stop");
+		if (resultUsage) updateUsage(output, resultUsage, model);
+		debug(`standalone: done textLen=${text.length}`);
+		stream.push({ type: "done", reason: "stop", message: output });
 		stream.end();
 	} catch (err) {
 		const msg = errorMessage(err);
-		debug("runIsolatedSummary threw; pushing terminal error", err);
+		debug("runStandaloneRequest threw; pushing terminal error", err);
 		stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", msg) });
 		stream.end();
 	} finally {
@@ -513,17 +543,6 @@ async function runIsolatedSummary(
 	}
 }
 
-function reinjectPriorCompactionFileOps(branchEntries: Array<{ type: string; details?: unknown }>, preparation: { fileOps: { read: Set<string>; edited: Set<string> } }): void {
-	const prior = [...branchEntries]
-		.reverse()
-		.find((entry): entry is CompactionEntry => entry.type === "compaction");
-	const details = prior?.details as { readFiles?: unknown; modifiedFiles?: unknown } | undefined;
-	if (!Array.isArray(details?.readFiles) || !Array.isArray(details?.modifiedFiles)) return;
-	for (const file of details.readFiles) preparation.fileOps.read.add(String(file));
-	for (const file of details.modifiedFiles) preparation.fileOps.edited.add(String(file));
-	debug(`compact takeover: re-injected prior file ops read=${details.readFiles.length} modified=${details.modifiedFiles.length}`);
-}
-
 interface SyncResult {
 	sessionId: string | null;
 	preserveSharedSession?: boolean;
@@ -640,8 +659,8 @@ function syncSharedSession(
 	// the completion handler). Remove this branch and a subagent resumes — then
 	// overwrites — the parent's session.
 	//
-	// It is NOT, despite an earlier comment here, the isolated compact-summary
-	// path: runIsolatedSummary never calls syncSharedSession at all.
+	// It is not the standalone no-cache path: runStandaloneRequest never calls
+	// syncSharedSession at all.
 	//
 	// Only reachable when needsRebuild is false — user-facing history rewrites
 	// (/compact, session_tree, /new, fork) always set needsRebuild or clear
@@ -719,7 +738,8 @@ export const __test = {
 	drainForAbort,
 	CC_CHILD_ENV,
 	buildMcpServers,
-	branchSummaryOutcome,
+	isStandaloneRequest,
+	extractStandalonePrompt,
 };
 
 // --- Provider helpers: tool name mapping ---
@@ -830,25 +850,6 @@ function reportLeaks(label: string): void {
 	);
 }
 
-/** What pi's branch summary means for the navigation it was asked for.
- *
- *  Cancelling on failure matches pi's own path, which rethrows a summary error out
- *  of the navigation rather than moving without one. Separated from the event
- *  handler so this decision is testable without a Claude Code subprocess — driving
- *  `generateBranchSummary` itself would only be testing pi. */
-function branchSummaryOutcome(result: BranchSummaryResult): { cancel: true } | { summary: { summary: string; details: unknown; usage?: BranchSummaryResult["usage"] } } {
-	if (result.aborted) return { cancel: true };
-	if (result.error) throw new Error(result.error);
-	debug(`session_before_tree: takeover complete summaryLen=${result.summary?.length ?? 0}`);
-	return {
-		summary: {
-			summary: result.summary ?? "",
-			details: { readFiles: result.readFiles ?? [], modifiedFiles: result.modifiedFiles ?? [] },
-			usage: result.usage,
-		},
-	};
-}
-
 function contextForToolResults(results: McpResult[]): QueryContext | undefined {
 	for (const result of results) {
 		const id = result.toolCallId;
@@ -1421,9 +1422,15 @@ function drainForAbort(c: QueryContext, promptStream: PromptStream): void {
 	c.releasePendingToolCalls("Operation aborted");
 }
 
-/** Provider entry point. Pi calls this for each new prompt and each tool result.
- *  Two cases: tool result delivery (active query) or fresh query. */
+/** Provider entry point. Pi calls this for normal agent turns, but also for
+ * standalone no-cache completions made by compaction and extensions. Route the
+ * latter before touching prompt captures or resumable-session state. */
 function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+	if (isStandaloneRequest(context, options)) {
+		debug(`provider: routing standalone cacheRetention=none request to isolated subprocess`);
+		return standaloneStreamFn(model, context, options);
+	}
+
 	showStartupNoticeOnce();
 	const stream = newAssistantMessageEventStream();
 
@@ -1492,6 +1499,19 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 	const queryCtx = isReentrant ? new QueryContext() : ctx();
 	debug(`provider: fresh query setup, isReentrant=${isReentrant}, activeContexts=${activeQueryContexts.size}`);
 
+	// Fail before claiming a stream if this model needs a newer CLI than we have.
+	const claudeExecutableResolution = resolveClaudeCodeExecutable(model.id, providerSettings.pathToClaudeCodeExecutable);
+	if (claudeExecutableResolution.error) {
+		debug(`provider: ${claudeExecutableResolution.error}`);
+		stream.push({ type: "error", reason: "error", error: newAssistantOutput(model, "", "error", claudeExecutableResolution.error) });
+		stream.end();
+		return stream;
+	}
+	const claudeExecutable = claudeExecutableResolution.path;
+	if (claudeExecutableResolution.source === "path") {
+		debug(`provider: using PATH claude ${claudeExecutable} (bundled CLI is too old for ${model.id})`);
+	}
+
 	// Resolved first: an unaccountable system prompt throws, and doing that before
 	// anything is claimed or reset leaves no half-built query behind — in particular
 	// no stream claimed on the shared context that nobody will ever end.
@@ -1561,7 +1581,6 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 	// programmatically and ignore filesystem MCP entries — applied unconditionally because
 	// settingSources is left at CC's default, which loads all sources.
 	const strictMcpConfigEnabled = providerSettings.strictMcpConfig !== false;
-	const claudeExecutable = providerSettings.pathToClaudeCodeExecutable;
 
 	// Prefer the model's own thinkingLevelMap when present (pi-ai 0.72+ ships
 	// per-model overrides — e.g. opus-4-7 wants xhigh→xhigh, not xhigh→max).
@@ -1813,39 +1832,6 @@ export default function (pi: ExtensionAPI) {
 		clearSession("session_shutdown");
 	});
 
-	pi.on("session_before_compact", async (event, ctx) => {
-		if (ctx.model?.baseUrl !== "claude-bridge") return undefined;
-		debug(
-			`session_before_compact: takeover reason=${event.reason} willRetry=${event.willRetry} ` +
-			`isSplitTurn=${event.preparation.isSplitTurn} messages=${event.preparation.messagesToSummarize.length} ` +
-			`turnPrefix=${event.preparation.turnPrefixMessages.length}`,
-		);
-		try {
-			reinjectPriorCompactionFileOps(event.branchEntries, event.preparation);
-			const compaction = await compact(
-				event.preparation,
-				ctx.model,
-				undefined,
-				undefined,
-				event.customInstructions,
-				event.signal,
-				undefined,
-				isolatedStreamFn,
-				undefined,
-			);
-			debug(`session_before_compact: takeover complete summaryLen=${compaction.summary.length}`);
-			return { compaction };
-		} catch (err) {
-			const msg = errorMessage(err);
-			debug("session_before_compact: takeover failed; cancelling to avoid native compact fallback", err);
-			ctx.ui?.notify?.(
-				`pi-claude-agent-sdk compact failed (${msg}); cancelled to avoid known hang. Retry, switch model, or reduce context.`,
-				"error",
-			);
-			return { cancel: true };
-		}
-	});
-
 	// pi /compact and session-tree navigation (rewind / fork-at-point /
 	// branch switch) both mutate pi's messages array out from under the
 	// bridge. syncSharedSession's REUSE check would otherwise see
@@ -1862,38 +1848,6 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_compact", (event) => markRebuild(`session_compact:${event.reason}:willRetry=${event.willRetry}`));
 	pi.on("session_tree", () => markRebuild("session_tree"));
 
-	// Branch summarization — rewind or fork-at-point with "summarize" — is the other
-	// place pi asks the model for a summary, and unlike compaction it runs through
-	// the *agent's* stream function (agent-session passes `streamFn:
-	// this.agent.streamFunction`). On a bridge model that reaches this provider
-	// carrying pi's internal summarization prompt, which no `before_agent_start`
-	// ever recorded, so the prompt-capture resolver has nothing to resolve it to.
-	// Take it over the way compaction is taken over: the summary runs as its own
-	// Claude Code subprocess, never touching the live session or the resolver.
-	pi.on("session_before_tree", async (event, ctx) => {
-		if (ctx.model?.baseUrl !== "claude-bridge") return undefined;
-		const { entriesToSummarize, userWantsSummary, customInstructions, replaceInstructions } = event.preparation;
-		if (!userWantsSummary || entriesToSummarize.length === 0) return undefined;
-		debug(`session_before_tree: takeover entries=${entriesToSummarize.length} target=${event.preparation.targetId.slice(0, 8)}`);
-		try {
-			const result = await generateBranchSummary(entriesToSummarize, {
-				model: ctx.model,
-				signal: event.signal,
-				customInstructions,
-				replaceInstructions,
-				streamFn: isolatedStreamFn,
-			});
-			return branchSummaryOutcome(result);
-		} catch (err) {
-			debug("session_before_tree: takeover failed; cancelling navigation", err);
-			ctx.ui?.notify?.(
-				`pi-claude-agent-sdk branch summary failed (${errorMessage(err)}); navigation cancelled.`,
-				"error",
-			);
-			return { cancel: true };
-		}
-	});
-
 	// --- Provider ---
 	//
 	// Guard against re-registration when the module is loaded multiple times

package/src/models.ts

@@ -120,6 +120,14 @@ export function thinkingBoundToPrefix(modelId: string): boolean {
 	return modelId === "claude-fable-5-1" || modelId.startsWith("claude-fable-5-1[");
 }
 
+/** Minimum Claude Code CLI version that will accept this model. Undefined
+ *  means the SDK's bundled CLI is fine. Fable 5.1 400s on 2.1.141 with
+ *  "version 2.1.251 or newer is required". */
+export function minClaudeCodeVersionForModel(modelId: string): string | undefined {
+	if (modelId === "claude-fable-5-1" || modelId.startsWith("claude-fable-5-1[")) return "2.1.251";
+	return undefined;
+}
+
 export function resolveModel<T extends { id: string }>(models: T[], input: string): T | undefined {
 	const lower = input.toLowerCase();
 	// Exact match first: otherwise `claude-fable-5` would hit `claude-fable-5-1`