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

package/src/extensibility/extensions/types.ts

@@ -8,7 +8,19 @@
  * - Interact with the user via UI primitives
  */
 import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Model, TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type {
+	Api,
+	AssistantMessageEvent,
+	AssistantMessageEventStream,
+	Context,
+	ImageContent,
+	Model,
+	OAuthCredentials,
+	OAuthLoginCallbacks,
+	SimpleStreamOptions,
+	TextContent,
+	ToolResultMessage,
+} from "@oh-my-pi/pi-ai";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { AutocompleteItem, Component, EditorComponent, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { Static, TSchema } from "@sinclair/typebox";
@@ -64,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.
@@ -81,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;
 
@@ -157,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 {
@@ -461,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";
@@ -700,6 +762,12 @@ export type ExtensionEvent =
 	| AgentEndEvent
 	| TurnStartEvent
 	| TurnEndEvent
+	| MessageStartEvent
+	| MessageUpdateEvent
+	| MessageEndEvent
+	| ToolExecutionStartEvent
+	| ToolExecutionUpdateEvent
+	| ToolExecutionEndEvent
 	| AutoCompactionStartEvent
 	| AutoCompactionEndEvent
 	| AutoRetryStartEvent
@@ -868,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;
@@ -976,10 +1050,108 @@ export interface ExtensionAPI {
 	/** Set thinking level (clamped to model capabilities). */
 	setThinkingLevel(level: ThinkingLevel): void;
 
+	// =========================================================================
+	// Provider Registration
+	// =========================================================================
+
+	/**
+	 * Register or override a model provider.
+	 *
+	 * If `models` is provided: replaces all existing models for this provider.
+	 * If only `baseUrl` is provided: overrides the URL for existing models.
+	 * If `streamSimple` is provided: registers a custom API stream handler.
+	 *
+	 * @example
+	 * // Register a new provider with custom models and streaming
+	 * pi.registerProvider("google-vertex-claude", {
+	 *   baseUrl: "https://us-east5-aiplatform.googleapis.com",
+	 *   apiKey: "GOOGLE_CLOUD_PROJECT",
+	 *   api: "vertex-claude-api",
+	 *   streamSimple: myStreamFunction,
+	 *   models: [
+	 *     {
+	 *       id: "claude-sonnet-4@20250514",
+	 *       name: "Claude Sonnet 4 (Vertex)",
+	 *       reasoning: true,
+	 *       input: ["text", "image"],
+	 *       cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+	 *       contextWindow: 200000,
+	 *       maxTokens: 64000,
+	 *     }
+	 *   ]
+	 * });
+	 *
+	 * @example
+	 * // Override baseUrl for an existing provider
+	 * pi.registerProvider("anthropic", {
+	 *   baseUrl: "https://proxy.example.com"
+	 * });
+	 */
+	registerProvider(name: string, config: ProviderConfig): void;
+
 	/** Shared event bus for extension communication. */
 	events: EventBus;
 }
 
+// ============================================================================
+// Provider Registration Types
+// ============================================================================
+
+/** Configuration for registering a provider via pi.registerProvider(). */
+export interface ProviderConfig {
+	/** Base URL for the API endpoint. Required when defining models. */
+	baseUrl?: string;
+	/** API key or environment variable name. Required when defining models unless oauth is provided. */
+	apiKey?: string;
+	/** API type identifier. Required when registering streamSimple or when models don't specify one. */
+	api?: Api;
+	/** Custom streaming function for non-built-in APIs. */
+	streamSimple?: (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+	/** Custom headers to include in requests. */
+	headers?: Record<string, string>;
+	/** If true, adds Authorization: Bearer header with the resolved API key. */
+	authHeader?: boolean;
+	/** Models to register. If provided, replaces all existing models for this provider. */
+	models?: ProviderModelConfig[];
+	/** OAuth provider for /login support. */
+	oauth?: {
+		/** Display name in login UI. */
+		name: string;
+		/** Run the provider login flow and return credentials (or a plain API key) to persist. */
+		login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials | string>;
+		/** Refresh expired credentials. */
+		refreshToken?(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+		/** Convert credentials to an API key string for requests. */
+		getApiKey?(credentials: OAuthCredentials): string;
+		/** Optional model rewrite hook for credential-aware routing (e.g., enterprise URLs). */
+		modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
+	};
+}
+
+/** Configuration for a model within a provider. */
+export interface ProviderModelConfig {
+	/** Model ID (e.g., "claude-sonnet-4@20250514"). */
+	id: string;
+	/** Display name (e.g., "Claude Sonnet 4 (Vertex)"). */
+	name: string;
+	/** API type override for this model. */
+	api?: Api;
+	/** Whether the model supports extended thinking. */
+	reasoning: boolean;
+	/** Supported input types. */
+	input: ("text" | "image")[];
+	/** Cost per million tokens. */
+	cost: { input: number; output: number; cacheRead: number; cacheWrite: number };
+	/** Maximum context window size in tokens. */
+	contextWindow: number;
+	/** Maximum output tokens. */
+	maxTokens: number;
+	/** Custom headers for this model. */
+	headers?: Record<string, string>;
+	/** OpenAI compatibility settings. */
+	compat?: Model<Api>["compat"];
+}
+
 /** Extension factory function type. Supports both sync and async initialization. */
 export type ExtensionFactory = (pi: ExtensionAPI) => void | Promise<void>;
 
@@ -1038,6 +1210,8 @@ export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean)
 /** Shared state created by loader, used during registration and runtime. */
 export interface ExtensionRuntimeState {
 	flagValues: Map<string, boolean | string>;
+	/** Provider registrations queued during extension loading, processed during session initialization */
+	pendingProviderRegistrations: Array<{ name: string; config: ProviderConfig; sourceId: string }>;
 }
 
 /** Action implementations for ExtensionAPI methods. */

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/index.ts

@@ -62,6 +62,8 @@ export type {
 	LoadExtensionsResult,
 	MessageRenderer,
 	MessageRenderOptions,
+	ProviderConfig,
+	ProviderModelConfig,
 	RegisteredCommand,
 	ToolCallEvent,
 	ToolResultEvent,

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,22 +371,39 @@ 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.getAvailable();
 		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) {
-			writeStderr(chalk.red(`Model "${parsed.model}" not found`));
-			process.exit(1);
+		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;
+			}
 		}
-		options.model = model;
-		settings.overrideModelRoles({ default: `${model.provider}/${model.id}` });
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
 		const remembered = settings.getModelRole("default");
 		if (remembered) {
@@ -470,7 +488,7 @@ async function buildSessionOptions(
 		options.additionalExtensionPaths = [];
 	}
 
-	return options;
+	return { options, cliThinkingFromModel };
 }
 
 export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void> {
@@ -602,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;
@@ -610,11 +633,15 @@ 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) {
-			writeStderr(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--models"));
+		if (!sessionOptions.model && !sessionOptions.modelPattern) {
+			writeStderr(
+				chalk.red("--api-key requires a model to be specified via --model, --provider/--model, or --models"),
+			);
 			process.exit(1);
 		}
-		authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsedArgs.apiKey);
+		if (sessionOptions.model) {
+			authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsedArgs.apiKey);
+		}
 	}
 
 	time("buildSessionOptions");
@@ -622,6 +649,9 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		await createAgentSession(sessionOptions);
 	debugStartup("main:createAgentSession");
 	time("createAgentSession");
+	if (parsedArgs.apiKey && !sessionOptions.model && session.model) {
+		authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
+	}
 
 	if (modelFallbackMessage) {
 		notifs.push({ kind: "warn", message: modelFallbackMessage });
@@ -660,16 +690,22 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	debugStartup("main:applyExtensionFlags");
 
 	if (!isInteractive && !session.model) {
-		writeStderr(chalk.red("No models available."));
+		if (modelFallbackMessage) {
+			writeStderr(chalk.red(modelFallbackMessage));
+		} else {
+			writeStderr(chalk.red("No models available."));
+		}
 		writeStderr(chalk.yellow("\nSet an API key environment variable:"));
 		writeStderr("  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.");
 		writeStderr(chalk.yellow(`\nOr create ${ModelsConfigFile.path()}`));
 		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" },

package/src/modes/components/welcome.ts

@@ -41,12 +41,31 @@ export class WelcomeComponent implements Component {
 	}
 
 	render(termWidth: number): string[] {
-		// Box dimensions - responsive with min/max
-		const minWidth = 80;
+		// Box dimensions - responsive with max width and small-terminal support
 		const maxWidth = 100;
-		const boxWidth = Math.max(minWidth, Math.min(termWidth - 2, maxWidth));
-		const leftCol = 26;
-		const rightCol = boxWidth - leftCol - 3; // 3 = │ + │ + │
+		const boxWidth = Math.min(maxWidth, Math.max(0, termWidth - 2));
+		if (boxWidth < 4) {
+			return [];
+		}
+		const dualContentWidth = boxWidth - 3; // 3 = │ + │ + │
+		const preferredLeftCol = 26;
+		const minLeftCol = 14; // logo width
+		const minRightCol = 20;
+		const leftMinContentWidth = Math.max(
+			minLeftCol,
+			visibleWidth("Welcome back!"),
+			visibleWidth(this.modelName),
+			visibleWidth(this.providerName),
+		);
+		const desiredLeftCol = Math.min(preferredLeftCol, Math.max(minLeftCol, Math.floor(dualContentWidth * 0.35)));
+		const dualLeftCol =
+			dualContentWidth >= minRightCol + 1
+				? Math.min(desiredLeftCol, dualContentWidth - minRightCol)
+				: Math.max(1, dualContentWidth - 1);
+		const dualRightCol = Math.max(1, dualContentWidth - dualLeftCol);
+		const showRightColumn = dualLeftCol >= leftMinContentWidth && dualRightCol >= minRightCol;
+		const leftCol = showRightColumn ? dualLeftCol : boxWidth - 2;
+		const rightCol = showRightColumn ? dualRightCol : 0;
 
 		// Block-based OMP logo (gradient: magenta → cyan)
 		// biome-ignore format: preserve ASCII art layout
@@ -67,7 +86,7 @@ export class WelcomeComponent implements Component {
 		];
 
 		// Right column separator
-		const separatorWidth = rightCol - 2; // padding on each side
+		const separatorWidth = Math.max(0, rightCol - 2); // padding on each side
 		const separator = ` ${theme.fg("dim", theme.boxRound.horizontal.repeat(separatorWidth))}`;
 
 		// Recent sessions content
@@ -131,20 +150,31 @@ export class WelcomeComponent implements Component {
 		const titlePrefixRaw = hChar.repeat(3);
 		const titleStyled = theme.fg("dim", titlePrefixRaw) + theme.fg("muted", title);
 		const titleVisLen = visibleWidth(titlePrefixRaw) + visibleWidth(title);
-		const afterTitle = boxWidth - 2 - titleVisLen;
-		const afterTitleText = afterTitle > 0 ? theme.fg("dim", hChar.repeat(afterTitle)) : "";
-		lines.push(tl + titleStyled + afterTitleText + tr);
+		const titleSpace = boxWidth - 2;
+		if (titleVisLen >= titleSpace) {
+			lines.push(tl + truncateToWidth(titleStyled, titleSpace) + tr);
+		} else {
+			const afterTitle = titleSpace - titleVisLen;
+			lines.push(tl + titleStyled + theme.fg("dim", hChar.repeat(afterTitle)) + tr);
+		}
 
 		// Content rows
-		const maxRows = Math.max(leftLines.length, rightLines.length);
+		const maxRows = showRightColumn ? Math.max(leftLines.length, rightLines.length) : leftLines.length;
 		for (let i = 0; i < maxRows; i++) {
 			const left = this.#fitToWidth(leftLines[i] ?? "", leftCol);
-			const right = this.#fitToWidth(rightLines[i] ?? "", rightCol);
-			lines.push(v + left + v + right + v);
+			if (showRightColumn) {
+				const right = this.#fitToWidth(rightLines[i] ?? "", rightCol);
+				lines.push(v + left + v + right + v);
+			} else {
+				lines.push(v + left + v);
+			}
 		}
-
 		// Bottom border
-		lines.push(bl + h.repeat(leftCol) + theme.fg("dim", theme.boxSharp.teeUp) + h.repeat(rightCol) + br);
+		if (showRightColumn) {
+			lines.push(bl + h.repeat(leftCol) + theme.fg("dim", theme.boxSharp.teeUp) + h.repeat(rightCol) + br);
+		} else {
+			lines.push(bl + h.repeat(leftCol) + br);
+		}
 
 		return lines;
 	}