litellmts-core 1.0.1 → 2.0.0

package/README.md

@@ -42,7 +42,7 @@ npm install litellmts-core
 import { completion } from 'litellmts-core';
 
 const response = await completion({
-  model: 'gpt-4o-mini',
+  model: 'openai/gpt-4o-mini',
   messages: [{ role: 'user', content: 'Hello!' }],
 });
 
@@ -53,7 +53,7 @@ Swap providers by changing just the model string:
 
 ```ts
 // Same code, different provider:
-await completion({ model: 'claude-sonnet-4-20250514', ... });
+await completion({ model: 'anthropic/claude-sonnet-4-20250514', ... });
 await completion({ model: 'gemini/gemini-2.5-pro', ... });
 await completion({ model: 'groq/llama-3.3-70b', ... });
 await completion({ model: 'deepseek/deepseek-chat', ... });
@@ -63,11 +63,13 @@ await completion({ model: 'deepseek/deepseek-chat', ... });
 
 - **Unified API** — same `completion()` / `embedding()` for every provider
 - **Streaming** — all providers support `stream: true`
+- **Model listing** — `listModels('openai')` fetches available models from each provider's API
+- **Provider discovery** — `listProviders()` returns all configured providers
 - **TypeScript first** — full type safety with auto-completion
 - **45+ providers** — from OpenAI to niche OpenAI-compatible APIs
 - **No SDK sprawl** — one dependency replaces 10+ vendor SDKs
-- **CLI auth** — built-in OAuth device flow for GitHub Copilot
-- **Persistent auth store** — `~/.litellm/auth.json`
+- **CLI auth** — built-in OAuth device flow for GitHub Copilot & API key setup for Anthropic
+- **Encrypted auth store** — `~/.litellm/auth.json` protected with AES-256-GCM (key derived from machine + user)
 
 ## Usage
 
@@ -77,7 +79,7 @@ await completion({ model: 'deepseek/deepseek-chat', ... });
 import { completion } from 'litellmts-core';
 
 const response = await completion({
-  model: 'gpt-4o-mini',
+  model: 'openai/gpt-4o-mini',
   messages: [
     { role: 'system', content: 'You are a helpful assistant.' },
     { role: 'user', content: 'What is TypeScript?' },
@@ -96,7 +98,7 @@ console.log(response.usage);
 
 ```ts
 const stream = await completion({
-  model: 'claude-sonnet-4-20250514',
+  model: 'anthropic/claude-sonnet-4-20250514',
   messages: [{ role: 'user', content: 'Write a poem' }],
   stream: true,
 });
