litellmts-core 1.0.0 → 1.1.0

package/README.md

@@ -1,7 +1,3 @@
-<p align="center">
-  <img src="https://raw.githubusercontent.com/madkoding/litellmTS/main/.github/banner.png" alt="LiteLLM.ts" width="600"/>
-</p>
-
 <p align="center">
   <strong>Unified TypeScript interface for 45+ LLM providers</strong><br>
   One API. Every model. Zero boilerplate.
@@ -11,46 +7,39 @@
   <a href="https://github.com/madkoding/litellmTS/blob/main/LICENSE">
     <img src="https://img.shields.io/badge/license-GPLv3-blue.svg" alt="License"/>
   </a>
-  <a href="https://github.com/madkoding/litellmTS">
-    <img src="https://img.shields.io/github/v/release/madkoding/litellmTS" alt="GitHub Release"/>
+  <a href="https://www.npmjs.com/package/litellmts-core">
+    <img src="https://img.shields.io/npm/v/litellmts-core" alt="npm"/>
   </a>
   <a href="https://nodejs.org/">
     <img src="https://img.shields.io/badge/node-%3E%3D22-brightgreen" alt="Node"/>
   </a>
+  <a href="https://github.com/madkoding/litellmTS/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/madkoding/litellmTS/ci.yml" alt="CI"/>
+  </a>
 </p>
 
 ---
 
 ## Installation
 
-### From GitHub (recommended)
+```bash
+npm install litellmts-core
+```
 
-Add this to your `package.json`:
+### From GitHub (alternative)
 
 ```json
 {
   "dependencies": {
-    "@litellmts/core": "github:madkoding/litellmTS"
+    "litellmts-core": "github:madkoding/litellmTS"
   }
 }
 ```
 
-Then install:
-
-```bash
-npm install
-```
-
-### Alternative — npm (when published)
-
-```bash
-npm install @litellmts/core
-```
-
 ## Quick Start
 
 ```ts
-import { completion } from '@litellmts/core';
+import { completion } from 'litellmts-core';
 
 const response = await completion({
   model: 'gpt-4o-mini',
@@ -77,15 +66,15 @@ await completion({ model: 'deepseek/deepseek-chat', ... });
 - **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
 
 ### Non-streaming
 
 ```ts
