@ottocode/server 0.1.265 → 0.1.267

package/src/runtime/prompt/capabilities.ts

@@ -1,6 +1,5 @@
 import {
 	filterDiscoveredSkills,
-	getDiscoveredSkills,
 	getMCPManager,
 	summarizeDescription,
 	type DiscoveredSkill,
@@ -31,7 +30,9 @@ export function buildCapabilitySummary(options?: {
 	skills?: DiscoveredSkill[];
 	mcpTools?: CapabilitySummaryMCPTool[];
 }): CapabilitySummaryResult {
-	const skillLines = buildSkillLines(options?.skills, options?.skillSettings);
+	const skillLines = options?.skills
+		? buildSkillLines(options.skills, options.skillSettings)
+		: [];
 	const mcpLines = buildMCPLines(options?.mcpTools);
 	const components = ['capabilities'];
 	const sections: string[] = [];
@@ -64,13 +65,10 @@ export function buildCapabilitySummary(options?: {
 }
 
 function buildSkillLines(
-	providedSkills: DiscoveredSkill[] | undefined,
+	providedSkills: DiscoveredSkill[],
 	skillSettings: OttoConfig['skills'] | undefined,
 ): string[] {
-	const skills = filterDiscoveredSkills(
-		providedSkills ?? getDiscoveredSkills(),
-		skillSettings,
-	);
+	const skills = filterDiscoveredSkills(providedSkills, skillSettings);
 	const seen = new Set<string>();
 	const unique: DiscoveredSkill[] = [];
 
@@ -81,7 +79,14 @@ function buildSkillLines(
 		unique.push(skill);
 	}
 
-	unique.sort((a, b) => a.name.localeCompare(b.name));
+	unique.sort((a, b) => {
+		const aExplicitlyEnabled = skillSettings?.items?.[a.name]?.enabled === true;
+		const bExplicitlyEnabled = skillSettings?.items?.[b.name]?.enabled === true;
+		if (aExplicitlyEnabled !== bExplicitlyEnabled) {
+			return aExplicitlyEnabled ? -1 : 1;
+		}
+		return a.name.localeCompare(b.name);
+	});
 
 	const visible = unique.slice(0, MAX_SKILLS).map((skill) => {
 		const summary = finalizeSentence(summarizeDescription(skill.description));

package/src/runtime/provider/custom.ts

@@ -0,0 +1,73 @@
+import {
+	getConfiguredProviderApiKey,
+	normalizeOllamaBaseURL,
+	resolveOpenAIResponsesModel,
+	type getProviderDefinition,
+	type OttoConfig,
+} from '@ottocode/sdk';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { createOllama } from 'ai-sdk-ollama';
+
+export 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 resolveOpenAIResponsesModel(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/index.ts

@@ -1,16 +1,5 @@
 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 { getProviderDefinition, isBuiltInProviderId } from '@ottocode/sdk';
 import { getAnthropicInstance } from './anthropic.ts';
 import { resolveOpenAIModel } from './openai.ts';
 import { resolveGoogleModel } from './google.ts';
@@ -25,6 +14,7 @@ import { resolveOpencodeModel } from './opencode.ts';
 import { getMoonshotInstance } from './moonshot.ts';
 import { getMinimaxInstance } from './minimax.ts';
 import { resolveCopilotModel } from './copilot.ts';
+import { resolveCustomConfiguredModel } from './custom.ts';
 
 export type ProviderName = ProviderId;
 
@@ -96,76 +86,3 @@ export async function resolveModel(
 	}
 	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-builders.ts

@@ -0,0 +1,280 @@
+import {
+	catalog,
+	getProviderDefinition,
+	isBuiltInProviderId,
+	type OttoConfig,
+	type ProviderId,
+	type ReasoningLevel,
+} from '@ottocode/sdk';
+import type { ReasoningConfigResult } from './reasoning.ts';
+
+const THINKING_BUDGET = 16000;
+
+type ReasoningBuilderArgs = {
+	cfg?: OttoConfig;
+	provider: ProviderId;
+	model: string;
+	reasoningLevel?: ReasoningLevel;
+	maxOutputTokens: number | undefined;
+};
+
+function normalizeReasoningLevel(
+	level: ReasoningLevel | undefined,
+): Exclude<ReasoningLevel, 'xhigh'> {
+	if (!level) return 'high';
+	if (level === 'xhigh') return 'high';
+	return level;
+}
+
+function toAnthropicEffort(
+	model: string,
+	level: ReasoningLevel | undefined,
+): 'low' | 'medium' | 'high' | 'xhigh' | 'max' {
+	switch (level) {
+		case 'minimal':
+		case 'low':
+			return 'low';
+		case 'medium':
+			return 'medium';
+		case 'max':
+			return 'max';
+		case 'xhigh':
+			return isClaudeOpus47(model) ? 'xhigh' : 'max';
+		default:
+			return 'high';
+	}
+}
+
+function toOpenAIEffort(
+	level: ReasoningLevel | undefined,
+): 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' {
+	switch (level) {
+		case 'minimal':
+			return 'minimal';
+		case 'low':
+			return 'low';
+		case 'medium':
+			return 'medium';
+		case 'max':
+		case 'xhigh':
+			return 'xhigh';
+		default:
+			return 'high';
+	}
+}
+
+function toGoogleThinkingLevel(
+	level: ReasoningLevel | undefined,
+): 'minimal' | 'low' | 'medium' | 'high' {
+	switch (level) {
+		case 'minimal':
+			return 'minimal';
+		case 'low':
+			return 'low';
+		case 'medium':
+			return 'medium';
+		default:
+			return 'high';
+	}
+}
+
+function toThinkingBudget(
+	level: ReasoningLevel | undefined,
+	maxOutputTokens: number | undefined,
+): number {
+	const cap = maxOutputTokens
+		? Math.max(maxOutputTokens, THINKING_BUDGET)
+		: THINKING_BUDGET;
+	switch (level) {
+		case 'minimal':
+			return Math.min(2048, cap);
+		case 'low':
+			return Math.min(4096, cap);
+		case 'medium':
+			return Math.min(8192, cap);
+		case 'max':
+		case 'xhigh':
+			return Math.min(24000, cap);
+		default:
+			return Math.min(16000, cap);
+	}
+}
+
+function toCamelCaseKey(value: string): string {
+	return value
+		.replace(/[^a-zA-Z0-9]+/g, ' ')
+		.trim()
+		.split(/\s+/)
+		.map((segment, index) => {
+			const lower = segment.toLowerCase();
+			if (index === 0) return lower;
+			return lower.charAt(0).toUpperCase() + lower.slice(1);
+		})
+		.join('');
+}
+
+function getOpenAICompatibleProviderOptionKeys(
+	provider: ProviderId,
+	cfg?: OttoConfig,
+): string[] {
+	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
+	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
+	const keys = new Set<string>(['openaiCompatible', toCamelCaseKey(provider)]);
+	const label = definition?.label ?? entry?.label;
+	if (label) {
+		keys.add(toCamelCaseKey(label));
+	}
+	return Array.from(keys).filter(Boolean);
+}
+
+function buildSharedProviderOptions(
+	provider: ProviderId,
+	options: Record<string, unknown>,
+	cfg?: OttoConfig,
+): Record<string, unknown> {
+	const keys = getOpenAICompatibleProviderOptionKeys(provider, cfg);
+	return Object.fromEntries(keys.map((key) => [key, options]));
+}
+
+export function isClaudeOpus47(model: string): boolean {
+	const lower = model.toLowerCase();
+	return lower.includes('claude-opus-4-7') || lower.includes('claude-opus-4.7');
+}
+
+function usesAdaptiveAnthropicThinking(model: string): boolean {
+	const lower = model.toLowerCase();
+	return (
+		isClaudeOpus47(model) ||
+		lower.includes('claude-opus-4-6') ||
+		lower.includes('claude-opus-4.6') ||
+		lower.includes('claude-sonnet-4-6') ||
+		lower.includes('claude-sonnet-4.6')
+	);
+}
+
+export function buildAnthropicReasoningOptions({
+	model,
+	reasoningLevel,
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	if (usesAdaptiveAnthropicThinking(model)) {
+		const thinking = isClaudeOpus47(model)
+			? { type: 'adaptive', display: 'summarized' }
+			: { type: 'adaptive' };
+
+		return {
+			providerOptions: {
+				anthropic: {
+					thinking,
+					effort: toAnthropicEffort(model, reasoningLevel),
+				},
+			},
+			effectiveMaxOutputTokens: maxOutputTokens,
+			enabled: true,
+		};
+	}
+
+	const thinkingBudget = toThinkingBudget(reasoningLevel, maxOutputTokens);
+
+	return {
+		providerOptions: {
+			anthropic: {
+				thinking: { type: 'enabled', budgetTokens: thinkingBudget },
+			},
+		},
+		effectiveMaxOutputTokens:
+			maxOutputTokens && maxOutputTokens > thinkingBudget
+				? maxOutputTokens - thinkingBudget
+				: maxOutputTokens,
+		enabled: true,
+	};
+}
+
+export function buildOpenAIReasoningOptions({
+	reasoningLevel,
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	return {
+		providerOptions: {
+			openai: {
+				reasoningEffort: toOpenAIEffort(reasoningLevel),
+				reasoningSummary: 'auto',
+			},
+		},
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: true,
+	};
+}
+
+export function buildGoogleReasoningOptions({
+	model,
+	reasoningLevel,
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	const isGemini3 = model.includes('gemini-3');
+	return {
+		providerOptions: {
+			google: {
+				thinkingConfig: isGemini3
+					? {
+							thinkingLevel: toGoogleThinkingLevel(reasoningLevel),
+							includeThoughts: true,
+						}
+					: {
+							thinkingBudget: toThinkingBudget(reasoningLevel, maxOutputTokens),
+							includeThoughts: true,
+						},
+			},
+		},
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: true,
+	};
+}
+
+export function buildOllamaReasoningOptions({
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	return {
+		providerOptions: {
+			ollama: {
+				think: true,
+			},
+		},
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: true,
+	};
+}
+
+export function buildOpenRouterReasoningOptions({
+	reasoningLevel,
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	return {
+		providerOptions: {
+			openrouter: {
+				reasoning: { effort: normalizeReasoningLevel(reasoningLevel) },
+			},
+		},
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: true,
+	};
+}
+
+export function buildOpenAICompatibleReasoningOptions({
+	cfg,
+	provider,
+	reasoningLevel,
+	maxOutputTokens,
+}: ReasoningBuilderArgs): ReasoningConfigResult {
+	return {
+		providerOptions: buildSharedProviderOptions(
+			provider,
+			{
+				reasoningEffort: normalizeReasoningLevel(reasoningLevel),
+			},
+			cfg,
+		),
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: true,
+	};
+}