@graf-research/llm-runner 0.0.1

package/dist/base/generic-llm.d.ts

@@ -0,0 +1,26 @@
+import { Readable } from 'node:stream';
+export declare namespace GenericLLM {
+    type OnMessage = (chunk: string, is_complete: boolean) => void;
+    interface StreamResponse {
+        cancel(): void;
+        stream(onMessage: OnMessage): Promise<void>;
+    }
+    abstract class ChatSessionManager<SessionModel, ChatModel> {
+        abstract newSession(): Promise<SessionModel>;
+        abstract getChatSession(id_session: string): Promise<SessionModel>;
+        abstract saveMessage(messages: string[], role: string, id_session: string): Promise<void>;
+        abstract retrieveHistory(id_session: string): Promise<ChatModel[]>;
+    }
+    abstract class GenericLLM {
+        abstract stream(messages: string[], id_session: string): Promise<StreamResponse>;
+        abstract streamNoContext(messages: string[]): Promise<GenericLLM.StreamResponse>;
+        abstract ask(messages: string[], id_session: string): Promise<string>;
+        abstract askNoContext(messages: string[]): Promise<string>;
+    }
+    abstract class BaseLLM<SessionModel, ChatModel> extends GenericLLM {
+        chat_session_manager: ChatSessionManager<SessionModel, ChatModel>;
+        constructor(chat_session_manager: ChatSessionManager<SessionModel, ChatModel>);
+        protected abstract streamChat(messages: string[], id_session: string | null, stream: Readable, ac: AbortController): Promise<void>;
+        protected abstract chat(messages: string[], id_session: string | null): Promise<string>;
+    }
+}

package/dist/base/generic-llm.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericLLM = void 0;
+var GenericLLM;
+(function (GenericLLM_1) {
+    class ChatSessionManager {
+    }
+    GenericLLM_1.ChatSessionManager = ChatSessionManager;
+    class GenericLLM {
+    }
+    GenericLLM_1.GenericLLM = GenericLLM;
+    class BaseLLM extends GenericLLM {
+        constructor(chat_session_manager) {
+            super();
+            this.chat_session_manager = chat_session_manager;
+        }
+    }
+    GenericLLM_1.BaseLLM = BaseLLM;
+})(GenericLLM || (exports.GenericLLM = GenericLLM = {}));

package/dist/base/llm-runner.d.ts

@@ -0,0 +1,31 @@
+import { GenericLLM } from "./generic-llm";
+export declare namespace LLMRunner {
+    interface Message {
+        content: string;
+        role: string;
+    }
+    interface ChatSession {
+        id: string;
+        list_message: Message[];
+    }
+    /**
+     * Chat Session Manager Implementation
+     */
+    class SessionManager implements GenericLLM.ChatSessionManager<ChatSession, Message> {
+        list_session: ChatSession[];
+        newSession(): Promise<ChatSession>;
+        getSession(id_session: string): Promise<ChatSession | undefined>;
+        getChatSession(id_session: string): Promise<ChatSession>;
+        saveMessage(messages: string[], role: string, id_session: string): Promise<void>;
+        retrieveHistory(id_session: string): Promise<Message[]>;
+    }
+    /**
+     * Abstract Base LLM Class
+     */
+    abstract class BaseLLM extends GenericLLM.BaseLLM<ChatSession, Message> {
+        stream(messages: string[], id_session: string): Promise<GenericLLM.StreamResponse>;
+        streamNoContext(messages: string[]): Promise<GenericLLM.StreamResponse>;
+        ask(messages: string[], id_session: string): Promise<string>;
+        askNoContext(messages: string[]): Promise<string>;
+    }
+}