-import { completion } from '@litellmts/core';
+import { completion } from 'litellmts-core';
 
 const response = await completion({
   model: 'gpt-4o-mini',
@@ -120,7 +109,7 @@ for await (const chunk of stream) {
 ### Embeddings
 
 ```ts
-import { embedding } from '@litellmts/core';
+import { embedding } from 'litellmts-core';
 
 const result = await embedding({
   model: 'text-embedding-3-small',
@@ -229,10 +218,10 @@ npx litellm login anthropic
 └──────────────┘     └──────────────┘     └─────────────────┘
                            │
                     ┌──────┴──────┐
-                    │  Model Map   │
-                    │  groq/ → ... │
-                    │  claude- → . │
-                    │  gpt- → ...  │
+                    │  Registry   │
+                    │  groq/ → .  │
+                    │  claude- →  │
+                    │  gpt- → ..  │
                     └─────────────┘
 ```
 

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/anthropic.js

@@ -6,58 +6,98 @@ 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 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}`;
+function toMessages(input) {
+    let system;
+    const messages = [];
+    for (const msg of input) {
+        if (msg.role === 'system') {
+            system = (system ? system + '\n' : '') + (msg.content ?? '');
+            continue;
         }
-        return `${sdk_1.default.HUMAN_PROMPT} ${content}`;
-    })
-        .join('') + sdk_1.default.AI_PROMPT;
+        if (msg.role === 'user' || msg.role === 'assistant') {
+            messages.push({
+                role: msg.role,
+                content: msg.content ?? '',
+            });
+        }
+    }
+    return { system, messages };
 }
-function toFinishReson(string) {
-    if (string === 'max_tokens') {
+function toFinishReason(reason) {
+    if (reason === 'max_tokens') {
         return 'length';
     }
     return 'stop';
 }
-function toResponse(anthropicResponse, prompt) {
+function getTextContent(content) {
+    return content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function toResponse(message) {
     return {
-        model: anthropicResponse.model,
+        model: message.model,
         created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
-        usage: (0, toUsage_1.toUsage)(prompt, anthropicResponse.completion),
+        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: anthropicResponse.completion,
+                    content: getTextContent(message.content),
                     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),
+                finish_reason: toFinishReason(message.stop_reason),
                 index: 0,
             },
         ],
     };
 }
 async function* toStreamingResponse(stream) {
-    for await (const chunk of stream) {
-        yield toStreamingChunk(chunk);
+    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;
+        }
     }
 }
 async function AnthropicHandler(params) {
@@ -65,21 +105,27 @@ async function AnthropicHandler(params) {
     const anthropic = new sdk_1.default({
         apiKey: apiKey,
     });
-    const prompt = toAnthropicPrompt(params.messages);
+    const { system, messages } = toMessages(params.messages);
     const anthropicParams = {
         model: params.model,
-        max_tokens_to_sample: params.max_tokens ?? 300,
-        prompt,
+        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 toStreamingResponse(stream);
+        }
+        const message = await anthropic.messages.create(anthropicParams);
+        return toResponse(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);

package/dist/handlers/cohere.js

@@ -2,56 +2,106 @@
 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");
+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 cohere = new cohere_ai_1.CohereClient({ token: apiKey });
-    const textsCombined = (0, combinePrompts_1.combinePrompts)(params.messages);
-    const config = {
+    const { message, chatHistory, preamble } = toChatHistory(params.messages);
+    const chatParams = {
         model: params.model,
-        prompt: textsCombined,
-        max_tokens: params.max_tokens ?? 50,
+        message,
+        ...(chatHistory ? { chatHistory } : {}),
+        ...(preamble ? { preamble } : {}),
+        maxTokens: params.max_tokens ?? 50,
         temperature: params.temperature ?? 1,
     };
-    if (params.stream) {
-        const stream = await cohere.generateStream({
+    try {
+        if (params.stream) {
+            const stream = await cohere.chatStream({
+                ...chatParams,
+            });
+            return toStreamingResponse(stream, params.model);
+        }
+        const { text, finishReason, meta } = await cohere.chat(chatParams);
+        return {
             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',
+            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,20 +115,15 @@ 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");

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}`);

package/dist/handlers/gemini.js

@@ -52,12 +52,12 @@ function toResponse(response, model) {
         ],
     };
 }
-async function* toStreamingResponse(stream) {
+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: undefined,
+            model,
             created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
             usage: toUsage(chunk.usageMetadata),
             choices: [
@@ -91,12 +91,17 @@ async function GeminiHandler(params) {
         },
     });
     const contents = toGeminiContent(params.messages);
