@vib-rato/ai 0.16.0

package/src/provider-models/bundled-references.ts

@@ -0,0 +1,38 @@
+import { getBundledModels, getBundledProviders } from "../models";
+import type { Api, Model } from "../types";
+
+export function createBundledReferenceMap<TApi extends Api>(
+	provider: Parameters<typeof getBundledModels>[0],
+): Map<string, Model<TApi>> {
+	const references = new Map<string, Model<TApi>>();
+	for (const model of getBundledModels(provider)) {
+		references.set(model.id, model as Model<TApi>);
+	}
+	return references;
+}
+
+export function createReferenceResolver<TApi extends Api>(
+	providerRefs: Map<string, Model<TApi>>,
+): (modelId: string) => Model<TApi> | undefined {
+	const globalRefs = new Map<string, Model<Api>>();
+	for (const provider of getBundledProviders()) {
+		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
+			const candidate = model as Model<Api>;
+			const existing = globalRefs.get(candidate.id);
+			if (!existing) {
+				globalRefs.set(candidate.id, candidate);
+			} else if (candidate.contextWindow !== existing.contextWindow) {
+				if (candidate.contextWindow > existing.contextWindow) {
+					globalRefs.set(candidate.id, candidate);
+				}
+			} else if (candidate.maxTokens !== existing.maxTokens) {
+				if (candidate.maxTokens > existing.maxTokens) {
+					globalRefs.set(candidate.id, candidate);
+				}
+			} else if (existing.provider !== "openai" && candidate.provider === "openai") {
+				globalRefs.set(candidate.id, candidate);
+			}
+		}
+	}
+	return (modelId: string) => providerRefs.get(modelId) ?? (globalRefs.get(modelId) as Model<TApi> | undefined);
+}

package/src/provider-models/descriptors.ts

