litellmts-core 1.1.0 → 2.1.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,6 +63,8 @@ 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
@@ -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/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,109 +5,18 @@ 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 anthropic_1 = require("../utils/anthropic");
 const auth_1 = require("../auth");
-function toMessages(input) {
-    let system;
-    const messages = [];
-    for (const msg of input) {
-        if (msg.role === 'system') {
-            system = (system ? system + '\n' : '') + (msg.content ?? '');
-            continue;
-        }
-        if (msg.role === 'user' || msg.role === 'assistant') {
-            messages.push({
-                role: msg.role,
-                content: msg.content ?? '',
-            });
-        }
-    }
-    return { system, messages };
-}
-function toFinishReason(reason) {
-    if (reason === 'max_tokens') {
-        return 'length';
-    }
-    return 'stop';
-}
-function getTextContent(content) {
-    return content
-        .filter((block) => block.type === 'text')
-        .map((block) => block.text)
-        .join('');
-}
-function toResponse(message) {
-    return {
-        model: message.model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: {
-            prompt_tokens: message.usage.input_tokens,
-            completion_tokens: message.usage.output_tokens,
-            total_tokens: message.usage.input_tokens + message.usage.output_tokens,
-        },
-        choices: [
-            {
-                message: {
-                    content: getTextContent(message.content),
-                    role: 'assistant',
-                },
-                finish_reason: toFinishReason(message.stop_reason),
-                index: 0,
-            },
-        ],
-    };
-}
-async function* toStreamingResponse(stream) {
-    let model = '';
-    let stopReason;
-    for await (const event of stream) {
-        switch (event.type) {
-            case 'message_start':
-                model = event.message.model;
-                stopReason = event.message.stop_reason;
-                break;
-            case 'content_block_delta':
-                if (event.delta.type === 'text_delta') {
-                    yield {
-                        model,
-                        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-                        choices: [
-                            {
-                                delta: { content: event.delta.text, role: 'assistant' },
-                                finish_reason: null,
-                                index: 0,
-                            },
-                        ],
-                    };
-                }
-                break;
-            case 'message_delta':
-                stopReason = event.delta.stop_reason;
-                break;
-            case 'message_stop':
-                yield {
-                    model,
-                    created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-                    choices: [
-                        {
-                            delta: { content: '', role: 'assistant' },
-                            finish_reason: toFinishReason(stopReason),
-                            index: 0,
-                        },
-                    ],
-                };
-                break;
-        }
-    }
-}
+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 { system, messages } = toMessages(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,
+        model: modelName,
         max_tokens: params.max_tokens ?? 300,
         messages,
         ...(system ? { system } : {}),
@@ -118,14 +27,24 @@ async function AnthropicHandler(params) {
                 ...anthropicParams,
                 stream: true,
             });
-            return toStreamingResponse(stream);
+            return (0, anthropic_1.toAnthropicStreamingResponse)(stream);
         }
         const message = await anthropic.messages.create(anthropicParams);