-    if (params.stream) {
-        const result = await model.generateContentStream({ contents });
-        return toStreamingResponse(result.stream);
+    try {
+        if (params.stream) {
+            const result = await model.generateContentStream({ contents });
+            return toStreamingResponse(result.stream, modelName);
+        }
+        const result = await model.generateContent({ contents });
+        return toResponse(result.response, modelName);
+    }
+    catch (err) {
+        throw new Error(`Gemini API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
-    const result = await model.generateContent({ contents });
-    return toResponse(result.response, modelName);
 }
 const registry_1 = require("../registry");
 (0, registry_1.registerCompletionHandler)('gemini/', GeminiHandler);

package/dist/handlers/mistral.js

@@ -21,7 +21,9 @@ async function MistralHandler(params) {
     const apiKey = params.apiKey ?? process.env.MISTRAL_API_KEY;
     if (!apiKey)
         throw new Error('Mistral requires an API key. Set MISTRAL_API_KEY environment variable or pass apiKey in params.');
-    const model = params.model.split('mistral/')[1];
+    const model = params.model.startsWith('mistral/')
+        ? params.model.slice(8)
+        : params.model;
     const res = await getMistralResponse(model, params.messages, baseUrl, apiKey, params.stream ?? false);
     if (!res.ok) {
         throw new Error(`Mistral API error: ${res.status} ${res.statusText}`);

package/dist/handlers/mistralEmbedding.js

@@ -15,7 +15,9 @@ async function getMistralResponse(model, input, baseUrl, apiKey) {
     });
 }
 async function MistralEmbeddingHandler(params) {
-    const model = params.model.split('mistral/')[1];
+    const model = params.model.startsWith('mistral/')
+        ? params.model.slice(8)
+        : params.model;
     const baseUrl = params.baseUrl ?? 'https://api.mistral.ai';
     const apiKey = params.apiKey ?? process.env.MISTRAL_API_KEY;
     if (!apiKey)

package/dist/handlers/ollama.js

@@ -67,7 +67,9 @@ async function getOllamaResponse(model, prompt, baseUrl) {
 }
 async function OllamaHandler(params) {
     const baseUrl = params.baseUrl ?? 'http://127.0.0.1:11434';
-    const model = params.model.split('ollama/')[1];
+    const model = params.model.startsWith('ollama/')
+        ? params.model.slice(7)
+        : params.model;
     const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
     const res = await getOllamaResponse(model, prompt, baseUrl);
     if (!res.ok) {
@@ -81,7 +83,7 @@ async function OllamaHandler(params) {
         chunks.push(chunk);
     }
     const message = chunks.reduce((acc, chunk) => {
-        return (acc += chunk.choices[0].delta.content);
+        return acc + chunk.choices[0].delta.content;
     }, '');
     return toResponse(message, model, prompt);
 }

package/dist/handlers/ollamaEmbedding.js

@@ -16,11 +16,13 @@ async function getOllamaResponse(model, input, baseUrl) {
     });
 }
 async function OllamaEmbeddingHandler(params) {
-    const model = params.model.split('ollama/')[1];
+    const model = params.model.startsWith('ollama/')
+        ? params.model.slice(7)
+        : params.model;
     const baseUrl = params.baseUrl ?? 'http://127.0.0.1:11434';
     const input = typeof params.input === 'string'
         ? params.input
-        : params.input.reduce((acc, curr) => (acc += curr), '');
+        : params.input.reduce((acc, curr) => acc + curr, '');
     const response = await getOllamaResponse(model, input, baseUrl);
     if (!response.ok) {
         throw new Error(`Received an error with code ${response.status} from Ollama API.`);

package/dist/handlers/openai.js

@@ -37,18 +37,30 @@ async function OpenAIHandler(params) {
     });
     const messages = toOpenAIMessages(completionsParams.messages);
     if (params.stream) {
-        const response = await openai.chat.completions.create({
+        let response;
+        try {
+            response = await openai.chat.completions.create({
+                ...completionsParams,
+                stream: true,
+                messages,
+            });
+        }
+        catch (err) {
+            throw new Error(`OpenAI API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        return toStreamingResponse(response);
+    }
+    let response;
+    try {
+        response = await openai.chat.completions.create({
             ...completionsParams,
-            stream: true,
+            stream: false,
             messages,
         });
-        return toStreamingResponse(response);
     }
-    const response = await openai.chat.completions.create({
-        ...completionsParams,
-        stream: false,
-        messages,
-    });
+    catch (err) {
+        throw new Error(`OpenAI API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
     const result = {
         created: response.created,
         model: response.model,

package/dist/handlers/openaiEmbedding.js

@@ -12,7 +12,12 @@ async function OpenAIEmbeddingHandler(params) {
         apiKey: apiKey,
         baseURL: baseUrl,
     });
-    return openai.embeddings.create({ input: params.input, model: params.model });
+    try {
+        return await openai.embeddings.create({ input: params.input, model: params.model });
+    }
+    catch (err) {
+        throw new Error(`OpenAI embedding API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
 }
 const registry_1 = require("../registry");
 (0, registry_1.registerEmbeddingHandler)('text-embedding-', OpenAIEmbeddingHandler);

package/dist/handlers/replicate.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReplicateHandler = ReplicateHandler;
 const replicate_1 = __importDefault(require("replicate"));
-const eventsource_1 = __importDefault(require("eventsource"));
+const eventsource_1 = require("eventsource");
 const combinePrompts_1 = require("../utils/combinePrompts");
 const toUsage_1 = require("../utils/toUsage");
 const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
@@ -16,10 +16,11 @@ async function sleep(time) {
         }, time);
     });
 }
