@ottocode/server 0.1.265 → 0.1.266

package/src/routes/config/models.ts

@@ -1,282 +1,9 @@
 import type { Hono } from 'hono';
-import {
-	DEFAULT_REMOTE_MODEL_CATALOG_URL,
-	catalog,
-	discoverOllamaModels,
-	loadConfig,
-	getProviderDefinition,
-	providerAllowsAnyModel,
-	getAuth,
-	logger,
-	readEnvKey,
-	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';
-import {
-	isProviderAuthorizedHybrid,
-	getAuthorizedProviders,
-	getDefault,
-	getAuthTypeForProvider,
-} from './utils.ts';
 import { openApiRoute } from '../../openapi/route.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;
-const USE_BUILTIN_MODEL_CATALOG = process.env.CI === 'true';
-
-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
-	);
-}
-
-function getModelCatalogProviders(
-	cachedCatalog: Awaited<ReturnType<typeof readCachedModelCatalog>>,
-): Record<string, { models?: ModelInfo[]; label?: string }> {
-	return cachedCatalog?.providers ?? (USE_BUILTIN_MODEL_CATALOG ? catalog : {});
-}
-
-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,
-		});
-		if (!discoveredModels) return;
-		await mergeCachedModelCatalog({
-			[provider]: {
-				id: provider,
-				label: providerDefinition.label,
-				models: discoveredModels,
-			},
-		});
-	} 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,
-	models: T[],
-	copilotAllowedModels: Set<string> | null,
-): T[] {
-	if (provider !== 'copilot') return models;
-	if (!copilotAllowedModels || copilotAllowedModels.size === 0) return models;
-	return models.filter((m) => copilotAllowedModels.has(m.id));
-}
-
-async function getCopilotAuthTokens(projectRoot: string): Promise<string[]> {
-	const tokens: string[] = [];
-
-	const envToken = readEnvKey('copilot');
-	if (envToken) tokens.push(envToken);
-
-	const auth = await getAuth('copilot', projectRoot);
-	if (auth?.type === 'oauth' && auth.refresh) {
-		if (auth.refresh !== envToken) {
-			tokens.push(auth.refresh);
-		}
-	}
-
-	return tokens;
-}
-
-async function getAuthorizedCopilotModels(
-	projectRoot: string,
-): Promise<Set<string> | null> {
-	const tokens = await getCopilotAuthTokens(projectRoot);
-	if (!tokens.length) return null;
-
-	const merged = new Set<string>();
-	let successful = false;
-
-	for (const token of tokens) {
-		try {
-			const response = await fetch(COPILOT_MODELS_URL, {
-				headers: {
-					Authorization: `Bearer ${token}`,
-					'Openai-Intent': 'conversation-edits',
-					'User-Agent': 'ottocode',
-				},
-			});
-			if (!response.ok) continue;
-
-			successful = true;
-			const payload = (await response.json()) as {
-				data?: Array<{ id?: string }>;
-			};
-
-			for (const id of (payload.data ?? []).map((item) => item.id)) {
-				if (id) merged.add(id);
-			}
-		} catch {}
-	}
-
-	return successful ? merged : null;
-}
-
-async function discoverProviderModels(args: {
-	provider: ProviderId;
-	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>;
-	projectRoot: string;
-}): Promise<ModelInfo[] | undefined> {
-	const { provider, providerDefinition, projectRoot } = args;
-	if (
-		providerDefinition.source !== 'custom' ||
-		providerDefinition.compatibility !== 'ollama' ||
-		!providerDefinition.baseURL
-	) {
-		return undefined;
-	}
-
-	try {
-		const auth = await getAuth(provider, projectRoot);
-		const apiKey =
-			auth?.type === 'api'
-				? auth.key
-				: (readEnvKey(provider) ?? providerDefinition.apiKey);
-		const discovered = await discoverOllamaModels({
-			baseURL: providerDefinition.baseURL,
-			apiKey,
-			includeDetails: true,
-		});
-		return discovered.models;
-	} catch (error) {
-		logger.warn('Failed to discover Ollama models', {
-			provider,
-			error: error instanceof Error ? error.message : String(error),
-		});
-		return undefined;
-	}
-}
-
-function shouldLazyLoadProviderModels(
-	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>,
-): boolean {
-	return (
-		providerDefinition.source === 'custom' &&
-		providerDefinition.compatibility === 'ollama'
-	);
-}
-
-function getProviderModelsForUi(args: {
-	catalogModels: ModelInfo[] | undefined;
-	provider: ProviderId;
-	authType: 'api' | 'oauth' | 'wallet' | undefined;
-}): ModelInfo[] {
-	const catalogModels = args.catalogModels ?? [];
-	return filterModelsForAuthType(args.provider, catalogModels, args.authType);
-}
-
-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)`;
-}
+import {
+	handleGetAllModels,
+	handleGetProviderModels,
+} from './models-service.ts';
 
 export function registerModelsRoutes(app: Hono) {
 	openApiRoute(
@@ -371,90 +98,7 @@ export function registerModelsRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const embeddedConfig = (
-					c as unknown as {
-						get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
-					}
-				).get('embeddedConfig');
-				const provider = c.req.param('provider') as ProviderId;
-
-				const projectRoot = c.req.query('project') || process.cwd();
-				const cfg = await loadConfig(projectRoot);
-				const cachedCatalog = await readCachedModelCatalog();
-				const modelCatalogProviders = getModelCatalogProviders(cachedCatalog);
-				const providerCatalog = modelCatalogProviders[provider];
-
-				const authorized = await isProviderAuthorizedHybrid(
-					embeddedConfig,
-					cfg,
-					provider,
-				);
-
-				if (!authorized) {
-					logger.warn('Provider not authorized', { provider });
-					return c.json({ error: 'Provider not authorized' }, 403);
-				}
-
-				const providerDefinition = getProviderDefinition(cfg, provider);
-				if (!providerDefinition && !providerCatalog) {
-					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,
-				);
-				if (
-					providerDefinition &&
-					shouldLazyLoadProviderModels(providerDefinition)
-				) {
-					void refreshProviderModelsInBackground({
-						provider,
-						providerDefinition,
-						projectRoot,
-					});
-				}
-				const filteredModels = getProviderModelsForUi({
-					catalogModels: providerCatalog?.models,
-					provider,
-					authType,
-				});
-				const copilotAllowedModels =
-					provider === 'copilot'
-						? await getAuthorizedCopilotModels(projectRoot)
-						: null;
-
-				const availableModels = filterCopilotAvailability(
-					provider,
-					filteredModels,
-					copilotAllowedModels,
-				);
-
-				return c.json({
-					models: availableModels.map(toUiModel),
-					default: getDefault(
-						embeddedConfig?.model,
-						embeddedConfig?.defaults?.model,
-						cfg.defaults.model,
-					),
-					allowAnyModel: providerDefinition
-						? providerAllowsAnyModel(cfg, provider)
-						: undefined,
-					label: providerDefinition
-						? getUiProviderLabel(providerDefinition)
-						: (providerCatalog?.label ?? provider),
-				});
-			} catch (error) {
-				logger.error('Failed to get provider models', error);
-				const errorResponse = serializeError(error);
-				return c.json(errorResponse, errorResponse.error.status || 500);
-			}
-		},
+		handleGetProviderModels,
 	);
 
 	openApiRoute(
@@ -529,70 +173,6 @@ export function registerModelsRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const embeddedConfig = (
-					c as unknown as {
-						get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
-					}
-				).get('embeddedConfig');
-
-				const projectRoot = c.req.query('project') || process.cwd();
-				const cfg = await loadConfig(projectRoot);
-
-				const authorizedProviders = await getAuthorizedProviders(
-					embeddedConfig,
-					cfg,
-				);
-
-				const cachedCatalog = await readCachedModelCatalog();
-				const modelCatalogProviders = getModelCatalogProviders(cachedCatalog);
-				void refreshRemoteCatalogInBackground();
-
-				const modelsMap: Record<string, UiProviderModels> = {};
-
-				for (const provider of authorizedProviders) {
-					const providerCatalog = modelCatalogProviders[provider];
-					const providerDefinition = getProviderDefinition(cfg, provider);
-					if (providerCatalog) {
-						const dynamicModels =
-							providerDefinition &&
-							shouldLazyLoadProviderModels(providerDefinition);
-						const authType = await getAuthTypeForProvider(
-							embeddedConfig,
-							provider,
-							projectRoot,
-						);
-						if (dynamicModels && providerDefinition) {
-							void refreshProviderModelsInBackground({
-								provider,
-								providerDefinition,
-								projectRoot,
-							});
-						}
-						const filteredModels = getProviderModelsForUi({
-							catalogModels: providerCatalog?.models,
-							provider,
-							authType,
-						});
-						modelsMap[provider] = {
-							label: providerDefinition
-								? getUiProviderLabel(providerDefinition)
-								: (providerCatalog.label ?? provider),
-							authType,
-							allowAnyModel: providerDefinition?.allowAnyModel,
-							dynamicModels,
-							models: filteredModels.map(toUiModel),
-						};
-					}
-				}
-
-				return c.json(modelsMap);
-			} catch (error) {
-				logger.error('Failed to get all models', error);
-				const errorResponse = serializeError(error);
-				return c.json(errorResponse, errorResponse.error.status || 500);
-			}
-		},
+		handleGetAllModels,
 	);
 }

package/src/routes/config/providers-service.ts

@@ -0,0 +1,237 @@
+import {
+	discoverOllamaModels,
+	isBuiltInProviderId,
+	loadConfig,
+	logger,
+	removeProviderSettings,
+	writeProviderSettings,
+	type ModelInfo,
+	type ProviderCompatibility,
+	type ProviderId,
+	type ProviderPromptFamily,
+	type ProviderSettingsEntry,
+} from '@ottocode/sdk';
+import type { Context } from 'hono';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import {
+	getAuthorizedProviders,
+	getDefault,
+	getProviderDetails,
+} from './utils.ts';
+
+type ProviderMutationBody = {
+	enabled?: boolean;
+	custom?: boolean;
+	label?: string;
+	compatibility?: ProviderCompatibility;
+	family?: ProviderPromptFamily;
+	baseURL?: string | null;
+	apiKey?: string | null;
+	apiKeyEnv?: string | null;
+	models?: string[];
+	allowAnyModel?: boolean;
+};
+
+type ProviderDiscoveryBody = {
+	compatibility?: ProviderCompatibility;
+	baseURL?: string;
+	apiKey?: string;
+};
+
+function getEmbeddedConfig(c: Context): EmbeddedAppConfig | undefined {
+	return (
+		c as unknown as {
+			get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
+		}
+	).get('embeddedConfig');
+}
+
+function isEmbeddedConfigActive(
+	config: EmbeddedAppConfig | undefined,
+): boolean {
+	return Boolean(config && Object.keys(config).length > 0);
+}
+
+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 async function handleGetProviders(c: Context) {
+	try {
+		const embeddedConfig = getEmbeddedConfig(c);
+
+		if (isEmbeddedConfigActive(embeddedConfig)) {
+			const providers = embeddedConfig?.auth
+				? (Object.keys(embeddedConfig.auth) as ProviderId[])
+				: embeddedConfig?.provider
+					? [embeddedConfig.provider]
+					: [];
+
+			return c.json({
+				providers,
+				details: providers.map((provider) => ({
+					id: provider,
+					label: provider,
+					source: 'built-in',
+					enabled: true,
+					authorized: true,
+					custom: false,
+					hasApiKey: false,
+					allowAnyModel: false,
+					modelCount: 0,
+				})),
+				default: getDefault(
+					embeddedConfig?.provider,
+					embeddedConfig?.defaults?.provider,
+					undefined,
+				),
+			});
+		}
+
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const authorizedProviders = await getAuthorizedProviders(undefined, cfg);
+		const details = await getProviderDetails(undefined, cfg);
+
+		return c.json({
+			providers: authorizedProviders,
+			details,
+			default: cfg.defaults.provider,
+		});
+	} catch (error) {
+		logger.error('Failed to get providers', error);
+		const errorResponse = serializeError(error);
+		return c.json(errorResponse, errorResponse.error.status || 500);
+	}
+}
+
+export async function handleDiscoverProviderModels(c: Context) {
+	try {
+		if (isEmbeddedConfigActive(getEmbeddedConfig(c))) {
+			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);
+	}
+}
+
+function buildProviderUpdates(
+	provider: string,
+	body: ProviderMutationBody,
+): ProviderSettingsEntry {
+	const updates: ProviderSettingsEntry = {
+		enabled: body.enabled ?? true,
+		custom: isBuiltInProviderId(provider) ? body.custom : (body.custom ?? true),
+	};
+
+	if (body.label !== undefined) updates.label = body.label.trim() || undefined;
+	if (body.compatibility !== undefined)
+		updates.compatibility = body.compatibility;
+	if (body.family !== undefined) updates.family = body.family;
+	if (body.baseURL !== undefined) {
+		updates.baseURL = body.baseURL?.trim() || undefined;
+	}
+	if (body.apiKey !== undefined) {
+		updates.apiKey = body.apiKey?.trim() || undefined;
+	}
+	if (body.apiKeyEnv !== undefined) {
+		updates.apiKeyEnv = body.apiKeyEnv?.trim() || undefined;
+	}
+	if (body.models !== undefined) {
+		updates.models = body.models.map((model) => model.trim()).filter(Boolean);
+	}
+	if (body.allowAnyModel !== undefined) {
+		updates.allowAnyModel = body.allowAnyModel;
+	}
+
+	return updates;
+}
+
+export async function handleUpdateProviderSettings(c: Context) {
+	try {
+		if (isEmbeddedConfigActive(getEmbeddedConfig(c))) {
+			return c.json({ error: 'Embedded config cannot be modified' }, 400);
+		}
+
+		const projectRoot = c.req.query('project') || process.cwd();
+		const provider = c.req.param('provider').trim();
+		const body = await c.req.json<ProviderMutationBody>();
+		if (!provider) return c.json({ error: 'Provider is required' }, 400);
+
+		const updates = buildProviderUpdates(provider, body);
+		if (!isBuiltInProviderId(provider) && !updates.compatibility) {
+			return c.json({ error: 'Custom providers require compatibility' }, 400);
+		}
+
+		await writeProviderSettings('global', provider, updates, projectRoot);
+		const cfg = await loadConfig(projectRoot);
+		const details = await getProviderDetails(undefined, cfg);
+		return c.json({
+			success: true,
+			provider,
+			details,
+		});
+	} catch (error) {
+		logger.error('Failed to update provider settings', error);
+		const errorResponse = serializeError(error);
+		return c.json(errorResponse, errorResponse.error.status || 500);
+	}
+}
+
+export async function handleDeleteProviderSettings(c: Context) {
+	try {
+		if (isEmbeddedConfigActive(getEmbeddedConfig(c))) {
+			return c.json({ error: 'Embedded config cannot be modified' }, 400);
+		}
+
+		const projectRoot = c.req.query('project') || process.cwd();
+		const provider = c.req.param('provider').trim();
+		if (!provider) return c.json({ error: 'Provider is required' }, 400);
+
+		await removeProviderSettings('global', provider, projectRoot);
+		const cfg = await loadConfig(projectRoot);
+		const details = await getProviderDetails(undefined, cfg);
+		return c.json({ success: true, provider, details });
+	} catch (error) {
+		logger.error('Failed to remove provider settings', error);
+		const errorResponse = serializeError(error);
+		return c.json(errorResponse, errorResponse.error.status || 500);
+	}
+}