-        return toResponse(message);
+        return (0, anthropic_1.toAnthropicResponse)(message);
     }
     catch (err) {
         throw new Error(`Anthropic API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
 }
-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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CohereHandler = CohereHandler;
 const cohere_ai_1 = require("cohere-ai");
 const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+const registry_1 = require("../models/registry");
 function toChatHistory(messages) {
     let system;
     const chatMessages = [];
@@ -43,10 +44,13 @@ 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 { message, chatHistory, preamble } = toChatHistory(params.messages);
     const chatParams = {
-        model: params.model,
+        model: modelName,
         message,
         ...(chatHistory ? { chatHistory } : {}),
         ...(preamble ? { preamble } : {}),
@@ -58,11 +62,11 @@ async function CohereHandler(params) {
             const stream = await cohere.chatStream({
                 ...chatParams,
             });
-            return toStreamingResponse(stream, params.model);
+            return toStreamingResponse(stream, modelName);
         }
         const { text, finishReason, meta } = await cohere.chat(chatParams);
         return {
-            model: params.model,
+            model: modelName,
             created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
             usage: meta?.tokens
                 ? {
@@ -126,5 +130,17 @@ async function* toStreamingResponse(stream, model) {
         }
     }
 }
-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

@@ -54,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>;

package/dist/handlers/gemini.js

@@ -1,78 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiHandler = GeminiHandler;
-const generative_ai_1 = require("@google/generative-ai");
-const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
-function toGeminiContent(messages) {
-    return messages.map((msg) => {
-        const parts = [];
-        if (msg.content) {
-            parts.push({ text: msg.content });
-        }
-        return {
-            role: msg.role === 'assistant' ? 'model' : msg.role,
-            parts,
-        };
-    });
-}
-function toFinishReason(reason) {
-    switch (reason) {
-        case 'STOP':
-            return 'stop';
-        case 'MAX_TOKENS':
-            return 'length';
-        default:
-            return 'stop';
-    }
-}
-function toUsage(meta) {
-    if (!meta)
-        return undefined;
-    return {
-        prompt_tokens: meta.promptTokenCount,
-        completion_tokens: meta.candidatesTokenCount,
-        total_tokens: meta.totalTokenCount,
-    };
-}
-function toResponse(response, model) {
-    const candidate = response.candidates?.[0];
-    return {
-        model: model,
-        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: toUsage(response.usageMetadata),
-        choices: [
-            {
-                index: candidate?.index ?? 0,
-                finish_reason: toFinishReason(candidate?.finishReason),
-                message: {
-                    role: 'assistant',
-                    content: candidate ? candidate.content.parts.map((p) => 'text' in p ? p.text : '').join('') : null,
-                },
-            },
-        ],
-    };
-}
-async function* toStreamingResponse(stream, model) {
-    for await (const chunk of stream) {
-        const candidate = chunk.candidates?.[0];
-        const deltaContent = candidate?.content.parts.map((p) => 'text' in p ? p.text : '').join('') ?? '';
-        yield {
-            model,
-            created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-            usage: toUsage(chunk.usageMetadata),
-            choices: [
-                {
-                    index: candidate?.index ?? 0,
-                    finish_reason: toFinishReason(candidate?.finishReason),
-                    delta: {
-                        content: deltaContent,
-                        role: 'assistant',
-                    },
-                },
-            ],
-        };
-    }
-}
+const genai_1 = require("@google/genai");
+const gemini_1 = require("../utils/gemini");
 async function GeminiHandler(params) {
     const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
     if (!apiKey)
@@ -80,28 +10,50 @@ async function GeminiHandler(params) {
     const modelName = params.model.startsWith('gemini/')
         ? params.model.slice(7)
         : params.model;
-    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
-    const model = genAI.getGenerativeModel({
-        model: modelName,
-        generationConfig: {
-            temperature: params.temperature ?? undefined,
-            topP: params.top_p ?? undefined,
-            maxOutputTokens: params.max_tokens ?? undefined,
-            stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
-        },
-    });
-    const contents = toGeminiContent(params.messages);
+    const client = new genai_1.GoogleGenAI({ apiKey });
+    const contents = (0, gemini_1.toGeminiContent)(params.messages);
     try {
         if (params.stream) {
-            const result = await model.generateContentStream({ contents });
-            return toStreamingResponse(result.stream, modelName);
+            const stream = await client.models.generateContentStream({
+                model: modelName,
+                contents,
+                config: {
+                    temperature: params.temperature ?? undefined,
+                    topP: params.top_p ?? undefined,
+                    maxOutputTokens: params.max_tokens ?? undefined,
+                    stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
+                },
+            });
+            return (0, gemini_1.toStreamingResponse)(stream, modelName);
         }
-        const result = await model.generateContent({ contents });
-        return toResponse(result.response, modelName);
+        const response = await client.models.generateContent({
+            model: modelName,
+            contents,
+            config: {
+                temperature: params.temperature ?? undefined,
+                topP: params.top_p ?? undefined,
+                maxOutputTokens: params.max_tokens ?? undefined,
+                stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
+            },
+        });
+        return (0, gemini_1.toResponse)(response, modelName);
     }
     catch (err) {
         throw new Error(`Gemini API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('gemini/', GeminiHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('gemini', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.GEMINI_API_KEY;
+    if (!key)
+        return [];
+    const client = new genai_1.GoogleGenAI({ apiKey: key });
+    const pager = await client.models.list();
+    const models = [];
+    for await (const m of pager) {
+        models.push({ id: m.name ?? m.displayName, provider: 'gemini' });
+    }
+    return models;
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('gemini/', GeminiHandler);

package/dist/handlers/geminiEmbedding.d.ts

@@ -1,2 +1,2 @@
-import { EmbeddingParams, EmbeddingResponse } from '../types';
+import type { EmbeddingParams, EmbeddingResponse } from '../types';
 export declare function GeminiEmbeddingHandler(params: EmbeddingParams): Promise<EmbeddingResponse>;

package/dist/handlers/geminiEmbedding.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiEmbeddingHandler = GeminiEmbeddingHandler;
-const generative_ai_1 = require("@google/generative-ai");
+const genai_1 = require("@google/genai");
 async function GeminiEmbeddingHandler(params) {
     const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
     if (!apiKey)
@@ -9,20 +9,17 @@ async function GeminiEmbeddingHandler(params) {
     const modelName = params.model.startsWith('gemini/')
         ? params.model.slice(7)
         : params.model;
-    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
-    const model = genAI.getGenerativeModel({ model: modelName });
+    const client = new genai_1.GoogleGenAI({ apiKey });
     const input = typeof params.input === 'string'
         ? params.input
         : params.input.join(' ');
-    const result = await model.embedContent({
-        content: {
-            role: 'user',
-            parts: [{ text: input }],
-        },
+    const result = await client.models.embedContent({
+        model: modelName,
+        contents: [{ role: 'user', parts: [{ text: input }] }],
     });
     return {
         model: modelName,
-        data: [{ embedding: result.embedding.values, index: 0 }],
+        data: [{ embedding: result.embeddings?.[0]?.values ?? [], index: 0 }],
     };
 }
 const registry_1 = require("../registry");

package/dist/handlers/mistral.js

@@ -54,5 +54,18 @@ async function MistralHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('mistral/', MistralHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('mistral', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.MISTRAL_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.mistral.ai/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const { data } = await res.json();
+    return (data ?? []).map((m) => ({ id: m.id, provider: 'mistral' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('mistral/', MistralHandler);