@proteinjs/conversation 1.0.5 → 1.0.7

package/dist/src/OpenAi.js

@@ -1,305 +1,512 @@
-"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); }); }
+'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());
+      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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
+  };
+var __generator =
+  (this && this.__generator) ||
+  function (thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function () {
+          if (t[0] & 1) throw t[1];
+          return t[1];
+        },
+        trys: [],
+        ops: [],
+      },
+      f,
+      y,
+      t,
+      g;
+    return (
+      (g = { next: verb(0), throw: verb(1), return: verb(2) }),
+      typeof Symbol === 'function' &&
+        (g[Symbol.iterator] = function () {
+          return this;
+        }),
+      g
+    );
+    function verb(n) {
+      return function (v) {
+        return step([n, v]);
+      };
+    }
     function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      if (f) throw new TypeError('Generator is already executing.');
+      while ((g && ((g = 0), op[0] && (_ = 0)), _))
+        try {
+          if (
+            ((f = 1),
+            y &&
+              (t = op[0] & 2 ? y['return'] : op[0] ? y['throw'] || ((t = y['return']) && t.call(y), 0) : y.next) &&
+              !(t = t.call(y, op[1])).done)
+          )
+            return t;
+          if (((y = 0), t)) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+      if (op[0] & 5) throw op[1];
+      return { value: op[0] ? op[1] : void 0, done: true };
     }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.OpenAi = exports.DEFAULT_MODEL = void 0;
