litellmts-core 1.0.0

package/dist/handlers/replicate.d.ts

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

package/dist/handlers/replicate.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplicateHandler = ReplicateHandler;
+const replicate_1 = __importDefault(require("replicate"));
+const eventsource_1 = __importDefault(require("eventsource"));
+const combinePrompts_1 = require("../utils/combinePrompts");
+const toUsage_1 = require("../utils/toUsage");
+const getUnixTimestamp_1 = require("../utils/getUnixTimestamp");
+async function sleep(time) {
+    return new Promise((res) => {
+        setTimeout(() => {
+            res({});
+        }, time);
+    });
+}
+async function handleNonStreamingPrediction(prompt, prediction, replicate) {
+    const pred = await replicate.wait(prediction, {});
+    const output = pred.output.reduce((acc, curr) => (acc += curr), '');
+    return {
+        usage: (0, toUsage_1.toUsage)(prompt, output),
+        created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+        choices: [
+            {
+                message: {
+                    role: 'assistant',
+                    content: output,
+                },
+                finish_reason: 'stop',
+                index: 0,
+            },
+        ],
+    };
+}
+async function* handleStreamingPrediction(prompt, prediction) {
+    if (!prediction?.urls?.stream) {
+        throw new Error('Prediction does not support streaming');
+    }
+    const source = new eventsource_1.default(prediction.urls.stream, {
+        withCredentials: true,
+    });
+    let results = [];
+    let done = false;
+    let resolve;
+    let promise = new Promise((r) => (resolve = r));
+    source.addEventListener('output', (e) => {
+        results.push(e.data);
+        resolve({});
+        promise = new Promise((r) => (resolve = r));
+    });
+    source.addEventListener('done', () => {
+        done = true;
+        source.close();
+    });
+    while (!done) {
+        await promise;
+        await sleep(500);
+        const combined = results.reduce((acc, curr) => (acc += curr), '');
+        yield {
+            created: (0, getUnixTimestamp_1.getUnixTimestamp)(),
+            usage: (0, toUsage_1.toUsage)(prompt, combined),
+            choices: [
+                {
+                    delta: {
+                        content: combined,
+                        role: 'assistant',
+                    },
+                    index: 0,
+                    finish_reason: 'stop',
+                },
+            ],
+        };
+        results = [];
+    }
+}
+async function ReplicateHandler(params) {
+    const apiKey = params.apiKey ?? process.env.REPLICATE_API_KEY;
+    const replicate = new replicate_1.default({
+        auth: apiKey,
+    });
+    const model = params.model.split('replicate/')[1];
+    const version = model.split(':')[1];
+    const prompt = (0, combinePrompts_1.combinePrompts)(params.messages);
+    const prediction = await replicate.predictions.create({
+        version: version,
+        input: {
+            prompt,
+        },
+    });
+    if (params.stream) {
+        return handleStreamingPrediction(prompt, prediction);
+    }
+    return handleNonStreamingPrediction(prompt, prediction, replicate);
+}
+const registry_1 = require("../registry");
+(0, registry_1.registerCompletionHandler)('replicate/', ReplicateHandler);

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @litellmts/core — Unified API client for 45+ LLM providers.
+ *
+ * @example
+ * import { completion } from '@litellmts/core';
+ * const res = await completion({ model: 'gpt-4', messages: [{ role: 'user', content: 'Hello' }] });
+ */
+export { completion } from './completion';
+export { embedding } from './embedding';
+export { login, loginAnthropic, getValidToken, getAnthropicKey } from './auth';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnthropicKey = exports.getValidToken = exports.loginAnthropic = exports.login = exports.embedding = exports.completion = void 0;
+/**
+ * @litellmts/core — Unified API client for 45+ LLM providers.
+ *
+ * @example
+ * import { completion } from '@litellmts/core';
+ * const res = await completion({ model: 'gpt-4', messages: [{ role: 'user', content: 'Hello' }] });
+ */
+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 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; } });
+Object.defineProperty(exports, "getValidToken", { enumerable: true, get: function () { return auth_1.getValidToken; } });
+Object.defineProperty(exports, "getAnthropicKey", { enumerable: true, get: function () { return auth_1.getAnthropicKey; } });

package/dist/mappings/openaiLike.d.ts

@@ -0,0 +1,6 @@
+export interface OpenAILikeConfig {
+    name: string;
+    baseUrl: string;
+    apiKeyEnv: string;
+}
+export declare const OPENAI_LIKE_MAPPINGS: Record<string, OpenAILikeConfig>;

