@proteinjs/conversation 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.1 (2024-04-19)
+
+**Note:** Version bump only for package @proteinjs/conversation

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Brent Bahry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/Sentence"), exports);
+__exportStar(require("./src/Paragraph"), exports);
+__exportStar(require("./src/OpenAi"), exports);
+__exportStar(require("./src/code_template/CodeTemplate"), exports);
+__exportStar(require("./src/Conversation"), exports);
+__exportStar(require("./src/CodegenConversation"), exports);
+__exportStar(require("./src/code_template/Code"), exports);
+__exportStar(require("./src/ConversationModule"), exports);
+__exportStar(require("./src/Function"), exports);
+__exportStar(require("./src/history/MessageModerator"), exports);
+__exportStar(require("./src/history/MessageHistory"), exports);

package/dist/jest.config.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest',
+    },
+    testMatch: ["**/?(*.)+(spec|test).ts"],
+    setupFiles: ['./test/setup'],
+};

package/dist/src/CodegenConversation.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.CodegenConversation = void 0;
+const readline = __importStar(require("readline-sync"));
+const Conversation_1 = require("./Conversation");
+const KeywordToFilesIndexModule_1 = require("./fs/keyword_to_files_index/KeywordToFilesIndexModule");
+const ConversationTemplateModule_1 = require("./template/ConversationTemplateModule");
+const ConversationFsModule_1 = require("./fs/conversation_fs/ConversationFsModule");
+const PackageModule_1 = require("./fs/package/PackageModule");
+const util_1 = require("@proteinjs/util");
+const GitModule_1 = require("./fs/git/GitModule");
+class CodegenConversation {
+    constructor(repoPath) {
+        this.repoPath = repoPath;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conversation = yield this.createConversation();
+            conversation.addAssistantMessagesToHistory([CodegenConversation.INITIAL_QUESTION]);
+            const initialUserInput = this.respondToUser(CodegenConversation.INITIAL_QUESTION);
+            let response = yield conversation.generateResponse([initialUserInput], CodegenConversation.MODEL);
+            while (true) {
+                const userInput = this.respondToUser(response);
+                response = yield conversation.generateResponse([userInput], CodegenConversation.MODEL);
+            }
+        });
+    }
+    createConversation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conversation = new Conversation_1.Conversation({
+                name: this.constructor.name,
+                modules: yield this.getModules(),
+                logLevel: 'info',
+            });
+            conversation.addSystemMessagesToHistory(this.getSystemMessages());
+            return conversation;
+        });
+    }
+    getModules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const moduleFactories = [
+                new ConversationFsModule_1.ConversationFsModuleFactory(),
+                new KeywordToFilesIndexModule_1.KeywordToFilesIndexModuleFactory(),
+                new PackageModule_1.PackageModuleFactory(),
+                new ConversationTemplateModule_1.ConversationTemplateModuleFactory(),
+                new GitModule_1.GitModuleFactory(),
+            ];
+            const modules = [];
+            for (let moduleFactory of moduleFactories)
+                modules.push(yield moduleFactory.createModule(this.repoPath));
+            return modules;
+        });
+    }
+    getSystemMessages() {
+        return [
+            `We are going to have a conversation with the user to generate code`,
+            `Await all function calls that return a promise`,
+            `Try to repspond to the user with as few words as possible while still having a conversational tone`,
+            `When generating code, export the objects you create inline; do not use 'export default' syntax`,
+            // `After finding a file to work with, assume the user's following question pertains to that file and use ${readFilesFunctionName} to read the file if needed`,
+            // `If a conversation summary exists, if you aren't already working with a file, use the most relevant keyword mentioned in the conversation summary to find a file to read (using the ${searchFilesFunctionName} function) and then respond to the user after reading the file`,
+            // `Use the most relevant keyword mentioned in the conversation summary to find a file to read (using the ${searchFilesFunctionName} function) and then respond to the user after reading the file`,
+            // `If the conversation summary indicates the user was working with a file get the file path (use the ${searchFilesFunctionName} function if needed) and read the file with the ${readFilesFunctionName} function. Use that file as context to respond to the user.`,
+            //
+            // `Use the conversation summary to identify a file as context for the user interaction`,
+            // `Use the ${searchFilesFunctionName} function to find the file if needed; read the file if needed`,
+            // `If the user is referring to a function, object, class, or type and you don't have the relevant file content, first inspect the conversation summary in the chat history (if it exists) to find a file name, and call the ${searchFilesFunctionName} function and read the file before responding to the user`,
+            // `Before calling ${searchFilesFunctionName}, ${searchLibrariesFunctionName} or ${searchPackagesFunctionName}, use the conversation summary in the chat history to identify a file or keyword to search for instead; after reading that file, respond to the user's request`,
+            // 
+            // `Use the ${getRecentlyAccessedFilePathsFunctionName} function find a file that might pertain to the user's request before searching files, libraries or packages; read that file then respond to the user`,
+            // `When trying to locate code, use the ${getRecentlyAccessedFilePathsFunctionName} function to search recently accessed files first, then proceed to calling other functions: ${searchLibrariesFunctionName}, ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+            // `The conversation summary indicates files recently worked in as well`,
+            // `If that doesn't yield results, proceed to calling the ${searchLibrariesFunctionName} function, then fall back to functions: ${searchPackagesFunctionName}, ${searchFilesFunctionName}`,
+            // 
+            // `To find code, a file, or a library, call ${getRecentlyAccessedFilePathsFunctionName} and read the most recent file, after trying that call ${searchLibrariesFunctionName} then ${searchFilesFunctionName} to find a relevant file`,
+            // `The file mentioned in the conversation summary should be read if we're not already working in a file`,
+            // `If there is a conversation summary assistant message, use that to pick a file to read before responding to the user if not already working with a specific file`,
+            // `Check for a previous conversation summary assistant message in the chat history; if there is one and it mentions a file the user was working with, call ${searchLibrariesFunctionName} to find the file path then call ${readFilesFunctionName} to read the file. Do this to build context before responding to the user`,
+        ];
+    }
+    respondToUser(message) {
+        return readline.question(`${util_1.textColorMap.cyan}[${CodegenConversation.BOT_NAME}] ${message}${util_1.Reset}\n`);
+    }
+}
+exports.CodegenConversation = CodegenConversation;
+CodegenConversation.INITIAL_QUESTION = 'What would you like to create?';
+CodegenConversation.BOT_NAME = 'Alina';
+CodegenConversation.MODEL = 'gpt-4'; //'gpt-3.5-turbo-16k';

