@gajae-code/ai 0.1.1

package/src/models.json.d.ts

@@ -0,0 +1,9 @@
+import type { Api } from "./types";
+
+/** Typed declaration for the generated models.json — only the `api` field matters for type inference. */
+declare const models: {
+	[provider: string]: {
+		[modelId: string]: { readonly api: Api; [key: string]: unknown };
+	};
+};
+export default models;

package/src/models.ts

@@ -0,0 +1,56 @@
+import { enrichModelThinking } from "./model-thinking";
+import MODELS from "./models.json" with { type: "json" };
+import type { Api, KnownProvider, Model, Usage } from "./types";
+
+/**
+ * Static bundled model registry loaded from `models.json`.
+ *
+ * This module intentionally exposes compile-time defaults only.
+ * It does not include runtime discovery, models.dev overlays, or on-disk cache state.
+ *
+ * For runtime-aware resolution, use `createModelManager()` / `resolveProviderModels()`.
+ */
+const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
+for (const [provider, models] of Object.entries(MODELS)) {
+	const providerModels = new Map<string, Model<Api>>();
+	for (const [id, model] of Object.entries(models)) {
+		providerModels.set(id, enrichModelThinking(model as Model<Api>));
+	}
+	modelRegistry.set(provider, providerModels);
+}
+
+export type GeneratedProvider = keyof typeof MODELS;
+
+export function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi> {
+	const providerModels = modelRegistry.get(provider);
+	return providerModels?.get(modelId) as Model<TApi>;
+}
+
+export function getBundledProviders(): KnownProvider[] {
+	return Array.from(modelRegistry.keys()) as KnownProvider[];
+}
+
+export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
+	const models = modelRegistry.get(provider);
+	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
+}
+
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+	usage.cost.input = (model.cost.input / 1000000) * usage.input;
+	usage.cost.output = (model.cost.output / 1000000) * usage.output;
+	usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
+	usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export function modelsAreEqual<TApi extends Api>(
+	a: Model<TApi> | null | undefined,
+	b: Model<TApi> | null | undefined,
+): boolean {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}

package/src/prompts/turn-aborted-guidance.md

@@ -0,0 +1,4 @@
+<turn-aborted>
+The previous turn was aborted. Any running tools/commands were terminated. 
+If tools were aborted, they may have partially executed; verify current state before retrying.
+</turn-aborted>

package/src/provider-details.ts

