jeopi-ai 16.2.13

package/src/registry/devin.ts

@@ -0,0 +1,15 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const devinProvider = {
+	id: "devin",
+	name: "Devin",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep OAuth flow modules out of the eager registry graph.
+		const { loginDevin } = await import("./oauth/devin");
+		const credentials = await loginDevin(cb);
+		return credentials.access;
+	},
+	callbackPort: 59653,
+	pasteCodeFlow: true,
+} as const satisfies ProviderDefinition;

package/src/registry/firepass.ts

@@ -0,0 +1,32 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+/**
+ * Fire Pass login flow.
+ *
+ * Fire Pass is a Fireworks subscription product whose dedicated `fpk_…` API
+ * keys are scoped to the `accounts/fireworks/routers/kimi-k2p6-turbo` router
+ * (Kimi K2.6 Turbo). The key does NOT authorize `/v1/models`, so validation
+ * pings the chat completions endpoint with the router id directly.
+ * See https://docs.fireworks.ai/firepass.
+ */
+export const loginFirepass = createApiKeyLogin({
+	providerLabel: "Fire Pass",
+	authUrl: "https://app.fireworks.ai/settings/users/api-keys",
+	instructions: "Create a dedicated Fire Pass API key in the Fireworks dashboard",
+	promptMessage: "Paste your Fire Pass API key",
+	placeholder: "fpk_...",
+	validation: {
+		kind: "chat-completions",
+		provider: "Fire Pass",
+		baseUrl: "https://api.fireworks.ai/inference/v1",
+		model: "accounts/fireworks/routers/kimi-k2p6-turbo",
+	},
+});
+
+export const firepassProvider = {
+	id: "firepass",
+	name: "Fire Pass (Fireworks Kimi K2.6 Turbo subscription)",
+	login: (cb: OAuthLoginCallbacks) => loginFirepass(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/fireworks.ts

@@ -0,0 +1,28 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginFireworks = createApiKeyLogin({
+	providerLabel: "Fireworks",
+	authUrl: "https://app.fireworks.ai/settings/users/api-keys",
+	instructions: "Create or copy your Fireworks API key",
+	promptMessage: "Paste your Fireworks API key",
+	placeholder: "fw_...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "Fireworks",
+		// The OpenAI-compatible inference listing (`/inference/v1/models`) enumerates
+		// the caller's *deployed* models and returns `500 Error listing deployed models`
+		// for accounts without active deployments, which rejected valid `fw_…` keys
+		// during `/login`. The control-plane `List Models` API hits the static
+		// `fireworks` serverless catalog (same endpoint discovery uses) and only
+		// requires the key to authenticate, not to own any deployments.
+		modelsUrl: "https://api.fireworks.ai/v1/accounts/fireworks/models?filter=supports_serverless%3Dtrue&pageSize=1",
+	},
+});
+
+export const fireworksProvider = {
+	id: "fireworks",
+	name: "Fireworks",
+	login: (cb: OAuthLoginCallbacks) => loginFireworks(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/github-copilot.ts

@@ -0,0 +1,22 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const githubCopilotProvider = {
+	id: "github-copilot",
+	name: "GitHub Copilot",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginGitHubCopilot } = await import("./oauth/github-copilot");
+		return loginGitHubCopilot({
+			onAuth: (url, instructions) => cb.onAuth({ url, instructions }),
+			onPrompt: cb.onPrompt,
+			onProgress: cb.onProgress,
+			signal: cb.signal,
+		});
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { refreshGitHubCopilotToken } = await import("./oauth/github-copilot");
+		return refreshGitHubCopilotToken(credentials.refresh, credentials.enterpriseUrl, credentials.apiEndpoint);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/gitlab-duo-workflow.ts

@@ -0,0 +1,20 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const gitLabDuoWorkflowProvider = {
+	id: "gitlab-duo-agent",
+	name: "GitLab Duo Agent",
+	envKeys: "GITLAB_TOKEN",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginGitLabDuoWorkflow } = await import("./oauth/gitlab-duo-workflow");
+		return loginGitLabDuoWorkflow(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { refreshGitLabDuoWorkflowToken } = await import("./oauth/gitlab-duo-workflow");
+		return refreshGitLabDuoWorkflowToken(credentials);
+	},
+	callbackPort: 8080,
+	pasteCodeFlow: true,
+} as const satisfies ProviderDefinition;

package/src/registry/gitlab-duo.ts

@@ -0,0 +1,19 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const gitlabDuoProvider = {
+	id: "gitlab-duo",
+	name: "GitLab Duo Non-Agentic",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginGitLabDuo } = await import("./oauth/gitlab-duo");
+		return loginGitLabDuo(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { refreshGitLabDuoToken } = await import("./oauth/gitlab-duo");
+		return refreshGitLabDuoToken(credentials);
+	},
+	callbackPort: 8080,
+	pasteCodeFlow: true,
+} as const satisfies ProviderDefinition;

package/src/registry/google-antigravity.ts

@@ -0,0 +1,22 @@
+import * as AIError from "../error";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const googleAntigravityProvider = {
+	id: "google-antigravity",
+	name: "Antigravity (Gemini 3, Claude, GPT-OSS)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginAntigravity } = await import("./oauth/google-antigravity");
+		return loginAntigravity(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		if (!credentials.projectId) {
+			throw new AIError.ConfigurationError("Antigravity credentials missing projectId");
+		}
+		const { refreshAntigravityToken } = await import("./oauth/google-antigravity");
+		return refreshAntigravityToken(credentials.refresh, credentials.projectId);
+	},
+	callbackPort: 51121,
+	pasteCodeFlow: true,
+} as const satisfies ProviderDefinition;

package/src/registry/google-gemini-cli.ts

@@ -0,0 +1,22 @@
+import * as AIError from "../error";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const googleGeminiCliProvider = {
+	id: "google-gemini-cli",
+	name: "Google Cloud Code Assist (Gemini CLI)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginGeminiCli } = await import("./oauth/google-gemini-cli");
+		return loginGeminiCli(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		if (!credentials.projectId) {
+			throw new AIError.ConfigurationError("Google Cloud credentials missing projectId");
+		}
+		const { refreshGoogleCloudToken } = await import("./oauth/google-gemini-cli");
+		return refreshGoogleCloudToken(credentials.refresh, credentials.projectId);
+	},
+	callbackPort: 8085,
+	pasteCodeFlow: true,
+} as const satisfies ProviderDefinition;

package/src/registry/google-vertex.ts

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $env } from "jeopi-utils";
+import type { ProviderDefinition } from "./types";
+
+let cachedVertexAdcCredentialsExists: boolean | null = null;
+
+function hasVertexAdcCredentials(): boolean {
+	if (cachedVertexAdcCredentialsExists === null) {
+		const gacPath = $env.GOOGLE_APPLICATION_CREDENTIALS;
+		if (gacPath) {
+			cachedVertexAdcCredentialsExists = fs.existsSync(gacPath);
+		} else {
+			cachedVertexAdcCredentialsExists = fs.existsSync(
+				path.join(os.homedir(), ".config", "gcloud", "application_default_credentials.json"),
+			);
+		}
+	}
+	return cachedVertexAdcCredentialsExists;
+}
+
+export const googleVertexProvider = {
+	id: "google-vertex",
+	name: "Google Vertex AI",
+	// Vertex AI supports either GOOGLE_CLOUD_API_KEY or Application Default Credentials.
+	envKeys: () => {
+		if ($env.GOOGLE_CLOUD_API_KEY) {
+			return $env.GOOGLE_CLOUD_API_KEY;
+		}
+		const hasCredentials = hasVertexAdcCredentials();
+		const hasProject = !!($env.GOOGLE_CLOUD_PROJECT || $env.GCP_PROJECT || $env.GCLOUD_PROJECT);
+		const hasLocation = !!($env.GOOGLE_VERTEX_LOCATION || $env.GOOGLE_CLOUD_LOCATION || $env.VERTEX_LOCATION);
+		if (hasCredentials && hasProject && hasLocation) {
+			return "<authenticated>";
+		}
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/google.ts

@@ -0,0 +1,6 @@
+import type { ProviderDefinition } from "./types";
+
+export const googleProvider = {
+	id: "google",
+	name: "Google Gemini",
+} as const satisfies ProviderDefinition;

package/src/registry/groq.ts

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

package/src/registry/huggingface.ts

@@ -0,0 +1,29 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL =
+	"https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained";
+const API_BASE_URL = "https://router.huggingface.co/v1";
+const VALIDATION_MODEL = "openai/gpt-oss-120b";
+
+export const loginHuggingface = createApiKeyLogin({
+	providerLabel: "Hugging Face",
+	authUrl: AUTH_URL,
+	instructions:
+		"Create/copy a token with Make calls to Inference Providers permission (usable as HUGGINGFACE_HUB_TOKEN or HF_TOKEN)",
+	promptMessage: "Paste your Hugging Face token (HUGGINGFACE_HUB_TOKEN / HF_TOKEN)",
+	placeholder: "hf_...",
+	validation: {
+		kind: "chat-completions",
+		provider: "Hugging Face",
+		baseUrl: API_BASE_URL,
+		model: VALIDATION_MODEL,
+	},
+});
+
+export const huggingfaceProvider = {
+	id: "huggingface",
+	name: "Hugging Face Inference",
+	login: (cb: OAuthLoginCallbacks) => loginHuggingface(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/index.ts

@@ -0,0 +1,4 @@
+export * from "./derived";
+export * from "./oauth";
+export * from "./registry";
+export * from "./types";

package/src/registry/kagi.ts

@@ -0,0 +1,46 @@
+import * as AIError from "../error";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL = "https://kagi.com/settings/api";
+
+/**
+ * Login to Kagi.
+ *
+ * Opens browser to API settings and prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export async function loginKagi(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("Kagi");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions:
+			"Copy your Kagi Search API key from Kagi API settings. Search API access is beta-only; if unavailable, email support@kagi.com.",
+	});
+
+	const apiKey = await options.onPrompt({
+		message: "Paste your Kagi API key",
+		placeholder: "KG_...",
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = apiKey.trim();
+	if (!trimmed) {
+		throw new AIError.ApiKeyRequiredError();
+	}
+
+	return trimmed;
+}
+
+export const kagiProvider = {
+	id: "kagi",
+	name: "Kagi",
+	envKeys: "KAGI_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginKagi(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/kilo.ts

@@ -0,0 +1,114 @@
+import * as AIError from "../error";
+import type { OAuthController, OAuthCredentials } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const KILO_DEVICE_AUTH_BASE_URL = "https://api.kilo.ai/api/device-auth";
+const POLL_INTERVAL_MS = 5000;
+const ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1000;
+
+interface KiloDeviceAuthCodeResponse {
+	code?: string;
+	verificationUrl?: string;
+	expiresIn?: number;
+}
+
+interface KiloDeviceAuthPollResponse {
+	status?: string;
+	token?: string;
+}
+
+export async function loginKilo(callbacks: OAuthController): Promise<OAuthCredentials> {
+	const fetchImpl = callbacks.fetch ?? fetch;
+	const initiateResponse = await fetchImpl(`${KILO_DEVICE_AUTH_BASE_URL}/codes`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+	});
+
+	if (!initiateResponse.ok) {
+		if (initiateResponse.status === 429) {
+			throw new AIError.OAuthError("Too many pending authorization requests. Please try again later.", {
+				kind: "polling",
+				provider: "kilo",
+				status: initiateResponse.status,
+			});
+		}
+		throw new AIError.OAuthError(`Failed to initiate device authorization: ${initiateResponse.status}`, {
+			kind: "device-auth",
+			provider: "kilo",
+			status: initiateResponse.status,
+		});
+	}
+
+	const initiateData = (await initiateResponse.json()) as KiloDeviceAuthCodeResponse;
+	const userCode = initiateData.code;
+	const verificationUrl = initiateData.verificationUrl;
+	const expiresInSeconds = initiateData.expiresIn;
+	if (!userCode || !verificationUrl || typeof expiresInSeconds !== "number" || expiresInSeconds <= 0) {
+		throw new AIError.OAuthError("Kilo device authorization response missing required fields", {
+			kind: "validation",
+			provider: "kilo",
+		});
+	}
+
+	callbacks.onAuth?.({
+		url: verificationUrl,
+		instructions: `Enter code: ${userCode}`,
+	});
+
+	const deadline = Date.now() + expiresInSeconds * 1000;
+	while (Date.now() < deadline) {
+		if (callbacks.signal?.aborted) {
+			throw new AIError.LoginCancelledError();
+		}
+
+		const pollResponse = await fetchImpl(`${KILO_DEVICE_AUTH_BASE_URL}/codes/${encodeURIComponent(userCode)}`);
+		if (pollResponse.status === 202) {
+			await Bun.sleep(POLL_INTERVAL_MS);
+			continue;
+		}
+		if (pollResponse.status === 403) {
+			throw new AIError.OAuthError("Authorization was denied", { kind: "device-auth", provider: "kilo" });
+		}
+		if (pollResponse.status === 410) {
+			throw new AIError.OAuthError("Authorization code expired. Please try again.", {
+				kind: "device-auth",
+				provider: "kilo",
+			});
+		}
+		if (!pollResponse.ok) {
+			throw new AIError.OAuthError(`Failed to poll device authorization: ${pollResponse.status}`, {
+				kind: "polling",
+				provider: "kilo",
+				status: pollResponse.status,
+			});
+		}
+
+		const pollData = (await pollResponse.json()) as KiloDeviceAuthPollResponse;
+		if (pollData.status === "approved" && pollData.token) {
+			return {
+				refresh: "",
+				access: pollData.token,
+				expires: Date.now() + ONE_YEAR_MS,
+			};
+		}
+		if (pollData.status === "denied") {
+			throw new AIError.OAuthError("Authorization was denied", { kind: "device-auth", provider: "kilo" });
+		}
+		if (pollData.status === "expired") {
+			throw new AIError.OAuthError("Authorization code expired. Please try again.", {
+				kind: "device-auth",
+				provider: "kilo",
+			});
+		}
+
+		await Bun.sleep(POLL_INTERVAL_MS);
+	}
+
+	throw new AIError.OAuthError("Authentication timed out. Please try again.", { kind: "timeout", provider: "kilo" });
+}
+
+export const kiloProvider = {
+	id: "kilo",
+	name: "Kilo Gateway",
+	login: loginKilo,
+} as const satisfies ProviderDefinition;

package/src/registry/kimi-code.ts

@@ -0,0 +1,17 @@
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const kimiCodeProvider = {
+	id: "kimi-code",
+	name: "Kimi Code",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginKimi } = await import("./oauth/kimi");
+		return loginKimi(cb);
+	},
+	refreshToken: async (credentials: OAuthCredentials) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { refreshKimiToken } = await import("./oauth/kimi");
+		return refreshKimiToken(credentials.refresh);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/litellm.ts

@@ -0,0 +1,45 @@
+import * as AIError from "../error";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL = "https://docs.litellm.ai/docs/proxy/deploy";
+
+/**
+ * Login to LiteLLM.
+ *
+ * Opens browser to LiteLLM setup docs, prompts user to paste their API key.
+ * Returns the API key directly (not OAuthCredentials - this isn't OAuth).
+ */
+export async function loginLiteLLM(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("LiteLLM");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions:
+			"Run LiteLLM proxy (default http://localhost:4000/v1; set LITELLM_BASE_URL to customize it), then copy your master key or virtual key",
+	});
+
+	const apiKey = await options.onPrompt({
+		message: "Paste your LiteLLM API key (master key or virtual key)",
+		placeholder: "sk-...",
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = apiKey.trim();
+	if (!trimmed) {
+		throw new AIError.ApiKeyRequiredError();
+	}
+
+	return trimmed;
+}
+
+export const litellmProvider = {
+	id: "litellm",
+	name: "LiteLLM",
+	login: (cb: OAuthLoginCallbacks) => loginLiteLLM(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/llama-cpp.ts

@@ -0,0 +1,35 @@
+import * as AIError from "../error";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const PROVIDER_ID = "llama.cpp";
+const AUTH_URL = "https://github.com/ggml-org/llama.cpp#quick-start";
+const DEFAULT_LOCAL_BASE_URL = "http://127.0.0.1:8080";
+const DEFAULT_LOCAL_TOKEN = "llama-cpp-local";
+
+export async function loginLlamaCpp(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError(PROVIDER_ID);
+	}
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: `Paste your llama.cpp API key if your server requires auth. Leave empty for local no-auth mode (default base URL: ${DEFAULT_LOCAL_BASE_URL}; set LLAMA_CPP_BASE_URL to customize).`,
+	});
+	const apiKey = await options.onPrompt({
+		message: "Paste your llama.cpp API key (optional for local no-auth)",
+		placeholder: DEFAULT_LOCAL_TOKEN,
+		allowEmpty: true,
+	});
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+	const trimmed = apiKey.trim();
+	return trimmed || DEFAULT_LOCAL_TOKEN;
+}
+
+export const llamaCppProvider = {
+	id: PROVIDER_ID,
+	name: "llama.cpp (Local OpenAI-compatible)",
+	envKeys: "LLAMA_CPP_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginLlamaCpp(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/lm-studio.ts

@@ -0,0 +1,31 @@
+import * as AIError from "../error";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const PROVIDER_ID = "lm-studio";
+export const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
+
+export async function loginLmStudio(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError(PROVIDER_ID);
+	}
+
+	const apiKey = await options.onPrompt({
+		message: "Optional: Paste LM Studio API key (to customize endpoint URL, set LM_STUDIO_BASE_URL env var)",
+		placeholder: DEFAULT_LOCAL_TOKEN,
+		allowEmpty: true,
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = apiKey.trim();
+	return trimmed || DEFAULT_LOCAL_TOKEN;
+}
+
+export const lmStudioProvider = {
+	id: "lm-studio",
+	name: "LM Studio (Local OpenAI-compatible)",
+	login: (cb: OAuthLoginCallbacks) => loginLmStudio(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/minimax-code-cn.ts

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

package/src/registry/minimax-code.ts

@@ -0,0 +1,12 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const minimaxCodeProvider = {
+	id: "minimax-code",
+	name: "MiniMax Token Plan (International)",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginMiniMaxCode } = await import("./oauth/minimax-code");
+		return loginMiniMaxCode(cb);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/minimax.ts

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

package/src/registry/mistral.ts

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

package/src/registry/moonshot.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginMoonshot = createApiKeyLogin({
+	providerLabel: "Moonshot",
+	authUrl: "https://platform.moonshot.ai/console/api-keys",
+	instructions: "Copy your API key from the Moonshot dashboard",
+	promptMessage: "Paste your Moonshot API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "moonshot",
+		modelsUrl: "https://api.moonshot.ai/v1/models",
+	},
+});
+
+export const moonshotProvider = {
+	id: "moonshot",
+	name: "Moonshot (Kimi API)",
+	login: (cb: OAuthLoginCallbacks) => loginMoonshot(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/nanogpt.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginNanoGPT = createApiKeyLogin({
+	providerLabel: "NanoGPT",
+	authUrl: "https://nano-gpt.com/api",
+	instructions: "Create or copy your NanoGPT API key",
+	promptMessage: "Paste your NanoGPT API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "NanoGPT",
+		modelsUrl: "https://nano-gpt.com/api/v1/models",
+	},
+});
+
+export const nanogptProvider = {
+	id: "nanogpt",
+	name: "NanoGPT",
+	login: (cb: OAuthLoginCallbacks) => loginNanoGPT(cb),
+} as const satisfies ProviderDefinition;