@prometheus-ai/ai 0.5.4 → 0.5.8

package/src/registry/registry.ts

@@ -0,0 +1,149 @@
+import type { KnownProvider } from "@prometheus-ai/catalog";
+import { aimlApiProvider } from "./aimlapi";
+import { alibabaCodingPlanProvider } from "./alibaba-coding-plan";
+import { amazonBedrockProvider } from "./amazon-bedrock";
+import { anthropicProvider } from "./anthropic";
+import { cerebrasProvider } from "./cerebras";
+import { cloudflareAiGatewayProvider } from "./cloudflare-ai-gateway";
+import { cursorProvider } from "./cursor";
+import { deepseekProvider } from "./deepseek";
+import { firepassProvider } from "./firepass";
+import { fireworksProvider } from "./fireworks";
+import { githubCopilotProvider } from "./github-copilot";
+import { gitlabDuoProvider } from "./gitlab-duo";
+import { googleProvider } from "./google";
+import { googleAntigravityProvider } from "./google-antigravity";
+import { googleGeminiCliProvider } from "./google-gemini-cli";
+import { googleVertexProvider } from "./google-vertex";
+import { groqProvider } from "./groq";
+import { huggingfaceProvider } from "./huggingface";
+import { kagiProvider } from "./kagi";
+import { kiloProvider } from "./kilo";
+import { kimiCodeProvider } from "./kimi-code";
+import { litellmProvider } from "./litellm";
+import { lmStudioProvider } from "./lm-studio";
+import { minimaxProvider } from "./minimax";
+import { minimaxCodeProvider } from "./minimax-code";
+import { minimaxCodeCnProvider } from "./minimax-code-cn";
+import { mistralProvider } from "./mistral";
+import { moonshotProvider } from "./moonshot";
+import { nanogptProvider } from "./nanogpt";
+import { nvidiaProvider } from "./nvidia";
+import { ollamaProvider } from "./ollama";
+import { ollamaCloudProvider } from "./ollama-cloud";
+import { openaiProvider } from "./openai";
+import { openaiCodexProvider } from "./openai-codex";
+import { openaiCodexDeviceProvider } from "./openai-codex-device";
+import { opencodeGoProvider } from "./opencode-go";
+import { opencodeZenProvider } from "./opencode-zen";
+import { openrouterProvider } from "./openrouter";
+import { parallelProvider } from "./parallel";
+import { perplexityProvider } from "./perplexity";
+import { qianfanProvider } from "./qianfan";
+import { qwenPortalProvider } from "./qwen-portal";
+import { syntheticProvider } from "./synthetic";
+import { tavilyProvider } from "./tavily";
+import { togetherProvider } from "./together";
+import type { ProviderDefinition } from "./types";
+import { veniceProvider } from "./venice";
+import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
+import { vllmProvider } from "./vllm";
+import { waferPassProvider } from "./wafer-pass";
+import { waferServerlessProvider } from "./wafer-serverless";
+import { xaiProvider } from "./xai";
+import { xaiOauthProvider } from "./xai-oauth";
+import { xiaomiProvider } from "./xiaomi";
+import { xiaomiTokenPlanAmsProvider } from "./xiaomi-token-plan-ams";
+import { xiaomiTokenPlanCnProvider } from "./xiaomi-token-plan-cn";
+import { xiaomiTokenPlanSgpProvider } from "./xiaomi-token-plan-sgp";
+import { zaiProvider } from "./zai";
+import { zenmuxProvider } from "./zenmux";
+import { zhipuCodingPlanProvider } from "./zhipu-coding-plan";
+
+/**
+ * The single per-provider list. Adding a provider = create `./providers/<id>.ts`
+ * and add its export here. Every legacy structure (`KnownProvider`/`OAuthProvider`
+ * unions, descriptors, env map, login list, refresh/login dispatch, CLI callback
+ * maps) is derived from this registry. Order matches the interactive `/login`
+ * list for the loginable providers; non-login model providers are appended.
+ */
+const ALL = [
+	openaiCodexProvider,
+	anthropicProvider,
+	zaiProvider,
+	kimiCodeProvider,
+	openrouterProvider,
+	githubCopilotProvider,
+	cursorProvider,
+	googleAntigravityProvider,
+	googleGeminiCliProvider,
+	openaiCodexDeviceProvider,
+	xaiOauthProvider,
+	gitlabDuoProvider,
+	alibabaCodingPlanProvider,
+	aimlApiProvider,
+	zhipuCodingPlanProvider,
+	qwenPortalProvider,
+	minimaxCodeProvider,
+	minimaxCodeCnProvider,
+	xiaomiProvider,
+	xiaomiTokenPlanSgpProvider,
+	xiaomiTokenPlanAmsProvider,
+	xiaomiTokenPlanCnProvider,
+	firepassProvider,
+	waferPassProvider,
+	deepseekProvider,
+	moonshotProvider,
+	cerebrasProvider,
+	fireworksProvider,
+	togetherProvider,
+	nvidiaProvider,
+	huggingfaceProvider,
+	perplexityProvider,
+	qianfanProvider,
+	veniceProvider,
+	syntheticProvider,
+	nanogptProvider,
+	waferServerlessProvider,
+	vercelAiGatewayProvider,
+	cloudflareAiGatewayProvider,
+	litellmProvider,
+	kiloProvider,
+	zenmuxProvider,
+	opencodeZenProvider,
+	opencodeGoProvider,
+	tavilyProvider,
+	kagiProvider,
+	parallelProvider,
+	ollamaProvider,
+	ollamaCloudProvider,
+	lmStudioProvider,
+	vllmProvider,
+	openaiProvider,
+	googleProvider,
+	googleVertexProvider,
+	xaiProvider,
+	groqProvider,
+	mistralProvider,
+	minimaxProvider,
+	amazonBedrockProvider,
+];
+
+export type RegistryDef = (typeof ALL)[number];
+export const PROVIDER_REGISTRY: readonly ProviderDefinition[] = ALL;
+
+const BY_ID = new Map<string, ProviderDefinition>(ALL.map(p => [p.id, p] as [string, ProviderDefinition]));
+
+export function getProviderDefinition(id: string): ProviderDefinition | undefined {
+	return BY_ID.get(id);
+}
+
+/** Compile-time completeness: every catalog chat-model provider must have a registry definition. */
+type _MissingCatalogProviders = Exclude<KnownProvider, RegistryDef["id"]>;
+type _CheckRegistryComplete = _MissingCatalogProviders extends never
+	? true
+	: ["registry is missing catalog providers", _MissingCatalogProviders];
+true satisfies _CheckRegistryComplete;
+
+/** Loginable providers (those carrying a `login` flow). */
+export type OAuthProviderUnion = Extract<RegistryDef, { login: object }>["id"];

