@ottocode/server 0.1.245 → 0.1.246

package/src/routes/config/providers.ts

@@ -1,10 +1,36 @@
 import type { Hono } from 'hono';
-import { loadConfig } from '@ottocode/sdk';
-import type { ProviderId } from '@ottocode/sdk';
+import {
+	loadConfig,
+	removeProviderSettings,
+	writeProviderSettings,
+	isBuiltInProviderId,
+	type ProviderCompatibility,
+	type ProviderPromptFamily,
+	type ProviderId,
+	type ProviderSettingsEntry,
+} from '@ottocode/sdk';
 import type { EmbeddedAppConfig } from '../../index.ts';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../../runtime/errors/api-error.ts';
-import { getAuthorizedProviders, getDefault } from './utils.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;
+	scope?: 'global' | 'local';
+};
 
 export function registerProvidersRoute(app: Hono) {
 	app.get('/v1/config/providers', async (c) => {
@@ -15,7 +41,7 @@ export function registerProvidersRoute(app: Hono) {
 				}
 			).get('embeddedConfig');
 
-			if (embeddedConfig) {
+			if (embeddedConfig && Object.keys(embeddedConfig).length > 0) {
 				const providers = embeddedConfig.auth
 					? (Object.keys(embeddedConfig.auth) as ProviderId[])
 					: embeddedConfig.provider
@@ -24,6 +50,17 @@ export function registerProvidersRoute(app: Hono) {
 
 				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,
@@ -36,9 +73,11 @@ export function registerProvidersRoute(app: Hono) {
 			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) {
@@ -47,4 +86,98 @@ export function registerProvidersRoute(app: Hono) {
 			return c.json(errorResponse, errorResponse.error.status || 500);
 		}
 	});
+
+	app.put('/v1/config/providers/:provider', 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 projectRoot = c.req.query('project') || process.cwd();
+			const provider = c.req.param('provider').trim();
+			const body = await c.req.json<ProviderMutationBody>();
+			const scope = body.scope || 'local';
+			if (!provider) return c.json({ error: 'Provider is required' }, 400);
+
+			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;
+			}
+
+			if (!isBuiltInProviderId(provider) && !updates.compatibility) {
+				return c.json({ error: 'Custom providers require compatibility' }, 400);
+			}
+
+			await writeProviderSettings(scope, 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);
+		}
+	});
+
+	app.delete('/v1/config/providers/:provider', 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 projectRoot = c.req.query('project') || process.cwd();
+			const provider = c.req.param('provider').trim();
+			const scope =
+				(c.req.query('scope') as 'global' | 'local' | undefined) || 'local';
+			if (!provider) return c.json({ error: 'Provider is required' }, 400);
+
+			await removeProviderSettings(scope, 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);
+		}
+	});
 }

package/src/routes/config/utils.ts