-var openai_1 = require("openai");
-var util_1 = require("@proteinjs/util");
-var MessageHistory_1 = require("./history/MessageHistory");
+var openai_1 = require('openai');
+var util_1 = require('@proteinjs/util');
+var MessageHistory_1 = require('./history/MessageHistory');
 function delay(ms) {
-    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+  return new Promise(function (resolve) {
+    return setTimeout(resolve, ms);
+  });
 }
 exports.DEFAULT_MODEL = 'gpt-3.5-turbo';
 var OpenAi = /** @class */ (function () {
-    function OpenAi() {
+  function OpenAi() {}
+  OpenAi.generateResponse = function (messages, model, history, functions, messageModerators, logLevel) {
+    if (logLevel === void 0) {
+      logLevel = 'info';
     }
-    OpenAi.generateResponse = function (messages, model, history, functions, messageModerators, logLevel) {
-        if (logLevel === void 0) { logLevel = 'info'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var logger, messageParams, messageParamsWithHistory, response, responseMessage, functionReturnMessage, responseText;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger = new util_1.Logger('OpenAi.generateResponse', logLevel);
-                        messageParams = messages.map(function (message) { return { role: 'user', content: message }; });
-                        if (history)
-                            history.push(messageParams);
-                        messageParamsWithHistory = history ? history : new MessageHistory_1.MessageHistory().push(messageParams);
-                        if (messageModerators)
-                            messageParamsWithHistory = OpenAi.moderateHistory(messageParamsWithHistory, messageModerators);
-                        return [4 /*yield*/, OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model)];
-                    case 1:
-                        response = _a.sent();
-                        responseMessage = response.choices[0].message;
-                        if (!responseMessage.function_call) return [3 /*break*/, 4];
-                        messageParamsWithHistory.push([responseMessage]);
-                        return [4 /*yield*/, this.callFunction(logLevel, responseMessage.function_call, functions)];
-                    case 2:
-                        functionReturnMessage = _a.sent();
-                        if (functionReturnMessage)
-                            messageParamsWithHistory.push([functionReturnMessage]);
-                        return [4 /*yield*/, this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel)];
-                    case 3: return [2 /*return*/, _a.sent()];
-                    case 4:
-                        responseText = responseMessage.content;
-                        if (!responseText) {
-                            logger.error("Received response: ".concat(JSON.stringify(response)));
-                            throw new Error("Response was empty for messages: ".concat(messages.join('\n')));
-                        }
-                        messageParamsWithHistory.push([responseMessage]);
-                        return [2 /*return*/, responseText];
-                }
+    return __awaiter(this, void 0, void 0, function () {
+      var logger,
+        messageParams,
+        messageParamsWithHistory,
+        response,
+        responseMessage,
+        functionReturnMessage,
+        responseText;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            logger = new util_1.Logger('OpenAi.generateResponse', logLevel);
+            messageParams = messages.map(function (message) {
+              return { role: 'user', content: message };
             });
-        });
-    };
-    OpenAi.moderateHistory = function (history, messageModerators) {
-        for (var _i = 0, messageModerators_1 = messageModerators; _i < messageModerators_1.length; _i++) {
-            var messageModerator = messageModerators_1[_i];
-            history.setMessages(messageModerator.observe(history.getMessages()));
+            if (history) {
+              history.push(messageParams);
+            }
+            messageParamsWithHistory = history ? history : new MessageHistory_1.MessageHistory().push(messageParams);
+            if (messageModerators) {
+              messageParamsWithHistory = OpenAi.moderateHistory(messageParamsWithHistory, messageModerators);
+            }
+            return [4 /*yield*/, OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model)];
+          case 1:
+            response = _a.sent();
+            responseMessage = response.choices[0].message;
+            if (!responseMessage.function_call) return [3 /*break*/, 4];
+            messageParamsWithHistory.push([responseMessage]);
+            return [4 /*yield*/, this.callFunction(logLevel, responseMessage.function_call, functions)];
+          case 2:
+            functionReturnMessage = _a.sent();
+            if (functionReturnMessage) {
+              messageParamsWithHistory.push([functionReturnMessage]);
+            }
+            return [
+              4 /*yield*/,
+              this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel),
+            ];
+          case 3:
+            return [2 /*return*/, _a.sent()];
+          case 4:
+            responseText = responseMessage.content;
+            if (!responseText) {
+              logger.error('Received response: '.concat(JSON.stringify(response)));
+              throw new Error('Response was empty for messages: '.concat(messages.join('\n')));
+            }
+            messageParamsWithHistory.push([responseMessage]);
+            return [2 /*return*/, responseText];
         }
-        return history;
-    };
-    OpenAi.executeRequest = function (messageParamsWithHistory, logLevel, functions, model) {
-        return __awaiter(this, void 0, void 0, function () {
-            var logger, openaiApi, response, latestMessage, responseMessage, error_1, waitTime, remainingTokens, delayMs;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        logger = new util_1.Logger('OpenAi.executeRequest', logLevel);
-                        openaiApi = new openai_1.OpenAI();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 7]);
-                        latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
-                        if (latestMessage.content)
-                            logger.info("Sending request: ".concat(latestMessage.content));
-                        else if (latestMessage.role == 'function')
-                            logger.info("Sending request: returning output of ".concat(latestMessage.name, " function"));
-                        else
-                            logger.info("Sending request");
-                        logger.debug("Sending messages: ".concat(JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)), true);
-                        return [4 /*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(function (f) { return f.definition; }),
-                            })];
-                    case 2:
-                        response = _a.sent();
-                        responseMessage = response.choices[0].message;
-                        if (responseMessage.content)
-                            logger.info("Received response: ".concat(responseMessage.content));
-                        else if (responseMessage.function_call)
-                            logger.info("Received response: call ".concat(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"));
-                        return [3 /*break*/, 7];
-                    case 3:
-                        error_1 = _a.sent();
-                        logger.info("Received error response, error type: ".concat(error_1.type));
-                        if (!(typeof error_1.status !== 'undefined' && error_1.status == 429)) return [3 /*break*/, 6];
-                        if (!(error_1.type == 'tokens' && typeof error_1.headers['x-ratelimit-reset-tokens'] === 'string')) return [3 /*break*/, 6];
-                        waitTime = parseInt(error_1.headers['x-ratelimit-reset-tokens']);
-                        remainingTokens = error_1.headers['x-ratelimit-remaining-tokens'];
-                        delayMs = 15000;
-                        logger.warn("Waiting to retry in ".concat(delayMs / 1000, "s, token reset in: ").concat(waitTime, "s, remaining tokens: ").concat(remainingTokens));
-                        return [4 /*yield*/, delay(delayMs)];
-                    case 4:
-                        _a.sent();
-                        return [4 /*yield*/, OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model)];
-                    case 5: return [2 /*return*/, _a.sent()];
-                    case 6: throw error_1;
-                    case 7: return [2 /*return*/, response];
-                }
-            });
-        });
-    };
-    OpenAi.callFunction = function (logLevel, functionCall, functions) {
-        return __awaiter(this, void 0, void 0, function () {
-            var logger, warning, message, f, warning, message, returnObject, _a, _b, error_2;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        logger = new util_1.Logger('OpenAi.callFunction', logLevel);
-                        if (!functions) {
-                            warning = "Assistant attempted to call a function when no functions were provided";
-                            logger.warn(warning);
-                            message = { role: 'user', content: warning };
-                            return [2 /*return*/, message];
-                        }
-                        functionCall.name = functionCall.name.split('.').pop();
-                        f = functions.find(function (f) { return f.definition.name === functionCall.name; });
-                        if (!f) {
-                            warning = "Assistant attempted to call nonexistent function: ".concat(functionCall.name);
-                            logger.warn(warning);
-                            message = { role: 'user', content: warning };
-                            return [2 /*return*/, message];
-                        }
-                        returnObject = null;
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        logger.info("Assistant calling function: ".concat(f.definition.name, "(").concat(functionCall.arguments, ")"));
-                        _b = (_a = JSON).stringify;
-                        return [4 /*yield*/, f.call(JSON.parse(functionCall.arguments))];
-                    case 2:
-                        returnObject = _b.apply(_a, [_c.sent()]);
-                        logger.info("Assistant called function: ".concat(f.definition.name, "(").concat(functionCall.arguments, ") => ").concat(returnObject), 1000);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_2 = _c.sent();
-                        logger.error(error_2.message);
-                        return [3 /*break*/, 4];
-                    case 4:
-                        if (!returnObject)
-                            return [2 /*return*/];
-                        return [2 /*return*/, {
-                                role: 'function',
-                                name: f.definition.name,
-                                content: returnObject,
-                            }];
-                }
-            });
-        });
-    };
-    OpenAi.generateCode = function (messages, model, history, functions, messageModerators, includeSystemMessages, logLevel) {
-        if (includeSystemMessages === void 0) { includeSystemMessages = true; }
-        if (logLevel === void 0) { logLevel = 'info'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var systemMessages, resolvedHistory, code;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        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.' },
-                        ];
-                        resolvedHistory = history ?
-                            includeSystemMessages ?
-                                history.push(systemMessages)
-                                :
-                                    history
-                            :
-                                includeSystemMessages ?
-                                    new MessageHistory_1.MessageHistory().push(systemMessages)
-                                    :
-                                        undefined;
-                        return [4 /*yield*/, this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel)];
-                    case 1:
-                        code = _a.sent();
-                        return [2 /*return*/, this.parseCodeFromMarkdown(code)];
-                }
-            });
-        });
-    };
-    OpenAi.updateCode = function (code, description, model, history, functions, messageModerators, includeSystemMessages, logLevel) {
-        if (includeSystemMessages === void 0) { includeSystemMessages = true; }
-        if (logLevel === void 0) { logLevel = 'info'; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.generateCode([this.updateCodeDescription(code, description)], model, history, functions, messageModerators, includeSystemMessages, logLevel)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    OpenAi.updateCodeDescription = function (code, description) {
-        return "Update this code:\n\n".concat(code, "\n\n").concat(description);
-    };
-    OpenAi.parseCodeFromMarkdown = function (code) {
-        if (!code.match(/```([\s\S]+?)```/g))
-            return code;
-        var filteredLines = [];
-        var inCodeBlock = false;
-        for (var _i = 0, _a = code.split('\n'); _i < _a.length; _i++) {
-            var line = _a[_i];
-            if (line.startsWith('```')) {
-                inCodeBlock = !inCodeBlock;
-                if (!inCodeBlock)
-                    filteredLines.push('');
-                continue;
+      });
+    });
+  };
+  OpenAi.moderateHistory = function (history, messageModerators) {
+    for (var _i = 0, messageModerators_1 = messageModerators; _i < messageModerators_1.length; _i++) {
+      var messageModerator = messageModerators_1[_i];
+      history.setMessages(messageModerator.observe(history.getMessages()));
+    }
+    return history;
+  };
+  OpenAi.executeRequest = function (messageParamsWithHistory, logLevel, functions, model) {
+    return __awaiter(this, void 0, void 0, function () {
+      var logger, openaiApi, response, latestMessage, responseMessage, error_1, waitTime, remainingTokens, delayMs;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            logger = new util_1.Logger('OpenAi.executeRequest', logLevel);
+            openaiApi = new openai_1.OpenAI();
+            _a.label = 1;
+          case 1:
+            _a.trys.push([1, 3, , 7]);
+            latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
+            if (latestMessage.content) {
+              logger.info('Sending request: '.concat(latestMessage.content));
+            } else if (latestMessage.role == 'function') {
+              logger.info('Sending request: returning output of '.concat(latestMessage.name, ' function'));
+            } else {
+              logger.info('Sending request');
+            }
+            logger.debug(
+              'Sending messages: '.concat(JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)),
+              true
+            );
+            return [
+              4 /*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(function (f) {
+                        return f.definition;
+                      }),
+              }),
+            ];
+          case 2:
+            response = _a.sent();
+            responseMessage = response.choices[0].message;
+            if (responseMessage.content) {
+              logger.info('Received response: '.concat(responseMessage.content));
+            } else if (responseMessage.function_call) {
+              logger.info('Received response: call '.concat(responseMessage.function_call.name, ' function'));
+            } else {
+              logger.info('Received response');
             }
-            if (inCodeBlock)
-                filteredLines.push(line);
+            if (response.usage) {
+              logger.info(JSON.stringify(response.usage));
+            } else {
+              logger.info(JSON.stringify('Usage data missing'));
+            }
+            return [3 /*break*/, 7];
+          case 3:
+            error_1 = _a.sent();
+            logger.info('Received error response, error type: '.concat(error_1.type));
+            if (!(typeof error_1.status !== 'undefined' && error_1.status == 429)) return [3 /*break*/, 6];
+            if (!(error_1.type == 'tokens' && typeof error_1.headers['x-ratelimit-reset-tokens'] === 'string'))
+              return [3 /*break*/, 6];
+            waitTime = parseInt(error_1.headers['x-ratelimit-reset-tokens']);
+            remainingTokens = error_1.headers['x-ratelimit-remaining-tokens'];
+            delayMs = 15000;
+            logger.warn(
+              'Waiting to retry in '
+                .concat(delayMs / 1000, 's, token reset in: ')
+                .concat(waitTime, 's, remaining tokens: ')
+                .concat(remainingTokens)
+            );
+            return [4 /*yield*/, delay(delayMs)];
+          case 4:
+            _a.sent();
+            return [4 /*yield*/, OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model)];
+          case 5:
+            return [2 /*return*/, _a.sent()];
+          case 6:
+            throw error_1;
+          case 7:
+            return [2 /*return*/, response];
         }
