litellmts-core 1.0.0

package/dist/handlers/deepinfra.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepInfraHandler = DeepInfraHandler;
+const sse_1 = require("../utils/sse");
+async function getDeepInfraResponse(model, messages, baseUrl, apiKey, stream) {
+    return fetch(`${baseUrl}/v1/openai/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            messages,
+            model,
+            stream,
+        }),
+    });
+}
+async function DeepInfraHandler(params) {
+    const baseUrl = params.baseUrl ?? 'https://api.deepinfra.com';
+    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 res = await getDeepInfraResponse(model, params.messages, baseUrl, apiKey, params.stream ?? false);
+    if (!res.ok) {
+        throw new Error(`DeepInfra API error: ${res.status} ${res.statusText}`);
+    }
+    if (params.stream) {
+        return (0, sse_1.iterateSSEStream)(res, (payload) => JSON.parse(payload));
+    }
+    const body = await res.json();
+    const result = {
+        created: body.created,
+        model: body.model,
+        choices: body.choices.map((c) => ({
+            finish_reason: c.finish_reason,
+            index: c.index,
+            message: {
+                role: c.message.role,
+                content: c.message.content,
+                function_call: c.message.function_call ?? undefined,
+            },
+        })),
+        usage: body.usage
+            ? {
+                prompt_tokens: body.usage.prompt_tokens,
+                completion_tokens: body.usage.completion_tokens,
+                total_tokens: body.usage.total_tokens,
+            }
+            : undefined,
+    };
+    return result;
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('deepinfra/', DeepInfraHandler);

package/dist/handlers/gemini.d.ts

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

package/dist/handlers/gemini.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiHandler = GeminiHandler;
+const generative_ai_1 = require("@google/generative-ai");
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+function toGeminiContent(messages) {
+    return messages.map((msg) => {
+        const parts = [];
+        if (msg.content) {
+            parts.push({ text: msg.content });
+        }
+        return {
+            role: msg.role === 'assistant' ? 'model' : msg.role,
+            parts,
+        };
+    });
+}
+function toFinishReason(reason) {
+    switch (reason) {
+        case 'STOP':
+            return 'stop';
+        case 'MAX_TOKENS':
+            return 'length';
+        default:
+            return 'stop';
+    }
+}
+function toUsage(meta) {
+    if (!meta)
+        return undefined;
+    return {
+        prompt_tokens: meta.promptTokenCount,
+        completion_tokens: meta.candidatesTokenCount,
+        total_tokens: meta.totalTokenCount,
+    };
+}
+function toResponse(response, model) {
+    const candidate = response.candidates?.[0];
+    return {
+        model: model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: toUsage(response.usageMetadata),
+        choices: [
+            {
+                index: candidate?.index ?? 0,
+                finish_reason: toFinishReason(candidate?.finishReason),
+                message: {
+                    role: 'assistant',
+                    content: candidate ? candidate.content.parts.map((p) => 'text' in p ? p.text : '').join('') : null,
+                },
+            },
+        ],
+    };
+}
+async function* toStreamingResponse(stream) {
+    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,
+            created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+            usage: toUsage(chunk.usageMetadata),
+            choices: [
+                {
+                    index: candidate?.index ?? 0,
+                    finish_reason: toFinishReason(candidate?.finishReason),
+                    delta: {
+                        content: deltaContent,
+                        role: 'assistant',
+                    },
+                },
+            ],
+        };
+    }
+}
+async function GeminiHandler(params) {
+    const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
+    if (!apiKey)
+        throw new Error('Gemini requires an API key. Set GEMINI_API_KEY environment variable or pass apiKey in params.');
+    const modelName = params.model.startsWith('gemini/')
+        ? params.model.slice(7)
+        : params.model;
+    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
+    const model = genAI.getGenerativeModel({
+        model: modelName,
+        generationConfig: {
+            temperature: params.temperature ?? undefined,
+            topP: params.top_p ?? undefined,
+            maxOutputTokens: params.max_tokens ?? undefined,
+            stopSequences: params.stop ? (Array.isArray(params.stop) ? params.stop : [params.stop]) : undefined,
+        },
+    });
+    const contents = toGeminiContent(params.messages);
+    if (params.stream) {
+        const result = await model.generateContentStream({ contents });
+        return toStreamingResponse(result.stream);
+    }
+    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/geminiEmbedding.d.ts

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

package/dist/handlers/geminiEmbedding.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiEmbeddingHandler = GeminiEmbeddingHandler;
+const generative_ai_1 = require("@google/generative-ai");
+async function GeminiEmbeddingHandler(params) {
+    const apiKey = params.apiKey ?? process.env.GEMINI_API_KEY;
+    if (!apiKey)
+        throw new Error('Gemini requires an API key. Set GEMINI_API_KEY environment variable or pass apiKey in params.');
+    const modelName = params.model.startsWith('gemini/')
+        ? params.model.slice(7)
+        : params.model;
+    const genAI = new generative_ai_1.GoogleGenerativeAI(apiKey);
+    const model = genAI.getGenerativeModel({ model: modelName });
+    const input = typeof params.input === 'string'
+        ? params.input
+        : params.input.join(' ');
+    const result = await model.embedContent({
+        content: {
+            role: 'user',
+            parts: [{ text: input }],
+        },
+    });
+    return {
+        model: modelName,
+        data: [{ embedding: result.embedding.values, index: 0 }],
+    };
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerEmbeddingHandler)('gemini/', GeminiEmbeddingHandler);

package/dist/handlers/getHandler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Find a handler function by matching the model name against registered prefix patterns.
+ *
+ * Each handler registers itself with a prefix (e.g. `'gpt-'`, `'claude-'`). This function
+ * checks if the model name starts with any registered prefix and returns the matching handler.
+ *
+ * @param model - The model name to look up (e.g. `'gpt-4'`, `'claude-3-opus'`)
+ * @param mapping - A record of prefix → handler function
+ * @returns The matching handler, or `null` if no prefix matches
+ */
+export declare function getHandler<T>(model: string, mapping: Record<string, T>): T | null;

package/dist/handlers/getHandler.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHandler = getHandler;
+/**
+ * Find a handler function by matching the model name against registered prefix patterns.
+ *
+ * Each handler registers itself with a prefix (e.g. `'gpt-'`, `'claude-'`). This function
+ * checks if the model name starts with any registered prefix and returns the matching handler.
+ *
+ * @param model - The model name to look up (e.g. `'gpt-4'`, `'claude-3-opus'`)
+ * @param mapping - A record of prefix → handler function
+ * @returns The matching handler, or `null` if no prefix matches
+ */
+function getHandler(model, mapping) {
+    const patterns = Object.keys(mapping);
+    const handlerKey = patterns.find((pattern) => {
+        const regex = new RegExp(`^${pattern}`);
+        return model.match(regex);
+    });
+    if (!handlerKey) {
+        return null;
+    }
+    return mapping[handlerKey];
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,16 @@
+import './anthropic';
+import './cohere';
+import './ollama';
+import './openai';
+import './ai21';
+import './replicate';
+import './deepinfra';
+import './mistral';
+import './gemini';
+import './copilot';
+import './openaiLike';
+import './openaiEmbedding';
+import './ollamaEmbedding';
+import './mistralEmbedding';
+import './geminiEmbedding';
+import './openaiLikeEmbedding';

package/dist/handlers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./anthropic");
+require("./cohere");
+require("./ollama");
+require("./openai");
+require("./ai21");
+require("./replicate");
+require("./deepinfra");
+require("./mistral");
+require("./gemini");
+require("./copilot");
+require("./openaiLike");
+require("./openaiEmbedding");
+require("./ollamaEmbedding");
+require("./mistralEmbedding");
+require("./geminiEmbedding");
+require("./openaiLikeEmbedding");

package/dist/handlers/mistral.d.ts

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

package/dist/handlers/mistral.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralHandler = MistralHandler;
+const sse_1 = require("../utils/sse");
+async function getMistralResponse(model, messages, baseUrl, apiKey, stream) {
+    return fetch(`${baseUrl}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            messages,
+            model,
+            stream,
+        }),
+    });
+}
+async function MistralHandler(params) {
+    const baseUrl = params.baseUrl ?? 'https://api.mistral.ai';
+    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 res = await getMistralResponse(model, params.messages, baseUrl, apiKey, params.stream ?? false);
+    if (!res.ok) {
+        throw new Error(`Mistral API error: ${res.status} ${res.statusText}`);
+    }
+    if (params.stream) {
+        return (0, sse_1.iterateSSEStream)(res, (payload) => JSON.parse(payload));
+    }
+    const body = await res.json();
+    const result = {
+        created: body.created,
+        model: body.model,
+        choices: body.choices.map((c) => ({
+            finish_reason: c.finish_reason,
+            index: c.index,
+            message: {
+                role: c.message.role,
+                content: c.message.content,
+                function_call: c.message.function_call ?? undefined,
+            },
+        })),
+        usage: body.usage
+            ? {
+                prompt_tokens: body.usage.prompt_tokens,
+                completion_tokens: body.usage.completion_tokens,
+                total_tokens: body.usage.total_tokens,
+            }
+            : undefined,
+    };
+    return result;
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('mistral/', MistralHandler);

package/dist/handlers/mistralEmbedding.d.ts

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

package/dist/handlers/mistralEmbedding.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralEmbeddingHandler = MistralEmbeddingHandler;
+async function getMistralResponse(model, input, baseUrl, apiKey) {
+    return fetch(`${baseUrl}/v1/embeddings`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model,
+            input: typeof input === 'string' ? [input] : input,
+        }),
+    });
+}
+async function MistralEmbeddingHandler(params) {
+    const model = params.model.split('mistral/')[1];
+    const baseUrl = params.baseUrl ?? 'https://api.mistral.ai';
+    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 response = await getMistralResponse(model, params.input, baseUrl, apiKey);
+    if (!response.ok) {
+        throw new Error(`Received an error with code ${response.status} from Mistral API.`);
+    }
+    const body = (await response.json());
+    return body;
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerEmbeddingHandler)('mistral/', MistralEmbeddingHandler);

