litellmts-core 1.0.0

package/dist/auth/store.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderCredentials = getProviderCredentials;
+exports.setProviderCredentials = setProviderCredentials;
+exports.getCopilotCredentials = getCopilotCredentials;
+exports.setCopilotCredentials = setCopilotCredentials;
+exports.getAnthropicCredentials = getAnthropicCredentials;
+exports.setAnthropicCredentials = setAnthropicCredentials;
+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 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) {
+    return err?.code === 'ENOENT';
+}
+async function ensureDir() {
+    await (0, promises_1.mkdir)(STORE_DIR, { recursive: true });
+}
+async function readStore() {
+    try {
+        const data = await (0, promises_1.readFile)(STORE_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        if (isNotFound(err))
+            return {};
+        throw err;
+    }
+}
+async function getProviderCredentials(provider) {
+    try {
+        const store = await readStore();
+        const raw = store[provider];
+        if (!raw)
+            return null;
+        return raw;
+    }
+    catch (err) {
+        if (isNotFound(err))
+            return null;
+        throw err;
+    }
+}
+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');
+}
+// Backward-compat old single-provider format
+async function getCopilotCredentials() {
+    const legacy = await getProviderCredentials('github-copilot');
+    if (legacy)
+        return legacy;
+    try {
+        const store = await readStore();
+        if (store.copilotToken && store.githubToken) {
+            const migrated = {
+                githubToken: store.githubToken,
+                copilotToken: store.copilotToken,
+                expiresAt: store.expiresAt,
+                enterpriseUrl: store.enterpriseUrl,
+            };
+            await setProviderCredentials('github-copilot', migrated);
+            return migrated;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+async function setCopilotCredentials(creds) {
+    await setProviderCredentials('github-copilot', creds);
+}
+async function getAnthropicCredentials() {
+    return getProviderCredentials('anthropic');
+}
+async function setAnthropicCredentials(creds) {
+    await setProviderCredentials('anthropic', creds);
+}
+async function clearCredentials() {
+    try {
+        await (0, promises_1.writeFile)(STORE_PATH, JSON.stringify({}), 'utf-8');
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/bin/litellm.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/litellm.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+/* eslint-disable no-console, @typescript-eslint/no-unsafe-return */
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const copilot_1 = require("../auth/copilot");
+const anthropic_1 = require("../auth/anthropic");
+function findPackageJson(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 10; i++) {
+        try {
+            return JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(dir, 'package.json'), 'utf8'));
+        }
+        catch {
+            dir = (0, path_1.resolve)(dir, '..');
+        }
+    }
+    throw new Error('Could not find package.json');
+}
+const pkg = findPackageJson(__dirname);
+const [cmd, subcmd] = process.argv.slice(2);
+if (cmd === 'login' && subcmd === 'copilot') {
+    (0, copilot_1.login)().catch((err) => {
+        console.error('\n❌ Error:', err.message);
+        process.exit(1);
+    });
+}
+else if (cmd === 'login' && subcmd === 'anthropic') {
+    (0, anthropic_1.loginAnthropic)().catch((err) => {
+        console.error('\n❌ Error:', err.message);
+        process.exit(1);
+    });
+}
+else if (cmd === '--version' || cmd === '-v') {
+    console.log(pkg.version);
+}
+else {
+    console.log(`litellmTS v${pkg.version}`);
+    console.log('');
+    console.log('Uso:');
+    console.log('  litellm login copilot      Iniciar sesión en GitHub Copilot');
+    console.log('  litellm login anthropic    Configurar API key de Anthropic');
+    console.log('  litellm --version          Mostrar versión');
+}

package/dist/completion.d.ts

@@ -0,0 +1,24 @@
+import { Handler, HandlerParams, HandlerParamsNotStreaming, HandlerParamsStreaming, Result, ResultNotStreaming, ResultStreaming } from './types';
+import './handlers';
+export declare const MODEL_HANDLER_MAPPINGS: Record<string, Handler>;
+/**
+ * Send a chat completion request to the provider that matches the model prefix.
+ *
+ * Supports 45+ providers including OpenAI, Anthropic, Cohere, Gemini, Groq, Together AI, and more.
+ * Model routing is automatic based on the model name prefix (e.g. `gpt-`, `claude-`, `gemini/`).
+ *
+ * @param params - The completion parameters including model, messages, and optional stream flag
+ * @returns The completion result (non-streaming) or an async iterable (streaming)
+ *
+ * @example
+ * // Non-streaming
+ * const res = await completion({ model: 'gpt-4', messages: [{ role: 'user', content: 'Hello' }] });
+ *
+ * @example
+ * // Streaming
+ * const stream = await completion({ model: 'claude-3', messages: [{ role: 'user', content: 'Hi' }], stream: true });
+ * for await (const chunk of stream) { process.stdout.write(chunk.choices[0].delta.content ?? ''); }
+ */
+export declare function completion(params: HandlerParamsNotStreaming): Promise<ResultNotStreaming>;
+export declare function completion(params: HandlerParamsStreaming): Promise<ResultStreaming>;
+export declare function completion(params: HandlerParams): Promise<Result>;

package/dist/completion.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_HANDLER_MAPPINGS = void 0;
+exports.completion = completion;
+const getHandler_1 = require("./handlers/getHandler");
+const registry_1 = require("./registry");
+require("./handlers");
+exports.MODEL_HANDLER_MAPPINGS = (0, registry_1.getCompletionHandlers)();
+async function completion(params) {
+    const handler = (0, getHandler_1.getHandler)(params.model, exports.MODEL_HANDLER_MAPPINGS);
+    if (!handler) {
+        throw new Error(`Model: ${params.model} not supported. Cannot find a handler.`);
+    }
+    return handler(params);
+}

package/dist/embedding.d.ts

@@ -0,0 +1,15 @@
+import { EmbeddingParams, EmbeddingResponse } from './types';
+import './handlers';
+/**
+ * Generate embeddings for the given input using the provider that matches the model prefix.
+ *
+ * Supports OpenAI, Mistral, Gemini, Ollama, and 38+ OpenAI-compatible embedding providers.
+ *
+ * @param params - The embedding parameters including input text and model name
+ * @returns An embedding response with the vector data
+ *
+ * @example
+ * const res = await embedding({ model: 'text-embedding-3-small', input: 'Hello world' });
+ * console.log(res.data[0].embedding);
+ */
+export declare function embedding(params: EmbeddingParams): Promise<EmbeddingResponse>;

package/dist/embedding.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embedding = embedding;
+const getHandler_1 = require("./handlers/getHandler");
+const registry_1 = require("./registry");
+require("./handlers");
+const EMBEDDING_MODEL_HANDLER_MAPPINGS = (0, registry_1.getEmbeddingHandlers)();
+/**
+ * Generate embeddings for the given input using the provider that matches the model prefix.
+ *
+ * Supports OpenAI, Mistral, Gemini, Ollama, and 38+ OpenAI-compatible embedding providers.
+ *
+ * @param params - The embedding parameters including input text and model name
+ * @returns An embedding response with the vector data
+ *
+ * @example
+ * const res = await embedding({ model: 'text-embedding-3-small', input: 'Hello world' });
+ * console.log(res.data[0].embedding);
+ */
+async function embedding(params) {
+    const handler = (0, getHandler_1.getHandler)(params.model, EMBEDDING_MODEL_HANDLER_MAPPINGS);
+    if (!handler) {
+        throw new Error(`Model: ${params.model} not supported. Cannot find a handler.`);
+    }
+    return handler(params);
+}

package/dist/handlers/ai21.d.ts

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

package/dist/handlers/ai21.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI21Handler = AI21Handler;
+const combinePrompts_1 = require("../utils/combinePrompts");
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+const sse_1 = require("../utils/sse");
+const FINISH_REASON_MAP = {
+    length: 'length',
+    endoftext: 'stop',
+};
+function toUsage(response) {
+    const promptTokens = response.prompt.tokens.length;
+    const completionTokens = response.completions.reduce((acc, completion) => {
+        return acc + completion.data.tokens.length;
+    }, 0);
+    return {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+    };
+}
+function toResponse(response, model) {
+    const choices = response.completions.map((completion, i) => {
+        return {
+            finish_reason: FINISH_REASON_MAP[completion.finishReason.reason] ?? 'stop',
+            index: i,
+            message: {
+                content: completion.data.text,
+                role: 'assistant',
+            },
+        };
+    });
+    return {
+        model: model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: toUsage(response),
+        choices: choices,
+    };
+}
+async function getAI21Response(model, prompt, baseUrl, apiKey, stream) {
+    const body = { prompt };
+    if (stream)
+        body.stream = true;
+    return fetch(`${baseUrl}/studio/v1/${model}/complete`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            accept: stream ? 'text/event-stream' : 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+}
+async function AI21Handler(params) {
+    const baseUrl = params.baseUrl ?? 'https://api.ai21.com';
+    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 prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
+    const res = await getAI21Response(model, prompt, baseUrl, apiKey, params.stream ?? false);
+    if (!res.ok) {
+        throw new Error(`Received an error with code ${res.status} from AI21 API.`);
+    }
+    if (params.stream) {
+        return (0, sse_1.iterateSSEStream)(res, (payload) => {
+            const parsed = JSON.parse(payload);
+            return {
+                model,
+                created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+                choices: [
+                    {
+                        delta: { content: parsed.text ?? '', role: 'assistant' },
+                        finish_reason: parsed.finishReason
+                            ? (FINISH_REASON_MAP[parsed.finishReason.reason] ?? 'stop')
+                            : null,
+                        index: 0,
+                    },
+                ],
+            };
+        });
+    }
+    const body = (await res.json());
+    return toResponse(body, model);
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('j2-', AI21Handler);

package/dist/handlers/anthropic.d.ts

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

package/dist/handlers/anthropic.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicHandler = AnthropicHandler;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+const toUsage_1 = require("../utils/toUsage");
+const auth_1 = require("../auth");
+function toAnthropicPrompt(messages) {
+    return messages
+        .map((msg) => {
+        const content = msg.content ?? '';
+        if (msg.role === 'assistant') {
+            return `${sdk_1.default.AI_PROMPT} ${content}`;
+        }
+        return `${sdk_1.default.HUMAN_PROMPT} ${content}`;
+    })
+        .join('') + sdk_1.default.AI_PROMPT;
+}
+function toFinishReson(string) {
+    if (string === 'max_tokens') {
+        return 'length';
+    }
+    return 'stop';
+}
+function toResponse(anthropicResponse, prompt) {
+    return {
+        model: anthropicResponse.model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: (0, toUsage_1.toUsage)(prompt, anthropicResponse.completion),
+        choices: [
+            {
+                message: {
+                    content: anthropicResponse.completion,
+                    role: 'assistant',
+                },
+                finish_reason: toFinishReson(anthropicResponse.stop_reason),
+                index: 0,
+            },
+        ],
+    };
+}
+function toStreamingChunk(anthropicResponse) {
+    return {
+        model: anthropicResponse.model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        choices: [
+            {
+                delta: { content: anthropicResponse.completion, role: 'assistant' },
+                finish_reason: toFinishReson(anthropicResponse.stop_reason),
+                index: 0,
+            },
+        ],
+    };
+}
+async function* toStreamingResponse(stream) {
+    for await (const chunk of stream) {
+        yield toStreamingChunk(chunk);
+    }
+}
+async function AnthropicHandler(params) {
+    const apiKey = params.apiKey ?? process.env.ANTHROPIC_API_KEY ?? (await (0, auth_1.getAnthropicKey)());
+    const anthropic = new sdk_1.default({
+        apiKey: apiKey,
+    });
+    const prompt = toAnthropicPrompt(params.messages);
+    const anthropicParams = {
+        model: params.model,
+        max_tokens_to_sample: params.max_tokens ?? 300,
+        prompt,
+    };
+    if (params.stream) {
+        const completionStream = await anthropic.completions.create({
+            ...anthropicParams,
+            stream: params.stream,
+        });
+        return toStreamingResponse(completionStream);
+    }
+    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.d.ts

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

package/dist/handlers/cohere.js

@@ -0,0 +1,85 @@
+"use strict";
+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");
+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 = {
+        model: params.model,
+        prompt: textsCombined,
+        max_tokens: params.max_tokens ?? 50,
+        temperature: params.temperature ?? 1,
+    };
+    if (params.stream) {
+        const stream = await cohere.generateStream({
+            model: params.model,
+            prompt: textsCombined,
+            maxTokens: params.max_tokens ?? 50,
+            temperature: params.temperature ?? 1,
+        });
+        return toRealStream(stream, params.model, textsCombined);
+    }
+    const response = await cohere.generate(config);
+    return {
+        model: params.model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: (0, toUsage_1.toUsage)(textsCombined, response.generations[0].text),
+        choices: [
+            {
+                message: {
+                    content: response.generations[0].text,
+                    role: 'assistant',
+                },
+                finish_reason: 'stop',
+                index: 0,
+            },
+        ],
+    };
+}
+async function* toRealStream(stream, model, prompt) {
+    let fullText = '';
+    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' },
+                        finish_reason: null,
+                        index: 0,
+                    },
+                ],
+            };
+        }
+        else if (event.eventType === 'stream-end') {
+            yield {
+                model,
+                created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+                usage: (0, toUsage_1.toUsage)(prompt, fullText),
+                choices: [
+                    {
+                        delta: { content: '', role: 'assistant' },
+                        finish_reason: 'stop',
+                        index: 0,
+                    },
+                ],
+            };
+        }
+        else if (event.eventType === 'stream-error') {
+            const msg = event.message ?? 'unknown';
+            throw new Error(`Cohere stream error: ${msg}`);
+        }
+    }
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('command', CohereHandler);