@@ -0,0 +1,392 @@
+/**
+ * Unified provider descriptors — single source of truth for provider metadata
+ * used by both runtime model discovery (model-registry.ts) and catalog
+ * generation (generate-models.ts).
+ */
+import type { ModelManagerOptions } from "../model-manager";
+import type { Api, KnownProvider } from "../types";
+import type { OAuthProvider } from "../utils/oauth/types";
+import { googleModelManagerOptions } from "./google";
+import { ollamaCloudModelManagerOptions } from "./ollama";
+import {
+	alibabaTokenPlanModelManagerOptions,
+	anthropicModelManagerOptions,
+	bizrouterModelManagerOptions,
+	cerebrasModelManagerOptions,
+	cloudflareAiGatewayModelManagerOptions,
+	commandCodeModelManagerOptions,
+	deepinfraModelManagerOptions,
+	deepseekModelManagerOptions,
+	firepassModelManagerOptions,
+	fireworksModelManagerOptions,
+	fuguModelManagerOptions,
+	githubCopilotModelManagerOptions,
+	groqModelManagerOptions,
+	huggingfaceModelManagerOptions,
+	kiloModelManagerOptions,
+	kimiCodeModelManagerOptions,
+	litellmModelManagerOptions,
+	lmStudioModelManagerOptions,
+	maraModelManagerOptions,
+	mistralModelManagerOptions,
+	moonshotModelManagerOptions,
+	nanoGptModelManagerOptions,
+	nvidiaModelManagerOptions,
+	ollamaModelManagerOptions,
+	omlxModelManagerOptions,
+	openaiModelManagerOptions,
+	opencodeGoModelManagerOptions,
+	opencodeZenModelManagerOptions,
+	opengatewayModelManagerOptions,
+	openrouterModelManagerOptions,
+	qianfanModelManagerOptions,
+	qwenPortalModelManagerOptions,
+	sglangModelManagerOptions,
+	syntheticModelManagerOptions,
+	togetherModelManagerOptions,
+	veniceModelManagerOptions,
+	vercelAiGatewayModelManagerOptions,
+	vllmModelManagerOptions,
+	xaiModelManagerOptions,
+	xiaomiModelManagerOptions,
+	zenmuxModelManagerOptions,
+} from "./openai-compat";
+import {
+	cursorModelManagerOptions,
+	glmZcodeModelManagerOptions,
+	jetbrainsJunieModelManagerOptions,
+	kiroModelManagerOptions,
+	openCodexModelManagerOptions,
+	zaiModelManagerOptions,
+} from "./special";
+
+/** Catalog discovery configuration for providers that support endpoint-based model listing. */
+export interface CatalogDiscoveryConfig {
+	/** Human-readable name for log messages. */
+	label: string;
+	/** Environment variables to check for API keys during catalog generation. */
+	envVars: string[];
+	/** OAuth provider for credential refresh during catalog generation. */
+	oauthProvider?: OAuthProvider;
+	/** When true, catalog discovery proceeds even without credentials. */
+	allowUnauthenticated?: boolean;
+}
+
+/** Unified provider descriptor used by both runtime discovery and catalog generation. */
+export interface ProviderDescriptor {
+	providerId: KnownProvider;
+	createModelManagerOptions(config: { apiKey?: string; baseUrl?: string }): ModelManagerOptions<Api>;
+	/** Preferred model ID when no explicit selection is made. */
+	defaultModel: string;
+	/** When true, the runtime creates a model manager even without a valid API key (e.g. ollama). */
+	allowUnauthenticated?: boolean;
+	/** Catalog discovery configuration. Only providers with this field participate in generate-models.ts. */
+	catalogDiscovery?: CatalogDiscoveryConfig;
+}
+
+/** A provider descriptor that has catalog discovery configured. */
+export type CatalogProviderDescriptor = ProviderDescriptor & { catalogDiscovery: CatalogDiscoveryConfig };
+
+/** Type guard for descriptors with catalog discovery. */
+export function isCatalogDescriptor(d: ProviderDescriptor): d is CatalogProviderDescriptor {
+	return d.catalogDiscovery != null;
+}
+
+/** Whether catalog discovery may run without provider credentials. */
+export function allowsUnauthenticatedCatalogDiscovery(descriptor: CatalogProviderDescriptor): boolean {
+	return descriptor.catalogDiscovery.allowUnauthenticated ?? descriptor.allowUnauthenticated ?? false;
+}
+
+function descriptor(
+	providerId: KnownProvider,
+	defaultModel: string,
+	createModelManagerOptions: ProviderDescriptor["createModelManagerOptions"],
+	options: Pick<ProviderDescriptor, "allowUnauthenticated"> = {},
+): ProviderDescriptor {
+	return {
+		providerId,
+		defaultModel,
+		createModelManagerOptions,
+		...options,
+	};
+}
+
+function catalog(
+	label: string,
+	envVars: string[],
+	options: Pick<CatalogDiscoveryConfig, "oauthProvider" | "allowUnauthenticated"> = {},
+): CatalogDiscoveryConfig {
+	return {
+		label,
+		envVars,
+		...options,
+	};
+}
+
+function catalogDescriptor(
+	providerId: KnownProvider,
+	defaultModel: string,
+	createModelManagerOptions: ProviderDescriptor["createModelManagerOptions"],
+	catalogDiscovery: CatalogDiscoveryConfig,
+	options: Pick<ProviderDescriptor, "allowUnauthenticated"> = {},
+): ProviderDescriptor {
+	return {
+		...descriptor(providerId, defaultModel, createModelManagerOptions, options),
+		catalogDiscovery,
+	};
+}
+
+/**
+ * All standard providers. Special providers (google-antigravity, google-gemini-cli,
+ * OpenAI code provider) are handled separately because they require different config shapes.
+ */
+export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
+	descriptor("anthropic", "claude-sonnet-5", config => anthropicModelManagerOptions(config)),
+	catalogDescriptor(
+		"alibaba-token-plan",
+		"deepseek-v4-pro",
+		config => alibabaTokenPlanModelManagerOptions(config),
+		catalog("Alibaba Token Plan", ["ALIBABA_TOKEN_PLAN_API_KEY"], { oauthProvider: "alibaba-token-plan" }),
+	),
+	descriptor("openai", "gpt-5.4", config => openaiModelManagerOptions(config)),
+	descriptor("opencodex", "gpt-5.4", () => openCodexModelManagerOptions(), { allowUnauthenticated: true }),
+	descriptor("groq", "openai/gpt-oss-120b", config => groqModelManagerOptions(config)),
+	catalogDescriptor(
+		"huggingface",
+		"deepseek-ai/DeepSeek-R1",
+		config => huggingfaceModelManagerOptions(config),
+		catalog("Hugging Face", ["HUGGINGFACE_HUB_TOKEN", "HF_TOKEN"]),
+	),
+	catalogDescriptor(
+		"cerebras",
+		"zai-glm-4.6",
+		config => cerebrasModelManagerOptions(config),
+		catalog("Cerebras", ["CEREBRAS_API_KEY"]),
+	),
+	catalogDescriptor(
+		"fireworks",
+		"kimi-k2.6",
+		config => fireworksModelManagerOptions(config),
+		catalog("Fireworks", ["FIREWORKS_API_KEY"]),
+	),
+	descriptor("firepass", "kimi-k2.6-turbo", config => firepassModelManagerOptions(config)),
+	catalogDescriptor(
+		"fugu",
+		"fugu",
+		config => fuguModelManagerOptions(config),
+		catalog("Sakana Fugu", ["FUGU_API_KEY"]),
+	),
+	descriptor("xai", "grok-4-fast-non-reasoning", config => xaiModelManagerOptions(config)),
+	catalogDescriptor(
+		"deepseek",
+		"deepseek-v4-pro",
+		config => deepseekModelManagerOptions(config),
+		catalog("DeepSeek", ["DEEPSEEK_API_KEY"]),
+	),
+	catalogDescriptor(
+		"deepinfra",
+		"deepseek-ai/DeepSeek-V3.2",
+		config => deepinfraModelManagerOptions(config),
+		catalog("DeepInfra", ["DEEPINFRA_API_KEY"]),
+	),
+	descriptor("mistral", "devstral-medium-latest", config => mistralModelManagerOptions(config)),
+	catalogDescriptor(
+		"nvidia",
+		"nvidia/llama-3.1-nemotron-70b-instruct",
+		config => nvidiaModelManagerOptions(config),
+		catalog("NVIDIA", ["NVIDIA_API_KEY"]),
+	),
+	catalogDescriptor(
+		"nanogpt",
+		"openai/gpt-5.4",
+		config => nanoGptModelManagerOptions(config),
+		catalog("NanoGPT", ["NANO_GPT_API_KEY"]),
+	),
+	descriptor("opencode-zen", "claude-sonnet-4-6", config => opencodeZenModelManagerOptions(config)),
+	descriptor("opencode-go", "kimi-k2.5", config => opencodeGoModelManagerOptions(config)),
+	descriptor("commandcode-goat", "zai-org/GLM-5.3", config => commandCodeModelManagerOptions(config)),
+	catalogDescriptor(
+		"openrouter",
+		"openai/gpt-5.4",
+		config => openrouterModelManagerOptions(config),
+		catalog("OpenRouter", ["OPENROUTER_API_KEY"], { allowUnauthenticated: true }),
+	),
+	catalogDescriptor(
+		"kilo",
+		"anthropic/claude-sonnet-4.5",
+		config => kiloModelManagerOptions(config),
+		catalog("Kilo Gateway", ["KILO_API_KEY"], { allowUnauthenticated: true }),
+	),
+	catalogDescriptor(
+		"vercel-ai-gateway",
+		"anthropic/claude-sonnet-4-6",
+		config => vercelAiGatewayModelManagerOptions(config),
+		catalog("Vercel AI Gateway", ["VERCEL_AI_GATEWAY_API_KEY"], { allowUnauthenticated: true }),
+	),
+	catalogDescriptor(
+		"ollama",
+		"gpt-oss:20b",
+		config => ollamaModelManagerOptions(config),
+		catalog("Ollama", ["OLLAMA_API_KEY"]),
+		{ allowUnauthenticated: true },
+	),
+	catalogDescriptor(
+		"ollama-cloud",
+		"gpt-oss:120b",
+		config => ollamaCloudModelManagerOptions(config),
+		catalog("Ollama Cloud", ["OLLAMA_CLOUD_API_KEY"], { oauthProvider: "ollama-cloud" }),
+	),
+	catalogDescriptor(
+		"cloudflare-ai-gateway",
+		"claude-sonnet-4-5",
+		config => cloudflareAiGatewayModelManagerOptions(config),
+		catalog("Cloudflare AI Gateway", ["CLOUDFLARE_AI_GATEWAY_API_KEY"]),
+	),
+	catalogDescriptor(
+		"kimi-code",
+		"kimi-k2.5",
+		config => kimiCodeModelManagerOptions(config),
+		catalog("Kimi Code", ["KIMI_API_KEY"]),
+	),
+	catalogDescriptor(
+		"qwen-portal",
+		"coder-model",
+		config => qwenPortalModelManagerOptions(config),
+		catalog("Qwen Portal", ["QWEN_OAUTH_TOKEN", "QWEN_PORTAL_API_KEY"], { oauthProvider: "qwen-portal" }),
+	),
+	catalogDescriptor(
+		"synthetic",
+		"hf:moonshotai/Kimi-K2.5",
+		config => syntheticModelManagerOptions(config),
+		catalog("Synthetic", ["SYNTHETIC_API_KEY"]),
+	),
+	catalogDescriptor(
+		"venice",
+		"llama-3.3-70b",
+		config => veniceModelManagerOptions(config),
+		catalog("Venice", ["VENICE_API_KEY"], { allowUnauthenticated: true }),
+	),
+	catalogDescriptor(
+		"litellm",
+		"claude-opus-4-6",
+		config => litellmModelManagerOptions(config),
+		catalog("LiteLLM", ["LITELLM_API_KEY"], { allowUnauthenticated: true }),
+	),
+	descriptor("lm-studio", "llama-3-8b", config => lmStudioModelManagerOptions(config), { allowUnauthenticated: true }),
+	descriptor("omlx", "Qwen3.5-122B-A10B-Q4", config => omlxModelManagerOptions(config), {
+		allowUnauthenticated: true,
+	}),
+	catalogDescriptor(
+		"vllm",
+		"gpt-oss-20b",
+		config => vllmModelManagerOptions(config),
+		catalog("vLLM", ["VLLM_API_KEY"], { allowUnauthenticated: true }),
+		{ allowUnauthenticated: true },
+	),
+	catalogDescriptor(
+		"sglang",
+		"gpt-oss-20b",
+		config => sglangModelManagerOptions(config),
+		catalog("SGLang", ["SGLANG_API_KEY"], { allowUnauthenticated: true }),
+		{ allowUnauthenticated: true },
+	),
+	catalogDescriptor(
+		"moonshot",
+		"kimi-k2.5",
+		config => moonshotModelManagerOptions(config),
+		catalog("Moonshot", ["MOONSHOT_API_KEY"]),
+	),
+	catalogDescriptor(
+		"qianfan",
+		"deepseek-v3.2",
+		config => qianfanModelManagerOptions(config),
+		catalog("Qianfan", ["QIANFAN_API_KEY"]),
+	),
+	catalogDescriptor(
+		"together",
+		"moonshotai/Kimi-K2.5",
+		config => togetherModelManagerOptions(config),
+		catalog("Together", ["TOGETHER_API_KEY"]),
+	),
+	catalogDescriptor(
+		"xiaomi",
+		"mimo-v2-flash",
+		config => xiaomiModelManagerOptions(config),
+		catalog("Xiaomi", ["XIAOMI_API_KEY"]),
+	),
+	catalogDescriptor(
+		"xiaomi-token-plan-ams",
+		"mimo-v2.5",
+		config => xiaomiModelManagerOptions({ ...config, providerId: "xiaomi-token-plan-ams", tokenPlanRegion: "ams" }),
+		catalog("Xiaomi Token Plan (Europe)", ["XIAOMI_TOKEN_PLAN_AMS_API_KEY"]),
+	),
+	catalogDescriptor(
+		"xiaomi-token-plan-cn",
+		"mimo-v2.5",
+		config => xiaomiModelManagerOptions({ ...config, providerId: "xiaomi-token-plan-cn", tokenPlanRegion: "cn" }),
+		catalog("Xiaomi Token Plan (China)", ["XIAOMI_TOKEN_PLAN_CN_API_KEY"]),
+	),
+	catalogDescriptor(
+		"xiaomi-token-plan-sgp",
+		"mimo-v2.5",
+		config => xiaomiModelManagerOptions({ ...config, providerId: "xiaomi-token-plan-sgp", tokenPlanRegion: "sgp" }),
+		catalog("Xiaomi Token Plan (Singapore)", ["XIAOMI_TOKEN_PLAN_SGP_API_KEY"]),
+	),
+	catalogDescriptor(
+		"zenmux",
+		"anthropic/claude-opus-4.6",
+		config => zenmuxModelManagerOptions(config),
+		catalog("ZenMux", ["ZENMUX_API_KEY"]),
+	),
+	catalogDescriptor(
+		"opengateway",
+		"openai/gpt-4o",
+		config => opengatewayModelManagerOptions(config),
+		catalog("OpenGateway by Sionic AI", ["OPENGATEWAY_API_KEY"]),
+	),
+	catalogDescriptor(
+		"bizrouter",
+		"anthropic/claude-sonnet-4.5",
+		config => bizrouterModelManagerOptions(config),
+		catalog("BizRouter", ["BIZROUTER_API_KEY"]),
+	),
+	catalogDescriptor(
+		"mara",
+		"DeepSeek-V3.1",
+		config => maraModelManagerOptions(config),
+		catalog("Mara Cloud", ["MARA_API_KEY"]),
+	),
+	catalogDescriptor("zai", "glm-5.3", config => zaiModelManagerOptions(config), catalog("zAI", ["ZAI_API_KEY"])),
+	catalogDescriptor(
+		"glm-zcode",
+		"glm-5.2",
+		config => glmZcodeModelManagerOptions(config),
+		catalog("GLM ZCode (unofficial)", ["GLM_ZCODE_API_KEY"], { oauthProvider: "glm-zcode" }),
+	),
+	descriptor("jetbrains-junie", "claude-sonnet-4-6", config => jetbrainsJunieModelManagerOptions(config)),
+	descriptor("github-copilot", "gpt-4o", config => githubCopilotModelManagerOptions(config)),
+	descriptor("google", "gemini-2.5-pro", config => googleModelManagerOptions(config)),
+	catalogDescriptor(
+		"cursor",
+		"claude-sonnet-4-6",
+		config => cursorModelManagerOptions(config),
+		catalog("Cursor", ["CURSOR_API_KEY"], { oauthProvider: "cursor" }),
+	),
+	descriptor("kiro", "auto", config => kiroModelManagerOptions(config)),
+] as const;
+
+/** Default model IDs for all known providers, built from descriptors + special providers. */
+export const DEFAULT_MODEL_PER_PROVIDER: Record<KnownProvider, string> = {
+	...Object.fromEntries(PROVIDER_DESCRIPTORS.map(d => [d.providerId, d.defaultModel])),
+	// Providers not in PROVIDER_DESCRIPTORS (special auth or no standard discovery)
+	"azure-openai": "gpt-4.1",
+	"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
+	"google-antigravity": "gemini-3-pro-high",
+	"google-gemini-cli": "gemini-2.5-pro",
+	"google-vertex": "gemini-3-pro-preview",
+	minimax: "MiniMax-M3",
+	"minimax-code": "MiniMax-M3",
+	"minimax-code-cn": "MiniMax-M3",
+	"openai-codex": "gpt-5.5",
+	"gitlab-duo": "duo-chat-sonnet-4-5",
+} as Record<KnownProvider, string>;

