llm-provider-registry 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oratis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# llm-provider-registry
+
+**Give it a model name, get back where to send the request and which key to use.**
+
+```
+"glm-4.6"            → https://open.bigmodel.cn/api/paas/v4   · ZHIPU_API_KEY    · OpenAI-compatible
+"deepseek-chat"      → https://api.deepseek.com/v1            · DEEPSEEK_API_KEY · OpenAI-compatible
+"kimi-k2"            → https://api.moonshot.cn/v1             · MOONSHOT_API_KEY · OpenAI-compatible
+"claude-sonnet-4-6"  → https://api.anthropic.com              · ANTHROPIC_API_KEY· Anthropic SDK
+"gpt-5"              → https://api.openai.com/v1              · OPENAI_API_KEY   · OpenAI SDK
+```
+
+A tiny, **zero-dependency** lookup table + resolver. It knows **16 providers** — including the Chinese ones (Zhipu/GLM, DeepSeek, Moonshot/Kimi, Qwen, Doubao, MiniMax, Baichuan, Yi, Stepfun, Hunyuan) that the big frameworks make you wire up by hand.
+
+## The problem it solves
+
+You want to let users pick *any* model — `gpt-5`, `deepseek-chat`, `glm-4.6`, `qwen3-max`, `claude-…` — and Just Work. Every one of those is reachable through the **OpenAI chat-completions API**, so in principle you only need one SDK. The catch is the plumbing: each provider has its own base URL and its own API-key env var, and nobody ships a maintained table of them — the OpenAI SDK obviously doesn't, and the big frameworks skip most of the Chinese providers.
+
+So everyone ends up hand-copying base URLs off docs pages into a `switch` statement. This is that `switch` statement, curated and tested, as a 2 kB import.
+
+```js
+import OpenAI from "openai";
+import { resolveModel } from "llm-provider-registry";
+
+function clientFor(model) {
+  const p = resolveModel(model);
+  if (!p) throw new Error(`Unknown model: ${model}`);
+  if (!p.openaiCompatible) throw new Error(`${p.provider} needs its own SDK, not OpenAI's`);
+  return new OpenAI({ baseURL: p.baseURL, apiKey: p.apiKey });
+}
+
+// One line, any provider:
+const res = await clientFor("glm-4.6").chat.completions.create({
+  model: "glm-4.6",
+  messages: [{ role: "user", content: "hi" }],
+});
+```
+
+## Install
+
+```bash
+npm install llm-provider-registry
+```
+
+Node ≥ 18. ESM. Ships its own TypeScript types.
+
+## API
+
+### `resolveModel(model, env?) → ResolvedModel | null`
+
+Returns `null` if the model isn't recognized, otherwise:
+
+```ts
+{
+  provider: string;          // "Zhipu (GLM)", "DeepSeek", "Anthropic", …
+  kind: "anthropic" | "openai" | "gemini" | "openai-compatible";
+  baseURL: string;           // point your client here
+  apiKeyEnv: string;         // e.g. "ZHIPU_API_KEY"
+  apiKey: string | undefined;// that var's value, read from `env` (default process.env)
+  openaiCompatible: boolean; // true → use the OpenAI SDK against baseURL
+}
+```
+
+`env` defaults to `process.env`; pass your own object to resolve keys from somewhere else (tests, a config store, per-request overrides).
+
+**`openaiCompatible` is the branch that matters.** It's `true` for everything except Anthropic (`claude-*`), which speaks a different wire protocol — send those to `@anthropic-ai/sdk`. OpenAI, Gemini (via its OpenAI-compat endpoint), and all 13 presets are `true`.
+
+### `hasCredentials(model, env?) → boolean`
+
+`true` only when the model is recognized **and** its API-key env var is set. Handy for filtering a model menu down to the ones the user can actually call:
+
+```js
+const usable = ALL_MODELS.filter((m) => hasCredentials(m));
+```
+
+### `PRESETS`
+
+The raw table of OpenAI-compatible third-party providers, if you'd rather iterate it yourself:
+
+```ts
+{ name: string; modelPrefixes: string[]; baseURL: string; apiKeyEnv: string }[]
+```
+
+## Providers covered
+
+| Provider | Example model prefixes | Base URL | API-key env |
+|---|---|---|---|
+| **Anthropic** | `claude-` | `api.anthropic.com` | `ANTHROPIC_API_KEY` |
+| **OpenAI** | `gpt-`, `o1`, `o3`, `o4`, `chatgpt-` | `api.openai.com/v1` | `OPENAI_API_KEY` |
+| **Google Gemini** | `gemini-` | `…/v1beta/openai/` | `GEMINI_API_KEY` |
+| DeepSeek | `deepseek-` | `api.deepseek.com/v1` | `DEEPSEEK_API_KEY` |
+| Mistral AI | `mistral-`, `codestral-`, `magistral-`, `ministral-`, `pixtral-` | `api.mistral.ai/v1` | `MISTRAL_API_KEY` |
+| Perplexity (Sonar) | `sonar`, `sonar-` | `api.perplexity.ai` | `PERPLEXITY_API_KEY` |
+| xAI Grok | `grok-` | `api.x.ai/v1` | `XAI_API_KEY` |
+| Volcengine Ark (Doubao) | `doubao-`, `ep-` | `ark.cn-beijing.volces.com/api/v3` | `ARK_API_KEY` |
+| Aliyun DashScope (Qwen) | `qwen-`, `qwen2`, `qwen3` | `dashscope.aliyuncs.com/compatible-mode/v1` | `DASHSCOPE_API_KEY` |
+| Moonshot (Kimi) | `moonshot-`, `kimi-` | `api.moonshot.cn/v1` | `MOONSHOT_API_KEY` |
+| Zhipu (GLM) | `glm-`, `chatglm-` | `open.bigmodel.cn/api/paas/v4` | `ZHIPU_API_KEY` |
+| Stepfun (Step) | `step-` | `api.stepfun.com/v1` | `STEPFUN_API_KEY` |
+| 01.AI (Yi) | `yi-` | `api.lingyiwanwu.com/v1` | `LINGYI_API_KEY` |
+| Baichuan | `baichuan-`, `baichuan2/3/4` | `api.baichuan-ai.com/v1` | `BAICHUAN_API_KEY` |
+| MiniMax | `abab`, `minimax-` | `api.minimax.io/v1` | `MINIMAX_API_KEY` |
+| Tencent Hunyuan | `hunyuan-` | `api.hunyuan.cloud.tencent.com/v1` | `HUNYUAN_API_KEY` |
+
+Matching is by **case-insensitive prefix**, so `glm-4.6`, `glm-4-flash`, and `GLM-4.6` all resolve to Zhipu — new model releases usually keep the family prefix and Just Work without a library bump.
+
+## What it deliberately isn't
+
+- **Not an API client.** It hands you a `baseURL` + key; you bring your own SDK. That's the point — it stays 2 kB and never breaks when a provider tweaks a response field.
+- **Not a param translator.** It doesn't reshape requests between the Anthropic and OpenAI schemas. It only tells you which family a model belongs to (`kind`) so you know which SDK to reach for.
+- **Not exhaustive on models.** It matches *families* by prefix, not an ever-changing list of exact model IDs.
+
+## License
+
+MIT © 2026 oratis

package/index.d.ts

@@ -0,0 +1,40 @@
+export interface Preset {
+  name: string;
+  modelPrefixes: string[];
+  baseURL: string;
+  apiKeyEnv: string;
+}
+
+/** OpenAI-compatible third-party providers, keyed by model-name prefix. */
+export const PRESETS: Preset[];
+
+export type ProviderKind = "anthropic" | "openai" | "gemini" | "openai-compatible";
+
+export interface ResolvedModel {
+  /** Human-readable provider name, e.g. "Zhipu (GLM)". */
+  provider: string;
+  kind: ProviderKind;
+  /** API base URL to point your client at. */
+  baseURL: string;
+  /** Env var that holds this provider's API key. */
+  apiKeyEnv: string;
+  /** The key's value from the provided env (or undefined if unset). */
+  apiKey: string | undefined;
+  /** True when you can use the OpenAI chat-completions SDK against `baseURL`. */
+  openaiCompatible: boolean;
+}
+
+/**
+ * Resolve a model name to its provider endpoint + credential.
+ * Returns `null` if the model isn't recognized.
+ */
+export function resolveModel(
+  model: string,
+  env?: Record<string, string | undefined>,
+): ResolvedModel | null;
+
+/** True iff the model is recognized AND its API-key env var is set. */
+export function hasCredentials(
+  model: string,
+  env?: Record<string, string | undefined>,
+): boolean;

package/index.mjs

@@ -0,0 +1,71 @@
+// llm-provider-registry — map an LLM model name to the endpoint + credential it
+// needs. Given "glm-4.6", "deepseek-chat", "kimi-k2", "grok-4", "claude-…",
+// "gpt-…", tells you the base URL, which API-key env var, and whether it speaks
+// the OpenAI chat-completions API — so you can point one SDK anywhere.
+//
+// Curated for 16 providers the big frameworks don't cover (esp. Chinese ones).
+// Zero dependencies. Pure data + string matching.
+
+/** @typedef {{ name: string, modelPrefixes: string[], baseURL: string, apiKeyEnv: string }} Preset */
+
+/** OpenAI-compatible third-party providers, keyed by model-name prefix. */
+export const PRESETS = [
+  // ── International ──
+  { name: "DeepSeek",            modelPrefixes: ["deepseek-"],                                        baseURL: "https://api.deepseek.com/v1",                        apiKeyEnv: "DEEPSEEK_API_KEY" },
+  { name: "Mistral AI",          modelPrefixes: ["mistral-", "codestral-", "magistral-", "ministral-", "pixtral-"], baseURL: "https://api.mistral.ai/v1",         apiKeyEnv: "MISTRAL_API_KEY" },
+  { name: "Perplexity (Sonar)",  modelPrefixes: ["sonar-", "sonar"],                                  baseURL: "https://api.perplexity.ai",                          apiKeyEnv: "PERPLEXITY_API_KEY" },
+  { name: "xAI Grok",            modelPrefixes: ["grok-"],                                            baseURL: "https://api.x.ai/v1",                                apiKeyEnv: "XAI_API_KEY" },
+  // ── Chinese ──
+  { name: "Volcengine Ark (Doubao)", modelPrefixes: ["doubao-", "ep-"],                              baseURL: "https://ark.cn-beijing.volces.com/api/v3",           apiKeyEnv: "ARK_API_KEY" },
+  { name: "Aliyun DashScope (Qwen)", modelPrefixes: ["qwen-", "qwen2", "qwen3"],                     baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",  apiKeyEnv: "DASHSCOPE_API_KEY" },
+  { name: "Moonshot (Kimi)",     modelPrefixes: ["moonshot-", "kimi-"],                               baseURL: "https://api.moonshot.cn/v1",                         apiKeyEnv: "MOONSHOT_API_KEY" },
+  { name: "Zhipu (GLM)",         modelPrefixes: ["glm-", "chatglm-"],                                 baseURL: "https://open.bigmodel.cn/api/paas/v4",               apiKeyEnv: "ZHIPU_API_KEY" },
+  { name: "Stepfun (Step)",      modelPrefixes: ["step-"],                                            baseURL: "https://api.stepfun.com/v1",                         apiKeyEnv: "STEPFUN_API_KEY" },
+  { name: "01.AI (Yi)",          modelPrefixes: ["yi-"],                                              baseURL: "https://api.lingyiwanwu.com/v1",                     apiKeyEnv: "LINGYI_API_KEY" },
+  { name: "Baichuan",            modelPrefixes: ["baichuan-", "baichuan2", "baichuan3", "baichuan4"], baseURL: "https://api.baichuan-ai.com/v1",                     apiKeyEnv: "BAICHUAN_API_KEY" },
+  { name: "MiniMax",             modelPrefixes: ["abab", "minimax-"],                                 baseURL: "https://api.minimax.io/v1",                          apiKeyEnv: "MINIMAX_API_KEY" },
+  { name: "Tencent Hunyuan",     modelPrefixes: ["hunyuan-"],                                         baseURL: "https://api.hunyuan.cloud.tencent.com/v1",           apiKeyEnv: "HUNYUAN_API_KEY" },
+];
+
+// First-party providers (matched before the presets).
+const FIRST_PARTY = [
+  { name: "Anthropic", kind: "anthropic", test: (m) => m.startsWith("claude-"),
+    baseURL: "https://api.anthropic.com", apiKeyEnv: "ANTHROPIC_API_KEY", openaiCompatible: false },
+  { name: "OpenAI", kind: "openai", test: (m) => /^(gpt-|o1|o3|o4|chatgpt-)/.test(m),
+    baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", openaiCompatible: true },
+  { name: "Google Gemini", kind: "gemini", test: (m) => m.startsWith("gemini-"),
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/", apiKeyEnv: "GEMINI_API_KEY", openaiCompatible: true },
+];
+
+/**
+ * Resolve a model name to its provider endpoint + credential.
+ * @param {string} model  e.g. "glm-4.6", "deepseek-chat", "claude-sonnet-4-6", "gpt-5"
+ * @param {Record<string,string|undefined>} [env]  where to read the API key (default process.env)
+ * @returns {{ provider: string, kind: "anthropic"|"openai"|"gemini"|"openai-compatible",
+ *            baseURL: string, apiKeyEnv: string, apiKey: string|undefined,
+ *            openaiCompatible: boolean } | null}  null if the model isn't recognized.
+ */
+export function resolveModel(model, env = process.env) {
+  if (!model) return null;
+  const m = String(model).toLowerCase();
+
+  for (const p of FIRST_PARTY) {
+    if (p.test(m)) {
+      return { provider: p.name, kind: p.kind, baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv,
+               apiKey: env?.[p.apiKeyEnv], openaiCompatible: p.openaiCompatible };
+    }
+  }
+  for (const p of PRESETS) {
+    if (p.modelPrefixes.some((pre) => m.startsWith(pre.toLowerCase()))) {
+      return { provider: p.name, kind: "openai-compatible", baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv,
+               apiKey: env?.[p.apiKeyEnv], openaiCompatible: true };
+    }
+  }
+  return null;
+}
+
+/** True iff the model is recognized AND its API-key env var is set (non-empty). */
+export function hasCredentials(model, env = process.env) {
+  const r = resolveModel(model, env);
+  return !!(r && r.apiKey && r.apiKey.trim());
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "llm-provider-registry",
+  "version": "1.0.0",
+  "description": "Map any LLM model name (glm-4.6, deepseek-chat, kimi-k2, grok-4, claude-…, gpt-…) to its API base URL + key env var. Curated for 16 providers — incl. the Chinese ones the big frameworks don't ship. Zero deps.",
+  "type": "module",
+  "main": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.mjs"
+    }
+  },
+  "files": [
+    "index.mjs",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "llm",
+    "openai",
+    "anthropic",
+    "gemini",
+    "deepseek",
+    "qwen",
+    "glm",
+    "kimi",
+    "moonshot",
+    "doubao",
+    "grok",
+    "mistral",
+    "provider",
+    "router",
+    "base-url",
+    "openai-compatible"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "author": "oratis",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oratis/llm-provider-registry.git"
+  },
+  "homepage": "https://github.com/oratis/llm-provider-registry#readme"
+}