@ottocode/server 0.1.244 → 0.1.246

package/src/runtime/provider/index.ts

@@ -1,9 +1,24 @@
 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';
 import { resolveOpenRouterModel } from './openrouter.ts';
-import { resolveSetuModel, type ResolveSetuModelOptions } from './setu.ts';
+import {
+	resolveOttoRouterModel,
+	type ResolveOttoRouterModelOptions,
+} from './ottorouter.ts';
 import { getZaiInstance, getZaiCodingInstance } from './zai.ts';
 import { resolveOpencodeModel } from './opencode.ts';
 import { getMoonshotInstance } from './moonshot.ts';
@@ -20,8 +35,9 @@ export async function resolveModel(
 		systemPrompt?: string;
 		sessionId?: string;
 		messageId?: string;
-		topupApprovalMode?: ResolveSetuModelOptions['topupApprovalMode'];
-		autoPayThresholdUsd?: ResolveSetuModelOptions['autoPayThresholdUsd'];
+		reasoningText?: boolean;
+		topupApprovalMode?: ResolveOttoRouterModelOptions['topupApprovalMode'];
+		autoPayThresholdUsd?: ResolveOttoRouterModelOptions['autoPayThresholdUsd'];
 	},
 ) {
 	if (provider === 'openai') {
@@ -34,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);
 	}