package/dist/src/Conversation.js

@@ -0,0 +1,193 @@
+"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.summarizeConversationHistoryFunction = exports.summarizeConversationHistoryFunctionName = exports.Conversation = void 0;
+const OpenAi_1 = require("./OpenAi");
+const MessageHistory_1 = require("./history/MessageHistory");
+const util_1 = require("@proteinjs/util");
+const util_node_1 = require("@proteinjs/util-node");
+const tiktoken_1 = require("tiktoken");
+const PackageFunctions_1 = require("./fs/package/PackageFunctions");
+class Conversation {
+    constructor(params) {
+        var _a, _b, _c, _d;
+        this.tokenLimit = 3000;
+        this.systemMessages = [];
+        this.functions = [];
+        this.messageModerators = [];
+        this.generatedCode = false;
+        this.generatedList = false;
+        this.params = params;
+        this.history = new MessageHistory_1.MessageHistory({ maxMessages: (_a = params.limits) === null || _a === void 0 ? void 0 : _a.maxMessagesInHistory, enforceMessageLimit: (_b = params.limits) === null || _b === void 0 ? void 0 : _b.enforceLimits });
+        this.logger = new util_1.Logger(params.name, params.logLevel);
+        if (params.modules)
+            this.addModules(params.modules);
+        if (typeof ((_c = params.limits) === null || _c === void 0 ? void 0 : _c.enforceLimits) === 'undefined' || params.limits.enforceLimits) {
+            this.addFunctions('Conversation', [
+                (0, exports.summarizeConversationHistoryFunction)(this),
+            ]);
+        }
+        if ((_d = params.limits) === null || _d === void 0 ? void 0 : _d.tokenLimit)
+            this.tokenLimit = params.limits.tokenLimit;
+    }
+    addModules(modules) {
+        for (let module of modules) {
+            if (module.getSystemMessages().length < 1)
+                continue;
+            this.addSystemMessagesToHistory([
+                `The following are instructions from the ${module.getName()} module: ${module.getSystemMessages().join('. ')}`,
+            ]);
+            this.addFunctions(module.getName(), module.getFunctions());
+            this.addMessageModerators(module.getMessageModerators());
+        }
+    }
+    addFunctions(moduleName, functions) {
+        this.functions.push(...functions);
+        let functionInstructions = `The following are instructions from functions in the ${moduleName} module:`;
+        let functionInstructionsAdded = false;
+        for (let f of functions) {
+            if (f.instructions) {
+                if (!f.instructions || f.instructions.length < 1)
+                    continue;
+                functionInstructionsAdded = true;
+                const instructionsParagraph = f.instructions.join('. ');
+                functionInstructions += ` ${f.definition.name}: ${instructionsParagraph}.`;
+            }
+        }
+        if (!functionInstructionsAdded)
+            return;
+        this.addSystemMessagesToHistory([functionInstructions]);
+    }
+    addMessageModerators(messageModerators) {
+        this.messageModerators.push(...messageModerators);
+    }
+    enforceTokenLimit(messages, model) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.params.limits) === null || _a === void 0 ? void 0 : _a.enforceLimits) === false)
+                return;
+            const resolvedModel = model ? model : OpenAi_1.DEFAULT_MODEL;
+            const encoder = (0, tiktoken_1.encoding_for_model)(resolvedModel);
+            const conversation = this.history.toString() + messages.join('. ');
+            const encoded = encoder.encode(conversation);
+            console.log(`current tokens: ${encoded.length}`);
+            if (encoded.length < this.tokenLimit)
+                return;
+            const summarizeConversationRequest = `First, call the ${exports.summarizeConversationHistoryFunctionName} function`;
+            yield OpenAi_1.OpenAi.generateResponse([summarizeConversationRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+            const referenceSummaryRequest = `If there's a file mentioned in the conversation summary, find and read the file to better respond to my next request. If that doesn't find anything, call the ${PackageFunctions_1.searchLibrariesFunctionName} function on other keywords in the conversation summary to find a file to read`;
+            yield OpenAi_1.OpenAi.generateResponse([referenceSummaryRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+        });
+    }
+    summarizeConversationHistory(summary) {
+        this.clearHistory();
+        this.history.push([{ role: 'assistant', content: `Previous conversation summary: ${summary}` }]);
+    }
+    clearHistory() {
+        this.history = new MessageHistory_1.MessageHistory();
+        this.history.push(this.systemMessages);
+    }
+    addSystemMessagesToHistory(messages, unshift = false) {
+        const chatCompletions = messages.map(message => { return { role: 'system', content: message }; });
+        if (unshift) {
+            this.history.getMessages().unshift(...chatCompletions);
+            this.history.prune();
+            this.systemMessages.unshift(...chatCompletions);
+        }
+        else {
+            this.history.push(chatCompletions);
+            this.systemMessages.push(...chatCompletions);
+        }
+    }
+    addAssistantMessagesToHistory(messages, unshift = false) {
+        const chatCompletions = messages.map(message => { return { role: 'assistant', content: message }; });
+        if (unshift) {
+            this.history.getMessages().unshift(...chatCompletions);
+            this.history.prune();
+        }
+        else
+            this.history.push(chatCompletions);
+    }
+    addUserMessagesToHistory(messages, unshift = false) {
+        const chatCompletions = messages.map(message => { return { role: 'user', content: message }; });
+        if (unshift) {
+            this.history.getMessages().unshift(...chatCompletions);
+            this.history.prune();
+        }
+        else
+            this.history.push(chatCompletions);
+    }
+    generateResponse(messages, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.enforceTokenLimit(messages, model);
+            return yield OpenAi_1.OpenAi.generateResponse(messages, model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+        });
+    }
+    generateCode(description, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Generating code for description:\n${description.join('\n')}`);
+            const code = yield OpenAi_1.OpenAi.generateCode(description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+            this.logger.info(`Generated code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}`);
+            this.generatedCode = true;
+            return code;
+        });
+    }
+    updateCodeFromFile(codeToUpdateFilePath, dependencyCodeFilePaths, description, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const codeToUpdate = yield util_node_1.Fs.readFile(codeToUpdateFilePath);
+            let dependencyDescription = `Assume the following exists:\n`;
+            for (let dependencyCodeFilePath of dependencyCodeFilePaths) {
+                const dependencCode = yield util_node_1.Fs.readFile(dependencyCodeFilePath);
+                dependencyDescription += dependencCode + '\n\n';
+            }
+            this.logger.info(`Updating code from file: ${codeToUpdateFilePath}`);
+            return yield this.updateCode(codeToUpdate, dependencyDescription + description, model);
+        });
+    }
+    updateCode(code, description, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Updating code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}\nFrom description: ${description}`);
+            const updatedCode = yield OpenAi_1.OpenAi.updateCode(code, description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+            this.logger.info(`Updated code:\n${updatedCode.slice(0, 150)}${updatedCode.length > 150 ? '...' : ''}`);
+            this.generatedCode = true;
+            return updatedCode;
+        });
+    }
+    generateList(description, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const list = yield OpenAi_1.OpenAi.generateList(description, model, this.history, this.functions, this.messageModerators, !this.generatedList, this.params.logLevel);
+            this.generatedList = true;
+            return list;
+        });
+    }
+}
+exports.Conversation = Conversation;
+exports.summarizeConversationHistoryFunctionName = 'summarizeConversationHistory';
+const summarizeConversationHistoryFunction = (conversation) => {
+    return {
+        definition: {
+            name: exports.summarizeConversationHistoryFunctionName,
+            description: 'Clear the conversation history and summarize what was in it',
+            parameters: {
+                type: 'object',
+                properties: {
+                    summary: {
+                        type: 'string',
+                        description: 'A 1-3 sentence summary of the current chat history',
+                    },
+                },
+                required: ['summary']
+            },
+        },
+        call: (params) => __awaiter(void 0, void 0, void 0, function* () { return conversation.summarizeConversationHistory(params.summary); }),
+    };
+};
+exports.summarizeConversationHistoryFunction = summarizeConversationHistoryFunction;

