@oh-my-pi/pi-coding-agent 13.8.0 → 13.9.2

package/src/modes/components/agent-dashboard.ts

@@ -63,6 +63,7 @@ interface DashboardAgent extends AgentDefinition {
 interface ModelResolution {
 	resolved: string;
 	thinkingLevel?: string;
+	explicitThinkingLevel: boolean;
 }
 
 interface GeneratedAgentSpec {
@@ -109,6 +110,12 @@ function joinPatterns(patterns: string[]): string {
 	return patterns.join(", ");
 }
 
+function formatResolution(resolution: ModelResolution): string {
+	const resolved = theme.fg("success", resolution.resolved);
+	if (!resolution.explicitThinkingLevel || !resolution.thinkingLevel) return resolved;
+	return `${resolved} ${theme.fg("dim", `(${resolution.thinkingLevel})`)}`;
+}
+
 function matchAgent(agent: DashboardAgent, query: string): boolean {
 	const q = query.toLowerCase();
 	if (agent.name.toLowerCase().includes(q)) return true;
@@ -289,10 +296,7 @@ class AgentInspectorPane implements Component {
 	}
 
 	#formatResolution(resolution: ModelResolution): string {
-		if (resolution.thinkingLevel && resolution.thinkingLevel !== "off") {
-			return `${theme.fg("success", resolution.resolved)} ${theme.fg("dim", `(${resolution.thinkingLevel})`)}`;
-		}
-		return theme.fg("success", resolution.resolved);
+		return formatResolution(resolution);
 	}
 
 	invalidate(): void {}
@@ -770,7 +774,7 @@ export class AgentDashboard extends Container {
 	#resolvePatterns(patterns: string[]): ModelResolution | undefined {
 		const modelRegistry = this.modelContext.modelRegistry;
 		if (!modelRegistry || patterns.length === 0) return undefined;
-		const { model, thinkingLevel } = resolveModelOverride(
+		const { model, thinkingLevel, explicitThinkingLevel } = resolveModelOverride(
 			patterns,
 			modelRegistry,
 			this.#settingsManager ?? undefined,
@@ -779,6 +783,7 @@ export class AgentDashboard extends Container {
 		return {
 			resolved: formatModelString(model),
 			thinkingLevel,
+			explicitThinkingLevel,
 		};
 	}
 
@@ -930,20 +935,14 @@ export class AgentDashboard extends Container {
 			);
 			this.addChild(
 				new Text(
-					theme.fg(
-						"muted",
-						`Default resolves: ${defaultResolution ? defaultResolution.resolved : "(unresolved)"}`,
-					),
+					`${theme.fg("muted", "Default resolves:")} ${defaultResolution ? formatResolution(defaultResolution) : theme.fg("dim", "(unresolved)")}`,
 					0,
 					0,
 				),
 			);
 			this.addChild(
 				new Text(
-					theme.fg(
-						"muted",
-						`Preview effective: ${previewResolution ? previewResolution.resolved : "(unresolved)"}`,
-					),
+					`${theme.fg("muted", "Preview effective:")} ${previewResolution ? formatResolution(previewResolution) : theme.fg("dim", "(unresolved)")}`,
 					0,
 					0,
 				),

package/src/modes/components/model-selector.ts

@@ -1,7 +1,14 @@
-import { type Model, modelsAreEqual } from "@oh-my-pi/pi-ai";
+import {
+	getAvailableThinkingLevels,
+	getThinkingMetadata,
+	type Model,
+	modelsAreEqual,
+	supportsXhigh,
+	type ThinkingMode,
+} from "@oh-my-pi/pi-ai";
 import { Container, Input, matchesKey, Spacer, type Tab, TabBar, Text, type TUI, visibleWidth } from "@oh-my-pi/pi-tui";
 import { MODEL_ROLE_IDS, MODEL_ROLES, type ModelRegistry, type ModelRole } from "../../config/model-registry";
-import { parseModelString } from "../../config/model-resolver";
+import { resolveModelRoleValue } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 import { type ThemeColor, theme } from "../../modes/theme/theme";
 import { fuzzyFilter } from "../../utils/fuzzy";
@@ -25,12 +32,26 @@ interface ScopedModelItem {
 	thinkingLevel: string;
 }
 
-interface MenuAction {
+interface RoleAssignment {
+	model: Model;
+	thinkingMode: ThinkingMode;
+}
+
+type RoleSelectCallback = (model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode) => void;
+type CancelCallback = () => void;
+interface MenuRoleAction {
 	label: string;
 	role: ModelRole;
 }
 
-const MENU_ACTIONS: MenuAction[] = MODEL_ROLE_IDS.map(role => ({ label: `Set as ${MODEL_ROLES[role].name}`, role }));
+const MENU_ROLE_ACTIONS: MenuRoleAction[] = MODEL_ROLE_IDS.map(role => {
+	const roleInfo = MODEL_ROLES[role];
+	const roleLabel = roleInfo.tag ? `${roleInfo.tag} (${roleInfo.name})` : roleInfo.name;
+	return {
+		label: `Set as ${roleLabel}`,
+		role,
+	};
+});
 
 const ALL_TAB = "ALL";
 
@@ -50,11 +71,11 @@ export class ModelSelectorComponent extends Container {
 	#allModels: ModelItem[] = [];
 	#filteredModels: ModelItem[] = [];
 	#selectedIndex: number = 0;
-	#roles: { [key in ModelRole]?: Model } = {};
-	#settings: Settings;
-	#modelRegistry: ModelRegistry;
-	#onSelectCallback: (model: Model, role: ModelRole | null) => void;
-	#onCancelCallback: () => void;
+	#roles = {} as Record<ModelRole, RoleAssignment | undefined>;
+	#settings = null as unknown as Settings;
+	#modelRegistry = null as unknown as ModelRegistry;
+	#onSelectCallback = (() => {}) as RoleSelectCallback;
+	#onCancelCallback = (() => {}) as CancelCallback;
 	#errorMessage?: unknown;
 	#tui: TUI;
 	#scopedModels: ReadonlyArray<ScopedModelItem>;
@@ -67,6 +88,8 @@ export class ModelSelectorComponent extends Container {
 	// Context menu state
 	#isMenuOpen: boolean = false;
 	#menuSelectedIndex: number = 0;
+	#menuStep: "role" | "thinking" = "role";
+	#menuSelectedRole: ModelRole | null = null;
 
 	constructor(
 		tui: TUI,
@@ -74,7 +97,7 @@ export class ModelSelectorComponent extends Container {
 		settings: Settings,
 		modelRegistry: ModelRegistry,
 		scopedModels: ReadonlyArray<ScopedModelItem>,
-		onSelect: (model: Model, role: ModelRole | null) => void,
+		onSelect: (model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode) => void,
 		onCancel: () => void,
 		options?: { temporaryOnly?: boolean; initialSearchInput?: string },
 	) {
@@ -157,15 +180,20 @@ export class ModelSelectorComponent extends Container {
 
 	#loadRoleModels(): void {
 		const allModels = this.#modelRegistry.getAll();
+		const matchPreferences = { usageOrder: this.#settings.getStorage()?.getModelUsageOrder() };
 		for (const role of MODEL_ROLE_IDS) {
-			const modelId = this.#settings.getModelRole(role);
-			if (!modelId) continue;
-			const parsed = parseModelString(modelId);
-			if (parsed) {
-				const model = allModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
-				if (model) {
-					this.#roles[role] = model;
-				}
+			const roleValue = this.#settings.getModelRole(role);
+			if (!roleValue) continue;
+
+			const { model, thinkingLevel, explicitThinkingLevel } = resolveModelRoleValue(roleValue, allModels, {
+				settings: this.#settings,
+				matchPreferences,
+			});
+			if (model) {
+				this.#roles[role] = {
+					model,
+					thinkingMode: explicitThinkingLevel && thinkingLevel !== undefined ? thinkingLevel : "inherit",
+				};
 			}
 		}
 	}
@@ -179,7 +207,8 @@ export class ModelSelectorComponent extends Container {
 			let i = 0;
 			while (i < MODEL_ROLE_IDS.length) {
 				const role = MODEL_ROLE_IDS[i];
-				if (this.#roles[role] && modelsAreEqual(this.#roles[role], model.model)) {
+				const assigned = this.#roles[role];
+				if (assigned && modelsAreEqual(assigned.model, model.model)) {
 					break;
 				}
 				i++;
@@ -373,14 +402,17 @@ export class ModelSelectorComponent extends Container {
 			const isSelected = i === this.#selectedIndex;
 
 			// Build role badges (inverted: color as background, black text)
-			const badges: string[] = [];
+			const roleBadgeTokens: string[] = [];
 			for (const role of MODEL_ROLE_IDS) {
 				const { tag, color } = MODEL_ROLES[role];
-				if (tag && modelsAreEqual(this.#roles[role], item.model)) {
-					badges.push(makeInvertedBadge(tag, color ?? "success"));
-				}
+				const assigned = this.#roles[role];
+				if (!tag || !assigned || !modelsAreEqual(assigned.model, item.model)) continue;
+
+				const badge = makeInvertedBadge(tag, color ?? "success");
+				const thinkingLabel = getThinkingMetadata(assigned.thinkingMode).label;
+				roleBadgeTokens.push(`${badge} ${theme.fg("dim", `(${thinkingLabel})`)}`);
 			}
-			const badgeText = badges.length > 0 ? ` ${badges.join(" ")}` : "";
+			const badgeText = roleBadgeTokens.length > 0 ? ` ${roleBadgeTokens.join(" ")}` : "";
 
 			let line = "";
 			if (isSelected) {
@@ -424,17 +456,36 @@ export class ModelSelectorComponent extends Container {
 			this.#listContainer.addChild(new Text(theme.fg("muted", `  Model Name: ${selected.model.name}`), 0, 0));
 		}
 	}
+	#getThinkingModesForModel(model: Model): ReadonlyArray<ThinkingMode> {
+		return ["inherit", ...getAvailableThinkingLevels(supportsXhigh(model))];
+	}
+
+	#getCurrentRoleThinkingMode(role: ModelRole): ThinkingMode {
+		return this.#roles[role]?.thinkingMode ?? "inherit";
+	}
+
+	#getThinkingPreselectIndex(role: ModelRole, model: Model): number {
+		const options = this.#getThinkingModesForModel(model);
+		const currentMode = this.#getCurrentRoleThinkingMode(role);
+		const preferredMode = currentMode === "xhigh" && !options.includes("xhigh") ? "high" : currentMode;
+		const foundIndex = options.indexOf(preferredMode);
+		return foundIndex >= 0 ? foundIndex : 0;
+	}
 
 	#openMenu(): void {
 		if (this.#filteredModels.length === 0) return;
 
 		this.#isMenuOpen = true;
+		this.#menuStep = "role";
+		this.#menuSelectedRole = null;
 		this.#menuSelectedIndex = 0;
 		this.#updateMenu();
 	}
 
 	#closeMenu(): void {
 		this.#isMenuOpen = false;
+		this.#menuStep = "role";
+		this.#menuSelectedRole = null;
 		this.#menuContainer.clear();
 	}
 
@@ -444,35 +495,53 @@ export class ModelSelectorComponent extends Container {
 		const selectedModel = this.#filteredModels[this.#selectedIndex];
 		if (!selectedModel) return;
 
-		const headerText = `  Action for: ${selectedModel.id}`;
-		const hintText = "  Enter: confirm  Esc: cancel";
-		const actionLines = MENU_ACTIONS.map((action, index) => {
-			const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
-			return `${prefix}${action.label}`;
-		});
+		const showingThinking = this.#menuStep === "thinking" && this.#menuSelectedRole !== null;
+		const thinkingOptions = showingThinking ? this.#getThinkingModesForModel(selectedModel.model) : [];
+		const optionLines = showingThinking
+			? thinkingOptions.map((thinkingMode, index) => {
+					const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
+					const label = getThinkingMetadata(thinkingMode).label;
+					return `${prefix}${label}`;
+				})
+			: MENU_ROLE_ACTIONS.map((action, index) => {
+					const prefix = index === this.#menuSelectedIndex ? `  ${theme.nav.cursor} ` : "    ";
+					return `${prefix}${action.label}`;
+				});
+
+		const selectedRoleName = this.#menuSelectedRole ? MODEL_ROLES[this.#menuSelectedRole].name : "";
+		const headerText =
+			showingThinking && this.#menuSelectedRole
+				? `  Thinking for: ${selectedRoleName} (${selectedModel.id})`
+				: `  Action for: ${selectedModel.id}`;
+		const hintText = showingThinking ? "  Enter: confirm  Esc: back" : "  Enter: continue  Esc: cancel";
 		const menuWidth = Math.max(
 			visibleWidth(headerText),
 			visibleWidth(hintText),
-			...actionLines.map(line => visibleWidth(line)),
+			...optionLines.map(line => visibleWidth(line)),
 		);
 
-		// Menu header
 		this.#menuContainer.addChild(new Spacer(1));
 		this.#menuContainer.addChild(new Text(theme.fg("border", theme.boxSharp.horizontal.repeat(menuWidth)), 0, 0));
-		this.#menuContainer.addChild(new Text(theme.fg("text", `  Action for: ${theme.bold(selectedModel.id)}`), 0, 0));
+		if (showingThinking && this.#menuSelectedRole) {
+			this.#menuContainer.addChild(
+				new Text(
+					theme.fg("text", `  Thinking for: ${theme.bold(selectedRoleName)} (${theme.bold(selectedModel.id)})`),
+					0,
+					0,
+				),
+			);
+		} else {
+			this.#menuContainer.addChild(
+				new Text(theme.fg("text", `  Action for: ${theme.bold(selectedModel.id)}`), 0, 0),
+			);
+		}
 		this.#menuContainer.addChild(new Spacer(1));
 
-		// Menu options
-		for (let i = 0; i < MENU_ACTIONS.length; i++) {
-			const action = MENU_ACTIONS[i]!;
+		for (let i = 0; i < optionLines.length; i++) {
+			const lineText = optionLines[i];
+			if (!lineText) continue;
 			const isSelected = i === this.#menuSelectedIndex;
-
-			let line: string;
-			if (isSelected) {
-				line = theme.fg("accent", `  ${theme.nav.cursor} ${action.label}`);
-			} else {
-				line = theme.fg("muted", `    ${action.label}`);
-			}
+			const line = isSelected ? theme.fg("accent", lineText) : theme.fg("muted", lineText);
 			this.#menuContainer.addChild(new Text(line, 0, 0));
 		}
 
@@ -532,55 +601,84 @@ export class ModelSelectorComponent extends Container {
 		this.#searchInput.handleInput(keyData);
 		this.#filterModels(this.#searchInput.getValue());
 	}
-
 	#handleMenuInput(keyData: string): void {
-		// Up arrow - navigate menu
+		const selectedModel = this.#filteredModels[this.#selectedIndex];
+		if (!selectedModel) return;
+
+		const optionCount =
+			this.#menuStep === "thinking" && this.#menuSelectedRole !== null
+				? this.#getThinkingModesForModel(selectedModel.model).length
+				: MENU_ROLE_ACTIONS.length;
+		if (optionCount === 0) return;
+
 		if (matchesKey(keyData, "up")) {
-			this.#menuSelectedIndex = (this.#menuSelectedIndex - 1 + MENU_ACTIONS.length) % MENU_ACTIONS.length;
+			this.#menuSelectedIndex = (this.#menuSelectedIndex - 1 + optionCount) % optionCount;
 			this.#updateMenu();
 			return;
 		}
 
-		// Down arrow - navigate menu
 		if (matchesKey(keyData, "down")) {
-			this.#menuSelectedIndex = (this.#menuSelectedIndex + 1) % MENU_ACTIONS.length;
+			this.#menuSelectedIndex = (this.#menuSelectedIndex + 1) % optionCount;
 			this.#updateMenu();
 			return;
 		}
 
-		// Enter - confirm selection
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
-			const selectedModel = this.#filteredModels[this.#selectedIndex];
-			const action = MENU_ACTIONS[this.#menuSelectedIndex];
-			if (selectedModel && action) {
-				this.#handleSelect(selectedModel.model, action.role);
-				this.#closeMenu();
+			if (this.#menuStep === "role") {
+				const action = MENU_ROLE_ACTIONS[this.#menuSelectedIndex];
+				if (!action) return;
+				this.#menuSelectedRole = action.role;
+				this.#menuStep = "thinking";
+				this.#menuSelectedIndex = this.#getThinkingPreselectIndex(action.role, selectedModel.model);
+				this.#updateMenu();
+				return;
 			}
+
+			if (!this.#menuSelectedRole) return;
+			const thinkingOptions = this.#getThinkingModesForModel(selectedModel.model);
+			const thinkingMode = thinkingOptions[this.#menuSelectedIndex];
+			if (!thinkingMode) return;
+			this.#handleSelect(selectedModel.model, this.#menuSelectedRole, thinkingMode);
+			this.#closeMenu();
 			return;
 		}
 
-		// Escape or Ctrl+C - close menu only
 		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc") || matchesKey(keyData, "ctrl+c")) {
+			if (this.#menuStep === "thinking" && this.#menuSelectedRole !== null) {
+				this.#menuStep = "role";
+				const roleIndex = MENU_ROLE_ACTIONS.findIndex(action => action.role === this.#menuSelectedRole);
+				this.#menuSelectedRole = null;
+				this.#menuSelectedIndex = roleIndex >= 0 ? roleIndex : 0;
+				this.#updateMenu();
+				return;
+			}
 			this.#closeMenu();
 			return;
 		}
 	}
 
-	#handleSelect(model: Model, role: ModelRole | null): void {
+	#formatRoleModelValue(model: Model, thinkingMode: ThinkingMode): string {
+		const modelKey = `${model.provider}/${model.id}`;
+		if (thinkingMode === "inherit") return modelKey;
+		return `${modelKey}:${thinkingMode}`;
+	}
+	#handleSelect(model: Model, role: ModelRole | null, thinkingMode?: ThinkingMode): void {
 		// For temporary role, don't save to settings - just notify caller
 		if (role === null) {
 			this.#onSelectCallback(model, null);
 			return;
 		}
 
+		const selectedThinkingMode = thinkingMode ?? this.#getCurrentRoleThinkingMode(role);
+
 		// Save to settings
-		this.#settings.setModelRole(role, `${model.provider}/${model.id}`);
+		this.#settings.setModelRole(role, this.#formatRoleModelValue(model, selectedThinkingMode));
 
 		// Update local state for UI
-		this.#roles[role] = model;
+		this.#roles[role] = { model, thinkingMode: selectedThinkingMode };
 
 		// Notify caller (for updating agent state if needed)
-		this.#onSelectCallback(model, role);
+		this.#onSelectCallback(model, role, selectedThinkingMode);
 
 		// Update list to show new badges
 		this.#updateList();

package/src/modes/components/read-tool-group.ts

@@ -11,12 +11,32 @@ type ReadRenderArgs = {
 	limit?: number;
 };
 
+type ReadToolSuffixResolution = {
+	from: string;
+	to: string;
+};
+
+type ReadToolResultDetails = {
+	suffixResolution?: {
+		from?: string;
+		to?: string;
+	};
+};
+
+function getSuffixResolution(details: ReadToolResultDetails | undefined): ReadToolSuffixResolution | undefined {
+	if (typeof details?.suffixResolution?.from !== "string" || typeof details.suffixResolution.to !== "string") {
+		return undefined;
+	}
+	return { from: details.suffixResolution.from, to: details.suffixResolution.to };
+}
+
 type ReadEntry = {
 	toolCallId: string;
 	path: string;
 	offset?: number;
 	limit?: number;
-	status: "pending" | "success" | "error";
+	status: "pending" | "success" | "warning" | "error";
+	correctedFrom?: string;
 };
 
 export class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
@@ -56,7 +76,15 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		const entry = this.#entries.get(toolCallId);
 		if (!entry) return;
 		if (isPartial) return;
-		entry.status = result.isError ? "error" : "success";
+		const details = result.details as ReadToolResultDetails | undefined;
+		const suffixResolution = getSuffixResolution(details);
+		if (suffixResolution) {
+			entry.path = suffixResolution.to;
+			entry.correctedFrom = suffixResolution.from;
+		} else {
+			entry.correctedFrom = undefined;
+		}
+		entry.status = result.isError ? "error" : suffixResolution ? "warning" : "success";
 		this.#updateDisplay();
 	}
 
@@ -109,6 +137,9 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 			const endLine = entry.limit !== undefined ? startLine + entry.limit - 1 : "";
 			pathDisplay += theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
 		}
+		if (entry.correctedFrom) {
+			pathDisplay += theme.fg("dim", ` (corrected from ${shortenPath(entry.correctedFrom)})`);
+		}
 		return pathDisplay;
 	}
 
@@ -116,6 +147,9 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		if (status === "success") {
 			return theme.fg("success", theme.status.success);
 		}
+		if (status === "warning") {
+			return theme.fg("warning", theme.status.warning);
+		}
 		if (status === "error") {
 			return theme.fg("error", theme.status.error);
 		}

package/src/modes/components/settings-defs.ts

@@ -6,6 +6,8 @@
  * 1. Add it to settings-schema.ts with a `ui` field
  * 2. That's it - it appears in the UI automatically
  */
+
+import { getAvailableThinkingLevels, getThinkingMetadata } from "@oh-my-pi/pi-ai";
 import { TERMINAL } from "@oh-my-pi/pi-tui";
 import {
 	getDefault,
@@ -167,6 +169,14 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "300", label: "5 minutes" },
 		{ value: "600", label: "10 minutes" },
 	],
+	// Read line limit
+	"read.defaultLimit": [
+		{ value: "200", label: "200 lines" },
+		{ value: "300", label: "300 lines" },
+		{ value: "500", label: "500 lines" },
+		{ value: "1000", label: "1000 lines" },
+		{ value: "5000", label: "5000 lines" },
+	],
 	// Edit fuzzy threshold
 	"edit.fuzzyThreshold": [
 		{ value: "0.85", label: "0.85", description: "Lenient" },
@@ -221,14 +231,7 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "on", label: "On", description: "Force websockets for OpenAI Codex models" },
 	],
 	// Default thinking level
-	defaultThinkingLevel: [
-		{ value: "off", label: "off", description: "No reasoning" },
-		{ value: "minimal", label: "minimal", description: "Very brief (~1k tokens)" },
-		{ value: "low", label: "low", description: "Light (~2k tokens)" },
-		{ value: "medium", label: "medium", description: "Moderate (~8k tokens)" },
-		{ value: "high", label: "high", description: "Deep (~16k tokens)" },
-		{ value: "xhigh", label: "xhigh", description: "Maximum (~32k tokens)" },
-	],
+	defaultThinkingLevel: [...getAvailableThinkingLevels().map(getThinkingMetadata)],
 	// Temperature
 	temperature: [
 		{ value: "-1", label: "Default", description: "Use provider default" },

package/src/modes/components/settings-selector.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
 import {
 	Container,
 	matchesKey,

package/src/modes/components/thinking-selector.ts

@@ -1,17 +1,9 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { getThinkingMetadata, type ThinkingLevel } from "@oh-my-pi/pi-ai";
+
 import { Container, type SelectItem, SelectList } from "@oh-my-pi/pi-tui";
 import { getSelectListTheme } from "../../modes/theme/theme";
 import { DynamicBorder } from "./dynamic-border";
 
-const LEVEL_DESCRIPTIONS: Record<ThinkingLevel, string> = {
-	off: "No reasoning",
-	minimal: "Very brief reasoning (~1k tokens)",
-	low: "Light reasoning (~2k tokens)",
-	medium: "Moderate reasoning (~8k tokens)",
-	high: "Deep reasoning (~16k tokens)",
-	xhigh: "Maximum reasoning (~32k tokens)",
-};
-
 /**
  * Component that renders a thinking level selector with borders
  */
@@ -26,11 +18,7 @@ export class ThinkingSelectorComponent extends Container {
 	) {
 		super();
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(level => ({
-			value: level,
-			label: level,
-			description: LEVEL_DESCRIPTIONS[level],
-		}));
+		const thinkingLevels: SelectItem[] = availableLevels.map(getThinkingMetadata);
 
 		// Add top border
 		this.addChild(new DynamicBorder());

package/src/modes/controllers/selector-controller.ts

@@ -1,5 +1,4 @@
-import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { getOAuthProviders, type OAuthProvider } from "@oh-my-pi/pi-ai";
+import { getOAuthProviders, type OAuthProvider, type ThinkingLevel } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getAgentDbPath, getProjectDir } from "@oh-my-pi/pi-utils";
@@ -76,7 +75,7 @@ export class SelectorController {
 			this.showSelector(done => {
 				const selector = new SettingsSelectorComponent(
 					{
-						availableThinkingLevels: this.ctx.session.getAvailableThinkingLevels(),
+						availableThinkingLevels: [...this.ctx.session.getAvailableThinkingLevels()],
 						thinkingLevel: this.ctx.session.thinkingLevel,
 						availableThemes,
 						cwd: getProjectDir(),
@@ -342,12 +341,24 @@ export class SelectorController {
 			}
 
 			// Provider settings - update runtime preferences
-			case "webSearchProvider":
+			case "providers.webSearch":
 				setPreferredSearchProvider(
-					value as "auto" | "exa" | "jina" | "zai" | "perplexity" | "anthropic" | "gemini" | "codex",
+					value as
+						| "auto"
+						| "exa"
+						| "brave"
+						| "jina"
+						| "kimi"
+						| "zai"
+						| "perplexity"
+						| "anthropic"
+						| "gemini"
+						| "codex"
+						| "kagi"
+						| "synthetic",
 				);
 				break;
-			case "imageProvider":
+			case "providers.image":
 				setPreferredImageProvider(value as "auto" | "gemini" | "openrouter");
 				break;
 
@@ -369,7 +380,7 @@ export class SelectorController {
 				this.ctx.settings,
 				this.ctx.session.modelRegistry,
 				this.ctx.session.scopedModels,
-				async (model, role) => {
+				async (model, role, thinkingMode) => {
 					try {
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
@@ -382,6 +393,9 @@ export class SelectorController {
 						} else if (role === "default") {
 							// Default: update agent state and persist
 							await this.ctx.session.setModel(model, role);
+							if (thinkingMode && thinkingMode !== "inherit") {
+								this.ctx.session.setThinkingLevel(thinkingMode as ThinkingLevel);
+							}
 							this.ctx.statusLine.invalidate();
 							this.ctx.updateEditorBorderColor();
 							this.ctx.showStatus(`Default model: ${model.id}`);

package/src/modes/rpc/rpc-client.ts

@@ -3,8 +3,8 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { AgentEvent, AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, ThinkingLevel } from "@oh-my-pi/pi-ai";
 import { isRecord, ptree, readJsonl } from "@oh-my-pi/pi-utils";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";

package/src/modes/rpc/rpc-types.ts

@@ -4,8 +4,8 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, Model, ThinkingLevel } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
 import type { CompactionResult } from "../../session/compaction";