@ottocode/sdk 0.1.245 → 0.1.246

package/src/providers/src/env.ts

@@ -1,9 +1,10 @@
-import type { ProviderId } from '../../types/src/index.ts';
+import type { BuiltInProviderId, ProviderId } from '../../types/src/index.ts';
 
-const ENV_VARS: Record<ProviderId, string> = {
+const ENV_VARS: Record<BuiltInProviderId, string> = {
 	openai: 'OPENAI_API_KEY',
 	anthropic: 'ANTHROPIC_API_KEY',
 	google: 'GOOGLE_GENERATIVE_AI_API_KEY',
+	'ollama-cloud': 'OLLAMA_API_KEY',
 	openrouter: 'OPENROUTER_API_KEY',
 	opencode: 'OPENCODE_API_KEY',
 	copilot: 'GITHUB_TOKEN',
@@ -14,11 +15,14 @@ const ENV_VARS: Record<ProviderId, string> = {
 	minimax: 'MINIMAX_API_KEY',
 };
 
-export function providerEnvVar(provider: ProviderId): string {
-	return ENV_VARS[provider];
+export function providerEnvVar(provider: ProviderId): string | undefined {
+	return ENV_VARS[provider as BuiltInProviderId];
 }
 
 export function readEnvKey(provider: ProviderId): string | undefined {
+	if (!(provider in ENV_VARS) && provider !== 'copilot') {
+		return undefined;
+	}
 	if (provider === 'copilot') {
 		const copilotToken =
 			process.env.COPILOT_GITHUB_TOKEN ??
@@ -28,13 +32,14 @@ export function readEnvKey(provider: ProviderId): string | undefined {
 	}
 
 	const key = providerEnvVar(provider);
+	if (!key) return undefined;
 	const value = process.env[key];
 	return value?.length ? value : undefined;
 }
 
 export function setEnvKey(provider: ProviderId, value: string | undefined) {
 	const key = providerEnvVar(provider);
-	if (value) {
+	if (key && value) {
 		process.env[key] = value;
 	}
 }

package/src/providers/src/index.ts

@@ -1,7 +1,10 @@
 export { isProviderAuthorized, ensureProviderEnv } from './authorization.ts';
 export { catalog } from './catalog-merged.ts';
 export type {
+	BuiltInProviderId,
 	ProviderId,
+	ProviderCompatibility,
+	ProviderPromptFamily,
 	ModelInfo,
 	ModelProviderBinding,
 	ProviderCatalogEntry,
@@ -21,6 +24,29 @@ export {
 	modelSupportsReasoning,
 } from './utils.ts';
 export type { UnderlyingProviderKey } from './utils.ts';
+export {
+	discoverOllamaModels,
+	normalizeOllamaBaseURL,
+} from './ollama-discovery.ts';
+export type {
+	DiscoverOllamaOptions,
+	DiscoverOllamaResult,
+} from './ollama-discovery.ts';
+export {
+	isBuiltInProviderId,
+	getProviderSettings,
+	getProviderDefinition,
+	hasConfiguredProvider,
+	getConfiguredProviderIds,
+	getConfiguredProviderModels,
+	getConfiguredProviderDefaultModel,
+	providerAllowsAnyModel,
+	hasConfiguredModel,
+	getConfiguredProviderFamily,
+	getConfiguredProviderEnvVar,
+	getConfiguredProviderApiKey,
+} from './registry.ts';
+export type { ResolvedProviderDefinition } from './registry.ts';
 export { validateProviderModel } from './validate.ts';
 export { estimateModelCostUsd } from './pricing.ts';
 export { providerEnvVar, readEnvKey, setEnvKey } from './env.ts';

package/src/providers/src/ollama-discovery.ts

@@ -0,0 +1,149 @@
+import type { ModelInfo } from '../../types/src/index.ts';
+
+export type DiscoverOllamaOptions = {
+	baseURL: string;
+	apiKey?: string;
+	fetch?: typeof globalThis.fetch;
+	includeDetails?: boolean;
+};
+
+export type DiscoverOllamaResult = {
+	baseURL: string;
+	models: ModelInfo[];
+};
+
+type OllamaTagsResponse = {
+	models?: Array<
+		{
+			name?: string;
+			model?: string;
+		} & Record<string, unknown>
+	>;
+};
+
+type OllamaShowResponse = {
+	capabilities?: string[];
+	details?: {
+		family?: string;
+		parameter_size?: string;
+		quantization_level?: string;
+	};
+	model_info?: Record<string, unknown>;
+};
+
+export function normalizeOllamaBaseURL(baseURL: string): string {
+	const trimmed = baseURL.trim().replace(/\/$/, '');
+	return trimmed
+		.replace(/\/api\/(chat|generate|embed|show|tags)\/?$/, '')
+		.replace(/\/api\/?$/, '');
+}
+
+export async function discoverOllamaModels(
+	options: DiscoverOllamaOptions,
+): Promise<DiscoverOllamaResult> {
+	const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+	const baseURL = normalizeOllamaBaseURL(options.baseURL);
+	const headers = buildHeaders(options.apiKey);
+
+	const tagsResponse = await fetchImpl(`${baseURL}/api/tags`, {
+		method: 'GET',
+		headers,
+	});
+	if (!tagsResponse.ok) {
+		throw new Error(`Failed to fetch Ollama models: ${tagsResponse.status}`);
+	}
+	const tagsPayload = (await tagsResponse.json()) as OllamaTagsResponse;
+	const ids = (tagsPayload.models ?? [])
+		.map((model) => String(model.name ?? model.model ?? '').trim())
+		.filter(Boolean);
+
+	if (options.includeDetails === false) {
+		return {
+			baseURL,
+			models: ids.map((id) => ({ id, label: id })),
+		};
+	}
+
+	const models = await Promise.all(
+		ids.map(
+			async (id) =>
+				await discoverSingleOllamaModel(fetchImpl, baseURL, headers, id),
+		),
+	);
+
+	return {
+		baseURL,
+		models: models.filter((model): model is ModelInfo => Boolean(model)),
+	};
+}
+
+async function discoverSingleOllamaModel(
+	fetchImpl: typeof globalThis.fetch,
+	baseURL: string,
+	headers: HeadersInit | undefined,
+	id: string,
+): Promise<ModelInfo> {
+	try {
+		const response = await fetchImpl(`${baseURL}/api/show`, {
+			method: 'POST',
+			headers: {
+				'content-type': 'application/json',
+				...(headers ?? {}),
+			},
+			body: JSON.stringify({ model: id }),
+		});
+		if (!response.ok) return { id, label: id };
+		const payload = (await response.json()) as OllamaShowResponse;
+		return mapOllamaShowResponse(id, payload);
+	} catch {
+		return { id, label: id };
+	}
+}
+
+function mapOllamaShowResponse(
+	id: string,
+	payload: OllamaShowResponse,
+): ModelInfo {
+	const capabilities = new Set(
+		(payload.capabilities ?? []).map((cap) => cap.toLowerCase()),
+	);
+	const inputModalities = ['text'];
+	if (capabilities.has('vision')) inputModalities.push('image');
+	if (capabilities.has('audio')) inputModalities.push('audio');
+
+	const contextLength = extractContextLength(payload.model_info);
+	const parameterSize = payload.details?.parameter_size;
+	const quantization = payload.details?.quantization_level;
+	const labelParts = [id];
+	if (parameterSize) labelParts.push(parameterSize);
+	if (quantization) labelParts.push(quantization);
+
+	return {
+		id,
+		label: labelParts.join(' · '),
+		toolCall: capabilities.has('tools'),
+		reasoningText: capabilities.has('thinking'),
+		modalities: {
+			input: inputModalities,
+			output: ['text'],
+		},
+		limit: contextLength ? { context: contextLength } : undefined,
+	};
+}
+
+function extractContextLength(
+	modelInfo: Record<string, unknown> | undefined,
+): number | undefined {
+	if (!modelInfo) return undefined;
+	for (const [key, value] of Object.entries(modelInfo)) {
+		if (!key.endsWith('.context_length')) continue;
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed > 0) return parsed;
+	}
+	return undefined;
+}
+
+function buildHeaders(apiKey?: string): HeadersInit | undefined {
+	if (!apiKey) return undefined;
+	return { Authorization: `Bearer ${apiKey}` };
+}

package/src/providers/src/pricing.ts

@@ -70,6 +70,9 @@ const pricingTable: Record<ProviderName, PricingEntry[]> = {
 			outputPerMillion: 10.5,
 		},
 	],
+	'ollama-cloud': [
+		// Pricing can vary by your Ollama Cloud model/account; leave undefined here
+	],
 	openrouter: [
 		// Prefer catalog pricing; keep empty to defer to catalog or undefined
 	],

package/src/providers/src/registry.ts

@@ -0,0 +1,258 @@
+import { catalog } from './catalog-merged.ts';
+import { providerEnvVar } from './env.ts';
+import { getUnderlyingProviderKey, providerIds } from './utils.ts';
+import type {
+	BuiltInProviderId,
+	ModelInfo,
+	OttoConfig,
+	ProviderCompatibility,
+	ProviderId,
+	ProviderPromptFamily,
+	ProviderSettingsEntry,
+} from '../../types/src/index.ts';
+
+export type ResolvedProviderDefinition = {
+	id: ProviderId;
+	label: string;
+	source: 'built-in' | 'custom';
+	compatibility: ProviderCompatibility;
+	family: ProviderPromptFamily;
+	baseURL?: string;
+	apiKey?: string;
+	apiKeyEnv?: string;
+	models: ModelInfo[];
+	allowAnyModel: boolean;
+};
+
+const BUILTIN_COMPATIBILITY: Record<BuiltInProviderId, ProviderCompatibility> =
+	{
+		openai: 'openai',
+		anthropic: 'anthropic',
+		google: 'google',
+		'ollama-cloud': 'ollama',
+		openrouter: 'openrouter',
+		opencode: 'openai-compatible',
+		copilot: 'openai',
+		ottorouter: 'openrouter',
+		zai: 'openai-compatible',
+		'zai-coding': 'openai-compatible',
+		moonshot: 'openai-compatible',
+		minimax: 'anthropic',
+	};
+
+const BUILTIN_FAMILY: Record<BuiltInProviderId, ProviderPromptFamily> = {
+	openai: 'openai',
+	anthropic: 'anthropic',
+	google: 'google',
+	'ollama-cloud': 'openai-compatible',
+	openrouter: 'openai-compatible',
+	opencode: 'openai-compatible',
+	copilot: 'openai',
+	ottorouter: 'openai-compatible',
+	zai: 'glm',
+	'zai-coding': 'glm',
+	moonshot: 'moonshot',
+	minimax: 'minimax',
+};
+
+function normalizeCustomModels(
+	models: Array<string | ModelInfo> | undefined,
+): ModelInfo[] {
+	return (models ?? [])
+		.map((model) => {
+			if (typeof model === 'string') {
+				const id = String(model).trim();
+				return id ? ({ id, label: id } satisfies ModelInfo) : null;
+			}
+			const id = String(model.id ?? '').trim();
+			if (!id) return null;
+			return {
+				...model,
+				id,
+				label: model.label?.trim() || id,
+			} satisfies ModelInfo;
+		})
+		.filter((model): model is ModelInfo => Boolean(model));
+}
+
+function normalizeOptionalText(value: string | undefined): string | undefined {
+	if (!value) return undefined;
+	const trimmed = value.trim();
+	if (!trimmed || trimmed === 'undefined' || trimmed === 'null') {
+		return undefined;
+	}
+	return trimmed;
+}
+
+function resolveCustomCompatibility(
+	settings: ProviderSettingsEntry,
+): ProviderCompatibility {
+	return settings.compatibility ?? 'openai-compatible';
+}
+
+function resolveCustomFamily(
+	settings: ProviderSettingsEntry,
+): ProviderPromptFamily {
+	return settings.family ?? 'default';
+}
+
+function resolveCustomProviderLabel(
+	id: string,
+	settings: ProviderSettingsEntry,
+): string {
+	return settings.label ?? id;
+}
+
+export function isBuiltInProviderId(
+	value: unknown,
+): value is BuiltInProviderId {
+	return (
+		typeof value === 'string' &&
+		providerIds.includes(value as BuiltInProviderId)
+	);
+}
+
+export function getProviderSettings(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): ProviderSettingsEntry | undefined {
+	return cfg.providers[String(provider)];
+}
+
+export function getProviderDefinition(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): ResolvedProviderDefinition | undefined {
+	const settings = getProviderSettings(cfg, provider);
+	if (isBuiltInProviderId(provider)) {
+		const entry = catalog[provider];
+		if (!entry) return undefined;
+		return {
+			id: provider,
+			label: settings?.label ?? entry.label ?? provider,
+			source: 'built-in',
+			compatibility: BUILTIN_COMPATIBILITY[provider],
+			family: BUILTIN_FAMILY[provider],
+			baseURL: normalizeOptionalText(settings?.baseURL),
+			apiKey: normalizeOptionalText(settings?.apiKey),
+			apiKeyEnv:
+				normalizeOptionalText(settings?.apiKeyEnv) ?? providerEnvVar(provider),
+			models: entry.models,
+			allowAnyModel: provider === 'ollama-cloud',
+		};
+	}
+
+	if (!settings?.custom) return undefined;
+	const models = normalizeCustomModels(settings.models);
+	return {
+		id: provider,
+		label: resolveCustomProviderLabel(provider, settings),
+		source: 'custom',
+		compatibility: resolveCustomCompatibility(settings),
+		family: resolveCustomFamily(settings),
+		baseURL: normalizeOptionalText(settings.baseURL),
+		apiKey: normalizeOptionalText(settings.apiKey),
+		apiKeyEnv: normalizeOptionalText(settings.apiKeyEnv),
+		models,
+		allowAnyModel: settings.allowAnyModel === true || models.length === 0,
+	};
+}
+
+export function hasConfiguredProvider(
+	cfg: OttoConfig,
+	provider: ProviderId | undefined,
+): provider is ProviderId {
+	if (!provider || typeof provider !== 'string') return false;
+	const definition = getProviderDefinition(cfg, provider);
+	if (!definition) return false;
+	if (definition.source === 'built-in') return true;
+	return getProviderSettings(cfg, provider)?.enabled !== false;
+}
+
+export function getConfiguredProviderIds(
+	cfg: OttoConfig,
+	options?: { includeDisabled?: boolean },
+): ProviderId[] {
+	const includeDisabled = options?.includeDisabled === true;
+	const ids = new Set<ProviderId>([
+		...providerIds,
+		...Object.keys(cfg.providers),
+		cfg.defaults.provider,
+	]);
+	return Array.from(ids).filter((provider) => {
+		const definition = getProviderDefinition(cfg, provider);
+		if (!definition) return false;
+		if (definition.source === 'built-in') return true;
+		if (includeDisabled) return true;
+		return getProviderSettings(cfg, provider)?.enabled !== false;
+	});
+}
+
+export function getConfiguredProviderModels(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): ModelInfo[] {
+	return getProviderDefinition(cfg, provider)?.models ?? [];
+}
+
+export function getConfiguredProviderDefaultModel(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): string | undefined {
+	return getConfiguredProviderModels(cfg, provider)[0]?.id;
+}
+
+export function providerAllowsAnyModel(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): boolean {
+	return getProviderDefinition(cfg, provider)?.allowAnyModel === true;
+}
+
+export function hasConfiguredModel(
+	cfg: OttoConfig,
+	provider: ProviderId,
+	model: string | undefined,
+): boolean {
+	if (!model) return false;
+	const definition = getProviderDefinition(cfg, provider);
+	if (!definition) return false;
+	if (definition.allowAnyModel) return model.trim().length > 0;
+	return definition.models.some((entry) => entry.id === model);
+}
+
+export function getConfiguredProviderFamily(
+	cfg: OttoConfig,
+	provider: ProviderId,
+	model: string,
+): ProviderPromptFamily | null {
+	const definition = getProviderDefinition(cfg, provider);
+	if (!definition) return null;
+	if (definition.source === 'custom') return definition.family;
+	if (isBuiltInProviderId(provider)) {
+		return getUnderlyingProviderKey(provider, model) ?? definition.family;
+	}
+	return definition.family;
+}
+
+export function getConfiguredProviderEnvVar(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): string | undefined {
+	const definition = getProviderDefinition(cfg, provider);
+	return definition?.apiKeyEnv;
+}
+
+export function getConfiguredProviderApiKey(
+	cfg: OttoConfig,
+	provider: ProviderId,
+): string | undefined {
+	const definition = getProviderDefinition(cfg, provider);
+	if (!definition) return undefined;
+	if (definition.apiKey?.length) return definition.apiKey;
+	if (definition.apiKeyEnv?.length) {
+		const value = process.env[definition.apiKeyEnv];
+		if (value?.length) return value;
+	}
+	return undefined;
+}

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 {
@@ -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';