@linxiraos/pi-ai 1.0.0

package/src/registry/parallel.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://platform.parallel.ai/settings?tab=api-keys";
+
+/**
+ * Login to Parallel.
+ *
+ * Opens browser to the API keys page, prompts the user to paste their API key,
+ * and returns the API key directly.
+ */
+export async function loginParallel(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("Parallel");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: "Copy your Parallel API key from the Parallel settings page.",
+	});
+
+	const apiKey = await options.onPrompt({
+		message: "Paste your Parallel API 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 parallelProvider = {
+	id: "parallel",
+	name: "Parallel",
+	envKeys: "PARALLEL_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginParallel(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/perplexity.ts

@@ -0,0 +1,13 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const perplexityProvider = {
+	id: "perplexity",
+	name: "Perplexity (Pro/Max)",
+	envKeys: "PERPLEXITY_API_KEY",
+	login: async (cb: OAuthLoginCallbacks) => {
+		// Lazy import: keep heavy OAuth flow modules out of the eager registry graph.
+		const { loginPerplexity } = await import("./oauth/perplexity");
+		return loginPerplexity(cb);
+	},
+} as const satisfies ProviderDefinition;

package/src/registry/qianfan.ts

@@ -0,0 +1,27 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL = "https://console.bce.baidu.com/qianfan/ais/console/apiKey";
+const API_BASE_URL = "https://qianfan.baidubce.com/v2";
+const VALIDATION_MODEL = "deepseek-v3.2";
+
+export const loginQianfan = createApiKeyLogin({
+	providerLabel: "Qianfan",
+	authUrl: AUTH_URL,
+	instructions: "Copy your Qianfan API key from the console",
+	promptMessage: "Paste your Qianfan API key",
+	placeholder: "bce-v3/ALTAK-...",
+	validation: {
+		kind: "chat-completions",
+		provider: "qianfan",
+		baseUrl: API_BASE_URL,
+		model: VALIDATION_MODEL,
+	},
+});
+
+export const qianfanProvider = {
+	id: "qianfan",
+	name: "Qianfan",
+	login: (cb: OAuthLoginCallbacks) => loginQianfan(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/qwen-portal.ts

@@ -0,0 +1,50 @@
+import * as AIError from "../error";
+import { validateOpenAICompatibleApiKey } from "./api-key-validation";
+import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL = "https://chat.qwen.ai";
+const API_BASE_URL = "https://portal.qwen.ai/v1";
+const VALIDATION_MODEL = "coder-model";
+
+export async function loginQwenPortal(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("Qwen Portal");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: "Copy your Qwen OAuth token or API key",
+	});
+
+	const token = await options.onPrompt({
+		message: "Paste your Qwen OAuth token or API key",
+		placeholder: "sk-...",
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = token.trim();
+	if (!trimmed) {
+		throw new AIError.ApiKeyRequiredError("Qwen token/API key is required");
+	}
+
+	options.onProgress?.("Validating credentials...");
+	await validateOpenAICompatibleApiKey({
+		provider: "qwen-portal",
+		apiKey: trimmed,
+		baseUrl: API_BASE_URL,
+		model: VALIDATION_MODEL,
+		signal: options.signal,
+	});
+
+	return trimmed;
+}
+
+export const qwenPortalProvider = {
+	id: "qwen-portal",
+	name: "Qwen Portal",
+	login: (cb: OAuthLoginCallbacks) => loginQwenPortal(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/registry.ts

@@ -0,0 +1,182 @@
+import type { KnownProvider } from "@linxiraos/pi-catalog";
+import { aiandProvider } from "./aiand";
+import { aimlApiProvider } from "./aimlapi";
+import { alibabaCodingPlanProvider } from "./alibaba-coding-plan";
+import { alibabaTokenPlanProvider } from "./alibaba-token-plan";
+import { amazonBedrockProvider } from "./amazon-bedrock";
+import { anthropicProvider } from "./anthropic";
+import { azureProvider } from "./azure";
+import { basetenProvider } from "./baseten";
+import { bedrockMantleProvider } from "./bedrock-mantle";
+import { cerebrasProvider } from "./cerebras";
+import { cloudflareAiGatewayProvider } from "./cloudflare-ai-gateway";
+import { coreWeaveProvider } from "./coreweave";
+import { cursorProvider } from "./cursor";
+import { deepseekProvider } from "./deepseek";
+import { devinProvider } from "./devin";
+import { exaProvider } from "./exa";
+import { firepassProvider } from "./firepass";
+import { fireworksProvider } from "./fireworks";
+import { githubCopilotProvider } from "./github-copilot";
+import { gitlabDuoProvider } from "./gitlab-duo";
+import { gitLabDuoWorkflowProvider } from "./gitlab-duo-workflow";
+import { gmiCloudProvider } from "./gmi-cloud";
+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 { llamaCppProvider } from "./llama-cpp";
+import { lmStudioProvider } from "./lm-studio";
+import { metaProvider } from "./meta";
+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 { novitaProvider } from "./novita";
+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 { sakanaProvider } from "./sakana";
+import { siliconflowProvider } from "./siliconflow";
+import { siliconflowCnProvider } from "./siliconflow-cn";
+import { syntheticProvider } from "./synthetic";
+import { tavilyProvider } from "./tavily";
+import { togetherProvider } from "./together";
+import type { ProviderDefinition } from "./types";
+import { umansProvider } from "./umans";
+import { veniceProvider } from "./venice";
+import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
+import { vllmProvider } from "./vllm";
+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 { zaiCodingPlanProvider, 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 = [
+	azureProvider,
+	openaiCodexProvider,
+	anthropicProvider,
+	zaiProvider,
+	zaiCodingPlanProvider,
+	kimiCodeProvider,
+	openrouterProvider,
+	githubCopilotProvider,
+	cursorProvider,
+	devinProvider,
+	googleAntigravityProvider,
+	googleGeminiCliProvider,
+	openaiCodexDeviceProvider,
+	xaiProvider,
+	xaiOauthProvider,
+	gitlabDuoProvider,
+	gitLabDuoWorkflowProvider,
+	alibabaCodingPlanProvider,
+	alibabaTokenPlanProvider,
+	aiandProvider,
+	aimlApiProvider,
+	zhipuCodingPlanProvider,
+	umansProvider,
+	qwenPortalProvider,
+	sakanaProvider,
+	minimaxCodeProvider,
+	minimaxCodeCnProvider,
+	xiaomiProvider,
+	xiaomiTokenPlanSgpProvider,
+	xiaomiTokenPlanAmsProvider,
+	xiaomiTokenPlanCnProvider,
+	firepassProvider,
+	deepseekProvider,
+	metaProvider,
+	moonshotProvider,
+	cerebrasProvider,
+	basetenProvider,
+	fireworksProvider,
+	togetherProvider,
+	nvidiaProvider,
+	novitaProvider,
+	huggingfaceProvider,
+	perplexityProvider,
+	qianfanProvider,
+	veniceProvider,
+	siliconflowProvider,
+	siliconflowCnProvider,
+	syntheticProvider,
+	nanogptProvider,
+	waferServerlessProvider,
+	coreWeaveProvider,
+	vercelAiGatewayProvider,
+	cloudflareAiGatewayProvider,
+	litellmProvider,
+	kiloProvider,
+	zenmuxProvider,
+	opencodeZenProvider,
+	opencodeGoProvider,
+	tavilyProvider,
+	kagiProvider,
+	exaProvider,
+	parallelProvider,
+	ollamaProvider,
+	ollamaCloudProvider,
+	lmStudioProvider,
+	llamaCppProvider,
+	vllmProvider,
+	openaiProvider,
+	googleProvider,
+	googleVertexProvider,
+	groqProvider,
+	mistralProvider,
+	minimaxProvider,
+	amazonBedrockProvider,
+	bedrockMantleProvider,
+	gmiCloudProvider,
+];
+
+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/registry/sakana.ts

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

package/src/registry/siliconflow-cn.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginSiliconFlowCn = createApiKeyLogin({
+	providerLabel: "SiliconFlow (China)",
+	authUrl: "https://cloud.siliconflow.cn/account/ak",
+	instructions: "Create or copy your API key from the SiliconFlow console",
+	promptMessage: "Paste your SiliconFlow API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "siliconflow-cn",
+		modelsUrl: "https://api.siliconflow.cn/v1/models",
+	},
+});
+
+export const siliconflowCnProvider = {
+	id: "siliconflow-cn",
+	name: "SiliconFlow (China)",
+	login: (cb: OAuthLoginCallbacks) => loginSiliconFlowCn(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/siliconflow.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginSiliconFlow = createApiKeyLogin({
+	providerLabel: "SiliconFlow",
+	authUrl: "https://cloud.siliconflow.com/account/ak",
+	instructions: "Create or copy your API key from the SiliconFlow console",
+	promptMessage: "Paste your SiliconFlow API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "siliconflow",
+		modelsUrl: "https://api.siliconflow.com/v1/models",
+	},
+});
+
+export const siliconflowProvider = {
+	id: "siliconflow",
+	name: "SiliconFlow",
+	login: (cb: OAuthLoginCallbacks) => loginSiliconFlow(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/synthetic.ts

@@ -0,0 +1,21 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { ProviderDefinition } from "./types";
+
+export const loginSynthetic = createApiKeyLogin({
+	providerLabel: "Synthetic",
+	authUrl: "https://dev.synthetic.new/docs/api/overview",
+	instructions: "Copy your API key from the Synthetic dashboard",
+	promptMessage: "Paste your Synthetic API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "models-endpoint",
+		provider: "Synthetic",
+		modelsUrl: "https://api.synthetic.new/openai/v1/models",
+	},
+});
+
+export const syntheticProvider = {
+	id: "synthetic",
+	name: "Synthetic",
+	login: loginSynthetic,
+} as const satisfies ProviderDefinition;

package/src/registry/tavily.ts

@@ -0,0 +1,45 @@
+import * as AIError from "../error";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const AUTH_URL = "https://app.tavily.com/home";
+
+/**
+ * Login to Tavily.
+ *
+ * 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: OAuthLoginCallbacks): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("Tavily");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: "Copy your Tavily API key from the API Keys page.",
+	});
+
+	const apiKey = await options.onPrompt({
+		message: "Paste your Tavily API key",
+		placeholder: "tvly-...",
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = apiKey.trim();
+	if (!trimmed) {
+		throw new AIError.ApiKeyRequiredError();
+	}
+
+	return trimmed;
+}
+
+export const tavilyProvider = {
+	id: "tavily",
+	name: "Tavily",
+	envKeys: "TAVILY_API_KEY",
+	login: (cb: OAuthLoginCallbacks) => loginTavily(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/together.ts

@@ -0,0 +1,22 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { ProviderDefinition } from "./types";
+
+export const loginTogether = createApiKeyLogin({
+	providerLabel: "Together",
+	authUrl: "https://api.together.xyz/settings/api-keys",
+	instructions: "Copy your API key from the Together dashboard",
+	promptMessage: "Paste your Together API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "chat-completions",
+		provider: "together",
+		baseUrl: "https://api.together.xyz/v1",
+		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,86 @@
+/**
+ * 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
+ * `@linxiraos/pi-catalog`'s descriptor table.
+ */
+
+import type { Api, FetchImpl, Model, SimpleStreamOptions, StreamOptions } from "../types";
+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);
+
+/** Credentials are resolved by the provider transport rather than used as a bearer string. */
+export const AUTHENTICATED_SENTINEL = "<authenticated>";
+
+export interface PreparedProviderRequest {
+	readonly model: Model<Api>;
+	readonly options: StreamOptions;
+}
+
+export type ProviderRequestPreparer = (model: Model<Api>, options: StreamOptions) => PreparedProviderRequest;
+export type ProviderSimpleOptionsMapper = (options: SimpleStreamOptions) => Readonly<Record<string, unknown>>;
+
+export interface ProviderModelDiscoveryConfig {
+	readonly apiKey?: string;
+	readonly baseUrl?: string;
+	readonly fetch?: FetchImpl;
+	readonly authenticated?: boolean;
+}
+
+export type ProviderModelDiscoveryPreparer = (config: ProviderModelDiscoveryConfig) => ProviderModelDiscoveryConfig;
+
+/**
+ * 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;
+	/** Provider transport can authenticate without a resolved API-key string. */
+	readonly allowsMissingApiKey?: boolean;
+	/** Provider-owned request shaping applied before generic API dispatch. */
+	readonly prepareRequest?: ProviderRequestPreparer;
+	/** Provider-owned projection from the generic simple-stream option bag. */
+	readonly mapSimpleOptions?: ProviderSimpleOptionsMapper;
+	/** Provider-owned authentication and endpoint setup for model discovery. */
+	readonly prepareModelDiscovery?: ProviderModelDiscoveryPreparer;
+	// --- 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/registry/umans.ts

@@ -0,0 +1,23 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+export const loginUmans = createApiKeyLogin({
+	providerLabel: "Umans AI Coding Plan",
+	authUrl: "https://app.umans.ai/billing",
+	instructions: "Create or copy your Umans API key from Dashboard → API Keys.",
+	promptMessage: "Paste your Umans API key",
+	placeholder: "sk-...",
+	validation: {
+		kind: "anthropic-messages",
+		provider: "Umans AI Coding Plan",
+		baseUrl: "https://api.code.umans.ai",
+		model: "umans-coder",
+	},
+});
+
+export const umansProvider = {
+	id: "umans",
+	name: "Umans AI Coding Plan",
+	login: (cb: OAuthLoginCallbacks) => loginUmans(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/venice.ts

@@ -0,0 +1,33 @@
+import { createApiKeyLogin } from "./api-key-login";
+import type { 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";
+const VALIDATION_MODEL = "qwen3-4b";
+
+/**
+ * Login to Venice.
+ *
+ * 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 const loginVenice = createApiKeyLogin({
+	providerLabel: "Venice",
+	authUrl: AUTH_URL,
+	instructions: "Copy your API key from the Venice dashboard",
+	promptMessage: "Paste your Venice API key",
+	placeholder: "vapi_...",
+	validation: {
+		kind: "chat-completions",
+		provider: "Venice",
+		baseUrl: API_BASE_URL,
+		model: VALIDATION_MODEL,
+	},
+});
+
+export const veniceProvider = {
+	id: "venice",
+	name: "Venice",
+	login: (cb: OAuthLoginCallbacks) => loginVenice(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/vercel-ai-gateway.ts

@@ -0,0 +1,38 @@
+import * as AIError from "../error";
+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";
+
+export async function loginVercelAiGateway(options: OAuthController): Promise<string> {
+	if (!options.onPrompt) {
+		throw new AIError.OnPromptRequiredError("Vercel AI Gateway");
+	}
+
+	options.onAuth?.({
+		url: AUTH_URL,
+		instructions: "Copy your Vercel AI Gateway API key from the Vercel dashboard",
+	});
+
+	const apiKey = await options.onPrompt({
+		message: "Paste your Vercel AI Gateway API key",
+		placeholder: "vck_...",
+	});
+
+	if (options.signal?.aborted) {
+		throw new AIError.LoginCancelledError();
+	}
+
+	const trimmed = apiKey.trim();
+	if (!trimmed) {
+		throw new AIError.ApiKeyRequiredError();
+	}
+
+	return trimmed;
+}
+
+export const vercelAiGatewayProvider = {
+	id: "vercel-ai-gateway",
+	name: "Vercel AI Gateway",
+	login: (cb: OAuthLoginCallbacks) => loginVercelAiGateway(cb),
+} as const satisfies ProviderDefinition;