@ottocode/server 0.1.245 → 0.1.246

package/package.json

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

package/src/index.ts

@@ -284,6 +284,11 @@ export {
 	composeSystemPrompt,
 	type ComposedSystemPrompt,
 } from './runtime/prompt/builder.ts';
+export {
+	buildCapabilitySummary,
+	type CapabilitySummaryResult,
+	type CapabilitySummaryMCPTool,
+} from './runtime/prompt/capabilities.ts';
 export {
 	AskServiceError,
 	handleAskRequest,

package/src/openapi/paths/config.ts

@@ -91,9 +91,123 @@ export const configPaths = {
 										type: 'array',
 										items: { $ref: '#/components/schemas/Provider' },
 									},
+									details: {
+										type: 'array',
+										items: { $ref: '#/components/schemas/ProviderDetail' },
+									},
 									default: { $ref: '#/components/schemas/Provider' },
 								},
-								required: ['providers', 'default'],
+								required: ['providers', 'details', 'default'],
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	'/v1/config/providers/{provider}': {
+		put: {
+			tags: ['config'],
+			operationId: 'updateProviderSettings',
+			summary: 'Create or update provider settings',
+			parameters: [
+				projectQueryParam(),
+				{
+					in: 'path',
+					name: 'provider',
+					required: true,
+					schema: { $ref: '#/components/schemas/Provider' },
+				},
+			],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								enabled: { type: 'boolean' },
+								custom: { type: 'boolean' },
+								label: { type: 'string' },
+								compatibility: { type: 'string' },
+								family: { type: 'string' },
+								baseURL: { type: 'string', nullable: true },
+								apiKey: { type: 'string', nullable: true },
+								apiKeyEnv: { type: 'string', nullable: true },
+								models: {
+									type: 'array',
+									items: { type: 'string' },
+								},
+								allowAnyModel: { type: 'boolean' },
+								scope: {
+									type: 'string',
+									enum: ['global', 'local'],
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+									provider: { $ref: '#/components/schemas/Provider' },
+									details: {
+										type: 'array',
+										items: { $ref: '#/components/schemas/ProviderDetail' },
+									},
+								},
+								required: ['success', 'provider', 'details'],
+							},
+						},
+					},
+				},
+			},
+		},
+		delete: {
+			tags: ['config'],
+			operationId: 'deleteProviderSettings',
+			summary: 'Delete provider override or custom provider entry',
+			parameters: [
+				projectQueryParam(),
+				{
+					in: 'query',
+					name: 'scope',
+					required: false,
+					schema: {
+						type: 'string',
+						enum: ['global', 'local'],
+					},
+				},
+				{
+					in: 'path',
+					name: 'provider',
+					required: true,
+					schema: { $ref: '#/components/schemas/Provider' },
+				},
+			],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+									provider: { $ref: '#/components/schemas/Provider' },
+									details: {
+										type: 'array',
+										items: { $ref: '#/components/schemas/ProviderDetail' },
+									},
+								},
+								required: ['success', 'provider', 'details'],
 							},
 						},
 					},
@@ -128,8 +242,10 @@ export const configPaths = {
 										items: { $ref: '#/components/schemas/Model' },
 									},
 									default: { type: 'string', nullable: true },
+									allowAnyModel: { type: 'boolean' },
+									label: { type: 'string' },
 								},
-								required: ['models'],
+								required: ['models', 'allowAnyModel', 'label'],
 							},
 						},
 					},

package/src/openapi/paths/skills.ts