-        // remove the last '' that will become a \n
-        // we only want spaces between code blocks
-        filteredLines.pop();
-        return filteredLines.join('\n');
-    };
-    OpenAi.generateList = function (messages, model, history, functions, messageModerators, includeSystemMessages, logLevel) {
-        if (includeSystemMessages === void 0) { includeSystemMessages = true; }
-        if (logLevel === void 0) { logLevel = 'info'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var systemMessages, resolvedHistory, list;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        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 ;' },
-                        ];
-                        resolvedHistory = history ?
-                            includeSystemMessages ?
-                                history.push(systemMessages)
-                                :
-                                    history
-                            :
-                                includeSystemMessages ?
-                                    new MessageHistory_1.MessageHistory().push(systemMessages)
-                                    :
-                                        undefined;
-                        return [4 /*yield*/, this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel)];
-                    case 1:
-                        list = _a.sent();
-                        return [2 /*return*/, list.split(';').map(function (item) { return item.trim(); })];
-                }
+      });
+    });
+  };
+  OpenAi.callFunction = function (logLevel, functionCall, functions) {
+    return __awaiter(this, void 0, void 0, function () {
+      var logger, warning, message, f, warning, message, returnObject, _a, _b, error_2;
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            logger = new util_1.Logger('OpenAi.callFunction', logLevel);
+            if (!functions) {
+              warning = 'Assistant attempted to call a function when no functions were provided';
+              logger.warn(warning);
+              message = { role: 'user', content: warning };
+              return [2 /*return*/, message];
+            }
+            functionCall.name = functionCall.name.split('.').pop();
+            f = functions.find(function (f) {
+              return f.definition.name === functionCall.name;
             });
-        });
-    };
-    return OpenAi;
-}());
+            if (!f) {
+              warning = 'Assistant attempted to call nonexistent function: '.concat(functionCall.name);
+              logger.warn(warning);
+              message = { role: 'user', content: warning };
+              return [2 /*return*/, message];
+            }
+            returnObject = null;
+            _c.label = 1;
+          case 1:
+            _c.trys.push([1, 3, , 4]);
+            logger.info(
+              'Assistant calling function: '.concat(f.definition.name, '(').concat(functionCall.arguments, ')')
+            );
+            _b = (_a = JSON).stringify;
+            return [4 /*yield*/, f.call(JSON.parse(functionCall.arguments))];
+          case 2:
+            returnObject = _b.apply(_a, [_c.sent()]);
+            logger.info(
+              'Assistant called function: '
+                .concat(f.definition.name, '(')
+                .concat(functionCall.arguments, ') => ')
+                .concat(returnObject),
+              1000
+            );
+            return [3 /*break*/, 4];
+          case 3:
+            error_2 = _c.sent();
+            logger.error(error_2.message);
+            return [3 /*break*/, 4];
+          case 4:
+            if (!returnObject) {
+              return [2 /*return*/];
+            }
+            return [
+              2 /*return*/,
+              {
+                role: 'function',
+                name: f.definition.name,
+                content: returnObject,
+              },
+            ];
+        }
+      });
+    });
+  };
+  OpenAi.generateCode = function (
+    messages,
+    model,
+    history,
+    functions,
+    messageModerators,
+    includeSystemMessages,
+    logLevel
+  ) {
+    if (includeSystemMessages === void 0) {
+      includeSystemMessages = true;
+    }
+    if (logLevel === void 0) {
+      logLevel = 'info';
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      var systemMessages, resolvedHistory, code;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            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.' },
+            ];
+            resolvedHistory = history
+              ? includeSystemMessages
+                ? history.push(systemMessages)
+                : history
+              : includeSystemMessages
+                ? new MessageHistory_1.MessageHistory().push(systemMessages)
+                : undefined;
+            return [
+              4 /*yield*/,
+              this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel),
+            ];
+          case 1:
+            code = _a.sent();
+            return [2 /*return*/, this.parseCodeFromMarkdown(code)];
+        }
+      });
+    });
+  };
+  OpenAi.updateCode = function (
+    code,
+    description,
+    model,
+    history,
+    functions,
+    messageModerators,
+    includeSystemMessages,
+    logLevel
+  ) {
+    if (includeSystemMessages === void 0) {
+      includeSystemMessages = true;
+    }
+    if (logLevel === void 0) {
+      logLevel = 'info';
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [
+              4 /*yield*/,
+              this.generateCode(
+                [this.updateCodeDescription(code, description)],
+                model,
+                history,
+                functions,
+                messageModerators,
+                includeSystemMessages,
+                logLevel
+              ),
+            ];
+          case 1:
+            return [2 /*return*/, _a.sent()];
+        }
+      });
+    });
+  };
+  OpenAi.updateCodeDescription = function (code, description) {
+    return 'Update this code:\n\n'.concat(code, '\n\n').concat(description);
+  };
+  OpenAi.parseCodeFromMarkdown = function (code) {
+    if (!code.match(/```([\s\S]+?)```/g)) {
+      return code;
+    }
+    var filteredLines = [];
+    var inCodeBlock = false;
+    for (var _i = 0, _a = code.split('\n'); _i < _a.length; _i++) {
+      var line = _a[_i];
+      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');
+  };
+  OpenAi.generateList = function (
+    messages,
+    model,
+    history,
+    functions,
+    messageModerators,
+    includeSystemMessages,
+    logLevel
+  ) {
+    if (includeSystemMessages === void 0) {
+      includeSystemMessages = true;
+    }
+    if (logLevel === void 0) {
+      logLevel = 'info';
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      var systemMessages, resolvedHistory, list;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            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 ;' },
+            ];
+            resolvedHistory = history
+              ? includeSystemMessages
+                ? history.push(systemMessages)
+                : history
+              : includeSystemMessages
+                ? new MessageHistory_1.MessageHistory().push(systemMessages)
+                : undefined;
+            return [
+              4 /*yield*/,
+              this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel),
+            ];
+          case 1:
+            list = _a.sent();
+            return [
+              2 /*return*/,
+              list.split(';').map(function (item) {
+                return item.trim();
+              }),
+            ];
+        }
+      });
+    });
+  };
+  return OpenAi;
+})();
 exports.OpenAi = OpenAi;
-//# sourceMappingURL=OpenAi.js.map
+//# sourceMappingURL=OpenAi.js.map