@oh-my-pi/pi-ai 13.8.0 → 13.9.2

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [13.9.2] - 2026-03-05
+
+### Added
+
+- Support for redacted thinking blocks in Anthropic messages, enabling secure handling of encrypted reasoning content
+- Preservation of latest Anthropic thinking blocks and redacted thinking content during message transformation, even when switching between Anthropic models
+
+### Changed
+
+- Assistant message content now includes `RedactedThinkingContent` type alongside existing text, thinking, and tool call blocks
+- Message transformation logic now preserves signed thinking blocks and redacted thinking for the latest assistant message in Anthropic conversations
+
+### Fixed
+
+- Fixed Unicode normalization to consistently apply `toWellFormed()` to all text content, including thinking blocks, ensuring proper handling of malformed UTF-16 sequences
+
+## [13.9.1] - 2026-03-05
+### Breaking Changes
+
+- Removed `THINKING_LEVELS`, `ALL_THINKING_LEVELS`, `ALL_THINKING_MODES`, `THINKING_MODE_DESCRIPTIONS`, and `THINKING_MODE_LABELS` exports
+- Renamed `formatThinking()` to `getThinkingMetadata()` with changed return type from string to `ThinkingMetadata` object
+- Renamed `getAvailableThinkingLevel()` to `getAvailableThinkingLevels()` and added default parameter
+- Renamed `getAvailableThinkingEffort()` to `getAvailableThinkingEfforts()` and added default parameter
+
+### Added
+
+- Added `ThinkingMetadata` type to provide structured access to thinking mode information (value, label, description)
+
+## [13.9.0] - 2026-03-05
+### Added
+
+- Exported new thinking module with `ThinkingEffort`, `ThinkingLevel`, and `ThinkingMode` types for managing reasoning effort levels
+- Added `getAvailableThinkingEffort()` function to determine supported thinking effort levels based on model capabilities
+- Added `parseThinkingEffort()`, `parseThinkingLevel()`, and `parseThinkingMode()` functions for parsing thinking configuration strings
+- Added `THINKING_LEVELS`, `ALL_THINKING_LEVELS`, and `ALL_THINKING_MODES` constants for iterating over available thinking options
+- Added `THINKING_MODE_DESCRIPTIONS` and `THINKING_MODE_LABELS` for displaying thinking modes in user interfaces
+- Added `formatThinking()` function to format thinking modes as compact display labels
+
+### Changed
+
+- Refactored thinking level handling to distinguish between `ThinkingEffort` (provider-level, no "off") and `ThinkingLevel` (user-facing, includes "off")
+- Updated `ThinkingBudgets` type to use `ThinkingEffort` instead of `ThinkingLevel` for more precise token budget configuration
+- Improved reasoning option handling to explicitly support "off" value for disabling reasoning across all providers
+- Simplified thinking effort mapping logic by centralizing provider-specific clamping behavior
+
 ## [13.7.8] - 2026-03-04
 
 ### Added
@@ -9,6 +54,7 @@
 - Added ZenMux provider support with mixed API routing: Anthropic-owned models discovered from `https://zenmux.ai/api/v1/models` now use the Anthropic transport (`https://zenmux.ai/api/anthropic`), while other ZenMux models use the OpenAI-compatible transport.
 
 ## [13.7.7] - 2026-03-04
+
 ### Changed
 
 - Modified response ID normalization to preserve existing item ID prefixes when truncating oversized IDs
@@ -19,6 +65,7 @@
 - Fixed handling of reasoning item IDs to remain untouched during response normalization while function call IDs are properly normalized
 
 ## [13.7.2] - 2026-03-04
+
 ### Added
 
 - Added support for Kagi API key authentication via `login kagi` command
@@ -31,6 +78,7 @@
 - Tool schema compilation is now cached per schema identity, eliminating redundant recompilation on every tool call
 
 ## [13.6.0] - 2026-03-03
+
 ### Added
 
 - Added Anthropic Foundry gateway mode controlled by `CLAUDE_CODE_USE_FOUNDRY`, with support for `FOUNDRY_BASE_URL`, `ANTHROPIC_FOUNDRY_API_KEY`, `ANTHROPIC_CUSTOM_HEADERS`, and optional mTLS material (`CLAUDE_CODE_CLIENT_CERT`, `CLAUDE_CODE_CLIENT_KEY`, `NODE_EXTRA_CA_CERTS`)
@@ -43,6 +91,7 @@
 - Anthropic auth base-URL fallback now prefers `FOUNDRY_BASE_URL` when `CLAUDE_CODE_USE_FOUNDRY` is enabled
 
 ## [13.5.8] - 2026-03-02
+
 ### Fixed
 
 - Fixed schema compatibility issue where patternProperties in tool parameters caused failures when converting to legacy Antigravity format
@@ -59,6 +108,7 @@
 - Anthropic cache-control normalization now removes later `ttl: "1h"` entries when a default/5m block has already appeared earlier in evaluation order
 
 ## [13.5.3] - 2026-03-01
+
 ### Fixed
 
 - Fixed tool argument coercion to handle malformed JSON with trailing wrapper braces by parsing leading JSON containers

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "13.8.0",
+	"version": "13.9.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,7 +41,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
 		"@google/genai": "^1.43",
-		"@oh-my-pi/pi-utils": "13.8.0",
+		"@oh-my-pi/pi-utils": "13.9.2",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.18",

package/src/index.ts

@@ -21,6 +21,7 @@ export * from "./providers/openai-responses";
 export * from "./providers/synthetic";
 export * from "./rate-limit-utils";
 export * from "./stream";
+export * from "./thinking";
 export * from "./types";
 export * from "./usage";
 export * from "./usage/claude";