package/dist/handlers/ollama.d.ts

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

package/dist/handlers/ollama.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaHandler = OllamaHandler;
+const combinePrompts_1 = require("../utils/combinePrompts");
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+const toUsage_1 = require("../utils/toUsage");
+function toStreamingChunk(ollamaResponse, model, prompt) {
+    return {
+        model: model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: (0, toUsage_1.toUsage)(prompt, ollamaResponse.response),
+        choices: [
+            {
+                delta: { content: ollamaResponse.response, role: 'assistant' },
+                finish_reason: 'stop',
+                index: 0,
+            },
+        ],
+    };
+}
+function toResponse(content, model, prompt) {
+    return {
+        model: model,
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        usage: (0, toUsage_1.toUsage)(prompt, content),
+        choices: [
+            {
+                message: { content, role: 'assistant' },
+                finish_reason: 'stop',
+                index: 0,
+            },
+        ],
+    };
+}
+async function* iterateResponse(response, model, prompt) {
+    const reader = response.body?.getReader();
+    let done = false;
+    while (!done) {
+        const next = await reader?.read();
+        if (next?.value) {
+            const decoded = new TextDecoder().decode(next.value);
+            done = next.done;
+            const lines = decoded.split(/(?<!\\)\n/);
+            const ollamaResponses = lines
+                .map((line) => line.trim())
+                .filter((line) => line !== '')
+                .map((line) => JSON.parse(line))
+                .map((response) => toStreamingChunk(response, model, prompt));
+            yield* ollamaResponses;
+        }
+        else {
+            done = true;
+        }
+    }
+}
+async function getOllamaResponse(model, prompt, baseUrl) {
+    return fetch(`${baseUrl}/api/generate`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model,
+            prompt,
+        }),
+    });
+}
+async function OllamaHandler(params) {
+    const baseUrl = params.baseUrl ?? 'http://127.0.0.1:11434';
+    const model = params.model.split('ollama/')[1];
+    const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
+    const res = await getOllamaResponse(model, prompt, baseUrl);
+    if (!res.ok) {
+        throw new Error(`Received an error with code ${res.status} from Ollama API.`);
+    }
+    if (params.stream) {
+        return iterateResponse(res, model, prompt);
+    }
+    const chunks = [];
+    for await (const chunk of iterateResponse(res, model, prompt)) {
+        chunks.push(chunk);
+    }
+    const message = chunks.reduce((acc, chunk) => {
+        return (acc += chunk.choices[0].delta.content);
+    }, '');
+    return toResponse(message, model, prompt);
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('ollama/', OllamaHandler);

package/dist/handlers/ollamaEmbedding.d.ts

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

package/dist/handlers/ollamaEmbedding.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaEmbeddingHandler = OllamaEmbeddingHandler;
+const toUsage_1 = require("../utils/toUsage");
+async function getOllamaResponse(model, input, baseUrl) {
+    return fetch(`${baseUrl}/api/embeddings`, {
+        method: 'POST',
+        body: JSON.stringify({
+            model,
+            prompt: input,
+            stream: false,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        }),
+    });
+}
+async function OllamaEmbeddingHandler(params) {
+    const model = params.model.split('ollama/')[1];
+    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), '');
+    const response = await getOllamaResponse(model, input, baseUrl);
+    if (!response.ok) {
+        throw new Error(`Received an error with code ${response.status} from Ollama API.`);
+    }
+    const body = (await response.json());
+    return {
+        data: [{ embedding: body.embedding, index: 0 }],
+        model: model,
+        usage: (0, toUsage_1.toEmbeddingUsage)(input),
+    };
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerEmbeddingHandler)('ollama/', OllamaEmbeddingHandler);