package/dist/handlers/copilot.d.ts

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

package/dist/handlers/copilot.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotHandler = CopilotHandler;
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+const auth_1 = require("../auth");
+const COPILOT_API = 'https://api.githubcopilot.com';
+const USER_AGENT = 'GitHubCopilotChat/0.35.0';
+const EDITOR_VERSION = 'vscode/1.107.0';
+const EDITOR_PLUGIN_VERSION = 'copilot-chat/0.35.0';
+const COPILOT_INTEGRATION_ID = 'vscode-chat';
+function getAuthHeaders(token) {
+    return {
+        Authorization: `Bearer ${token}`,
+        'User-Agent': USER_AGENT,
+        'Editor-Version': EDITOR_VERSION,
+        'Editor-Plugin-Version': EDITOR_PLUGIN_VERSION,
+        'Copilot-Integration-Id': COPILOT_INTEGRATION_ID,
+        'Openai-Intent': 'conversation-edits',
+    };
+}
+function toUsage(data) {
+    if (!data.usage)
+        return undefined;
+    return {
+        prompt_tokens: data.usage.prompt_tokens ?? 0,
+        completion_tokens: data.usage.completion_tokens ?? 0,
+        total_tokens: data.usage.total_tokens ?? 0,
+    };
+}
+async function* toStreamingResponse(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('No response body');
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed?.startsWith('data: '))
+                continue;
+            const payload = trimmed.slice(6);
+            if (payload === '[DONE]')
+                return;
+            try {
+                const parsed = JSON.parse(payload);
+                yield {
+                    model: parsed.model,
+                    created: parsed.created,
+                    usage: toUsage(parsed),
+                    choices: (parsed.choices ?? []).map((c) => ({
+                        delta: {
+                            content: c.delta?.content ?? null,
+                            role: c.delta?.role ?? null,
+                        },
+                        index: c.index ?? 0,
+                        finish_reason: c.finish_reason ?? null,
+                    })),
+                };
+            }
+            catch {
+                // skip parse errors
+            }
+        }
+    }
+}
+async function CopilotHandler(params) {
+    const apiKey = params.apiKey ??
+        process.env.COPILOT_API_KEY ??
+        (await (0, auth_1.getValidToken)());
+    if (!apiKey) {
+        throw new Error('No se encontró token de Copilot. Ejecuta: npx litellm login copilot');
+    }
+    const baseUrl = params.baseUrl ?? COPILOT_API;
+    const model = params.model.startsWith('copilot/')
+        ? params.model.slice(8)
+        : params.model;
+    const body = {
+        model,
+        messages: params.messages.map((m) => ({
+            role: m.role,
+            content: m.content,
+        })),
+        stream: params.stream ?? false,
+    };
+    if (params.temperature != null)
+        body.temperature = params.temperature;
+    if (params.top_p != null)
+        body.top_p = params.top_p;
+    if (params.max_tokens != null)
+        body.max_tokens = params.max_tokens;
+    if (params.stop != null)
+        body.stop = params.stop;
+    if (params.presence_penalty != null)
+        body.presence_penalty = params.presence_penalty;
+    if (params.n != null)
+        body.n = params.n;
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...getAuthHeaders(apiKey),
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Error de Copilot API: ${response.status} ${response.statusText}\n${text}`);
+    }
+    if (params.stream) {
+        return toStreamingResponse(response);
+    }
+    const data = (await response.json());
+    const choices = (data.choices ?? []).map((c) => ({
+        index: c.index,
+        finish_reason: c.finish_reason ?? null,
+        message: {
+            role: c.message?.role ?? 'assistant',
+            content: c.message?.content ?? null,
+        },
+    }));
+    const result = {
+        created: data.created ?? (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        model: data.model,
+        usage: toUsage(data),
+        choices,
+    };
+    return result;
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('copilot/', CopilotHandler);

package/dist/handlers/deepinfra.d.ts

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