@ottocode/server 0.1.247 → 0.1.249

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.247",
+	"version": "0.1.249",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/database": "0.1.247",
-		"@ottocode/sdk": "0.1.247",
+		"@ottocode/database": "0.1.249",
+		"@ottocode/sdk": "0.1.249",
 		"ai-sdk-ollama": "^3.8.3",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",

package/src/routes/auth.ts

@@ -25,6 +25,7 @@ import {
 import { execFileSync, spawnSync } from 'node:child_process';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
+import { getProviderDetails } from './config/utils.ts';
 
 const oauthVerifiers = new Map<
 	string,
@@ -235,6 +236,7 @@ export function registerAuthRoutes(app: Hono) {
 					supportsOAuth: boolean;
 					supportsToken?: boolean;
 					supportsGhImport?: boolean;
+					custom?: boolean;
 					modelCount: number;
 					costRange?: { min: number; max: number };
 				}
@@ -267,6 +269,19 @@ export function registerAuthRoutes(app: Hono) {
 				};
 			}
 
+			const providerDetails = await getProviderDetails(undefined, cfg);
+			for (const detail of providerDetails) {
+				if (!detail.custom || providers[detail.id]) continue;
+				providers[detail.id] = {
+					configured: detail.authorized,
+					type: detail.authType,
+					label: detail.label,
+					supportsOAuth: false,
+					custom: true,
+					modelCount: detail.modelCount,
+				};
+			}
+
 			return c.json({
 				onboardingComplete,
 				ottorouter: ottorouterWallet

package/src/routes/config/models.ts

@@ -1,5 +1,6 @@
 import type { Hono } from 'hono';
 import {
+	DEFAULT_REMOTE_MODEL_CATALOG_URL,
 	discoverOllamaModels,
 	loadConfig,
 	catalog,
@@ -12,6 +13,9 @@ import {
 	type ModelInfo,
 	type ProviderId,
 	filterModelsForAuthType,
+	mergeCachedModelCatalog,
+	normalizeModelCatalogPayload,
+	readCachedModelCatalog,
 } from '@ottocode/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
 import { serializeError } from '../../runtime/errors/api-error.ts';
@@ -23,6 +27,129 @@ import {
 } from './utils.ts';
 
 const COPILOT_MODELS_URL = 'https://api.githubcopilot.com/models';
+const REMOTE_CATALOG_REFRESH_TTL_MS = 5 * 60 * 1000;
+const PROVIDER_MODEL_REFRESH_TTL_MS = 60 * 1000;
+
+type UiModel = {
+	id: string;
+	label: string;
+	toolCall?: boolean;
+	reasoningText?: boolean;
+	vision?: boolean;
+	attachment?: boolean;
+	free?: boolean;
+	contextWindow?: number;
+	maxOutputTokens?: number;
+};
+
+type UiProviderModels = {
+	label: string;
+	authType?: 'api' | 'oauth' | 'wallet';
+	allowAnyModel?: boolean;
+	dynamicModels?: boolean;
+	models: UiModel[];
+};
+
+const remoteCatalogRefreshes = new Set<string>();
+const providerModelRefreshes = new Set<string>();
+const providerModelRefreshAt = new Map<string, number>();
+let remoteCatalogRefreshAt = 0;
+
+function toUiModel(model: ModelInfo): UiModel {
+	return {
+		id: model.id,
+		label: model.label || model.id,
+		toolCall: model.toolCall,
+		reasoningText: model.reasoningText,
+		vision: model.modalities?.input?.includes('image') ?? false,
+		attachment: model.attachment ?? false,
+		free: model.cost?.input === 0 && model.cost?.output === 0,
+		contextWindow: model.limit?.context,
+		maxOutputTokens: model.limit?.output,
+	};
+}
+
+function getRemoteCatalogUrl(): string {
+	return (
+		process.env.OTTO_MODEL_CATALOG_URL?.trim() ||
+		DEFAULT_REMOTE_MODEL_CATALOG_URL
+	);
+}
+
+async function refreshRemoteCatalogInBackground(): Promise<void> {
+	const url = getRemoteCatalogUrl();
+	const now = Date.now();
+	if (now - remoteCatalogRefreshAt < REMOTE_CATALOG_REFRESH_TTL_MS) return;
+	const cachedCatalog = await readCachedModelCatalog();
+	const cachedAt = cachedCatalog ? Date.parse(cachedCatalog.updatedAt) : 0;
+	if (Number.isFinite(cachedAt)) {
+		remoteCatalogRefreshAt = Math.max(remoteCatalogRefreshAt, cachedAt);
+		if (now - remoteCatalogRefreshAt < REMOTE_CATALOG_REFRESH_TTL_MS) return;
+	}
+	if (remoteCatalogRefreshes.has(url)) return;
+	remoteCatalogRefreshes.add(url);
+	remoteCatalogRefreshAt = now;
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			throw new Error(`${response.status} ${response.statusText}`);
+		}
+		const providers = normalizeModelCatalogPayload(await response.json());
+		if (Object.keys(providers).length > 0) {
+			await mergeCachedModelCatalog(providers);
+			logger.debug('Refreshed remote model catalog', {
+				url,
+				providers: Object.keys(providers).length,
+			});
+		}
+	} catch (error) {
+		logger.debug('Failed to refresh remote model catalog', {
+			url,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	} finally {
+		remoteCatalogRefreshes.delete(url);
+	}
+}
+
+async function refreshProviderModelsInBackground(args: {
+	provider: ProviderId;
+	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>;
+	projectRoot: string;
+}): Promise<void> {
+	const refreshKey = `${args.projectRoot}:${args.provider}`;
+	const now = Date.now();
+	const lastRefresh = providerModelRefreshAt.get(refreshKey) ?? 0;
+	if (now - lastRefresh < PROVIDER_MODEL_REFRESH_TTL_MS) return;
+	if (providerModelRefreshes.has(refreshKey)) return;
+	providerModelRefreshes.add(refreshKey);
+	providerModelRefreshAt.set(refreshKey, now);
+	try {
+		const { provider, providerDefinition, projectRoot } = args;
+		const discoveredModels = await discoverProviderModels({
+			provider,
+			providerDefinition,
+			projectRoot,
+		});
+		const models =
+			discoveredModels ??
+			getConfiguredProviderModels(await loadConfig(projectRoot), provider);
+		await mergeCachedModelCatalog({
+			[provider]: {
+				id: provider,
+				label: providerDefinition.label,
+				models,
+			},
+		});
+	} catch (error) {
+		logger.debug('Failed to refresh provider model cache', {
+			provider: args.provider,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	} finally {
+		providerModelRefreshes.delete(refreshKey);
+	}
+}
 
 function filterCopilotAvailability<T extends { id: string }>(
 	provider: ProviderId,
@@ -91,6 +218,7 @@ async function discoverProviderModels(args: {
 }): Promise<ModelInfo[] | undefined> {
 	const { provider, providerDefinition, projectRoot } = args;
 	if (
+		providerDefinition.source !== 'custom' ||
 		providerDefinition.compatibility !== 'ollama' ||
 		!providerDefinition.baseURL
 	) {
@@ -106,7 +234,7 @@ async function discoverProviderModels(args: {
 		const discovered = await discoverOllamaModels({
 			baseURL: providerDefinition.baseURL,
 			apiKey,
-			includeDetails: false,
+			includeDetails: true,
 		});
 		return discovered.models;
 	} catch (error) {
@@ -122,11 +250,31 @@ function shouldLazyLoadProviderModels(
 	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>,
 ): boolean {
 	return (
-		providerDefinition.compatibility === 'ollama' ||
-		providerDefinition.source === 'custom'
+		providerDefinition.source === 'custom' &&
+		providerDefinition.compatibility === 'ollama'
 	);
 }
 
+function getCachedOrConfiguredModels(args: {
+	models: ModelInfo[] | undefined;
+	cfg: Awaited<ReturnType<typeof loadConfig>>;
+	provider: ProviderId;
+}): ModelInfo[] {
+	const cachedModels = args.models;
+	return cachedModels && cachedModels.length > 0
+		? cachedModels
+		: getConfiguredProviderModels(args.cfg, args.provider);
+}
+
+function getUiProviderLabel(
+	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>,
+): string {
+	if (providerDefinition.source !== 'custom') return providerDefinition.label;
+	return providerDefinition.label.includes('(custom)')
+		? providerDefinition.label
+		: `${providerDefinition.label} (custom)`;
+}
+
 export function registerModelsRoutes(app: Hono) {
 	app.get('/v1/config/providers/:provider/models', async (c) => {
 		try {
@@ -151,33 +299,38 @@ export function registerModelsRoutes(app: Hono) {
 				return c.json({ error: 'Provider not authorized' }, 403);
 			}
 
-			const providerCatalog = catalog[provider as keyof typeof catalog];
+			const cachedCatalog = await readCachedModelCatalog();
+			const providerCatalog =
+				cachedCatalog?.providers[provider] ??
+				catalog[provider as keyof typeof catalog];
 			const providerDefinition = getProviderDefinition(cfg, provider);
 			if (!providerDefinition) {
 				logger.warn('Provider not found in catalog', { provider });
 				return c.json({ error: 'Provider not found' }, 404);
 			}
+			void refreshRemoteCatalogInBackground();
 
 			const authType = await getAuthTypeForProvider(
 				embeddedConfig,
 				provider,
 				projectRoot,
 			);
-			const discoveredModels = await discoverProviderModels({
-				provider,
-				providerDefinition,
-				projectRoot,
-			});
-			const filteredModels =
-				providerDefinition.compatibility === 'ollama'
-					? (discoveredModels ?? [])
-					: providerCatalog
-						? filterModelsForAuthType(
-								provider,
-								providerCatalog.models,
-								authType,
-							)
-						: getConfiguredProviderModels(cfg, provider);
+			if (shouldLazyLoadProviderModels(providerDefinition)) {
+				void refreshProviderModelsInBackground({
+					provider,
+					providerDefinition,
+					projectRoot,
+				});
+			}
+			const filteredModels = shouldLazyLoadProviderModels(providerDefinition)
+				? getCachedOrConfiguredModels({
+						models: providerCatalog?.models,
+						cfg,
+						provider,
+					})
+				: providerCatalog
+					? filterModelsForAuthType(provider, providerCatalog.models, authType)
+					: getConfiguredProviderModels(cfg, provider);
 			const copilotAllowedModels =
 				provider === 'copilot'
 					? await getAuthorizedCopilotModels(projectRoot)
@@ -190,22 +343,14 @@ export function registerModelsRoutes(app: Hono) {
 			);
 
 			return c.json({
-				models: availableModels.map((m) => ({
-					id: m.id,
-					label: m.label || m.id,
-					toolCall: m.toolCall,
-					reasoningText: m.reasoningText,
-					vision: m.modalities?.input?.includes('image') ?? false,
-					attachment: m.attachment ?? false,
-					free: m.cost?.input === 0 && m.cost?.output === 0,
-				})),
+				models: availableModels.map(toUiModel),
 				default: getDefault(
 					embeddedConfig?.model,
 					embeddedConfig?.defaults?.model,
 					cfg.defaults.model,
 				),
 				allowAnyModel: providerAllowsAnyModel(cfg, provider),
-				label: providerDefinition.label,
+				label: getUiProviderLabel(providerDefinition),
 			});
 		} catch (error) {
 			logger.error('Failed to get provider models', error);
@@ -230,22 +375,15 @@ export function registerModelsRoutes(app: Hono) {
 				cfg,
 			);
 
-			const modelsMap: Record<
-				string,
-				{
-					label: string;
-					authType?: 'api' | 'oauth' | 'wallet';
-					models: Array<{
-						id: string;
-						label: string;
-						toolCall?: boolean;
-						reasoningText?: boolean;
-					}>;
-				}
-			> = {};
+			const cachedCatalog = await readCachedModelCatalog();
+			void refreshRemoteCatalogInBackground();
+
+			const modelsMap: Record<string, UiProviderModels> = {};
 
 			for (const provider of authorizedProviders) {
-				const providerCatalog = catalog[provider as keyof typeof catalog];
+				const providerCatalog =
+					cachedCatalog?.providers[provider] ??
+					catalog[provider as keyof typeof catalog];
 				const providerDefinition = getProviderDefinition(cfg, provider);
 				if (providerDefinition) {
 					const dynamicModels =
@@ -255,8 +393,19 @@ export function registerModelsRoutes(app: Hono) {
 						provider,
 						projectRoot,
 					);
+					if (dynamicModels) {
+						void refreshProviderModelsInBackground({
+							provider,
+							providerDefinition,
+							projectRoot,
+						});
+					}
 					const filteredModels = dynamicModels
-						? getConfiguredProviderModels(cfg, provider)
+						? getCachedOrConfiguredModels({
+								models: providerCatalog?.models,
+								cfg,
+								provider,
+							})
 						: providerCatalog
 							? filterModelsForAuthType(
 									provider,
@@ -265,19 +414,11 @@ export function registerModelsRoutes(app: Hono) {
 								)
 							: getConfiguredProviderModels(cfg, provider);
 					modelsMap[provider] = {
-						label: providerDefinition.label,
+						label: getUiProviderLabel(providerDefinition),
 						authType,
 						allowAnyModel: providerDefinition.allowAnyModel,
 						dynamicModels,
-						models: filteredModels.map((m) => ({
-							id: m.id,
-							label: m.label || m.id,
-							toolCall: m.toolCall,
-							reasoningText: m.reasoningText,
-							vision: m.modalities?.input?.includes('image') ?? false,
-							attachment: m.attachment ?? false,
-							free: m.cost?.input === 0 && m.cost?.output === 0,
-						})),
+						models: filteredModels.map(toUiModel),
 					};
 				}
 			}

package/src/routes/config/providers.ts

@@ -3,7 +3,9 @@ import {
 	loadConfig,
 	removeProviderSettings,
 	writeProviderSettings,
+	discoverOllamaModels,
 	isBuiltInProviderId,
+	type ModelInfo,
 	type ProviderCompatibility,
 	type ProviderPromptFamily,
 	type ProviderId,
@@ -32,6 +34,25 @@ type ProviderMutationBody = {
 	scope?: 'global' | 'local';
 };
 
+type ProviderDiscoveryBody = {
+	compatibility?: ProviderCompatibility;
+	baseURL?: string;
+	apiKey?: string;
+};
+
+function toDiscoveredModel(model: ModelInfo) {
+	return {
+		id: model.id,
+		label: model.label || model.id,
+		toolCall: model.toolCall,
+		reasoningText: model.reasoningText,
+		vision: model.modalities?.input?.includes('image') ?? false,
+		attachment: model.attachment ?? false,
+		contextWindow: model.limit?.context,
+		maxOutputTokens: model.limit?.output,
+	};
+}
+
 export function registerProvidersRoute(app: Hono) {
 	app.get('/v1/config/providers', async (c) => {
 		try {
@@ -87,6 +108,49 @@ export function registerProvidersRoute(app: Hono) {
 		}
 	});
 
+	app.post('/v1/config/providers/discover-models', async (c) => {
+		try {
+			const embeddedConfig = (
+				c as unknown as {
+					get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
+				}
+			).get('embeddedConfig');
+			if (embeddedConfig && Object.keys(embeddedConfig).length > 0) {
+				return c.json({ error: 'Embedded config cannot be modified' }, 400);
+			}
+
+			const body = await c.req.json<ProviderDiscoveryBody>();
+			const compatibility = body.compatibility || 'openai-compatible';
+			const baseURL = body.baseURL?.trim();
+			const apiKey = body.apiKey?.trim() || undefined;
+			if (!baseURL) return c.json({ error: 'Base URL is required' }, 400);
+
+			if (compatibility !== 'ollama') {
+				return c.json({
+					models: [],
+					unsupported: true,
+					message:
+						'Model discovery is currently available for Ollama providers.',
+				});
+			}
+
+			const discovered = await discoverOllamaModels({
+				baseURL,
+				apiKey,
+				includeDetails: true,
+			});
+
+			return c.json({
+				baseURL: discovered.baseURL,
+				models: discovered.models.map(toDiscoveredModel),
+			});
+		} catch (error) {
+			logger.error('Failed to discover provider models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
 	app.put('/v1/config/providers/:provider', async (c) => {
 		try {
 			const embeddedConfig = (