package/dist/base/llm-runner.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMRunner = void 0;
+const generic_llm_1 = require("./generic-llm");
+const uuid_1 = require("uuid");
+const node_stream_1 = require("node:stream");
+var LLMRunner;
+(function (LLMRunner) {
+    /**
+     * Chat Session Manager Implementation
+     */
+    class SessionManager {
+        constructor() {
+            this.list_session = [];
+        }
+        newSession() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const session = {
+                    id: (0, uuid_1.v4)(),
+                    list_message: []
+                };
+                this.list_session.push(session);
+                return session;
+            });
+        }
+        getSession(id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.list_session.find(s => s.id == id_session);
+            });
+        }
+        getChatSession(id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cs = this.list_session.find(s => s.id == id_session);
+                if (!cs) {
+                    throw new Error('Session not found.');
+                }
+                return cs;
+            });
+        }
+        saveMessage(messages, role, id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cs = yield this.getChatSession(id_session);
+                cs.list_message.push(...messages.map(content => ({
+                    role,
+                    content
+                })));
+            });
+        }
+        retrieveHistory(id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const cs = yield this.getChatSession(id_session);
+                return cs.list_message;
+            });
+        }
+    }
+    LLMRunner.SessionManager = SessionManager;
+    /**
+     * Abstract Base LLM Class
+     */
+    class BaseLLM extends generic_llm_1.GenericLLM.BaseLLM {
+        stream(messages, id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const ac = new AbortController();
+                const stream = new node_stream_1.Readable({ objectMode: true, read() { } });
+                this.streamChat(messages, id_session, stream, ac);
+                return {
+                    stream: (onMessage) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, e_1, _b, _c;
+                        let complete_message = ``;
+                        try {
+                            for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                                _c = stream_1_1.value;
+                                _d = false;
+                                const chunk = _c;
+                                complete_message = `${complete_message}${chunk}`;
+                                onMessage(chunk, false);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        yield this.chat_session_manager.saveMessage(messages, 'user', id_session);
+                        yield this.chat_session_manager.saveMessage([complete_message], 'assistant', id_session);
+                        onMessage('', true);
+                    }),
+                    cancel() {
+                        ac.abort();
+                    }
+                };
+            });
+        }
+        streamNoContext(messages) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const ac = new AbortController();
+                const stream = new node_stream_1.Readable({ objectMode: true, read() { } });
+                this.streamChat(messages, null, stream, ac);
+                return {
+                    stream: (onMessage) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, e_2, _b, _c;
+                        let complete_message = ``;
+                        try {
+                            for (var _d = true, stream_2 = __asyncValues(stream), stream_2_1; stream_2_1 = yield stream_2.next(), _a = stream_2_1.done, !_a; _d = true) {
+                                _c = stream_2_1.value;
+                                _d = false;
+                                const chunk = _c;
+                                complete_message = `${complete_message}${chunk}`;
+                                onMessage(chunk, false);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = stream_2.return)) yield _b.call(stream_2);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        onMessage('', true);
+                    }),
+                    cancel() {
+                        ac.abort();
+                    }
+                };
+            });
+        }
+        ask(messages, id_session) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const res = yield this.chat(messages, id_session);
+                yield this.chat_session_manager.saveMessage(messages, 'user', id_session);
+                yield this.chat_session_manager.saveMessage([res], 'assistant', id_session);
+                return res;
+            });
+        }
+        askNoContext(messages) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.chat(messages, null);
+            });
+        }
+    }
+    LLMRunner.BaseLLM = BaseLLM;
+})(LLMRunner || (exports.LLMRunner = LLMRunner = {}));

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { LLMRunner } from "./base/llm-runner";
+import { ChatGPTLLM } from "./platform/chatgpt";
+import { OllamaLLM } from "./platform/ollama";
+import { NativeStep } from "./multistep";
+import { GenericLLM } from "./base/generic-llm";
+export { GenericLLM, LLMRunner, ChatGPTLLM, OllamaLLM, NativeStep, };

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeStep = exports.OllamaLLM = exports.ChatGPTLLM = exports.LLMRunner = exports.GenericLLM = void 0;
+const llm_runner_1 = require("./base/llm-runner");
+Object.defineProperty(exports, "LLMRunner", { enumerable: true, get: function () { return llm_runner_1.LLMRunner; } });
+const chatgpt_1 = require("./platform/chatgpt");
+Object.defineProperty(exports, "ChatGPTLLM", { enumerable: true, get: function () { return chatgpt_1.ChatGPTLLM; } });
+const ollama_1 = require("./platform/ollama");
+Object.defineProperty(exports, "OllamaLLM", { enumerable: true, get: function () { return ollama_1.OllamaLLM; } });
+const multistep_1 = require("./multistep");
+Object.defineProperty(exports, "NativeStep", { enumerable: true, get: function () { return multistep_1.NativeStep; } });
+const generic_llm_1 = require("./base/generic-llm");
+Object.defineProperty(exports, "GenericLLM", { enumerable: true, get: function () { return generic_llm_1.GenericLLM; } });

package/dist/multistep.d.ts