-async function handleNonStreamingPrediction(prompt, prediction, replicate) {
+async function handleNonStreamingPrediction(prompt, prediction, replicate, modelName) {
     const pred = await replicate.wait(prediction, {});
-    const output = pred.output.reduce((acc, curr) => (acc += curr), '');
+    const output = pred.output.reduce((acc, curr) => acc + curr, '');
     return {
+        model: modelName,
         usage: (0, toUsage_1.toUsage)(prompt, output),
         created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
         choices: [
@@ -38,7 +39,7 @@ async function* handleStreamingPrediction(prompt, prediction) {
     if (!prediction?.urls?.stream) {
         throw new Error('Prediction does not support streaming');
     }
-    const source = new eventsource_1.default(prediction.urls.stream, {
+    const source = new eventsource_1.EventSource(prediction.urls.stream, {
         withCredentials: true,
     });
     let results = [];
@@ -57,7 +58,7 @@ async function* handleStreamingPrediction(prompt, prediction) {
     while (!done) {
         await promise;
         await sleep(500);
-        const combined = results.reduce((acc, curr) => (acc += curr), '');
+        const combined = results.reduce((acc, curr) => acc + curr, '');
         yield {
             created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
             usage: (0, toUsage_1.toUsage)(prompt, combined),
@@ -80,19 +81,30 @@ async function ReplicateHandler(params) {
     const replicate = new replicate_1.default({
         auth: apiKey,
     });
-    const model = params.model.split('replicate/')[1];
-    const version = model.split(':')[1];
+    const modelName = params.model.startsWith('replicate/')
+        ? params.model.slice(10)
+        : params.model;
+    const version = modelName.split(':')[1];
+    if (!version) {
+        throw new Error(`Invalid Replicate model format: ${params.model}. Expected format: replicate/<owner>/<name>:<version>`);
+    }
     const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
-    const prediction = await replicate.predictions.create({
-        version: version,
-        input: {
-            prompt,
-        },
-    });
+    let prediction;
+    try {
+        prediction = await replicate.predictions.create({
+            version: version,
+            input: {
+                prompt,
+            },
+        });
+    }
+    catch (err) {
+        throw new Error(`Replicate API error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
     if (params.stream) {
         return handleStreamingPrediction(prompt, prediction);
     }
-    return handleNonStreamingPrediction(prompt, prediction, replicate);
+    return handleNonStreamingPrediction(prompt, prediction, replicate, modelName);
 }
 const registry_1 = require("../registry");
 (0, registry_1.registerCompletionHandler)('replicate/', ReplicateHandler);

package/dist/utils/sse.js

@@ -30,7 +30,6 @@ async function* iterateSSEStream(response, parseChunk, doneToken = '[DONE]') {
                     continue;
                 const payload = trimmed.slice(6);
                 if (payload === doneToken) {
-                    done = true;
                     return;
                 }
                 yield parseChunk(payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litellmts-core",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "TypeScript implementation of LiteLLM — unified interface for 45+ LLM providers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,34 +25,28 @@
   "author": "madkoding",
   "license": "GPL-3.0-only",
   "devDependencies": {
-    "@eslint/js": "^9.19.0",
-    "@types/eventsource": "^1.1.15",
+    "@eslint/js": "^10.0.1",
     "@types/jest": "^29.5.14",
     "@types/node": "^25.9.3",
-    "dotenv": "^16.4.7",
-    "eslint": "^9.19.0",
+    "dotenv": "^17.4.2",
+    "eslint": "^10.4.1",
     "eslint-config-prettier": "^10.0.1",
-    "jest": "^29.7.0",
+    "jest": "^30.4.2",
     "jest-runner-groups": "^2.2.0",
     "prettier": "^3.4.2",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.4.11",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.24.0"
+    "typescript-eslint": "^8.61.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/sdk": "^0.104.1",
     "@google/generative-ai": "^0.24.1",
-    "cohere-ai": "^7.21.0",
-    "eventsource": "^2.0.2",
+    "cohere-ai": "^8.0.0",
+    "eventsource": "^4.1.0",
     "js-tiktoken": "^1.0.21",
-    "openai": "^4.104.0",
+    "openai": "^6.42.0",
     "replicate": "^1.4.0"
   },
-  "overrides": {
-    "jest-runner-groups": {
-      "jest-runner": "29.7.0"
-    }
-  },
   "engines": {
     "node": ">=22"
   },