package/dist/mappings/openaiLike.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_LIKE_MAPPINGS = void 0;
+exports.OPENAI_LIKE_MAPPINGS = {
+    'groq/': {
+        name: 'Groq',
+        baseUrl: 'https://api.groq.com/openai/v1',
+        apiKeyEnv: 'GROQ_API_KEY',
+    },
+    'deepseek/': {
+        name: 'DeepSeek',
+        baseUrl: 'https://api.deepseek.com/beta',
+        apiKeyEnv: 'DEEPSEEK_API_KEY',
+    },
+    'perplexity/': {
+        name: 'Perplexity',
+        baseUrl: 'https://api.perplexity.ai',
+        apiKeyEnv: 'PERPLEXITY_API_KEY',
+    },
+    'xai/': {
+        name: 'X AI',
+        baseUrl: 'https://api.x.ai/v1',
+        apiKeyEnv: 'XAI_API_KEY',
+    },
+    'openrouter/': {
+        name: 'OpenRouter',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        apiKeyEnv: 'OPENROUTER_API_KEY',
+    },
+    'together/': {
+        name: 'Together AI',
+        baseUrl: 'https://api.together.xyz/v1',
+        apiKeyEnv: 'TOGETHER_API_KEY',
+    },
+    'fireworks/': {
+        name: 'Fireworks AI',
+        baseUrl: 'https://api.fireworks.ai/inference/v1',
+        apiKeyEnv: 'FIREWORKS_API_KEY',
+    },
+    'cerebras/': {
+        name: 'Cerebras',
+        baseUrl: 'https://api.cerebras.ai/v1',
+        apiKeyEnv: 'CEREBRAS_API_KEY',
+    },
+    'sambanova/': {
+        name: 'SambaNova',
+        baseUrl: 'https://api.sambanova.ai/v1',
+        apiKeyEnv: 'SAMBANOVA_API_KEY',
+    },
+    'nebius/': {
+        name: 'Nebius AI',
+        baseUrl: 'https://api.studio.nebius.ai/v1',
+        apiKeyEnv: 'NEBIUS_API_KEY',
+    },
+    'hyperbolic/': {
+        name: 'Hyperbolic',
+        baseUrl: 'https://api.hyperbolic.xyz/v1',
+        apiKeyEnv: 'HYPERBOLIC_API_KEY',
+    },
+    'novita/': {
+        name: 'Novita AI',
+        baseUrl: 'https://api.novita.ai/v3/openai',
+        apiKeyEnv: 'NOVITA_API_KEY',
+    },
+    'github/': {
+        name: 'GitHub Models',
+        baseUrl: 'https://models.inference.ai.azure.com',
+        apiKeyEnv: 'GITHUB_TOKEN',
+    },
+    'anyscale/': {
+        name: 'Anyscale',
+        baseUrl: 'https://api.endpoints.anyscale.com/v1',
+        apiKeyEnv: 'ANYSCALE_API_KEY',
+    },
+    'nvidia_nim/': {
+        name: 'NVIDIA NIM',
+        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',
+        apiKeyEnv: 'CODESTRAL_API_KEY',
+    },
+    'moonshot/': {
+        name: 'Moonshot',
+        baseUrl: 'https://api.moonshot.ai/v1',
+        apiKeyEnv: 'MOONSHOT_API_KEY',
+    },
+    'dashscope/': {
+        name: 'DashScope',
+        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+        apiKeyEnv: 'DASHSCOPE_API_KEY',
+    },
+    'meta_llama/': {
+        name: 'Meta Llama',
+        baseUrl: 'https://api.llama.com/compat/v1',
+        apiKeyEnv: 'LLAMA_API_KEY',
+    },
+    'featherless/': {
+        name: 'Featherless AI',
+        baseUrl: 'https://api.featherless.ai/v1',
+        apiKeyEnv: 'FEATHERLESS_API_KEY',
+    },
+    'nscale/': {
+        name: 'Nscale',
+        baseUrl: 'https://inference.api.nscale.com/v1',
+        apiKeyEnv: 'NSCALE_API_KEY',
+    },
+    'inception/': {
+        name: 'Inception Labs',
+        baseUrl: 'https://api.inceptionlabs.ai/v1',
+        apiKeyEnv: 'INCEPTION_API_KEY',
+    },
+    'morph/': {
+        name: 'Morph LLM',
+        baseUrl: 'https://api.morphllm.com/v1',
+        apiKeyEnv: 'MORPH_API_KEY',
+    },
+    'lambda/': {
+        name: 'Lambda AI',
+        baseUrl: 'https://api.lambda.ai/v1',
+        apiKeyEnv: 'LAMBDA_API_KEY',
+    },
+    'aiml/': {
+        name: 'AIML API',
+        baseUrl: 'https://api.aimlapi.com/v1',
+        apiKeyEnv: 'AIML_API_KEY',
+    },
+    'wandb/': {
+        name: 'Weights & Biases',
+        baseUrl: 'https://api.inference.wandb.ai/v1',
+        apiKeyEnv: 'WANDB_API_KEY',
+    },
+    'volcengine/': {
+        name: 'Volcengine',
+        baseUrl: 'https://ark.cn-beijing.volces.com/api/v3',
+        apiKeyEnv: 'VOLCENGINE_API_KEY',
+    },
+    'galadriel/': {
+        name: 'Galadriel',
+        baseUrl: 'https://api.galadriel.com/v1',
+        apiKeyEnv: 'GALADRIEL_API_KEY',
+    },
+    'empower/': {
+        name: 'Empower',
+        baseUrl: 'https://app.empower.dev/api/v1',
+        apiKeyEnv: 'EMPOWER_API_KEY',
+    },
+    'friendliai/': {
+        name: 'Friendli AI',
+        baseUrl: 'https://api.friendli.ai/serverless/v1',
+        apiKeyEnv: 'FRIENDLI_API_KEY',
+    },
+    'helicone/': {
+        name: 'Helicone',
+        baseUrl: 'https://ai-gateway.helicone.ai',
+        apiKeyEnv: 'HELICONE_API_KEY',
+    },
+    'vercel_ai/': {
+        name: 'Vercel AI Gateway',
+        baseUrl: 'https://ai-gateway.vercel.sh/v1',
+        apiKeyEnv: 'VERCEL_AI_GATEWAY_API_KEY',
+    },
+    'clarifai/': {
+        name: 'Clarifai',
+        baseUrl: 'https://api.clarifai.com/v2/ext/openai/v1',
+        apiKeyEnv: 'CLARIFAI_API_KEY',
+    },
+    'baseten/': {
+        name: 'Baseten',
+        baseUrl: 'https://inference.baseten.co/v1',
+        apiKeyEnv: 'BASETEN_API_KEY',
+    },
+    'publicai/': {
+        name: 'PublicAI',
+        baseUrl: 'https://api.publicai.co/v1',
+        apiKeyEnv: 'PUBLICAI_API_KEY',
+    },
+    'venice/': {
+        name: 'Venice AI',
+        baseUrl: 'https://api.venice.ai/api/v1',
+        apiKeyEnv: 'VENICE_API_KEY',
+    },
+};

