@ottocode/sdk 0.1.244 → 0.1.246

package/src/providers/src/env.ts

@@ -1,24 +1,28 @@
-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',
-	setu: 'SETU_PRIVATE_KEY',
+	ottorouter: 'OTTOROUTER_PRIVATE_KEY',
 	zai: 'ZAI_API_KEY',
 	'zai-coding': 'ZAI_CODING_API_KEY',
 	moonshot: 'MOONSHOT_API_KEY',
 	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,26 +24,49 @@ 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';
 export {
-	createSetu,
-	createSetuFetch,
-	createSetuModel,
-	fetchSetuBalance,
+	createOttoRouter,
+	createOttoRouterFetch,
+	createOttoRouterModel,
+	fetchOttoRouterBalance,
 	getPublicKeyFromPrivate,
 	fetchSolanaUsdcBalance,
-} from './setu-client.ts';
+} from './ottorouter-client.ts';
 export type {
-	SetuAuth,
-	SetuInstance,
-	SetuProviderOptions,
-	SetuPaymentCallbacks,
-	SetuBalanceUpdate,
-	SetuBalanceResponse,
+	OttoRouterAuth,
+	OttoRouterInstance,
+	OttoRouterProviderOptions,
+	OttoRouterPaymentCallbacks,
+	OttoRouterBalanceUpdate,
+	OttoRouterBalanceResponse,
 	SolanaUsdcBalanceResponse,
-} from './setu-client.ts';
+} from './ottorouter-client.ts';
 export {
 	createOpenAIOAuthFetch,
 	createOpenAIOAuthModel,

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/{setu-client.ts → ottorouter-client.ts}

@@ -1,29 +1,29 @@
 import {
-	createSetu,
+	createOttoRouter,
 	fetchBalance,
 	fetchWalletUsdcBalance,
 	getPublicKeyFromPrivate as _getPublicKeyFromPrivate,
-	type SetuConfig,
+	type OttoRouterConfig,
 	type PaymentCallbacks,
 	type BalanceUpdate,
 	type BalanceResponse,
 	type WalletUsdcBalance,
-	type SetuAuth as _SetuAuth,
-	type SetuInstance,
-} from '@ottocode/ai-sdk';
+	type OttoRouterAuth as _OttoRouterAuth,
+	type OttoRouterInstance,
+} from '@ottorouter/ai-sdk';
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 
-export type SetuBalanceUpdate = BalanceUpdate;
+export type OttoRouterBalanceUpdate = BalanceUpdate;
 
-export type SetuPaymentCallbacks = PaymentCallbacks;
+export type OttoRouterPaymentCallbacks = PaymentCallbacks;
 
-export type SetuProviderOptions = {
+export type OttoRouterProviderOptions = {
 	baseURL?: string;
 	rpcURL?: string;
 	network?: string;
 	maxRequestAttempts?: number;
 	maxPaymentAttempts?: number;
-	callbacks?: SetuPaymentCallbacks;
+	callbacks?: OttoRouterPaymentCallbacks;
 	providerNpm?: string;
 	promptCacheKey?: string;
 	promptCacheRetention?: 'in_memory' | '24h';
@@ -32,33 +32,33 @@ export type SetuProviderOptions = {
 	middleware?: LanguageModelV3Middleware | LanguageModelV3Middleware[];
 };
 
-export type SetuAuth = _SetuAuth;
+export type OttoRouterAuth = _OttoRouterAuth;
 
-export type SetuBalanceResponse = BalanceResponse;
+export type OttoRouterBalanceResponse = BalanceResponse;
 
 export type SolanaUsdcBalanceResponse = WalletUsdcBalance;
 
-export function createSetuFetch(
-	auth: SetuAuth,
-	options: SetuProviderOptions = {},
+export function createOttoRouterFetch(
+	auth: OttoRouterAuth,
+	options: OttoRouterProviderOptions = {},
 ): typeof fetch {
-	const setu = createSetu(buildSetuConfig(auth, options));
-	return setu.fetch() as typeof fetch;
+	const ottorouter = createOttoRouter(buildOttoRouterConfig(auth, options));
+	return ottorouter.fetch() as typeof fetch;
 }
 
-export function createSetuModel(
+export function createOttoRouterModel(
 	model: string,
-	auth: SetuAuth,
-	options: SetuProviderOptions = {},
+	auth: OttoRouterAuth,
+	options: OttoRouterProviderOptions = {},
 ) {
-	const setu = createSetu(buildSetuConfig(auth, options));
-	return setu.model(model);
+	const ottorouter = createOttoRouter(buildOttoRouterConfig(auth, options));
+	return ottorouter.model(model);
 }
 
-function buildSetuConfig(
-	auth: SetuAuth,
-	options: SetuProviderOptions = {},
-): SetuConfig {
+function buildOttoRouterConfig(
+	auth: OttoRouterAuth,
+	options: OttoRouterProviderOptions = {},
+): OttoRouterConfig {
 	return {
 		auth,
 		baseURL: options.baseURL,
@@ -78,10 +78,10 @@ function buildSetuConfig(
 	};
 }
 
-export async function fetchSetuBalance(
-	auth: SetuAuth,
+export async function fetchOttoRouterBalance(
+	auth: OttoRouterAuth,
 	baseURL?: string,
-): Promise<SetuBalanceResponse | null> {
+): Promise<OttoRouterBalanceResponse | null> {
 	return fetchBalance(auth, baseURL);
 }
 
@@ -90,7 +90,7 @@ export function getPublicKeyFromPrivate(privateKey: string): string | null {
 }
 
 export async function fetchSolanaUsdcBalance(
-	auth: SetuAuth,
+	auth: OttoRouterAuth,
 	network: 'mainnet' | 'devnet' = 'mainnet',
 ): Promise<SolanaUsdcBalanceResponse | null> {
 	if (auth.privateKey) {
@@ -105,4 +105,4 @@ export async function fetchSolanaUsdcBalance(
 	return null;
 }
 
-export { createSetu, type SetuInstance };
+export { createOttoRouter, type OttoRouterInstance };

package/src/providers/src/pricing.ts

@@ -70,13 +70,16 @@ 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
 	],
 	opencode: [
 		// Pricing from catalog entries; leave empty here
 	],
-	setu: [
+	ottorouter: [
 		// Pricing from catalog entries; leave empty here
 	],
 	zai: [

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;
+}