backend-manager 3.2.13 → 3.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.13",
+  "version": "3.2.15",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/manager/functions/core/actions/api/general/emails/general:download-app-link.js

@@ -14,9 +14,7 @@ module.exports = function (payload, config) {
       subject: `Free ${config.brand.name} download link for ${payload.name || 'you'}!`,
       template: 'd-1d730ac8cc544b7cbccc8fa4a4b3f9ce',
       group: 24077,
-      options: {
-        copy: false,
-      },
+      copy: false,
       data: {},
     }
   }

package/src/manager/helpers/assistant.js

@@ -330,6 +330,12 @@ BackendAssistant.prototype._log = function () {
   }
 }
 
+BackendAssistant.prototype.getUser = function () {
+  const self = this;
+
+  return self?.usage?.user || self.request.user;
+}
+
 BackendAssistant.prototype.errorify = function (e, options) {
   const self = this;
   const res = self.ref.res;

package/src/manager/helpers/middleware.js

@@ -27,6 +27,7 @@ Middleware.prototype.run = function (library, options) {
     const data = assistant.request.data;
     const geolocation = assistant.request.geolocation;
     const client = assistant.request.client;
+    const isProduction = assistant.meta.environment === 'production';
 
     // Set options
     options = options || {};
@@ -56,11 +57,11 @@ Middleware.prototype.run = function (library, options) {
 
     // Setup usage
     if (options.setupUsage) {
-      assistant.usage = await Manager.Usage().init(assistant);
+      assistant.usage = await Manager.Usage().init(assistant, {log: isProduction});
     }
 
     // Log working user
-    const workingUser = assistant?.usage?.user || assistant.request.user;
+    const workingUser = assistant.getUser();
     assistant.log(`Middleware.process(): User (${workingUser.auth.uid}, ${workingUser.auth.email}, ${workingUser.plan.id}=${workingUser.plan.status}):`, JSON.stringify(workingUser));
 
     // Setup analytics

package/src/manager/libraries/openai.js

@@ -1,5 +1,23 @@
 const fetch = require('wonderful-fetch');
+const jetpack = require('fs-jetpack');
 const powertools = require('node-powertools');
+const _ = require('lodash');
+
+const TOKEN_COST_TABLE = {
+  // Nov 6th, 2023
+  'gpt-4-1106-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4': {
+    input: 0.0300,
+    output: 0.0600,
+  },
+  'gpt-3.5-turbo': {
+    input: 0.0010,
+    output: 0.0020,
+  },
+}
 
 function OpenAI(assistant, key) {
   const self = this;
@@ -9,37 +27,71 @@ function OpenAI(assistant, key) {
   self.user = assistant.user;
   self.key = key;
 
+  self.tokens = {
+    total: {
+      count: 0,
+      price: 0,
+    },
+    input: {
+      count: 0,
+      price: 0,
+    },
+    output: {
+      count: 0,
+      price: 0,
+    },
+  }
+
   return self;
 }
 
-OpenAI.prototype.request = function (options, messages, template) {
+OpenAI.prototype.request = function (options) {
   const self = this;
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  assistant.log('callOpenAI(): Starting', self.key);
-  assistant.log('callOpenAI(): Starting', options, messages, template);
-
   return new Promise(async function(resolve, reject) {
-    options = options || {};
-    options.prompt = options.prompt || '';
-    options.timeout = options.timeout || 120000;
-    options.model = options.model || (
-      self.user.plan.id === 'basic'
-        ? BASIC_MODEL
-        : PREMIUM_MODEL
-    );
-    options.user = options.user || assistant.request.geolocation.ip;
+    options = _.merge({}, options);
 
-    // Load prompt
-    options.prompt = powertools.template(
-      jetpack.read(`${__dirname}/prompts/${options.prompt}.md`),
-      template,
-    );
+    options.model = typeof options.model === 'undefined' ? 'gpt-3.5-turbo' : options.model;
+    options.timeout = typeof options.timeout === 'undefined' ? 120000 : options.timeout;
+    options.moderate = typeof options.moderate === 'undefined' ? true : options.moderate;
+    options.user = options.user || assistant.getUser();
+
+    options.prompt = options.prompt || {};
+    options.prompt.path = options.prompt.path || '';
+    options.prompt.settings = options.prompt.settings || {};
+
+    options.message = options.message || {};
+    options.message.path = options.message.path || '';
+    options.message.settings = options.message.settings || {};
 
-    // assistant.log('callOpenAI():', options);
+    options.history = options.history || {};
+    options.history.messages = options.history.messages || [];
+    options.history.limit = typeof options.history.limit === 'undefined' ? 5 : options.history.limit;
+
+    options.response = typeof options.response === 'undefined' ? undefined : options.response;
+    options.temperature = typeof options.temperature === 'undefined' ? 0.7 : options.temperature;
+    options.maxTokens = typeof options.maxTokens === 'undefined' ? 512 : options.maxTokens;
+
+    assistant.log('callOpenAI(): Starting', self.key);
     assistant.log('callOpenAI(): Starting', options);
 
+    // Load prompt
+    const prompt = powertools.template(
+      jetpack.read(options.prompt.path),
+      options.prompt.settings,
+    ).trim();
+    const message = powertools.template(
+      jetpack.read(options.message.path),
+      options.message.settings,
+    ).trim();
+    const user = options.user?.auth?.uid || assistant.request.geolocation.ip;
+
+    assistant.log('callOpenAI(): Prompt', prompt);
+    assistant.log('callOpenAI(): Message', message);
+    assistant.log('callOpenAI(): User', user);
+
     function _request(mode, options) {
       return new Promise(async function(resolve, reject) {
         let resultPath = '';
@@ -58,25 +110,33 @@ OpenAI.prototype.request = function (options, messages, template) {
 
         if (mode === 'chatgpt') {
           request.url = 'https://api.openai.com/v1/chat/completions';
-          messages = messages.slice(-MAX_MESSAGE_LENGTH);
-          messages.unshift({
+          options.history.messages = options.history.messages.slice(-options.history.limit);
+          options.history.messages.unshift({
             role: 'system',
-            content: options.prompt,
+            content: prompt,
+          });
+          options.history.messages.push({
+            role: 'user',
+            content: message,
           });
+
+          // Log message
+          assistant.log('callOpenAI(): Messages', options.history.messages);
+
           request.body = {
             model: options.model,
-            response_format: { type: 'json_object' },
-            messages: messages,
-            temperature: 0.7, // default: 0.7
-            max_tokens: 512, // default: infinity
-            user: options.user,
+            response_format: options.response === 'json' ? { type: 'json_object' } : undefined,
+            messages: options.history.messages,
+            temperature: options.temperature,
+            max_tokens: options.maxTokens,
+            user: user,
           }
           resultPath = 'choices[0].message.content';
         } else if (mode === 'moderation') {
           request.url = 'https://api.openai.com/v1/moderations';
           request.body = {
-            input: messages.map(obj => obj.content).join('\n\nMessage:\n'),
-            user: options.user,
+            input: message,
+            user: user,
           }
           resultPath = 'results[0]';
         }
@@ -102,25 +162,39 @@ OpenAI.prototype.request = function (options, messages, template) {
       });
     }
 
-    await _request('moderation', options)
-    .then(async (r) => {
-      // assistant.log('callOpenAI(): moderation', r);
-      assistant.log('callOpenAI(): Moderated');
+    // Moderate if needed
+    let moderation = null;
+    if (options.moderate) {
+      moderation = await _request('moderation', options)
+      .then(async (r) => {
+        assistant.log('callOpenAI(): Moderated', r);
 
-      // If the moderation is not approved, return
-      if (r.flagged) {
-        return reject(new Error('Moderation not approved'));
-      }
+        // Save moderation
+        self.moderation = r;
 
-      await _request('chatgpt', options)
-      .then((r) => {
-        try {
-          return resolve(JSON.parse(r));
-        } catch (e) {
-          return reject(e);
-        }
+        return r;
       })
-      .catch((e) => reject(e));
+      .catch((e) => e);
+
+      if (moderation.flagged) {
+        return reject(assistant.errorify(`This request is inappropriate`, {code: 400, sentry: false, send: false, log: false}));
+      }
+    }
+
+    // Request
+    await _request('chatgpt', options)
+    .then((r) => {
+      try {
+        const content = options.response === 'json' ? JSON.parse(r) : r;
+
+        return resolve({
+          content: content,
+          tokens: self.tokens,
+          moderation: moderation,
+        })
+      } catch (e) {
+        return reject(e);
+      }
     })
     .catch((e) => reject(e));
   });