multi-llm/dist/providers/cerebras.js

A unified TypeScript/JavaScript package to use LLMs across ALL platforms with support for 17 major providers, streaming, MCP tools, and intelligent response parsing

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CerebrasProvider = void 0;
const axios_1 = __importDefault(require("axios"));
const provider_1 = require("../provider");
const llm_1 = require("../llm");
const parser_1 = require("../utils/parser");
class CerebrasProvider extends provider_1.Provider {
    constructor(apiKey, baseUrl) {
        super(apiKey, baseUrl);
        this.baseUrl = baseUrl || 'https://api.cerebras.ai/v1';
    }
    async getModels() {
        // Cerebras doesn't have a models endpoint, so we return known models
        return [
            {
                id: 'llama3.1-8b',
                name: 'Llama 3.1 8B',
                contextWindow: 128000,
                maxOutputTokens: 8192,
                pricing: { input: 0.00010, output: 0.00010, currency: 'USD' }
            },
            {
                id: 'llama3.1-70b',
                name: 'Llama 3.1 70B',
                contextWindow: 128000,
                maxOutputTokens: 8192,
                pricing: { input: 0.00060, output: 0.00060, currency: 'USD' }
            }
        ];
    }
    createLLM(modelId) {
        return new llm_1.LLM(this, modelId);
    }
    async chat(modelId, messages, options, streamCallback) {
        try {
            const payload = {
                model: modelId,
                messages: messages.map(msg => ({ role: msg.role, content: msg.content })),
                temperature: options.temperature,
                max_tokens: options.maxTokens,
                top_p: options.topP,
                stream: !!streamCallback
            };
            if (streamCallback) {
                return this.streamChat(payload, streamCallback);
            }
            else {
                const response = await axios_1.default.post(`${this.baseUrl}/chat/completions`, payload, {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`,
                        'Content-Type': 'application/json'
                    }
                });
                const content = response.data.choices[0].message.content;
                const parsed = parser_1.ResponseParser.parseResponse(content);
                return {
                    raw: response.data,
                    parsed,
                    usage: {
                        inputTokens: response.data.usage?.prompt_tokens || 0,
                        outputTokens: response.data.usage?.completion_tokens || 0,
                        totalTokens: response.data.usage?.total_tokens || 0
                    }
                };
            }
        }
        catch (error) {
            throw new Error(`Cerebras chat failed: ${error}`);
        }
    }
    async streamChat(payload, streamCallback) {
        return new Promise((resolve, reject) => {
            let fullContent = '';
            let rawResponse = null;
            const source = axios_1.default.post(`${this.baseUrl}/chat/completions`, payload, {
                headers: {
                    'Authorization': `Bearer ${this.apiKey}`,
                    'Content-Type': 'application/json'
                },
                responseType: 'stream'
            });
            source.then(response => {
                response.data.on('data', (chunk) => {
                    const lines = chunk.toString().split('\n');
                    for (const line of lines) {
                        if (line.startsWith('data: ')) {
                            const data = line.slice(6);
                            if (data === '[DONE]') {
                                const parsed = parser_1.ResponseParser.parseResponse(fullContent);
                                resolve({
                                    raw: rawResponse,
                                    parsed,
                                    usage: undefined
                                });
                                return;
                            }
                            try {
                                const parsed = JSON.parse(data);
                                rawResponse = parsed;
                                const content = parsed.choices[0]?.delta?.content || '';
                                if (content) {
                                    fullContent += content;
                                    streamCallback(content);
                                }
                            }
                            catch (e) {
                                // Ignore parsing errors for partial chunks
                            }
                        }
                    }
                });
                response.data.on('error', reject);
            }).catch(reject);
        });
    }
}
exports.CerebrasProvider = CerebrasProvider;
//# sourceMappingURL=cerebras.js.map