@oh-my-pi/pi-coding-agent 12.6.0 → 12.7.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [12.7.0] - 2026-02-16
+### Added
+
+- Added Z.AI web search provider support via remote MCP endpoint (webSearchPrime)
+- Added `zai` as a selectable web search provider option in settings
+- Added Z.AI to automatic provider fallback chain for web search
+
 ## [12.6.0] - 2026-02-16
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.6.0",
+	"version": "12.7.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"bin": {
@@ -84,12 +84,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "12.6.0",
-		"@oh-my-pi/pi-agent-core": "12.6.0",
-		"@oh-my-pi/pi-ai": "12.6.0",
-		"@oh-my-pi/pi-natives": "12.6.0",
-		"@oh-my-pi/pi-tui": "12.6.0",
-		"@oh-my-pi/pi-utils": "12.6.0",
+		"@oh-my-pi/omp-stats": "12.7.0",
+		"@oh-my-pi/pi-agent-core": "12.7.0",
+		"@oh-my-pi/pi-ai": "12.7.0",
+		"@oh-my-pi/pi-natives": "12.7.0",
+		"@oh-my-pi/pi-tui": "12.7.0",
+		"@oh-my-pi/pi-utils": "12.7.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.18.0",

package/src/cli/update-cli.ts

@@ -59,23 +59,28 @@ function hasBun(): boolean {
 }
 
 /**
- * Get the latest release info from GitHub.
+ * Get the latest release info from the npm registry.
+ * Uses npm instead of GitHub API to avoid unauthenticated rate limiting.
  */
 async function getLatestRelease(): Promise<ReleaseInfo> {
-	const response = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`);
+	const response = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`);
 	if (!response.ok) {
 		throw new Error(`Failed to fetch release info: ${response.statusText}`);
 	}
 
-	const data = (await response.json()) as {
-		tag_name: string;
-		assets: Array<{ name: string; browser_download_url: string }>;
-	};
+	const data = (await response.json()) as { version: string };
+	const version = data.version;
+	const tag = `v${version}`;
 
+	// Construct deterministic GitHub release download URLs for the current platform
+	const makeAsset = (name: string) => ({
+		name,
+		url: `https://github.com/${REPO}/releases/download/${tag}/${name}`,
+	});
 	return {
-		tag: data.tag_name,
-		version: data.tag_name.replace(/^v/, ""),
-		assets: data.assets.map(a => ({ name: a.name, url: a.browser_download_url })),
+		tag,
+		version,
+		assets: [makeAsset(getBinaryName()), makeAsset(getNativeAddonName())],
 	};
 }
 

package/src/cli/web-search-cli.ts

@@ -25,6 +25,7 @@ const PROVIDERS: Array<SearchProviderId | "auto"> = [
 	"perplexity",
 	"exa",
 	"jina",
+	"zai",
 	"gemini",
 	"codex",
 ];
@@ -99,6 +100,7 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 		provider: cmd.provider,
 		recency: cmd.recency,
 		limit: cmd.limit,
+		no_fallback: cmd.provider !== undefined && cmd.provider !== "auto",
 	};
 
 	const result = await runSearchQuery(params);

package/src/commands/web-search.ts

@@ -11,6 +11,7 @@ const PROVIDERS: Array<SearchProviderId | "auto"> = [
 	"perplexity",
 	"exa",
 	"jina",
+	"zai",
 	"gemini",
 	"codex",
 ];

package/src/config/model-resolver.ts