@@ -0,0 +1,17 @@
+import { GenericLLM } from "./base/generic-llm";
+import { LLMRunner } from "./base/llm-runner";
+export declare namespace NativeStep {
+    interface StreamResponseWithFinalAnswer<T> {
+        cancel(): void;
+        stream(onMessage: GenericLLM.OnMessage): Promise<T>;
+    }
+    type Resolver<T, U = any> = (response: string, data?: U) => Promise<T>;
+    function askNormal(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<string>;
+    function streamNormal(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<StreamResponseWithFinalAnswer<string>>;
+    function askYesNo(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<boolean>;
+    function streamYesNo(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<StreamResponseWithFinalAnswer<boolean>>;
+    function askChoose(llm: LLMRunner.BaseLLM, q: string, options: string[], session_id?: string): Promise<string>;
+    function streamAskChoose(llm: LLMRunner.BaseLLM, q: string, options: string[], session_id?: string): Promise<StreamResponseWithFinalAnswer<string>>;
+    function askPlan(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<string[]>;
+    function streamPlan(llm: LLMRunner.BaseLLM, q: string, session_id?: string): Promise<StreamResponseWithFinalAnswer<string[]>>;
+}

package/dist/multistep.js

@@ -0,0 +1,149 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeStep = void 0;
+var NativeStep;
+(function (NativeStep) {
+    function ask(llm, prompt, resolver, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = session_id ? yield llm.ask([prompt], session_id) : yield llm.askNoContext([prompt]);
+            return yield resolver(res);
+        });
+    }
+    function stream(llm, prompt, resolver, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = session_id ? yield llm.stream([prompt], session_id) : yield llm.streamNoContext([prompt]);
+            return {
+                cancel() {
+                    res.cancel();
+                },
+                stream(onMessage) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        return new Promise((resolve, reject) => {
+                            let complete_message = '';
+                            res.stream((chunk, is_complete) => __awaiter(this, void 0, void 0, function* () {
+                                onMessage(chunk, is_complete);
+                                if (is_complete) {
+                                    try {
+                                        resolve(yield resolver(complete_message));
+                                    }
+                                    catch (err) {
+                                        reject(err);
+                                    }
+                                    return;
+                                }
+                                else {
+                                    complete_message = `${complete_message}${chunk}`;
+                                }
+                            }));
+                        });
+                    });
+                },
+            };
+        });
+    }
+    // ================================= //
+    // Normal
+    // ================================= //
+    const normal_resolver = (response) => __awaiter(this, void 0, void 0, function* () { return response; });
+    function askNormal(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ask(llm, q, normal_resolver, session_id);
+        });
+    }
+    NativeStep.askNormal = askNormal;
+    function streamNormal(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield stream(llm, q, normal_resolver, session_id);
+        });
+    }
+    NativeStep.streamNormal = streamNormal;
+    // ================================= //
+    // Yes/No
+    // ================================= //
+    const yes_no_resolver = (response) => __awaiter(this, void 0, void 0, function* () { return response.includes('1'); });
+    function askYesNo(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prompt = `Respond 1 if "Yes" or 0 for "No" to this question: ${q}`;
+            return yield ask(llm, prompt, yes_no_resolver, session_id);
+        });
+    }
+    NativeStep.askYesNo = askYesNo;
+    function streamYesNo(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prompt = `Respond 1 if "Yes" or 0 for "No" to this question: ${q}`;
+            return yield stream(llm, prompt, yes_no_resolver, session_id);
+        });
+    }
+    NativeStep.streamYesNo = streamYesNo;
+    // ================================= //
+    // Choose
+    // ================================= //
+    function generateChooseResolver(options) {
+        return (response) => __awaiter(this, void 0, void 0, function* () {
+            const selected = options.sort((a, b) => b.length - a.length).find(a => response.includes(a));
+            if (!selected) {
+                throw new Error(`Unexpected LLM answer: ${response}`);
+            }
+            return selected;
+        });
+    }
+    function askChoose(llm, q, options, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prompt = `Respond this question: ${q}, with one of these options: ${options.map(a => `"${a}"`).join(',')}. Answer with only one option, even when multiple answer is available`;
+            return yield ask(llm, prompt, generateChooseResolver(options), session_id);
+        });
+    }
+    NativeStep.askChoose = askChoose;
+    function streamAskChoose(llm, q, options, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prompt = `Respond this question: ${q}, with one of these options: ${options.map(a => `"${a}"`).join(',')}. Answer with only one option, even when multiple answer is available`;
+            return yield stream(llm, prompt, generateChooseResolver(options), session_id);
+        });
+    }
+    NativeStep.streamAskChoose = streamAskChoose;
+    // ================================= //
+    // Plan
+    // ================================= //
+    const plan_resolver = (response) => __awaiter(this, void 0, void 0, function* () { return response.split('\n').map(a => a.trim()).filter(Boolean); });
+    function askPlan(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = yield llm.chat_session_manager.newSession();
+            const yn = yield askYesNo(llm, [
+                `Look at this instruction`,
+                q,
+                `Is the instruction above can be broken down into numbered step by step plan?`
+            ].join('\n'), session_id !== null && session_id !== void 0 ? session_id : session.id);
+            if (!yn) {
+                throw new Error(`Your prompt cant be broken down into numbered step by step plan`);
+            }
+            const prompt = `Responds previous instruction with numbered step by step plans, where each step must be one line only.`;
+            return yield ask(llm, prompt, plan_resolver, session_id);
+        });
+    }
+    NativeStep.askPlan = askPlan;
+    function streamPlan(llm, q, session_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = yield llm.chat_session_manager.newSession();
+            const yn = yield askYesNo(llm, [
+                `Look at this instruction`,
+                q,
+                `Is the instruction above can be broken down into numbered step by step plan?`
+            ].join('\n'), session_id !== null && session_id !== void 0 ? session_id : session.id);
+            if (!yn) {
+                throw new Error(`Your prompt cant be broken down into numbered step by step plan`);
+            }
+            const prompt = `Responds previous instruction with numbered step by step plans, where each step must be one line only.`;
+            return yield stream(llm, prompt, plan_resolver, session_id !== null && session_id !== void 0 ? session_id : session.id);
+        });
+    }
+    NativeStep.streamPlan = streamPlan;
+})(NativeStep || (exports.NativeStep = NativeStep = {}));