@@ -43,8 +66,8 @@ export async function resolveModel(
 	if (provider === 'copilot') {
 		return resolveCopilotModel(model, cfg);
 	}
-	if (provider === 'setu') {
-		return await resolveSetuModel(model, options?.sessionId, {
+	if (provider === 'ottorouter') {
+		return await resolveOttoRouterModel(model, options?.sessionId, {
 			messageId: options?.messageId,
 			topupApprovalMode: options?.topupApprovalMode,
 			autoPayThresholdUsd: options?.autoPayThresholdUsd,
@@ -62,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/{setu.ts → ottorouter.ts}

@@ -1,6 +1,6 @@
 import {
-	createSetu,
-	type SetuPaymentCallbacks,
+	createOttoRouter,
+	type OttoRouterPaymentCallbacks,
 	getAuth,
 	loadConfig,
 } from '@ottocode/sdk';
@@ -14,19 +14,19 @@ import {
 
 const MIN_TOPUP_USD = 5;
 
-export interface ResolveSetuModelOptions {
+export interface ResolveOttoRouterModelOptions {
 	messageId?: string;
 	topupApprovalMode?: 'auto' | 'approval';
 	autoPayThresholdUsd?: number;
 }
 
-async function getSetuPrivateKey(): Promise<string> {
-	if (process.env.SETU_PRIVATE_KEY) {
-		return process.env.SETU_PRIVATE_KEY;
+async function getOttoRouterPrivateKey(): Promise<string> {
+	if (process.env.OTTOROUTER_PRIVATE_KEY) {
+		return process.env.OTTOROUTER_PRIVATE_KEY;
 	}
 	try {
 		const cfg = await loadConfig(process.cwd());
-		const auth = await getAuth('setu', cfg.projectRoot);
+		const auth = await getAuth('ottorouter', cfg.projectRoot);
 		if (auth?.type === 'wallet' && auth.secret) {
 			return auth.secret;
 		}
@@ -34,58 +34,58 @@ async function getSetuPrivateKey(): Promise<string> {
 	return '';
 }
 
-export async function resolveSetuModel(
+export async function resolveOttoRouterModel(
 	model: string,
 	sessionId?: string,
-	options: ResolveSetuModelOptions = {},
+	options: ResolveOttoRouterModelOptions = {},
 ) {
-	const privateKey = await getSetuPrivateKey();
+	const privateKey = await getOttoRouterPrivateKey();
 	if (!privateKey) {
 		throw new Error(
-			'Setu provider requires SETU_PRIVATE_KEY (base58 Solana secret).',
+			'OttoRouter provider requires OTTOROUTER_PRIVATE_KEY (base58 Solana secret).',
 		);
 	}
-	const baseURL = process.env.SETU_BASE_URL;
-	const rpcURL = process.env.SETU_SOLANA_RPC_URL;
+	const baseURL = process.env.OTTOROUTER_BASE_URL;
+	const rpcURL = process.env.OTTOROUTER_SOLANA_RPC_URL;
 	const {
 		messageId,
 		topupApprovalMode = 'approval',
 		autoPayThresholdUsd = MIN_TOPUP_USD,
 	} = options;
 
-	const callbacks: SetuPaymentCallbacks = sessionId
+	const callbacks: OttoRouterPaymentCallbacks = sessionId
 		? {
 				onPaymentRequired: (amountUsd, currentBalance) => {
 					publish({
-						type: 'setu.payment.required',
+						type: 'ottorouter.payment.required',
 						sessionId,
 						payload: { amountUsd, currentBalance },
 					});
 				},
 				onPaymentSigning: () => {
 					publish({
-						type: 'setu.payment.signing',
+						type: 'ottorouter.payment.signing',
 						sessionId,
 						payload: {},
 					});
 				},
 				onPaymentComplete: (data) => {
 					publish({
-						type: 'setu.payment.complete',
+						type: 'ottorouter.payment.complete',
 						sessionId,
 						payload: data,
 					});
 				},
 				onPaymentError: (error) => {
 					publish({
-						type: 'setu.payment.error',
+						type: 'ottorouter.payment.error',
 						sessionId,
 						payload: { error },
 					});
 				},
 				onBalanceUpdate: (update) => {
 					publish({
-						type: 'setu.balance.updated',
+						type: 'ottorouter.balance.updated',
 						sessionId,
 						payload: update,
 					});
@@ -97,7 +97,7 @@ export async function resolveSetuModel(
 					);
 
 					publish({
-						type: 'setu.topup.required',
+						type: 'ottorouter.topup.required',
 						sessionId,
 						payload: {
 							messageId,
@@ -118,7 +118,7 @@ export async function resolveSetuModel(
 			}
 		: {};
 
-	const setu = createSetu({
+	const ottorouter = createOttoRouter({
 		auth: { privateKey },
 		baseURL,
 		rpcURL,
@@ -130,5 +130,5 @@ export async function resolveSetuModel(
 		},
 	});
 
-	return setu.model(model);
+	return ottorouter.model(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[] = [
@@ -14,7 +14,7 @@ const FALLBACK_ORDER: ProviderId[] = [
 	'google',
 	'opencode',
 	'openrouter',
-	'setu',
+	'ottorouter',
 ];
 
 type SelectionInput = {
@@ -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/db-operations.ts

@@ -71,7 +71,7 @@ export function resolveUsageProvider(
 	model: string,
 ): ProviderId {
 	if (
-		provider !== 'setu' &&
+		provider !== 'ottorouter' &&
 		provider !== 'openrouter' &&
 		provider !== 'opencode'
 	) {

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);

package/src/runtime/stream/error-handler.ts

@@ -28,7 +28,7 @@ export function createErrorHandler(
 			| undefined;
 		const causeError = errObj?.cause as Record<string, unknown> | undefined;
 
-		// Check for SETU_FIAT_SELECTED code specifically (not string matching)
+		// Check for OTTOROUTER_FIAT_SELECTED code specifically (not string matching)
 		const errorCode =
 			(errObj?.code as string) ??
 			((errObj?.error as Record<string, unknown>)?.code as string) ??
@@ -72,7 +72,7 @@ export function createErrorHandler(
 			(causeError?.message as string) ??
 			'';
 
-		const isFiatSelected = errorCode === 'SETU_FIAT_SELECTED';
+		const isFiatSelected = errorCode === 'OTTOROUTER_FIAT_SELECTED';
 
 		// Handle fiat payment selected - this is not an error, just a signal to pause
 		if (isFiatSelected) {
@@ -140,7 +140,7 @@ export function createErrorHandler(
 
 			// Emit a special event so UI knows to show topup modal
 			publish({
-				type: 'setu.fiat.checkout_created',
+				type: 'ottorouter.fiat.checkout_created',
 				sessionId: opts.sessionId,
 				payload: {
 					messageId: opts.assistantMessageId,