@diegopetrucci/pi-oracle 0.1.7 → 0.1.9

package/README.md

@@ -11,7 +11,7 @@ It adds an `oracle` tool that spins up a separate read-only pi subprocess and se
 - creates an isolated read-only subprocess
 - auto-picks the strongest reasoning model on the current provider
 - uses provider-specific hardcoded rankings first, then a heuristic fallback
-- sets reasoning/thinking to `xhigh` by default for reasoning models
+- requests `xhigh` by default for reasoning models, then clamps to the model-supported thinking level
 - defaults to `read,grep,find,ls`
 - can optionally allow non-mutating `bash` inspection
 - shows a live oracle status line and widget while the subprocess is running
@@ -27,7 +27,7 @@ By default, the extension:
 4. tries a provider-specific hardcoded priority list first
 5. falls back to a heuristic that favors stronger tiers like `opus`, `pro`, newer versions, and penalizes `mini`, `flash`, `haiku`, `spark`, etc.
 
-The hardcoded rankings now cover pi's built-in provider set, including OpenAI/Codex, Anthropic, Google variants, GitHub Copilot, Bedrock, Azure OpenAI Responses, Cloudflare, DeepSeek, Fireworks, Groq, Hugging Face, Kimi/Moonshot, MiniMax, Mistral, OpenCode, OpenRouter, Vercel AI Gateway, xAI, ZAI, and Cerebras.
+The hardcoded rankings now cover pi's built-in provider set, including Together; see the provider matrix for the current provider-by-provider top picks.
 
 If no reasoning model exists on the current provider, it falls back to the best available model on that provider.
 
@@ -35,9 +35,10 @@ If no reasoning model exists on the current provider, it falls back to the best
 
 Yes — the extension explicitly sets the oracle reasoning level.
 
-- reasoning models default to `xhigh`
+- reasoning models request `xhigh` by default, then use the Pi-compatible effective thinking level supported by the matched model
 - non-reasoning models default to `off`
-- you can override it with the tool's optional `thinkingLevel` parameter
+- you can override it with the tool's optional `thinkingLevel` parameter; matched models still clamp unsupported overrides and report the effective level
+- you can persist a default thinking level with `/oracle thinking <level>` so future automatic oracle tool calls use it when the agent does not pass a per-call override
 
 Use `/oracle-model` inside pi to see what it would pick right now.
 
@@ -81,12 +82,28 @@ Ask pi normally, for example:
 
 The main agent can call the tool directly.
 
+## User defaults
+
+Use `/oracle` to set persisted defaults that apply to future oracle tool calls, including calls the agent launches automatically without per-call overrides.
+
+```text
+/oracle status
+/oracle model anthropic/claude-opus-4-5
+/oracle thinking high
+/oracle thinking auto
+/oracle clear model
+/oracle clear thinking
+/oracle clear
+```
+
+Tool-call parameters still win over these defaults. `auto` clears the configured default and restores the built-in selection behavior. Preferences are saved under pi's agent directory in `extensions/oracle.json`.
+
 ## Tool parameters
 
 - `task` - required prompt for the oracle
 - `includeBash` - optional, adds `bash` for non-mutating inspection
-- `model` - optional explicit model override
-- `thinkingLevel` - optional reasoning/thinking override
+- `model` - optional explicit model override; falls back to the `/oracle model` default, then auto-selection
+- `thinkingLevel` - optional reasoning/thinking override; falls back to the `/oracle thinking` default, then built-in defaults
 - `cwd` - optional working directory override
 
 ## Notes

package/index.ts