package/dist/src/ConversationModule.js

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

package/dist/src/Function.js

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

package/dist/src/OpenAi.js

@@ -0,0 +1,209 @@
+"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.OpenAi = exports.DEFAULT_MODEL = void 0;
+const openai_1 = require("openai");
+const util_1 = require("@proteinjs/util");
+const MessageHistory_1 = require("./history/MessageHistory");
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.DEFAULT_MODEL = 'gpt-3.5-turbo';
+class OpenAi {
+    static generateResponse(messages, model, history, functions, messageModerators, logLevel = 'info') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = new util_1.Logger('OpenAi.generateResponse', logLevel);
+            const messageParams = messages.map(message => { return { role: 'user', content: message }; });
+            if (history)
+                history.push(messageParams);
+            let messageParamsWithHistory = history ? history : new MessageHistory_1.MessageHistory().push(messageParams);
+            if (messageModerators)
+                messageParamsWithHistory = OpenAi.moderateHistory(messageParamsWithHistory, messageModerators);
+            const response = yield OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
+            const responseMessage = response.choices[0].message;
+            if (responseMessage.function_call) {
+                messageParamsWithHistory.push([responseMessage]);
+                const functionReturnMessage = yield this.callFunction(logLevel, responseMessage.function_call, functions);
+                if (functionReturnMessage)
+                    messageParamsWithHistory.push([functionReturnMessage]);
+                return yield this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel);
+            }
+            const responseText = responseMessage.content;
+            if (!responseText) {
+                logger.error(`Received response: ${JSON.stringify(response)}`);
+                throw new Error(`Response was empty for messages: ${messages.join('\n')}`);
+            }
+            messageParamsWithHistory.push([responseMessage]);
+            return responseText;
+        });
+    }
+    static moderateHistory(history, messageModerators) {
+        for (let messageModerator of messageModerators)
+            history.setMessages(messageModerator.observe(history.getMessages()));
+        return history;
+    }
+    static executeRequest(messageParamsWithHistory, logLevel, functions, model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = new util_1.Logger('OpenAi.executeRequest', logLevel);
+            const openaiApi = new openai_1.OpenAI();
+            let response;
+            try {
+                const latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
+                if (latestMessage.content)
+                    logger.info(`Sending request: ${latestMessage.content}`);
+                else if (latestMessage.role == 'function')
+                    logger.info(`Sending request: returning output of ${latestMessage.name} function`);
+                else
+                    logger.info(`Sending request`);
+                logger.debug(`Sending messages: ${JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)}`, true);
+                response = yield openaiApi.chat.completions.create({
+                    model: model ? model : exports.DEFAULT_MODEL,
+                    temperature: 0,
+                    messages: messageParamsWithHistory.getMessages(),
+                    functions: functions === null || functions === void 0 ? void 0 : functions.map(f => f.definition),
+                });
+                const responseMessage = response.choices[0].message;
+                if (responseMessage.content)
+                    logger.info(`Received response: ${responseMessage.content}`);
+                else if (responseMessage.function_call)
+                    logger.info(`Received response: call ${responseMessage.function_call.name} function`);
+                else
+                    logger.info(`Received response`);
+                if (response.usage)
+                    logger.info(JSON.stringify(response.usage));
+                else
+                    logger.info(JSON.stringify(`Usage data missing`));
+            }
+            catch (error) {
+                logger.info(`Received error response, error type: ${error.type}`);
+                if (typeof error.status !== 'undefined' && error.status == 429) {
+                    if (error.type == 'tokens' && typeof error.headers['x-ratelimit-reset-tokens'] === 'string') {
+                        const waitTime = parseInt(error.headers['x-ratelimit-reset-tokens']);
+                        const remainingTokens = error.headers['x-ratelimit-remaining-tokens'];
+                        const delayMs = 15000;
+                        logger.warn(`Waiting to retry in ${delayMs / 1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`);
+                        yield delay(delayMs);
+                        return yield OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
+                    }
+                }
+                throw error;
+            }
+            return response;
+        });
+    }
+    static callFunction(logLevel, functionCall, functions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = new util_1.Logger('OpenAi.callFunction', logLevel);
+            if (!functions) {
+                const warning = `Assistant attempted to call a function when no functions were provided`;
+                logger.warn(warning);
+                const message = { role: 'user', content: warning };
+                return message;
+            }
+            functionCall.name = functionCall.name.split('.').pop();
+            const f = functions.find(f => f.definition.name === functionCall.name);
+            if (!f) {
+                const warning = `Assistant attempted to call nonexistent function: ${functionCall.name}`;
+                logger.warn(warning);
+                const message = { role: 'user', content: warning };
+                return message;
+            }
+            let returnObject = null;
+            try {
+                logger.info(`Assistant calling function: ${f.definition.name}(${functionCall.arguments})`);
+                returnObject = JSON.stringify(yield f.call(JSON.parse(functionCall.arguments)));
+                logger.info(`Assistant called function: ${f.definition.name}(${functionCall.arguments}) => ${returnObject}`, 1000);
+            }
+            catch (error) {
+                logger.error(error.message);
+            }
+            if (!returnObject)
+                return;
+            return {
+                role: 'function',
+                name: f.definition.name,
+                content: returnObject,
+            };
+        });
+    }
+    static generateCode(messages, model, history, functions, messageModerators, includeSystemMessages = true, logLevel = 'info') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const systemMessages = [
+                { role: 'system', content: 'Return only the code and exclude example usage, markdown, explanations, comments and notes.' },
+                { role: 'system', content: `Write code in typescript.` },
+                { role: 'system', content: `Declare explicit types for all function parameters.` },
+                { role: 'system', content: 'Export all functions and objects generated.' },
+                { role: 'system', content: 'Do not omit function implementations.' },
+            ];
+            const resolvedHistory = history ?
+                includeSystemMessages ?
+                    history.push(systemMessages)
+                    :
+                        history
+                :
+                    includeSystemMessages ?
+                        new MessageHistory_1.MessageHistory().push(systemMessages)
+                        :
+                            undefined;
+            const code = yield this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
+            return this.parseCodeFromMarkdown(code);
+        });
+    }
+    static updateCode(code, description, model, history, functions, messageModerators, includeSystemMessages = true, logLevel = 'info') {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.generateCode([this.updateCodeDescription(code, description)], model, history, functions, messageModerators, includeSystemMessages, logLevel);
+        });
+    }
+    static updateCodeDescription(code, description) {
+        return `Update this code:\n\n${code}\n\n${description}`;
+    }
+    static parseCodeFromMarkdown(code) {
+        if (!code.match(/```([\s\S]+?)```/g))
+            return code;
+        const filteredLines = [];
+        let inCodeBlock = false;
+        for (let line of code.split('\n')) {
+            if (line.startsWith('```')) {
+                inCodeBlock = !inCodeBlock;
+                if (!inCodeBlock)
+                    filteredLines.push('');
+                continue;
+            }
+            if (inCodeBlock)
+                filteredLines.push(line);
+        }
+        // remove the last '' that will become a \n
+        // we only want spaces between code blocks
+        filteredLines.pop();
+        return filteredLines.join('\n');
+    }
+    static generateList(messages, model, history, functions, messageModerators, includeSystemMessages = true, logLevel = 'info') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const systemMessages = [
+                { role: 'system', content: 'Return only the list and exclude example usage, markdown and all explanations, comments and notes.' },
+                { role: 'system', content: 'Separate each item in the list by a ;' },
+            ];
+            const resolvedHistory = history ?
+                includeSystemMessages ?
+                    history.push(systemMessages)
+                    :
+                        history
+                :
+                    includeSystemMessages ?
+                        new MessageHistory_1.MessageHistory().push(systemMessages)
+                        :
+                            undefined;
+            const list = yield this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
+            return list.split(';').map(item => item.trim());
+        });
+    }
+}
+exports.OpenAi = OpenAi;

package/dist/src/Paragraph.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paragraph = void 0;
+class Paragraph {
+    constructor() {
+        this.sentences = [];
+    }
+    add(sentence) {
+        this.sentences.push(sentence);
+        return this;
+    }
+    toString() {
+        if (this.sentences.length == 0)
+            return '';
+        return this.sentences.join(' ');
+    }
+}
+exports.Paragraph = Paragraph;

package/dist/src/Sentence.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sentence = void 0;
+// Alina was here
+class Sentence {
+    constructor() {
+        this.lines = [];
+    }
+    add(line) {
+        this.lines.push(line);
+        return this;
+    }
+    toString() {
+        if (this.lines.length == 0)
+            return '';
+        let sentence = this.lines.join(', ');
+        if (sentence.lastIndexOf('.') != (sentence.length - 1))
+            sentence += '.';
+        return sentence;
+    }
+}
+exports.Sentence = Sentence;