@oh-my-pi/pi-catalog 15.10.11

package/src/provider-models/google.ts

@@ -0,0 +1,105 @@
+import { fetchAntigravityDiscoveryModels } from "../discovery/antigravity";
+import { fetchGeminiModels } from "../discovery/gemini";
+import type { ModelManagerOptions } from "../model-manager";
+import type { FetchImpl } from "../types";
+
+export interface GoogleModelManagerConfig {
+	apiKey?: string;
+	fetch?: FetchImpl;
+}
+
+export interface GoogleVertexModelManagerConfig {
+	apiKey?: string;
+	project?: string;
+	location?: string;
+	signal?: AbortSignal;
+	fetch?: FetchImpl;
+}
+
+export interface GoogleAntigravityModelManagerConfig {
+	oauthToken?: string;
+	endpoint?: string;
+	fetch?: FetchImpl;
+}
+
+export interface GoogleGeminiCliModelManagerConfig {
+	oauthToken?: string;
+	endpoint?: string;
+	fetch?: FetchImpl;
+}
+
+const CLOUD_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+
+function toDiscoveryFetch(fetchImpl: FetchImpl | undefined): typeof fetch | undefined {
+	if (!fetchImpl) {
+		return undefined;
+	}
+	return Object.assign(
+		(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => fetchImpl(input, init),
+		{ preconnect: fetchImpl.preconnect ?? fetch.preconnect },
+	);
+}
+
+export function googleModelManagerOptions(
+	config?: GoogleModelManagerConfig,
+): ModelManagerOptions<"google-generative-ai"> {
+	const apiKey = config?.apiKey;
+	return {
+		providerId: "google",
+		...(apiKey
+			? { fetchDynamicModels: () => fetchGeminiModels({ apiKey, fetch: toDiscoveryFetch(config?.fetch) }) }
+			: undefined),
+	};
+}
+
+export function googleVertexModelManagerOptions(_config?: GoogleVertexModelManagerConfig): ModelManagerOptions {
+	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,
+							fetcher: toDiscoveryFetch(config?.fetch),
+						}),
+				}
+			: 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,
+							fetcher: toDiscoveryFetch(config?.fetch),
+						});
+						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,6 @@
+export * from "./descriptor-types";
+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,154 @@
+import { fetchWithRetry } from "@oh-my-pi/pi-utils";
+import { Effort } from "../effort";
+import type { ModelManagerOptions } from "../model-manager";
+import type { FetchImpl, ThinkingConfig } from "../types";
+import { createBundledReferenceMap, createReferenceResolver } from "./bundled-references";
+
+export interface OllamaCloudModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+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];
+
+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", efforts: [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High] };
+}
+async function fetchShowMetadata(
+	baseUrl: string,
+	apiKey: string,
+	model: string,
+	fetchImpl: FetchImpl = fetch,
+): Promise<OllamaShowResponse | undefined> {
+	const response = await fetchImpl(`${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 providerReferences = createBundledReferenceMap<"ollama-chat">("ollama-cloud");
+	const resolveReference = createReferenceResolver(providerReferences);
+	return {
+		providerId: "ollama-cloud",
+		fetchDynamicModels: async () => {
+			if (!apiKey) {
+				return [];
+			}
+			const response = await fetchWithRetry(`${baseUrl}/api/tags`, {
+				method: "GET",
+				headers: createCloudHeaders(apiKey),
+				fetch: config?.fetch,
+				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 providerReference = providerReferences.get(id);
+					const reference = resolveReference(id);
+					let metadata: OllamaShowResponse | undefined;
+					try {
+						metadata = await fetchShowMetadata(baseUrl, apiKey, id, config?.fetch);
+					} catch {
+						metadata = undefined;
+					}
+					const capabilities = metadata?.capabilities;
+					const contextWindow =
+						getContextWindow(metadata?.model_info) ?? providerReference?.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: providerReference?.maxTokens ?? Math.min(contextWindow, 8192),
+					};
+				}),
+			);
+			return models
+				.filter((model): model is NonNullable<(typeof models)[number]> => model !== undefined)
+				.sort((left, right) => left.id.localeCompare(right.id));
+		},
+	};
+}