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

package/src/config/model-resolver.ts

@@ -1,17 +1,20 @@
 /**
  * Model resolution, scoping, and initial selection
  */
+
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import {
 	type Api,
+	clampThinkingLevelForModel,
 	DEFAULT_MODEL_PER_PROVIDER,
+	type Effort,
 	type KnownProvider,
 	type Model,
 	modelsAreEqual,
-	parseThinkingLevel,
-	type ThinkingLevel,
 } from "@oh-my-pi/pi-ai";
 import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
+import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { fuzzyMatch } from "../utils/fuzzy";
 import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
@@ -377,7 +380,14 @@ export function resolveModelRoleValue(
 		options?.matchPreferences,
 	);
 
-	return { model, thinkingLevel, explicitThinkingLevel, warning };
+	return {
+		model,
+		thinkingLevel: explicitThinkingLevel
+			? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+			: thinkingLevel,
+		explicitThinkingLevel,
+		warning,
+	};
 }
 
 export function extractExplicitThinkingSelector(
@@ -393,10 +403,10 @@ export function extractExplicitThinkingSelector(
 	while (!visited.has(current)) {
 		visited.add(current);
 		const lastColonIndex = current.lastIndexOf(":");
-		const hasThinkingSuffix =
-			lastColonIndex > PREFIX_MODEL_ROLE.length && parseThinkingLevel(current.slice(lastColonIndex + 1));
-		if (hasThinkingSuffix) {
-			return current.slice(lastColonIndex + 1) as ThinkingLevel;
+		const thinkingSelector =
+			lastColonIndex > PREFIX_MODEL_ROLE.length ? parseThinkingLevel(current.slice(lastColonIndex + 1)) : undefined;
+		if (thinkingSelector) {
+			return thinkingSelector;
 		}
 		const expanded = expandRoleAlias(current, settings).trim();
 		if (!expanded || expanded === current) break;
@@ -520,7 +530,13 @@ export async function resolveModelScope(
 
 			for (const model of matchingModels) {
 				if (!scopedModels.find(sm => modelsAreEqual(sm.model, model))) {
-					scopedModels.push({ model, thinkingLevel, explicitThinkingLevel });
+					scopedModels.push({
+						model,
+						thinkingLevel: explicitThinkingLevel
+							? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+							: thinkingLevel,
+						explicitThinkingLevel,
+					});
 				}
 			}
 			continue;
@@ -543,7 +559,13 @@ export async function resolveModelScope(
 
 		// Avoid duplicates
 		if (!scopedModels.find(sm => modelsAreEqual(sm.model, model))) {
-			scopedModels.push({ model, thinkingLevel, explicitThinkingLevel });
+			scopedModels.push({
+				model,
+				thinkingLevel: explicitThinkingLevel
+					? (resolveThinkingLevelForModel(model, thinkingLevel) ?? thinkingLevel)
+					: thinkingLevel,
+				explicitThinkingLevel,
+			});
 		}
 	}
 
@@ -644,7 +666,7 @@ export function resolveCliModel(options: {
 
 export interface InitialModelResult {
 	model: Model<Api> | undefined;
-	thinkingLevel: ThinkingLevel;
+	thinkingLevel?: ThinkingLevel;
 	fallbackMessage: string | undefined;
 }
 
@@ -663,7 +685,7 @@ export async function findInitialModel(options: {
 	isContinuing: boolean;
 	defaultProvider?: string;
 	defaultModelId?: string;
-	defaultThinkingSelector?: ThinkingLevel;
+	defaultThinkingSelector?: Effort;
 	modelRegistry: ModelRegistry;
 }): Promise<InitialModelResult> {
 	const {
@@ -678,7 +700,7 @@ export async function findInitialModel(options: {
 	} = options;
 
 	let model: Model<Api> | undefined;
-	let thinkingLevel: ThinkingLevel = "off";
+	let thinkingLevel: Effort | undefined;
 
 	// 1. CLI args take priority
 	if (cliProvider && cliModel) {
@@ -687,16 +709,22 @@ export async function findInitialModel(options: {
 			console.error(chalk.red(`Model ${cliProvider}/${cliModel} not found`));
 			process.exit(1);
 		}
-		return { model: found, thinkingLevel: "off", fallbackMessage: undefined };
+		return { model: found, thinkingLevel: undefined, fallbackMessage: undefined };
 	}
 
 	// 2. Use first model from scoped models (skip if continuing/resuming)
 	if (scopedModels.length > 0 && !isContinuing) {
 		const scoped = scopedModels[0];
-		const scopedThinkingSelector = scoped.thinkingLevel ?? defaultThinkingSelector ?? "off";
+		const scopedThinkingSelector =
+			scoped.thinkingLevel === ThinkingLevel.Inherit
+				? defaultThinkingSelector
+				: (scoped.thinkingLevel ?? defaultThinkingSelector);
 		return {
 			model: scoped.model,
-			thinkingLevel: scopedThinkingSelector,
+			thinkingLevel:
+				scopedThinkingSelector === ThinkingLevel.Off
+					? ThinkingLevel.Off
+					: clampThinkingLevelForModel(scoped.model, scopedThinkingSelector),
 			fallbackMessage: undefined,
 		};
 	}
@@ -706,9 +734,7 @@ export async function findInitialModel(options: {
 		const found = modelRegistry.find(defaultProvider, defaultModelId);
 		if (found) {
 			model = found;
-			if (defaultThinkingSelector) {
-				thinkingLevel = defaultThinkingSelector;
-			}
+			thinkingLevel = clampThinkingLevelForModel(found, defaultThinkingSelector);
 			return { model, thinkingLevel, fallbackMessage: undefined };
 		}
 	}
@@ -722,16 +748,16 @@ export async function findInitialModel(options: {
 			const defaultId = defaultModelPerProvider[provider];
 			const match = availableModels.find(m => m.provider === provider && m.id === defaultId);
 			if (match) {
-				return { model: match, thinkingLevel: "off", fallbackMessage: undefined };
+				return { model: match, thinkingLevel: undefined, fallbackMessage: undefined };
 			}
 		}
 
 		// If no default found, use first available
-		return { model: availableModels[0], thinkingLevel: "off", fallbackMessage: undefined };
+		return { model: availableModels[0], thinkingLevel: undefined, fallbackMessage: undefined };
 	}
 
 	// 5. No model found
-	return { model: undefined, thinkingLevel: "off", fallbackMessage: undefined };
+	return { model: undefined, thinkingLevel: undefined, fallbackMessage: undefined };
 }
 
 /**

package/src/config/settings-schema.ts

@@ -1,4 +1,4 @@
-import { getAvailableThinkingLevels } from "@oh-my-pi/pi-ai";
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 
 /** Unified settings schema - single source of truth for all settings.
  * Unified settings schema - single source of truth for all settings.
@@ -192,7 +192,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	defaultThinkingLevel: {
 		type: "enum",
-		values: getAvailableThinkingLevels(),
+		values: THINKING_EFFORTS,
 		default: "high",
 		ui: {
 			tab: "agent",
@@ -345,9 +345,48 @@ export const SETTINGS_SCHEMA = {
 			description: "Automatically compact context when it gets too large",
 		},
 	},
+	"compaction.strategy": {
+		type: "enum",
+		values: ["context-full", "handoff", "off"] as const,
+		default: "context-full",
+		ui: {
+			tab: "agent",
+			label: "Context-full strategy",
+			description: "Choose in-place context-full maintenance, auto-handoff, or disable auto maintenance (off)",
+			submenu: true,
+		},
+	},
+	"compaction.thresholdPercent": {
+		type: "number",
+		default: -1,
+		ui: {
+			tab: "agent",
+			label: "Context threshold",
+			description: "Percent threshold for context maintenance; set to Default to use legacy reserve-based behavior",
+			submenu: true,
+		},
+	},
+	"compaction.handoffSaveToDisk": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "agent",
+			label: "Save auto-handoff docs",
+			description: "Save generated handoff documents to markdown files for the auto-handoff flow",
+		},
+	},
 	"compaction.reserveTokens": { type: "number", default: 16384 },
 	"compaction.keepRecentTokens": { type: "number", default: 20000 },
 	"compaction.autoContinue": { type: "boolean", default: true },
+	"compaction.remoteEnabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "agent",
+			label: "Remote compaction",
+			description: "Use remote compaction endpoints when available instead of local summarization",
+		},
+	},
 	"compaction.remoteEndpoint": { type: "string", default: undefined },
 
 	// ─────────────────────────────────────────────────────────────────────────
@@ -1186,6 +1225,17 @@ export const SETTINGS_SCHEMA = {
 			submenu: true,
 		},
 	},
+	serviceTier: {
+		type: "enum",
+		values: ["none", "auto", "default", "flex", "scale", "priority"] as const,
+		default: "none",
+		ui: {
+			tab: "agent",
+			label: "Service tier",
+			description: "OpenAI processing priority (none = omit parameter)",
+			submenu: true,
+		},
+	},
 } as const;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1265,9 +1315,13 @@ export type StatusLineSeparatorStyle = SettingValue<"statusLine.separator">;
 
 export interface CompactionSettings {
 	enabled: boolean;
+	strategy: "context-full" | "handoff" | "off";
+	thresholdPercent: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
+	handoffSaveToDisk: boolean;
 	autoContinue: boolean;
+	remoteEnabled: boolean;
 	remoteEndpoint: string | undefined;
 }
 

package/src/discovery/helpers.ts

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@oh-my-pi/pi-ai";
-import { parseThinkingLevel } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, tryParseJson } from "@oh-my-pi/pi-utils";
 import { readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { parseThinkingLevel } from "../thinking";
 import { parseFrontmatter } from "../utils/frontmatter";
 
 /**
@@ -206,7 +206,7 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 		return null;
 	}
 
-	let tools = parseArrayOrCSV(frontmatter.tools);
+	let tools = parseArrayOrCSV(frontmatter.tools)?.map(tool => tool.toLowerCase());
 
 	// Subagents with explicit tool lists always need submit_result
 	if (tools && !tools.includes("submit_result")) {

package/src/extensibility/custom-tools/types.ts

@@ -90,9 +90,11 @@ export type CustomToolSessionEvent =
 	| {
 			reason: "auto_compaction_start";
 			trigger: "threshold" | "overflow";
+			action: "context-full" | "handoff";
 	  }
 	| {
 			reason: "auto_compaction_end";
+			action: "context-full" | "handoff";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;

package/src/extensibility/extensions/loader.ts

@@ -4,7 +4,8 @@
 import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ImageContent, Model, TextContent, ThinkingLevel } from "@oh-my-pi/pi-ai";
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
 import * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
@@ -214,7 +215,7 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		return this.runtime.setModel(model);
 	}
 
-	getThinkingLevel(): ThinkingLevel {
+	getThinkingLevel(): ThinkingLevel | undefined {
 		return this.runtime.getThinkingLevel();
 	}
 

package/src/extensibility/extensions/types.ts

@@ -7,7 +7,7 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type {
 	Api,
 	AssistantMessageEvent,
@@ -19,7 +19,6 @@ import type {
 	OAuthLoginCallbacks,
 	SimpleStreamOptions,
 	TextContent,
-	ThinkingLevel,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
@@ -538,11 +537,13 @@ export interface ToolExecutionEndEvent {
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
 	reason: "threshold" | "overflow";
+	action: "context-full" | "handoff";
 }
 
 /** Fired when auto-compaction ends */
 export interface AutoCompactionEndEvent {
 	type: "auto_compaction_end";
+	action: "context-full" | "handoff";
 	result: CompactionResult | undefined;
 	aborted: boolean;
 	willRetry: boolean;
@@ -1056,9 +1057,9 @@ export interface ExtensionAPI {
 	setModel(model: Model): Promise<boolean>;
 
 	/** Get current thinking level. */
-	getThinkingLevel(): ThinkingLevel;
+	getThinkingLevel(): ThinkingLevel | undefined;
 
-	/** Set thinking level (clamped to model capabilities). */
+	/** Set thinking level for the current session. */
 	setThinkingLevel(level: ThinkingLevel): void;
 
 	// =========================================================================
@@ -1084,11 +1085,11 @@ export interface ExtensionAPI {
 	 *       id: "claude-sonnet-4@20250514",
 	 *       name: "Claude Sonnet 4 (Vertex)",
 	 *       reasoning: true,
+	 *       thinking: { mode: "anthropic-adaptive", minLevel: "minimal", maxLevel: "high" },
 	 *       input: ["text", "image"],
 	 *       cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
 	 *       contextWindow: 200000,
 	 *       maxTokens: 64000,
-	 *     }
 	 *   ]
 	 * });
 	 *
@@ -1147,8 +1148,10 @@ export interface ProviderModelConfig {
 	name: string;
 	/** API type override for this model. */
 	api?: Api;
-	/** Whether the model supports extended thinking. */
+	/** Whether the model supports extended thinking at all. */
 	reasoning: boolean;
+	/** Optional canonical thinking capability metadata for per-model effort support. */
+	thinking?: Model["thinking"];
 	/** Supported input types. */
 	input: ("text" | "image")[];
 	/** Cost per million tokens. */
@@ -1216,7 +1219,7 @@ export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 
 export type SetModelHandler = (model: Model) => Promise<boolean>;
 
-export type GetThinkingLevelHandler = () => ThinkingLevel;
+export type GetThinkingLevelHandler = () => ThinkingLevel | undefined;
 
 export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean) => void;
 

package/src/extensibility/hooks/types.ts

@@ -395,11 +395,13 @@ export interface TurnEndEvent {
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
 	reason: "threshold" | "overflow";
+	action: "context-full" | "handoff";
 }
 
 /** Event data for auto_compaction_end event. */
 export interface AutoCompactionEndEvent {
 	type: "auto_compaction_end";
+	action: "context-full" | "handoff";
 	result: CompactionResult | undefined;
 	aborted: boolean;
 	willRetry: boolean;

package/src/main.ts

@@ -10,7 +10,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { $env, getProjectDir, logger, postmortem, setProjectDir, VERSION } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { Args } from "./cli/args";
@@ -334,11 +334,10 @@ async function buildSessionOptions(
 	scopedModels: ScopedModel[],
 	sessionManager: SessionManager | undefined,
 	modelRegistry: ModelRegistry,
-): Promise<{ options: CreateAgentSessionOptions; cliThinkingFromModel: boolean }> {
+): Promise<{ options: CreateAgentSessionOptions }> {
 	const options: CreateAgentSessionOptions = {
 		cwd: parsed.cwd ?? getProjectDir(),
 	};
-	let cliThinkingFromModel = false;
 
 	// Auto-discover SYSTEM.md if no CLI system prompt provided
 	const systemPromptSource = parsed.systemPrompt ?? discoverSystemPromptFile();
@@ -380,7 +379,6 @@ async function buildSessionOptions(
 			settings.overrideModelRoles({ default: `${resolved.model.provider}/${resolved.model.id}` });
 			if (!parsed.thinking && resolved.thinkingLevel) {
 				options.thinkingLevel = resolved.thinkingLevel;
-				cliThinkingFromModel = true;
 			}
 		}
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
@@ -483,7 +481,7 @@ async function buildSessionOptions(
 		options.additionalExtensionPaths = [];
 	}
 
-	return { options, cliThinkingFromModel };
+	return { options };
 }
 
 export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
@@ -618,7 +616,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
-	const { options: sessionOptions, cliThinkingFromModel } = await logger.timeAsync("buildSessionOptions", () =>
+	const { options: sessionOptions } = await logger.timeAsync("buildSessionOptions", () =>
 		buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry),
 	);
 	sessionOptions.authStorage = authStorage;
@@ -692,21 +690,6 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		process.exit(1);
 	}
 
-	// Clamp thinking level to model capabilities for CLI-provided thinking levels.
-	// This covers both --thinking <level> and --model <pattern>:<thinking>.
-	const cliThinkingOverride = parsedArgs.thinking !== undefined || cliThinkingFromModel;
-	if (session.model && cliThinkingOverride) {
-		let effectiveThinking = session.thinkingLevel;
-		if (!session.model.reasoning) {
-			effectiveThinking = "off";
-		} else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
-			effectiveThinking = "high";
-		}
-		if (effectiveThinking !== session.thinkingLevel) {
-			session.setThinkingLevel(effectiveThinking);
-		}
-	}
-
 	if (mode === "rpc") {
 		await runRpcMode(session);
 	} else if (isInteractive) {
@@ -717,7 +700,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		if (scopedModelsForDisplay.length > 0) {
 			const modelList = scopedModelsForDisplay
 				.map(scopedModel => {
-					const thinkingStr = scopedModel.thinkingLevel !== "off" ? `:${scopedModel.thinkingLevel}` : "";
+					const thinkingStr = !scopedModel.thinkingLevel ? `:${scopedModel.thinkingLevel}` : "";
 					return `${scopedModel.model.id}${thinkingStr}`;
 				})
 				.join(", ");

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 { completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
 import { getAgentDbPath, logger, parseJsonlLenient } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { parseModelString } from "../config/model-resolver";
@@ -583,7 +583,11 @@ async function runStage1Job(options: {
 				systemPrompt: stageOneSystemTemplate,
 				messages: [{ role: "user", content: [{ type: "text", text: inputPrompt }], timestamp: Date.now() }],
 			},
-			{ apiKey, maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))), reasoning: "low" },
+			{
+				apiKey,
+				maxTokens: Math.max(1024, Math.min(4096, Math.floor(modelMaxTokens * 0.2))),
+				reasoning: Effort.Low,
+			},
 		);
 
 		if (response.stopReason === "error") {
@@ -709,7 +713,7 @@ async function runConsolidationModel(options: { memoryRoot: string; model: Model
 		{
 			messages: [{ role: "user", content: [{ type: "text", text: input }], timestamp: Date.now() }],
 		},
-		{ apiKey, maxTokens: 8192, reasoning: "medium" },
+		{ apiKey, maxTokens: 8192, reasoning: Effort.Medium },
 	);
 	if (response.stopReason === "error") {
 		throw new Error(response.errorMessage || "phase2 model error");

package/src/modes/components/footer.ts

@@ -1,10 +1,12 @@
 import * as fs from "node:fs";
+import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { formatNumber, getProjectDir } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { shortenPath } from "../../tools/render-utils";
 import { findGitHeadPathAsync, sanitizeStatusText } from "../shared";
+import { getContextUsageLevel, getContextUsageThemeColor } from "./status-line/context-thresholds";
 
 /**
  * Footer component that shows pwd, token stats, and context usage
@@ -197,10 +199,10 @@ export class FooterComponent implements Component {
 			contextPercent === "?"
 				? `?/${formatNumber(contextWindow)}${autoIndicator}`
 				: `${contextPercent}%/${formatNumber(contextWindow)}${autoIndicator}`;
-		if (contextPercentValue > 90) {
-			contextPercentStr = theme.fg("error", contextPercentDisplay);
-		} else if (contextPercentValue > 70) {
-			contextPercentStr = theme.fg("warning", contextPercentDisplay);
+		if (contextUsage?.percent !== null && contextUsage?.percent !== undefined) {
+			const color = getContextUsageThemeColor(getContextUsageLevel(contextPercentValue, contextWindow));
+			contextPercentStr =
+				color === "statusLineContext" ? contextPercentDisplay : theme.fg(color, contextPercentDisplay);
 		} else {
 			contextPercentStr = contextPercentDisplay;
 		}
@@ -211,11 +213,11 @@ export class FooterComponent implements Component {
 		// Add model name on the right side, plus thinking level if model supports it
 		const modelName = state.model?.id || "no-model";
 
-		// Add thinking level hint if model supports reasoning and thinking is enabled
+		// Add thinking level hint when the current model advertises supported efforts
 		let rightSide = modelName;
-		if (state.model?.reasoning) {
-			const thinkingLevel = state.thinkingLevel || "off";
-			if (thinkingLevel !== "off") {
+		if (state.model?.thinking) {
+			const thinkingLevel = state.thinkingLevel ?? ThinkingLevel.Off;
+			if (thinkingLevel !== ThinkingLevel.Off) {
 				rightSide = `${modelName} • ${thinkingLevel}`;
 			}
 		}