@@ -0,0 +1,90 @@
+import { getOpenAICodexTransportDetails, type OpenAICodexTransportDetails } from "./providers/openai-codex-responses";
+import type { Api, Model, Provider, ProviderSessionState } from "./types";
+
+export interface ProviderDetailField {
+	label: string;
+	value: string;
+}
+
+export interface ProviderDetails {
+	provider: Provider;
+	api: Api;
+	fields: ProviderDetailField[];
+}
+
+export interface ProviderDetailsContext {
+	model: Model<Api>;
+	sessionId?: string;
+	authMode?: string;
+	/**
+	 * Human-readable description of the active credential, e.g.
+	 * `"broker http://can.internal:8765 · oauth #5 (foo@bar.com)"`.
+	 * Rendered as a `Source` field; omitted when undefined.
+	 */
+	credentialSource?: string;
+	preferWebsockets?: boolean;
+	providerSessionState?: Map<string, ProviderSessionState>;
+}
+
+export function getProviderDetails(context: ProviderDetailsContext): ProviderDetails {
+	const endpoint = formatEndpoint(context.model.baseUrl);
+	const fields: ProviderDetailField[] = [
+		{ label: "Model", value: context.model.id },
+		{ label: "API", value: context.model.api },
+		{ label: "Auth", value: context.authMode ?? "auto" },
+		{ label: "Endpoint", value: endpoint },
+	];
+	if (context.credentialSource) {
+		fields.push({ label: "Source", value: context.credentialSource });
+	}
+
+	if (context.model.api === "openai-codex-responses") {
+		const codexDetails = getOpenAICodexTransportDetails(context.model as Model<"openai-codex-responses">, {
+			sessionId: context.sessionId,
+			baseUrl: context.model.baseUrl,
+			preferWebsockets: context.preferWebsockets,
+			providerSessionState: context.providerSessionState,
+		});
+		fields.push({ label: "Transport", value: formatCodexTransport(codexDetails) });
+		fields.push({ label: "WebSocket", value: formatCodexWebSocket(codexDetails) });
+		fields.push({ label: "Reuse", value: formatCodexReuse(codexDetails, context.sessionId) });
+	}
+
+	return {
+		provider: context.model.provider,
+		api: context.model.api,
+		fields,
+	};
+}
+
+function formatEndpoint(baseUrl: string): string {
+	try {
+		const parsed = new URL(baseUrl);
+		const path = parsed.pathname.replace(/\/$/, "");
+		return `${parsed.origin}${path || "/"}`;
+	} catch {
+		return baseUrl;
+	}
+}
+
+function formatCodexTransport(details: OpenAICodexTransportDetails): string {
+	if (details.lastTransport === "websocket") return "websocket";
+	if (details.lastTransport === "sse" && (details.websocketDisabled || details.fallbackCount > 0)) {
+		return "sse (fallback)";
+	}
+	if (details.lastTransport === "sse") return "sse";
+	return details.websocketPreferred ? "websocket preferred" : "sse";
+}
+
+function formatCodexWebSocket(details: OpenAICodexTransportDetails): string {
+	if (!details.websocketPreferred) return "off";
+	if (details.websocketDisabled) return "disabled after fallback";
+	if (details.websocketConnected) return "connected";
+	if (details.prewarmed) return "prewarmed";
+	return details.hasSessionState ? "enabled" : "waiting for first request";
+}
+
+function formatCodexReuse(details: OpenAICodexTransportDetails, sessionId: string | undefined): string {
+	if (!sessionId) return "no session key";
+	return details.canAppend ? "append enabled" : "full request";
+}

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,308 @@
+/**
+ * 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 {
+	alibabaCodingPlanModelManagerOptions,
+	anthropicModelManagerOptions,
+	cerebrasModelManagerOptions,
+	cloudflareAiGatewayModelManagerOptions,
+	deepseekModelManagerOptions,
+	firepassModelManagerOptions,
+	fireworksModelManagerOptions,
+	githubCopilotModelManagerOptions,
+	groqModelManagerOptions,
+	huggingfaceModelManagerOptions,
+	kiloModelManagerOptions,
+	kimiCodeModelManagerOptions,
+	litellmModelManagerOptions,
+	lmStudioModelManagerOptions,
+	mistralModelManagerOptions,
+	moonshotModelManagerOptions,
+	nanoGptModelManagerOptions,
+	nvidiaModelManagerOptions,
+	ollamaModelManagerOptions,
+	openaiModelManagerOptions,
+	opencodeGoModelManagerOptions,
+	opencodeZenModelManagerOptions,
+	openrouterModelManagerOptions,
+	qianfanModelManagerOptions,
+	qwenPortalModelManagerOptions,
+	syntheticModelManagerOptions,
+	togetherModelManagerOptions,
+	veniceModelManagerOptions,
+	vercelAiGatewayModelManagerOptions,
+	vllmModelManagerOptions,
+	xaiModelManagerOptions,
+	xiaomiModelManagerOptions,
+	zenmuxModelManagerOptions,
+} from "./openai-compat";
+import { cursorModelManagerOptions, 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-4-6", config => anthropicModelManagerOptions(config)),
+	catalogDescriptor(
+		"alibaba-coding-plan",
+		"qwen3.5-plus",
+		config => alibabaCodingPlanModelManagerOptions(config),
+		catalog("Alibaba Coding Plan", ["ALIBABA_CODING_PLAN_API_KEY"]),
+	),
+	descriptor("openai", "gpt-5.4", config => openaiModelManagerOptions(config)),
+	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)),
+	descriptor("xai", "grok-4-fast-non-reasoning", config => xaiModelManagerOptions(config)),
+	catalogDescriptor(
+		"deepseek",
+		"deepseek-v4-pro",
+		config => deepseekModelManagerOptions(config),
+		catalog("DeepSeek", ["DEEPSEEK_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)),
+	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 }),
+	catalogDescriptor(
+		"vllm",
+		"gpt-oss-20b",
+		config => vllmModelManagerOptions(config),
+		catalog("vLLM", ["VLLM_API_KEY"], { 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(
+		"zenmux",
+		"anthropic/claude-opus-4.6",
+		config => zenmuxModelManagerOptions(config),
+		catalog("ZenMux", ["ZENMUX_API_KEY"]),
+	),
+	catalogDescriptor("zai", "glm-5.1", config => zaiModelManagerOptions(config), catalog("zAI", ["ZAI_API_KEY"])),
+	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" }),
+	),
+] 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)
+	"alibaba-coding-plan": "qwen3.5-plus",
+	"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-M2.5",
+	"minimax-code": "MiniMax-M2.5",
+	"minimax-code-cn": "MiniMax-M2.5",
+	"openai-codex": "gpt-5.4",
+	"gitlab-duo": "duo-chat-sonnet-4-5",
+} as Record<KnownProvider, string>;

package/src/provider-models/google.ts

@@ -0,0 +1,91 @@
+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,
+						});
+						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";