@ottocode/sdk 0.1.228 → 0.1.231

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.228",
+	"version": "0.1.231",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/config/src/index.ts

@@ -34,6 +34,8 @@ const DEFAULTS: {
 		toolApproval: 'auto',
 		guidedMode: false,
 		reasoningText: true,
+		reasoningLevel: 'high',
+		fullWidthContent: true,
 	},
 	providers: DEFAULT_PROVIDER_SETTINGS,
 };

package/src/config/src/manager.ts

@@ -66,6 +66,7 @@ export async function writeDefaults(
 		toolApproval: 'auto' | 'dangerous' | 'all';
 		guidedMode: boolean;
 		reasoningText: boolean;
+		reasoningLevel: 'minimal' | 'low' | 'medium' | 'high' | 'max' | 'xhigh';
 		theme: string;
 	}>,
 	projectRoot?: string,

package/src/core/src/index.ts

@@ -115,9 +115,15 @@ export { isDebugEnabled, isTraceEnabled } from './utils/debug.ts';
 export {
 	MCPClientWrapper,
 	MCPServerManager,
+	COPILOT_MCP_SCOPE,
 	convertMCPToolsToAISDK,
+	getCopilotMCPOAuthKey,
+	getStoredCopilotMCPToken,
 	getMCPManager,
+	hasCopilotMCPScopes,
 	initializeMCP,
+	isGitHubCopilotUrl,
+	isStoredCopilotMCPAuthenticated,
 	shutdownMCP,
 	loadMCPConfig,
 	addMCPServerToConfig,

package/src/core/src/mcp/copilot-auth.ts

@@ -0,0 +1,104 @@
+import { createHash } from 'node:crypto';
+import type { MCPScope } from './types.ts';
+import type { OAuthCredentialStore } from './oauth/store.ts';
+
+export const GITHUB_COPILOT_HOSTS = [
+	'api.githubcopilot.com',
+	'copilot-proxy.githubusercontent.com',
+];
+
+export const COPILOT_MCP_REQUIRED_SCOPES = [
+	'repo',
+	'read:org',
+	'gist',
+	'notifications',
+	'read:project',
+	'security_events',
+];
+
+export const COPILOT_MCP_SCOPE =
+	'repo read:org read:packages gist notifications read:project security_events';
+
+/**
+ * Returns whether a URL points at a GitHub Copilot-backed MCP endpoint.
+ */
+export function isGitHubCopilotUrl(url?: string): boolean {
+	if (!url) return false;
+	try {
+		const parsed = new URL(url);
+		return GITHUB_COPILOT_HOSTS.some(
+			(host) =>
+				parsed.hostname === host || parsed.hostname.endsWith(`.${host}`),
+		);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Returns whether the stored scope string satisfies the GitHub Copilot MCP requirements.
+ */
+export function hasCopilotMCPScopes(scopes?: string): boolean {
+	if (!scopes) return false;
+	const granted = scopes.split(/[\s,]+/).filter(Boolean);
+	return COPILOT_MCP_REQUIRED_SCOPES.every((scope) => granted.includes(scope));
+}
+
+/**
+ * Builds the MCP OAuth store key for a GitHub Copilot MCP server.
+ */
+export function getCopilotMCPOAuthKey(
+	serverName: string,
+	scope: MCPScope = 'global',
+	projectRoot?: string,
+): string {
+	if (scope === 'project' && projectRoot) {
+		const hash = createHash('sha256')
+			.update(projectRoot)
+			.digest('hex')
+			.slice(0, 8);
+		return `${serverName}_proj_${hash}`;
+	}
+	return serverName;
+}
+
+/**
+ * Loads the stored GitHub Copilot MCP bearer token for a server.
+ */
+export async function getStoredCopilotMCPToken(
+	store: OAuthCredentialStore,
+	serverName: string,
+	scope: MCPScope = 'global',
+	projectRoot?: string,
+): Promise<{ token: string | null; needsReauth: boolean; scopes?: string }> {
+	const tokens = await store.loadTokens(
+		getCopilotMCPOAuthKey(serverName, scope, projectRoot),
+	);
+	const token = tokens?.access_token ?? null;
+	if (!token) {
+		return { token: null, needsReauth: true };
+	}
+	return {
+		token,
+		needsReauth: !hasCopilotMCPScopes(tokens?.scope),
+		scopes: tokens?.scope,
+	};
+}
+
+/**
+ * Returns whether the stored GitHub Copilot MCP credentials are usable.
+ */
+export async function isStoredCopilotMCPAuthenticated(
+	store: OAuthCredentialStore,
+	serverName: string,
+	scope: MCPScope = 'global',
+	projectRoot?: string,
+): Promise<boolean> {
+	const { token, needsReauth } = await getStoredCopilotMCPToken(
+		store,
+		serverName,
+		scope,
+		projectRoot,
+	);
+	return !!token && !needsReauth;
+}

package/src/core/src/mcp/index.ts

@@ -13,6 +13,15 @@ export { MCPServerManager } from './server-manager.ts';
 
 export { convertMCPToolsToAISDK } from './tools.ts';
 
+export {
+	COPILOT_MCP_SCOPE,
+	getCopilotMCPOAuthKey,
+	getStoredCopilotMCPToken,
+	hasCopilotMCPScopes,
+	isGitHubCopilotUrl,
+	isStoredCopilotMCPAuthenticated,
+} from './copilot-auth.ts';
+
 export {
 	getMCPToolBriefs,
 	buildLoadMCPToolsTool,

package/src/core/src/mcp/server-manager.ts

@@ -2,66 +2,12 @@ import { MCPClientWrapper, type MCPToolInfo } from './client.ts';
 import type { MCPServerConfig, MCPServerStatus } from './types.ts';
 import { OAuthCredentialStore } from './oauth/store.ts';
 import { OttoOAuthProvider } from './oauth/provider.ts';
-import { createHash } from 'node:crypto';
-import { getAuth } from '../../../auth/src/index.ts';
-
-const GITHUB_COPILOT_HOSTS = [
-	'api.githubcopilot.com',
-	'copilot-proxy.githubusercontent.com',
-];
-
-function isGitHubCopilotUrl(url?: string): boolean {
-	if (!url) return false;
-	try {
-		const parsed = new URL(url);
-		return GITHUB_COPILOT_HOSTS.some(
-			(h) => parsed.hostname === h || parsed.hostname.endsWith(`.${h}`),
-		);
-	} catch {
-		return false;
-	}
-}
-
-const COPILOT_MCP_REQUIRED_SCOPES = [
-	'repo',
-	'read:org',
-	'gist',
-	'notifications',
-	'read:project',
-	'security_events',
-];
-
-function hasMCPScopes(scopes?: string): boolean {
-	if (!scopes) return false;
-	const granted = scopes.split(/[\s,]+/).filter(Boolean);
-	return COPILOT_MCP_REQUIRED_SCOPES.every((s) => granted.includes(s));
-}
-
-async function getCopilotToken(): Promise<string | null> {
-	try {
-		const auth = await getAuth('copilot');
-		if (auth?.type === 'oauth' && auth.refresh) {
-			return auth.refresh;
-		}
-	} catch {}
-	return null;
-}
-
-async function getCopilotMCPToken(): Promise<{
-	token: string | null;
-	needsReauth: boolean;
-}> {
-	try {
-		const auth = await getAuth('copilot');
-		if (auth?.type === 'oauth' && auth.refresh) {
-			if (!hasMCPScopes(auth.scopes)) {
-				return { token: auth.refresh, needsReauth: true };
-			}
-			return { token: auth.refresh, needsReauth: false };
-		}
-	} catch {}
-	return { token: null, needsReauth: true };
-}
+import {
+	getCopilotMCPOAuthKey,
+	getStoredCopilotMCPToken,
+	isGitHubCopilotUrl,
+	isStoredCopilotMCPAuthenticated,
+} from './copilot-auth.ts';
 
 type IndexedTool = {
 	server: string;
@@ -88,14 +34,11 @@ export class MCPServerManager {
 
 	private oauthKey(serverName: string): string {
 		const scope = this.serverScopes.get(serverName);
-		if (scope === 'project' && this.projectRoot) {
-			const hash = createHash('sha256')
-				.update(this.projectRoot)
-				.digest('hex')
-				.slice(0, 8);
-			return `${serverName}_proj_${hash}`;
-		}
-		return serverName;
+		return getCopilotMCPOAuthKey(
+			serverName,
+			scope,
+			this.projectRoot ?? undefined,
+		);
 	}
 
 	async startServers(configs: MCPServerConfig[]): Promise<void> {
@@ -115,7 +58,12 @@ export class MCPServerManager {
 
 		if (transport !== 'stdio') {
 			if (isGitHubCopilotUrl(config.url)) {
-				const { token, needsReauth } = await getCopilotMCPToken();
+				const { token, needsReauth } = await getStoredCopilotMCPToken(
+					this.oauthStore,
+					config.name,
+					config.scope ?? 'global',
+					this.projectRoot ?? undefined,
+				);
 				if (token && !needsReauth) {
 					config = {
 						...config,
@@ -159,7 +107,7 @@ export class MCPServerManager {
 					return;
 				}
 				console.error(
-					`[mcp] GitHub Copilot MCP server "${config.name}" requires authentication. Run \`otto auth login copilot\` or \`otto mcp auth ${config.name}\`.`,
+					`[mcp] GitHub Copilot MCP server "${config.name}" requires authentication. Run \`otto mcp auth ${config.name}\`.`,
 				);
 				this.clients.set(config.name, client);
 				return;
@@ -296,7 +244,12 @@ export class MCPServerManager {
 			const config = client.serverConfig;
 			let authenticated = false;
 			if (isGitHubCopilotUrl(config.url)) {
-				authenticated = !!(await getCopilotToken());
+				authenticated = await isStoredCopilotMCPAuthenticated(
+					this.oauthStore,
+					name,
+					config.scope ?? 'global',
+					this.projectRoot ?? undefined,
+				).catch(() => false);
 			} else {
 				const key = this.oauthKey(name);
 				authenticated = await this.oauthStore
@@ -334,8 +287,13 @@ export class MCPServerManager {
 		if (transport === 'stdio') return null;
 
 		if (isGitHubCopilotUrl(config.url)) {
-			const token = await getCopilotToken();
-			if (token) {
+			const { token, needsReauth } = await getStoredCopilotMCPToken(
+				this.oauthStore,
+				config.name,
+				config.scope ?? 'global',
+				this.projectRoot ?? undefined,
+			);
+			if (token && !needsReauth) {
 				const authedConfig = {
 					...config,
 					headers: {
@@ -472,8 +430,19 @@ export class MCPServerManager {
 	): Promise<{ authenticated: boolean; expiresAt?: number }> {
 		const client = this.clients.get(name);
 		if (client && isGitHubCopilotUrl(client.serverConfig.url)) {
-			const token = await getCopilotToken();
-			return { authenticated: !!token };
+			const key = this.oauthKey(name);
+			const tokens = await this.oauthStore.loadTokens(key);
+			return {
+				authenticated:
+					!!tokens?.access_token &&
+					(await isStoredCopilotMCPAuthenticated(
+						this.oauthStore,
+						name,
+						client.serverConfig.scope ?? 'global',
+						this.projectRoot ?? undefined,
+					)),
+				expiresAt: tokens?.expires_at,
+			};
 		}
 		const key = this.oauthKey(name);
 		const tokens = await this.oauthStore.loadTokens(key);

package/src/core/src/terminals/rust-libs.ts

@@ -1,20 +1,15 @@
-// @ts-expect-error Bun file asset import
 import darwinArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.dylib' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import darwinX64 from 'bun-pty/rust-pty/target/release/librust_pty.dylib' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import linuxArm64 from 'bun-pty/rust-pty/target/release/librust_pty_arm64.so' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import linuxX64 from 'bun-pty/rust-pty/target/release/librust_pty.so' with {
 	type: 'file',
 };
-// @ts-expect-error Bun file asset import
 import windowsDll from 'bun-pty/rust-pty/target/release/rust_pty.dll' with {
 	type: 'file',
 };

package/src/core/src/tools/builtin/bash.ts

@@ -1,9 +1,9 @@
 import { tool, type Tool } from 'ai';
-import { z } from 'zod/v3';
 import { spawn } from 'node:child_process';
+import { z } from 'zod/v3';
 import DESCRIPTION from './bash.txt' with { type: 'text' };
-import { createToolError, type ToolResponse } from '../error.ts';
 import { getAugmentedPath } from '../bin-manager.ts';
+import { createToolError, type ToolResponse } from '../error.ts';
 import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
 
 function normalizePath(p: string) {
@@ -41,10 +41,26 @@ function killProcessTree(pid: number) {
 	}
 }
 
+type BashResult = ToolResponse<{
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}>;
+
+type BashStreamChunk =
+	| {
+			channel: 'output';
+			delta: string;
+	  }
+	| {
+			result: BashResult;
+	  };
+
 export function buildBashTool(projectRoot: string): {
 	name: string;
 	tool: Tool;
 } {
+	// biome-ignore lint/suspicious/noExplicitAny: AI SDK tool typings do not model async-iterable execute results yet.
 	const bash = tool({
 		description: DESCRIPTION,
 		inputSchema: z
@@ -66,7 +82,7 @@ export function buildBashTool(projectRoot: string): {
 					.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
 			})
 			.strict(),
-		async execute(
+		execute(
 			{
 				cmd,
 				cwd,
@@ -79,13 +95,7 @@ export function buildBashTool(projectRoot: string): {
 				timeout?: number;
 			},
 			options?: { abortSignal?: AbortSignal },
-		): Promise<
-			ToolResponse<{
-				exitCode: number;
-				stdout: string;
-				stderr: string;
-			}>
-		> {
+		): AsyncIterable<BashStreamChunk> | BashResult {
 			const abortSignal = options?.abortSignal;
 
 			if (abortSignal?.aborted) {
@@ -95,126 +105,162 @@ export function buildBashTool(projectRoot: string): {
 			}
 
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
-
 			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
 
-			return new Promise((resolve) => {
-				const proc = spawn(finalCmd, {
-					cwd: absCwd,
-					shell: true,
-					stdio: ['ignore', 'pipe', 'pipe'],
-					env: { ...process.env, PATH: getAugmentedPath() },
-					detached: true,
-				});
+			const proc = spawn(finalCmd, {
+				cwd: absCwd,
+				shell: true,
+				stdio: ['ignore', 'pipe', 'pipe'],
+				env: { ...process.env, PATH: getAugmentedPath() },
+				detached: true,
+			});
 
-				let stdout = '';
-				let stderr = '';
-				let didTimeout = false;
-				let didAbort = false;
-				let settled = false;
-				let timeoutId: ReturnType<typeof setTimeout> | null = null;
-
-				const settle = (
-					result: ToolResponse<{
-						exitCode: number;
-						stdout: string;
-						stderr: string;
-					}>,
-				) => {
-					if (settled) return;
-					settled = true;
-					if (timeoutId) clearTimeout(timeoutId);
-					if (abortSignal) {
-						abortSignal.removeEventListener('abort', onAbort);
-					}
-					resolve(result);
-				};
+			let stdout = '';
+			let stderr = '';
+			let didTimeout = false;
+			let didAbort = false;
+			let settled = false;
+			let done = false;
+			let timeoutId: ReturnType<typeof setTimeout> | null = null;
+			const queue: BashStreamChunk[] = [];
+			let notify: (() => void) | null = null;
 
-				const onAbort = () => {
-					if (settled) return;
-					didAbort = true;
-					if (proc.pid) killProcessTree(proc.pid);
-					else proc.kill('SIGTERM');
-				};
+			const wake = () => {
+				if (!notify) return;
+				notify();
+				notify = null;
+			};
+
+			const pushDelta = (text: string) => {
+				if (!text) return;
+				queue.push({ channel: 'output', delta: text });
+				wake();
+			};
 
+			const settle = (result: BashResult) => {
+				if (settled) return;
+				settled = true;
+				if (timeoutId) clearTimeout(timeoutId);
 				if (abortSignal) {
-					abortSignal.addEventListener('abort', onAbort, { once: true });
+					abortSignal.removeEventListener('abort', onAbort);
 				}
+				queue.push({ result });
+				done = true;
+				wake();
+			};
 
-				if (timeout > 0) {
-					timeoutId = setTimeout(() => {
-						didTimeout = true;
-						if (proc.pid) killProcessTree(proc.pid);
-						else proc.kill();
-					}, timeout);
-				}
+			const onAbort = () => {
+				if (settled) return;
+				didAbort = true;
+				if (proc.pid) killProcessTree(proc.pid);
+				else proc.kill('SIGTERM');
+			};
 
-				proc.stdout?.on('data', (chunk) => {
-					stdout += chunk.toString();
-				});
+			if (abortSignal) {
+				abortSignal.addEventListener('abort', onAbort, { once: true });
+			}
 
-				proc.stderr?.on('data', (chunk) => {
-					stderr += chunk.toString();
-				});
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					didTimeout = true;
+					if (proc.pid) killProcessTree(proc.pid);
+					else proc.kill();
+				}, timeout);
+			}
 
-				proc.on('close', (exitCode) => {
-					if (didAbort) {
-						settle(
-							createToolError(`Command aborted by user: ${cmd}`, 'abort', {
-								cmd,
-								stdout,
-								stderr,
-							}),
-						);
-					} else if (didTimeout) {
-						settle(
-							createToolError(
-								`Command timed out after ${timeout}ms: ${cmd}`,
-								'timeout',
-								{
-									parameter: 'timeout',
-									value: timeout,
-									suggestion: 'Increase timeout or optimize the command',
-								},
-							),
-						);
-					} else if (exitCode !== 0 && !allowNonZeroExit) {
-						const errorDetail = stderr.trim() || stdout.trim() || '';
-						const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
-						settle(
-							createToolError(errorMsg, 'execution', {
-								exitCode,
-								stdout,
-								stderr,
-								cmd,
-								suggestion:
-									'Check command syntax or use allowNonZeroExit: true',
-							}),
-						);
-					} else {
-						settle({
-							ok: true,
-							exitCode: exitCode ?? 0,
+			proc.stdout?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stdout += text;
+				pushDelta(text);
+			});
+
+			proc.stderr?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stderr += text;
+				pushDelta(text);
+			});
+
+			proc.on('close', (exitCode) => {
+				if (didAbort) {
+					settle(
+						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
+							cmd,
 							stdout,
 							stderr,
-						});
-					}
-				});
+						}),
+					);
+					return;
+				}
 
-				proc.on('error', (err) => {
+				if (didTimeout) {
 					settle(
 						createToolError(
-							`Command execution failed: ${err.message}`,
-							'execution',
+							`Command timed out after ${timeout}ms: ${cmd}`,
+							'timeout',
 							{
-								cmd,
-								originalError: err.message,
+								parameter: 'timeout',
+								value: timeout,
+								stdout,
+								stderr,
+								suggestion: 'Increase timeout or optimize the command',
 							},
 						),
 					);
+					return;
+				}
+
+				if (exitCode !== 0 && !allowNonZeroExit) {
+					const errorDetail = stderr.trim() || stdout.trim() || '';
+					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
+					settle(
+						createToolError(errorMsg, 'execution', {
+							exitCode,
+							stdout,
+							stderr,
+							cmd,
+							suggestion: 'Check command syntax or use allowNonZeroExit: true',
+						}),
+					);
+					return;
+				}
+
+				settle({
+					ok: true,
+					exitCode: exitCode ?? 0,
+					stdout,
+					stderr,
 				});
 			});
+
+			proc.on('error', (err) => {
+				settle(
+					createToolError(
+						`Command execution failed: ${err.message}`,
+						'execution',
+						{
+							cmd,
+							originalError: err.message,
+						},
+					),
+				);
+			});
+
+			const stream = async function* (): AsyncGenerator<BashStreamChunk> {
+				while (!done || queue.length > 0) {
+					if (queue.length === 0) {
+						await new Promise<void>((resolve) => {
+							notify = resolve;
+						});
+					}
+					while (queue.length > 0) {
+						const chunk = queue.shift();
+						if (chunk) yield chunk;
+					}
+				}
+			};
+
+			return stream();
 		},
-	});
+	} as any);
 	return { name: 'bash', tool: bash };
 }

package/src/index.ts

@@ -29,6 +29,7 @@ export type {
 	DefaultConfig,
 	PathConfig,
 	OttoConfig,
+	ReasoningLevel,
 } from './types/src/index.ts';
 
 // =======================
@@ -361,9 +362,15 @@ export type { TunnelConnection, TunnelEvents } from './tunnel/index.ts';
 export {
 	MCPClientWrapper,
 	MCPServerManager,
+	COPILOT_MCP_SCOPE,
 	convertMCPToolsToAISDK,
+	getCopilotMCPOAuthKey,
+	getStoredCopilotMCPToken,
 	getMCPManager,
+	hasCopilotMCPScopes,
 	initializeMCP,
+	isGitHubCopilotUrl,
+	isStoredCopilotMCPAuthenticated,
 	shutdownMCP,
 	loadMCPConfig,
 	addMCPServerToConfig,

package/src/prompts/src/providers.ts

@@ -49,6 +49,25 @@ async function readIfExists(path: string): Promise<string | undefined> {
 	return undefined;
 }
 
+function getPromptOverridePaths(args: {
+	projectRoot: string;
+	provider: string;
+	modelId?: string;
+}): { modelPaths: string[]; providerPaths: string[] } {
+	const { projectRoot, provider, modelId } = args;
+	const modelPaths: string[] = [];
+	const providerPaths: string[] = [];
+
+	if (modelId) {
+		const sanitized = sanitizeModelId(modelId);
+		modelPaths.push(`${projectRoot}/.otto/prompts/models/${sanitized}.txt`);
+	}
+
+	providerPaths.push(`${projectRoot}/.otto/prompts/providers/${provider}.txt`);
+
+	return { modelPaths, providerPaths };
+}
+
 export type ProviderPromptResult = {
 	prompt: string;
 	resolvedType: string;
@@ -57,21 +76,37 @@ export type ProviderPromptResult = {
 export async function providerBasePrompt(
 	provider: string,
 	modelId: string | undefined,
-	_projectRoot: string,
+	projectRoot: string,
 ): Promise<ProviderPromptResult> {
 	const id = String(provider || '').toLowerCase();
+	const { modelPaths, providerPaths } = getPromptOverridePaths({
+		projectRoot,
+		provider: id,
+		modelId,
+	});
 
 	if (modelId) {
 		const sanitized = sanitizeModelId(modelId);
-		const modelPath = `src/prompts/models/${sanitized}.txt`;
-		const modelText = await readIfExists(modelPath);
-		if (modelText) {
+		for (const modelPath of modelPaths) {
+			const modelText = await readIfExists(modelPath);
+			if (!modelText) continue;
 			const promptType = `model:${sanitized}`;
-			debugLog(`[provider] prompt: ${promptType} (${modelText.length} chars)`);
+			debugLog(
+				`[provider] prompt: ${promptType} (${modelText.length} chars) from ${modelPath}`,
+			);
 			return { prompt: modelText, resolvedType: promptType };
 		}
 	}
 
+	for (const providerPath of providerPaths) {
+		const providerText = await readIfExists(providerPath);
+		if (!providerText) continue;
+		debugLog(
+			`[provider] prompt: custom:${id} (${providerText.length} chars) from ${providerPath}`,
+		);
+		return { prompt: providerText, resolvedType: `custom:${id}` };
+	}
+
 	if (isProviderId(id) && modelId) {
 		const info = getModelInfo(id, modelId);
 		if (info?.ownedBy) {
@@ -119,13 +154,6 @@ export async function providerBasePrompt(
 		return { prompt: result, resolvedType: 'glm' };
 	}
 
-	const providerPath = `src/prompts/providers/${id}.txt`;
-	const providerText = await readIfExists(providerPath);
-	if (providerText) {
-		debugLog(`[provider] prompt: custom:${id} (${providerText.length} chars)`);
-		return { prompt: providerText, resolvedType: `custom:${id}` };
-	}
-
 	const result = PROVIDER_DEFAULT.trim();
 	debugLog(`[provider] prompt: default (${result.length} chars)`);
 	return { prompt: result, resolvedType: 'default' };

package/src/providers/src/catalog-manual.ts

@@ -14,6 +14,7 @@ const OWNER_NPM: Record<ModelOwner, string> = {
 	openai: '@ai-sdk/openai',
 	anthropic: '@ai-sdk/anthropic',
 	google: '@ai-sdk/google',
+	openrouter: '@openrouter/ai-sdk-provider',
 	xai: '@ai-sdk/xai',
 	moonshot: '@ai-sdk/openai-compatible',
 	zai: '@ai-sdk/openai-compatible',

package/src/providers/src/catalog.ts

@@ -762,7 +762,7 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 				ownedBy: 'openai',
 				label: 'GPT-5.4',
 				modalities: {
-					input: ['text', 'image'],
+					input: ['text', 'image', 'pdf'],
 					output: ['text'],
 				},
 				toolCall: true,
@@ -2323,6 +2323,57 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 64000,
 				},
 			},
+			{
+				id: 'gemini-3.1-flash-image-preview',
+				ownedBy: 'google',
+				label: 'Gemini 3.1 Flash Image (Preview)',
+				modalities: {
+					input: ['text', 'image', 'pdf'],
+					output: ['text', 'image'],
+				},
+				toolCall: false,
+				reasoningText: true,
+				attachment: true,
+				temperature: true,
+				knowledge: '2025-01',
+				releaseDate: '2026-02-26',
+				lastUpdated: '2026-02-26',
+				openWeights: false,
+				cost: {
+					input: 0.25,
+					output: 60,
+				},
+				limit: {
+					context: 131072,
+					output: 32768,
+				},
+			},
+			{
+				id: 'gemini-3.1-flash-lite-preview',
+				ownedBy: 'google',
+				label: 'Gemini 3.1 Flash Lite Preview',
+				modalities: {
+					input: ['text', 'image', 'video', 'audio', 'pdf'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: true,
+				temperature: true,
+				knowledge: '2025-01',
+				releaseDate: '2026-03-03',
+				lastUpdated: '2026-03-03',
+				openWeights: false,
+				cost: {
+					input: 0.5,
+					output: 3,
+					cacheRead: 0.05,
+				},
+				limit: {
+					context: 1048576,
+					output: 65536,
+				},
+			},
 			{
 				id: 'gemini-3.1-pro-preview',
 				ownedBy: 'google',
@@ -3940,6 +3991,78 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 2000,
 				},
 			},
+			{
+				id: 'inception/mercury',
+				label: 'Mercury',
+				modalities: {
+					input: ['text'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: false,
+				attachment: false,
+				temperature: true,
+				releaseDate: '2025-06-26',
+				lastUpdated: '2025-06-26',
+				openWeights: false,
+				cost: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+				},
+				limit: {
+					context: 128000,
+					output: 32000,
+				},
+			},
+			{
+				id: 'inception/mercury-2',
+				label: 'Mercury 2',
+				modalities: {
+					input: ['text'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: false,
+				temperature: true,
+				releaseDate: '2026-03-04',
+				lastUpdated: '2026-03-04',
+				openWeights: false,
+				cost: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+				},
+				limit: {
+					context: 128000,
+					output: 50000,
+				},
+			},
+			{
+				id: 'inception/mercury-coder',
+				label: 'Mercury Coder',
+				modalities: {
+					input: ['text'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: false,
+				attachment: false,
+				temperature: true,
+				releaseDate: '2025-04-30',
+				lastUpdated: '2025-04-30',
+				openWeights: false,
+				cost: {
+					input: 0.25,
+					output: 0.75,
+					cacheRead: 0.025,
+				},
+				limit: {
+					context: 128000,
+					output: 32000,
+				},
+			},
 			{
 				id: 'kwaipilot/kat-coder-pro:free',
 				label: 'Kat Coder Pro (free)',
@@ -5743,6 +5866,77 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 50000,
 				},
 			},
+			{
+				id: 'openrouter/free',
+				label: 'Free Models Router',
+				modalities: {
+					input: ['text', 'image'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: true,
+				temperature: true,
+				releaseDate: '2026-02-01',
+				lastUpdated: '2026-02-01',
+				openWeights: false,
+				cost: {
+					input: 0,
+					output: 0,
+				},
+				limit: {
+					context: 200000,
+					output: 8000,
+				},
+			},
+			{
+				id: 'openrouter/healer-alpha',
+				label: 'Healer Alpha',
+				modalities: {
+					input: ['text', 'image', 'audio', 'pdf'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: true,
+				temperature: true,
+				knowledge: '2026-03-11',
+				releaseDate: '2026-03-11',
+				lastUpdated: '2026-03-11',
+				openWeights: false,
+				cost: {
+					input: 0,
+					output: 0,
+				},
+				limit: {
+					context: 262144,
+					output: 64000,
+				},
+			},
+			{
+				id: 'openrouter/hunter-alpha',
+				label: 'Hunter Alpha',
+				modalities: {
+					input: ['text', 'image', 'pdf'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: true,
+				temperature: true,
+				knowledge: '2026-03-11',
+				releaseDate: '2026-03-11',
+				lastUpdated: '2026-03-11',
+				openWeights: false,
+				cost: {
+					input: 0,
+					output: 0,
+				},
+				limit: {
+					context: 1048576,
+					output: 64000,
+				},
+			},
 			{
 				id: 'openrouter/sherlock-dash-alpha',
 				label: 'Sherlock Dash Alpha',
@@ -8199,6 +8393,31 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 262144,
 				},
 			},
+			{
+				id: 'mimo-v2-flash-free',
+				label: 'MiMo V2 Flash Free',
+				modalities: {
+					input: ['text'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: false,
+				temperature: true,
+				knowledge: '2024-12',
+				releaseDate: '2025-12-16',
+				lastUpdated: '2025-12-16',
+				openWeights: true,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+				},
+				limit: {
+					context: 262144,
+					output: 65536,
+				},
+			},
 			{
 				id: 'minimax-m2.1',
 				ownedBy: 'minimax',
@@ -8309,6 +8528,31 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					npm: '@ai-sdk/anthropic',
 				},
 			},
+			{
+				id: 'nemotron-3-super-free',
+				label: 'Nemotron 3 Super Free',
+				modalities: {
+					input: ['text'],
+					output: ['text'],
+				},
+				toolCall: true,
+				reasoningText: true,
+				attachment: false,
+				temperature: true,
+				knowledge: '2026-02',
+				releaseDate: '2026-03-11',
+				lastUpdated: '2026-03-11',
+				openWeights: true,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+				},
+				limit: {
+					context: 1000000,
+					output: 128000,
+				},
+			},
 			{
 				id: 'qwen3-coder',
 				label: 'Qwen3 Coder',
@@ -8593,7 +8837,7 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 				temperature: true,
 				releaseDate: '2026-02-11',
 				lastUpdated: '2026-02-11',
-				openWeights: false,
+				openWeights: true,
 				cost: {
 					input: 1,
 					output: 3.2,
@@ -8868,7 +9112,7 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 				temperature: true,
 				releaseDate: '2026-02-11',
 				lastUpdated: '2026-02-11',
-				openWeights: false,
+				openWeights: true,
 				cost: {
 					input: 0,
 					output: 0,
@@ -9661,7 +9905,7 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 0,
 				},
 				limit: {
-					context: 128000,
+					context: 264000,
 					output: 64000,
 				},
 			},
@@ -9686,7 +9930,7 @@ export const catalog: Partial<Record<ProviderId, ProviderCatalogEntry>> = {
 					output: 0,
 				},
 				limit: {
-					context: 272000,
+					context: 400000,
 					output: 128000,
 				},
 			},

package/src/providers/src/openrouter-client.ts

@@ -4,6 +4,7 @@ import { getModelNpmBinding } from './utils.ts';
 
 export type OpenRouterProviderConfig = {
 	apiKey?: string;
+	baseURL?: string;
 };
 
 function isAnthropicModel(model: string): boolean {

package/src/providers/src/utils.ts

@@ -129,6 +129,7 @@ const OWNER_TO_FAMILY: Record<ModelOwner, UnderlyingProviderKey> = {
 	openai: 'openai',
 	anthropic: 'anthropic',
 	google: 'google',
+	openrouter: 'openai-compatible',
 	xai: 'openai',
 	moonshot: 'moonshot',
 	zai: 'glm',

package/src/tunnel/qr.ts

@@ -1,4 +1,3 @@
-// @ts-expect-error No bundled types for qrcode-terminal in all workspace builds
 import qrcode from 'qrcode-terminal';
 
 export function generateQRCode(data: string): Promise<string> {

package/src/types/src/config.ts

@@ -9,6 +9,13 @@ export type Scope = 'global' | 'local';
  * Default settings for the CLI
  */
 export type ToolApprovalMode = 'auto' | 'dangerous' | 'all';
+export type ReasoningLevel =
+	| 'minimal'
+	| 'low'
+	| 'medium'
+	| 'high'
+	| 'max'
+	| 'xhigh';
 
 export type DefaultConfig = {
 	agent: string;
@@ -17,7 +24,9 @@ export type DefaultConfig = {
 	toolApproval?: ToolApprovalMode;
 	guidedMode?: boolean;
 	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 	theme?: string;
+	fullWidthContent?: boolean;
 };
 
 export type ProviderSettings = Record<

package/src/types/src/index.ts

@@ -19,4 +19,5 @@ export type {
 	ProviderSettings,
 	OttoConfig,
 	ToolApprovalMode,
+	ReasoningLevel,
 } from './config';

package/src/types/src/provider.ts

@@ -33,6 +33,7 @@ export type ModelOwner =
 	| 'openai'
 	| 'anthropic'
 	| 'google'
+	| 'openrouter'
 	| 'xai'
 	| 'moonshot'
 	| 'zai'