package/src/models.json

@@ -38967,4 +38967,4 @@
 			"maxTokens": 128000
 		}
 	}
-}
+}

package/src/prompts/turn-aborted-guidance.md

@@ -0,0 +1,4 @@
+<turn-aborted>
+The previous turn was aborted. Any running tools/commands were terminated. 
+If tools were aborted, they may have partially executed; verify current state before retrying.
+</turn-aborted>

package/src/providers/amazon-bedrock.ts

@@ -22,6 +22,7 @@ import {
 import { $env } from "@oh-my-pi/pi-utils";
 import { NodeHttpHandler } from "@smithy/node-http-handler";
 import { calculateCost } from "../models";
+import type { ThinkingEffort, ThinkingLevel } from "../thinking";
 import type {
 	Api,
 	AssistantMessage,
@@ -35,7 +36,6 @@ import type {
 	TextContent,
 	ThinkingBudgets,
 	ThinkingContent,
-	ThinkingLevel,
 	Tool,
 	ToolCall,
 	ToolResultMessage,
@@ -622,14 +622,15 @@ function buildAdditionalModelRequestFields(
 	model: Model<"bedrock-converse-stream">,
 	options: BedrockOptions,
 ): Record<string, any> | undefined {
-	if (!options.reasoning || !model.reasoning) {
+	const reasoning = options.reasoning;
+	if (!reasoning || !model.reasoning || reasoning === "off") {
 		return undefined;
 	}
 
 	if (model.id.includes("anthropic.claude")) {
 		// Opus 4.6+ / Sonnet 4.6+ uses adaptive thinking with effort levels
 		if (supportsAdaptiveThinking(model.id)) {
-			let effort = mapThinkingLevelToEffort(options.reasoning);
+			let effort = mapThinkingLevelToEffort(reasoning);
 			// "max" effort is only supported on Opus 4.6; clamp to "high" for Sonnet 4.6
 			const supportsMax = model.id.includes("opus-4-6") || model.id.includes("opus-4.6");
 			if (effort === "max" && !supportsMax) {
@@ -642,7 +643,7 @@ function buildAdditionalModelRequestFields(
 			return result;
 		}
 
-		const defaultBudgets: Record<ThinkingLevel, number> = {
+		const defaultBudgets: Record<ThinkingEffort, number> = {
 			minimal: 1024,
 			low: 2048,
 			medium: 8192,
@@ -651,8 +652,8 @@ function buildAdditionalModelRequestFields(
 		};
 
 		// Custom budgets override defaults (xhigh not in ThinkingBudgets, use high)
-		const level = options.reasoning === "xhigh" ? "high" : options.reasoning;
-		const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[options.reasoning];
+		const level = reasoning === "xhigh" ? "high" : reasoning;
+		const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[level];
 
 		const result: Record<string, any> = {
 			thinking: {

package/src/providers/anthropic.ts

@@ -18,6 +18,7 @@ import type {
 	ImageContent,
 	Message,
 	Model,
+	RedactedThinkingContent,
 	SimpleStreamOptions,
 	StopReason,
 	StreamFunction,
@@ -613,7 +614,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				body: params,
 			};
 
-			type Block = (ThinkingContent | TextContent | (ToolCall & { partialJson: string })) & { index: number };
+			type Block = (
+				| ThinkingContent
+				| RedactedThinkingContent
+				| TextContent
+				| (ToolCall & { partialJson: string })
+			) & { index: number };
 			const blocks = output.content as Block[];
 			stream.push({ type: "start", partial: output });
 			// Retry loop for transient errors from the stream.
@@ -664,6 +670,13 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									contentIndex: output.content.length - 1,
 									partial: output,
 								});
+							} else if (event.content_block.type === "redacted_thinking") {
+								const block: Block = {
+									type: "redactedThinking",
+									data: event.content_block.data,
+									index: event.index,
+								};
+								output.content.push(block);
 							} else if (event.content_block.type === "tool_use") {
 								const block: Block = {
 									type: "toolCall",
@@ -1403,6 +1416,10 @@ export function convertAnthropicMessages(
 			}
 		} else if (msg.role === "assistant") {
 			const blocks: ContentBlockParam[] = [];
+			const hasSignedThinking = msg.content.some(
+				block =>
+					block.type === "thinking" && !!block.thinkingSignature && block.thinkingSignature.trim().length > 0,
+			);
 
 			for (const block of msg.content) {
 				if (block.type === "text") {
@@ -1412,6 +1429,22 @@ export function convertAnthropicMessages(
 						text: block.text.toWellFormed(),
 					});
 				} else if (block.type === "thinking") {
+					if (hasSignedThinking) {
+						if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+							if (block.thinking.trim().length === 0) continue;
+							blocks.push({
+								type: "text",
+								text: block.thinking.toWellFormed(),
+							});
+							continue;
+						}
+						blocks.push({
+							type: "thinking",
+							thinking: block.thinking,
+							signature: block.thinkingSignature,
+						});
+						continue;
+					}
 					if (block.thinking.trim().length === 0) continue;
 					if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
 						blocks.push({
@@ -1425,6 +1458,12 @@ export function convertAnthropicMessages(
 							signature: block.thinkingSignature,
 						});
 					}
+				} else if (block.type === "redactedThinking") {
+					if (block.data.trim().length === 0) continue;
+					blocks.push({
+						type: "redacted_thinking",
+						data: block.data,
+					});
 				} else if (block.type === "toolCall") {
 					blocks.push({
 						type: "tool_use",

package/src/providers/azure-openai-responses.ts

@@ -61,7 +61,7 @@ function resolveDeploymentName(model: Model<"azure-openai-responses">, options?:
 
 // Azure OpenAI Responses-specific options
 export interface AzureOpenAIResponsesOptions extends StreamOptions {
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "detailed" | "concise" | null;
 	azureApiVersion?: string;
 	azureResourceName?: string;
@@ -499,9 +499,9 @@ function buildParams(
 		// See: https://github.com/can1357/oh-my-pi/issues/41
 		params.include = ["reasoning.encrypted_content"];
 
-		if (options?.reasoningEffort || options?.reasoningSummary) {
+		if (options?.reasoning || options?.reasoningSummary) {
 			params.reasoning = {
-				effort: options?.reasoningEffort || "medium",
+				effort: options?.reasoning || "medium",
 				summary: options?.reasoningSummary || "auto",
 			};
 		} else {

package/src/providers/gitlab-duo.ts

@@ -267,6 +267,11 @@ export function streamGitLabDuo(
 				...options.headers,
 			};
 
+			const reasoningEffort =
+				options.reasoning === "off"
+					? undefined
+					: (options.reasoning as "minimal" | "low" | "medium" | "high" | "xhigh" | undefined);
+
 			const inner =
 				mapping.provider === "anthropic"
 					? streamAnthropic(
@@ -295,11 +300,11 @@ export function streamGitLabDuo(
 								sessionId: options.sessionId,
 								providerSessionState: options.providerSessionState,
 								onPayload: options.onPayload,
-								thinkingEnabled: Boolean(options.reasoning) && model.reasoning,
-								thinkingBudgetTokens: options.reasoning
-									? (options.thinkingBudgets?.[options.reasoning] ?? ANTHROPIC_THINKING[options.reasoning])
+								thinkingEnabled: Boolean(reasoningEffort) && model.reasoning,
+								thinkingBudgetTokens: reasoningEffort
+									? (options.thinkingBudgets?.[reasoningEffort] ?? ANTHROPIC_THINKING[reasoningEffort])
 									: undefined,
-								reasoning: options.reasoning,
+								reasoning: reasoningEffort,
 								toolChoice: mapAnthropicToolChoice(options.toolChoice),
 							},
 						)
@@ -329,7 +334,7 @@ export function streamGitLabDuo(
 									sessionId: options.sessionId,
 									providerSessionState: options.providerSessionState,
 									onPayload: options.onPayload,
-									reasoningEffort: options.reasoning,
+									reasoning: reasoningEffort,
 									toolChoice: options.toolChoice,
 								} satisfies OpenAIResponsesOptions,
 							)
@@ -358,7 +363,7 @@ export function streamGitLabDuo(
 									sessionId: options.sessionId,
 									providerSessionState: options.providerSessionState,
 									onPayload: options.onPayload,
-									reasoningEffort: options.reasoning,
+									reasoning: reasoningEffort,
 									toolChoice: options.toolChoice,
 								} satisfies OpenAICompletionsOptions,
 							);

package/src/providers/kimi.ts

@@ -62,9 +62,10 @@ export function streamKimi(
 
 				// Calculate thinking budget from reasoning level
 				const reasoning = options?.reasoning;
-				const thinkingEnabled = !!reasoning && model.reasoning;
-				const thinkingBudget = reasoning
-					? (options?.thinkingBudgets?.[reasoning] ?? ANTHROPIC_THINKING[reasoning])
+				const reasoningEffort = reasoning === "off" ? undefined : reasoning;
+				const thinkingEnabled = !!reasoningEffort && model.reasoning;
+				const thinkingBudget = reasoningEffort
+					? (options?.thinkingBudgets?.[reasoningEffort] ?? ANTHROPIC_THINKING[reasoningEffort])
 					: undefined;
 
 				const innerStream = streamAnthropic(anthropicModel, context, {
@@ -89,6 +90,7 @@ export function streamKimi(
 				}
 			} else {
 				// OpenAI format - use original model with Kimi headers
+				const reasoningEffort = options?.reasoning === "off" ? undefined : options?.reasoning;
 				const innerStream = streamOpenAICompletions(model, context, {
 					apiKey: options?.apiKey,
 					temperature: options?.temperature,
@@ -102,7 +104,7 @@ export function streamKimi(
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,
 					onPayload: options?.onPayload,
-					reasoningEffort: options?.reasoning,
+					reasoning: reasoningEffort,
 				});
 
 				for await (const event of innerStream) {

package/src/providers/openai-codex-responses.ts

@@ -49,7 +49,7 @@ import { parseCodexError } from "./openai-codex/response-handler";
 import { transformMessages } from "./transform-messages";
 
 export interface OpenAICodexResponsesOptions extends StreamOptions {
-	reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoning?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "concise" | "detailed" | null;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
@@ -369,7 +369,7 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 			params.instructions = systemPrompt.instructions;
 
 			const codexOptions: CodexRequestOptions = {
-				reasoningEffort: options?.reasoningEffort,
+				reasoningEffort: options?.reasoning,
 				reasoningSummary: options?.reasoningSummary ?? "auto",
 				textVerbosity: options?.textVerbosity,
 				include: options?.include,

package/src/providers/openai-completions.ts

@@ -109,7 +109,7 @@ function hasToolHistory(messages: Message[]): boolean {
 
 export interface OpenAICompletionsOptions extends StreamOptions {
 	toolChoice?: ToolChoice;
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
 }
 
 type OpenAICompletionsSamplingParams = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming & {
@@ -611,13 +611,13 @@ function buildParams(model: Model<"openai-completions">, context: Context, optio
 	if (compat.thinkingFormat === "zai" && model.reasoning) {
 		// Z.ai uses binary thinking: { type: "enabled" | "disabled" }
 		// Must explicitly disable since z.ai defaults to thinking enabled
-		(params as any).thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
+		(params as any).thinking = { type: options?.reasoning ? "enabled" : "disabled" };
 	} else if (compat.thinkingFormat === "qwen" && model.reasoning) {
 		// Qwen uses enable_thinking: boolean
-		(params as any).enable_thinking = !!options?.reasoningEffort;
-	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+		(params as any).enable_thinking = !!options?.reasoning;
+	} else if (options?.reasoning && model.reasoning && compat.supportsReasoningEffort) {
 		// OpenAI-style reasoning_effort
-		params.reasoning_effort = options.reasoningEffort;
+		params.reasoning_effort = options?.reasoning;
 	}
 
 	// OpenRouter provider routing preferences

package/src/providers/openai-responses.ts

@@ -57,7 +57,7 @@ function getPromptCacheRetention(baseUrl: string, cacheRetention: CacheRetention
 
 // OpenAI Responses-specific options
 export interface OpenAIResponsesOptions extends StreamOptions {
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "detailed" | "concise" | null;
 	serviceTier?: ResponseCreateParamsStreaming["service_tier"];
 	toolChoice?: ToolChoice;
@@ -480,9 +480,9 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
 		// See: https://github.com/can1357/oh-my-pi/issues/41
 		params.include = ["reasoning.encrypted_content"];
 
-		if (options?.reasoningEffort || options?.reasoningSummary) {
+		if (options?.reasoning || options?.reasoningSummary) {
 			params.reasoning = {
-				effort: options?.reasoningEffort || "medium",
+				effort: options?.reasoning || "medium",
 				summary: options?.reasoningSummary || "auto",
 			};
 		} else {

package/src/providers/synthetic.ts

@@ -59,9 +59,10 @@ export function streamSynthetic(
 
 				// Calculate thinking budget from reasoning level
 				const reasoning = options?.reasoning;
-				const thinkingEnabled = !!reasoning && model.reasoning;
-				const thinkingBudget = reasoning
-					? (options?.thinkingBudgets?.[reasoning] ?? ANTHROPIC_THINKING[reasoning])
+				const reasoningEffort = reasoning === "off" ? undefined : reasoning;
+				const thinkingEnabled = !!reasoningEffort && model.reasoning;
+				const thinkingBudget = reasoningEffort
+					? (options?.thinkingBudgets?.[reasoningEffort] ?? ANTHROPIC_THINKING[reasoningEffort])
 					: undefined;
 
 				const innerStream = streamAnthropic(anthropicModel, context, {
@@ -92,6 +93,7 @@ export function streamSynthetic(
 					headers: mergedHeaders,
 				};
 
+				const reasoningEffort = options?.reasoning === "off" ? undefined : options?.reasoning;
 				const innerStream = streamOpenAICompletions(syntheticModel, context, {
 					apiKey: options?.apiKey,
 					temperature: options?.temperature,
@@ -105,7 +107,7 @@ export function streamSynthetic(
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,
 					onPayload: options?.onPayload,
-					reasoningEffort: options?.reasoning,
+					reasoning: reasoningEffort,
 				});
 
 				for await (const event of innerStream) {

package/src/providers/transform-messages.ts

@@ -1,11 +1,6 @@
+import turnAbortedGuidance from "../prompts/turn-aborted-guidance.md" with { type: "text" };
 import type { Api, AssistantMessage, DeveloperMessage, Message, Model, ToolCall, ToolResultMessage } from "../types";
 
-const TURN_ABORTED_GUIDANCE =
-	"<turn-aborted>\n" +
-	"The previous turn was aborted. Any running tools/commands were terminated. " +
-	"If tools were aborted, they may have partially executed; verify current state before retrying.\n" +
-	"</turn-aborted>";
-
 const enum ToolCallStatus {
 	/** Tool call has received a result (real or synthetic for orphan) */
 	Resolved = 1,
@@ -31,8 +26,9 @@ export function transformMessages<TApi extends Api>(
 	// Build a map of original tool call IDs to normalized IDs
 	const toolCallIdMap = new Map<string, string>();
 
+	const latestAssistantIndex = messages.findLastIndex(msg => msg.role === "assistant");
 	// First pass: transform messages (thinking blocks, tool call ID normalization)
-	const transformed = messages.map(msg => {
+	const transformed = messages.map((msg, index) => {
 		// User and developer messages pass through unchanged
 		if (msg.role === "user" || msg.role === "developer") {
 			return msg;
@@ -55,8 +51,14 @@ export function transformMessages<TApi extends Api>(
 				assistantMsg.api === model.api &&
 				assistantMsg.model === model.id;
 
+			const mustPreserveLatestAnthropicThinking =
+				index === latestAssistantIndex &&
+				model.api === "anthropic-messages" &&
+				assistantMsg.api === "anthropic-messages";
+
 			const transformedContent = assistantMsg.content.flatMap(block => {
 				if (block.type === "thinking") {
+					if (mustPreserveLatestAnthropicThinking) return block;
 					// For same model: keep thinking blocks with signatures (needed for replay)
 					// even if the thinking text is empty (OpenAI encrypted reasoning)
 					if (isSameModel && block.thinkingSignature) return block;
@@ -69,6 +71,12 @@ export function transformMessages<TApi extends Api>(
 					};
 				}
 
+				if (block.type === "redactedThinking") {
+					if (mustPreserveLatestAnthropicThinking) return block;
+					if (isSameModel) return block;
+					return [];
+				}
+
 				if (block.type === "text") {
 					if (isSameModel) return block;
 					return {
@@ -163,7 +171,7 @@ export function transformMessages<TApi extends Api>(
 				// Inject turn_aborted guidance marker as developer message
 				result.push({
 					role: "developer",
-					content: TURN_ABORTED_GUIDANCE,
+					content: turnAbortedGuidance,
 					timestamp: assistantMsg.timestamp + 1,
 				} as DeveloperMessage);
 

package/src/stream.ts

@@ -21,6 +21,7 @@ import { streamOpenAICodexResponses } from "./providers/openai-codex-responses";
 import { type OpenAICompletionsOptions, streamOpenAICompletions } from "./providers/openai-completions";
 import { streamOpenAIResponses } from "./providers/openai-responses";
 import { isSyntheticModel, streamSynthetic } from "./providers/synthetic";
+import type { ThinkingEffort } from "./thinking";
 import type {
 	Api,
 	AssistantMessage,
@@ -31,7 +32,6 @@ import type {
 	SimpleStreamOptions,
 	StreamOptions,
 	ThinkingBudgets,
-	ThinkingLevel,
 	ToolChoice,
 } from "./types";
 
@@ -301,9 +301,9 @@ export async function completeSimple<TApi extends Api>(
 
 const MIN_OUTPUT_TOKENS = 1024;
 export const OUTPUT_FALLBACK_BUFFER = 4000;
-const ANTHROPIC_USE_INTERLEAVED_THINKING = true;
+const ANTHROPIC_USE_INTERLEAVED_THINKING = Bun.env.PI_NO_INTERLEAVED_THINKING !== "1";
 
-export const ANTHROPIC_THINKING: Record<ThinkingLevel, number> = {
+export const ANTHROPIC_THINKING: Record<ThinkingEffort, number> = {
 	minimal: 1024,
 	low: 4096,
 	medium: 8192,
@@ -311,7 +311,7 @@ export const ANTHROPIC_THINKING: Record<ThinkingLevel, number> = {
 	xhigh: 32768,
 };
 
-const GOOGLE_THINKING: Record<ThinkingLevel, number> = {
+const GOOGLE_THINKING: Record<ThinkingEffort, number> = {
 	minimal: 1024,
 	low: 4096,
 	medium: 8192,
@@ -319,7 +319,7 @@ const GOOGLE_THINKING: Record<ThinkingLevel, number> = {
 	xhigh: 24575,
 };
 
-const BEDROCK_CLAUDE_THINKING: Record<ThinkingLevel, number> = {
+const BEDROCK_CLAUDE_THINKING: Record<ThinkingEffort, number> = {
 	minimal: 1024,
 	low: 2048,
 	medium: 8192,
@@ -330,8 +330,8 @@ const BEDROCK_CLAUDE_THINKING: Record<ThinkingLevel, number> = {
 function resolveBedrockThinkingBudget(
 	model: Model<"bedrock-converse-stream">,
 	options?: SimpleStreamOptions,
-): { budget: number; level: ThinkingLevel } | null {
-	if (!options?.reasoning || !model.reasoning) return null;
+): { budget: number; level: ThinkingEffort } | null {
+	if (!options?.reasoning || !model.reasoning || options.reasoning === "off") return null;
 	if (!model.id.includes("anthropic.claude")) return null;
 	const level = options.reasoning === "xhigh" ? "high" : options.reasoning;
 	const budget = options.thinkingBudgets?.[level] ?? BEDROCK_CLAUDE_THINKING[level];
@@ -358,7 +358,7 @@ export function mapAnthropicToolChoice(choice?: ToolChoice): AnthropicOptions["t
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking (Opus 4.6+)
  */
-function mapThinkingLevelToAnthropicEffort(level: ThinkingLevel): AnthropicOptions["effort"] {
+function mapThinkingLevelToAnthropicEffort(level: ThinkingEffort, supportsXhigh: boolean): AnthropicOptions["effort"] {
 	switch (level) {
 		case "minimal":
 			return "low";
@@ -369,7 +369,7 @@ function mapThinkingLevelToAnthropicEffort(level: ThinkingLevel): AnthropicOptio
 		case "high":
 			return "high";
 		case "xhigh":
-			return "max";
+			return supportsXhigh ? "max" : "high";
 		default:
 			return "high";
 	}
@@ -404,6 +404,18 @@ function mapOpenAiToolChoice(choice?: ToolChoice): OpenAICompletionsOptions["too
 	return undefined;
 }
 
+function resolveOpenAiReasoningEffort<TApi extends Api>(
+	model: Model<TApi>,
+	options?: SimpleStreamOptions,
+): ThinkingEffort | undefined {
+	const reasoning = options?.reasoning;
+	if (!reasoning || reasoning === "off") return undefined;
+	if (reasoning === "xhigh" && !supportsXhigh(model)) return "high";
+	return reasoning;
+}
+
+const castApi = <TApi extends Api>(api: OptionsForApi<TApi>): OptionsForApi<Api> => api as OptionsForApi<Api>;
+
 function mapOptionsForApi<TApi extends Api>(
 	model: Model<TApi>,
 	options?: SimpleStreamOptions,
@@ -429,28 +441,25 @@ function mapOptionsForApi<TApi extends Api>(
 		execHandlers: options?.execHandlers,
 	};
 
-	// Helper to clamp xhigh to high for providers that don't support it
-	const clampReasoning = (effort: ThinkingLevel | undefined) => (effort === "xhigh" ? "high" : effort);
-
 	switch (model.api) {
 		case "anthropic-messages": {
 			// Explicitly disable thinking when reasoning is not specified
 			const reasoning = options?.reasoning;
-			if (!reasoning) {
-				return {
+			if (!reasoning || reasoning === "off") {
+				return castApi<"anthropic-messages">({
 					...base,
 					thinkingEnabled: false,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			let thinkingBudget = options.thinkingBudgets?.[reasoning] ?? ANTHROPIC_THINKING[reasoning];
 			if (thinkingBudget <= 0) {
-				return {
+				return castApi<"anthropic-messages">({
 					...base,
 					thinkingEnabled: false,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			// For Opus 4.6+ and Sonnet 4.6+: use adaptive thinking with effort level
@@ -462,24 +471,22 @@ function mapOptionsForApi<TApi extends Api>(
 				model.id.includes("sonnet-4.6")
 			) {
 				const supportsMaxEffort = model.id.includes("opus-4-6") || model.id.includes("opus-4.6");
-				const effort = mapThinkingLevelToAnthropicEffort(
-					supportsMaxEffort ? reasoning : (clampReasoning(reasoning) ?? reasoning),
-				);
-				return {
+				const effort = mapThinkingLevelToAnthropicEffort(reasoning, supportsMaxEffort);
+				return castApi<"anthropic-messages">({
 					...base,
 					thinkingEnabled: true,
 					effort,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			if (ANTHROPIC_USE_INTERLEAVED_THINKING) {
-				return {
+				return castApi<"anthropic-messages">({
 					...base,
 					thinkingEnabled: true,
 					thinkingBudgetTokens: thinkingBudget,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			// Caller's maxTokens is the desired output; add thinking budget on top, capped at model limit
@@ -492,19 +499,19 @@ function mapOptionsForApi<TApi extends Api>(
 
 			// If thinking budget is too low, disable thinking
 			if (thinkingBudget <= 0) {
-				return {
+				return castApi<"anthropic-messages">({
 					...base,
 					thinkingEnabled: false,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			} else {
-				return {
+				return castApi<"anthropic-messages">({
 					...base,
 					maxTokens,
 					thinkingEnabled: true,
 					thinkingBudgetTokens: thinkingBudget,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 		}
 
@@ -529,96 +536,98 @@ function mapOptionsForApi<TApi extends Api>(
 				const adjustedBudget = Math.max(0, maxTokens - MIN_OUTPUT_TOKENS);
 				thinkingBudgets = { ...(thinkingBudgets ?? {}), [budgetInfo.level]: adjustedBudget };
 			}
-			return { ...bedrockBase, maxTokens, thinkingBudgets } as OptionsForApi<TApi>;
+			return castApi<"bedrock-converse-stream">({ ...bedrockBase, maxTokens, thinkingBudgets });
 		}
 
 		case "openai-completions":
-			return {
+			return castApi<"openai-completions">({
 				...base,
-				reasoningEffort: supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning),
+				reasoning: resolveOpenAiReasoningEffort(model, options),
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
-			} as OptionsForApi<TApi>;
+			});
 
 		case "openai-responses":
-			return {
+			return castApi<"openai-responses">({
 				...base,
-				reasoningEffort: supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning),
+				reasoning: resolveOpenAiReasoningEffort(model, options),
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
-			} as OptionsForApi<TApi>;
+			});
 
 		case "azure-openai-responses":
-			return {
+			return castApi<"azure-openai-responses">({
 				...base,
-				reasoningEffort: supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning),
+				reasoning: resolveOpenAiReasoningEffort(model, options),
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
-			} as OptionsForApi<TApi>;
+			});
 
 		case "openai-codex-responses":
-			return {
+			return castApi<"openai-codex-responses">({
 				...base,
-				reasoningEffort: supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning),
+				reasoning: resolveOpenAiReasoningEffort(model, options),
 				toolChoice: mapOpenAiToolChoice(options?.toolChoice),
 				preferWebsockets: options?.preferWebsockets,
-			} as OptionsForApi<TApi>;
+			});
 
 		case "google-generative-ai": {
 			// Explicitly disable thinking when reasoning is not specified
 			// This is needed because Gemini has "dynamic thinking" enabled by default
-			if (!options?.reasoning) {
-				return {
+			const reasoning = options?.reasoning;
+			if (!reasoning || reasoning === "off") {
+				return castApi<"google-generative-ai">({
 					...base,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			const googleModel = model as Model<"google-generative-ai">;
-			const effort = clampReasoning(options.reasoning)!;
+			const effort = reasoning === "xhigh" ? "high" : reasoning;
 
 			// Gemini 3+ models use thinkingLevel exclusively instead of thinkingBudget.
 			// https://ai.google.dev/gemini-api/docs/thinking#set-budget
 			if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel)) {
-				return {
+				return castApi<"google-generative-ai">({
 					...base,
 					thinking: {
 						enabled: true,
 						level: getGemini3ThinkingLevel(effort, googleModel),
 					},
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
-			return {
+			return castApi<"google-gemini-cli">({
 				...base,
 				thinking: {
 					enabled: true,
 					budgetTokens: getGoogleBudget(googleModel, effort, options?.thinkingBudgets),
 				},
 				toolChoice: mapGoogleToolChoice(options?.toolChoice),
-			} as OptionsForApi<TApi>;
+			});
 		}
 
 		case "google-gemini-cli": {
-			if (!options?.reasoning) {
-				return {
+			const reasoning = options?.reasoning;
+			if (!reasoning || reasoning === "off") {
+				return castApi<"google-gemini-cli">({
 					...base,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
-			const effort = clampReasoning(options.reasoning)!;
+			const effort = reasoning === "xhigh" ? "high" : reasoning;
 
 			// Gemini 3+ models use thinkingLevel instead of thinkingBudget
 			if (isGemini3ProModelId(model.id) || isGemini3FlashModelId(model.id)) {
-				return {
+				return castApi<"google-vertex">({
 					...base,
 					thinking: {
 						enabled: true,
 						level: getGeminiCliThinkingLevel(effort, model.id),
 					},
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			let thinkingBudget = options.thinkingBudgets?.[effort] ?? GOOGLE_THINKING[effort];
@@ -633,64 +642,65 @@ function mapOptionsForApi<TApi extends Api>(
 
 			// If thinking budget is too low, disable thinking
 			if (thinkingBudget <= 0) {
-				return {
+				return castApi<"google-gemini-cli">({
 					...base,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			} else {
-				return {
+				return castApi<"google-gemini-cli">({
 					...base,
 					maxTokens,
 					thinking: { enabled: true, budgetTokens: thinkingBudget },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 		}
 
 		case "google-vertex": {
 			// Explicitly disable thinking when reasoning is not specified
-			if (!options?.reasoning) {
-				return {
+			const reasoning = options?.reasoning;
+			if (!reasoning || reasoning === "off") {
+				return castApi<"google-vertex">({
 					...base,
 					thinking: { enabled: false },
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
 			const vertexModel = model as Model<"google-vertex">;
-			const effort = clampReasoning(options.reasoning)!;
+			const effort = reasoning === "xhigh" ? "high" : reasoning;
 			const geminiModel = vertexModel as unknown as Model<"google-generative-ai">;
 
 			if (isGemini3ProModel(geminiModel) || isGemini3FlashModel(geminiModel)) {
-				return {
+				return castApi<"google-vertex">({
 					...base,
 					thinking: {
 						enabled: true,
 						level: getGemini3ThinkingLevel(effort, geminiModel),
 					},
 					toolChoice: mapGoogleToolChoice(options?.toolChoice),
-				} as OptionsForApi<TApi>;
+				});
 			}
 
-			return {
+			return castApi<"google-vertex">({
 				...base,
 				thinking: {
 					enabled: true,
 					budgetTokens: getGoogleBudget(geminiModel, effort, options?.thinkingBudgets),
 				},
 				toolChoice: mapGoogleToolChoice(options?.toolChoice),
-			} as OptionsForApi<TApi>;
+			});
 		}
 
 		case "cursor-agent": {
 			const execHandlers = options?.cursorExecHandlers ?? options?.execHandlers;
 			const onToolResult = options?.cursorOnToolResult ?? execHandlers?.onToolResult;
-			return {
+			return castApi<"cursor-agent">({
 				...base,
 				execHandlers,
 				onToolResult,
-			} as OptionsForApi<TApi>;
+			});
 		}
 
 		default:
@@ -698,8 +708,6 @@ function mapOptionsForApi<TApi extends Api>(
 	}
 }
 
-type ClampedThinkingLevel = Exclude<ThinkingLevel, "xhigh">;
-
 function isGemini3ProModelId(modelId: string): boolean {
 	return /3(?:\.\d+)?-pro/.test(modelId);
 }
@@ -718,18 +726,14 @@ function isGemini3FlashModel(model: Model<"google-generative-ai">): boolean {
 	return isGemini3FlashModelId(model.id);
 }
 
-function getGemini3ThinkingLevel(
-	effort: ClampedThinkingLevel,
-	model: Model<"google-generative-ai">,
-): GoogleThinkingLevel {
+function getGemini3ThinkingLevel(effort: ThinkingEffort, model: Model<"google-generative-ai">): GoogleThinkingLevel {
 	if (isGemini3ProModel(model)) {
 		// Gemini 3 Pro only supports LOW/HIGH (for now)
 		switch (effort) {
 			case "minimal":
 			case "low":
 				return "LOW";
-			case "medium":
-			case "high":
+			default:
 				return "HIGH";
 		}
 	}
@@ -741,20 +745,19 @@ function getGemini3ThinkingLevel(
 			return "LOW";
 		case "medium":
 			return "MEDIUM";
-		case "high":
+		default:
 			return "HIGH";
 	}
 }
 
-function getGeminiCliThinkingLevel(effort: ClampedThinkingLevel, modelId: string): GoogleThinkingLevel {
+function getGeminiCliThinkingLevel(effort: ThinkingEffort, modelId: string): GoogleThinkingLevel {
 	if (isGemini3ProModelId(modelId)) {
 		// Gemini 3 Pro only supports LOW/HIGH (for now)
 		switch (effort) {
 			case "minimal":
 			case "low":
 				return "LOW";
-			case "medium":
-			case "high":
+			default:
 				return "HIGH";
 		}
 	}
@@ -766,41 +769,35 @@ function getGeminiCliThinkingLevel(effort: ClampedThinkingLevel, modelId: string
 			return "LOW";
 		case "medium":
 			return "MEDIUM";
-		case "high":
+		default:
 			return "HIGH";
 	}
 }
 
 function getGoogleBudget(
 	model: Model<"google-generative-ai">,
-	effort: ClampedThinkingLevel,
+	effort: ThinkingEffort,
 	customBudgets?: ThinkingBudgets,
 ): number {
+	effort = effort === "xhigh" ? "high" : effort;
+
 	// Custom budgets take precedence if provided for this level
 	if (customBudgets?.[effort] !== undefined) {
 		return customBudgets[effort]!;
 	}
 
 	// See https://ai.google.dev/gemini-api/docs/thinking#set-budget
-	if (model.id.includes("2.5-pro")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 32768,
-		};
-		return budgets[effort];
-	}
-
-	if (model.id.includes("2.5-flash")) {
-		// Covers 2.5-flash-lite as well
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 24576,
-		};
-		return budgets[effort];
+	if (model.id.includes("2.5-")) {
+		switch (effort) {
+			case "minimal":
+				return 128;
+			case "low":
+				return 2048;
+			case "medium":
+				return 8192;
+			default:
+				return model.id.includes("2.5-flash") ? 24576 : 32768;
+		}
 	}
 
 	// Unknown model - use dynamic

package/src/thinking.ts

@@ -0,0 +1,85 @@
+/** Provider-level thinking levels (no "off"), ordered least to most. */
+export type ThinkingEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+
+/**
+ * ThinkingLevel extended with "off" to disable reasoning entirely.
+ * Used in UI, config, session state, and CLI args.
+ * "off" is never sent to providers — callers strip it before streaming.
+ */
+export type ThinkingLevel = ThinkingEffort | "off";
+
+/**
+ * ThinkingSelector extended with "inherit" to indicate the role should
+ * use the session-level default rather than an explicit choice.
+ * Used in per-role model assignment UI.
+ */
+export type ThinkingMode = ThinkingLevel | "inherit";
+
+/** Metadata for a thinking mode. */
+export type ThinkingMetadata = {
+	/** The value of the thinking mode. */
+	value: ThinkingMode;
+	/** The label to display for the thinking mode. */
+	label: string;
+	/** The description to display for the thinking mode. */
+	description: string;
+};
+
+const THINKING_META: Record<ThinkingMode, ThinkingMetadata> = {
+	inherit: { value: "inherit", label: "inherit", description: "Inherit session default" },
+	off: { value: "off", label: "off", description: "No reasoning" },
+	minimal: { value: "minimal", label: "min", description: "Very brief reasoning (~1k tokens)" },
+	low: { value: "low", label: "low", description: "Light reasoning (~2k tokens)" },
+	medium: { value: "medium", label: "medium", description: "Moderate reasoning (~8k tokens)" },
+	high: { value: "high", label: "high", description: "Deep reasoning (~16k tokens)" },
+	xhigh: { value: "xhigh", label: "xhigh", description: "Maximum reasoning (~32k tokens)" },
+};
+
+const F_LEVEL = 3;
+const F_SEL = 2;
+const F_MODE = 1;
+
+const F_THINKING: Record<string, number> = {
+	inherit: F_MODE,
+	off: F_SEL,
+	minimal: F_LEVEL,
+	low: F_LEVEL,
+	medium: F_LEVEL,
+	high: F_LEVEL,
+	xhigh: F_LEVEL,
+};
+
+// Parses an unknown value and returns a ThinkingLevel if valid, otherwise undefined.
+export function parseThinkingEffort(level: string | null | undefined): ThinkingEffort | undefined {
+	return level && (F_THINKING[level] ?? 0) >= F_LEVEL ? (level as ThinkingEffort) : undefined;
+}
+
+// Parses an unknown value and returns a ThinkingSelector if valid, otherwise undefined.
+export function parseThinkingLevel(level: string | null | undefined): ThinkingLevel | undefined {
+	return level && (F_THINKING[level] ?? 0) >= F_SEL ? (level as ThinkingLevel) : undefined;
+}
+
+// Parses an unknown value and returns a ThinkingMode if valid, otherwise undefined.
+export function parseThinkingMode(level: string | null | undefined): ThinkingMode | undefined {
+	return level && (F_THINKING[level] ?? 0) >= F_MODE ? (level as ThinkingMode) : undefined;
+}
+
+/** Get the information for a thinking mode. */
+export function getThinkingMetadata(mode: ThinkingMode): ThinkingMetadata {
+	return THINKING_META[mode];
+}
+
+const REG_LVL: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high"];
+const XHI_LVL: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
+
+/** Returns the available thinking modes for a model based on whether it supports xhigh. */
+export function getAvailableThinkingLevels(hasXhigh: boolean = true): ReadonlyArray<ThinkingLevel> {
+	return hasXhigh ? XHI_LVL : REG_LVL;
+}
+
+const REG_EFF: readonly ThinkingEffort[] = ["minimal", "low", "medium", "high"];
+const XHI_EFF: readonly ThinkingEffort[] = ["minimal", "low", "medium", "high", "xhigh"];
+
+export function getAvailableThinkingEfforts(hasXhigh: boolean = true): ReadonlyArray<ThinkingEffort> {
+	return hasXhigh ? XHI_EFF : REG_EFF;
+}

package/src/types.ts

@@ -109,10 +109,10 @@ export type KnownProvider =
 	| "lm-studio";
 export type Provider = KnownProvider | string;
 
-export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh";
+import type { ThinkingEffort, ThinkingLevel } from "./thinking";
 
 /** Token budgets for each thinking level (token-based providers only) */
-export type ThinkingBudgets = { [key in ThinkingLevel]?: number };
+export type ThinkingBudgets = { [key in ThinkingEffort]?: number };
 
 export type MessageAttribution = "user" | "agent";
 
@@ -224,6 +224,11 @@ export interface ThinkingContent {
 	thinkingSignature?: string; // e.g., for OpenAI responses, the reasoning item ID
 }
 
+export interface RedactedThinkingContent {
+	type: "redactedThinking";
+	data: string;
+}
+
 export interface ImageContent {
 	type: "image";
 	data: string; // base64 encoded image data
@@ -277,7 +282,7 @@ export interface DeveloperMessage {
 
 export interface AssistantMessage {
 	role: "assistant";
-	content: (TextContent | ThinkingContent | ToolCall)[];
+	content: (TextContent | ThinkingContent | RedactedThinkingContent | ToolCall)[];
 	api: Api;
 	provider: Provider;
 	model: string;