lsd-pi 1.2.4 → 1.3.6

package/packages/pi-ai/src/providers/google-vertex.ts

@@ -447,7 +447,6 @@ function getGemini3ThinkingLevel(
 ): GoogleThinkingLevel {
 	if (isGemini3ProModel(model)) {
 		switch (effort) {
-			case "minimal":
 			case "low":
 				return "LOW";
 			case "medium":
@@ -456,8 +455,6 @@ function getGemini3ThinkingLevel(
 		}
 	}
 	switch (effort) {
-		case "minimal":
-			return "MINIMAL";
 		case "low":
 			return "LOW";
 		case "medium":
@@ -480,7 +477,6 @@ function getGoogleBudget(
 
 	if (model.id.includes("2.5-pro")) {
 		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
 			low: 2048,
 			medium: 8192,
 			high: 32768,
@@ -490,7 +486,6 @@ function getGoogleBudget(
 
 	if (model.id.includes("2.5-flash")) {
 		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
 			low: 2048,
 			medium: 8192,
 			high: 24576,

package/packages/pi-ai/src/providers/google.ts

@@ -414,7 +414,6 @@ function getGemini3ThinkingLevel(
 ): GoogleThinkingLevel {
 	if (isGemini3ProModel(model)) {
 		switch (effort) {
-			case "minimal":
 			case "low":
 				return "LOW";
 			case "medium":
@@ -423,8 +422,6 @@ function getGemini3ThinkingLevel(
 		}
 	}
 	switch (effort) {
-		case "minimal":
-			return "MINIMAL";
 		case "low":
 			return "LOW";
 		case "medium":
@@ -447,7 +444,6 @@ function getGoogleBudget(
 
 	if (model.id.includes("2.5-pro")) {
 		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
 			low: 2048,
 			medium: 8192,
 			high: 32768,
@@ -457,7 +453,6 @@ function getGoogleBudget(
 
 	if (model.id.includes("2.5-flash")) {
 		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
 			low: 2048,
 			medium: 8192,
 			high: 24576,

package/packages/pi-ai/src/providers/openai-codex-responses.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { streamSimpleOpenAICodexResponses } from "./openai-codex-responses.js";
+import { __testing, streamSimpleOpenAICodexResponses } from "./openai-codex-responses.js";
 
 function makeJwt(accountId: string): string {
 	const header = Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url");
@@ -11,6 +11,24 @@ function makeJwt(accountId: string): string {
 	return `${header}.${payload}.sig`;
 }
 
+const codexModel = {
+	id: "gpt-5.4",
+	name: "gpt-5.4",
+	api: "openai-codex-responses",
+	provider: "openai-codex",
+	baseUrl: "https://chatgpt.com/backend-api",
+	reasoning: true,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 128000,
+	maxTokens: 16384,
+} as any;
+
+const simpleContext = {
+	systemPrompt: "",
+	messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+} as any;
+
 test("codex provider does not internally retry ChatGPT usage-plan 429s", async () => {
 	const originalFetch = globalThis.fetch;
 	let fetchCalls = 0;
@@ -31,25 +49,10 @@ test("codex provider does not internally retry ChatGPT usage-plan 429s", async (
 	}) as typeof fetch;
 
 	try {
-		const stream = streamSimpleOpenAICodexResponses(
-			{
-				id: "gpt-5.4",
-				name: "gpt-5.4",
-				api: "openai-codex-responses",
-				provider: "openai-codex",
-				baseUrl: "https://chatgpt.com/backend-api",
-				reasoning: true,
-				input: ["text"],
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 128000,
-				maxTokens: 16384,
-			} as any,
-			{
-				systemPrompt: "",
-				messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-			} as any,
-			{ apiKey: makeJwt("acct_123"), transport: "sse" } as any,
-		);
+		const stream = streamSimpleOpenAICodexResponses(codexModel, simpleContext, {
+			apiKey: makeJwt("acct_123"),
+			transport: "sse",
+		} as any);
 
 		let finalError = "";
 		for await (const event of stream) {
@@ -64,3 +67,123 @@ test("codex provider does not internally retry ChatGPT usage-plan 429s", async (
 		globalThis.fetch = originalFetch;
 	}
 });
+
+test("codex request body maps fast mode to service_tier=priority and omits when off", () => {
+	const onBody = __testing.buildRequestBody(codexModel, simpleContext, { fastMode: true } as any);
+	assert.equal(onBody.service_tier, "priority");
+
+	const offBody = __testing.buildRequestBody(codexModel, simpleContext, { fastMode: false } as any);
+	assert.equal("service_tier" in offBody, false);
+});
+
+test("codex SSE payload includes priority when fast mode is on and omits when off", async () => {
+	const originalFetch = globalThis.fetch;
+	const bodies: any[] = [];
+
+	globalThis.fetch = (async (_url, init) => {
+		const rawBody = typeof init?.body === "string" ? init.body : "{}";
+		bodies.push(JSON.parse(rawBody));
+		const sse = [
+			'data: {"type":"response.completed","response":{"status":"completed","usage":{"input_tokens":0,"output_tokens":0,"total_tokens":0}}}',
+			"",
+		].join("\n");
+		return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } });
+	}) as typeof fetch;
+
+	try {
+		for (const fastMode of [true, false]) {
+			const stream = streamSimpleOpenAICodexResponses(codexModel, simpleContext, {
+				apiKey: makeJwt("acct_sse"),
+				transport: "sse",
+				fastMode,
+			} as any);
+			await stream.result();
+		}
+
+		assert.equal(bodies[0]?.service_tier, "priority");
+		assert.equal("service_tier" in bodies[1], false);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test("codex websocket cache resets when fast mode changes on same session", async () => {
+	const originalWebSocket = (globalThis as any).WebSocket;
+	const originalFetch = globalThis.fetch;
+	const sentPayloads: any[] = [];
+	let constructorCalls = 0;
+
+	class MockWebSocket {
+		public readyState = 0;
+		private listeners = new Map<string, Set<(event: any) => void>>();
+
+		constructor(_url: string, _options?: unknown) {
+			constructorCalls++;
+			queueMicrotask(() => {
+				this.readyState = 1;
+				this.emit("open", {});
+			});
+		}
+
+		send(data: string): void {
+			sentPayloads.push(JSON.parse(data));
+			queueMicrotask(() => {
+				this.emit("message", {
+					data: JSON.stringify({
+						type: "response.completed",
+						response: {
+							status: "completed",
+							usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+						},
+					}),
+				});
+			});
+		}
+
+		close(): void {
+			this.readyState = 3;
+			this.emit("close", { code: 1000, reason: "closed" });
+		}
+
+		addEventListener(type: string, listener: (event: any) => void): void {
+			if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+			this.listeners.get(type)!.add(listener);
+		}
+
+		removeEventListener(type: string, listener: (event: any) => void): void {
+			this.listeners.get(type)?.delete(listener);
+		}
+
+		private emit(type: string, event: any): void {
+			for (const listener of this.listeners.get(type) ?? []) {
+				listener(event);
+			}
+		}
+	}
+
+	(globalThis as any).WebSocket = MockWebSocket as any;
+	globalThis.fetch = (async () => {
+		throw new Error("fetch should not be used in websocket transport test");
+	}) as any;
+
+	try {
+		__testing.clearWebSocketSessionCache();
+		for (const fastMode of [true, false]) {
+			const stream = streamSimpleOpenAICodexResponses(codexModel, simpleContext, {
+				apiKey: makeJwt("acct_ws"),
+				transport: "websocket",
+				sessionId: "session-fast-toggle",
+				fastMode,
+			} as any);
+			await stream.result();
+		}
+
+		assert.equal(constructorCalls, 2, "websocket should reconnect when service tier state changes");
+		assert.equal(sentPayloads[0]?.service_tier, "priority");
+		assert.equal("service_tier" in sentPayloads[1], false);
+	} finally {
+		__testing.clearWebSocketSessionCache();
+		(globalThis as any).WebSocket = originalWebSocket;
+		globalThis.fetch = originalFetch;
+	}
+});

package/packages/pi-ai/src/providers/openai-codex-responses.ts

@@ -1,5 +1,5 @@
 import type * as NodeOs from "node:os";
-import type { Tool as OpenAITool, ResponseInput, ResponseStreamEvent } from "openai/resources/responses/responses.js";
+import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput, ResponseStreamEvent } from "openai/resources/responses/responses.js";
 
 // NEVER convert to top-level runtime imports - breaks browser/Vite builds (web-ui)
 let _os: typeof NodeOs | null = null;
@@ -54,9 +54,10 @@ const CODEX_RESPONSE_STATUSES = new Set<CodexResponseStatus>([
 // ============================================================================
 
 export interface OpenAICodexResponsesOptions extends StreamOptions {
-	reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoningEffort?: "none" | "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "concise" | "detailed" | "off" | "on" | null;
 	textVerbosity?: "low" | "medium" | "high";
+	serviceTier?: ResponseCreateParamsStreaming["service_tier"];
 }
 
 type CodexResponseStatus = "completed" | "incomplete" | "failed" | "cancelled" | "queued" | "in_progress";
@@ -73,6 +74,7 @@ interface RequestBody {
 	temperature?: number;
 	reasoning?: { effort?: string; summary?: string };
 	text?: { verbosity?: string };
+	service_tier?: ResponseCreateParamsStreaming["service_tier"];
 	include?: string[];
 	prompt_cache_key?: string;
 	[key: string]: unknown;
@@ -294,6 +296,13 @@ export const streamSimpleOpenAICodexResponses: StreamFunction<"openai-codex-resp
 // Request Building
 // ============================================================================
 
+function resolveCodexServiceTier(options?: OpenAICodexResponsesOptions): ResponseCreateParamsStreaming["service_tier"] | undefined {
+	if (options?.serviceTier !== undefined) {
+		return options.serviceTier;
+	}
+	return options?.fastMode ? "priority" : undefined;
+}
+
 function buildRequestBody(
 	model: Model<"openai-codex-responses">,
 	context: Context,
@@ -320,6 +329,11 @@ function buildRequestBody(
 		body.temperature = options.temperature;
 	}
 
+	const resolvedServiceTier = resolveCodexServiceTier(options);
+	if (resolvedServiceTier !== undefined) {
+		body.service_tier = resolvedServiceTier;
+	}
+
 	if (context.tools) {
 		body.tools = convertResponsesTools(context.tools, { strict: null });
 	}
@@ -336,8 +350,6 @@ function buildRequestBody(
 
 function clampReasoningEffort(modelId: string, effort: string): string {
 	const id = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
-	if ((id.startsWith("gpt-5.2") || id.startsWith("gpt-5.3") || id.startsWith("gpt-5.4")) && effort === "minimal")
-		return "low";
 	if (id === "gpt-5.1" && effort === "xhigh") return "high";
 	if (id === "gpt-5.1-codex-mini") return effort === "high" || effort === "xhigh" ? "high" : "medium";
 	return effort;
@@ -476,6 +488,7 @@ interface CachedWebSocketConnection {
 	socket: WebSocketLike;
 	busy: boolean;
 	idleTimer?: ReturnType<typeof setTimeout>;
+	serviceTier?: ResponseCreateParamsStreaming["service_tier"];
 }
 
 const websocketSessionCache = new Map<string, CachedWebSocketConnection>();
@@ -591,6 +604,7 @@ async function acquireWebSocket(
 	url: string,
 	headers: Headers,
 	sessionId: string | undefined,
+	serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
 	signal?: AbortSignal,
 ): Promise<{ socket: WebSocketLike; release: (options?: { keep?: boolean }) => void }> {
 	if (!sessionId) {
@@ -613,7 +627,8 @@ async function acquireWebSocket(
 			clearTimeout(cached.idleTimer);
 			cached.idleTimer = undefined;
 		}
-		if (!cached.busy && isWebSocketReusable(cached.socket)) {
+
+		if (!cached.busy && isWebSocketReusable(cached.socket) && cached.serviceTier === serviceTier) {
 			cached.busy = true;
 			return {
 				socket: cached.socket,
@@ -628,6 +643,10 @@ async function acquireWebSocket(
 				},
 			};
 		}
+		if (!cached.busy && isWebSocketReusable(cached.socket) && cached.serviceTier !== serviceTier) {
+			closeWebSocketSilently(cached.socket, 1000, "service_tier_changed");
+			websocketSessionCache.delete(sessionId);
+		}
 		if (cached.busy) {
 			const socket = await connectWebSocket(url, headers, signal);
 			return {
@@ -644,7 +663,7 @@ async function acquireWebSocket(
 	}
 
 	const socket = await connectWebSocket(url, headers, signal);
-	const entry: CachedWebSocketConnection = { socket, busy: true };
+	const entry: CachedWebSocketConnection = { socket, busy: true, serviceTier };
 
 	// Evict the oldest entry if the cache is at capacity (LRU eviction).
 	if (websocketSessionCache.size >= MAX_WEBSOCKET_CACHE_SIZE) {
@@ -832,7 +851,13 @@ async function processWebSocketStream(
 	onStart: () => void,
 	options?: OpenAICodexResponsesOptions,
 ): Promise<void> {
-	const { socket, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+	const { socket, release } = await acquireWebSocket(
+		url,
+		headers,
+		options?.sessionId,
+		body.service_tier,
+		options?.signal,
+	);
 	let keepConnection = true;
 	try {
 		socket.send(JSON.stringify({ type: "response.create", ...body }));
@@ -924,3 +949,19 @@ function buildHeaders(
 
 	return headers;
 }
+
+function clearWebSocketSessionCache(): void {
+	for (const [, entry] of websocketSessionCache) {
+		if (entry.idleTimer) {
+			clearTimeout(entry.idleTimer);
+		}
+		closeWebSocketSilently(entry.socket);
+	}
+	websocketSessionCache.clear();
+}
+
+export const __testing = {
+	buildRequestBody,
+	resolveCodexServiceTier,
+	clearWebSocketSessionCache,
+};

package/packages/pi-ai/src/providers/openai-completions.ts

@@ -62,7 +62,7 @@ function hasToolHistory(messages: Message[]): boolean {
 
 export interface OpenAICompletionsOptions extends StreamOptions {
 	toolChoice?: "auto" | "none" | "required" | { type: "function"; function: { name: string } };
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoningEffort?: "low" | "medium" | "high" | "xhigh";
 }
 
 export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions> = (
@@ -718,7 +718,6 @@ function detectCompat(model: Model<"openai-completions">): Required<OpenAIComple
 	const reasoningEffortMap =
 		isGroq && model.id === "qwen/qwen3-32b"
 			? {
-					minimal: "default",
 					low: "default",
 					medium: "default",
 					high: "default",

package/packages/pi-ai/src/providers/openai-responses.fast-mode.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { __testing } from "./openai-responses.js";
+
+test("openai-responses fast mode maps to service_tier=priority for supported models", () => {
+	const model = {
+		id: "gpt-5.4",
+		name: "gpt-5.4",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200000,
+		maxTokens: 32768,
+		capabilities: { supportsServiceTier: true },
+	} as any;
+	const context = {
+		systemPrompt: "",
+		messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+	} as any;
+
+	const params = __testing.buildParams(model, context, { fastMode: true });
+	assert.equal(params.service_tier, "priority");
+});
+
+test("openai-responses fast mode off omits service_tier", () => {
+	const model = {
+		id: "gpt-5.4",
+		name: "gpt-5.4",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200000,
+		maxTokens: 32768,
+		capabilities: { supportsServiceTier: true },
+	} as any;
+	const context = {
+		systemPrompt: "",
+		messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+	} as any;
+
+	const params = __testing.buildParams(model, context, { fastMode: false });
+	assert.equal("service_tier" in params, false);
+});
+
+test("openai-responses fast mode is scoped to provider=openai", () => {
+	const model = {
+		id: "gpt-5.4",
+		name: "gpt-5.4",
+		api: "openai-responses",
+		provider: "openrouter",
+		baseUrl: "https://openrouter.ai/api/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200000,
+		maxTokens: 32768,
+		capabilities: { supportsServiceTier: true },
+	} as any;
+	const context = {
+		systemPrompt: "",
+		messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+	} as any;
+
+	const params = __testing.buildParams(model, context, { fastMode: true });
+	assert.equal("service_tier" in params, false);
+});

package/packages/pi-ai/src/providers/openai-responses.ts

@@ -56,7 +56,7 @@ function getPromptCacheRetention(baseUrl: string, cacheRetention: CacheRetention
 
 // OpenAI Responses-specific options
 export interface OpenAIResponsesOptions extends StreamOptions {
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoningEffort?: "low" | "medium" | "high" | "xhigh";
 	reasoningSummary?: "auto" | "detailed" | "concise" | null;
 	serviceTier?: ResponseCreateParamsStreaming["service_tier"];
 }
@@ -86,6 +86,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
 			if (nextParams !== undefined) {
 				params = nextParams as ResponseCreateParamsStreaming;
 			}
+			const resolvedServiceTier = resolveOpenAIServiceTier(model, options);
 			const openaiStream = await client.responses.create(
 				params,
 				options?.signal ? { signal: options.signal } : undefined,
@@ -93,7 +94,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
 			stream.push({ type: "start", partial: output });
 
 			await processResponsesStream(openaiStream, output, stream, model, {
-				serviceTier: options?.serviceTier,
+				serviceTier: resolvedServiceTier,
 				applyServiceTierPricing,
 			});
 
@@ -127,8 +128,25 @@ export const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", Sim
 	} satisfies OpenAIResponsesOptions);
 };
 
+function resolveOpenAIServiceTier(
+	model: Model<"openai-responses">,
+	options?: OpenAIResponsesOptions,
+): ResponseCreateParamsStreaming["service_tier"] | undefined {
+	if (options?.serviceTier !== undefined) {
+		return options.serviceTier;
+	}
+	if (options?.fastMode !== true) {
+		return undefined;
+	}
+	if (model.provider !== "openai") {
+		return undefined;
+	}
+	return model.capabilities?.supportsServiceTier ? "priority" : undefined;
+}
+
 function buildParams(model: Model<"openai-responses">, context: Context, options?: OpenAIResponsesOptions) {
 	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS);
+	const resolvedServiceTier = resolveOpenAIServiceTier(model, options);
 
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const params: ResponseCreateParamsStreaming = {
@@ -148,8 +166,8 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
 		params.temperature = options?.temperature;
 	}
 
-	if (options?.serviceTier !== undefined) {
-		params.service_tier = options.serviceTier;
+	if (resolvedServiceTier !== undefined) {
+		params.service_tier = resolvedServiceTier;
 	}
 
 	if (context.tools) {
@@ -204,3 +222,8 @@ function applyServiceTierPricing(usage: Usage, serviceTier: ResponseCreateParams
 	usage.cost.cacheWrite *= multiplier;
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 }
+
+export const __testing = {
+	buildParams,
+	resolveOpenAIServiceTier,
+};

package/packages/pi-ai/src/providers/openai-shared.ts

@@ -182,12 +182,9 @@ export function handleStreamError(
 
 /**
  * Clamp reasoning effort for models that don't support all levels.
- * gpt-5.x models don't support "minimal" -- map to "low".
  *
  * Used by both openai-responses.ts and azure-openai-responses.ts.
  */
 export function clampReasoningForModel(modelName: string, effort: string): string {
-	const name = modelName.includes("/") ? modelName.split("/").pop()! : modelName;
-	if (name.startsWith("gpt-5") && effort === "minimal") return "low";
 	return effort;
 }

package/packages/pi-ai/src/providers/simple-options.ts

@@ -6,6 +6,8 @@ export function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOption
 		maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32000),
 		signal: options?.signal,
 		apiKey: apiKey || options?.apiKey,
+		transport: options?.transport,
+		fastMode: options?.fastMode,
 		cacheRetention: options?.cacheRetention,
 		sessionId: options?.sessionId,
 		headers: options?.headers,
@@ -28,7 +30,6 @@ export function adjustMaxTokensForThinking(
 	customBudgets?: ThinkingBudgets,
 ): { maxTokens: number; thinkingBudget: number } {
 	const defaultBudgets: ThinkingBudgets = {
-		minimal: 1024,
 		low: 2048,
 		medium: 8192,
 		high: 16384,

package/packages/pi-ai/src/types.ts

@@ -46,11 +46,10 @@ export type KnownProvider =
 	| "ollama-cloud";
 export type Provider = KnownProvider | string;
 
-export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive";
+export type ThinkingLevel = "low" | "medium" | "high" | "xhigh" | "adaptive";
 
 /** Token budgets for each thinking level (token-based providers only) */
 export interface ThinkingBudgets {
-	minimal?: number;
 	low?: number;
 	medium?: number;
 	high?: number;
@@ -66,6 +65,11 @@ export interface StreamOptions {
 	maxTokens?: number;
 	signal?: AbortSignal;
 	apiKey?: string;
+	/**
+	 * Enable fast mode for providers/models that support OpenAI service tiers.
+	 * For OpenAI/Codex Responses, this maps to service_tier="priority".
+	 */
+	fastMode?: boolean;
 	/**
 	 * Preferred transport for providers that support multiple transports.
 	 * Providers that do not support this option ignore it.

package/packages/pi-coding-agent/dist/cli/args.js

@@ -4,7 +4,7 @@
 import chalk from "chalk";
 import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config.js";
 import { allTools } from "../core/tools/index.js";
-const VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "adaptive"];
+const VALID_THINKING_LEVELS = ["off", "low", "medium", "high", "xhigh", "adaptive"];
 export function isValidThinkingLevel(level) {
     return VALID_THINKING_LEVELS.includes(level);
 }
@@ -210,7 +210,7 @@ ${chalk.bold("Options:")}
   --no-tools                     Disable all built-in tools
   --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
                                  Available: read, bash, edit, write, lsp, grep, find, ls
-  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --thinking <level>             Set thinking level: off, low, medium, high, xhigh
   --extension, -e <path>         Load an extension file (can be used multiple times)
   --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
   --skill <path>                 Load a skill file or directory (can be used multiple times)