package/dist/handlers/openai.d.ts

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

package/dist/handlers/openai.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIHandler = OpenAIHandler;
+const openai_1 = __importDefault(require("openai"));
+function toOpenAIMessages(messages) {
+    return messages;
+}
+async function* toStreamingResponse(response) {
+    for await (const chunk of response) {
+        yield {
+            model: chunk.model,
+            created: chunk.created,
+            choices: chunk.choices.map((openAIChoice) => {
+                return {
+                    delta: {
+                        content: openAIChoice.delta.content,
+                        role: openAIChoice.delta.role,
+                        function_call: openAIChoice.delta.function_call,
+                    },
+                    index: openAIChoice.index,
+                    finish_reason: openAIChoice.finish_reason,
+                };
+            }),
+        };
+    }
+}
+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 openai = new openai_1.default({
+        apiKey: apiKey,
+        baseURL: baseUrl,
+    });
+    const messages = toOpenAIMessages(completionsParams.messages);
+    if (params.stream) {
+        const response = await openai.chat.completions.create({
+            ...completionsParams,
+            stream: true,
+            messages,
+        });
+        return toStreamingResponse(response);
+    }
+    const response = await openai.chat.completions.create({
+        ...completionsParams,
+        stream: false,
+        messages,
+    });
+    const result = {
+        created: response.created,
+        model: response.model,
+        choices: response.choices.map((c) => ({
+            finish_reason: c.finish_reason,
+            index: c.index,
+            message: {
+                role: c.message.role,
+                content: c.message.content,
+                function_call: c.message.function_call ?? undefined,
+            },
+        })),
+        usage: response.usage
+            ? {
+                prompt_tokens: response.usage.prompt_tokens,
+                completion_tokens: response.usage.completion_tokens,
+                total_tokens: response.usage.total_tokens,
+            }
+            : undefined,
+    };
+    return result;
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('gpt-', OpenAIHandler);
+(0, registry_1.registerCompletionHandler)('openai/', OpenAIHandler);

