litellmts-core 1.0.1 → 2.0.0

package/dist/handlers/vertexai.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexAIHandler = VertexAIHandler;
+const genai_1 = require("@google/genai");
+const gemini_1 = require("../utils/gemini");
+async function VertexAIHandler(params) {
+    const project = params.project ?? process.env.GCP_PROJECT;
+    if (!project)
+        throw new Error('Vertex AI requires GCP_PROJECT environment variable or project in params.');
+    const location = params.location ?? process.env.GCP_LOCATION ?? 'us-central1';
+    const modelName = params.model.startsWith('vertex/')
+        ? params.model.slice(7)
+        : params.model;
+    const client = new genai_1.GoogleGenAI({
+        vertexai: true,
+        project,
+        location,
+    });
+    const contents = (0, gemini_1.toGeminiContent)(params.messages);
+    try {
+        if (params.stream) {
+            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 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(`Vertex AI error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('vertex/', VertexAIHandler);

package/dist/handlers/vertexaiEmbedding.d.ts

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

package/dist/handlers/vertexaiEmbedding.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexAIEmbeddingHandler = VertexAIEmbeddingHandler;
+const genai_1 = require("@google/genai");
+async function VertexAIEmbeddingHandler(params) {
+    const project = params.project ?? process.env.GCP_PROJECT;
+    if (!project)
+        throw new Error('Vertex AI requires GCP_PROJECT environment variable or project in params.');
+    const location = params.location ?? process.env.GCP_LOCATION ?? 'us-central1';
+    const modelName = params.model.startsWith('vertex/')
+        ? params.model.slice(7)
+        : params.model;
+    const client = new genai_1.GoogleGenAI({
+        vertexai: true,
+        project,
+        location,
+    });
+    const input = typeof params.input === 'string'
+        ? params.input
+        : params.input.join(' ');
+    const result = await client.models.embedContent({
+        model: modelName,
+        contents: [{ role: 'user', parts: [{ text: input }] }],
+    });
+    return {
+        model: modelName,
+        data: [{ embedding: result.embeddings?.[0]?.values ?? [], index: 0 }],
+    };
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerEmbeddingHandler)('vertex/', VertexAIEmbeddingHandler);

package/dist/index.d.ts

@@ -7,4 +7,5 @@
  */
 export { completion } from './completion';
 export { embedding } from './embedding';
+export { listModels, listProviders, clearModelCache } from './models';
 export { login, loginAnthropic, getValidToken, getAnthropicKey } from './auth';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAnthropicKey = exports.getValidToken = exports.loginAnthropic = exports.login = exports.embedding = exports.completion = void 0;
+exports.getAnthropicKey = exports.getValidToken = exports.loginAnthropic = exports.login = exports.clearModelCache = exports.listProviders = exports.listModels = exports.embedding = exports.completion = void 0;
 /**
  * @litellmts/core — Unified API client for 45+ LLM providers.
  *
@@ -12,6 +12,10 @@ var completion_1 = require("./completion");
 Object.defineProperty(exports, "completion", { enumerable: true, get: function () { return completion_1.completion; } });
 var embedding_1 = require("./embedding");
 Object.defineProperty(exports, "embedding", { enumerable: true, get: function () { return embedding_1.embedding; } });
+var models_1 = require("./models");
+Object.defineProperty(exports, "listModels", { enumerable: true, get: function () { return models_1.listModels; } });
+Object.defineProperty(exports, "listProviders", { enumerable: true, get: function () { return models_1.listProviders; } });
+Object.defineProperty(exports, "clearModelCache", { enumerable: true, get: function () { return models_1.clearModelCache; } });
 var auth_1 = require("./auth");
 Object.defineProperty(exports, "login", { enumerable: true, get: function () { return auth_1.login; } });
 Object.defineProperty(exports, "loginAnthropic", { enumerable: true, get: function () { return auth_1.loginAnthropic; } });

package/dist/mappings/openaiLike.js

@@ -77,11 +77,6 @@ exports.OPENAI_LIKE_MAPPINGS = {
         baseUrl: 'https://integrate.api.nvidia.com/v1',
         apiKeyEnv: 'NVIDIA_API_KEY',
     },
-    'ai21/': {
-        name: 'AI21 Labs',
-        baseUrl: 'https://api.ai21.com/studio/v1',
-        apiKeyEnv: 'AI21_API_KEY',
-    },
     'codestral/': {
         name: 'Codestral',
         baseUrl: 'https://codestral.mistral.ai/v1',

package/dist/models/index.d.ts

@@ -0,0 +1,2 @@
+export { listModels, listProviders, clearModelCache } from './registry';
+export type { ModelInfo, ProviderInfo } from './types';

package/dist/models/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearModelCache = exports.listProviders = exports.listModels = void 0;
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "listModels", { enumerable: true, get: function () { return registry_1.listModels; } });
+Object.defineProperty(exports, "listProviders", { enumerable: true, get: function () { return registry_1.listProviders; } });
+Object.defineProperty(exports, "clearModelCache", { enumerable: true, get: function () { return registry_1.clearModelCache; } });

package/dist/models/registry.d.ts

@@ -0,0 +1,13 @@
+import type { ModelInfo, ProviderInfo } from './types';
+type ModelFetcher = (params?: {
+    apiKey?: string;
+    baseUrl?: string;
+}) => Promise<ModelInfo[]>;
+export declare function registerModelProvider(provider: string, fetcher: ModelFetcher): void;
+export declare function listModels(provider: string, opts?: {
+    apiKey?: string;
+    baseUrl?: string;
+}): Promise<ModelInfo[]>;
+export declare function listProviders(): ProviderInfo[];
+export declare function clearModelCache(): void;
+export {};

package/dist/models/registry.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModelProvider = registerModelProvider;
+exports.listModels = listModels;
+exports.listProviders = listProviders;
+exports.clearModelCache = clearModelCache;
+const fetchers = new Map();
+const cache = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+function registerModelProvider(provider, fetcher) {
+    fetchers.set(provider, fetcher);
+}
+async function listModels(provider, opts) {
+    const cached = cache.get(provider);
+    if (cached && cached.expires > Date.now())
+        return cached.data;
+    const fetcher = fetchers.get(provider);
+    if (!fetcher)
+        throw new Error(`Provider '${provider}' not found.`);
+    const data = await fetcher(opts);
+    cache.set(provider, { data, expires: Date.now() + CACHE_TTL });
+    return data;
+}
+function listProviders() {
+    return Array.from(fetchers.keys()).map((key) => ({
+        name: key,
+        hasModelList: true,
+    }));
+}
+function clearModelCache() {
+    cache.clear();
+}

package/dist/models/types.d.ts

@@ -0,0 +1,9 @@
+export interface ModelInfo {
+    id: string;
+    provider: string;
+    created?: number;
+}
+export interface ProviderInfo {
+    name: string;
+    hasModelList: boolean;
+}

package/dist/models/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/anthropic.d.ts

@@ -0,0 +1,10 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { Message, FinishReason, ResultNotStreaming, ResultStreaming } from '../types';
+export declare function toAnthropicMessages(input: Message[]): {
+    system: string | undefined;
+    messages: Anthropic.MessageParam[];
+};
+export declare function toAnthropicFinishReason(reason: Anthropic.StopReason | null | undefined): FinishReason;
+export declare function getTextContent(content: Anthropic.ContentBlock[]): string;
+export declare function toAnthropicResponse(message: Anthropic.Message): ResultNotStreaming;
+export declare function toAnthropicStreamingResponse(stream: AsyncIterable<Anthropic.RawMessageStreamEvent>): ResultStreaming;

package/dist/utils/anthropic.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnthropicMessages = toAnthropicMessages;
+exports.toAnthropicFinishReason = toAnthropicFinishReason;
+exports.getTextContent = getTextContent;
+exports.toAnthropicResponse = toAnthropicResponse;
+exports.toAnthropicStreamingResponse = toAnthropicStreamingResponse;
+const getUnixTimestamp_1 = require("./getUnixTimestamp");
+function toAnthropicMessages(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 toAnthropicFinishReason(reason) {
+    return reason === 'max_tokens' ? 'length' : 'stop';
+}
+function getTextContent(content) {
+    return content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+function toAnthropicResponse(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: toAnthropicFinishReason(message.stop_reason),
+                index: 0,
+            },
+        ],
+    };
+}
+async function* toAnthropicStreamingResponse(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') {
+                    const chunk = {
+                        model,
+                        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+                        choices: [
+                            {
+                                delta: { content: event.delta.text, role: 'assistant' },
+                                finish_reason: null,
+                                index: 0,
+                            },
+                        ],
+                    };
+                    yield chunk;
+                }
+                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: toAnthropicFinishReason(stopReason),
+                            index: 0,
+                        },
+                    ],
+                };
+                break;
+        }
+    }
+}

package/dist/utils/gemini.d.ts

@@ -0,0 +1,12 @@
+import type { GenerateContentResponse } from '@google/genai';
+import type { Message, FinishReason, ConsistentResponseUsage, ResultNotStreaming, ResultStreaming } from '../types';
+export declare function toGeminiContent(messages: Message[]): {
+    role: string;
+    parts: {
+        text: string;
+    }[];
+}[];
+export declare function toFinishReason(reason: string | null | undefined): FinishReason;
+export declare function toUsage(meta: GenerateContentResponse['usageMetadata']): ConsistentResponseUsage | undefined;
+export declare function toResponse(response: GenerateContentResponse, model: string): ResultNotStreaming;
+export declare function toStreamingResponse(stream: AsyncGenerator<GenerateContentResponse>, model: string): ResultStreaming;

package/dist/utils/gemini.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGeminiContent = toGeminiContent;
+exports.toFinishReason = toFinishReason;
+exports.toUsage = toUsage;
+exports.toResponse = toResponse;
+exports.toStreamingResponse = toStreamingResponse;
+const getUnixTimestamp_1 = require("./getUnixTimestamp");
+function toGeminiContent(messages) {
+    return messages.map((msg) => ({
+        role: msg.role === 'assistant' ? 'model' : msg.role,
+        parts: msg.content ? [{ text: msg.content }] : [],
+    }));
+}
+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 ?? 0,
+        completion_tokens: meta.candidatesTokenCount ?? 0,
+        total_tokens: meta.totalTokenCount ?? 0,
+    };
+}
+function toResponse(response, model) {
+    const candidate = response.candidates?.[0];
+    return {
+        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?.content?.parts?.map((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) => p.text ?? '').join('') ?? '';
+        const chunkOutput = {
+            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',
+                    },
+                },
+            ],
+        };
+        yield chunkOutput;
+    }
+}

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.1",
+  "version": "2.0.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",
-    "@google/generative-ai": "^0.24.1",
-    "cohere-ai": "^7.21.0",
-    "eventsource": "^2.0.2",
+    "@anthropic-ai/sdk": "^0.104.1",
+    "@google/genai": "^2.8.0",
+    "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"
   },