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

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [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
+
+- Added runtime tests covering extension provider registration and deferred model pattern resolution behavior.
+
+### Changed
+
+- Improved welcome screen responsiveness to dynamically show or hide the right column based on available terminal width
+- Extended extension `registerProvider()` typing with OAuth provider support and source-aware registration metadata.
+
+### Fixed
+
+- Fixed welcome screen layout to gracefully handle small terminal widths and prevent rendering errors on narrow displays
+- Fixed welcome screen title truncation to prevent overflow when content exceeds available width
+- Fixed deferred `--model` resolution so extension-provided models are matched before fallback selection and unresolved explicit patterns no longer silently fallback.
+- Fixed CLI `--api-key` handling for deferred model resolution by applying runtime API key overrides after extension model selection.
+- Fixed extension provider registration cleanup to remove stale source-scoped custom API/OAuth providers across extension reloads.
+
 ## [12.5.1] - 2026-02-15
 ### Added
 

package/docs/extensions.md

@@ -886,6 +886,37 @@ pi.registerCommand("stats", {
 	},
 });
 ```
+### pi.registerProvider(name, config)
+
+Register or override providers/models at runtime:
+
+```typescript
+pi.registerProvider("my-provider", {
+	baseUrl: "https://api.example.com/v1",
+	apiKey: "MY_PROVIDER_API_KEY",
+	api: "openai-completions",
+	models: [
+		{
+			id: "my-model",
+			name: "My Model",
+			reasoning: false,
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: 128000,
+			maxTokens: 8192,
+		},
+	],
+});
+```
+
+`registerProvider()` also supports:
+
+- `streamSimple` for custom API adapters
+- `headers` / `authHeader` for request customization
+- `oauth` for `/login <provider>` support with extension-defined login/refresh behavior
+
+Provider registrations are queued during extension load and applied when the session initializes.
+
 
 ### pi.registerMessageRenderer(customType, renderer)
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.5.1",
+	"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.5.1",
-		"@oh-my-pi/pi-agent-core": "12.5.1",
-		"@oh-my-pi/pi-ai": "12.5.1",
-		"@oh-my-pi/pi-natives": "12.5.1",
-		"@oh-my-pi/pi-tui": "12.5.1",
-		"@oh-my-pi/pi-utils": "12.5.1",
+		"@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-registry.ts

@@ -1,10 +1,19 @@
 import {
 	type Api,
+	type AssistantMessageEventStream,
+	type Context,
 	getGitHubCopilotBaseUrl,
 	getModels,
 	getProviders,
 	type Model,
 	normalizeDomain,
+	type OAuthCredentials,
+	type OAuthLoginCallbacks,
+	registerCustomApi,
+	registerOAuthProvider,
+	type SimpleStreamOptions,
+	unregisterCustomApis,
+	unregisterOAuthProviders,
 } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
@@ -291,6 +300,7 @@ export class ModelRegistry {
 	#modelOverrides: Map<string, Map<string, ModelOverride>> = new Map();
 	#configError: ConfigError | undefined = undefined;
 	#modelsConfigFile: ConfigFile<ModelsConfig>;
+	#registeredProviderSources: Set<string> = new Set();
 
 	/**
 	 * @param authStorage - Auth storage for API key resolution
@@ -705,4 +715,162 @@ export class ModelRegistry {
 	isUsingOAuth(model: Model<Api>): boolean {
 		return this.authStorage.hasOAuth(model.provider);
 	}
+
+	/**
+	 * Remove custom API/OAuth registrations for a specific extension source.
+	 */
+	clearSourceRegistrations(sourceId: string): void {
+		unregisterCustomApis(sourceId);
+		unregisterOAuthProviders(sourceId);
+	}
+
+	/**
+	 * Remove registrations for extension sources that are no longer active.
+	 */
+	syncExtensionSources(activeSourceIds: string[]): void {
+		const activeSources = new Set(activeSourceIds);
+		for (const sourceId of this.#registeredProviderSources) {
+			if (activeSources.has(sourceId)) {
+				continue;
+			}
+			this.clearSourceRegistrations(sourceId);
+			this.#registeredProviderSources.delete(sourceId);
+		}
+	}
+
+	/**
+	 * Register a provider dynamically (from extensions).
+	 *
+	 * If provider has models: replaces all existing models for this provider.
+	 * If provider has only baseUrl/headers: overrides existing models' URLs.
+	 * If provider has streamSimple: registers a custom API streaming function.
+	 * If provider has oauth: registers OAuth provider for /login support.
+	 */
+	registerProvider(providerName: string, config: ProviderConfigInput, sourceId?: string): void {
+		if (config.streamSimple && !config.api) {
+			throw new Error(`Provider ${providerName}: "api" is required when registering streamSimple.`);
+		}
+
+		if (config.models && config.models.length > 0) {
+			if (!config.baseUrl) {
+				throw new Error(`Provider ${providerName}: "baseUrl" is required when defining models.`);
+			}
+			if (!config.apiKey && !config.oauth) {
+				throw new Error(`Provider ${providerName}: "apiKey" or "oauth" is required when defining models.`);
+			}
+			for (const modelDef of config.models) {
+				const api = modelDef.api || config.api;
+				if (!api) {
+					throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified.`);
+				}
+			}
+		}
+
+		if (config.streamSimple && config.api) {
+			const streamSimple = config.streamSimple;
+			registerCustomApi(config.api, streamSimple, sourceId, (model, context, options) =>
+				streamSimple(model, context, options as SimpleStreamOptions),
+			);
+		}
+
+		if (config.oauth) {
+			registerOAuthProvider({
+				...config.oauth,
+				id: providerName,
+				sourceId,
+			});
+		}
+
+		if (sourceId) {
+			this.#registeredProviderSources.add(sourceId);
+		}
+		if (config.apiKey) {
+			this.#customProviderApiKeys.set(providerName, config.apiKey);
+		}
+
+		if (config.models && config.models.length > 0) {
+			const nextModels = this.#models.filter(m => m.provider !== providerName);
+			for (const modelDef of config.models) {
+				const api = modelDef.api || config.api;
+				if (!api) {
+					throw new Error(`Provider ${providerName}, model ${modelDef.id}: no "api" specified.`);
+				}
+				let headers = config.headers || modelDef.headers ? { ...config.headers, ...modelDef.headers } : undefined;
+				if (config.authHeader && config.apiKey) {
+					const resolvedKey = resolveApiKeyConfig(config.apiKey);
+					if (resolvedKey) {
+						headers = { ...headers, Authorization: `Bearer ${resolvedKey}` };
+					}
+				}
+
+				nextModels.push({
+					id: modelDef.id,
+					name: modelDef.name,
+					api,
+					provider: providerName,
+					baseUrl: config.baseUrl!,
+					reasoning: modelDef.reasoning,
+					input: modelDef.input as ("text" | "image")[],
+					cost: modelDef.cost,
+					contextWindow: modelDef.contextWindow,
+					maxTokens: modelDef.maxTokens,
+					headers,
+					compat: modelDef.compat,
+				} as Model<Api>);
+			}
+
+			if (config.oauth?.modifyModels) {
+				const credential = this.authStorage.getOAuthCredential(providerName);
+				if (credential) {
+					this.#models = config.oauth.modifyModels(nextModels, credential);
+					return;
+				}
+			}
+
+			this.#models = nextModels;
+			return;
+		}
+
+		if (config.baseUrl) {
+			this.#models = this.#models.map(m => {
+				if (m.provider !== providerName) return m;
+				return {
+					...m,
+					baseUrl: config.baseUrl ?? m.baseUrl,
+					headers: config.headers ? { ...m.headers, ...config.headers } : m.headers,
+				};
+			});
+		}
+	}
+}
+
+/**
+ * Input type for registerProvider API (from extensions).
+ */
+export interface ProviderConfigInput {
+	baseUrl?: string;
+	apiKey?: string;
+	api?: Api;
+	streamSimple?: (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+	headers?: Record<string, string>;
+	authHeader?: boolean;
+	oauth?: {
+		name: string;
+		login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials | string>;
+		refreshToken?(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+		getApiKey?(credentials: OAuthCredentials): string;
+		modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
+	};
+	models?: Array<{
+		id: string;
+		name: string;
+		api?: Api;
+		reasoning: boolean;
+		input: ("text" | "image")[];
+		cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+		contextWindow: number;
+		maxTokens: number;
+		headers?: Record<string, string>;
+		compat?: Model<Api>["compat"];
+	}>;
 }

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,16 @@ export type {
 	InputEventResult,
 	KeybindingsManager,
 	LoadExtensionsResult,
+	// Events - Message
+	MessageEndEvent,
 	// Message Rendering
 	MessageRenderer,
 	MessageRenderOptions,
+	MessageStartEvent,
+	MessageUpdateEvent,
+	// Provider Registration
+	ProviderConfig,
+	ProviderModelConfig,
 	ReadToolCallEvent,
 	ReadToolResultEvent,
 	// Commands
@@ -101,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/loader.ts

@@ -52,6 +52,8 @@ export class ExtensionRuntimeNotInitializedError extends Error {
  */
 export class ExtensionRuntime implements IExtensionRuntime {
 	flagValues = new Map<string, boolean | string>();
+	pendingProviderRegistrations: Array<{ name: string; config: import("./types").ProviderConfig; sourceId: string }> =
+		[];
 
 	sendMessage(): void {
 		throw new ExtensionRuntimeNotInitializedError();
@@ -108,6 +110,11 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly typebox = TypeBox;
 	readonly pi = piCodingAgent;
 	readonly flagValues = new Map<string, boolean | string>();
+	readonly pendingProviderRegistrations: Array<{
+		name: string;
+		config: import("./types").ProviderConfig;
+		sourceId: string;
+	}> = [];
 
 	constructor(
 		private readonly extension: Extension,
@@ -222,6 +229,10 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	setThinkingLevel(level: ThinkingLevel, persist?: boolean): void {
 		this.runtime.setThinkingLevel(level, persist);
 	}
+
+	registerProvider(name: string, config: import("./types").ProviderConfig): void {
+		this.runtime.pendingProviderRegistrations.push({ name, config, sourceId: this.extension.path });
+	}
 }
 
 /**

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: () => {},