package/dist/handlers/openaiEmbedding.d.ts

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

package/dist/handlers/openaiEmbedding.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIEmbeddingHandler = OpenAIEmbeddingHandler;
+const openai_1 = __importDefault(require("openai"));
+async function OpenAIEmbeddingHandler(params) {
+    const apiKey = params.apiKey ?? process.env.OPENAI_API_KEY;
+    const baseUrl = params.baseUrl;
+    const openai = new openai_1.default({
+        apiKey: apiKey,
+        baseURL: baseUrl,
+    });
+    return openai.embeddings.create({ input: params.input, model: params.model });
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerEmbeddingHandler)('text-embedding-', OpenAIEmbeddingHandler);

package/dist/handlers/openaiLike.d.ts

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

package/dist/handlers/openaiLike.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAILikeHandler = createOpenAILikeHandler;
+const openai_1 = require("./openai");
+function createOpenAILikeHandler(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.`);
+        }
+        return (0, openai_1.OpenAIHandler)({
+            ...params,
+            apiKey,
+            baseUrl: config.baseUrl,
+        });
+    };
+}
+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.registerCompletionHandler)(prefix, createOpenAILikeHandler(config));
+}

package/dist/handlers/openaiLikeEmbedding.d.ts

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

package/dist/handlers/openaiLikeEmbedding.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAILikeEmbeddingHandler = createOpenAILikeEmbeddingHandler;
+const openaiEmbedding_1 = require("./openaiEmbedding");
+function createOpenAILikeEmbeddingHandler(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.`);
+        }
+        return (0, openaiEmbedding_1.OpenAIEmbeddingHandler)({
+            ...params,
+            apiKey,
+            baseUrl: config.baseUrl,
+        });
+    };
+}
+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));
+}