@rigelbuild/omp-catalog 18.0.3

package/src/discovery/devin.ts

@@ -0,0 +1,152 @@
+import { gunzipSync } from "node:zlib";
+import type { FetchImpl, ModelSpec } from "../types";
+import { discoveryFetch } from "../utils";
+import {
+	type ClientModelConfig,
+	GetCliModelConfigsRequestSchema,
+	GetCliModelConfigsResponseSchema,
+	MetadataSchema,
+} from "./devin-proto";
+import { create, fromBinary, toBinary } from "./protobuf";
+
+const DEVIN_DEFAULT_BASE_URL = "https://server.codeium.com";
+const DEVIN_GET_CLI_MODEL_CONFIGS_PATH = "/exa.api_server_pb.ApiServerService/GetCliModelConfigs";
+const DEVIN_IDE_VERSION = "3.2.23";
+const DEVIN_EXTENSION_VERSION = "1.48.2";
+const DEVIN_SESSION_TOKEN_PREFIX = "devin-session-token$";
+
+const DEFAULT_CONTEXT_WINDOW = 200_000;
+const DEFAULT_MAX_TOKENS = 64_000;
+
+/** Best-effort match for labels whose wording implies a thinking / reasoning-effort variant. */
+const REASONING_LABEL_PATTERN = /think|thinking|minimal|high|medium|low|xhigh|max|reasoning/i;
+const NO_REASONING_LABEL_PATTERN = /\bno thinking\b/i;
+function supportsDevinThinking(config: ClientModelConfig): boolean {
+	if (NO_REASONING_LABEL_PATTERN.test(config.label)) return false;
+	return config.modelInfo?.modelFeatures?.supportsThinking === true || REASONING_LABEL_PATTERN.test(config.label);
+}
+
+/**
+ * Options for fetching dynamic Devin (Codeium Cascade) models from `GetCliModelConfigs`.
+ */
+export interface DevinModelDiscoveryOptions {
+	/** Codeium session token carried inside protobuf `Metadata.apiKey`. */
+	apiKey?: string;
+	/** Optional Codeium API base URL override. */
+	baseUrl?: string;
+	/** Optional request timeout in milliseconds (default 5000). */
+	timeoutMs?: number;
+	/** Optional caller abort signal, combined with the internal timeout. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation for request-debug/proxy/test transports. */
+	fetch?: FetchImpl;
+}
+
+/**
+ * Fetches Devin models through the `GetCliModelConfigs` unary Connect RPC and
+ * normalizes them into canonical model entries.
+ *
+ * Returns `null` on request/decode failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export async function fetchDevinModels(
+	options: DevinModelDiscoveryOptions,
+): Promise<ModelSpec<"devin-agent">[] | null> {
+	const timeoutMs = options.timeoutMs ?? 5_000;
+	const resolvedBaseUrl = options.baseUrl ?? DEVIN_DEFAULT_BASE_URL;
+	const requestUrl = `${resolvedBaseUrl.replace(/\/+$/, "")}${DEVIN_GET_CLI_MODEL_CONFIGS_PATH}`;
+
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+
+	try {
+		const request = create(GetCliModelConfigsRequestSchema, {
+			metadata: create(MetadataSchema, {
+				apiKey: normalizeDevinSessionToken(options.apiKey),
+				ideName: "windsurf",
+				ideVersion: DEVIN_IDE_VERSION,
+				extensionName: "windsurf",
+				extensionVersion: DEVIN_EXTENSION_VERSION,
+			}),
+		});
+		const body = toBinary(GetCliModelConfigsRequestSchema, request);
+
+		const headers: Record<string, string> = {
+			"content-type": "application/proto",
+			"connect-protocol-version": "1",
+			accept: "*/*",
+		};
+
+		const fetchImpl = discoveryFetch(options.fetch);
+		const response = await fetchImpl(requestUrl, { method: "POST", headers, body, signal });
+		if (!response.ok) {
+			return null;
+		}
+
+		const decoded = decodeCliModelConfigsResponse(new Uint8Array(await response.arrayBuffer()));
+		if (!decoded) {
+			return null;
+		}
+
+		return normalizeDevinModels(decoded.clientModelConfigs, options.baseUrl);
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+function normalizeDevinSessionToken(apiKey: string | undefined): string {
+	if (!apiKey) return "";
+	return apiKey.startsWith(DEVIN_SESSION_TOKEN_PREFIX) ? apiKey : `${DEVIN_SESSION_TOKEN_PREFIX}${apiKey}`;
+}
+
+/**
+ * Decodes a raw (unframed) `GetCliModelConfigsResponse`. Bun's `fetch` usually
+ * auto-decompresses gzip, so the direct decode is attempted first; a
+ * `gunzipSync` fallback covers runtimes that hand back the still-compressed body.
+ */
+function decodeCliModelConfigsResponse(payload: Uint8Array) {
+	try {
+		return fromBinary(GetCliModelConfigsResponseSchema, payload);
+	} catch {
+		try {
+			return fromBinary(GetCliModelConfigsResponseSchema, gunzipSync(payload));
+		} catch {
+			return null;
+		}
+	}
+}
+
+function normalizeDevinModels(
+	configs: readonly ClientModelConfig[],
+	baseUrlOverride: string | undefined,
+): ModelSpec<"devin-agent">[] {
+	const byId = new Map<string, ModelSpec<"devin-agent">>();
+	for (const config of configs) {
+		if (config.disabled) {
+			continue;
+		}
+		const id = config.modelUid.trim();
+		if (!id) {
+			continue;
+		}
+		const input: ("text" | "image")[] = config.supportsImages ? ["text", "image"] : ["text"];
+		const contextWindow = config.maxTokens > 0 ? config.maxTokens : DEFAULT_CONTEXT_WINDOW;
+		byId.set(id, {
+			id,
+			name: config.label.trim() || id,
+			api: "devin-agent",
+			provider: "devin",
+			baseUrl: baseUrlOverride ?? DEVIN_DEFAULT_BASE_URL,
+			reasoning: supportsDevinThinking(config),
+			input,
+			supportsTools: true,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow,
+			maxTokens: Math.min(config.maxTokens > 0 ? config.maxTokens : DEFAULT_MAX_TOKENS, DEFAULT_MAX_TOKENS),
+		});
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/discovery/gemini-cli.ts

@@ -0,0 +1,198 @@
+import { type } from "@rigelbuild/omp-omptype";
+import type { FetchImpl } from "@rigelbuild/omp-utils";
+import { parseGeminiModel, semverGte } from "../identity/classify";
+import { isGeminiModelId } from "../identity/family";
+import { createBundledReferenceMap } from "../provider-models/bundled-references";
+import type { ModelSpec } from "../types";
+import { discoveryFetch } from "../utils";
+import {
+	collapseEffortVariants,
+	GEMINI_CLI_VARIANT_COLLAPSE_TABLE,
+	type VariantCollapseTable,
+} from "../variant-collapse";
+import { getGeminiCliHeaders } from "../wire/gemini-headers";
+
+const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const LOAD_CODE_ASSIST_PATH = "/v1internal:loadCodeAssist";
+const RETRIEVE_USER_QUOTA_PATH = "/v1internal:retrieveUserQuota";
+
+// All current Gemini CLI models ship a 1M-token context and 65,536-token
+// output ceiling; used only for quota-listed ids the bundled catalog does not
+// already describe. Ids present in the bundle keep their real limits.
+const DEFAULT_CONTEXT_WINDOW = 1_048_576;
+const DEFAULT_MAX_TOKENS = 65_536;
+
+/** Gemini generations that expose thinking on Cloud Code Assist. */
+const REASONING_MIN_VERSION = "2.5";
+
+const LoadCodeAssistResponseSchema = type({
+	"cloudaicompanionProject?": type("unknown").pipe(value => {
+		if (typeof value === "string") return value;
+		if (value && typeof value === "object" && "id" in value && typeof value.id === "string") {
+			return value.id;
+		}
+		return undefined;
+	}),
+});
+
+const QuotaBucketSchema = type({
+	"modelId?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+});
+
+const RetrieveUserQuotaResponseSchema = type({
+	"buckets?": type("unknown").pipe(value => {
+		if (!Array.isArray(value)) return undefined;
+		const buckets: Array<{ modelId?: string }> = [];
+		for (const bucket of value) {
+			const parsed = QuotaBucketSchema(bucket);
+			if (!(parsed instanceof type.errors)) {
+				buckets.push(parsed);
+			}
+		}
+		return buckets;
+	}),
+});
+
+/**
+ * Options for the Gemini CLI quota-based discovery fallback.
+ */
+export interface FetchGeminiCliQuotaModelsOptions {
+	/** OAuth access token sent as `Authorization: Bearer <token>`. */
+	token: string;
+	/** Cloud Code Assist endpoint. Defaults to `https://cloudcode-pa.googleapis.com`. */
+	endpoint?: string;
+	/** Pre-resolved GCP project id; otherwise discovered via `loadCodeAssist`. */
+	projectId?: string;
+	/** Optional abort signal for request cancellation. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation override for tests. */
+	fetcher?: typeof fetch;
+	/** Effort-tier collapse table applied to the discovered list. */
+	collapseTable?: VariantCollapseTable;
+}
+
+/**
+ * Discovers the Gemini models available to a `google-gemini-cli` credential via
+ * the account's own `retrieveUserQuota` endpoint on Cloud Code Assist.
+ *
+ * This is the fallback for accounts whose credential is not authorized for the
+ * Antigravity `fetchAvailableModels` endpoint (e.g. Gemini Code Assist Standard
+ * tiers, which return HTTP 403 there). Quota buckets carry only model ids, so
+ * metadata is filled from the bundled catalog where the id is known and
+ * synthesized with Gemini CLI defaults otherwise.
+ *
+ * Returns `null` on network/payload/auth failure (the caller keeps the bundled
+ * catalog). Returns `[]` when the quota response lists no usable Gemini models.
+ */
+export async function fetchGeminiCliQuotaModels(
+	options: FetchGeminiCliQuotaModelsOptions,
+): Promise<ModelSpec<"google-gemini-cli">[] | null> {
+	const fetcher = discoveryFetch(options.fetcher);
+	const endpoint = (options.endpoint?.trim() || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+	const headers = {
+		Authorization: `Bearer ${options.token}`,
+		"Content-Type": "application/json",
+		...getGeminiCliHeaders(),
+	};
+
+	const projectId = options.projectId ?? (await loadProjectId(fetcher, endpoint, headers, options.signal));
+
+	let response: Response;
+	try {
+		response = await fetcher(`${endpoint}${RETRIEVE_USER_QUOTA_PATH}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(projectId ? { project: projectId } : {}),
+			signal: options.signal,
+		});
+	} catch {
+		return null;
+	}
+
+	if (!response.ok) {
+		return null;
+	}
+
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		return null;
+	}
+
+	const parsed = RetrieveUserQuotaResponseSchema(payload);
+	if (parsed instanceof type.errors) {
+		return null;
+	}
+
+	const seen = new Set<string>();
+	const models: ModelSpec<"google-gemini-cli">[] = [];
+	const bundled = createBundledReferenceMap<"google-gemini-cli">("google-gemini-cli");
+
+	for (const bucket of parsed.buckets ?? []) {
+		const modelId = bucket.modelId?.trim();
+		if (!modelId || seen.has(modelId) || !isGeminiModelId(modelId)) {
+			continue;
+		}
+		seen.add(modelId);
+
+		const reference = bundled.get(modelId);
+		if (reference) {
+			models.push({ ...reference, baseUrl: endpoint });
+			continue;
+		}
+
+		const parsedId = parseGeminiModel(modelId);
+		models.push({
+			id: modelId,
+			name: modelId,
+			api: "google-gemini-cli",
+			provider: "google-gemini-cli",
+			baseUrl: endpoint,
+			reasoning: parsedId ? semverGte(parsedId.version, REASONING_MIN_VERSION) : false,
+			input: ["text", "image"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: DEFAULT_CONTEXT_WINDOW,
+			maxTokens: DEFAULT_MAX_TOKENS,
+		});
+	}
+
+	const collapsed = collapseEffortVariants(models, options.collapseTable ?? GEMINI_CLI_VARIANT_COLLAPSE_TABLE);
+	collapsed.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+	return collapsed;
+}
+
+async function loadProjectId(
+	fetcher: FetchImpl,
+	endpoint: string,
+	headers: Record<string, string>,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	let response: Response;
+	try {
+		response = await fetcher(`${endpoint}${LOAD_CODE_ASSIST_PATH}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				metadata: { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" },
+			}),
+			signal,
+		});
+	} catch {
+		return undefined;
+	}
+
+	if (!response.ok) {
+		return undefined;
+	}
+
+	let payload: unknown;
+	try {
+		payload = await response.json();
+	} catch {
+		return undefined;
+	}
+
+	const parsed = LoadCodeAssistResponseSchema(payload);
+	return parsed instanceof type.errors ? undefined : parsed.cloudaicompanionProject;
+}

package/src/discovery/gemini.ts

@@ -0,0 +1,260 @@
+import { type } from "@rigelbuild/omp-omptype";
+import { getBundledModels } from "../models";
+import { toModelSpec } from "../provider-models/bundled-references";
+import type { FetchImpl, Model, ModelSpec } from "../types";
+import { discoveryFetch } from "../utils";
+
+const GOOGLE_GENERATIVE_AI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const DEFAULT_PAGE_SIZE = 100;
+const DEFAULT_MAX_PAGES = 25;
+
+const resilientString = type("unknown").pipe(val => {
+	if (val === undefined) return undefined;
+	const out = type("string")(val);
+	return out instanceof type.errors ? undefined : out;
+});
+
+const resilientNumber = type("unknown").pipe(val => {
+	if (val === undefined) return undefined;
+	const out = type("number")(val);
+	return out instanceof type.errors ? undefined : out;
+});
+
+const geminiModelListItemSchema = type({
+	"name?": resilientString,
+	"displayName?": resilientString,
+	"supportedGenerationMethods?": "string[]",
+	"inputTokenLimit?": resilientNumber,
+	"outputTokenLimit?": resilientNumber,
+});
+
+type GeminiModelListItem = typeof geminiModelListItemSchema.infer;
+
+const modelsSchema = type("unknown[]")
+	.pipe(items => {
+		const parsedItems: GeminiModelListItem[] = [];
+		for (const item of items) {
+			const parsed = geminiModelListItemSchema(item);
+			if (!(parsed instanceof type.errors)) {
+				parsedItems.push(parsed);
+			}
+		}
+		return parsedItems;
+	})
+	.default(() => []);
+
+const geminiModelListResponseSchema = type({
+	models: modelsSchema,
+	"nextPageToken?": resilientString,
+});
+/**
+ * Configuration for Google Generative AI model discovery.
+ */
+export interface GeminiDiscoveryOptions {
+	/** API key for the Google Generative AI public endpoint. */
+	apiKey: string;
+	/** Optional endpoint override for testing or proxying. */
+	baseUrl?: string;
+	/** Optional requested page size for model listing. */
+	pageSize?: number;
+	/** Maximum number of pages to request before stopping pagination. */
+	maxPages?: number;
+	/** Optional abort signal for HTTP requests. */
+	signal?: AbortSignal;
+	/** Optional fetch implementation override for tests. */
+	fetch?: FetchImpl;
+}
+
+/**
+ * Fetches and normalizes Google Generative AI models from the public models endpoint.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export async function fetchGeminiModels(
+	options: GeminiDiscoveryOptions,
+): Promise<ModelSpec<"google-generative-ai">[] | null> {
+	if (!options.apiKey.trim()) {
+		return null;
+	}
+
+	const fetchImpl = discoveryFetch(options.fetch);
+	const baseUrl = normalizeBaseUrl(options.baseUrl);
+	const pageSize = normalizePositiveInt(options.pageSize, DEFAULT_PAGE_SIZE);
+	const maxPages = normalizePositiveInt(options.maxPages, DEFAULT_MAX_PAGES);
+
+	const bundledById = new Map(
+		getBundledModels("google").map(model => [model.id, toModelSpec(model as Model<"google-generative-ai">)]),
+	);
+	const modelsById = new Map<string, ModelSpec<"google-generative-ai">>();
+	const seenTokens = new Set<string>();
+	let nextPageToken: string | undefined;
+
+	for (let page = 0; page < maxPages; page += 1) {
+		const requestUrl = buildModelsUrl(baseUrl, options.apiKey, pageSize, nextPageToken);
+		let response: Response;
+		try {
+			response = await fetchImpl(requestUrl, {
+				method: "GET",
+				signal: options.signal,
+			});
+		} catch {
+			return null;
+		}
+
+		if (!response.ok) {
+			return null;
+		}
+
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			return null;
+		}
+
+		const parsed = geminiModelListResponseSchema(payload);
+		if (parsed instanceof type.errors) {
+			return null;
+		}
+
+		for (const item of parsed.models) {
+			const model = normalizeModel(item, baseUrl, bundledById);
+			if (model) {
+				modelsById.set(model.id, model);
+			}
+		}
+
+		const token = normalizePageToken(parsed.nextPageToken);
+		if (!token) {
+			break;
+		}
+		if (seenTokens.has(token)) {
+			break;
+		}
+		seenTokens.add(token);
+		nextPageToken = token;
+	}
+
+	return Array.from(modelsById.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function buildModelsUrl(baseUrl: string, apiKey: string, pageSize: number, pageToken?: string): URL {
+	const url = new URL(`${baseUrl}/models`);
+	url.searchParams.set("key", apiKey);
+	url.searchParams.set("pageSize", String(pageSize));
+	if (pageToken) {
+		url.searchParams.set("pageToken", pageToken);
+	}
+	return url;
+}
+
+function normalizeBaseUrl(baseUrl?: string): string {
+	const value = (baseUrl ?? GOOGLE_GENERATIVE_AI_BASE_URL).trim();
+	if (!value) {
+		return GOOGLE_GENERATIVE_AI_BASE_URL;
+	}
+	return value.replace(/\/+$/, "");
+}
+
+function normalizePositiveInt(value: number | undefined, fallback: number): number;
+function normalizePositiveInt(value: number | undefined, fallback: number | null): number | null;
+function normalizePositiveInt(value: number | undefined, fallback: number | null): number | null {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		return fallback;
+	}
+	const normalized = Math.floor(value);
+	return normalized > 0 ? normalized : fallback;
+}
+
+function normalizePageToken(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const token = value.trim();
+	return token.length > 0 ? token : undefined;
+}
+
+function normalizeModel(
+	item: GeminiModelListItem,
+	baseUrl: string,
+	bundledById: Map<string, ModelSpec<"google-generative-ai">>,
+): ModelSpec<"google-generative-ai"> | null {
+	const id = normalizeModelId(item.name);
+	if (!id) {
+		return null;
+	}
+	if (!supportsTextGeneration(item.supportedGenerationMethods)) {
+		return null;
+	}
+
+	const reference = bundledById.get(id);
+	const contextWindow = normalizePositiveInt(item.inputTokenLimit, reference?.contextWindow ?? null);
+	const maxTokens = normalizePositiveInt(item.outputTokenLimit, reference?.maxTokens ?? null);
+	const name = normalizeModelName(item.displayName, reference?.name ?? id);
+
+	if (reference) {
+		return {
+			...reference,
+			id,
+			name,
+			baseUrl,
+			contextWindow,
+			maxTokens,
+		};
+	}
+	return {
+		id,
+		name,
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl,
+		reasoning: inferReasoningFromGeminiId(id),
+		input: inferInputFromGeminiId(id),
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow,
+		maxTokens,
+	};
+}
+
+function normalizeModelId(value: string | undefined): string | null {
+	if (!value) {
+		return null;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return null;
+	}
+	return trimmed.startsWith("models/") ? trimmed.slice("models/".length) : trimmed;
+}
+
+function normalizeModelName(displayName: string | undefined, id: string): string {
+	const trimmed = displayName?.trim();
+	return trimmed ? trimmed : id;
+}
+
+function supportsTextGeneration(methods: string[] | undefined): boolean {
+	if (!methods || methods.length === 0) {
+		return false;
+	}
+	return methods.some(method => method === "generateContent");
+}
+
+function inferReasoningFromGeminiId(id: string): boolean {
+	const normalized = id.toLowerCase();
+	if (normalized.includes("thinking")) {
+		return true;
+	}
+	if (normalized.includes("pro") || normalized.includes("2.5")) {
+		return true;
+	}
+	return false;
+}
+
+function inferInputFromGeminiId(id: string): ("text" | "image")[] {
+	const normalized = id.toLowerCase();
+	if (normalized.includes("vision") || normalized.includes("image") || normalized.includes("gemini")) {
+		return ["text", "image"];
+	}
+	return ["text"];
+}