package/dist/registry.d.ts

@@ -0,0 +1,15 @@
+import { EmbeddingHandler, Handler } from './types';
+/**
+ * Register a completion handler for a model prefix.
+ * Handlers self-register when their module is imported.
+ */
+export declare function registerCompletionHandler(prefix: string, handler: Handler): void;
+/**
+ * Register an embedding handler for a model prefix.
+ * Handlers self-register when their module is imported.
+ */
+export declare function registerEmbeddingHandler(prefix: string, handler: EmbeddingHandler): void;
+/** @internal Get the completion handler registry. */
+export declare function getCompletionHandlers(): Record<string, Handler>;
+/** @internal Get the embedding handler registry. */
+export declare function getEmbeddingHandlers(): Record<string, EmbeddingHandler>;

package/dist/registry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompletionHandler = registerCompletionHandler;
+exports.registerEmbeddingHandler = registerEmbeddingHandler;
+exports.getCompletionHandlers = getCompletionHandlers;
+exports.getEmbeddingHandlers = getEmbeddingHandlers;
+const completionHandlers = {};
+const embeddingHandlers = {};
+/**
+ * Register a completion handler for a model prefix.
+ * Handlers self-register when their module is imported.
+ */
+function registerCompletionHandler(prefix, handler) {
+    completionHandlers[prefix] = handler;
+}
+/**
+ * Register an embedding handler for a model prefix.
+ * Handlers self-register when their module is imported.
+ */
+function registerEmbeddingHandler(prefix, handler) {
+    embeddingHandlers[prefix] = handler;
+}
+/** @internal Get the completion handler registry. */
+function getCompletionHandlers() {
+    return completionHandlers;
+}
+/** @internal Get the embedding handler registry. */
+function getEmbeddingHandlers() {
+    return embeddingHandlers;
+}