@@ -112,13 +114,33 @@ for await (const chunk of stream) {
 import { embedding } from 'litellmts-core';
 
 const result = await embedding({
-  model: 'text-embedding-3-small',
+  model: 'openai/text-embedding-3-small',
   input: 'Hello world',
 });
 
 console.log(result.data[0].embedding); // number[]
 ```
 
+### Model Discovery
+
+```ts
+import { listModels, listProviders, clearModelCache } from 'litellmts-core';
+
+// List all available models for a provider (fetched live from their API)
+const models = await listModels('openai');
+// => [{ id: 'gpt-4o', provider: 'openai', created: 1700000000 }, ...]
+
+// List all configured providers
+const providers = listProviders();
+// => [{ name: 'openai', hasModelList: true }, { name: 'groq', hasModelList: true }, ...]
+
+// Get models for a specific provider with apiKey override
+const groqModels = await listModels('groq', { apiKey: 'gsk_...' });
+
+// Clear cached model lists (re-fetches on next call)
+clearModelCache();
+```
+
 ### API Keys
 
 Keys are read from environment variables by default:
@@ -153,17 +175,17 @@ npx litellm login anthropic
 
 ### Dedicated Handlers
 
-| Provider | Prefix | Completion | Streaming | Embedding | API Key Env |
-|---|---|---|---|---|---|
-| OpenAI | `gpt-*`, `openai/` | ✅ | ✅ | ✅ | `OPENAI_API_KEY` |
-| Anthropic | `claude-*` | ✅ | ✅ | ❌ | `ANTHROPIC_API_KEY` |
+| Provider | Model prefix | Completion | Streaming | Embedding | API Key Env |
+|---|---|---|---|---|---|---|
+| OpenAI | `openai/` | ✅ | ✅ | ✅ | `OPENAI_API_KEY` |
+| Anthropic | `anthropic/` | ✅ | ✅ | ❌ | `ANTHROPIC_API_KEY` |
 | Google Gemini | `gemini/` | ✅ | ✅ | ✅ | `GEMINI_API_KEY` |
 | GitHub Copilot | `copilot/` | ✅ | ✅ | ❌ | (OAuth) |
 | Mistral | `mistral/` | ✅ | ✅ | ✅ | `MISTRAL_API_KEY` |
-| Cohere | `command*` | ✅ | ✅ | ❌ | `COHERE_API_KEY` |
+| Cohere | `cohere/` | ✅ | ✅ | ❌ | `COHERE_API_KEY` |
 | DeepInfra | `deepinfra/` | ✅ | ✅ | ❌ | `DEEPINFRA_API_KEY` |
 | Replicate | `replicate/` | ✅ | ✅ | ❌ | `REPLICATE_API_KEY` |
-| AI21 Labs | `j2-*`, `ai21/` | ✅ | ✅ | ❌ | `AI21_API_KEY` |
+| AI21 Labs | `ai21/` | ✅ | ✅ | ❌ | `AI21_API_KEY` |
 | Ollama (local) | `ollama/` | ✅ | ✅ | ✅ | — |
 
 ### OpenAI-Compatible (38 providers)
@@ -213,16 +235,19 @@ npx litellm login anthropic
 ┌──────────────┐     ┌──────────────┐     ┌─────────────────┐
 │  completion() │────▶│  getHandler() │────▶│  OpenAIHandler   │
 │  embedding()  │     │  (prefix      │     │  AnthropicHandler│
-│               │     │   matching)   │     │  GeminiHandler   │
-│               │     │              │     │  OpenAILikeHandler│
+│  listModels() │     │   matching)   │     │  GeminiHandler   │
+│  listProviders│     │              │     │  OpenAILikeHandler│
 └──────────────┘     └──────────────┘     └─────────────────┘
                            │
-                    ┌──────┴──────┐
-                    │  Registry   │
-                    │  groq/ → .  │
-                    │  claude- →  │
-                    │  gpt- → ..  │
-                    └─────────────┘
+                    ┌──────┴──────┐       ┌──────────────────┐
+                    │  Registry   │       │  Model Registry  │
+                    │  openai/ →  │       │  (in-memory      │
+                    │  anthropic/ │       │   cache + TTL)   │
+                    │  groq/ → .. │       │                  │
+                    └─────────────┘       │  listModels()    │
+                                          │  listProviders() │
+                                          │  clearModelCache()│
+                                          └──────────────────┘
 ```
 
 ## Development

package/dist/auth/copilot.js

@@ -18,13 +18,13 @@ function openBrowser(url) {
     const platform = process.platform;
     try {
         if (platform === 'darwin') {
-            (0, node_child_process_1.execSync)(`open "${url}"`, { stdio: 'ignore' });
+            (0, node_child_process_1.execFileSync)('open', [url], { stdio: 'ignore' });
         }
         else if (platform === 'win32') {
-            (0, node_child_process_1.execSync)(`start "" "${url}"`, { stdio: 'ignore' });
+            (0, node_child_process_1.execFileSync)('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
         }
         else {
-            (0, node_child_process_1.execSync)(`xdg-open "${url}" 2>/dev/null || sensible-browser "${url}" 2>/dev/null || x-www-browser "${url}"`, { stdio: 'ignore' });
+            (0, node_child_process_1.execFileSync)('xdg-open', [url], { stdio: 'ignore' });
         }
     }
     catch {

package/dist/auth/store.d.ts

@@ -1,3 +1,4 @@
+export declare function decrypt(payload: string): string;
 /** GitHub Copilot OAuth credentials. */
 export interface CopilotCredentials {
     githubToken: string;

package/dist/auth/store.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = decrypt;
 exports.getProviderCredentials = getProviderCredentials;
 exports.setProviderCredentials = setProviderCredentials;
 exports.getCopilotCredentials = getCopilotCredentials;
@@ -10,6 +11,38 @@ exports.clearCredentials = clearCredentials;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const PEPPER = 'litellmts-core@v1';
+function deriveKey() {
+    const seed = `${(0, node_os_1.hostname)()}-${process.getuid?.() ?? process.pid}-${PEPPER}`;
+    return (0, node_crypto_1.scryptSync)(seed, 'credentials-key-salt', KEY_LENGTH);
+}
+function encrypt(plaintext) {
+    const key = deriveKey();
+    const iv = (0, node_crypto_1.randomBytes)(IV_LENGTH);
+    const cipher = (0, node_crypto_1.createCipheriv)(ALGORITHM, key, iv);
+    let encrypted = cipher.update(plaintext, 'utf-8', 'hex');
+    encrypted += cipher.final('hex');
+    const tag = cipher.getAuthTag().toString('hex');
+    return `${iv.toString('hex')}:${tag}:${encrypted}`;
+}
+function decrypt(payload) {
+    const parts = payload.split(':');
+    if (parts.length < 3)
+        throw new Error('Invalid encrypted payload');
+    const iv = Buffer.from(parts.shift(), 'hex');
+    const tag = Buffer.from(parts.shift(), 'hex');
+    const encrypted = parts.join(':');
+    const key = deriveKey();
+    const decipher = (0, node_crypto_1.createDecipheriv)(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    let plaintext = decipher.update(encrypted, 'hex', 'utf-8');
+    plaintext += decipher.final('utf-8');
+    return plaintext;
+}
 const STORE_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), '.litellm');
 const STORE_PATH = (0, node_path_1.join)(STORE_DIR, 'auth.json');
 function isNotFound(err) {
@@ -20,8 +53,11 @@ async function ensureDir() {
 }
 async function readStore() {
     try {
-        const data = await (0, promises_1.readFile)(STORE_PATH, 'utf-8');
-        return JSON.parse(data);
+        const raw = await (0, promises_1.readFile)(STORE_PATH, 'utf-8');
+        if (!raw.startsWith('{')) {
+            return JSON.parse(decrypt(raw));
+        }
+        return JSON.parse(raw);
     }
     catch (err) {
         if (isNotFound(err))
@@ -29,6 +65,11 @@ async function readStore() {
         throw err;
     }
 }
+async function writeStore(data) {
+    const plaintext = JSON.stringify(data);
+    const encrypted = encrypt(plaintext);
+    await (0, promises_1.writeFile)(STORE_PATH, encrypted, 'utf-8');
+}
 async function getProviderCredentials(provider) {
     try {
         const store = await readStore();
@@ -47,9 +88,8 @@ async function setProviderCredentials(provider, creds) {
     await ensureDir();
     const store = await readStore();
     store[provider] = creds;
-    await (0, promises_1.writeFile)(STORE_PATH, JSON.stringify(store, null, 2), 'utf-8');
+    await writeStore(store);
 }
-// Backward-compat old single-provider format
 async function getCopilotCredentials() {
     const legacy = await getProviderCredentials('github-copilot');
     if (legacy)
@@ -83,7 +123,7 @@ async function setAnthropicCredentials(creds) {
 }
 async function clearCredentials() {
     try {
-        await (0, promises_1.writeFile)(STORE_PATH, JSON.stringify({}), 'utf-8');
+        await writeStore({});
     }
     catch {
         // ignore

package/dist/handlers/ai21.js

@@ -56,9 +56,11 @@ async function AI21Handler(params) {
     const apiKey = params.apiKey ?? process.env.AI21_API_KEY;
     if (!apiKey)
         throw new Error('AI21 requires an API key. Set AI21_API_KEY environment variable or pass apiKey in params.');
-    const model = params.model;
+    const modelName = params.model.startsWith('ai21/')
+        ? params.model.slice(5)
+        : params.model;
     const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
-    const res = await getAI21Response(model, prompt, baseUrl, apiKey, params.stream ?? false);
+    const res = await getAI21Response(modelName, prompt, baseUrl, apiKey, params.stream ?? false);
     if (!res.ok) {
         throw new Error(`Received an error with code ${res.status} from AI21 API.`);
     }
@@ -66,7 +68,7 @@ async function AI21Handler(params) {
         return (0, sse_1.iterateSSEStream)(res, (payload) => {
             const parsed = JSON.parse(payload);
             return {
-                model,
+                model: modelName,
                 created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
                 choices: [
                     {
@@ -81,7 +83,7 @@ async function AI21Handler(params) {
         });
     }
     const body = (await res.json());
-    return toResponse(body, model);
+    return toResponse(body, modelName);
 }
 const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('j2-', AI21Handler);
+(0, registry_1.registerCompletionHandler)('ai21/', AI21Handler);

package/dist/handlers/anthropic.d.ts

@@ -1,2 +1,2 @@
-import { HandlerParams, ResultStreaming, ResultNotStreaming } from '../types';
+import type { HandlerParams, ResultNotStreaming, ResultStreaming } from '../types';
 export declare function AnthropicHandler(params: HandlerParams): Promise<ResultNotStreaming | ResultStreaming>;

package/dist/handlers/anthropic.js

@@ -5,81 +5,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicHandler = AnthropicHandler;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
-const toUsage_1 = require("../utils/toUsage");
+const anthropic_1 = require("../utils/anthropic");
 const auth_1 = require("../auth");
-function toAnthropicPrompt(messages) {
-    return messages
-        .map((msg) => {
-        const content = msg.content ?? '';
-        if (msg.role === 'assistant') {
-            return `${sdk_1.default.AI_PROMPT} ${content}`;
-        }
-        return `${sdk_1.default.HUMAN_PROMPT} ${content}`;
-    })
-        .join('') + sdk_1.default.AI_PROMPT;
-}
-function toFinishReson(string) {
-    if (string === 'max_tokens') {
-        return 'length';
-    }
-    return 'stop';
-}
-function toResponse(anthropicResponse, prompt) {
-    return {
-        model: anthropicResponse.model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: (0, toUsage_1.toUsage)(prompt, anthropicResponse.completion),
-        choices: [
-            {
-                message: {
-                    content: anthropicResponse.completion,
-                    role: 'assistant',
-                },
-                finish_reason: toFinishReson(anthropicResponse.stop_reason),
-                index: 0,
-            },
-        ],
-    };
-}
-function toStreamingChunk(anthropicResponse) {
-    return {
-        model: anthropicResponse.model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        choices: [
-            {
-                delta: { content: anthropicResponse.completion, role: 'assistant' },
-                finish_reason: toFinishReson(anthropicResponse.stop_reason),
-                index: 0,
-            },
-        ],
-    };
-}
-async function* toStreamingResponse(stream) {
-    for await (const chunk of stream) {
-        yield toStreamingChunk(chunk);
-    }
-}
+const registry_1 = require("../models/registry");
 async function AnthropicHandler(params) {
     const apiKey = params.apiKey ?? process.env.ANTHROPIC_API_KEY ?? (await (0, auth_1.getAnthropicKey)());
-    const anthropic = new sdk_1.default({
-        apiKey: apiKey,
-    });
-    const prompt = toAnthropicPrompt(params.messages);
+    const modelName = params.model.startsWith('anthropic/')
+        ? params.model.slice(10)
+        : params.model;
+    const anthropic = new sdk_1.default({ apiKey });
+    const { system, messages } = (0, anthropic_1.toAnthropicMessages)(params.messages);
     const anthropicParams = {
-        model: params.model,
-        max_tokens_to_sample: params.max_tokens ?? 300,
-        prompt,
+        model: modelName,
+        max_tokens: params.max_tokens ?? 300,
+        messages,
+        ...(system ? { system } : {}),
     };
-    if (params.stream) {
-        const completionStream = await anthropic.completions.create({
-            ...anthropicParams,
-            stream: params.stream,
-        });
-        return toStreamingResponse(completionStream);
+    try {
+        if (params.stream) {
+            const stream = await anthropic.messages.create({
+                ...anthropicParams,
+                stream: true,
+            });
+            return (0, anthropic_1.toAnthropicStreamingResponse)(stream);
+        }
+        const message = await anthropic.messages.create(anthropicParams);
+        return (0, anthropic_1.toAnthropicResponse)(message);
+    }
+    catch (err) {
+        throw new Error(`Anthropic API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
-    const completion = await anthropic.completions.create(anthropicParams);
-    return toResponse(completion, prompt);
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('claude-', AnthropicHandler);
+(0, registry_1.registerModelProvider)('anthropic', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.anthropic.com/v1/models', {
+        headers: { 'x-api-key': key, 'anthropic-version': '2023-06-01' },
+    });
+    const { data } = await res.json();
+    return data.map((m) => ({ id: m.id, provider: 'anthropic' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('anthropic/', AnthropicHandler);

package/dist/handlers/cohere.js

@@ -2,56 +2,110 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CohereHandler = CohereHandler;
 const cohere_ai_1 = require("cohere-ai");
-const combinePrompts_1 = require("../utils/combinePrompts");
 const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
-const toUsage_1 = require("../utils/toUsage");
+const registry_1 = require("../models/registry");
+function toChatHistory(messages) {
+    let system;
+    const chatMessages = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            system = (system ? system + '\n' : '') + (msg.content ?? '');
+        }
+        else {
+            chatMessages.push(msg);
+        }
+    }
+    let lastUserMessage = '';
+    const chatHistory = [];
+    for (let i = 0; i < chatMessages.length; i++) {
+        const msg = chatMessages[i];
+        const isLastUser = i === chatMessages.length - 1 && msg.role === 'user';
+        if (isLastUser) {
+            lastUserMessage = msg.content ?? '';
+        }
+        else if (msg.role === 'user') {
+            chatHistory.push({ role: 'USER', message: msg.content ?? '' });
+        }
+        else if (msg.role === 'assistant') {
+            chatHistory.push({ role: 'CHATBOT', message: msg.content ?? '' });
+        }
+    }
+    if (!lastUserMessage && chatMessages.length > 0) {
+        const last = chatMessages[chatMessages.length - 1];
+        lastUserMessage = last.content ?? '';
+    }
+    return {
+        message: lastUserMessage,
+        ...(chatHistory.length > 0 ? { chatHistory } : {}),
+        ...(system ? { preamble: system } : {}),
+    };
+}
 async function CohereHandler(params) {
     const apiKey = params.apiKey ?? process.env.COHERE_API_KEY;
     if (!apiKey)
         throw new Error('Cohere requires an API key. Set COHERE_API_KEY environment variable or pass apiKey in params.');
+    const modelName = params.model.startsWith('cohere/')
+        ? params.model.slice(7)
+        : params.model;
     const cohere = new cohere_ai_1.CohereClient({ token: apiKey });
-    const textsCombined = (0, combinePrompts_1.combinePrompts)(params.messages);
-    const config = {
-        model: params.model,
-        prompt: textsCombined,
-        max_tokens: params.max_tokens ?? 50,
+    const { message, chatHistory, preamble } = toChatHistory(params.messages);
+    const chatParams = {
+        model: modelName,
+        message,
+        ...(chatHistory ? { chatHistory } : {}),
+        ...(preamble ? { preamble } : {}),
+        maxTokens: params.max_tokens ?? 50,
         temperature: params.temperature ?? 1,
     };
-    if (params.stream) {
-        const stream = await cohere.generateStream({
-            model: params.model,
-            prompt: textsCombined,
-            maxTokens: params.max_tokens ?? 50,
-            temperature: params.temperature ?? 1,
-        });
-        return toRealStream(stream, params.model, textsCombined);
-    }
-    const response = await cohere.generate(config);
-    return {
-        model: params.model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: (0, toUsage_1.toUsage)(textsCombined, response.generations[0].text),
-        choices: [
-            {
-                message: {
-                    content: response.generations[0].text,
-                    role: 'assistant',
+    try {
+        if (params.stream) {
+            const stream = await cohere.chatStream({
+                ...chatParams,
+            });
+            return toStreamingResponse(stream, modelName);
+        }
+        const { text, finishReason, meta } = await cohere.chat(chatParams);
+        return {
+            model: modelName,
+            created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+            usage: meta?.tokens
+                ? {
+                    prompt_tokens: meta.tokens.inputTokens ?? 0,
+                    completion_tokens: meta.tokens.outputTokens ?? 0,
+                    total_tokens: (meta.tokens.inputTokens ?? 0) + (meta.tokens.outputTokens ?? 0),
+                }
+                : undefined,
+            choices: [
+                {
+                    message: {
+                        content: text,
+                        role: 'assistant',
+                    },
+                    finish_reason: toFinishReason(finishReason),
+                    index: 0,
                 },
-                finish_reason: 'stop',
-                index: 0,
-            },
-        ],
-    };
+            ],
+        };
+    }
+    catch (err) {
+        throw new Error(`Cohere API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
 }
-async function* toRealStream(stream, model, prompt) {
-    let fullText = '';
+function toFinishReason(reason) {
+    if (reason === 'MAX_TOKENS' || reason === 'ERROR_LIMIT') {
+        return 'length';
+    }
+    if (reason === 'ERROR_TOXIC') {
+        return 'content_filter';
+    }
+    return 'stop';
+}
+async function* toStreamingResponse(stream, model) {
     for await (const event of stream) {
         if (event.eventType === 'text-generation') {
-            fullText += event.text ?? '';
             yield {
                 model,
                 created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-                usage: (0, toUsage_1.toUsage)(prompt, fullText),
                 choices: [
                     {
                         delta: { content: event.text, role: 'assistant' },
@@ -65,21 +119,28 @@ async function* toRealStream(stream, model, prompt) {
             yield {
                 model,
                 created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-                usage: (0, toUsage_1.toUsage)(prompt, fullText),
                 choices: [
                     {
                         delta: { content: '', role: 'assistant' },
-                        finish_reason: 'stop',
+                        finish_reason: toFinishReason(event.finishReason),
                         index: 0,
                     },
                 ],
             };
         }
-        else if (event.eventType === 'stream-error') {
-            const msg = event.message ?? 'unknown';
-            throw new Error(`Cohere stream error: ${msg}`);
-        }
     }
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('command', CohereHandler);
+(0, registry_1.registerModelProvider)('cohere', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.COHERE_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.cohere.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const json = await res.json();
+    return (json.models ?? []).map((m) => ({ id: m.id, provider: 'cohere' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('cohere/', CohereHandler);

package/dist/handlers/copilot.js

@@ -132,5 +132,7 @@ async function CopilotHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('copilot/', CopilotHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('copilot', async () => []);
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('copilot/', CopilotHandler);

package/dist/handlers/deepinfra.js

@@ -21,7 +21,9 @@ async function DeepInfraHandler(params) {
     const apiKey = params.apiKey ?? process.env.DEEPINFRA_API_KEY;
     if (!apiKey)
         throw new Error('DeepInfra requires an API key. Set DEEPINFRA_API_KEY environment variable or pass apiKey in params.');
-    const model = params.model.split('deepinfra/')[1];
+    const model = params.model.startsWith('deepinfra/')
+        ? params.model.slice(10)
+        : params.model;
     const res = await getDeepInfraResponse(model, params.messages, baseUrl, apiKey, params.stream ?? false);
     if (!res.ok) {
         throw new Error(`DeepInfra API error: ${res.status} ${res.statusText}`);
@@ -52,5 +54,18 @@ async function DeepInfraHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('deepinfra/', DeepInfraHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('deepinfra', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.DEEPINFRA_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.deepinfra.com/v1/openai/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const { data } = await res.json();
+    return (data ?? []).map((m) => ({ id: m.id, provider: 'deepinfra' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('deepinfra/', DeepInfraHandler);

package/dist/handlers/gemini.d.ts

@@ -1,2 +1,2 @@
-import { HandlerParams, ResultNotStreaming, ResultStreaming } from '../types';
+import type { HandlerParams, ResultNotStreaming, ResultStreaming } from '../types';
 export declare function GeminiHandler(params: HandlerParams): Promise<ResultNotStreaming | ResultStreaming>;