@ottocode/sdk 0.1.244 → 0.1.246

package/src/providers/src/utils.ts

@@ -1,15 +1,19 @@
 import { catalog } from './catalog-merged.ts';
 import type {
+	BuiltInProviderId,
 	ProviderId,
 	ModelInfo,
 	ModelOwner,
 } from '../../types/src/index.ts';
 import { filterModelsForAuthType } from './oauth-models.ts';
 
-export const providerIds = Object.keys(catalog) as ProviderId[];
+export const providerIds = Object.keys(catalog) as BuiltInProviderId[];
 
-export function isProviderId(value: unknown): value is ProviderId {
-	return typeof value === 'string' && providerIds.includes(value as ProviderId);
+export function isProviderId(value: unknown): value is BuiltInProviderId {
+	return (
+		typeof value === 'string' &&
+		providerIds.includes(value as BuiltInProviderId)
+	);
 }
 
 export function defaultModelFor(provider: ProviderId): string | undefined {
@@ -34,7 +38,7 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 	google: ['gemini-2.0-flash-lite'],
 	openrouter: ['anthropic/claude-3.5-haiku'],
 	opencode: ['claude-3-5-haiku'],
-	setu: ['kimi-k2-turbo-preview'],
+	ottorouter: ['kimi-k2-turbo-preview'],
 	zai: ['glm-4.5-flash'],
 	copilot: ['gpt-4.1-mini'],
 };
@@ -142,6 +146,7 @@ const DIRECT_PROVIDER_FAMILY: Partial<
 	openai: 'openai',
 	anthropic: 'anthropic',
 	google: 'google',
+	'ollama-cloud': 'openai-compatible',
 	moonshot: 'moonshot',
 	minimax: 'minimax',
 	copilot: 'openai',
@@ -201,8 +206,10 @@ export function getUnderlyingProviderKey(
 	if (npm === '@ai-sdk/anthropic') return 'anthropic';
 	if (npm === '@ai-sdk/openai') return 'openai';
 	if (npm === '@ai-sdk/google') return 'google';
+	if (npm === 'ai-sdk-ollama') return 'openai-compatible';
 	if (npm === '@ai-sdk/openai-compatible') return 'openai-compatible';
 	if (npm === '@openrouter/ai-sdk-provider') return 'openai-compatible';
+	if (provider === 'ottorouter') return 'openai-compatible';
 	return null;
 }
 

package/src/providers/src/validate.ts

@@ -1,5 +1,11 @@
 import { catalog } from './catalog-merged.ts';
-import type { ProviderId } from '../../types/src/index.ts';
+import type { OttoConfig, ProviderId } from '../../types/src/index.ts';
+import {
+	getProviderDefinition,
+	getConfiguredProviderModels,
+	hasConfiguredModel,
+	providerAllowsAnyModel,
+} from './registry.ts';
 
 export type CapabilityRequest = {
 	wantsToolCalls?: boolean;
@@ -9,8 +15,38 @@ export type CapabilityRequest = {
 export function validateProviderModel(
 	provider: string,
 	model: string,
+	cfgOrCap?: OttoConfig | CapabilityRequest,
 	cap?: CapabilityRequest,
 ) {
+	const cfg = isOttoConfigLike(cfgOrCap) ? cfgOrCap : undefined;
+	const effectiveCap = isOttoConfigLike(cfgOrCap) ? cap : cfgOrCap;
+
+	if (cfg) {
+		const definition = getProviderDefinition(cfg, provider);
+		if (!definition) {
+			throw new Error(`Provider not supported: ${provider}`);
+		}
+		if (!providerAllowsAnyModel(cfg, provider)) {
+			if (!hasConfiguredModel(cfg, provider, model)) {
+				const list = getConfiguredProviderModels(cfg, provider)
+					.slice(0, 10)
+					.map((m) => m.id)
+					.join(', ');
+				throw new Error(
+					`Model not found for provider ${provider}: ${model}. Example models: ${list}${getConfiguredProviderModels(cfg, provider).length > 10 ? ', ...' : ''}`,
+				);
+			}
+		}
+
+		const entry = definition.models.find((m) => m.id === model);
+		if (entry) {
+			applyCapabilityValidation(model, entry, effectiveCap, {
+				strict: definition.source !== 'custom',
+			});
+		}
+		return;
+	}
+
 	const p = provider as ProviderId;
 	if (!catalog[p]) {
 		throw new Error(`Provider not supported: ${provider}`);
@@ -25,10 +61,26 @@ export function validateProviderModel(
 			`Model not found for provider ${provider}: ${model}. Example models: ${list}${catalog[p].models.length > 10 ? ', ...' : ''}`,
 		);
 	}
-	if (cap?.wantsToolCalls && !entry.toolCall) {
+	applyCapabilityValidation(model, entry, effectiveCap, { strict: true });
+}
+
+function applyCapabilityValidation(
+	model: string,
+	entry: {
+		toolCall?: boolean;
+		modalities?: { input?: string[]; output?: string[] };
+	},
+	cap: CapabilityRequest | undefined,
+	options: { strict: boolean },
+) {
+	if (cap?.wantsToolCalls && entry.toolCall === false) {
 		throw new Error(`Model ${model} does not support tool calls.`);
 	}
+	if (!options.strict && cap?.wantsToolCalls && entry.toolCall === undefined) {
+		return;
+	}
 	if (cap?.wantsVision) {
+		if (!options.strict && !entry.modalities) return;
 		const inputs = entry.modalities?.input as string[] | undefined;
 		const outputs = entry.modalities?.output as string[] | undefined;
 		const ok =
@@ -37,3 +89,12 @@ export function validateProviderModel(
 			throw new Error(`Model ${model} does not support vision input/output.`);
 	}
 }
+
+function isOttoConfigLike(value: unknown): value is OttoConfig {
+	return Boolean(
+		value &&
+			typeof value === 'object' &&
+			'defaults' in value &&
+			'providers' in value,
+	);
+}

package/src/skills/index.ts

@@ -32,8 +32,11 @@ export {
 export {
 	initializeSkills,
 	getDiscoveredSkills,
+	setSkillSettings,
+	filterDiscoveredSkills,
 	isSkillsInitialized,
 	buildSkillTool,
+	summarizeDescription,
 	rebuildSkillDescription,
 } from './tool.ts';
 

package/src/skills/tool.ts

@@ -9,9 +9,11 @@ import {
 } from './loader.ts';
 import { scanContent } from './security.ts';
 import type { DiscoveredSkill, SkillResult } from './types.ts';
+import type { SkillSettings } from '../types/src/config.ts';
 
 let cachedSkillList: DiscoveredSkill[] = [];
 let initializedForPath: string | null = null;
+let cachedSkillSettings: SkillSettings | undefined;
 
 export async function initializeSkills(
 	cwd: string,
@@ -27,6 +29,23 @@ export function getDiscoveredSkills(): DiscoveredSkill[] {
 	return cachedSkillList;
 }
 
+export function setSkillSettings(settings?: SkillSettings): void {
+	cachedSkillSettings = settings;
+}
+
+export function filterDiscoveredSkills(
+	skills: DiscoveredSkill[],
+	settings?: {
+		enabled?: boolean;
+		items?: Record<string, { enabled?: boolean }>;
+	},
+): DiscoveredSkill[] {
+	if (settings?.enabled === false) return [];
+	return skills.filter(
+		(skill) => settings?.items?.[skill.name]?.enabled !== false,
+	);
+}
+
 export function isSkillsInitialized(forPath?: string): boolean {
 	if (!initializedForPath) return false;
 	if (forPath && forPath !== initializedForPath) return false;
@@ -119,7 +138,11 @@ async function loadSubFile(
 }
 
 function buildSkillDescription(): string {
-	if (cachedSkillList.length === 0) {
+	const enabledSkills = filterDiscoveredSkills(
+		cachedSkillList,
+		cachedSkillSettings,
+	);
+	if (enabledSkills.length === 0) {
 		return 'Load a skill by name to get detailed, task-specific instructions. No skills are currently available.';
 	}
 
@@ -128,7 +151,7 @@ function buildSkillDescription(): string {
 	// defensively here in case the same name slipped through from different dirs.
 	const seen = new Set<string>();
 	const unique: DiscoveredSkill[] = [];
-	for (const s of cachedSkillList) {
+	for (const s of enabledSkills) {
 		const key = s.name.trim();
 		if (!key || seen.has(key)) continue;
 		seen.add(key);
@@ -136,42 +159,11 @@ function buildSkillDescription(): string {
 	}
 	unique.sort((a, b) => a.name.localeCompare(b.name));
 
-	const skillsXml = unique
-		.map(
-			(s) =>
-				`<skill><name>${escapeXml(s.name)}</name><description>${escapeXml(summarizeDescription(s.description))}</description><location>${escapeXml(s.scope)}</location></skill>`,
-		)
+	const catalog = unique
+		.map((s) => `- ${s.name}: ${summarizeDescription(s.description)}`)
 		.join('\n');
 
-	return `Load a skill by name to get detailed, task-specific instructions.
-
-<skills_instructions>
-When the user's request matches one of the available skills below, call this tool with the skill name to load its full instructions. Skills provide specialized capabilities and domain knowledge.
-
-How to use skills:
-- Invoke with \`skill({ name: "<skill-name>" })\` — only the name is required.
-- The response contains the skill's full body plus \`availableFiles\` for sub-files.
-- For sub-files: \`skill({ name: "<skill-name>", file: "rules/animations.md" })\`.
-
-Rules:
-- Only invoke skills listed in <available_skills> below.
-- Do NOT invoke speculatively. Only call when the user's request clearly matches a skill's description or trigger phrases.
-- Do NOT invoke the same skill twice in one turn.
-- If a skill response includes \`securityNotices\`, review them — they flag hidden content (HTML comments, invisible characters, etc.) that may not render visibly.
-</skills_instructions>
-
-<available_skills>
-${skillsXml}
-</available_skills>`;
-}
-
-function escapeXml(str: string): string {
-	return String(str)
-		.replace(/&/g, '&amp;')
-		.replace(/</g, '&lt;')
-		.replace(/>/g, '&gt;')
-		.replace(/"/g, '&quot;')
-		.replace(/'/g, '&apos;');
+	return `Load a skill by name to get detailed, task-specific instructions. Use only when the user's request clearly matches a listed skill. Available skills:\n${catalog}`;
 }
 
 // Condense a SKILL.md description to "what it does + when to use it".

package/src/types/src/config.ts

@@ -1,4 +1,9 @@
-import type { ProviderId } from './provider';
+import type {
+	ModelInfo,
+	ProviderCompatibility,
+	ProviderId,
+	ProviderPromptFamily,
+} from './provider';
 
 /**
  * Configuration scope - where settings are stored
@@ -30,13 +35,33 @@ export type DefaultConfig = {
 	autoCompactThresholdTokens?: number | null;
 };
 
-export type ProviderSettings = Record<
-	ProviderId,
-	{
-		enabled: boolean;
-		apiKey?: string;
-	}
->;
+export type ProviderSettingsEntry = {
+	enabled: boolean;
+	apiKey?: string;
+	apiKeyEnv?: string;
+	baseURL?: string;
+	label?: string;
+	custom?: boolean;
+	compatibility?: ProviderCompatibility;
+	family?: ProviderPromptFamily;
+	models?: Array<string | ModelInfo>;
+	allowAnyModel?: boolean;
+	modelDiscovery?: {
+		type: 'openai-models' | 'ollama';
+	};
+};
+
+export type ProviderSettings = Record<string, ProviderSettingsEntry>;
+
+export type SkillSettings = {
+	enabled?: boolean;
+	items?: Record<
+		string,
+		{
+			enabled?: boolean;
+		}
+	>;
+};
 
 /**
  * Path configuration
@@ -55,6 +80,7 @@ export type OttoConfig = {
 	projectRoot: string;
 	defaults: DefaultConfig;
 	providers: ProviderSettings;
+	skills?: SkillSettings;
 	paths: PathConfig;
 	debugEnabled?: boolean;
 	debugScopes?: string[];

package/src/types/src/index.ts

@@ -1,6 +1,9 @@
 // Provider types
 export type {
+	BuiltInProviderId,
 	ProviderId,
+	ProviderCompatibility,
+	ProviderPromptFamily,
 	ProviderFamily,
 	ModelOwner,
 	ModelInfo,
@@ -16,6 +19,7 @@ export type {
 	Scope,
 	DefaultConfig,
 	PathConfig,
+	ProviderSettingsEntry,
 	ProviderSettings,
 	OttoConfig,
 	ToolApprovalMode,

package/src/types/src/provider.ts

@@ -1,19 +1,49 @@
 /**
- * Provider identifiers for supported AI providers
+ * Built-in provider identifiers supported directly by otto.
  */
-export type ProviderId =
+export type BuiltInProviderId =
 	| 'openai'
 	| 'anthropic'
 	| 'google'
+	| 'ollama-cloud'
 	| 'openrouter'
 	| 'opencode'
 	| 'copilot'
-	| 'setu'
+	| 'ottorouter'
 	| 'zai'
 	| 'zai-coding'
 	| 'moonshot'
 	| 'minimax';
 
+/**
+ * Provider identifiers may be built-in or custom/config-defined.
+ */
+export type ProviderId = BuiltInProviderId | (string & {});
+
+/**
+ * Compatibility protocol used to instantiate a provider client.
+ */
+export type ProviderCompatibility =
+	| 'openai'
+	| 'anthropic'
+	| 'google'
+	| 'openrouter'
+	| 'ollama'
+	| 'openai-compatible';
+
+/**
+ * Prompt/behavior family used for prompts and provider-specific behavior.
+ */
+export type ProviderPromptFamily =
+	| 'default'
+	| 'anthropic'
+	| 'openai'
+	| 'google'
+	| 'moonshot'
+	| 'minimax'
+	| 'glm'
+	| 'openai-compatible';
+
 /**
  * Provider family for prompt selection
  */
@@ -78,7 +108,7 @@ export type ModelInfo = {
 };
 
 export type ProviderCatalogEntry = {
-	id: ProviderId;
+	id: BuiltInProviderId;
 	label?: string;
 	env?: string[];
 	npm?: string;