package/dist/types.d.ts

@@ -0,0 +1,104 @@
+export type Role = 'system' | 'user' | 'assistant' | 'function' | 'tool';
+/** A single message in a chat conversation. */
+export interface Message {
+    role: Role;
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+}
+export type FinishReason = 'stop' | 'length' | 'function_call' | 'content_filter' | 'tool_calls';
+export interface ConsistentResponseChoice {
+    finish_reason: FinishReason | null;
+    index: number;
+    message: {
+        role: string | null | undefined;
+        content: string | null | undefined;
+        function_call?: {
+            arguments: string;
+            name: string;
+        };
+    };
+}
+export interface ConsistentResponseStreamingChoice extends Omit<ConsistentResponseChoice, 'message'> {
+    delta: Omit<ConsistentResponseChoice['message'], 'function_call'> & {
+        function_call?: {
+            arguments?: string;
+            name?: string;
+        };
+    };
+}
+export interface ConsistentResponseUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+/** Normalized completion response shared across all providers. */
+export interface ConsistentResponse {
+    choices: ConsistentResponseChoice[];
+    model?: string;
+    created?: number;
+    usage?: ConsistentResponseUsage;
+}
+export type ResultNotStreaming = ConsistentResponse;
+export interface StreamingChunk extends Omit<ConsistentResponse, 'choices'> {
+    choices: ConsistentResponseStreamingChoice[];
+}
+export type ResultStreaming = AsyncIterable<StreamingChunk>;
+export type Result = ResultNotStreaming | ResultStreaming;
+/** Parameters accepted by all completion handlers. */
+export interface HandlerParamsBase {
+    model: string;
+    messages: Message[];
+    stream?: boolean | null;
+    baseUrl?: string;
+    temperature?: number | null;
+    top_p?: number | null;
+    stop?: string | null | string[];
+    presence_penalty?: number | null;
+    n?: number | null;
+    max_tokens?: number | null;
+    apiKey?: string;
+    functions?: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    }[];
+    function_call?: 'none' | 'auto' | {
+        name: string;
+    };
+}
+export interface HandlerParamsStreaming extends HandlerParamsBase {
+    stream?: true;
+}
+export interface HandlerParamsNotStreaming extends HandlerParamsBase {
+    stream?: false;
+}
+export type HandlerParams = HandlerParamsStreaming | HandlerParamsNotStreaming;
+/** Parameters for embedding requests. */
+export interface EmbeddingParams {
+    input: string | string[];
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+}
+/** A single embedding vector and its index. */
+export interface EmbeddingObject {
+    embedding: number[];
+    index: number;
+}
+/** Normalized embedding response shared across all providers. */
+export interface EmbeddingResponse {
+    usage?: Pick<import('openai/resources').CompletionUsage, 'prompt_tokens' | 'total_tokens'>;
+    model: string;
+    data: EmbeddingObject[];
+}
+export type Handler = (params: HandlerParams) => Promise<Result>;
+export type EmbeddingHandler = (params: EmbeddingParams) => Promise<EmbeddingResponse>;

package/dist/types.js

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

package/dist/utils/combinePrompts.d.ts

@@ -0,0 +1,10 @@
+import { Message } from '../types';
+/**
+ * Combine an array of chat messages into a single prompt string with role labels.
+ *
+ * Used by providers with legacy string-based prompt APIs (Cohere, AI21, Replicate, Ollama).
+ *
+ * @param messages - The messages to combine
+ * @returns A single prompt string with format `"Human: ...\n\nAssistant: ..."`
+ */
+export declare function combinePrompts(messages: Message[]): string;

package/dist/utils/combinePrompts.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combinePrompts = combinePrompts;
+/**
+ * Combine an array of chat messages into a single prompt string with role labels.
+ *
+ * Used by providers with legacy string-based prompt APIs (Cohere, AI21, Replicate, Ollama).
+ *
+ * @param messages - The messages to combine
+ * @returns A single prompt string with format `"Human: ...\n\nAssistant: ..."`
+ */
+function combinePrompts(messages) {
+    return messages
+        .map((msg) => {
+        const roleLabel = msg.role === 'assistant' ? 'Assistant' : msg.role === 'system' ? 'System' : 'Human';
+        return `${roleLabel}: ${msg.content ?? ''}`;
+    })
+        .join('\n\n');
+}

