litellmts-core 1.1.0 → 2.0.0

package/dist/handlers/openai.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIHandler = OpenAIHandler;
 const openai_1 = __importDefault(require("openai"));
+const registry_1 = require("../models/registry");
 function toOpenAIMessages(messages) {
     return messages;
 }
@@ -31,6 +32,9 @@ async function OpenAIHandler(params) {
     const { apiKey: providedApiKey, baseUrl: providedBaseUrl, ...completionsParams } = params;
     const apiKey = providedApiKey ?? process.env.OPENAI_API_KEY;
     const baseUrl = providedBaseUrl ?? 'https://api.openai.com/v1';
+    const modelName = completionsParams.model.startsWith('openai/')
+        ? completionsParams.model.slice(7)
+        : completionsParams.model;
     const openai = new openai_1.default({
         apiKey: apiKey,
         baseURL: baseUrl,
@@ -41,6 +45,7 @@ async function OpenAIHandler(params) {
         try {
             response = await openai.chat.completions.create({
                 ...completionsParams,
+                model: modelName,
                 stream: true,
                 messages,
             });
@@ -54,6 +59,7 @@ async function OpenAIHandler(params) {
     try {
         response = await openai.chat.completions.create({
             ...completionsParams,
+            model: modelName,
             stream: false,
             messages,
         });
@@ -83,6 +89,15 @@ async function OpenAIHandler(params) {
     };
     return result;
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('gpt-', OpenAIHandler);
-(0, registry_1.registerCompletionHandler)('openai/', OpenAIHandler);
+(0, registry_1.registerModelProvider)('openai', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.openai.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    const { data } = await res.json();
+    return data.map((m) => ({ id: m.id, provider: 'openai', created: m.created }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('openai/', OpenAIHandler);

package/dist/handlers/openaiEmbedding.js

@@ -8,16 +8,19 @@ const openai_1 = __importDefault(require("openai"));
 async function OpenAIEmbeddingHandler(params) {
     const apiKey = params.apiKey ?? process.env.OPENAI_API_KEY;
     const baseUrl = params.baseUrl;
+    const modelName = params.model.startsWith('openai/')
+        ? params.model.slice(7)
+        : params.model;
     const openai = new openai_1.default({
         apiKey: apiKey,
         baseURL: baseUrl,
     });
     try {
-        return await openai.embeddings.create({ input: params.input, model: params.model });
+        return await openai.embeddings.create({ input: params.input, model: modelName });
     }
     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);
+(0, registry_1.registerEmbeddingHandler)('openai/', OpenAIEmbeddingHandler);

package/dist/handlers/openaiLike.d.ts

@@ -1,3 +1,3 @@
 import type { Handler } from '../types';
 import type { OpenAILikeConfig } from '../mappings/openaiLike';
-export declare function createOpenAILikeHandler(config: OpenAILikeConfig): Handler;
+export declare function createOpenAILikeHandler(prefix: string, config: OpenAILikeConfig): Handler;

package/dist/handlers/openaiLike.js

@@ -2,21 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAILikeHandler = createOpenAILikeHandler;
 const openai_1 = require("./openai");
-function createOpenAILikeHandler(config) {
+const registry_1 = require("../models/registry");
+function createOpenAILikeHandler(prefix, config) {
     return async (params) => {
         const apiKey = params.apiKey ?? process.env[config.apiKeyEnv];
         if (!apiKey) {
             throw new Error(`${config.name} requires an API key. Set the ${config.apiKeyEnv} environment variable or pass apiKey in params.`);
         }
+        const modelName = params.model.startsWith(prefix)
+            ? params.model.slice(prefix.length)
+            : params.model;
         return (0, openai_1.OpenAIHandler)({
             ...params,
+            model: modelName,
             apiKey,
             baseUrl: config.baseUrl,
         });
     };
 }
 const openaiLike_1 = require("../mappings/openaiLike");
-const registry_1 = require("../registry");
+const registry_2 = require("../registry");
 for (const [prefix, config] of Object.entries(openaiLike_1.OPENAI_LIKE_MAPPINGS)) {
-    (0, registry_1.registerCompletionHandler)(prefix, createOpenAILikeHandler(config));
+    (0, registry_2.registerCompletionHandler)(prefix, createOpenAILikeHandler(prefix, config));
+    const provider = prefix.replace('/', '');
+    (0, registry_1.registerModelProvider)(provider, async ({ apiKey } = {}) => {
+        const key = apiKey ?? process.env[config.apiKeyEnv];
+        if (!key)
+            return [];
+        try {
+            const res = await fetch(`${config.baseUrl}/models`, {
+                headers: { Authorization: `Bearer ${key}` },
+            });
+            if (!res.ok)
+                return [];
+            const { data } = await res.json();
+            return (data ?? []).map((m) => ({ id: m.id, provider }));
+        }
+        catch {
+            return [];
+        }
+    });
 }

package/dist/handlers/openaiLikeEmbedding.d.ts

@@ -1,3 +1,3 @@
 import type { EmbeddingParams, EmbeddingResponse } from '../types';
 import type { OpenAILikeConfig } from '../mappings/openaiLike';
-export declare function createOpenAILikeEmbeddingHandler(config: OpenAILikeConfig): (params: EmbeddingParams) => Promise<EmbeddingResponse>;
+export declare function createOpenAILikeEmbeddingHandler(prefix: string, config: OpenAILikeConfig): (params: EmbeddingParams) => Promise<EmbeddingResponse>;

package/dist/handlers/openaiLikeEmbedding.js

@@ -2,14 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAILikeEmbeddingHandler = createOpenAILikeEmbeddingHandler;
 const openaiEmbedding_1 = require("./openaiEmbedding");
-function createOpenAILikeEmbeddingHandler(config) {
+function createOpenAILikeEmbeddingHandler(prefix, config) {
     return async (params) => {
         const apiKey = params.apiKey ?? process.env[config.apiKeyEnv];
         if (!apiKey) {
             throw new Error(`${config.name} requires an API key. Set the ${config.apiKeyEnv} environment variable or pass apiKey in params.`);
         }
+        const modelName = params.model.startsWith(prefix)
+            ? params.model.slice(prefix.length)
+            : params.model;
         return (0, openaiEmbedding_1.OpenAIEmbeddingHandler)({
             ...params,
+            model: modelName,
             apiKey,
             baseUrl: config.baseUrl,
         });
@@ -18,5 +22,5 @@ function createOpenAILikeEmbeddingHandler(config) {
 const openaiLike_1 = require("../mappings/openaiLike");
 const registry_1 = require("../registry");
 for (const [prefix, config] of Object.entries(openaiLike_1.OPENAI_LIKE_MAPPINGS)) {
-    (0, registry_1.registerEmbeddingHandler)(prefix, createOpenAILikeEmbeddingHandler(config));
+    (0, registry_1.registerEmbeddingHandler)(prefix, createOpenAILikeEmbeddingHandler(prefix, config));
 }

package/dist/handlers/replicate.js

@@ -106,5 +106,18 @@ async function ReplicateHandler(params) {
     }
     return handleNonStreamingPrediction(prompt, prediction, replicate, modelName);
 }
-const registry_1 = require("../registry");
-(0, registry_1.registerCompletionHandler)('replicate/', ReplicateHandler);
+const registry_1 = require("../models/registry");
+(0, registry_1.registerModelProvider)('replicate', async ({ apiKey } = {}) => {
+    const key = apiKey ?? process.env.REPLICATE_API_KEY;
+    if (!key)
+        return [];
+    const res = await fetch('https://api.replicate.com/v1/models', {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    if (!res.ok)
+        return [];
+    const { results } = await res.json();
+    return (results ?? []).map((m) => ({ id: `${m.owner}/${m.name}`, provider: 'replicate' }));
+});
+const registry_2 = require("../registry");
+(0, registry_2.registerCompletionHandler)('replicate/', ReplicateHandler);

package/dist/handlers/vertexAnthropic.d.ts

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

package/dist/handlers/vertexAnthropic.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexAnthropicHandler = VertexAnthropicHandler;
+const vertex_sdk_1 = require("@anthropic-ai/vertex-sdk");
+const anthropic_1 = require("../utils/anthropic");
+async function VertexAnthropicHandler(params) {
+    const project = params.project ?? process.env.GCP_PROJECT;
+    if (!project)
+        throw new Error('Vertex AI Anthropic requires GCP_PROJECT environment variable or project in params.');
+    const region = params.location ?? process.env.CLOUD_ML_REGION ?? 'us-central1';
+    const modelName = params.model.startsWith('vertex/')
+        ? params.model.slice(7)
+        : params.model;
+    const anthropic = new vertex_sdk_1.AnthropicVertex({
+        projectId: project,
+        region,
+    });
+    const { system, messages } = (0, anthropic_1.toAnthropicMessages)(params.messages);
+    try {
+        if (params.stream) {
+            const stream = await anthropic.messages.create({
+                model: modelName,
+                max_tokens: params.max_tokens ?? 300,
+                messages,
+                ...(system ? { system } : {}),
+                stream: true,
+            });
+            return (0, anthropic_1.toAnthropicStreamingResponse)(stream);
+        }
+        const message = await anthropic.messages.create({
+            model: modelName,
+            max_tokens: params.max_tokens ?? 300,
+            messages,
+            ...(system ? { system } : {}),
+        });
+        return (0, anthropic_1.toAnthropicResponse)(message);
+    }
+    catch (err) {
+        throw new Error(`Vertex Anthropic error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('vertex/claude-', VertexAnthropicHandler);

package/dist/handlers/vertexai.d.ts

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litellmts-core",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "TypeScript implementation of LiteLLM — unified interface for 45+ LLM providers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,7 +40,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.104.1",
-    "@google/generative-ai": "^0.24.1",
+    "@google/genai": "^2.8.0",
     "cohere-ai": "^8.0.0",
     "eventsource": "^4.1.0",
     "js-tiktoken": "^1.0.21",