package/dist/platform/chatgpt.d.ts

@@ -0,0 +1,12 @@
+import { LLMRunner } from "../base/llm-runner";
+import { GenericLLM } from "../base/generic-llm";
+import { Readable } from 'node:stream';
+/**
+ * Chat GPT Implementation
+ */
+export declare class ChatGPTLLM extends LLMRunner.BaseLLM {
+    private cgpt;
+    constructor(api_key: string, chat_session_manager?: GenericLLM.ChatSessionManager<LLMRunner.ChatSession, LLMRunner.Message>);
+    protected streamChat(messages: string[], id_session: string | null, stream: Readable, ac: AbortController): Promise<void>;
+    protected chat(messages: string[], id_session: string | null): Promise<string>;
+}

package/dist/platform/chatgpt.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGPTLLM = void 0;
+const openai_1 = __importDefault(require("openai"));
+const llm_runner_1 = require("../base/llm-runner");
+/**
+ * Chat GPT Implementation
+ */
+class ChatGPTLLM extends llm_runner_1.LLMRunner.BaseLLM {
+    constructor(api_key, chat_session_manager) {
+        super(chat_session_manager !== null && chat_session_manager !== void 0 ? chat_session_manager : new llm_runner_1.LLMRunner.SessionManager());
+        this.cgpt = new openai_1.default({ apiKey: api_key });
+    }
+    streamChat(messages, id_session, stream, ac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d, _e;
+            const chat_history = id_session ? yield this.chat_session_manager.retrieveHistory(id_session) : [];
+            const chat_messages = [
+                ...chat_history.map((msg) => { var _a; return ({ role: msg.role, content: (_a = msg.content) !== null && _a !== void 0 ? _a : '' }); }),
+                ...messages.map(content => ({ role: 'user', content }))
+            ];
+            if (ac.signal.aborted) {
+                stream.push(null);
+                return;
+            }
+            const cgpt_stream = yield this.cgpt.chat.completions.create({
+                model: "gpt-4o-mini",
+                store: false,
+                stream: true,
+                n: 1,
+                messages: chat_messages
+            });
+            ac.signal.addEventListener('abort', () => cgpt_stream.controller.abort());
+            try {
+                for (var _f = true, cgpt_stream_1 = __asyncValues(cgpt_stream), cgpt_stream_1_1; cgpt_stream_1_1 = yield cgpt_stream_1.next(), _a = cgpt_stream_1_1.done, !_a; _f = true) {
+                    _c = cgpt_stream_1_1.value;
+                    _f = false;
+                    const chunk = _c;
+                    const c = chunk;
+                    const first_choice = (_d = c.choices) === null || _d === void 0 ? void 0 : _d[0];
+                    const delta = (_e = first_choice.delta.content) !== null && _e !== void 0 ? _e : '';
+                    if (!delta) {
+                        continue;
+                    }
+                    stream.push(delta);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = cgpt_stream_1.return)) yield _b.call(cgpt_stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            stream.push(null);
+        });
+    }
+    chat(messages, id_session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const chat_history = id_session ? yield this.chat_session_manager.retrieveHistory(id_session) : [];
+            const chat_messages = [
+                ...chat_history.map((msg) => { var _a; return ({ role: msg.role, content: (_a = msg.content) !== null && _a !== void 0 ? _a : '' }); }),
+                ...messages.map(content => ({ role: 'user', content }))
+            ];
+            const res = yield this.cgpt.chat.completions.create({
+                model: "gpt-4o-mini",
+                store: false,
+                n: 1,
+                messages: chat_messages
+            });
+            return (_b = (_a = res.choices) === null || _a === void 0 ? void 0 : _a[0].message.content) !== null && _b !== void 0 ? _b : '';
+        });
+    }
+}
+exports.ChatGPTLLM = ChatGPTLLM;