@@ -1,12 +1,14 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { basename } from "node:path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { getMarkdownTheme, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, getMarkdownTheme, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+type ThinkingLevelMap = Partial<Record<ThinkingLevel, unknown | null>>;
 
 type PiModel = {
 	provider: string;
@@ -15,6 +17,7 @@ type PiModel = {
 	reasoning?: boolean;
 	contextWindow?: number;
 	maxTokens?: number;
+	thinkingLevelMap?: ThinkingLevelMap;
 };
 
 interface UsageStats {
@@ -33,6 +36,8 @@ interface OracleSelection {
 	modelId: string;
 	modelName?: string;
 	thinkingLevel: ThinkingLevel;
+	requestedThinkingLevel?: ThinkingLevel;
+	thinkingLevelClamped?: boolean;
 	autoSelected: boolean;
 	selectionReason: string;
 }
@@ -54,6 +59,11 @@ interface OracleUiRun {
 	preview?: string;
 }
 
+interface OraclePreferences {
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+}
+
 const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"];
 const READ_ONLY_PLUS_BASH_TOOLS = [...READ_ONLY_TOOLS, "bash"];
 const DEFAULT_THINKING_LEVEL: ThinkingLevel = "xhigh";
@@ -61,6 +71,7 @@ const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as
 const COLLAPSED_LINE_LIMIT = 8;
 const ORACLE_STATUS_ID = "oracle";
 const ORACLE_WIDGET_ID = "oracle";
+const ORACLE_CONFIG_FILE = "oracle.json";
 
 const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	"amazon-bedrock": [
@@ -294,6 +305,20 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"minimax/minimax-m2.1",
 		"z-ai/glm-5.1",
 	],
+	together: [
+		"deepseek-ai/DeepSeek-V4-Pro",
+		"zai-org/GLM-5.1",
+		"moonshotai/Kimi-K2.6",
+		"Qwen/Qwen3.6-Plus",
+		"MiniMaxAI/MiniMax-M2.7",
+		"Qwen/Qwen3.5-397B-A17B",
+		"Qwen/Qwen3-Coder-Next-FP8",
+		"Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+		"openai/gpt-oss-120b",
+		"moonshotai/Kimi-K2.5",
+		"deepseek-ai/DeepSeek-V3-1",
+		"MiniMaxAI/MiniMax-M2.5",
+	],
 	"vercel-ai-gateway": [
 		"anthropic/claude-opus-4.7",
 		"anthropic/claude-opus-4.6",
@@ -393,7 +418,7 @@ const OracleParams = Type.Object({
 	thinkingLevel: Type.Optional(
 		StringEnum(THINKING_LEVELS, {
 			description:
-				"Optional reasoning level override for the oracle subprocess. Default: xhigh for reasoning models, off for non-reasoning models.",
+				"Optional reasoning level override for the oracle subprocess. Defaults request xhigh for reasoning models and off for non-reasoning models, then clamp to matched model capabilities.",
 		}),
 	),
 	cwd: Type.Optional(Type.String({ description: "Optional working directory for the oracle subprocess." })),
@@ -411,6 +436,74 @@ function createEmptyUsage(): UsageStats {
 	};
 }
 
+function getOracleConfigPath(): string {
+	return path.join(getAgentDir(), "extensions", ORACLE_CONFIG_FILE);
+}
+
+function parseThinkingLevel(value: unknown): ThinkingLevel | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	return (THINKING_LEVELS as readonly string[]).includes(normalized) ? (normalized as ThinkingLevel) : undefined;
+}
+
+function normalizeModelPreference(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function parseModelPreference(value: unknown): { model?: string; thinkingLevel?: ThinkingLevel } {
+	const model = normalizeModelPreference(value);
+	if (!model) return {};
+	const match = model.match(/^(.*):(off|minimal|low|medium|high|xhigh)$/i);
+	if (!match?.[1]) return { model };
+	return { model: match[1], thinkingLevel: parseThinkingLevel(match[2]) };
+}
+
+async function readOraclePreferences(): Promise<OraclePreferences> {
+	try {
+		const raw = await fs.readFile(getOracleConfigPath(), "utf8");
+		const parsed = JSON.parse(raw) as {
+			model?: unknown;
+			defaultModel?: unknown;
+			thinkingLevel?: unknown;
+			defaultThinkingLevel?: unknown;
+		};
+		return {
+			model: parseModelPreference(parsed.model).model ?? parseModelPreference(parsed.defaultModel).model,
+			thinkingLevel:
+				parseThinkingLevel(parsed.thinkingLevel) ??
+				parseThinkingLevel(parsed.defaultThinkingLevel) ??
+				parseModelPreference(parsed.model).thinkingLevel ??
+				parseModelPreference(parsed.defaultModel).thinkingLevel,
+		};
+	} catch {
+		return {};
+	}
+}
+
+async function writeOraclePreferences(preferences: OraclePreferences): Promise<void> {
+	const configPath = getOracleConfigPath();
+	const config = {
+		...(preferences.model ? { model: preferences.model } : {}),
+		...(preferences.thinkingLevel ? { thinkingLevel: preferences.thinkingLevel } : {}),
+		updatedAt: new Date().toISOString(),
+	};
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+function formatOraclePreferences(preferences: OraclePreferences): string {
+	const model = preferences.model ?? "auto";
+	const thinkingLevel = preferences.thinkingLevel ?? "auto";
+	return `Oracle defaults: model=${model}, thinkingLevel=${thinkingLevel}. Config: ${getOracleConfigPath()}`;
+}
+
+function notifyCommand(ctx: any, message: string, kind = "info"): void {
+	if (ctx.hasUI && ctx.ui) ctx.ui.notify(message, kind);
+	else console.log(message);
+}
+
 function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
 	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
@@ -516,7 +609,7 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
 		return { command: process.execPath, args: [currentScript, ...args] };
 	}
 
-	const execName = basename(process.execPath).toLowerCase();
+	const execName = path.basename(process.execPath).toLowerCase();
 	const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
 	if (!isGenericRuntime) {
 		return { command: process.execPath, args };
@@ -530,9 +623,48 @@ function withThinking(modelRef: string, thinkingLevel: ThinkingLevel): string {
 	return `${modelRef}:${thinkingLevel}`;
 }
 
-function resolveThinkingLevel(model: PiModel | undefined, override: ThinkingLevel | undefined): ThinkingLevel {
-	if (override) return override;
-	return model?.reasoning ? DEFAULT_THINKING_LEVEL : "off";
+// Keep these local so the extension stays compatible with older pi peer installs that do not export clamp helpers.
+function isThinkingLevelSupported(model: PiModel, level: ThinkingLevel): boolean {
+	if (!model.reasoning) return level === "off";
+
+	const map = model.thinkingLevelMap;
+	if (level === "xhigh") {
+		return !!map && Object.prototype.hasOwnProperty.call(map, "xhigh") && map.xhigh != null;
+	}
+	return map?.[level] !== null;
+}
+
+function clampThinkingLevel(model: PiModel, requested: ThinkingLevel): ThinkingLevel {
+	if (isThinkingLevelSupported(model, requested)) return requested;
+
+	const requestedIndex = THINKING_LEVELS.indexOf(requested);
+	for (let index = requestedIndex + 1; index < THINKING_LEVELS.length; index++) {
+		const level = THINKING_LEVELS[index];
+		if (isThinkingLevelSupported(model, level)) return level;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index--) {
+		const level = THINKING_LEVELS[index];
+		if (isThinkingLevelSupported(model, level)) return level;
+	}
+
+	return "off";
+}
+
+function resolveThinkingLevel(
+	model: PiModel | undefined,
+	override: ThinkingLevel | undefined,
+): { requested: ThinkingLevel; effective: ThinkingLevel; clamped: boolean } {
+	const requested = override ?? (model?.reasoning ? DEFAULT_THINKING_LEVEL : "off");
+	const effective = model ? clampThinkingLevel(model, requested) : requested;
+	return { requested, effective, clamped: effective !== requested };
+}
+
+function appendThinkingLevelClampReason(
+	reason: string,
+	resolution: { requested: ThinkingLevel; effective: ThinkingLevel; clamped: boolean },
+): string {
+	if (!resolution.clamped) return reason;
+	return `${reason} Requested thinking level ${resolution.requested} was clamped to ${resolution.effective} based on the matched model's capabilities.`;
 }
 
 async function findAvailableModel(
@@ -599,9 +731,11 @@ async function selectOracleModel(
 
 	const preferred = selectPreferredModel(candidates, providerForPreferences);
 	const winner = preferred ?? [...candidates].sort((a, b) => rankModel(b) - rankModel(a))[0];
-	const selectionReason = preferred
-		? `Selected ${winner.id} via the hardcoded preference list for ${winner.provider}.`
-		: reason;
+	const thinking = resolveThinkingLevel(winner, thinkingLevelOverride);
+	const selectionReason = appendThinkingLevelClampReason(
+		preferred ? `Selected ${winner.id} via the hardcoded preference list for ${winner.provider}.` : reason,
+		thinking,
+	);
 
 	return {
 		ok: true,
@@ -610,7 +744,8 @@ async function selectOracleModel(
 			provider: winner.provider,
 			modelId: winner.id,
 			modelName: winner.name,
-			thinkingLevel: resolveThinkingLevel(winner, thinkingLevelOverride),
+			thinkingLevel: thinking.effective,
+			...(thinking.clamped ? { requestedThinkingLevel: thinking.requested, thinkingLevelClamped: true } : {}),
 			autoSelected: true,
 			selectionReason,
 		},
@@ -833,26 +968,147 @@ function renderCollapsedText(text: string, lineLimit = COLLAPSED_LINE_LIMIT): st
 
 export default function oracleExtension(pi: ExtensionAPI) {
 	const activeRuns = new Map<string, OracleUiRun>();
+	let preferences: OraclePreferences = {};
 
 	pi.on("session_start", async (_event, ctx) => {
+		preferences = await readOraclePreferences();
 		activeRuns.clear();
 		updateOracleUi(ctx, activeRuns);
 	});
 
+	pi.registerCommand("oracle", {
+		description: "Configure Oracle default model and thinking level for future oracle tool calls",
+		getArgumentCompletions: (prefix) => {
+			const parts = prefix.trim().toLowerCase().split(/\s+/).filter(Boolean);
+			const first = parts[0] ?? "";
+			if (parts.length <= 1) {
+				const commands = ["status", "model", "thinking", "clear"];
+				const matches = commands.filter((command) => command.startsWith(first));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			if (parts[0] === "thinking") {
+				const query = parts[1] ?? "";
+				const values = ["auto", ...THINKING_LEVELS];
+				const matches = values.filter((value) => value.startsWith(query));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			if (parts[0] === "clear") {
+				const query = parts[1] ?? "";
+				const values = ["all", "model", "thinking"];
+				const matches = values.filter((value) => value.startsWith(query));
+				return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+			}
+			return null;
+		},
+		handler: async (args, ctx) => {
+			const raw = args.trim();
+			const tokens = raw ? raw.split(/\s+/) : [];
+			const [command = "status", ...rest] = tokens;
+			const action = command.toLowerCase();
+			const configPath = getOracleConfigPath();
+
+			const save = async (next: OraclePreferences): Promise<string | undefined> => {
+				preferences = next;
+				try {
+					await writeOraclePreferences(preferences);
+					return undefined;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return `Preference changed for this process, but could not save ${configPath}: ${message}`;
+				}
+			};
+
+			if (action === "status" || action === "show") {
+				notifyCommand(ctx, formatOraclePreferences(preferences));
+				return;
+			}
+
+			if (action === "model") {
+				const model = rest.join(" ").trim();
+				const normalizedModelAction = model.toLowerCase();
+				if (!model) {
+					notifyCommand(ctx, "Usage: /oracle model <provider/model|auto>", "warning");
+					return;
+				}
+				if (normalizedModelAction === "auto" || normalizedModelAction === "clear" || normalizedModelAction === "default") {
+					const warning = await save({ ...preferences, model: undefined });
+					notifyCommand(ctx, `Oracle default model cleared; future oracle calls will auto-select. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+					return;
+				}
+				const parsedModel = parseModelPreference(model);
+				const next = {
+					...preferences,
+					model: parsedModel.model,
+					thinkingLevel: parsedModel.thinkingLevel ?? preferences.thinkingLevel,
+				};
+				const warning = await save(next);
+				notifyCommand(ctx, `Oracle default model set to ${parsedModel.model}. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "thinking" || action === "think" || action === "thinking-level") {
+				const value = rest[0]?.trim().toLowerCase();
+				if (!value) {
+					notifyCommand(ctx, `Usage: /oracle thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				if (value === "auto" || value === "clear" || value === "default") {
+					const warning = await save({ ...preferences, thinkingLevel: undefined });
+					notifyCommand(ctx, `Oracle default thinking level cleared; future oracle calls will use built-in defaults. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+					return;
+				}
+				const thinkingLevel = parseThinkingLevel(value);
+				if (!thinkingLevel) {
+					notifyCommand(ctx, `Usage: /oracle thinking ${THINKING_LEVELS.join(" | ")} | auto`, "warning");
+					return;
+				}
+				const warning = await save({ ...preferences, thinkingLevel });
+				notifyCommand(ctx, `Oracle default thinking level set to ${thinkingLevel}. ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			if (action === "clear" || action === "reset") {
+				const target = rest[0]?.trim().toLowerCase() || "all";
+				let next: OraclePreferences;
+				if (target === "all") next = {};
+				else if (target === "model") next = { ...preferences, model: undefined };
+				else if (target === "thinking" || target === "thinking-level") next = { ...preferences, thinkingLevel: undefined };
+				else {
+					notifyCommand(ctx, "Usage: /oracle clear [all|model|thinking]", "warning");
+					return;
+				}
+				const warning = await save(next);
+				notifyCommand(ctx, `Oracle defaults cleared (${target}). ${warning ?? formatOraclePreferences(preferences)}`, warning ? "warning" : "info");
+				return;
+			}
+
+			notifyCommand(ctx, "Usage: /oracle status | model <provider/model|auto> | thinking <off|minimal|low|medium|high|xhigh|auto> | clear [all|model|thinking]", "warning");
+		},
+	});
+
 	pi.registerCommand("oracle-model", {
 		description: "Show which model the oracle would use right now",
 		handler: async (_args, ctx) => {
-			const selectionResult = await selectOracleModel(ctx);
+			const defaultModel = parseModelPreference(preferences.model);
+			if (defaultModel.model) {
+				const matched = await findAvailableModel(ctx, defaultModel.model);
+				const thinking = resolveThinkingLevel(matched, preferences.thinkingLevel ?? defaultModel.thinkingLevel);
+				const modelRef = matched ? `${matched.provider}/${matched.id}` : defaultModel.model;
+				const suffix = matched
+					? appendThinkingLevelClampReason("Configured default oracle model is active.", thinking)
+					: "Configured default oracle model is active, but it was not matched against the authenticated model list.";
+				notifyCommand(ctx, `Oracle: ${modelRef} (${thinking.effective}) — ${suffix}`);
+				return;
+			}
+			const selectionResult = await selectOracleModel(ctx, preferences.thinkingLevel);
 			if (!selectionResult.ok) {
-				if (ctx.hasUI) ctx.ui.notify(selectionResult.error, "error");
-				else console.log(selectionResult.error);
+				notifyCommand(ctx, selectionResult.error, "error");
 				return;
 			}
 
 			const { selection } = selectionResult;
 			const message = `Oracle: ${selection.modelRef} (${selection.thinkingLevel}) — ${selection.selectionReason}`;
-			if (ctx.hasUI) ctx.ui.notify(message, "info");
-			else console.log(message);
+			notifyCommand(ctx, message);
 		},
 	});
 
@@ -867,11 +1123,16 @@ export default function oracleExtension(pi: ExtensionAPI) {
 			"Use this tool sparingly when you want a second opinion, deeper analysis, code review, debugging help, or a higher-reasoning pass.",
 			"Do not use it for routine low-value work; it is slower than the main agent.",
 			"The oracle is read-only by default. Set includeBash only when shell-based inspection is genuinely useful.",
-			"The oracle sets thinking to xhigh by default for reasoning models, unless the tool call explicitly overrides thinkingLevel.",
+			"The oracle requests xhigh by default for reasoning models; defaults and explicit thinkingLevel overrides are clamped to the effective model-supported level when the model is matched.",
 		],
 		parameters: OracleParams,
 
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const explicitModel = parseModelPreference(params.model);
+			const defaultModel = parseModelPreference(preferences.model);
+			const configuredModel = explicitModel.model ?? defaultModel.model;
+			const configuredThinkingLevel =
+				params.thinkingLevel ?? explicitModel.thinkingLevel ?? preferences.thinkingLevel ?? defaultModel.thinkingLevel;
 			const uiRun: OracleUiRun = {
 				task: params.task,
 				includeBash: params.includeBash ?? false,
@@ -882,25 +1143,38 @@ export default function oracleExtension(pi: ExtensionAPI) {
 
 			try {
 				let selection: OracleSelection;
-				if (params.model?.trim()) {
-					const modelRef = params.model.trim();
+				if (configuredModel) {
+					const modelRef = configuredModel;
 					const matched = await findAvailableModel(ctx, modelRef);
 					const provider =
 						matched?.provider ?? (modelRef.includes("/") ? modelRef.split("/")[0] : ctx.model?.provider ?? "unknown");
 					const modelId = matched?.id ?? (modelRef.includes("/") ? modelRef.split("/").slice(1).join("/") : modelRef);
+					const thinking = resolveThinkingLevel(matched, configuredThinkingLevel);
+					const usedToolOverride = !!explicitModel.model;
+					const selectionReason = matched
+						? appendThinkingLevelClampReason(
+							usedToolOverride
+								? "Used the explicit model override provided in the tool call."
+								: "Used the configured default oracle model.",
+							thinking,
+						)
+						: usedToolOverride
+							? "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied."
+							: "Used the configured default oracle model. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.";
 					selection = {
 						modelRef: matched ? `${matched.provider}/${matched.id}` : modelRef,
 						provider,
 						modelId,
 						modelName: matched?.name,
-						thinkingLevel: resolveThinkingLevel(matched, params.thinkingLevel),
+						thinkingLevel: thinking.effective,
+						...(matched && thinking.clamped
+							? { requestedThinkingLevel: thinking.requested, thinkingLevelClamped: true }
+							: {}),
 						autoSelected: false,
-						selectionReason: matched
-							? "Used the explicit model override provided in the tool call."
-							: "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.",
+						selectionReason,
 					};
 				} else {
-					const selectionResult = await selectOracleModel(ctx, params.thinkingLevel);
+					const selectionResult = await selectOracleModel(ctx, configuredThinkingLevel);
 					if (!selectionResult.ok) {
 						return {
 							content: [{ type: "text", text: selectionResult.error }],
@@ -909,7 +1183,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 								provider: ctx.model?.provider ?? "unknown",
 								modelId: "",
 								modelName: undefined,
-								thinkingLevel: params.thinkingLevel ?? DEFAULT_THINKING_LEVEL,
+								thinkingLevel: configuredThinkingLevel ?? DEFAULT_THINKING_LEVEL,
 								autoSelected: true,
 								selectionReason: selectionResult.error,
 								includeBash: params.includeBash ?? false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-oracle",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "An Amp-style oracle extension for pi that consults the strongest reasoning model on your current provider.",
   "keywords": ["pi-package", "pi", "oracle", "reasoning", "subagent"],
   "license": "MIT",