@oh-my-pi/pi-coding-agent 17.3.4 → 17.3.5

package/src/launch/presence.ts

@@ -1,9 +1,19 @@
+import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEisdir, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { isEisdir, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import { daemonRuntimeDir } from "./paths";
 
 const CLIENTS_DIR = "clients";
+const BROKER_PID_FILE = "broker.pid";
+const GLOBAL_DAEMON_DIR = "global";
+/**
+ * Grace before a dead daemon runtime dir becomes prune-eligible. Guards against
+ * deleting a scope whose owning omp process is mid-startup (token written, broker
+ * not yet spawned, presence not yet registered). The leak this reclaims is a
+ * weeks-scale accumulation, so a few minutes of slack costs nothing.
+ */
+const DAEMON_RUNTIME_STALE_GRACE_MS = 5 * 60_000;
 
 /** Handle keeping one omp process registered in a project daemon scope. */
 export interface DaemonProjectPresence {
@@ -80,3 +90,69 @@ export async function hasLiveDaemonProjectPresence(runtimeDir: string): Promise<
 	}
 	return live;
 }
+
+/** Whether a runtime dir's recorded broker PID is still alive. */
+async function hasLiveDaemonBroker(runtimeDir: string): Promise<boolean> {
+	let raw: unknown;
+	try {
+		raw = await Bun.file(path.join(runtimeDir, BROKER_PID_FILE)).json();
+	} catch {
+		return false; // Missing or malformed broker.pid => no owning broker.
+	}
+	if (typeof raw !== "object" || raw === null || !("pid" in raw) || typeof raw.pid !== "number") {
+		return false;
+	}
+	try {
+		process.kill(raw.pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Remove sibling project daemon runtime directories whose broker is dead and
+ * whose client-presence set is empty, reclaiming the disk that short-lived
+ * project directories leave behind (issue #8674).
+ *
+ * Best-effort and non-throwing: a scope is deleted only when its `broker.pid`
+ * is absent/dead, no live client presence remains, and it has been untouched
+ * for {@link DAEMON_RUNTIME_STALE_GRACE_MS}. The caller's own `currentRuntimeDir`
+ * and the machine-global daemon container are always skipped.
+ */
+export async function pruneDeadDaemonRuntimeDirs(currentRuntimeDir: string): Promise<void> {
+	const root = path.dirname(currentRuntimeDir);
+	if (path.basename(root) === GLOBAL_DAEMON_DIR) return;
+	const current = path.resolve(currentRuntimeDir);
+	let entries: Dirent[];
+	try {
+		entries = await fs.readdir(root, { withFileTypes: true });
+	} catch (error) {
+		if (!isEnoent(error)) {
+			logger.warn("Failed to scan daemon runtime root for pruning", {
+				root,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return;
+	}
+	const now = Date.now();
+	for (const entry of entries) {
+		if (!entry.isDirectory() || entry.name === GLOBAL_DAEMON_DIR) continue;
+		const dir = path.join(root, entry.name);
+		if (path.resolve(dir) === current) continue;
+		try {
+			const stat = await fs.stat(dir);
+			if (now - stat.mtimeMs < DAEMON_RUNTIME_STALE_GRACE_MS) continue;
+			if (await hasLiveDaemonBroker(dir)) continue;
+			if (await hasLiveDaemonProjectPresence(dir)) continue;
+			await fs.rm(dir, { recursive: true, force: true });
+		} catch (error) {
+			if (isEnoent(error)) continue;
+			logger.warn("Failed to prune dead daemon runtime dir", {
+				dir,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+}

package/src/lsp/client.ts

@@ -62,13 +62,32 @@ export function setIdleTimeout(ms: number | null | undefined): void {
 	}
 }
 
+/**
+ * Whether a client may be reaped by the idle checker.
+ *
+ * A client with in-flight requests is *busy*, never idle. `lastActivity` is
+ * stamped when a request is written, not while it is outstanding, so a single
+ * request that runs longer than the idle timeout used to look like silence:
+ * the checker tore the client down mid-flight and `shutdownClientInstance`
+ * rejected the caller's still-pending promise with "LSP client shutdown"
+ * (issue #8390). Requests that settle refresh `lastActivity`, so a client
+ * becomes eligible again only after the final one lands and the full idle
+ * window then elapses.
+ *
+ * Exported for tests; the idle checker is the only production caller.
+ */
+export function isIdleClient(client: LspClient, now: number, timeoutMs: number): boolean {
+	if (client.pendingRequests.size > 0) return false;
+	return now - client.lastActivity > timeoutMs;
+}
+
 function startIdleChecker(): void {
 	if (idleCheckInterval) return;
 	idleCheckInterval = setInterval(() => {
 		if (!idleTimeoutMs) return;
 		const now = Date.now();
 		for (const [key, client] of Array.from(clients.entries())) {
-			if (now - client.lastActivity > idleTimeoutMs) {
+			if (isIdleClient(client, now, idleTimeoutMs)) {
 				void shutdownClient(key);
 			}
 		}
@@ -746,7 +765,13 @@ function commandBasename(command: string): string {
 	return separator === -1 ? command : command.slice(separator + 1);
 }
 
-function isRustAnalyzerClient(client: LspClient): boolean {
+/**
+ * True when this client speaks the rust-analyzer protocol, detected by the
+ * command basename (`rust-analyzer[.exe]`) of the configured or resolved
+ * binary. Callers use it to gate rust-analyzer-only requests such as
+ * `rust-analyzer/reloadWorkspace` (see {@link reloadServer}).
+ */
+export function isRustAnalyzerClient(client: LspClient): boolean {
 	return (
 		commandBasename(client.config.command) === "rust-analyzer" ||
 		(client.config.resolvedCommand ? commandBasename(client.config.resolvedCommand) === "rust-analyzer" : false)
@@ -1456,15 +1481,22 @@ export async function sendRequest(
 		}
 	}
 
-	// Register pending request with timeout wrapper
+	// Register pending request with timeout wrapper.
+	// Settling stamps `lastActivity`: the idle window must be measured from when
+	// the exchange finished, not from when it started. Without this a request
+	// that outlives the timeout would leave the client instantly reapable the
+	// moment it lands, so the next idle sweep would kill a server that had just
+	// answered (issue #8390).
 	client.pendingRequests.set(id, {
 		resolve: result => {
 			if (timeout) clearTimeout(timeout);
+			client.lastActivity = Date.now();
 			cleanup();
 			resolve(result);
 		},
 		reject: err => {
 			if (timeout) clearTimeout(timeout);
+			client.lastActivity = Date.now();
 			cleanup();
 			reject(err);
 		},

package/src/lsp/clients/biome-client.ts

@@ -14,14 +14,21 @@ interface BiomeJsonOutput {
 	diagnostics: BiomeDiagnostic[];
 }
 
+/**
+ * A single diagnostic from Biome's `--reporter=json` output (Biome 2.x).
+ *
+ * Positions are 1-indexed `{ line, column }` pairs; the path is a plain string
+ * relative to the CLI's cwd. Older releases used byte-offset `span`s, which
+ * this client no longer parses.
+ */
 interface BiomeDiagnostic {
 	category: string; // e.g., "lint/correctness/noUnusedVariables"
-	severity: "error" | "warning" | "info" | "hint";
-	description: string;
+	severity: string; // "error" | "warning" | "info" | "hint"
+	message: string;
 	location?: {
-		path?: { file: string };
-		span?: [number, number]; // [startOffset, endOffset] in bytes
-		sourceCode?: string;
+		path?: string;
+		start?: { line: number; column: number };
+		end?: { line: number; column: number };
 	};
 }
 
@@ -29,43 +36,6 @@ interface BiomeDiagnostic {
 // Helpers
 // =============================================================================
 
-/**
- * Convert byte offsets to line:column positions in a single pass over the source.
- */
-function offsetsToPositions(source: string, offsets: number[]): Map<number, { line: number; column: number }> {
-	const sorted = [...new Set(offsets)].sort((a, b) => a - b);
-	const result = new Map<number, { line: number; column: number }>();
-	let line = 1;
-	let column = 1;
-	let byteIndex = 0;
-	let next = 0;
-
-	for (const ch of source) {
-		if (next >= sorted.length) break;
-		const cp = ch.codePointAt(0) as number;
-		const byteLen = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
-		while (next < sorted.length && byteIndex + byteLen > sorted[next]) {
-			result.set(sorted[next], { line, column });
-			next++;
-		}
-		if (ch === "\n") {
-			line++;
-			column = 1;
-		} else {
-			column++;
-		}
-		byteIndex += byteLen;
-	}
-
-	// Offsets at or past end-of-file map to the final position.
-	while (next < sorted.length) {
-		result.set(sorted[next], { line, column });
-		next++;
-	}
-
-	return result;
-}
-
 /**
  * Parse Biome severity to LSP DiagnosticSeverity.
  */
@@ -176,8 +146,6 @@ export class BiomeClient implements LinterClient {
 	 * Parse Biome's JSON output into LSP Diagnostics.
 	 */
 	#parseJsonOutput(jsonOutput: string, targetFile: string): Diagnostic[] {
-		const diagnostics: Diagnostic[] = [];
-
 		let parsed: BiomeJsonOutput;
 		try {
 			parsed = JSON.parse(jsonOutput);
@@ -186,61 +154,36 @@ export class BiomeClient implements LinterClient {
 				cwd: this.cwd,
 				file: targetFile,
 			});
-			return diagnostics;
+			return [];
 		}
 
+		const emitted = parsed.diagnostics ?? [];
 		const target = path.resolve(targetFile);
-		const relevant: BiomeDiagnostic[] = [];
-		// Batch all span offsets per source text so each source is scanned once
-		// instead of twice per diagnostic.
-		const offsetsBySource = new Map<string, number[]>();
-		for (const diag of parsed.diagnostics ?? []) {
-			const location = diag.location;
-			if (!location?.path?.file) continue;
-
-			// Resolve file path
-			const diagFile = path.isAbsolute(location.path.file)
-				? location.path.file
-				: path.join(this.cwd, location.path.file);
-
-			// Only include diagnostics for the target file
-			if (path.resolve(diagFile) !== target) {
-				continue;
-			}
+		const diagnostics: Diagnostic[] = [];
+		// Biome's JSON reporter is experimental and may reshape its output in
+		// patch releases. Track whether any diagnostic carried a usable location
+		// so a schema drift surfaces as a warning instead of a silent empty list.
+		let sawUsableLocation = false;
 
-			relevant.push(diag);
-			if (location.span && location.sourceCode) {
-				const offsets = offsetsBySource.get(location.sourceCode);
-				if (offsets) offsets.push(location.span[0], location.span[1]);
-				else offsetsBySource.set(location.sourceCode, [location.span[0], location.span[1]]);
-			}
-		}
+		for (const diag of emitted) {
+			const location = diag.location;
+			const filePath = location?.path;
+			if (!filePath) continue;
+			sawUsableLocation = true;
 
-		const positionsBySource = new Map<string, Map<number, { line: number; column: number }>>();
-		for (const [source, offsets] of offsetsBySource) {
-			positionsBySource.set(source, offsetsToPositions(source, offsets));
-		}
+			// Biome reports paths relative to its cwd.
+			const diagFile = path.isAbsolute(filePath) ? filePath : path.join(this.cwd, filePath);
 
-		for (const diag of relevant) {
-			const location = diag.location;
-			let startLine = 1;
-			let startColumn = 1;
-			let endLine = 1;
-			let endColumn = 1;
+			// Only include diagnostics for the target file.
+			if (path.resolve(diagFile) !== target) continue;
 
-			if (location?.span && location.sourceCode) {
-				const positions = positionsBySource.get(location.sourceCode);
-				const startPos = positions?.get(location.span[0]);
-				const endPos = positions?.get(location.span[1]);
-				if (startPos) {
-					startLine = startPos.line;
-					startColumn = startPos.column;
-				}
-				if (endPos) {
-					endLine = endPos.line;
-					endColumn = endPos.column;
-				}
-			}
+			// Biome positions are 1-indexed; LSP ranges are 0-indexed.
+			const start = location.start;
+			const end = location.end ?? start;
+			const startLine = start?.line ?? 1;
+			const startColumn = start?.column ?? 1;
+			const endLine = end?.line ?? startLine;
+			const endColumn = end?.column ?? startColumn;
 
 			diagnostics.push({
 				range: {
@@ -248,12 +191,23 @@ export class BiomeClient implements LinterClient {
 					end: { line: endLine - 1, character: endColumn - 1 },
 				},
 				severity: parseSeverity(diag.severity),
-				message: diag.description,
+				message: diag.message,
 				source: "biome",
 				code: diag.category,
 			});
 		}
 
+		// Non-empty output whose diagnostics all lacked a recognizable location
+		// means the reporter schema changed out from under us — warn loudly
+		// instead of masking the regression as "no lint issues".
+		if (emitted.length > 0 && !sawUsableLocation) {
+			warnBiomeOnce(
+				`schema:${this.cwd}`,
+				"Biome diagnostics had no recognizable location; reporter schema may have changed",
+				{ cwd: this.cwd, file: targetFile, count: emitted.length },
+			);
+		}
+
 		return diagnostics;
 	}
 

package/src/lsp/servers.ts

@@ -4,6 +4,7 @@ import {
 	getActiveClients,
 	getActiveOrPendingClient,
 	getOrCreateClient,
+	isRustAnalyzerClient,
 	type LspServerStatus,
 	notifySaved,
 	sendNotification,
@@ -256,17 +257,22 @@ export function isMethodNotFoundError(err: unknown): boolean {
 
 export async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
 	throwIfAborted(signal);
-	// rust-analyzer exposes a real reload request. Every other server rejects it
-	// with method-not-found — that alone justifies the generic fallback. A caller
-	// cancel or tool timeout must propagate, never be mistaken for an unsupported
-	// method and swallowed into a bogus "Restarted" (issue #6369).
-	try {
-		await sendRequest(client, "rust-analyzer/reloadWorkspace", null, signal);
-		return `Reloaded ${serverName}`;
-	} catch (err) {
-		throwIfAborted(signal);
-		if (!isMethodNotFoundError(err)) throw err;
-		// Method not supported — fall through to the generic reload.
+	// rust-analyzer exposes a real reload request. Only rust-analyzer implements
+	// it, so gate the request on the binary (or registered name) rather than
+	// probing every server: some servers (Roslyn) crash the whole process on an
+	// unknown method instead of replying with method-not-found — killing the
+	// server `lsp reload` was meant to refresh (issue #8571, dotnet/roslyn#84890).
+	// A caller cancel or tool timeout must propagate, never be mistaken for an
+	// unsupported method and swallowed into a bogus "Restarted" (issue #6369).
+	if (isRustAnalyzerClient(client) || serverName === "rust-analyzer") {
+		try {
+			await sendRequest(client, "rust-analyzer/reloadWorkspace", undefined, signal);
+			return `Reloaded ${serverName}`;
+		} catch (err) {
+			throwIfAborted(signal);
+			if (!isMethodNotFoundError(err)) throw err;
+			// Method not supported — fall through to the generic reload.
+		}
 	}
 	// workspace/didChangeConfiguration is a notification per spec; sending it
 	// as a request hangs until the tool deadline on servers that route it to

package/src/lsp/tool.ts

@@ -21,6 +21,7 @@ import {
 	ensureFileOpen,
 	getActiveClients,
 	getOrCreateClient,
+	isRustAnalyzerClient,
 	type LspServerStatus,
 	refreshFile,
 	sendNotification,
@@ -1075,10 +1076,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		try {
 			const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 			const targetFile = resolvedFile;
-			const isRustAnalyzerServer =
-				serverName === "rust-analyzer" ||
-				path.basename(serverConfig.command) === "rust-analyzer" ||
-				(serverConfig.resolvedCommand ? path.basename(serverConfig.resolvedCommand) === "rust-analyzer" : false);
+			const isRustAnalyzerServer = isRustAnalyzerClient(client) || serverName === "rust-analyzer";
 			const needsProjectIndex =
 				targetFile !== null && PROJECT_INDEXED_ACTIONS.has(action) && isProjectAwareLspServer(serverConfig);
 			const rustWorkspaceWait =

package/src/lsp/workspace-diagnostics.ts

@@ -114,6 +114,17 @@ async function detectProjectType(cwd: string, signal?: AbortSignal): Promise<Pro
 	return { type: "unknown", description: "Unknown project type" };
 }
 
+/** Interpret an empty checker result without mistaking a crash for a clean workspace. */
+export function interpretEmptyDiagnosticsResult(
+	exitCode: number,
+	signalCode: string | null,
+	command: readonly string[],
+): string {
+	if (exitCode === 0) return "No issues found";
+	const detail = signalCode ? `was killed by ${signalCode}` : `exited with code ${exitCode}`;
+	return `Failed to run ${command.join(" ")}: the checker ${detail} without reporting anything, so the workspace was not verified`;
+}
+
 /** Run workspace diagnostics command and parse output */
 export async function runWorkspaceDiagnostics(
 	cwd: string,
@@ -146,11 +157,22 @@ export async function runWorkspaceDiagnostics(
 				new Response(proc.stdout).text(),
 				new Response(proc.stderr).text(),
 			]);
-			await proc.exited;
+			const exitCode = await proc.exited;
 			throwIfAborted(signal);
 			const combined = (stdout + stderr).trim();
 			if (!combined) {
-				return { output: "No issues found", projectType };
+				// A checker that exits non-zero without writing a single byte never
+				// inspected the workspace: it failed to start (missing toolchain),
+				// crashed, or was killed (OOM). Reporting "No issues found" there
+				// tells the agent the workspace is clean when nothing actually
+				// checked it. A non-zero exit *with* output is the normal way
+				// tsc/cargo/pyright report diagnostics and still falls through to
+				// the branch below. Mirrors the exit-status gate
+				// `resolveGoWorkspaceDiagnosticsCommand` already applies above.
+				return {
+					output: interpretEmptyDiagnosticsResult(exitCode, proc.signalCode, projectType.command),
+					projectType,
+				};
 			}
 			// Limit output length
 			const lines = combined.split("\n");

package/src/mcp/config.ts

@@ -224,6 +224,43 @@ export function extractExaApiKey(config: MCPServerConfig): string | undefined {
 	return undefined;
 }
 
+/** Exa MCP tools already covered by the native Exa integration. */
+const NATIVE_EXA_MCP_TOOLS: Record<string, true> = { web_search_exa: true };
+
+/**
+ * Parse the comma-separated `tools` restriction from an Exa MCP config.
+ * Returns `null` when the config does not restrict its tool set.
+ */
+function getRequestedExaMcpTools(config: MCPServerConfig): string[] | null {
+	const raw = (() => {
+		if (config.type === "http" || config.type === "sse") {
+			const httpConfig = config as { url?: string };
+			if (!httpConfig.url) return undefined;
+			try {
+				return new URL(httpConfig.url).searchParams.get("tools") ?? undefined;
+			} catch {
+				return undefined;
+			}
+		}
+		if (!config.type || config.type === "stdio") {
+			const stdioConfig = config as { args?: string[] };
+			const args = stdioConfig.args ?? [];
+			for (let i = 0; i < args.length; i++) {
+				if (/^--?tools$/i.test(args[i])) return args[i + 1];
+				const match = args[i].match(/(?:^|[\s?&])tools=([^&\s]+)/i) ?? args[i].match(/--?tools[=\s]([^\s]+)/i);
+				if (match) return match[1];
+			}
+		}
+		return undefined;
+	})();
+	if (!raw) return null;
+	const tools = raw
+		.split(",")
+		.map(tool => tool.trim())
+		.filter(tool => tool.length > 0);
+	return tools.length > 0 ? tools : null;
+}
+
 /** Result of filtering Exa MCP servers */
 export interface ExaFilterResult {
 	/** Configs with Exa servers removed */
@@ -236,7 +273,9 @@ export interface ExaFilterResult {
 
 /**
  * Filter out Exa MCP servers and extract their API keys.
- * Since we have native Exa integration, we don't need the MCP server.
+ * Since we have native Exa integration, we don't need the MCP server —
+ * unless the config explicitly requests Exa tools the native integration
+ * does not provide (e.g. `web_fetch_exa`, `web_search_advanced_exa`).
  */
 export function filterExaMCPServers(
 	configs: Record<string, MCPServerConfig>,
@@ -248,17 +287,22 @@ export function filterExaMCPServers(
 
 	for (const [name, config] of Object.entries(configs)) {
 		if (isExaMCPServer(name, config)) {
-			// Extract API key before filtering
+			// Extract API key for the native Exa integration even when the MCP
+			// server is kept below for its extra tools.
 			const apiKey = extractExaApiKey(config);
 			if (apiKey) {
 				exaApiKeys.push(apiKey);
 			}
-		} else {
-			filtered[name] = config;
-			if (sources[name]) {
-				filteredSources[name] = sources[name];
+			const requested = getRequestedExaMcpTools(config);
+			const hasExtraTools = requested?.some(tool => !NATIVE_EXA_MCP_TOOLS[tool.toLowerCase()]) ?? false;
+			if (!hasExtraTools) {
+				continue;
 			}
 		}
+		filtered[name] = config;
+		if (sources[name]) {
+			filteredSources[name] = sources[name];
+		}
 	}
 
 	return { configs: filtered, exaApiKeys, sources: filteredSources };

package/src/memories/index.ts

@@ -3,7 +3,7 @@ import type * as fsNode from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { type ApiKey, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { type ApiKey, completeSimple, Effort, type Model, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import { getAgentDbPath, getMemoriesDir, isEnoent, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
 
@@ -750,18 +750,20 @@ async function runStage1Job(options: {
 			response_items_json: truncatedItems,
 		});
 
-		const response = await completeSimple(
-			model,
-			{
-				systemPrompt: [stageOneSystemTemplate],
-				messages: [{ role: "user", content: [{ type: "text", text: inputPrompt }], timestamp: Date.now() }],
-			},
-			{
-				apiKey,
-				metadata: options.metadata,
-				maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
-				reasoning: clampThinkingLevelForModel(model, Effort.Low),
-			},
+		const response = await retryTransientCompletion(() =>
+			completeSimple(
+				model,
+				{
+					systemPrompt: [stageOneSystemTemplate],
+					messages: [{ role: "user", content: [{ type: "text", text: inputPrompt }], timestamp: Date.now() }],
+				},
+				{
+					apiKey,
+					metadata: options.metadata,
+					maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
+					reasoning: clampThinkingLevelForModel(model, Effort.Low),
+				},
+			),
 		);
 
 		if (response.stopReason === "error") {
@@ -887,18 +889,20 @@ async function runConsolidationModel(options: {
 		rollout_summaries: truncateByApproxTokens(rolloutSummaries, 12_000),
 	});
 
-	const response = await completeSimple(
-		model,
-		{
-			systemPrompt: [consolidationSystemTemplate],
-			messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
-		},
-		{
-			apiKey,
-			metadata: options.metadata,
-			maxTokens: 8192,
-			reasoning: clampThinkingLevelForModel(model, Effort.Medium),
-		},
+	const response = await retryTransientCompletion(() =>
+		completeSimple(
+			model,
+			{
+				systemPrompt: [consolidationSystemTemplate],
+				messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				metadata: options.metadata,
+				maxTokens: 8192,
+				reasoning: clampThinkingLevelForModel(model, Effort.Medium),
+			},
+		),
 	);
 	if (response.stopReason === "error") {
 		throw new Error(response.errorMessage || "phase2 model error");

package/src/mnemopi/backend.ts

@@ -1,6 +1,6 @@
 import { rm } from "node:fs/promises";
 import * as path from "node:path";
-import { type ApiKeyResolver, completeSimple } from "@oh-my-pi/pi-ai";
+import { type ApiKeyResolver, completeSimple, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { hostMatchesUrl } from "@oh-my-pi/pi-catalog/hosts";
 import type { Mnemopi } from "@oh-my-pi/pi-mnemopi";
 import type * as MnemopiDiagnoseNs from "@oh-my-pi/pi-mnemopi/diagnose";
@@ -545,16 +545,18 @@ async function resolveMnemopiProviderOptions(
 					});
 					return null;
 				}
-				const message = await completeSimple(
-					model,
-					{
-						messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
-					},
-					{
-						apiKey: modelRegistry.resolver(model, sessionId),
-						maxTokens: opts?.maxTokens,
-						temperature: opts?.temperature,
-					},
+				const message = await retryTransientCompletion(() =>
+					completeSimple(
+						model,
+						{
+							messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+						},
+						{
+							apiKey: modelRegistry.resolver(model, sessionId),
+							maxTokens: opts?.maxTokens,
+							temperature: opts?.temperature,
+						},
+					),
 				);
 				return message.content
 					.filter(