package/dist/utils/encoders.d.ts

@@ -0,0 +1,2 @@
+import { getEncoding } from 'js-tiktoken';
+export declare function getEncoder(): ReturnType<typeof getEncoding>;

package/dist/utils/encoders.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEncoder = getEncoder;
+const js_tiktoken_1 = require("js-tiktoken");
+let _encoder = null;
+function getEncoder() {
+    _encoder ??= (0, js_tiktoken_1.getEncoding)('cl100k_base');
+    return _encoder;
+}

package/dist/utils/getUnixTimestamp.d.ts

@@ -0,0 +1 @@
+export declare function getUnixTimestamp(): number;

package/dist/utils/getUnixTimestamp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnixTimestamp = getUnixTimestamp;
+function getUnixTimestamp() {
+    return Math.floor(Date.now() / 1000);
+}

package/dist/utils/sse.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parse an SSE (Server-Sent Events) response stream into typed chunks.
+ *
+ * Reads `response.body` as a ReadableStream, splits on `\n`, filters for
+ * `data:` lines, parses each payload, and yields typed results.
+ * Stops iteration when a `doneToken` payload is encountered (default `[DONE]`).
+ *
+ * @param response - The HTTP response with an SSE body stream
+ * @param parseChunk - A function to parse each `data:` payload string into type T
+ * @param doneToken - The payload value that signals end-of-stream
+ */
+export declare function iterateSSEStream<T>(response: Response, parseChunk: (data: string) => T, doneToken?: string): AsyncIterable<T>;

package/dist/utils/sse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateSSEStream = iterateSSEStream;
+/**
+ * Parse an SSE (Server-Sent Events) response stream into typed chunks.
+ *
+ * Reads `response.body` as a ReadableStream, splits on `\n`, filters for
+ * `data:` lines, parses each payload, and yields typed results.
+ * Stops iteration when a `doneToken` payload is encountered (default `[DONE]`).
+ *
+ * @param response - The HTTP response with an SSE body stream
+ * @param parseChunk - A function to parse each `data:` payload string into type T
+ * @param doneToken - The payload value that signals end-of-stream
+ */
+async function* iterateSSEStream(response, parseChunk, doneToken = '[DONE]') {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('Response body is not readable');
+    let done = false;
+    let buffer = '';
+    while (!done) {
+        const next = await reader.read();
+        if (next.value) {
+            buffer += new TextDecoder().decode(next.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 === doneToken) {
+                    done = true;
+                    return;
+                }
+                yield parseChunk(payload);
+            }
+        }
+        done ||= next.done;
+    }
+}

package/dist/utils/toUsage.d.ts

@@ -0,0 +1,12 @@
+import { EmbeddingResponse } from '../types';
+import { ConsistentResponseUsage } from '../types';
+/**
+ * Count the number of tokens in a text string using cl100k_base encoding.
+ */
+export declare function countTokens(text: string): number;
+/**
+ * Build a usage object from prompt and completion text.
+ * Returns `undefined` when there is no completion text.
+ */
+export declare function toUsage(prompt: string, completion: string | undefined): ConsistentResponseUsage | undefined;
+export declare function toEmbeddingUsage(prompt: string): EmbeddingResponse['usage'];

package/dist/utils/toUsage.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTokens = countTokens;
+exports.toUsage = toUsage;
+exports.toEmbeddingUsage = toEmbeddingUsage;
+const encoders_1 = require("./encoders");
+/**
+ * Count the number of tokens in a text string using cl100k_base encoding.
+ */
+function countTokens(text) {
+    return (0, encoders_1.getEncoder)().encode(text).length;
+}
+/**
+ * Build a usage object from prompt and completion text.
+ * Returns `undefined` when there is no completion text.
+ */
+function toUsage(prompt, completion) {
+    if (!completion) {
+        return undefined;
+    }
+    const promptTokens = countTokens(prompt);
+    const completionTokens = countTokens(completion);
+    return {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+    };
+}
+function toEmbeddingUsage(prompt) {
+    const promptTokens = (0, encoders_1.getEncoder)().encode(prompt);
+    return {
+        prompt_tokens: promptTokens.length,
+        total_tokens: promptTokens.length,
+    };
+}