symmetry-cli 1.0.0

package/dist/provider.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymmetryProvider = void 0;
+const node_stream_1 = require("node:stream");
+const promises_1 = require("stream/promises");
+const chalk_1 = __importDefault(require("chalk"));
+const hyperswarm_1 = __importDefault(require("hyperswarm"));
+const hypercore_crypto_1 = __importDefault(require("hypercore-crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const logger_1 = require("./logger");
+const constants_1 = require("./constants");
+class SymmetryProvider {
+    constructor(configPath) {
+        this._challenge = null;
+        this._conversationIndex = 0;
+        this._discoveryKey = null;
+        this._isPublic = false;
+        this._providerConnections = 0;
+        this._providerSwarm = null;
+        this._serverPeer = null;
+        logger_1.logger.info(`🔗 Initializing client using config file: ${configPath}`);
+        this._config = new config_1.ConfigManager(configPath);
+        this._isPublic = this._config.get("public");
+    }
+    async init() {
+        this._providerSwarm = new hyperswarm_1.default({
+            maxConnections: this._config.get("maxConnections"),
+        });
+        const keyPair = hypercore_crypto_1.default.keyPair(Buffer.alloc(32).fill(this._config.get("name")));
+        this._discoveryKey = hypercore_crypto_1.default.discoveryKey(keyPair.publicKey);
+        const discovery = this._providerSwarm.join(this._discoveryKey, {
+            server: true,
+            client: true,
+        });
+        await discovery.flushed();
+        this._providerSwarm.on("error", (err) => {
+            logger_1.logger.error(chalk_1.default.red("🚨 Swarm Error:"), err);
+        });
+        this._providerSwarm.on("connection", (peer) => {
+            logger_1.logger.info(`⚡️ New connection from peer: ${peer.rawStream.remoteHost}`);
+            this.listeners(peer);
+        });
+        logger_1.logger.info(`📁 Symmetry client initialized.`);
+        logger_1.logger.info(`🔑 Discovery key: ${this._discoveryKey.toString("hex")}`);
+        if (this._isPublic) {
+            logger_1.logger.info(chalk_1.default.white(`🔑 Server key: ${this._config.get("serverKey")}`));
+            logger_1.logger.info(chalk_1.default.white("🔗 Joining server, please wait."));
+            await this.joinServer();
+        }
+        process.on("SIGINT", async () => {
+            var _a;
+            await ((_a = this._providerSwarm) === null || _a === void 0 ? void 0 : _a.destroy());
+            process.exit(0);
+        });
+        process.on("uncaughtException", (err) => {
+            if (err.message === "connection reset by peer") {
+                this._providerConnections = Math.max(0, this._providerConnections - 1);
+            }
+        });
+    }
+    async joinServer() {
+        const serverSwarm = new hyperswarm_1.default();
+        const serverKey = Buffer.from(this._config.get("serverKey"));
+        serverSwarm.join(hypercore_crypto_1.default.discoveryKey(serverKey), {
+            client: true,
+            server: false,
+        });
+        serverSwarm.flush();
+        serverSwarm.on("connection", (peer) => {
+            var _a;
+            this._serverPeer = peer;
+            logger_1.logger.info(chalk_1.default.green("🔗 Connected to server."));
+            this._challenge = hypercore_crypto_1.default.randomBytes(32);
+            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.challenge, {
+                challenge: this._challenge,
+            }));
+            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.join, {
+                ...this._config.getAll(),
+                discoveryKey: (_a = this._discoveryKey) === null || _a === void 0 ? void 0 : _a.toString("hex"),
+            }));
+            this._serverPeer.on("data", async (buffer) => {
+                var _a;
+                if (!buffer)
+                    return;
+                const data = (0, utils_1.safeParseJson)(buffer.toString());
+                if (data && data.key) {
+                    switch (data.key) {
+                        case constants_1.serverMessageKeys.challenge:
+                            this.handleServerVerification(data.data);
+                            break;
+                        case constants_1.serverMessageKeys.ping:
+                            (_a = this._serverPeer) === null || _a === void 0 ? void 0 : _a.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.pong));
+                            break;
+                    }
+                }
+            });
+        });
+    }
+    getServerPublicKey(serverKeyHex) {
+        const publicKey = Buffer.from(serverKeyHex, "hex");
+        if (publicKey.length !== 32) {
+            throw new Error(`Expected a 32-byte public key, but got ${publicKey.length} bytes`);
+        }
+        return publicKey;
+    }
+    handleServerVerification(data) {
+        if (!this._challenge) {
+            console.log("No challenge set. Cannot verify.");
+            return;
+        }
+        const serverKeyHex = this._config.get("serverKey");
+        try {
+            const publicKey = this.getServerPublicKey(serverKeyHex);
+            const signatureBuffer = Buffer.from(data.signature.data, "base64");
+            const verified = hypercore_crypto_1.default.verify(this._challenge, signatureBuffer, publicKey);
+            if (verified) {
+                logger_1.logger.info(chalk_1.default.greenBright(`✅ Verification successful.`));
+            }
+            else {
+                logger_1.logger.error(`❌ Verification failed!`);
+            }
+        }
+        catch (error) {
+            console.error("Error during verification:", error);
+        }
+    }
+    listeners(peer) {
+        peer.on("data", async (buffer) => {
+            if (!buffer)
+                return;
+            const data = (0, utils_1.safeParseJson)(buffer.toString());
+            if (data && data.key) {
+                switch (data.key) {
+                    case constants_1.serverMessageKeys.newConversation:
+                        this._conversationIndex = this._conversationIndex + 1;
+                        break;
+                    case constants_1.serverMessageKeys.inference:
+                        logger_1.logger.info(`📦 Inference message received from ${peer.rawStream.remoteHost}`);
+                        await this.handleInferenceRequest(data, peer);
+                        break;
+                }
+            }
+        });
+    }
+    async handleInferenceRequest(data, peer) {
+        const emitterKey = data.data.key;
+        const req = this.buildStreamRequest(data === null || data === void 0 ? void 0 : data.data.messages);
+        if (!req)
+            return;
+        const { requestOptions, requestBody } = req;
+        const { protocol, hostname, port, path, method, headers } = requestOptions;
+        const url = `${protocol}://${hostname}:${port}${path}`;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                throw new Error(`Server responded with status code: ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error("Failed to get a ReadableStream from the response");
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const responseStream = node_stream_1.Readable.fromWeb(response.body);
+            const peerStream = new node_stream_1.PassThrough();
+            responseStream.pipe(peerStream);
+            let completion = "";
+            const provider = this._config.get("apiProvider");
+            peer.write(JSON.stringify({
+                symmetryEmitterKey: emitterKey,
+            }));
+            const peerPipeline = (0, promises_1.pipeline)(peerStream, async function (source) {
+                for await (const chunk of source) {
+                    if (peer.writable) {
+                        completion += (0, utils_1.getChatDataFromProvider)(provider, (0, utils_1.safeParseStreamResponse)(chunk.toString()));
+                        const write = peer.write(chunk);
+                        if (!write) {
+                            await new Promise((resolve) => peer.once("drain", resolve));
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+            });
+            await Promise.resolve(peerPipeline);
+            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.inferenceEnded, data === null || data === void 0 ? void 0 : data.data.key));
+            if (this._config.get("dataCollectionEnabled") &&
+                data.data.key === constants_1.serverMessageKeys.inference) {
+                this.saveCompletion(completion, peer, data.data.messages);
+            }
+        }
+        catch (error) {
+            let errorMessage = "An error occurred during inference";
+            if (error instanceof Error)
+                errorMessage = error.message;
+            logger_1.logger.error(`🚨 ${errorMessage}`);
+        }
+    }
+    async saveCompletion(completion, peer, messages) {
+        node_fs_1.default.writeFile(`${this._config.get("path")}/${peer.publicKey.toString("hex")}-${this._conversationIndex}.json`, JSON.stringify([
+            ...messages,
+            {
+                role: "assistant",
+                content: completion,
+            },
+        ]), () => {
+            logger_1.logger.info(`📝 Completion saved to file`);
+        });
+    }
+    buildStreamRequest(messages) {
+        const requestOptions = {
+            hostname: this._config.get("apiHostname"),
+            port: Number(this._config.get("apiPort")),
+            path: this._config.get("apiPath"),
+            protocol: this._config.get("apiProtocol"),
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this._config.get("apiKey")}`,
+            },
+        };
+        const requestBody = {
+            model: this._config.get("modelName"),
+            messages: messages || undefined,
+            stream: true,
+        };
+        return { requestOptions, requestBody };
+    }
+}
+exports.SymmetryProvider = SymmetryProvider;
+exports.default = SymmetryProvider;