@@ -1,5 +1,9 @@
 import {
-	catalog,
+	getConfiguredProviderApiKey,
+	getConfiguredProviderIds,
+	getConfiguredProviderModels,
+	getProviderDefinition,
+	getProviderSettings,
 	type ProviderId,
 	isProviderAuthorized,
 	getGlobalAgentsDir,
@@ -11,6 +15,23 @@ import type { EmbeddedAppConfig } from '../../index.ts';
 import type { OttoConfig } from '@ottocode/sdk';
 import { loadAgentsConfig } from '../../runtime/agent/registry.ts';
 
+export type ProviderDetail = {
+	id: string;
+	label: string;
+	source: 'built-in' | 'custom';
+	enabled: boolean;
+	authorized: boolean;
+	custom: boolean;
+	compatibility?: string;
+	family?: string;
+	baseURL?: string;
+	apiKeyEnv?: string;
+	hasApiKey: boolean;
+	allowAnyModel: boolean;
+	modelCount: number;
+	authType?: 'api' | 'oauth' | 'wallet';
+};
+
 export async function isProviderAuthorizedHybrid(
 	embeddedConfig: EmbeddedAppConfig | undefined,
 	fileConfig: OttoConfig,
@@ -31,7 +52,7 @@ export async function getAuthorizedProviders(
 	embeddedConfig: EmbeddedAppConfig | undefined,
 	fileConfig: OttoConfig,
 ): Promise<ProviderId[]> {
-	const allProviders = Object.keys(catalog) as ProviderId[];
+	const allProviders = getConfiguredProviderIds(fileConfig);
 	const authorizedProviders: ProviderId[] = [];
 
 	for (const provider of allProviders) {
@@ -48,6 +69,55 @@ export async function getAuthorizedProviders(
 	return authorizedProviders;
 }
 
+export async function getProviderDetails(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: OttoConfig,
+): Promise<ProviderDetail[]> {
+	const providers = Array.from(
+		new Set<ProviderId>([
+			...getConfiguredProviderIds(fileConfig, { includeDisabled: true }),
+			...(embeddedConfig?.provider ? [embeddedConfig.provider] : []),
+			...((embeddedConfig?.auth
+				? (Object.keys(embeddedConfig.auth) as ProviderId[])
+				: []) as ProviderId[]),
+		]),
+	);
+	const details = await Promise.all(
+		providers.map(async (provider) => {
+			const definition = getProviderDefinition(fileConfig, provider);
+			if (!definition) return null;
+			const settings = getProviderSettings(fileConfig, provider);
+			const authorized = await isProviderAuthorizedHybrid(
+				embeddedConfig,
+				fileConfig,
+				provider,
+			);
+			const authType = await getAuthTypeForProvider(
+				embeddedConfig,
+				provider,
+				fileConfig.projectRoot,
+			);
+			return {
+				id: provider,
+				label: definition.label,
+				source: definition.source,
+				enabled: settings?.enabled !== false,
+				authorized,
+				custom: definition.source === 'custom',
+				compatibility: definition.compatibility,
+				family: definition.family,
+				baseURL: definition.baseURL,
+				apiKeyEnv: definition.apiKeyEnv,
+				hasApiKey: Boolean(getConfiguredProviderApiKey(fileConfig, provider)),
+				allowAnyModel: definition.allowAnyModel,
+				modelCount: getConfiguredProviderModels(fileConfig, provider).length,
+				authType,
+			} satisfies ProviderDetail;
+		}),
+	);
+	return details.filter((detail): detail is ProviderDetail => Boolean(detail));
+}
+
 export function getDefault<T>(
 	embeddedValue: T | undefined,
 	embeddedDefaultValue: T | undefined,

package/src/routes/doctor.ts

@@ -2,7 +2,10 @@ import type { Hono } from 'hono';
 import { readdir } from 'node:fs/promises';
 import {
 	readConfig,
-	isAuthorized,
+	isProviderAuthorized,
+	getConfiguredProviderApiKey,
+	getConfiguredProviderEnvVar,
+	getConfiguredProviderIds,
 	buildFsTools,
 	buildGitTools,
 	getSecureAuthPath,
@@ -11,27 +14,8 @@ import {
 	getGlobalCommandsDir,
 	logger,
 } from '@ottocode/sdk';
-import type { ProviderId } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
 
-const PROVIDERS: ProviderId[] = [
-	'openai',
-	'anthropic',
-	'google',
-	'openrouter',
-	'opencode',
-	'ottorouter',
-];
-
-function providerEnvVar(p: ProviderId): string | null {
-	if (p === 'openai') return 'OPENAI_API_KEY';
-	if (p === 'anthropic') return 'ANTHROPIC_API_KEY';
-	if (p === 'google') return 'GOOGLE_GENERATIVE_AI_API_KEY';
-	if (p === 'opencode') return 'OPENCODE_API_KEY';
-	if (p === 'ottorouter') return 'OTTOROUTER_PRIVATE_KEY';
-	return null;
-}
-
 async function fileExists(path: string | null): Promise<boolean> {
 	if (!path) return false;
 	try {
@@ -66,11 +50,14 @@ export function registerDoctorRoutes(app: Hono) {
 		try {
 			const projectRoot = c.req.query('project') || process.cwd();
 			const { cfg, auth } = await readConfig(projectRoot);
+			const configuredProviders = getConfiguredProviderIds(cfg, {
+				includeDisabled: true,
+			});
 
 			const providers = await Promise.all(
-				PROVIDERS.map(async (id) => {
-					const ok = await isAuthorized(id, projectRoot);
-					const envVar = providerEnvVar(id);
+				configuredProviders.map(async (id) => {
+					const ok = await isProviderAuthorized(cfg, id);
+					const envVar = getConfiguredProviderEnvVar(cfg, id) ?? null;
 					const envConfigured = envVar ? !!process.env[envVar] : false;
 
 					const globalAuthPath = getSecureAuthPath();
@@ -104,7 +91,8 @@ export function registerDoctorRoutes(app: Hono) {
 						envConfigured ||
 						hasGlobalAuth ||
 						cfg.defaults.provider === id ||
-						hasStoredSecret;
+						hasStoredSecret ||
+						Boolean(getConfiguredProviderApiKey(cfg, id));
 
 					return { id, ok, configured, sources };
 				}),
@@ -114,9 +102,9 @@ export function registerDoctorRoutes(app: Hono) {
 				agent: cfg.defaults.agent,
 				provider: cfg.defaults.provider,
 				model: cfg.defaults.model,
-				providerAuthorized: await isAuthorized(
-					cfg.defaults.provider as ProviderId,
-					projectRoot,
+				providerAuthorized: await isProviderAuthorized(
+					cfg,
+					cfg.defaults.provider,
 				),
 			};
 

package/src/routes/git/commit.ts

@@ -4,7 +4,12 @@ import { promisify } from 'node:util';
 import { generateText, streamText } from 'ai';
 import { eq } from 'drizzle-orm';
 import type { ProviderId } from '@ottocode/sdk';
-import { loadConfig, getAuth, getFastModelForAuth } from '@ottocode/sdk';
+import {
+	loadConfig,
+	getAuth,
+	getFastModelForAuth,
+	getProviderDefinition,
+} from '@ottocode/sdk';
 import { getDb } from '@ottocode/database';
 import { sessions } from '@ottocode/database/schema';
 import { gitCommitSchema, gitGenerateCommitMessageSchema } from './schemas.ts';
@@ -108,25 +113,31 @@ export function registerCommitRoutes(app: Hono) {
 			const config = await loadConfig();
 
 			let provider = (config.defaults?.provider || 'anthropic') as ProviderId;
+			let currentModel = config.defaults?.model ?? 'claude-3-5-sonnet-20241022';
 
 			if (sessionId) {
 				const db = await getDb();
 				const [session] = await db
-					.select({ provider: sessions.provider })
+					.select({ provider: sessions.provider, model: sessions.model })
 					.from(sessions)
 					.where(eq(sessions.id, sessionId));
 				if (session?.provider) {
 					provider = session.provider as ProviderId;
 				}
+				if (session?.model) {
+					currentModel = session.model;
+				}
 			}
 
 			const auth = await getAuth(provider, config.projectRoot);
 			const oauth = detectOAuth(provider, auth);
+			const providerDefinition = getProviderDefinition(config, provider);
 
 			const modelId =
-				getFastModelForAuth(provider, auth?.type) ??
-				config.defaults?.model ??
-				'claude-3-5-sonnet-20241022';
+				providerDefinition?.source === 'custom' ||
+				providerDefinition?.compatibility === 'ollama'
+					? currentModel
+					: (getFastModelForAuth(provider, auth?.type) ?? currentModel);
 			const model = await resolveModel(provider, modelId, config);
 
 			const userPrompt = `Generate a commit message for these git changes.

package/src/routes/research.ts

@@ -4,7 +4,7 @@ import { getDb } from '@ottocode/database';
 import { sessions, messages, messageParts } from '@ottocode/database/schema';
 import { desc, eq, and, asc, count } from 'drizzle-orm';
 import type { ProviderId } from '@ottocode/sdk';
-import { isProviderId } from '@ottocode/sdk';
+import { hasConfiguredProvider } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
 import { logger } from '@ottocode/sdk';
 import { publish } from '../events/bus.ts';
@@ -89,7 +89,7 @@ export function registerResearchRoutes(app: Hono) {
 		const providerCandidate =
 			typeof body.provider === 'string' ? body.provider : undefined;
 		const provider: ProviderId = (() => {
-			if (providerCandidate && isProviderId(providerCandidate))
+			if (providerCandidate && hasConfiguredProvider(cfg, providerCandidate))
 				return providerCandidate;
 			return parent.provider as ProviderId;
 		})();
@@ -278,7 +278,7 @@ export function registerResearchRoutes(app: Hono) {
 		const providerCandidate =
 			typeof body.provider === 'string' ? body.provider : undefined;
 		const provider: ProviderId = (() => {
-			if (providerCandidate && isProviderId(providerCandidate))
+			if (providerCandidate && hasConfiguredProvider(cfg, providerCandidate))
 				return providerCandidate;
 			return cfg.defaults.provider;
 		})();

package/src/routes/session-messages.ts

@@ -1,13 +1,15 @@
 import type { Hono } from 'hono';
-import { loadConfig, type ReasoningLevel } from '@ottocode/sdk';
-import { getDb } from '@ottocode/database';
-import { messages, messageParts, sessions } from '@ottocode/database/schema';
-import { eq, inArray } from 'drizzle-orm';
 import {
-	validateProviderModel,
-	isProviderAuthorized,
 	ensureProviderEnv,
+	getProviderDefinition,
+	isProviderAuthorized,
+	loadConfig,
+	type ReasoningLevel,
+	validateProviderModel,
 } from '@ottocode/sdk';
+import { getDb } from '@ottocode/database';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { eq, inArray } from 'drizzle-orm';
 import { dispatchAssistantMessage } from '../runtime/message/service.ts';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
@@ -132,7 +134,7 @@ export function registerSessionMessagesRoutes(app: Hono) {
 			// Validate model capabilities if tools are allowed for this agent
 			const wantsToolCalls = true; // agent toolset may be non-empty
 			try {
-				validateProviderModel(provider, modelName, { wantsToolCalls });
+				validateProviderModel(provider, modelName, cfg, { wantsToolCalls });
 			} catch (err) {
 				logger.error('Model validation failed', err, { provider, modelName });
 				const message = err instanceof Error ? err.message : String(err);
@@ -150,6 +152,7 @@ export function registerSessionMessagesRoutes(app: Hono) {
 				);
 			}
 			await ensureProviderEnv(cfg, provider);
+			const providerDefinition = getProviderDefinition(cfg, provider);
 
 			const { assistantMessageId } = await dispatchAssistantMessage({
 				cfg,
@@ -161,7 +164,10 @@ export function registerSessionMessagesRoutes(app: Hono) {
 				content,
 				oneShot: Boolean(body?.oneShot),
 				userContext,
-				reasoningText: reasoning,
+				reasoningText:
+					providerDefinition?.compatibility === 'ollama'
+						? (body?.reasoningText ?? false)
+						: reasoning,
 				reasoningLevel,
 				images,
 				files,

package/src/routes/sessions.ts

@@ -10,7 +10,7 @@ import {
 } from '@ottocode/database/schema';
 import { desc, eq, and, ne, inArray, or } from 'drizzle-orm';
 import type { ProviderId } from '@ottocode/sdk';
-import { isProviderId, catalog } from '@ottocode/sdk';
+import { hasConfiguredProvider, validateProviderModel } from '@ottocode/sdk';
 import { resolveAgentConfig } from '../runtime/agent/registry.ts';
 import { createSession as createSessionRow } from '../runtime/session/manager.ts';
 import { serializeError } from '../runtime/errors/api-error.ts';
@@ -79,9 +79,9 @@ export function registerSessionsRoutes(app: Hono) {
 		const providerCandidate =
 			typeof body.provider === 'string' ? body.provider : undefined;
 		const provider: ProviderId = (() => {
-			if (providerCandidate && isProviderId(providerCandidate))
+			if (providerCandidate && hasConfiguredProvider(cfg, providerCandidate))
 				return providerCandidate;
-			if (agentCfg.provider && isProviderId(agentCfg.provider))
+			if (hasConfiguredProvider(cfg, agentCfg.provider))
 				return agentCfg.provider;
 			return cfg.defaults.provider;
 		})();
@@ -208,7 +208,7 @@ export function registerSessionsRoutes(app: Hono) {
 			// Validate provider if provided
 			if (typeof body.provider === 'string') {
 				const providerName = body.provider.trim();
-				if (providerName && isProviderId(providerName)) {
+				if (providerName && hasConfiguredProvider(cfg, providerName)) {
 					updates.provider = providerName;
 				} else if (providerName) {
 					return c.json({ error: `Invalid provider: ${providerName}` }, 400);
@@ -221,21 +221,15 @@ export function registerSessionsRoutes(app: Hono) {
 				if (modelName) {
 					const targetProvider = (updates.provider ||
 						existingSession.provider) as ProviderId;
-
-					// Check if model exists for the provider
-					const providerCatalog = catalog[targetProvider];
-					if (providerCatalog) {
-						const modelExists = providerCatalog.models.some(
-							(m) => m.id === modelName,
+					try {
+						validateProviderModel(targetProvider, modelName, cfg);
+					} catch {
+						return c.json(
+							{
+								error: `Model "${modelName}" not found for provider "${targetProvider}"`,
+							},
+							400,
 						);
-						if (!modelExists) {
-							return c.json(
-								{
-									error: `Model "${modelName}" not found for provider "${targetProvider}"`,
-								},
-								400,
-							);
-						}
 					}
 
 					updates.model = modelName;