package/src/{utils/oauth → registry}/synthetic.ts

@@ -1,5 +1,5 @@
-/** Synthetic login flow (API key paste against https://api.synthetic.new/openai/v1). */
 import { createApiKeyLogin } from "./api-key-login";
+import type { ProviderDefinition } from "./types";
 
 export const loginSynthetic = createApiKeyLogin({
 	providerLabel: "Synthetic",
@@ -13,3 +13,9 @@ export const loginSynthetic = createApiKeyLogin({
 		modelsUrl: "https://api.synthetic.new/openai/v1/models",
 	},
 });
+
+export const syntheticProvider = {
+	id: "synthetic",
+	name: "Synthetic",
+	login: loginSynthetic,
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/tavily.ts

@@ -1,14 +1,5 @@
-/**
- * Tavily login flow.
- *
- * Tavily web search uses an API key from the account settings page.
- * This is an API key flow:
- * 1. Open browser to Tavily settings
- * 2. User copies API key
- * 3. User pastes key into CLI
- */
-
-import type { OAuthController } from "./types";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://app.tavily.com/home";
 
@@ -18,7 +9,7 @@ const AUTH_URL = "https://app.tavily.com/home";
  * Opens browser to API keys page and prompts user to paste their API key.
  * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
  */
-export async function loginTavily(options: OAuthController): Promise<string> {
+export async function loginTavily(options: OAuthLoginCallbacks): Promise<string> {
 	if (!options.onPrompt) {
 		throw new Error("Tavily login requires onPrompt callback");
 	}
@@ -44,3 +35,10 @@ export async function loginTavily(options: OAuthController): Promise<string> {
 
 	return trimmed;
 }
+
+export const tavilyProvider = {
+	id: "tavily",
+	name: "Tavily",
+	envKeys: "TAVILY_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginTavily(cb),
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/together.ts

@@ -1,5 +1,5 @@
-/** Together login flow (API key paste against https://api.together.xyz/v1). */
 import { createApiKeyLogin } from "./api-key-login";
+import type { ProviderDefinition } from "./types";
 
 export const loginTogether = createApiKeyLogin({
 	providerLabel: "Together",
@@ -14,3 +14,9 @@ export const loginTogether = createApiKeyLogin({
 		model: "moonshotai/Kimi-K2.5",
 	},
 });
+
+export const togetherProvider = {
+	id: "together",
+	name: "Together",
+	login: (cb: Parameters<typeof loginTogether>[0]) => loginTogether(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/types.ts

@@ -0,0 +1,56 @@
+/**
+ * Single-source provider auth model. Every provider — model providers,
+ * gateways, search/tool credentials, and login-only flows — is described by
+ * one {@link ProviderDefinition}. The legacy scattered structures (the
+ * `OAuthProvider` union, `serviceProviderMap`, `builtInOAuthProviders`, the
+ * refresh/login switches, and the CLI callback maps) are all *derived* from
+ * the registry of these definitions. Adding a provider is one new file in
+ * `./providers/` plus one line in `./registry.ts`. Model-catalog metadata
+ * (default model, model-manager factory, catalog discovery) lives in
+ * `@prometheus-ai/catalog`'s descriptor table.
+ */
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+
+/**
+ * API-key environment fallback: either a single env var name (e.g.
+ * `"OPENAI_API_KEY"`) or a resolver that inspects several env vars / probes
+ * the host (Vertex ADC, Bedrock credential chains, …).
+ */
+export type KeyResolver = string | (() => string | undefined);
+
+/**
+ * Declarative description of a single provider's auth/login wiring. All
+ * fields are optional except `id`/`name`; presence of a field opts the
+ * provider into a derived structure:
+ *
+ * - `envKeys` present ⇒ env-var fallback in `getEnvApiKey`, overriding the
+ *   catalog table's `envVars` for that provider.
+ * - `login` present ⇒ member of `OAuthProvider`, shown in the `/login` list
+ *   (unless `showInLoginList === false`) and dispatchable via `AuthStorage.login`.
+ * - `callbackPort` present ⇒ entry in the auth-broker `CALLBACK_PORTS` map.
+ * - `pasteCodeFlow` ⇒ member of `PASTE_CODE_LOGIN_PROVIDERS`.
+ *
+ * Heavy OAuth flow modules MUST be reached through dynamic-import thunks in
+ * `login`/`refreshToken` so they stay out of the eager startup graph.
+ */
+export interface ProviderDefinition {
+	readonly id: string;
+	readonly name: string;
+	/** Login-list availability flag. Defaults to true when shown. */
+	readonly available?: boolean;
+	/** Whether to surface in the interactive login list. Defaults to true when `login` is present. */
+	readonly showInLoginList?: boolean;
+	// --- env-var fallback (the catalog table's `envVars` supplies plain names; set this only for computed resolvers) ---
+	readonly envKeys?: KeyResolver;
+	// --- interactive login (OAuthProviderInterface-compatible) ---
+	readonly login?: (callbacks: OAuthLoginCallbacks) => Promise<OAuthCredentials | string>;
+	readonly refreshToken?: (credentials: OAuthCredentials) => Promise<OAuthCredentials>;
+	readonly getApiKey?: (credentials: OAuthCredentials) => string;
+	/** Store OAuth credentials under a different provider id (e.g. `openai-codex-device` ⇒ `openai-codex`). */
+	readonly storeCredentialsAs?: string;
+	// --- coding-agent login UX ---
+	/** Auth-broker local callback-server port. Presence ⇒ entry in `CALLBACK_PORTS`. */
+	readonly callbackPort?: number;
+	/** OAuth flow needs a pasted code/redirect URL rather than a callback server. */
+	readonly pasteCodeFlow?: boolean;
+}

package/src/{utils/oauth → registry}/venice.ts

@@ -1,16 +1,6 @@
-/**
- * Venice login flow.
- *
- * Venice provides OpenAI-compatible models via https://api.venice.ai/api/v1.
- *
- * This is not OAuth - it's a simple API key flow:
- * 1. Open browser to Venice API key settings
- * 2. User copies their API key
- * 3. User pastes the API key into the CLI
- */
-
 import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController } from "./types";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://venice.ai/settings/api";
 const API_BASE_URL = "https://api.venice.ai/api/v1";
@@ -57,3 +47,9 @@ export async function loginVenice(options: OAuthController): Promise<string> {
 
 	return trimmed;
 }
+
+export const veniceProvider = {
+	id: "venice",
+	name: "Venice",
+	login: (cb: OAuthLoginCallbacks) => loginVenice(cb),
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/vercel-ai-gateway.ts

@@ -1,24 +1,8 @@
-/**
- * Vercel AI Gateway login flow.
- *
- * Vercel AI Gateway proxies upstream model providers through a unified endpoint.
- *
- * This is not OAuth - it's a simple API key flow:
- * 1. Open Vercel AI Gateway docs
- * 2. User copies their API key
- * 3. User pastes the API key into the CLI
- */
-
-import type { OAuthController } from "./types";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://vercel.com/d?to=%2F%5Bteam%5D%2F%7E%2Fai-gateway%2Fapi-keys&title=AI+Gateway+API+Keys";
 
-/**
- * Login to Vercel AI Gateway.
- *
- * Opens browser to Vercel AI Gateway docs and prompts for an API key.
- * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
- */
 export async function loginVercelAiGateway(options: OAuthController): Promise<string> {
 	if (!options.onPrompt) {
 		throw new Error("Vercel AI Gateway login requires onPrompt callback");
@@ -45,3 +29,9 @@ export async function loginVercelAiGateway(options: OAuthController): Promise<st
 
 	return trimmed;
 }
+
+export const vercelAiGatewayProvider = {
+	id: "vercel-ai-gateway",
+	name: "Vercel AI Gateway",
+	login: (cb: OAuthLoginCallbacks) => loginVercelAiGateway(cb),
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/vllm.ts

@@ -1,24 +1,11 @@
-/**
- * vLLM login flow.
- *
- * vLLM is commonly self-hosted with an OpenAI-compatible API at a local base URL.
- * Some deployments require a bearer token, others allow unauthenticated access.
- *
- * This flow stores an API-key-style credential used by `/login` and auth storage.
- */
-
-import type { OAuthController, OAuthProvider } from "./types";
+import type { OAuthController, OAuthLoginCallbacks, OAuthProvider } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const PROVIDER_ID: OAuthProvider = "vllm";
 const AUTH_URL = "https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html";
 const DEFAULT_LOCAL_BASE_URL = "http://127.0.0.1:8000/v1";
 const DEFAULT_LOCAL_TOKEN = "vllm-local";
-/**
- * Login to vLLM.
- *
- * Opens vLLM OpenAI-compatible auth docs, prompts for an optional token,
- * and returns a stored key value.
- */
+
 export async function loginVllm(options: OAuthController): Promise<string> {
 	if (!options.onPrompt) {
 		throw new Error(`${PROVIDER_ID} login requires onPrompt callback`);
@@ -38,3 +25,9 @@ export async function loginVllm(options: OAuthController): Promise<string> {
 	const trimmed = apiKey.trim();
 	return trimmed || DEFAULT_LOCAL_TOKEN;
 }
+
+export const vllmProvider = {
+	id: "vllm",
+	name: "vLLM (Local OpenAI-compatible)",
+	login: (cb: OAuthLoginCallbacks) => loginVllm(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/wafer-pass.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const waferPassProvider = {
+	id: "wafer-pass",
+	name: "Wafer Pass (flat-rate subscription)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginWaferPass } = await import("./oauth/wafer");
+		return loginWaferPass(cb);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/wafer-serverless.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const waferServerlessProvider = {
+	id: "wafer-serverless",
+	name: "Wafer Serverless (pay-as-you-go)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginWaferServerless } = await import("./oauth/wafer");
+		return loginWaferServerless(cb);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/xai-oauth.ts

@@ -0,0 +1,17 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const xaiOauthProvider = {
+	id: "xai-oauth",
+	name: "xAI Grok OAuth (SuperGrok Subscription)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginXAIOAuth } = await import("./oauth/xai-oauth");
+		return loginXAIOAuth(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { refreshXAIOAuthToken } = await import("./oauth/xai-oauth");
+		return refreshXAIOAuthToken(credentials.refresh);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/xai.ts

@@ -0,0 +1,6 @@
+import type { ProviderDefinition } from "./types";
+
+export const xaiProvider = {
+	id: "xai",
+	name: "xAI",
+} as const satisfies ProviderDefinition;

package/src/registry/xiaomi-token-plan-ams.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const xiaomiTokenPlanAmsProvider = {
+	id: "xiaomi-token-plan-ams",
+	name: "Xiaomi Token Plan (Europe)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginXiaomiTokenPlan } = await import("./oauth/xiaomi");
+		return loginXiaomiTokenPlan(cb, "ams");
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/xiaomi-token-plan-cn.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const xiaomiTokenPlanCnProvider = {
+	id: "xiaomi-token-plan-cn",
+	name: "Xiaomi Token Plan (China)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginXiaomiTokenPlan } = await import("./oauth/xiaomi");
+		return loginXiaomiTokenPlan(cb, "cn");
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/xiaomi-token-plan-sgp.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const xiaomiTokenPlanSgpProvider = {
+	id: "xiaomi-token-plan-sgp",
+	name: "Xiaomi Token Plan (Singapore)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginXiaomiTokenPlan } = await import("./oauth/xiaomi");
+		return loginXiaomiTokenPlan(cb, "sgp");
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/xiaomi.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const xiaomiProvider = {
+	id: "xiaomi",
+	name: "Xiaomi MiMo",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginXiaomi } = await import("./oauth/xiaomi");
+		return loginXiaomi(cb);
+	},
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/zai.ts

@@ -1,39 +1,21 @@
-/**
- * Z.AI login flow.
- *
- * Z.AI is a platform that provides access to GLM models through an OpenAI-compatible API.
- * API docs: https://docs.z.ai/guides/overview/quick-start
- *
- * This is not OAuth - it's a simple API key flow:
- * 1. User gets their API key from https://z.ai/settings/api-keys
- * 2. User pastes the API key into the CLI
- */
-
 import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController } from "./types";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://z.ai/manage-apikey/apikey-list";
 const API_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
-const VALIDATION_MODEL = "glm-4.7";
-
-/**
- * Login to Z.AI.
- *
- * Opens browser to API keys page, prompts user to paste their API key.
- * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
- */
+const VALIDATION_MODEL = "glm-5.2";
+
 export async function loginZai(options: OAuthController): Promise<string> {
 	if (!options.onPrompt) {
 		throw new Error("Z.AI login requires onPrompt callback");
 	}
 
-	// Open browser to API keys page
 	options.onAuth?.({
 		url: AUTH_URL,
 		instructions: "Copy your API key from the dashboard",
 	});
 
-	// Prompt user to paste their API key
 	const apiKey = await options.onPrompt({
 		message: "Paste your Z.AI API key",
 		placeholder: "sk-...",
@@ -58,3 +40,9 @@ export async function loginZai(options: OAuthController): Promise<string> {
 	});
 	return trimmed;
 }
+
+export const zaiProvider = {
+	id: "zai",
+	name: "Z.AI (GLM Coding Plan)",
+	login: (cb: OAuthLoginCallbacks) => loginZai(cb),
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth → registry}/zenmux.ts

@@ -1,5 +1,6 @@
-/** ZenMux login flow (API key paste, validated via /models). */
 import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 export const loginZenMux = createApiKeyLogin({
 	providerLabel: "ZenMux",
@@ -13,3 +14,9 @@ export const loginZenMux = createApiKeyLogin({
 		modelsUrl: "https://zenmux.ai/api/v1/models",
 	},
 });
+
+export const zenmuxProvider = {
+	id: "zenmux",
+	name: "ZenMux",
+	login: (cb: OAuthLoginCallbacks) => loginZenMux(cb),
+} as const satisfies ProviderDefinition;

package/src/{utils/oauth/zhipu.ts → registry/zhipu-coding-plan.ts}

@@ -1,42 +1,24 @@
-/**
- * Zhipu Coding Plan login flow.
- *
- * GLM Coding Plan provides an OpenAI-compatible API on the dedicated coding
- * endpoint. API docs: https://docs.bigmodel.cn/cn/coding-plan/quick-start
- *
- * Simple API key flow:
- * 1. User gets a Coding Plan API key from https://bigmodel.cn/coding-plan/personal/overview
- * 2. User pastes the API key into the CLI
- */
-
 import { validateOpenAICompatibleApiKey } from "./api-key-validation";
-import type { OAuthController } from "./types";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
 
 const AUTH_URL = "https://bigmodel.cn/coding-plan/personal/overview";
 const API_BASE_URL = "https://open.bigmodel.cn/api/coding/paas/v4";
 const VALIDATION_MODEL = "glm-5.1";
 
-/**
- * Login to Zhipu Coding Plan.
- *
- * Opens browser to API keys page, prompts user to paste their API key.
- * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
- */
 export async function loginZhipuCodingPlan(options: OAuthController): Promise<string> {
 	if (!options.onPrompt) {
 		throw new Error("Zhipu Coding Plan login requires onPrompt callback");
 	}
 
-	// Open browser to API keys page
 	options.onAuth?.({
 		url: AUTH_URL,
 		instructions: "Copy your API key from the Coding Plan dashboard",
 	});
 
-	// Prompt user to paste their API key
 	const apiKey = await options.onPrompt({
 		message: "Paste your Zhipu API key",
-		placeholder: "sk-...",
+		placeholder: "<id>.<secret>",
 	});
 
 	if (options.signal?.aborted) {
@@ -58,3 +40,9 @@ export async function loginZhipuCodingPlan(options: OAuthController): Promise<st
 	});
 	return trimmed;
 }
+
+export const zhipuCodingPlanProvider = {
+	id: "zhipu-coding-plan",
+	name: "Zhipu Coding Plan (智谱)",
+	login: (cb: OAuthLoginCallbacks) => loginZhipuCodingPlan(cb),
+} as const satisfies ProviderDefinition;