package/dist/server.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymmetryServer = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const corestore_1 = __importDefault(require("corestore"));
+const hyperdrive_1 = __importDefault(require("hyperdrive"));
+const hyperswarm_1 = __importDefault(require("hyperswarm"));
+const path_1 = __importDefault(require("path"));
+const config_manager_1 = require("./config-manager");
+const utils_1 = require("./utils");
+const logger_1 = require("./logger");
+const peer_repository_1 = require("./peer-repository");
+const constants_1 = require("./constants");
+const session_manager_1 = require("./session-manager");
+const session_repository_1 = require("./session-repository");
+const websocket_server_1 = require("./websocket-server");
+class SymmetryServer {
+    constructor(configPath) {
+        logger_1.logger.info(`🔗 Initializing server using config file: ${configPath}`);
+        this._config = (0, config_manager_1.createConfigManager)(configPath, false);
+        if (!this._config.isServerConfig()) {
+            throw new Error("Invalid configuration for server");
+        }
+        this._peerRepository = new peer_repository_1.PeerRepository();
+        this._sessionRepository = new session_repository_1.SessionRepository();
+        this._sessionManager = new session_manager_1.SessionManager(this._sessionRepository, 5);
+    }
+    async init() {
+        var _a, _b;
+        const corePath = path_1.default.join(this._config.get("path"), "symmetry-core");
+        const store = new corestore_1.default(corePath);
+        const core = new hyperdrive_1.default(store);
+        const swarm = new hyperswarm_1.default();
+        await core.ready();
+        const discovery = swarm.join(core.discoveryKey, { server: true });
+        await discovery.flushed();
+        swarm.on("connection", (peer) => {
+            logger_1.logger.info(`🔗 New Connection: ${peer.rawStream.remoteHost}`);
+            store.replicate(peer);
+            this.listeners(peer);
+        });
+        this._wsServer = new websocket_server_1.WsServer(this._config.get("webSocketPort"), this._peerRepository, swarm);
+        logger_1.logger.info(`🔑 Discovery key: ${(_a = core.discoveryKey) === null || _a === void 0 ? void 0 : _a.toString("hex")}`);
+        logger_1.logger.info(`🔑 Drive key: ${(_b = core.key) === null || _b === void 0 ? void 0 : _b.toString("hex")}`);
+        logger_1.logger.info(chalk_1.default.green(`\u2713 Websocket server started: ws://localhost:${this._config.get("webSocketPort")}`));
+        logger_1.logger.info(chalk_1.default.green(`\u2713 Symmetry server started, waiting for connections...`));
+    }
+    listeners(peer) {
+        peer.on("error", (err) => err);
+        peer.on("close", () => {
+            const peerKey = peer.publicKey.toString("hex");
+            this._peerRepository.updateLastSeen(peerKey);
+            logger_1.logger.info(`🔗 Connection Closed: Peer ${peerKey.slice(0, 6)}...${peerKey.slice(-6)}`);
+        });
+        peer.on("data", (message) => {
+            const data = (0, utils_1.safeParseJson)(message.toString());
+            if (!data)
+                return;
+            if (data.key) {
+                switch (data === null || data === void 0 ? void 0 : data.key) {
+                    case constants_1.serverMessageKeys.join:
+                        this.join(peer, data.data);
+                        break;
+                    case constants_1.serverMessageKeys.requestProvider:
+                        this.handlePeerSession(peer, data.data);
+                        break;
+                    case constants_1.serverMessageKeys.verifySession:
+                        this.handlePeerSessionValidation(peer, data.data);
+                        break;
+                }
+            }
+        });
+    }
+    async join(peer, message) {
+        const peerKey = peer.publicKey.toString("hex");
+        try {
+            await this._peerRepository.upsert({
+                ...message,
+                key: peerKey,
+            });
+            logger_1.logger.info(`👋 Peer provider joined ${peer.rawStream.remoteHost}`);
+            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.joinAck, {
+                status: "success",
+                key: peerKey,
+            }));
+        }
+        catch (error) {
+            let errorMessage = "";
+            if (error instanceof Error)
+                errorMessage = error.message;
+            logger_1.logger.error(`🚨 ${errorMessage}`);
+        }
+    }
+    async handlePeerSession(peer, randomPeerRequest) {
+        try {
+            const providerPeer = await this._peerRepository.getPeer(randomPeerRequest);
+            const sessionToken = await this._sessionManager.createSession(providerPeer.discovery_key);
+            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.providerDetails, {
+                providerId: providerPeer.key,
+                sessionToken,
+            }));
+        }
+        catch (error) {
+            let errorMessage = "";
+            if (error instanceof Error)
+                errorMessage = error.message;
+            logger_1.logger.error(`🚨 ${errorMessage}`);
+        }
+    }
+    async handlePeerSessionValidation(peer, message) {
+        if (!message.sessionToken)
+            return;
+        try {
+            const providerDiscoveryKey = await this._sessionManager.verifySession(message.sessionToken);
+            if (!providerDiscoveryKey)
+                return;
+            const providerPeer = await this._peerRepository.getByDiscoveryKey(providerDiscoveryKey);
+            if (!providerPeer)
+                return;
+            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.sessionValid, {
+                discoveryKey: providerPeer.discovery_key,
+            }));
+            await this._sessionManager.extendSession(message.sessionToken);
+        }
+        catch (error) {
+            logger_1.logger.error(`Session verification error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.sessionValid, {
+                valid: false,
+                error: "Error verifying session",
+            }));
+        }
+    }
+    async cleanupSessions() {
+        await this._sessionManager.cleanupExpiredSessions();
+    }
+}
+exports.SymmetryServer = SymmetryServer;
+module.exports = {
+    SymmetryServer,
+};

package/dist/session-manager.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const logger_1 = require("./logger");
+const crypto_1 = __importDefault(require("crypto"));
+class SessionManager {
+    constructor(sessionRepository, sessionDurationMinutes = 60) {
+        this.sessionRepository = sessionRepository;
+        this.sessionDuration = sessionDurationMinutes * 60 * 1000;
+    }
+    async createSession(providerId) {
+        const sessionId = crypto_1.default.randomUUID();
+        const now = new Date();
+        const session = {
+            id: sessionId,
+            providerId,
+            createdAt: now,
+            expiresAt: new Date(now.getTime() + this.sessionDuration),
+        };
+        await this.sessionRepository.create(session);
+        logger_1.logger.info(`🖇️ Session created for provider: ${providerId}`);
+        return sessionId;
+    }
+    async verifySession(sessionId) {
+        const session = await this.sessionRepository.get(sessionId);
+        if (!session) {
+            logger_1.logger.warning(`❌ Session not found: ${sessionId}`);
+            return null;
+        }
+        if (new Date() > session.expiresAt) {
+            logger_1.logger.warning(`🕛 Session expired: ${sessionId}`);
+            await this.sessionRepository.delete(sessionId);
+            return null;
+        }
+        return session.providerId;
+    }
+    async extendSession(sessionId) {
+        const session = await this.sessionRepository.get(sessionId);
+        if (!session) {
+            logger_1.logger.warning(`🚨 Cannot extend non-existent session: ${sessionId}`);
+            return false;
+        }
+        session.expiresAt = new Date(Date.now() + this.sessionDuration);
+        await this.sessionRepository.update(session);
+        logger_1.logger.info(`🎟️ Session extended: ${sessionId}`);
+        return true;
+    }
+    async deleteSession(sessionId) {
+        const result = await this.sessionRepository.delete(sessionId);
+        if (result) {
+            // cross bin emoji  
+            logger_1.logger.info(`🗑 Session deleted: ${sessionId}`);
+        }
+        else {
+            logger_1.logger.warning(`🚨 Failed to delete session: ${sessionId}`);
+        }
+        return result;
+    }
+    async cleanupExpiredSessions() {
+        const deletedCount = await this.sessionRepository.deleteExpired();
+        logger_1.logger.info(`🕛 Cleaned up ${deletedCount} expired sessions`);
+        return deletedCount;
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/session-repository.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRepository = void 0;
+const database_1 = require("./database");
+class SessionRepository {
+    constructor() {
+        this.create = (session) => {
+            return new Promise((resolve, reject) => {
+                const sql = `INSERT INTO sessions (id, provider_id, created_at, expires_at) VALUES (?, ?, ?, ?)`;
+                this.db.run(sql, [
+                    session.id,
+                    session.providerId,
+                    session.createdAt.toISOString(),
+                    session.expiresAt.toISOString(),
+                ], function (err) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+        this.get = (id) => {
+            return new Promise((resolve, reject) => {
+                const sql = `
+        SELECT s.id, s.provider_id as providerId, s.created_at as createdAt, s.expires_at as expiresAt
+        FROM sessions s
+        WHERE s.id = ?
+      `;
+                this.db.get(sql, [id], (err, row) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else if (row) {
+                        resolve({
+                            id: row.id,
+                            providerId: row.providerId,
+                            createdAt: new Date(row.createdAt),
+                            expiresAt: new Date(row.expiresAt),
+                        });
+                    }
+                    else {
+                        resolve(null);
+                    }
+                });
+            });
+        };
+        this.update = (session) => {
+            return new Promise((resolve, reject) => {
+                const sql = `UPDATE sessions SET provider_id = ?, created_at = ?, expires_at = ? WHERE id = ?`;
+                this.db.run(sql, [
+                    session.providerId,
+                    session.createdAt.toISOString(),
+                    session.expiresAt.toISOString(),
+                    session.id,
+                ], function (err) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else if (this.changes === 0) {
+                        reject(new Error("No session found with the provided id"));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        };
+        this.delete = (id) => {
+            return new Promise((resolve, reject) => {
+                const sql = `DELETE FROM sessions WHERE id = ?`;
+                this.db.run(sql, [id], function (err) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(this.changes > 0);
+                    }
+                });
+            });
+        };
+        this.getAllActiveSessions = () => {
+            return new Promise((resolve, reject) => {
+                const sql = `
+        SELECT s.id, s.provider_id as providerId, s.created_at as createdAt, s.expires_at as expiresAt,
+               p.key as peer_key, p.discovery_key, p.model_name
+        FROM sessions s
+        LEFT JOIN peers p ON s.provider_id = p.id
+        WHERE s.expires_at > datetime('now')
+      `;
+                this.db.all(sql, [], (err, rows) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(rows.map((row) => ({
+                            id: row.id,
+                            providerId: row.providerId,
+                            createdAt: new Date(row.createdAt),
+                            expiresAt: new Date(row.expiresAt),
+                            peer_key: row.peer_key,
+                            discovery_key: row.discovery_key,
+                            model_name: row.model_name,
+                        })));
+                    }
+                });
+            });
+        };
+        this.deleteExpired = () => {
+            return new Promise((resolve, reject) => {
+                const sql = `DELETE FROM sessions WHERE expires_at <= datetime('now')`;
+                this.db.run(sql, function (err) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(this.changes);
+                    }
+                });
+            });
+        };
+        this.db = database_1.database;
+    }
+}
+exports.SessionRepository = SessionRepository;

package/dist/symmetry.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const provider_1 = require("./provider");
+const program = new commander_1.Command();
+program
+    .version("1.0.0")
+    .description("symmetry cli")
+    .option("-c, --config <path>", "Path to config file", path_1.default.join(os_1.default.homedir(), ".config", "symmetry", "provider.yaml"))
+    .action(async () => {
+    const client = new provider_1.SymmetryProvider(program.opts().config);
+    await client.init();
+});
+program.parse(process.argv);

package/dist/types.js

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

package/dist/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChatDataFromProvider = void 0;
+exports.safeParseJson = safeParseJson;
+exports.createMessage = createMessage;
+exports.isStreamWithDataPrefix = isStreamWithDataPrefix;
+exports.safeParseStreamResponse = safeParseStreamResponse;
+const constants_1 = require("./constants");
+function safeParseJson(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function createMessage(key, data) {
+    return JSON.stringify({ key, data });
+}
+function isStreamWithDataPrefix(stringBuffer) {
+    return stringBuffer.startsWith('data:');
+}
+function safeParseStreamResponse(stringBuffer) {
+    try {
+        if (isStreamWithDataPrefix(stringBuffer)) {
+            return JSON.parse(stringBuffer.split('data:')[1]);
+        }
+        return JSON.parse(stringBuffer);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+const getChatDataFromProvider = (provider, data) => {
+    var _a, _b;
+    switch (provider) {
+        case constants_1.apiProviders.Ollama:
+        case constants_1.apiProviders.OpenWebUI:
+            return ((_a = data === null || data === void 0 ? void 0 : data.choices[0].delta) === null || _a === void 0 ? void 0 : _a.content)
+                ? data === null || data === void 0 ? void 0 : data.choices[0].delta.content
+                : '';
+        case constants_1.apiProviders.LlamaCpp:
+            return data === null || data === void 0 ? void 0 : data.content;
+        case constants_1.apiProviders.LiteLLM:
+        default:
+            if ((data === null || data === void 0 ? void 0 : data.choices[0].delta.content) === 'undefined')
+                return '';
+            return ((_b = data === null || data === void 0 ? void 0 : data.choices[0].delta) === null || _b === void 0 ? void 0 : _b.content)
+                ? data === null || data === void 0 ? void 0 : data.choices[0].delta.content
+                : '';
+    }
+};
+exports.getChatDataFromProvider = getChatDataFromProvider;