package/src/provider-models/google.ts

@@ -0,0 +1,92 @@
+import type { ModelManagerOptions } from "../model-manager";
+import { fetchAntigravityDiscoveryModels } from "../utils/discovery/antigravity";
+import { fetchGeminiModels } from "../utils/discovery/gemini";
+
+export interface GoogleModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+}
+
+export interface GoogleVertexModelManagerConfig {
+	apiKey?: string;
+}
+
+export interface GoogleAntigravityModelManagerConfig {
+	oauthToken?: string;
+	endpoint?: string;
+}
+
+export interface GoogleGeminiCliModelManagerConfig {
+	oauthToken?: string;
+	endpoint?: string;
+}
+
+const CLOUD_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+
+export function googleModelManagerOptions(
+	config?: GoogleModelManagerConfig,
+): ModelManagerOptions<"google-generative-ai"> {
+	const apiKey = config?.apiKey;
+	return {
+		providerId: "google",
+		...(apiKey ? { fetchDynamicModels: () => fetchGeminiModels({ apiKey, baseUrl: config?.baseUrl }) } : undefined),
+	};
+}
+
+export function googleVertexModelManagerOptions(
+	_config?: GoogleVertexModelManagerConfig,
+): ModelManagerOptions<"google-vertex"> {
+	// Vertex AI uses Application Default Credentials (ADC) for authentication,
+	// which is handled at stream time rather than during model discovery.
+	// Dynamic model discovery is not yet implemented for this provider.
+	return {
+		providerId: "google-vertex",
+	};
+}
+
+export function googleAntigravityModelManagerOptions(
+	config?: GoogleAntigravityModelManagerConfig,
+): ModelManagerOptions<"google-gemini-cli"> {
+	const token = config?.oauthToken;
+	return {
+		providerId: "google-antigravity",
+		...(token
+			? {
+					fetchDynamicModels: () =>
+						fetchAntigravityDiscoveryModels({
+							token,
+							endpoint: config?.endpoint,
+						}),
+				}
+			: undefined),
+	};
+}
+
+export function googleGeminiCliModelManagerOptions(
+	config?: GoogleGeminiCliModelManagerConfig,
+): ModelManagerOptions<"google-gemini-cli"> {
+	const token = config?.oauthToken;
+	const endpoint = config?.endpoint ?? CLOUD_CODE_ASSIST_ENDPOINT;
+	return {
+		providerId: "google-gemini-cli",
+		...(token
+			? {
+					fetchDynamicModels: async () => {
+						const models = await fetchAntigravityDiscoveryModels({
+							token,
+							endpoint,
+							targetProvider: "google-gemini-cli",
+						});
+						if (models === null) {
+							return null;
+						}
+						return models.map(m => ({
+							...m,
+							provider: "google-gemini-cli" as const,
+							baseUrl: endpoint,
+						}));
+					},
+				}
+			: undefined),
+	};
+}

