@ottocode/server 0.1.245 → 0.1.246

package/src/runtime/provider/index.ts

@@ -1,4 +1,16 @@
 import type { OttoConfig, ProviderId } from '@ottocode/sdk';
+import {
+	getConfiguredProviderApiKey,
+	getProviderDefinition,
+	isBuiltInProviderId,
+	normalizeOllamaBaseURL,
+} from '@ottocode/sdk';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { createOllama } from 'ai-sdk-ollama';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { getAnthropicInstance } from './anthropic.ts';
 import { resolveOpenAIModel } from './openai.ts';
 import { resolveGoogleModel } from './google.ts';
@@ -23,6 +35,7 @@ export async function resolveModel(
 		systemPrompt?: string;
 		sessionId?: string;
 		messageId?: string;
+		reasoningText?: boolean;
 		topupApprovalMode?: ResolveOttoRouterModelOptions['topupApprovalMode'];
 		autoPayThresholdUsd?: ResolveOttoRouterModelOptions['autoPayThresholdUsd'];
 	},
@@ -37,6 +50,13 @@ export async function resolveModel(
 	if (provider === 'google') {
 		return resolveGoogleModel(model, cfg);
 	}
+	if (provider === 'ollama-cloud') {
+		const definition = getProviderDefinition(cfg, provider);
+		if (!definition) {
+			throw new Error(`Unsupported provider: ${provider}`);
+		}
+		return resolveCustomConfiguredModel(definition, cfg, model, options);
+	}
 	if (provider === 'openrouter') {
 		return resolveOpenRouterModel(model);
 	}
@@ -65,5 +85,83 @@ export async function resolveModel(
 	if (provider === 'minimax') {
 		return getMinimaxInstance(cfg, model);
 	}
+
+	const definition = getProviderDefinition(cfg, provider);
+	if (definition && !isBuiltInProviderId(provider)) {
+		return resolveCustomConfiguredModel(definition, cfg, model, options);
+	}
 	throw new Error(`Unsupported provider: ${provider}`);
 }
+
+function needsResponsesApi(model: string): boolean {
+	const lower = model.toLowerCase();
+	return (
+		lower.includes('gpt-5') ||
+		lower.startsWith('o1') ||
+		lower.startsWith('o3') ||
+		lower.startsWith('o4') ||
+		lower.includes('codex-mini')
+	);
+}
+
+function resolveCustomConfiguredModel(
+	definition: NonNullable<ReturnType<typeof getProviderDefinition>>,
+	cfg: OttoConfig,
+	model: string,
+	options?: {
+		reasoningText?: boolean;
+	},
+) {
+	const apiKey = getConfiguredProviderApiKey(cfg, definition.id) || '';
+	const baseURL =
+		definition.baseURL ||
+		(definition.id === 'ollama-cloud' ? 'https://ollama.com' : undefined);
+
+	if (!baseURL) {
+		throw new Error(
+			`Custom provider ${definition.id} requires a baseURL in config.`,
+		);
+	}
+
+	if (definition.compatibility === 'openai') {
+		const instance = createOpenAI({ apiKey, baseURL });
+		return needsResponsesApi(model)
+			? instance.responses(model)
+			: instance(model);
+	}
+
+	if (definition.compatibility === 'anthropic') {
+		const instance = createAnthropic({ apiKey, baseURL });
+		return instance(model);
+	}
+
+	if (definition.compatibility === 'google') {
+		const instance = createGoogleGenerativeAI({ apiKey, baseURL });
+		return instance(model);
+	}
+
+	if (definition.compatibility === 'openrouter') {
+		const instance = createOpenRouter({ apiKey, baseURL });
+		return instance.chat(model);
+	}
+
+	if (definition.compatibility === 'ollama') {
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		const ollamaBaseURL = normalizeOllamaBaseURL(baseURL);
+		const instance = createOllama({
+			baseURL: ollamaBaseURL,
+			headers,
+		});
+		return instance(model, {
+			...(options?.reasoningText ? { think: true } : {}),
+		});
+	}
+
+	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+	const instance = createOpenAICompatible({
+		name: definition.label,
+		baseURL,
+		headers,
+	});
+	return instance(model);
+}

package/src/runtime/provider/reasoning.ts

@@ -1,8 +1,11 @@
 import {
 	catalog,
+	getConfiguredProviderFamily,
+	getProviderDefinition,
 	getModelNpmBinding,
 	getUnderlyingProviderKey,
 	modelSupportsReasoning,
+	type OttoConfig,
 	type ProviderId,
 	type ReasoningLevel,
 } from '@ottocode/sdk';
@@ -35,7 +38,6 @@ function toAnthropicEffort(
 		case 'max':
 		case 'xhigh':
 			return 'max';
-		case 'high':
 		default:
 			return 'high';
 	}
@@ -54,7 +56,6 @@ function toOpenAIEffort(
 		case 'max':
 		case 'xhigh':
 			return 'xhigh';
-		case 'high':
 		default:
 			return 'high';
 	}
@@ -70,9 +71,6 @@ function toGoogleThinkingLevel(
 			return 'low';
 		case 'medium':
 			return 'medium';
-		case 'max':
-		case 'xhigh':
-		case 'high':
 		default:
 			return 'high';
 	}
@@ -95,7 +93,6 @@ function toThinkingBudget(
 		case 'max':
 		case 'xhigh':
 			return Math.min(24000, cap);
-		case 'high':
 		default:
 			return Math.min(16000, cap);
 	}
@@ -114,11 +111,16 @@ function toCamelCaseKey(value: string): string {
 		.join('');
 }
 
-function getOpenAICompatibleProviderOptionKeys(provider: ProviderId): string[] {
+function getOpenAICompatibleProviderOptionKeys(
+	provider: ProviderId,
+	cfg?: OttoConfig,
+): string[] {
+	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
 	const entry = catalog[provider];
 	const keys = new Set<string>(['openaiCompatible', toCamelCaseKey(provider)]);
-	if (entry?.label) {
-		keys.add(toCamelCaseKey(entry.label));
+	const label = definition?.label ?? entry?.label;
+	if (label) {
+		keys.add(toCamelCaseKey(label));
 	}
 	return Array.from(keys).filter(Boolean);
 }
@@ -126,8 +128,9 @@ function getOpenAICompatibleProviderOptionKeys(provider: ProviderId): string[] {
 function buildSharedProviderOptions(
 	provider: ProviderId,
 	options: Record<string, unknown>,
+	cfg?: OttoConfig,
 ): Record<string, unknown> {
-	const keys = getOpenAICompatibleProviderOptionKeys(provider);
+	const keys = getOpenAICompatibleProviderOptionKeys(provider, cfg);
 	return Object.fromEntries(keys.map((key) => [key, options]));
 }
 
@@ -146,14 +149,28 @@ function usesAdaptiveAnthropicThinking(model: string): boolean {
 function getReasoningProviderTarget(
 	provider: ProviderId,
 	model: string,
+	cfg?: OttoConfig,
 ):
 	| 'anthropic'
 	| 'openai'
 	| 'google'
+	| 'ollama'
 	| 'openai-compatible'
 	| 'openrouter'
 	| null {
+	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
+	if (definition?.source === 'custom') {
+		if (definition.compatibility === 'anthropic') return 'anthropic';
+		if (definition.compatibility === 'openai') return 'openai';
+		if (definition.compatibility === 'google') return 'google';
+		if (definition.compatibility === 'ollama') return 'ollama';
+		if (definition.compatibility === 'openrouter') return 'openrouter';
+		return 'openai-compatible';
+	}
+
+	if (provider === 'ottorouter') return 'openrouter';
 	if (provider === 'openrouter') return 'openrouter';
+	if (definition?.compatibility === 'ollama') return 'ollama';
 	if (
 		provider === 'moonshot' ||
 		provider === 'zai' ||
@@ -167,6 +184,7 @@ function getReasoningProviderTarget(
 	if (npmBinding === '@ai-sdk/anthropic') return 'anthropic';
 	if (npmBinding === '@ai-sdk/openai') return 'openai';
 	if (npmBinding === '@ai-sdk/google') return 'google';
+	if (npmBinding === 'ai-sdk-ollama') return 'ollama';
 	if (npmBinding === '@ai-sdk/openai-compatible') return 'openai-compatible';
 	if (npmBinding === '@openrouter/ai-sdk-provider') return 'openrouter';
 
@@ -175,19 +193,41 @@ function getReasoningProviderTarget(
 	if (underlyingProvider === 'openai') return 'openai';
 	if (underlyingProvider === 'google') return 'google';
 	if (underlyingProvider === 'openai-compatible') return 'openai-compatible';
+
+	const family = cfg ? getConfiguredProviderFamily(cfg, provider, model) : null;
+	if (family === 'anthropic') return 'anthropic';
+	if (family === 'openai') return 'openai';
+	if (family === 'google') return 'google';
+	if (family === 'openai-compatible') return 'openai-compatible';
 	return null;
 }
 
 export function buildReasoningConfig(args: {
+	cfg?: OttoConfig;
 	provider: ProviderId;
 	model: string;
 	reasoningText?: boolean;
 	reasoningLevel?: ReasoningLevel;
 	maxOutputTokens: number | undefined;
 }): ReasoningConfigResult {
-	const { provider, model, reasoningText, reasoningLevel, maxOutputTokens } =
-		args;
-	if (!reasoningText || !modelSupportsReasoning(provider, model)) {
+	const {
+		cfg,
+		provider,
+		model,
+		reasoningText,
+		reasoningLevel,
+		maxOutputTokens,
+	} = args;
+	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
+	const supportsReasoning =
+		definition?.compatibility === 'ollama'
+			? true
+			: definition?.source === 'custom'
+				? true
+				: provider === 'ottorouter'
+					? true
+					: modelSupportsReasoning(provider, model);
+	if (!reasoningText || !supportsReasoning) {
 		return {
 			providerOptions: {},
 			effectiveMaxOutputTokens: maxOutputTokens,
@@ -195,7 +235,7 @@ export function buildReasoningConfig(args: {
 		};
 	}
 
-	const reasoningTarget = getReasoningProviderTarget(provider, model);
+	const reasoningTarget = getReasoningProviderTarget(provider, model, cfg);
 	if (reasoningTarget === 'anthropic') {
 		if (usesAdaptiveAnthropicThinking(model)) {
 			return {
@@ -263,6 +303,18 @@ export function buildReasoningConfig(args: {
 		};
 	}
 
+	if (reasoningTarget === 'ollama') {
+		return {
+			providerOptions: {
+				ollama: {
+					think: true,
+				},
+			},
+			effectiveMaxOutputTokens: maxOutputTokens,
+			enabled: true,
+		};
+	}
+
 	if (reasoningTarget === 'openrouter') {
 		return {
 			providerOptions: {
@@ -277,9 +329,13 @@ export function buildReasoningConfig(args: {
 
 	if (reasoningTarget === 'openai-compatible') {
 		return {
-			providerOptions: buildSharedProviderOptions(provider, {
-				reasoningEffort: normalizeReasoningLevel(reasoningLevel),
-			}),
+			providerOptions: buildSharedProviderOptions(
+				provider,
+				{
+					reasoningEffort: normalizeReasoningLevel(reasoningLevel),
+				},
+				cfg,
+			),
 			effectiveMaxOutputTokens: maxOutputTokens,
 			enabled: true,
 		};

package/src/runtime/provider/selection.ts

@@ -1,11 +1,11 @@
 import type { OttoConfig } from '@ottocode/sdk';
 import {
-	catalog,
 	type ProviderId,
 	isProviderAuthorized,
-	providerIds,
-	defaultModelFor,
-	hasModel,
+	getConfiguredProviderIds,
+	getConfiguredProviderDefaultModel,
+	hasConfiguredModel,
+	hasConfiguredProvider,
 } from '@ottocode/sdk';
 
 const FALLBACK_ORDER: ProviderId[] = [
@@ -59,6 +59,7 @@ export async function selectProviderAndModel(
 	}
 
 	const model = resolveModelForProvider({
+		cfg,
 		provider,
 		explicitModel,
 		agentModelDefault,
@@ -81,9 +82,10 @@ async function pickAuthorizedProvider(args: {
 	const candidates = uniqueProviders([
 		candidate,
 		...FALLBACK_ORDER,
-		...providerIds,
+		...getConfiguredProviderIds(cfg),
 	]);
 	for (const provider of candidates) {
+		if (!hasConfiguredProvider(cfg, provider)) continue;
 		const ok = await isProviderAuthorized(cfg, provider);
 		if (ok) return provider;
 	}
@@ -94,7 +96,6 @@ function uniqueProviders(list: ProviderId[]): ProviderId[] {
 	const seen = new Set<ProviderId>();
 	const ordered: ProviderId[] = [];
 	for (const provider of list) {
-		if (!providerIds.includes(provider)) continue;
 		if (seen.has(provider)) continue;
 		seen.add(provider);
 		ordered.push(provider);
@@ -103,16 +104,17 @@ function uniqueProviders(list: ProviderId[]): ProviderId[] {
 }
 
 function resolveModelForProvider(args: {
+	cfg: OttoConfig;
 	provider: ProviderId;
 	explicitModel?: string;
 	agentModelDefault: string;
 }): string {
-	const { provider, explicitModel, agentModelDefault } = args;
-	if (explicitModel && hasModel(provider, explicitModel)) return explicitModel;
-	if (hasModel(provider, agentModelDefault)) return agentModelDefault;
-	return (
-		defaultModelFor(provider) ??
-		catalog[provider]?.models?.[0]?.id ??
-		agentModelDefault
-	);
+	const { cfg, provider, explicitModel, agentModelDefault } = args;
+	if (explicitModel && hasConfiguredModel(cfg, provider, explicitModel)) {
+		return explicitModel;
+	}
+	if (hasConfiguredModel(cfg, provider, agentModelDefault)) {
+		return agentModelDefault;
+	}
+	return getConfiguredProviderDefaultModel(cfg, provider) ?? agentModelDefault;
 }

package/src/runtime/session/manager.ts

@@ -29,7 +29,7 @@ export async function createSession({
 	model,
 	title,
 }: CreateSessionInput): Promise<SessionRow> {
-	validateProviderModel(provider, model);
+	validateProviderModel(provider, model, cfg);
 	const authorized = await isProviderAuthorized(cfg, provider);
 	if (!authorized) {
 		throw new Error(

package/src/runtime/session/queue.ts

@@ -10,6 +10,7 @@ export type RunOpts = {
 	provider: ProviderName;
 	model: string;
 	projectRoot: string;
+	queuedAt?: number;
 	oneShot?: boolean;
 	userContext?: string;
 	estimatedInputTokens?: number;
@@ -74,7 +75,7 @@ function publishQueueState(sessionId: string) {
  * Creates an abort controller per message.
  */
 export function enqueueAssistantRun(
-	opts: Omit<RunOpts, 'abortSignal'>,
+	opts: Omit<RunOpts, 'abortSignal' | 'queuedAt'>,
 	processQueueFn: (sessionId: string) => Promise<void>,
 ) {
 	const abortController = new AbortController();
@@ -85,7 +86,11 @@ export function enqueueAssistantRun(
 		running: false,
 		currentMessageId: null,
 	};
-	state.queue.push({ ...opts, abortSignal: abortController.signal });
+	state.queue.push({
+		...opts,
+		queuedAt: globalThis.performance?.now?.() ?? Date.now(),
+		abortSignal: abortController.signal,
+	});
 	runners.set(opts.sessionId, state);
 
 	publishQueueState(opts.sessionId);