@@ -1,6 +1,128 @@
 import { errorResponse, projectQueryParam } from '../helpers';
 
 export const skillsPaths = {
+	'/v1/config/skills': {
+		get: {
+			tags: ['config'],
+			operationId: 'getSkillsConfig',
+			summary: 'Get skills enable/disable config and counts',
+			parameters: [projectQueryParam()],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									enabled: { type: 'boolean' },
+									totalCount: { type: 'number' },
+									enabledCount: { type: 'number' },
+									items: {
+										type: 'array',
+										items: {
+											type: 'object',
+											properties: {
+												name: { type: 'string' },
+												description: { type: 'string' },
+												scope: { type: 'string' },
+												path: { type: 'string' },
+												enabled: { type: 'boolean' },
+											},
+											required: [
+												'name',
+												'description',
+												'scope',
+												'path',
+												'enabled',
+											],
+										},
+									},
+								},
+								required: ['enabled', 'totalCount', 'enabledCount', 'items'],
+							},
+						},
+					},
+				},
+				500: errorResponse(),
+			},
+		},
+		put: {
+			tags: ['config'],
+			operationId: 'updateSkillsConfig',
+			summary: 'Update skills enable/disable config',
+			parameters: [projectQueryParam()],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								enabled: { type: 'boolean' },
+								scope: { type: 'string', enum: ['global', 'local'] },
+								items: {
+									type: 'object',
+									additionalProperties: {
+										type: 'object',
+										properties: {
+											enabled: { type: 'boolean' },
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+									enabled: { type: 'boolean' },
+									totalCount: { type: 'number' },
+									enabledCount: { type: 'number' },
+									items: {
+										type: 'array',
+										items: {
+											type: 'object',
+											properties: {
+												name: { type: 'string' },
+												description: { type: 'string' },
+												scope: { type: 'string' },
+												path: { type: 'string' },
+												enabled: { type: 'boolean' },
+											},
+											required: [
+												'name',
+												'description',
+												'scope',
+												'path',
+												'enabled',
+											],
+										},
+									},
+								},
+								required: [
+									'success',
+									'enabled',
+									'totalCount',
+									'enabledCount',
+									'items',
+								],
+							},
+						},
+					},
+				},
+				500: errorResponse(),
+			},
+		},
+	},
 	'/v1/skills': {
 		get: {
 			tags: ['config'],

package/src/openapi/schemas.ts

@@ -1,9 +1,37 @@
-import { providerIds } from '@ottocode/sdk';
-
 export const schemas = {
 	Provider: {
 		type: 'string',
-		enum: providerIds,
+		description: 'Built-in or custom provider identifier',
+	},
+	ProviderDetail: {
+		type: 'object',
+		properties: {
+			id: { $ref: '#/components/schemas/Provider' },
+			label: { type: 'string' },
+			source: { type: 'string', enum: ['built-in', 'custom'] },
+			enabled: { type: 'boolean' },
+			authorized: { type: 'boolean' },
+			custom: { type: 'boolean' },
+			compatibility: { type: 'string', nullable: true },
+			family: { type: 'string', nullable: true },
+			baseURL: { type: 'string', nullable: true },
+			apiKeyEnv: { type: 'string', nullable: true },
+			hasApiKey: { type: 'boolean' },
+			allowAnyModel: { type: 'boolean' },
+			modelCount: { type: 'integer' },
+			authType: { type: 'string', nullable: true },
+		},
+		required: [
+			'id',
+			'label',
+			'source',
+			'enabled',
+			'authorized',
+			'custom',
+			'hasApiKey',
+			'allowAnyModel',
+			'modelCount',
+		],
 	},
 	AskResponse: {
 		type: 'object',
@@ -190,6 +218,10 @@ export const schemas = {
 				type: 'array',
 				items: { $ref: '#/components/schemas/Provider' },
 			},
+			providerDetails: {
+				type: 'array',
+				items: { $ref: '#/components/schemas/ProviderDetail' },
+			},
 			defaults: {
 				type: 'object',
 				properties: {

package/src/routes/auth.ts

@@ -16,8 +16,8 @@ import {
 	exchange,
 	authorizeWeb,
 	exchangeWeb,
-	authorizeOpenAI,
-	exchangeOpenAI,
+	authorizeOpenAIWeb,
+	exchangeOpenAIWeb,
 	authorizeCopilot,
 	pollForCopilotTokenOnce,
 	type ProviderId,
@@ -488,45 +488,23 @@ export function registerAuthRoutes(app: Hono) {
 		try {
 			const provider = c.req.param('provider');
 			const mode = c.req.query('mode') || 'max';
+			const host = c.req.header('host') || 'localhost:3000';
+			const protocol = c.req.header('x-forwarded-proto') || 'http';
 
 			let url: string;
 			let verifier: string;
 			let callbackUrl = '';
 
 			if (provider === 'anthropic') {
-				const host = c.req.header('host') || 'localhost:3000';
-				const protocol = c.req.header('x-forwarded-proto') || 'http';
 				callbackUrl = `${protocol}://${host}/v1/auth/${provider}/oauth/callback`;
 				const result = authorizeWeb(mode as 'max' | 'console', callbackUrl);
 				url = result.url;
 				verifier = result.verifier;
 			} else if (provider === 'openai') {
-				const result = await authorizeOpenAI();
+				callbackUrl = `${protocol}://${host}/v1/auth/${provider}/oauth/callback`;
+				const result = authorizeOpenAIWeb(callbackUrl);
 				url = result.url;
 				verifier = result.verifier;
-				callbackUrl = 'localhost';
-				result
-					.waitForCallback()
-					.then(async (code) => {
-						const tokens = await exchangeOpenAI(code, verifier);
-						await setAuth(
-							'openai',
-							{
-								type: 'oauth',
-								refresh: tokens.refresh,
-								access: tokens.access,
-								expires: tokens.expires,
-								accountId: tokens.accountId,
-								idToken: tokens.idToken,
-							},
-							undefined,
-							'global',
-						);
-						result.close();
-					})
-					.catch(() => {
-						result.close();
-					});
 			} else {
 				return c.json({ error: 'OAuth not supported for this provider' }, 400);
 			}
@@ -594,8 +572,24 @@ export function registerAuthRoutes(app: Hono) {
 					'global',
 				);
 			} else if (provider === 'openai') {
-				return c.html(
-					'<html><body><h1>OpenAI uses localhost callback</h1><p>This route is not used for OpenAI. Please close this window.</p><script>setTimeout(() => window.close(), 3000);</script></body></html>',
+				const tokens = await exchangeOpenAIWeb(
+					code ?? '',
+					verifier,
+					callbackUrl,
+				);
+
+				await setAuth(
+					'openai',
+					{
+						type: 'oauth',
+						refresh: tokens.refresh,
+						access: tokens.access,
+						expires: tokens.expires,
+						accountId: tokens.accountId,
+						idToken: tokens.idToken,
+					},
+					undefined,
+					'global',
 				);
 			}
 

package/src/routes/branch.ts

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono';
 import { loadConfig } from '@ottocode/sdk';
 import { getDb } from '@ottocode/database';
-import { isProviderId, logger } from '@ottocode/sdk';
+import { hasConfiguredProvider, logger } from '@ottocode/sdk';
 import {
 	createBranch,
 	listBranches,
@@ -28,7 +28,8 @@ export function registerBranchRoutes(app: Hono) {
 			}
 
 			const provider =
-				typeof body.provider === 'string' && isProviderId(body.provider)
+				typeof body.provider === 'string' &&
+				hasConfiguredProvider(cfg, body.provider)
 					? body.provider
 					: undefined;
 

package/src/routes/config/defaults.ts

@@ -2,6 +2,7 @@ import type { Hono } from 'hono';
 import {
 	setConfig,
 	loadConfig,
+	hasConfiguredProvider,
 	type ProviderId,
 	type ReasoningLevel,
 } from '@ottocode/sdk';
@@ -12,6 +13,7 @@ export function registerDefaultsRoute(app: Hono) {
 	app.patch('/v1/config/defaults', async (c) => {
 		try {
 			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
 			const body = await c.req.json<{
 				agent?: string;
 				provider?: string;
@@ -41,7 +43,12 @@ export function registerDefaultsRoute(app: Hono) {
 			}> = {};
 
 			if (body.agent) updates.agent = body.agent;
-			if (body.provider) updates.provider = body.provider as ProviderId;
+			if (body.provider) {
+				if (!hasConfiguredProvider(cfg, body.provider)) {
+					return c.json({ error: `Invalid provider: ${body.provider}` }, 400);
+				}
+				updates.provider = body.provider as ProviderId;
+			}
 			if (body.model) updates.model = body.model;
 			if (body.toolApproval) updates.toolApproval = body.toolApproval;
 			if (body.guidedMode !== undefined) updates.guidedMode = body.guidedMode;
@@ -62,11 +69,11 @@ export function registerDefaultsRoute(app: Hono) {
 
 			await setConfig(scope, updates, projectRoot);
 
-			const cfg = await loadConfig(projectRoot);
+			const nextCfg = await loadConfig(projectRoot);
 
 			return c.json({
 				success: true,
-				defaults: cfg.defaults,
+				defaults: nextCfg.defaults,
 			});
 		} catch (error) {
 			logger.error('Failed to update defaults', error);

package/src/routes/config/main.ts

@@ -7,6 +7,7 @@ import {
 	discoverAllAgents,
 	getAuthorizedProviders,
 	getDefault,
+	getProviderDetails,
 } from './utils.ts';
 
 export function registerMainConfigRoute(app: Hono) {
@@ -37,6 +38,7 @@ export function registerMainConfigRoute(app: Hono) {
 				embeddedConfig,
 				cfg,
 			);
+			const providerDetails = await getProviderDetails(embeddedConfig, cfg);
 
 			const defaults = {
 				agent: getDefault(
@@ -80,6 +82,7 @@ export function registerMainConfigRoute(app: Hono) {
 			return c.json({
 				agents: allAgents,
 				providers: authorizedProviders,
+				providerDetails,
 				defaults,
 			});
 		} catch (error) {

package/src/routes/config/models.ts

@@ -1,10 +1,15 @@
 import type { Hono } from 'hono';
 import {
+	discoverOllamaModels,
 	loadConfig,
 	catalog,
+	getConfiguredProviderModels,
+	getProviderDefinition,
+	providerAllowsAnyModel,
 	getAuth,
 	logger,
 	readEnvKey,
+	type ModelInfo,
 	type ProviderId,
 	filterModelsForAuthType,
 } from '@ottocode/sdk';
@@ -79,6 +84,49 @@ async function getAuthorizedCopilotModels(
 	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.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: false,
+		});
+		return discovered.models;
+	} catch (error) {
+		logger.warn('Failed to discover Ollama models', {
+			provider,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return [];
+	}
+}
+
+function shouldLazyLoadProviderModels(
+	providerDefinition: NonNullable<ReturnType<typeof getProviderDefinition>>,
+): boolean {
+	return (
+		providerDefinition.compatibility === 'ollama' ||
+		providerDefinition.source === 'custom'
+	);
+}
+
 export function registerModelsRoutes(app: Hono) {
 	app.get('/v1/config/providers/:provider/models', async (c) => {
 		try {
@@ -103,8 +151,9 @@ export function registerModelsRoutes(app: Hono) {
 				return c.json({ error: 'Provider not authorized' }, 403);
 			}
 
-			const providerCatalog = catalog[provider];
-			if (!providerCatalog) {
+			const providerCatalog = 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);
 			}
@@ -114,11 +163,21 @@ export function registerModelsRoutes(app: Hono) {
 				provider,
 				projectRoot,
 			);
-			const filteredModels = filterModelsForAuthType(
+			const discoveredModels = await discoverProviderModels({
 				provider,
-				providerCatalog.models,
-				authType,
-			);
+				providerDefinition,
+				projectRoot,
+			});
+			const filteredModels =
+				providerDefinition.compatibility === 'ollama'
+					? (discoveredModels ?? [])
+					: providerCatalog
+						? filterModelsForAuthType(
+								provider,
+								providerCatalog.models,
+								authType,
+							)
+						: getConfiguredProviderModels(cfg, provider);
 			const copilotAllowedModels =
 				provider === 'copilot'
 					? await getAuthorizedCopilotModels(projectRoot)
@@ -145,6 +204,8 @@ export function registerModelsRoutes(app: Hono) {
 					embeddedConfig?.defaults?.model,
 					cfg.defaults.model,
 				),
+				allowAnyModel: providerAllowsAnyModel(cfg, provider),
+				label: providerDefinition.label,
 			});
 		} catch (error) {
 			logger.error('Failed to get provider models', error);
@@ -184,21 +245,30 @@ export function registerModelsRoutes(app: Hono) {
 			> = {};
 
 			for (const provider of authorizedProviders) {
-				const providerCatalog = catalog[provider];
-				if (providerCatalog) {
+				const providerCatalog = catalog[provider as keyof typeof catalog];
+				const providerDefinition = getProviderDefinition(cfg, provider);
+				if (providerDefinition) {
+					const dynamicModels =
+						shouldLazyLoadProviderModels(providerDefinition);
 					const authType = await getAuthTypeForProvider(
 						embeddedConfig,
 						provider,
 						projectRoot,
 					);
-					const filteredModels = filterModelsForAuthType(
-						provider,
-						providerCatalog.models,
-						authType,
-					);
+					const filteredModels = dynamicModels
+						? getConfiguredProviderModels(cfg, provider)
+						: providerCatalog
+							? filterModelsForAuthType(
+									provider,
+									providerCatalog.models,
+									authType,
+								)
+							: getConfiguredProviderModels(cfg, provider);
 					modelsMap[provider] = {
-						label: providerCatalog.label || provider,
+						label: providerDefinition.label,
 						authType,
+						allowAnyModel: providerDefinition.allowAnyModel,
+						dynamicModels,
 						models: filteredModels.map((m) => ({
 							id: m.id,
 							label: m.label || m.id,