package/src/provider-models/index.ts

@@ -0,0 +1,5 @@
+export * from "./descriptors";
+export * from "./google";
+export * from "./ollama";
+export * from "./openai-compat";
+export * from "./special";

package/src/provider-models/ollama.ts

@@ -0,0 +1,159 @@
+import { fetchWithRetry } from "@vib-rato/utils";
+import type { ModelManagerOptions } from "../model-manager";
+import { Effort } from "../model-thinking";
+import type { ThinkingConfig } from "../types";
+import { createBundledReferenceMap, createReferenceResolver } from "./bundled-references";
+
+export interface OllamaCloudModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+}
+
+type OllamaTagEntry = {
+	name?: string;
+	model?: string;
+};
+
+type OllamaShowResponse = {
+	capabilities?: string[];
+	model_info?: Record<string, unknown>;
+};
+
+const OLLAMA_RETRY_DELAYS_MS = [2_000, 5_000, 10_000];
+
+// /api/show exposes the context window, not a verified output ceiling. Keep curated
+// output limits authoritative; unknown cloud models use the same bounded default that
+// streamSimple would request for a model with a larger known limit. This avoids the old
+// 8192-token truncation without advertising or requesting an unverified 131K output.
+const OLLAMA_CLOUD_UNKNOWN_MAX_TOKENS = 32_000;
+
+function trimTrailingSlash(value: string): string {
+	return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+
+export function normalizeOllamaCloudBaseUrl(baseUrl?: string): string {
+	const value = baseUrl?.trim();
+	if (!value) {
+		return "https://ollama.com";
+	}
+	const trimmed = trimTrailingSlash(value);
+	return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+}
+
+function createCloudHeaders(apiKey: string): Record<string, string> {
+	return {
+		Accept: "application/json",
+		Authorization: `Bearer ${apiKey}`,
+	};
+}
+
+function getContextWindow(modelInfo: Record<string, unknown> | undefined): number | undefined {
+	if (!modelInfo) {
+		return undefined;
+	}
+	for (const [key, value] of Object.entries(modelInfo)) {
+		if (typeof value !== "number") {
+			continue;
+		}
+		if (key.endsWith(".context_length") || key.endsWith(".num_ctx") || key.endsWith(".context_window")) {
+			return value;
+		}
+	}
+}
+
+function getThinkingConfig(capabilities: string[] | undefined): ThinkingConfig | undefined {
+	if (!capabilities?.includes("thinking")) {
+		return undefined;
+	}
+	return {
+		mode: "effort",
+		minLevel: Effort.Minimal,
+		maxLevel: Effort.High,
+	};
+}
+
+async function fetchShowMetadata(
+	baseUrl: string,
+	apiKey: string,
+	model: string,
+): Promise<OllamaShowResponse | undefined> {
+	const response = await fetch(`${baseUrl}/api/show`, {
+		method: "POST",
+		headers: {
+			...createCloudHeaders(apiKey),
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({ model }),
+	});
+	if (!response.ok) {
+		return undefined;
+	}
+	return (await response.json()) as OllamaShowResponse;
+}
+
+export function ollamaCloudModelManagerOptions(
+	config?: OllamaCloudModelManagerConfig,
+): ModelManagerOptions<"ollama-chat"> {
+	const apiKey = config?.apiKey;
+	const baseUrl = normalizeOllamaCloudBaseUrl(config?.baseUrl);
+	const resolveReference = createReferenceResolver(createBundledReferenceMap<"ollama-chat">("ollama-cloud"));
+	return {
+		providerId: "ollama-cloud",
+		fetchDynamicModels: async () => {
+			if (!apiKey) {
+				return [];
+			}
+			const response = await fetchWithRetry(`${baseUrl}/api/tags`, {
+				method: "GET",
+				headers: createCloudHeaders(apiKey),
+				defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
+			});
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status} from ${baseUrl}/api/tags`);
+			}
+			const payload = (await response.json()) as { models?: OllamaTagEntry[] };
+			const entries = payload.models ?? [];
+			const models = await Promise.all(
+				entries.map(async entry => {
+					const id = entry.model ?? entry.name;
+					if (!id) {
+						return undefined;
+					}
+					const reference = resolveReference(id);
+					let metadata: OllamaShowResponse | undefined;
+					try {
+						metadata = await fetchShowMetadata(baseUrl, apiKey, id);
+					} catch {
+						metadata = undefined;
+					}
+					const capabilities = metadata?.capabilities;
+					const contextWindow = getContextWindow(metadata?.model_info) ?? reference?.contextWindow ?? 128000;
+					const reasoning = capabilities ? capabilities.includes("thinking") : (reference?.reasoning ?? false);
+					const thinking = capabilities ? getThinkingConfig(capabilities) : reference?.thinking;
+					const input = capabilities
+						? capabilities.includes("vision")
+							? (["text", "image"] as Array<"text" | "image">)
+							: (["text"] as Array<"text">)
+						: ((reference?.input as Array<"text" | "image"> | undefined) ?? (["text"] as Array<"text">));
+					const resolvedName = entry.name && entry.name !== id ? entry.name : (reference?.name ?? id);
+					return {
+						id,
+						name: resolvedName,
+						api: "ollama-chat" as const,
+						provider: "ollama-cloud" as const,
+						baseUrl,
+						reasoning,
+						thinking,
+						input,
+						cost: reference?.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+						contextWindow,
+						maxTokens: reference?.maxTokens ?? Math.min(contextWindow, OLLAMA_CLOUD_UNKNOWN_MAX_TOKENS),
+					};
+				}),
+			);
+			return models
+				.filter((model): model is NonNullable<(typeof models)[number]> => model !== undefined)
+				.sort((left, right) => left.id.localeCompare(right.id));
+		},
+	};
+}