package/dist/platform/ollama.d.ts

@@ -0,0 +1,13 @@
+import { LLMRunner } from "../base/llm-runner";
+import { GenericLLM } from "../base/generic-llm";
+import { Readable } from 'node:stream';
+/**
+ * Ollama Implementation
+ */
+export declare class OllamaLLM extends LLMRunner.BaseLLM {
+    private ollama;
+    private model;
+    constructor(host: string, model: string, chat_session_manager?: GenericLLM.ChatSessionManager<LLMRunner.ChatSession, LLMRunner.Message>);
+    protected streamChat(messages: string[], id_session: string | null, stream: Readable, ac: AbortController): Promise<void>;
+    protected chat(messages: string[], id_session: string | null): Promise<string>;
+}

package/dist/platform/ollama.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaLLM = void 0;
+const ollama_1 = require("ollama");
+const llm_runner_1 = require("../base/llm-runner");
+/**
+ * Ollama Implementation
+ */
+class OllamaLLM extends llm_runner_1.LLMRunner.BaseLLM {
+    constructor(host, model, chat_session_manager) {
+        super(chat_session_manager !== null && chat_session_manager !== void 0 ? chat_session_manager : new llm_runner_1.LLMRunner.SessionManager());
+        this.ollama = new ollama_1.Ollama({ host });
+        this.model = model;
+    }
+    streamChat(messages, id_session, stream, ac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d;
+            const chat_history = id_session ? yield this.chat_session_manager.retrieveHistory(id_session) : [];
+            const cgpt_stream = yield this.ollama.chat({
+                model: this.model,
+                messages: [
+                    ...chat_history,
+                    ...messages.map(content => ({
+                        role: 'user', content
+                    }))
+                ],
+                stream: true
+            });
+            ac.signal.addEventListener('abort', () => cgpt_stream.abort());
+            try {
+                for (var _e = true, cgpt_stream_1 = __asyncValues(cgpt_stream), cgpt_stream_1_1; cgpt_stream_1_1 = yield cgpt_stream_1.next(), _a = cgpt_stream_1_1.done, !_a; _e = true) {
+                    _c = cgpt_stream_1_1.value;
+                    _e = false;
+                    const chunk = _c;
+                    stream.push((_d = chunk.message.content) !== null && _d !== void 0 ? _d : '');
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = cgpt_stream_1.return)) yield _b.call(cgpt_stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            stream.push(null);
+        });
+    }
+    chat(messages, id_session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chat_history = id_session ? yield this.chat_session_manager.retrieveHistory(id_session) : [];
+            const res = yield this.ollama.chat({
+                model: this.model,
+                messages: [
+                    ...chat_history,
+                    ...messages.map(content => ({ role: 'user', content }))
+                ]
+            });
+            return res.message.content;
+        });
+    }
+}
+exports.OllamaLLM = OllamaLLM;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@graf-research/llm-runner",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "start": "node dist"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/compression": "^1.7.5",
+    "@types/express": "^5.0.0",
+    "@types/lodash": "^4.17.15",
+    "@types/pg": "^8.11.11",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "ollama": "^0.5.13",
+    "openai": "^4.85.3",
+    "uuid": "^11.1.0"
+  }
+}