@@ -258,6 +258,7 @@ function parseModelPatternWithContext(
 	pattern: string,
 	availableModels: Model<Api>[],
 	context: ModelPreferenceContext,
+	options?: { allowInvalidThinkingLevelFallback?: boolean },
 ): ParsedModelResult {
 	// Try exact match first
 	const exactMatch = tryMatchModel(pattern, availableModels, context);
@@ -277,7 +278,7 @@ function parseModelPatternWithContext(
 
 	if (isValidThinkingLevel(suffix)) {
 		// Valid thinking level - recurse on prefix and use this level
-		const result = parseModelPatternWithContext(prefix, availableModels, context);
+		const result = parseModelPatternWithContext(prefix, availableModels, context, options);
 		if (result.model) {
 			// Only use this thinking level if no warning from inner recursion
 			const explicitThinkingLevel = !result.warning;
@@ -291,8 +292,13 @@ function parseModelPatternWithContext(
 		return result;
 	}
 
+	const allowFallback = options?.allowInvalidThinkingLevelFallback ?? true;
+	if (!allowFallback) {
+		return { model: undefined, thinkingLevel: undefined, warning: undefined, explicitThinkingLevel: false };
+	}
+
 	// Invalid suffix - recurse on prefix and warn
-	const result = parseModelPatternWithContext(prefix, availableModels, context);
+	const result = parseModelPatternWithContext(prefix, availableModels, context, options);
 	if (result.model) {
 		return {
 			model: result.model,
@@ -308,9 +314,10 @@ export function parseModelPattern(
 	pattern: string,
 	availableModels: Model<Api>[],
 	preferences?: ModelMatchPreferences,
+	options?: { allowInvalidThinkingLevelFallback?: boolean },
 ): ParsedModelResult {
 	const context = buildPreferenceContext(availableModels, preferences);
-	return parseModelPatternWithContext(pattern, availableModels, context);
+	return parseModelPatternWithContext(pattern, availableModels, context, options);
 }
 
 const PREFIX_MODEL_ROLE = "pi/";
@@ -486,6 +493,98 @@ export async function resolveModelScope(
 	return scopedModels;
 }
 
+export interface ResolveCliModelResult {
+	model: Model<Api> | undefined;
+	thinkingLevel?: ThinkingLevel;
+	warning: string | undefined;
+	error: string | undefined;
+}
+
+/**
+ * Resolve a single model from CLI flags.
+ */
+export function resolveCliModel(options: {
+	cliProvider?: string;
+	cliModel?: string;
+	modelRegistry: ModelRegistry;
+	preferences?: ModelMatchPreferences;
+}): ResolveCliModelResult {
+	const { cliProvider, cliModel, modelRegistry, preferences } = options;
+
+	if (!cliModel) {
+		return { model: undefined, warning: undefined, error: undefined };
+	}
+
+	const availableModels = modelRegistry.getAll();
+	if (availableModels.length === 0) {
+		return {
+			model: undefined,
+			warning: undefined,
+			error: "No models available. Check your installation or add models to models.json.",
+		};
+	}
+
+	const providerMap = new Map<string, string>();
+	for (const model of availableModels) {
+		providerMap.set(model.provider.toLowerCase(), model.provider);
+	}
+
+	let provider = cliProvider ? providerMap.get(cliProvider.toLowerCase()) : undefined;
+	if (cliProvider && !provider) {
+		return {
+			model: undefined,
+			warning: undefined,
+			error: `Unknown provider "${cliProvider}". Use --list-models to see available providers/models.`,
+		};
+	}
+
+	if (!provider) {
+		const lower = cliModel.toLowerCase();
+		const exact = availableModels.find(
+			model => model.id.toLowerCase() === lower || `${model.provider}/${model.id}`.toLowerCase() === lower,
+		);
+		if (exact) {
+			return { model: exact, warning: undefined, thinkingLevel: undefined, error: undefined };
+		}
+	}
+
+	let pattern = cliModel;
+
+	if (!provider) {
+		const slashIndex = cliModel.indexOf("/");
+		if (slashIndex !== -1) {
+			const maybeProvider = cliModel.substring(0, slashIndex);
+			const canonical = providerMap.get(maybeProvider.toLowerCase());
+			if (canonical) {
+				provider = canonical;
+				pattern = cliModel.substring(slashIndex + 1);
+			}
+		}
+	} else {
+		const prefix = `${provider}/`;
+		if (cliModel.toLowerCase().startsWith(prefix.toLowerCase())) {
+			pattern = cliModel.substring(prefix.length);
+		}
+	}
+
+	const candidates = provider ? availableModels.filter(model => model.provider === provider) : availableModels;
+	const { model, thinkingLevel, warning } = parseModelPattern(pattern, candidates, preferences, {
+		allowInvalidThinkingLevelFallback: false,
+	});
+
+	if (!model) {
+		const display = provider ? `${provider}/${pattern}` : cliModel;
+		return {
+			model: undefined,
+			thinkingLevel: undefined,
+			warning,
+			error: `Model "${display}" not found. Use --list-models to see available models.`,
+		};
+	}
+
+	return { model, thinkingLevel, warning, error: undefined };
+}
+
 export interface InitialModelResult {
 	model: Model<Api> | undefined;
 	thinkingLevel: ThinkingLevel;

package/src/config/settings-schema.ts

@@ -617,7 +617,7 @@ export const SETTINGS_SCHEMA = {
 	// ─────────────────────────────────────────────────────────────────────────
 	"providers.webSearch": {
 		type: "enum",
-		values: ["auto", "exa", "jina", "perplexity", "anthropic"] as const,
+		values: ["auto", "exa", "jina", "zai", "perplexity", "anthropic"] as const,
 		default: "auto",
 		ui: { tab: "services", label: "Web search provider", description: "Provider for web search tool", submenu: true },
 	},

package/src/extensibility/extensions/index.ts

@@ -67,9 +67,13 @@ export type {
 	InputEventResult,
 	KeybindingsManager,
 	LoadExtensionsResult,
+	// Events - Message
+	MessageEndEvent,
 	// Message Rendering
 	MessageRenderer,
 	MessageRenderOptions,
+	MessageStartEvent,
+	MessageUpdateEvent,
 	// Provider Registration
 	ProviderConfig,
 	ProviderModelConfig,
@@ -104,11 +108,16 @@ export type {
 	SetActiveToolsHandler,
 	SetModelHandler,
 	SetThinkingLevelHandler,
+	TerminalInputHandler,
 	// Events - Tool
 	ToolCallEvent,
 	ToolCallEventResult,
 	// Tools
 	ToolDefinition,
+	// Events - Tool Execution
+	ToolExecutionEndEvent,
+	ToolExecutionStartEvent,
+	ToolExecutionUpdateEvent,
 	ToolRenderResultOptions,
 	ToolResultEvent,
 	ToolResultEventResult,

package/src/extensibility/extensions/runner.ts

@@ -130,6 +130,7 @@ const noOpUIContext: ExtensionUIContext = {
 	confirm: async (_title, _message, _dialogOptions) => false,
 	input: async (_title, _placeholder, _dialogOptions) => undefined,
 	notify: () => {},
+	onTerminalInput: () => () => {},
 	setStatus: () => {},
 	setWorkingMessage: () => {},
 	setWidget: () => {},

package/src/extensibility/extensions/types.ts

@@ -10,6 +10,7 @@
 import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type {
 	Api,
+	AssistantMessageEvent,
 	AssistantMessageEventStream,
 	Context,
 	ImageContent,
@@ -75,6 +76,9 @@ export interface ExtensionUIDialogOptions {
 	outline?: boolean;
 }
 
+/** Raw terminal input listener for extensions. */
+export type TerminalInputHandler = (data: string) => { consume?: boolean; data?: string } | undefined;
+
 /**
  * UI context for extensions to request interactive UI.
  * Each mode (interactive, RPC, print) provides its own implementation.
@@ -92,6 +96,9 @@ export interface ExtensionUIContext {
 	/** Show a notification to the user. */
 	notify(message: string, type?: "info" | "warning" | "error"): void;
 
+	/** Listen to raw terminal input (interactive mode only). Returns an unsubscribe function. */
+	onTerminalInput(handler: TerminalInputHandler): () => void;
+
 	/** Set status text in the footer/status bar. Pass undefined to clear. */
 	setStatus(key: string, text: string | undefined): void;
 
@@ -168,12 +175,11 @@ export interface ExtensionUIContext {
 // ============================================================================
 
 export interface ContextUsage {
-	tokens: number;
+	/** Estimated context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
+	tokens: number | null;
 	contextWindow: number;
-	percent: number;
-	usageTokens: number;
-	trailingTokens: number;
-	lastUsageIndex: number | null;
+	/** Context usage as percentage of context window, or null if tokens is unknown. */
+	percent: number | null;
 }
 
 export interface CompactOptions {
@@ -472,6 +478,51 @@ export interface TurnEndEvent {
 	toolResults: ToolResultMessage[];
 }
 
+/** Fired when a message starts (user, assistant, or toolResult) */
+export interface MessageStartEvent {
+	type: "message_start";
+	message: AgentMessage;
+}
+
+/** Fired during assistant message streaming with token-by-token updates */
+export interface MessageUpdateEvent {
+	type: "message_update";
+	message: AgentMessage;
+	assistantMessageEvent: AssistantMessageEvent;
+}
+
+/** Fired when a message ends */
+export interface MessageEndEvent {
+	type: "message_end";
+	message: AgentMessage;
+}
+
+/** Fired when a tool starts executing */
+export interface ToolExecutionStartEvent {
+	type: "tool_execution_start";
+	toolCallId: string;
+	toolName: string;
+	args: unknown;
+}
+
+/** Fired during tool execution with partial/streaming output */
+export interface ToolExecutionUpdateEvent {
+	type: "tool_execution_update";
+	toolCallId: string;
+	toolName: string;
+	args: unknown;
+	partialResult: unknown;
+}
+
+/** Fired when a tool finishes executing */
+export interface ToolExecutionEndEvent {
+	type: "tool_execution_end";
+	toolCallId: string;
+	toolName: string;
+	result: unknown;
+	isError: boolean;
+}
+
 /** Fired when auto-compaction starts */
 export interface AutoCompactionStartEvent {
 	type: "auto_compaction_start";
@@ -711,6 +762,12 @@ export type ExtensionEvent =
 	| AgentEndEvent
 	| TurnStartEvent
 	| TurnEndEvent
+	| MessageStartEvent
+	| MessageUpdateEvent
+	| MessageEndEvent
+	| ToolExecutionStartEvent
+	| ToolExecutionUpdateEvent
+	| ToolExecutionEndEvent
 	| AutoCompactionStartEvent
 	| AutoCompactionEndEvent
 	| AutoRetryStartEvent
@@ -879,6 +936,12 @@ export interface ExtensionAPI {
 	on(event: "agent_end", handler: ExtensionHandler<AgentEndEvent>): void;
 	on(event: "turn_start", handler: ExtensionHandler<TurnStartEvent>): void;
 	on(event: "turn_end", handler: ExtensionHandler<TurnEndEvent>): void;
+	on(event: "message_start", handler: ExtensionHandler<MessageStartEvent>): void;
+	on(event: "message_update", handler: ExtensionHandler<MessageUpdateEvent>): void;
+	on(event: "message_end", handler: ExtensionHandler<MessageEndEvent>): void;
+	on(event: "tool_execution_start", handler: ExtensionHandler<ToolExecutionStartEvent>): void;
+	on(event: "tool_execution_update", handler: ExtensionHandler<ToolExecutionUpdateEvent>): void;
+	on(event: "tool_execution_end", handler: ExtensionHandler<ToolExecutionEndEvent>): void;
 	on(event: "auto_compaction_start", handler: ExtensionHandler<AutoCompactionStartEvent>): void;
 	on(event: "auto_compaction_end", handler: ExtensionHandler<AutoCompactionEndEvent>): void;
 	on(event: "auto_retry_start", handler: ExtensionHandler<AutoRetryStartEvent>): void;

package/src/extensibility/plugins/git-url.ts

@@ -172,7 +172,7 @@ function parseGenericGitUrl(url: string): GitSource | null {
 	if (scpLikeMatch) {
 		host = scpLikeMatch[1] ?? "";
 		repoPath = scpLikeMatch[2] ?? "";
-	} else if (/^https?:\/\/|^ssh:\/\//.test(repoWithoutRef)) {
+	} else if (/^https?:\/\/|^ssh:\/\/|^git:\/\//.test(repoWithoutRef)) {
 		try {
 			const parsed = new URL(repoWithoutRef);
 			if (parsed.hash) {
@@ -210,20 +210,30 @@ function parseGenericGitUrl(url: string): GitSource | null {
 }
 
 /**
- * Parse any git URL (SSH or HTTPS) into a GitSource.
+ * Parse git source into a GitSource.
+ *
+ * Rules:
+ * - With `git:` prefix, accept shorthand forms.
+ * - Without `git:` prefix, only accept explicit protocol URLs.
  *
  * Handles:
  * - `git:` prefixed URLs (`git:github.com/user/repo`)
- * - SSH SCP-like URLs (`git@github.com:user/repo`)
- * - HTTPS/HTTP/SSH protocol URLs
- * - Bare `host/user/repo` shorthand
+ * - SSH SCP-like URLs (`git:git@github.com:user/repo`)
+ * - HTTPS/HTTP/SSH/git protocol URLs
  * - Ref pinning via `@ref` suffix
  *
  * Recognizes GitHub, GitLab, Bitbucket, Sourcehut, and Codeberg natively.
  * Falls back to generic URL parsing for other hosts.
  */
 export function parseGitUrl(source: string): GitSource | null {
-	const url = source.startsWith("git:") ? source.slice(4).trim() : source;
+	const trimmed = source.trim();
+	const hasGitPrefix = /^git:(?!\/\/)/i.test(trimmed);
+	const url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
+
+	if (!hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(url)) {
+		return null;
+	}
+
 	const hashIndex = url.indexOf("#");
 	if (hashIndex >= 0) {
 		const hash = url.slice(hashIndex + 1);
@@ -244,7 +254,7 @@ export function parseGitUrl(source: string): GitSource | null {
 	const directCandidates: string[] = [];
 	if (scpMatch) {
 		directCandidates.push(`https://${scpMatch[1]}/${scpMatch[2]}`);
-	} else if (/^https?:\/\/|^ssh:\/\//.test(split.repo)) {
+	} else if (/^https?:\/\/|^ssh:\/\/|^git:\/\//.test(split.repo)) {
 		directCandidates.push(split.repo);
 	}
 
@@ -254,6 +264,7 @@ export function parseGitUrl(source: string): GitSource | null {
 			!split.repo.startsWith("http://") &&
 			!split.repo.startsWith("https://") &&
 			!split.repo.startsWith("ssh://") &&
+			!split.repo.startsWith("git://") &&
 			!split.repo.startsWith("git@");
 		const result = tryKnownHostSource(split, withRef, needsHttps ? `https://${split.repo}` : split.repo);
 		if (result) return result;

package/src/main.ts

@@ -20,7 +20,7 @@ import { listModels } from "./cli/list-models";
 import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
-import { parseModelPattern, parseModelString, resolveModelScope, type ScopedModel } from "./config/model-resolver";
+import { parseModelString, resolveCliModel, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { Settings, settings } from "./config/settings";
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
@@ -355,10 +355,11 @@ async function buildSessionOptions(
 	scopedModels: ScopedModel[],
 	sessionManager: SessionManager | undefined,
 	modelRegistry: ModelRegistry,
-): Promise<CreateAgentSessionOptions> {
+): Promise<{ options: CreateAgentSessionOptions; cliThinkingFromModel: boolean }> {
 	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();
@@ -370,23 +371,38 @@ async function buildSessionOptions(
 		options.sessionManager = sessionManager;
 	}
 
-	// Model from CLI (--model) - uses same fuzzy matching as --models
+	// Model from CLI
+	// - supports --provider <name> --model <pattern>
+	// - supports --model <provider>/<pattern>
 	if (parsed.model) {
-		const available = modelRegistry.getAll();
 		const modelMatchPreferences = {
 			usageOrder: settings.getStorage()?.getModelUsageOrder(),
 		};
-		const { model, warning } = parseModelPattern(parsed.model, available, modelMatchPreferences);
-		if (warning) {
-			writeStderr(chalk.yellow(`Warning: ${warning}`));
+		const resolved = resolveCliModel({
+			cliProvider: parsed.provider,
+			cliModel: parsed.model,
+			modelRegistry,
+			preferences: modelMatchPreferences,
+		});
+		if (resolved.warning) {
+			writeStderr(chalk.yellow(`Warning: ${resolved.warning}`));
 		}
-		if (!model) {
-			// Model not found in built-in registry — defer resolution to after extensions load
-			// (extensions may register additional providers/models via registerProvider)
-			options.modelPattern = parsed.model;
-		} else {
-			options.model = model;
-			settings.overrideModelRoles({ default: `${model.provider}/${model.id}` });
+		if (resolved.error) {
+			if (!parsed.provider && !parsed.model.includes(":")) {
+				// Model not found in built-in registry — defer resolution to after extensions load
+				// (extensions may register additional providers/models via registerProvider)
+				options.modelPattern = parsed.model;
+			} else {
+				writeStderr(chalk.red(resolved.error));
+				process.exit(1);
+			}
+		} else if (resolved.model) {
+			options.model = resolved.model;
+			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) {
 		const remembered = settings.getModelRole("default");
@@ -472,7 +488,7 @@ async function buildSessionOptions(
 		options.additionalExtensionPaths = [];
 	}
 
-	return options;
+	return { options, cliThinkingFromModel };
 }
 
 export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
@@ -604,7 +620,12 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		sessionManager = await SessionManager.open(selectedPath);
 	}
 
-	const sessionOptions = await buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry);
+	const { options: sessionOptions, cliThinkingFromModel } = await buildSessionOptions(
+		parsedArgs,
+		scopedModels,
+		sessionManager,
+		modelRegistry,
+	);
 	debugStartup("main:buildSessionOptions");
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
@@ -613,7 +634,9 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	// Handle CLI --api-key as runtime override (not persisted)
 	if (parsedArgs.apiKey) {
 		if (!sessionOptions.model && !sessionOptions.modelPattern) {
-			writeStderr(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--models"));
+			writeStderr(
+				chalk.red("--api-key requires a model to be specified via --model, --provider/--model, or --models"),
+			);
 			process.exit(1);
 		}
 		if (sessionOptions.model) {
@@ -678,9 +701,11 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		process.exit(1);
 	}
 
-	// Clamp thinking level to model capabilities (for CLI override case)
-	if (session.model && parsedArgs.thinking) {
-		let effectiveThinking = parsedArgs.thinking;
+	// 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)) {

package/src/modes/components/footer.ts

@@ -1,6 +1,5 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, padding, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { getProjectDir } from "@oh-my-pi/pi-utils/dirs";
@@ -175,22 +174,12 @@ export class FooterComponent implements Component {
 			}
 		}
 
-		// Get last assistant message for context percentage calculation (skip aborted messages)
-		const lastAssistantMessage = state.messages
-			.slice()
-			.reverse()
-			.find(m => m.role === "assistant" && m.stopReason !== "aborted") as AssistantMessage | undefined;
-
-		// Calculate context percentage from last message (input + output + cacheRead + cacheWrite)
-		const contextTokens = lastAssistantMessage
-			? lastAssistantMessage.usage.input +
-				lastAssistantMessage.usage.output +
-				lastAssistantMessage.usage.cacheRead +
-				lastAssistantMessage.usage.cacheWrite
-			: 0;
-		const contextWindow = state.model?.contextWindow || 0;
-		const contextPercentValue = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
-		const contextPercent = contextPercentValue.toFixed(1);
+		// Calculate context usage from session (handles compaction correctly).
+		// After compaction, tokens are unknown until the next LLM response.
+		const contextUsage = this.session.getContextUsage();
+		const contextWindow = contextUsage?.contextWindow ?? state.model?.contextWindow ?? 0;
+		const contextPercentValue = contextUsage?.percent ?? 0;
+		const contextPercent = contextUsage?.percent !== null ? contextPercentValue.toFixed(1) : "?";
 
 		// Format token counts (similar to web-ui)
 		const formatTokens = (count: number): string => {
@@ -239,7 +228,10 @@ export class FooterComponent implements Component {
 		// Colorize context percentage based on usage
 		let contextPercentStr: string;
 		const autoIndicator = this.#autoCompactEnabled ? " (auto)" : "";
-		const contextPercentDisplay = `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
+		const contextPercentDisplay =
+			contextPercent === "?"
+				? `?/${formatTokens(contextWindow)}${autoIndicator}`
+				: `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
 		if (contextPercentValue > 90) {
 			contextPercentStr = theme.fg("error", contextPercentDisplay);
 		} else if (contextPercentValue > 70) {

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

@@ -146,10 +146,16 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 	],
 	// Provider options
 	"providers.webSearch": [
-		{ value: "auto", label: "Auto", description: "Priority: Exa > Perplexity > Anthropic" },
+		{
+			value: "auto",
+			label: "Auto",
+			description: "Priority: Exa > Jina > Perplexity > Anthropic > Gemini > Codex > Z.AI",
+		},
 		{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
+		{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
 		{ value: "perplexity", label: "Perplexity", description: "Requires PERPLEXITY_API_KEY" },
 		{ value: "anthropic", label: "Anthropic", description: "Uses Anthropic web search" },
+		{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
 	],
 	"providers.image": [
 		{ value: "auto", label: "Auto", description: "Priority: OpenRouter > Gemini" },