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

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [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
+
+- Added `repeatToolDescriptions` setting to render full tool descriptions in the system prompt instead of a tool name list
+
 ## [12.5.0] - 2026-02-15
 ### Breaking Changes
 

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.0",
+	"version": "12.6.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.0",
-		"@oh-my-pi/pi-agent-core": "12.5.0",
-		"@oh-my-pi/pi-ai": "12.5.0",
-		"@oh-my-pi/pi-natives": "12.5.0",
-		"@oh-my-pi/pi-tui": "12.5.0",
-		"@oh-my-pi/pi-utils": "12.5.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",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.18.0",

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/settings-schema.ts

@@ -253,6 +253,15 @@ export const SETTINGS_SCHEMA = {
 			description: "Rewrite tool call arguments to normalized format in session history",
 		},
 	},
+	repeatToolDescriptions: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "agent",
+			label: "Repeat tool descriptions",
+			description: "Render full tool descriptions in the system prompt instead of a tool name list",
+		},
+	},
 	readLineNumbers: {
 		type: "boolean",
 		default: false,

package/src/extensibility/extensions/index.ts

@@ -70,6 +70,9 @@ export type {
 	// Message Rendering
 	MessageRenderer,
 	MessageRenderOptions,
+	// Provider Registration
+	ProviderConfig,
+	ProviderModelConfig,
 	ReadToolCallEvent,
 	ReadToolResultEvent,
 	// Commands

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

@@ -8,7 +8,18 @@
  * - 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,
+	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";
@@ -976,10 +987,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 +1147,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/index.ts

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

package/src/main.ts

@@ -372,7 +372,7 @@ async function buildSessionOptions(
 
 	// Model from CLI (--model) - uses same fuzzy matching as --models
 	if (parsed.model) {
-		const available = modelRegistry.getAvailable();
+		const available = modelRegistry.getAll();
 		const modelMatchPreferences = {
 			usageOrder: settings.getStorage()?.getModelUsageOrder(),
 		};
@@ -381,11 +381,13 @@ async function buildSessionOptions(
 			writeStderr(chalk.yellow(`Warning: ${warning}`));
 		}
 		if (!model) {
-			writeStderr(chalk.red(`Model "${parsed.model}" not found`));
-			process.exit(1);
+			// 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}` });
 		}
-		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) {
@@ -610,11 +612,13 @@ 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) {
+		if (!sessionOptions.model && !sessionOptions.modelPattern) {
 			writeStderr(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--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 +626,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,7 +667,11 @@ 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()}`));

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;
 	}

package/src/modes/rpc/rpc-mode.ts

@@ -688,6 +688,6 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		}
 	}
 
-	// Keep process alive forever
-	return new Promise(() => {});
+	// stdin closed — RPC client is gone, exit cleanly
+	process.exit(0);
 }

package/src/prompts/system/system-prompt.md

@@ -56,11 +56,15 @@ The question is not "does this work?" but "under what conditions? What happens o
 
 <tools>
 ## Available Tools
+{{#if repeatToolDescriptions}}
 {{#each toolDescriptions}}
 <tool name="{{name}}">
 {{description}}
 </tool>
 {{/each}}
+{{else}}
+{{#list tools join="\n"}}- {{this}}{{/list}}
+{{/if}}
 
 {{#ifAny (includes tools "python") (includes tools "bash")}}
 ### Precedence: Specialized → Python → Bash

package/src/prompts/tools/hashline.md

@@ -1,94 +1,85 @@
-# Edit (Hash anchored)
+# Edit (Hash Anchored)
 
-Line-addressed edits using hash-verified line references. Read file in hashline mode, then edit by referencing `LINE:HASH` pairs.
+Line-addressed edits using hash-verified line references. Read files in hashline mode, collect exact `LINE:HASH` references, and submit edits that change only the targeted token or expression.
+**CRITICAL: Copy `LINE:HASH` refs verbatim from read output. Use only the anchor prefix (e.g., `{{hashline 42 "const x = 1"}}`), never the trailing source text after `|`.**
 
-<critical>
-- Copy `LINE:HASH` refs verbatim from read output — never fabricate or guess hashes
-- `new_text` (set_line/replace_lines) or `text` (insert_after) contains plain replacement lines only — no `LINE:HASH` prefix, no diff `+` markers
-- On hash mismatch: use the updated `LINE:HASH` refs shown by `>>>` directly; only `read` again if you need additional lines/context
-- If you already edited a file in this turn, re-read that file before the next edit to it
-- For code-change requests, respond with tool calls, not prose
-- Edit only requested lines. Do not reformat unrelated code.
-- Direction-lock every mutation: replace the exact currently-present token/expression with the intended target token/expression; never reverse the change or "change something nearby".
-- `new_text` must differ from the current line content — sending identical content is rejected as a no-op
-</critical>
+<workflow>
+1. Read the target file (`read`) to obtain `LINE:HASH` references
+2. Collect the exact `LINE:HASH` refs for lines you will change
+3. Direction-lock each mutation: identify the exact current token/expression → the intended replacement
+4. Submit one `edit` call containing all operations for that file
+5. If another edit is needed on the same file: re-read first, then edit (hashes change after every edit)
+6. Respond with tool calls only — no prose
+</workflow>
 
-<instruction>
-**Workflow:**
-1. Read target file (`read`)
-2. Collect the exact `LINE:HASH` refs you need
-3. Submit one `edit` call with all known operations for that file
-4. If another change on same file is needed later: re-read first, then edit
-5. Direction-lock each operation before submitting (`exact source token/expression on target line` → `intended replacement`) and keep the mutation to one logical locus. Do not output prose; submit only the tool call.
-**Atomicity:** All edits in one call are validated against the file as last read — line numbers and hashes refer to the original state, not after earlier edits in the same array. The applicator sorts and applies bottom-up automatically.
-**Edit variants:**
-- `{ set_line: { anchor: "LINE:HASH", new_text: "..." } }`
-- `{ replace_lines: { start_anchor: "LINE:HASH", end_anchor: "LINE:HASH", new_text: "..." } }`
-- `{ insert_after: { anchor: "LINE:HASH", text: "..." } }`
-- `{ replace: { old_text: "...", new_text: "...", all?: boolean } }` — substr-style fuzzy replace (no LINE:HASH; use when line refs unavailable)
+<operations>
+Four edit variants are available:
+- **`set_line`**: Replace a single line
+  `{ set_line: { anchor: "LINE:HASH", new_text: "..." } }`
+  `new_text: ""` keeps the line but makes it blank.
+- **`replace_lines`**: Replace a contiguous range (use for deletions with `new_text: ""`)
+  `{ replace_lines: { start_anchor: "LINE:HASH", end_anchor: "LINE:HASH", new_text: "..." } }`
+- **`insert_after`**: Add new content after an anchor line
+  `{ insert_after: { anchor: "LINE:HASH", text: "..." } }`
+- **`replace`**: Substring-style fuzzy match (when line refs are unavailable)
+  `{ replace: { old_text: "...", new_text: "...", all?: boolean } }`
+**Atomicity:** All edits in one call validate against the file as last read. Line numbers and hashes refer to the original state, not post-edit state. The applicator sorts and applies bottom-up automatically.
+</operations>
 
-`new_text: ""` means delete (for `set_line`/`replace_lines`).
-</instruction>
+<rules>
+1. **Scope each operation minimally.** One logical change site per operation. Use separate `set_line` ops for non-adjacent lines instead of a wide `replace_lines` that spans unchanged code.
+2. **Preserve original formatting exactly.** Copy each line's whitespace, braces, semicolons, trailing commas, and style — then change only the targeted token/expression. Keep `import { foo }` as-is; keep indentation and line breaks as-is.
+3. **Use `insert_after` for additions.** When adding a field, argument, or import near existing lines, prefer `insert_after` over replacing a neighboring line.
+4. **Ensure `new_text` differs from current content.** Identical content is rejected as a no-op.
+5. **Edit only requested lines.** Leave unrelated code untouched.
+6. **Lock mutation direction.** Replace the exact currently-present token with the intended target. For swaps between two locations, use two `set_line` ops in one call.
+</rules>
 
-<caution>
-**Preserve original formatting.** When writing `new_text`/`text`, copy each line's exact whitespace, braces, and style from the read output — then change *only* the targeted token/expression. Do not:
-- Restyle braces: `import { foo }` → `import {foo}`
-- Reflow arguments onto multiple lines or collapse them onto one line
-- Change indentation style, trailing commas, or semicolons on lines you replace
-- Do NOT use `replace_lines` over a wide span when multiple `set_line` ops would work — wide ranges tempt reformatting everything in between
-
-If a change spans multiple non-adjacent lines, use separate `set_line` operations for each — not a single `replace_lines` that includes unchanged lines in `new_text`.
-- Each edit operation must target one logical change site with minimal scope. If a fix requires two locations, use two operations; never span unrelated lines in one `replace_lines`.
-- Self-check before submitting: if your edit touches lines unrelated to the stated fix, split or narrow it.
-- Do NOT reformat lines you are replacing — preserve exact whitespace, braces (`{ foo }` not `{foo}`), arrow style, and line breaks. Change ONLY the targeted token/expression. Reformatting causes hash verification failure even when the logic is correct.
-- For swaps (exchanging content between two locations), use two `set_line` operations in one call — the applicator handles ordering. Do not try to account for line number shifts between operations.
-</caution>
-<instruction>
-**Recovery:**
-- Hash mismatch (`>>>` error): copy the updated `LINE:HASH` refs from the error verbatim and retry with the same intended mutation. Do NOT re-read unless you need lines not shown in the error.
-- If hash mismatch repeats after applying updated refs, stop blind retries and re-read the relevant region before retrying.
-- After a successful edit, always re-read the file before making another edit to the same file (hashes have changed).
-- No-op error ("identical content"): your replacement text matches what the file already contains. STOP and re-read the file — you are likely targeting the wrong line or your replacement is not actually different. Do NOT retry with the same content. After 2 consecutive no-op errors on the same line, re-read the entire function/block to understand the current file state.
-</instruction>
-
-<instruction>
-**Preflight schema and validation (required):**
-- Payload shape is `{"path": string, "edits": [operation, ...]}` with a non-empty `edits` array.
-- Each operation contains exactly one variant key: `set_line`, `replace_lines`, `insert_after`, or `replace`.
-- Required fields by variant:
-  - `set_line`: `anchor`, `new_text`
-  - `replace_lines`: `start_anchor`, `end_anchor`, `new_text`
-  - `insert_after`: `anchor`, `text` (non-empty)
-  - `replace`: `old_text`, `new_text` (fuzzy match; `all: true` for replace-all)
-- Each `anchor`/`start_anchor`/`end_anchor` ref matches `^\d+:[A-Za-z0-9]+$` (no spaces, no trailing source text).
-- `new_text`/`text` preserves original formatting and changes only the direction-locked target locus.
-</instruction>
-
-<input>
-- `path`: File path
-- `edits`: Array of edit operations (one of the variants above)
-</input>
+<recovery>
+**Hash mismatch (`>>>` error):**
+→ Copy the updated `LINE:HASH` refs from the error output verbatim and retry with the same intended mutation.
+→ Re-read only if you need lines not shown in the error.
+→ If mismatch repeats after applying updated refs, stop and re-read the relevant region.
+**No-op error ("identical content"):**
+→ Stop. Re-read the file — you are targeting the wrong line or your replacement is not different.
+→ After 2 consecutive no-op errors on the same line, re-read the entire function/block.
+</recovery>
 
+<examples>
 <example name="replace single line">
-edit {"path":"src/app.py","edits":[{"set_line":{"anchor":"{{hashline 2 'x = 42'}}","new_text":"  x = 99"}}]}
+set_line: { anchor: "{{hashline 2 "  x"}}", new_text: "  x = 99" }
 </example>
 
 <example name="replace range">
-edit {"path":"src/app.py","edits":[{"replace_lines":{"start_anchor":"{{hashline 5 'old_value = True'}}","end_anchor":"{{hashline 8 'return result'}}","new_text":"  combined = True"}}]}
+replace_lines: { start_anchor: "{{hashline 5 "old start line"}}", end_anchor: "{{hashline 8 "old end line"}}", new_text: "  combined = True" }
 </example>
 
 <example name="delete lines">
-edit {"path":"src/app.py","edits":[{"replace_lines":{"start_anchor":"{{hashline 5 'old_value = True'}}","end_anchor":"{{hashline 6 'unused = None'}}","new_text":""}}]}
+replace_lines: { start_anchor: "{{hashline 5 "line to delete A"}}", end_anchor: "{{hashline 6 "line to delete B"}}", new_text: "" }
 </example>
 
 <example name="insert after">
-edit {"path":"src/app.py","edits":[{"insert_after":{"anchor":"{{hashline 3 'def hello'}}","text":"  # new comment"}}]}
+insert_after: { anchor: "{{hashline 3 "anchor line content"}}", text: "  # new comment" }
 </example>
 
 <example name="multiple edits (bottom-up safe)">
-edit {"path":"src/app.py","edits":[{"set_line":{"anchor":"{{hashline 10 'return True'}}","new_text":"  return False"}},{"set_line":{"anchor":"{{hashline 3 'def hello'}}","new_text":"  x = 42"}}]}
+set_line: { anchor: "{{hashline 10 "old line 10"}}", new_text: "  return False" }
+set_line: { anchor: "{{hashline 3 "old line 3"}}", new_text: "  x = 42" }
 </example>
 
 <example name="content replace (substr-style, no hashes)">
-edit {"path":"src/app.py","edits":[{"replace":{"old_text":"x = 42","new_text":"x = 99"}}]}
-</example>
+replace: { old_text: "x = 42", new_text: "x = 99" }
+</example>
+</examples>
+
+<validation>
+Before submitting, verify:
+- [ ] Payload shape: `{"path": string, "edits": [operation, ...]}`  with non-empty `edits` array
+- [ ] Each operation has exactly one variant key: `set_line` | `replace_lines` | `insert_after` | `replace`
+- [ ] Each anchor is copied exactly from the `LINE:HASH` prefix (no spaces, no trailing source text)
+- [ ] `new_text`/`text` contains plain replacement lines only — no `LINE:HASH` prefixes, no diff `+` markers
+- [ ] Each replacement differs from the current line content
+- [ ] Each operation targets one logical change site with minimal scope
+- [ ] Formatting of replaced lines matches the original exactly, except for the targeted change
+</validation>
+**REMINDER: Copy `LINE:HASH` refs verbatim. Anchors are `LINE:HASH` only — never `LINE:HASH|content`. Preserve exact formatting. Change only the targeted token.**

package/src/sdk.ts

@@ -8,7 +8,7 @@ import chalk from "chalk";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
-import { formatModelString, parseModelString } from "./config/model-resolver";
+import { formatModelString, parseModelPattern, parseModelString } from "./config/model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./config/prompt-templates";
 import { Settings, type SkillsSettings } from "./config/settings";
 import { CursorExecHandlers } from "./cursor";
@@ -101,6 +101,9 @@ export interface CreateAgentSessionOptions {
 
 	/** Model to use. Default: from settings, else first available */
 	model?: Model;
+	/** Raw model pattern string (e.g. from --model CLI flag) to resolve after extensions load.
+	 * Used when model lookup is deferred because extension-provided models aren't registered yet. */
+	modelPattern?: string;
 	/** Thinking level. Default: from settings, else 'off' (clamped to model capabilities) */
 	thinkingLevel?: ThinkingLevel;
 	/** Models available for cycling (Ctrl+P in interactive mode) */
@@ -323,6 +326,7 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string }>;
 	cwd?: string;
 	appendPrompt?: string;
+	repeatToolDescriptions?: boolean;
 }
 
 /**
@@ -334,6 +338,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills: options.skills,
 		contextFiles: options.contextFiles,
 		appendSystemPrompt: options.appendPrompt,
+		repeatToolDescriptions: options.repeatToolDescriptions,
 	});
 }
 
@@ -580,13 +585,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const hasExistingSession = existingSession.messages.length > 0;
 	const hasThinkingEntry = sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 
-	const hasExplicitModel = options.model !== undefined;
+	const hasExplicitModel = options.model !== undefined || options.modelPattern !== undefined;
 	let model = options.model;
 	let modelFallbackMessage: string | undefined;
-
-	// If session has data, try to restore model from it
+	// If session has data, try to restore model from it.
+	// Skip restore when an explicit model was requested.
 	const defaultModelStr = existingSession.models.default;
-	if (!model && hasExistingSession && defaultModelStr) {
+	if (!hasExplicitModel && !model && hasExistingSession && defaultModelStr) {
 		const parsedModel = parseModelString(defaultModelStr);
 		if (parsedModel) {
 			const restoredModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
@@ -599,8 +604,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	// If still no model, try settings default
-	if (!model) {
+	// If still no model, try settings default.
+	// Skip settings fallback when an explicit model was requested.
+	if (!hasExplicitModel && !model) {
 		const settingsDefaultModel = settings.getModelRole("default");
 		if (settingsDefaultModel) {
 			const parsedModel = parseModelString(settingsDefaultModel);
@@ -613,29 +619,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	// Fall back to first available model with a valid API key
-	if (!model) {
-		const allModels = modelRegistry.getAll();
-		for (const candidate of allModels) {
-			if (await hasModelApiKey(candidate)) {
-				model = candidate;
-				break;
-			}
-		}
-		time("findAvailableModel");
-		if (model) {
-			if (modelFallbackMessage) {
-				modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
-			}
-		} else {
-			// No models available - set message so user knows to /login or configure keys
-			modelFallbackMessage =
-				"No models available. Use /login or set an API key environment variable. Then use /model to select a model.";
-		}
-	}
-
-	time("findModel");
-
 	// For subagent sessions using GitHub Copilot, add X-Initiator header
 	// to ensure proper billing (agent-initiated vs user-initiated)
 	const taskDepth = options.taskDepth ?? 0;
@@ -897,6 +880,58 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
+	// Process provider registrations queued during extension loading.
+	// This must happen before the runner is created so that models registered by
+	// extensions are available for model selection on session resume / fallback.
+	const activeExtensionSources = extensionsResult.extensions.map(extension => extension.path);
+	modelRegistry.syncExtensionSources(activeExtensionSources);
+	for (const sourceId of new Set(activeExtensionSources)) {
+		modelRegistry.clearSourceRegistrations(sourceId);
+	}
+	if (extensionsResult.runtime.pendingProviderRegistrations.length > 0) {
+		for (const { name, config, sourceId } of extensionsResult.runtime.pendingProviderRegistrations) {
+			modelRegistry.registerProvider(name, config, sourceId);
+		}
+		extensionsResult.runtime.pendingProviderRegistrations = [];
+	}
+
+	// Resolve deferred --model pattern now that extension models are registered.
+	if (!model && options.modelPattern) {
+		const availableModels = modelRegistry.getAll();
+		const matchPreferences = {
+			usageOrder: settings.getStorage()?.getModelUsageOrder(),
+		};
+		const { model: resolved } = parseModelPattern(options.modelPattern, availableModels, matchPreferences);
+		if (resolved) {
+			model = resolved;
+			modelFallbackMessage = undefined;
+		} else {
+			modelFallbackMessage = `Model "${options.modelPattern}" not found`;
+		}
+	}
+
+	// Fall back to first available model with a valid API key.
+	// Skip fallback if the user explicitly requested a model via --model that wasn't found.
+	if (!model && !options.modelPattern) {
+		const allModels = modelRegistry.getAll();
+		for (const candidate of allModels) {
+			if (await hasModelApiKey(candidate)) {
+				model = candidate;
+				break;
+			}
+		}
+		time("findAvailableModel");
+		if (model) {
+			if (modelFallbackMessage) {
+				modelFallbackMessage += `. Using ${model.provider}/${model.id}`;
+			}
+		} else {
+			modelFallbackMessage =
+				"No models available. Use /login or set an API key environment variable. Then use /model to select a model.";
+		}
+	}
+
+	time("findModel");
 	// Discover custom commands (TypeScript slash commands)
 	const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
 		? { commands: [], errors: [] }
@@ -986,6 +1021,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		emitEvent: event => cursorEventEmitter?.(event),
 	});
 
+	const repeatToolDescriptions = settings.get("repeatToolDescriptions");
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const memoryInstructions = await buildMemoryToolDeveloperInstructions(agentDir, settings);
@@ -999,6 +1035,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			rules: rulebookRules,
 			skillsSettings: settings.getGroup("skills") as SkillsSettings,
 			appendSystemPrompt: memoryInstructions,
+			repeatToolDescriptions,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1016,6 +1053,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				skillsSettings: settings.getGroup("skills") as SkillsSettings,
 				customPrompt: options.systemPrompt,
 				appendSystemPrompt: memoryInstructions,
+				repeatToolDescriptions,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);

package/src/session/auth-storage.ts

@@ -7,6 +7,7 @@ import {
 	claudeUsageProvider,
 	getEnvApiKey,
 	getOAuthApiKey,
+	getOAuthProvider,
 	githubCopilotUsageProvider,
 	googleGeminiCliUsageProvider,
 	kimiUsageProvider,
@@ -25,6 +26,7 @@ import {
 	type OAuthController,
 	type OAuthCredentials,
 	type OAuthProvider,
+	type OAuthProviderId,
 	openaiCodexUsageProvider,
 	type Provider,
 	type UsageCache,
@@ -634,7 +636,7 @@ export class AuthStorage {
 	 * Login to an OAuth provider.
 	 */
 	async login(
-		provider: OAuthProvider,
+		provider: OAuthProviderId,
 		ctrl: OAuthController & {
 			/** onAuth is required by auth-storage but optional in OAuthController */
 			onAuth: (info: { url: string; instructions?: string }) => void;
@@ -709,8 +711,26 @@ export class AuthStorage {
 				await saveApiKeyCredential(apiKey);
 				return;
 			}
-			default:
-				throw new Error(`Unknown OAuth provider: ${provider}`);
+			default: {
+				const customProvider = getOAuthProvider(provider);
+				if (!customProvider) {
+					throw new Error(`Unknown OAuth provider: ${provider}`);
+				}
+				const customLoginResult = await customProvider.login({
+					onAuth: info => ctrl.onAuth(info),
+					onProgress: ctrl.onProgress,
+					onPrompt: ctrl.onPrompt,
+					onManualCodeInput: async () =>
+						ctrl.onPrompt({ message: "Paste the authorization code (or full redirect URL):" }),
+					signal: ctrl.signal,
+				});
+				if (typeof customLoginResult === "string") {
+					await saveApiKeyCredential(customLoginResult);
+					return;
+				}
+				credentials = customLoginResult;
+				break;
+			}
 		}
 		const newCredential: OAuthCredential = { type: "oauth", ...credentials };
 		const existing = this.#getCredentialsForProvider(provider);
@@ -1170,14 +1190,28 @@ export class AuthStorage {
 			}
 		}
 
-		const oauthCreds: Record<string, OAuthCredentials> = {
-			[provider]: selection.credential,
-		};
-
 		try {
-			const result = await getOAuthApiKey(provider as OAuthProvider, oauthCreds);
+			let result: { newCredentials: OAuthCredentials; apiKey: string } | null;
+			const customProvider = getOAuthProvider(provider);
+			if (customProvider) {
+				let refreshedCredentials: OAuthCredentials = selection.credential;
+				if (Date.now() >= refreshedCredentials.expires) {
+					if (!customProvider.refreshToken) {
+						throw new Error(`OAuth provider "${provider}" does not support token refresh`);
+					}
+					refreshedCredentials = await customProvider.refreshToken(refreshedCredentials);
+				}
+				const apiKey = customProvider.getApiKey
+					? customProvider.getApiKey(refreshedCredentials)
+					: refreshedCredentials.access;
+				result = { newCredentials: refreshedCredentials, apiKey };
+			} else {
+				const oauthCreds: Record<string, OAuthCredentials> = {
+					[provider]: selection.credential,
+				};
+				result = await getOAuthApiKey(provider as OAuthProvider, oauthCreds);
+			}
 			if (!result) return undefined;
-
 			const updated: OAuthCredential = {
 				type: "oauth",
 				access: result.newCredentials.access,
@@ -1189,7 +1223,6 @@ export class AuthStorage {
 				enterpriseUrl: result.newCredentials.enterpriseUrl ?? selection.credential.enterpriseUrl,
 			};
 			this.#replaceCredentialAt(provider, selection.index, updated);
-
 			if (checkUsage && !allowBlocked) {
 				const sameAccount = selection.credential.accountId === updated.accountId;
 				if (!usageChecked || !sameAccount) {
@@ -1205,7 +1238,6 @@ export class AuthStorage {
 					return undefined;
 				}
 			}
-
 			this.#recordSessionCredential(provider, sessionId, "oauth", selection.index);
 			return result.apiKey;
 		} catch (error) {

package/src/system-prompt.ts

@@ -430,6 +430,8 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
+	/** Repeat full tool descriptions in system prompt. Default: false */
+	repeatToolDescriptions?: boolean;
 	/** Skills settings for discovery. */
 	skillsSettings?: SkillsSettings;
 	/** Working directory. Default: getProjectDir() */
@@ -454,6 +456,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
+		repeatToolDescriptions = false,
 		skillsSettings,
 		toolNames,
 		cwd,
@@ -553,6 +556,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	return renderPromptTemplate(systemPromptTemplate, {
 		tools: toolNamesArray,
 		toolDescriptions,
+		repeatToolDescriptions,
 		environment,
 		systemPromptCustomization: systemPromptCustomization ?? "",
 		contextFiles,