backend-manager 3.2.12 → 3.2.13

package/package.json

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

package/src/manager/index.js

@@ -389,39 +389,39 @@ Manager.prototype.init = function (exporter, options) {
       self.libraries.functions
       .runWith({memory: '256MB', timeoutSeconds: 60})
       .auth.user()
-      .beforeCreate(async (user, context) => self._process((new (require(`${core}/events/auth/before-create.js`))(), {middleware: false}).init(self, { user: user, context: context})));
+      .beforeCreate(async (user, context) => self._process((new (require(`${core}/events/auth/before-create.js`))()).init(self, { user: user, context: context})));
 
       exporter.bm_authBeforeSignIn =
       self.libraries.functions
       .runWith({memory: '256MB', timeoutSeconds: 60})
       .auth.user()
-      .beforeSignIn(async (user, context) => self._process((new (require(`${core}/events/auth/before-signin.js`))(), {middleware: false}).init(self, { user: user, context: context})));
+      .beforeSignIn(async (user, context) => self._process((new (require(`${core}/events/auth/before-signin.js`))()).init(self, { user: user, context: context})));
     }
 
     exporter.bm_authOnCreate =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
     .auth.user()
-    .onCreate(async (user, context) => self._process((new (require(`${core}/events/auth/on-create.js`))(), {middleware: false}).init(self, { user: user, context: context})));
+    .onCreate(async (user, context) => self._process((new (require(`${core}/events/auth/on-create.js`))()).init(self, { user: user, context: context})));
 
     exporter.bm_authOnDelete =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
     .auth.user()
-    .onDelete(async (user, context) => self._process((new (require(`${core}/events/auth/on-delete.js`))(), {middleware: false}).init(self, { user: user, context: context})));
+    .onDelete(async (user, context) => self._process((new (require(`${core}/events/auth/on-delete.js`))()).init(self, { user: user, context: context})));
 
     exporter.bm_subOnWrite =
     self.libraries.functions
     .runWith({memory: '256MB', timeoutSeconds: 60})
     .firestore.document('notifications/subscriptions/all/{token}')
-    .onWrite(async (change, context) => self._process((new (require(`${core}/events/firestore/on-subscription.js`))(), {middleware: false}).init(self, { change: change, context: context, })));
+    .onWrite(async (change, context) => self._process((new (require(`${core}/events/firestore/on-subscription.js`))()).init(self, { change: change, context: context, })));
 
     // Cron
     exporter.bm_cronDaily =
     self.libraries.functions
     .runWith({ memory: '256MB', timeoutSeconds: 120 })
     .pubsub.schedule('every 24 hours')
-    .onRun(async (context) => self._process((new (require(`${core}/cron/daily.js`))(), {middleware: false}).init(self, { context: context, })));
+    .onRun(async (context) => self._process((new (require(`${core}/cron/daily.js`))()).init(self, { context: context, })));
   }
 
   // Set dotenv

package/src/manager/libraries/openai.js

@@ -0,0 +1,130 @@
+const fetch = require('wonderful-fetch');
+const powertools = require('node-powertools');
+
+function OpenAI(assistant, key) {
+  const self = this;
+
+  self.assistant = assistant;
+  self.Manager = assistant.Manager;
+  self.user = assistant.user;
+  self.key = key;
+
+  return self;
+}
+
+OpenAI.prototype.request = function (options, messages, template) {
+  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;
+
+    // Load prompt
+    options.prompt = powertools.template(
+      jetpack.read(`${__dirname}/prompts/${options.prompt}.md`),
+      template,
+    );
+
+    // assistant.log('callOpenAI():', options);
+    assistant.log('callOpenAI(): Starting', options);
+
+    function _request(mode, options) {
+      return new Promise(async function(resolve, reject) {
+        let resultPath = '';
+        const request = {
+          url: '',
+          method: 'post',
+          response: 'json',
+          // log: true,
+          tries: 1,
+          timeout: options.timeout,
+          headers: {
+            'Authorization': `Bearer ${Manager.config.openai.key}`,
+          },
+          body: {},
+        }
+
+        if (mode === 'chatgpt') {
+          request.url = 'https://api.openai.com/v1/chat/completions';
+          messages = messages.slice(-MAX_MESSAGE_LENGTH);
+          messages.unshift({
+            role: 'system',
+            content: options.prompt,
+          });
+          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,
+          }
+          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,
+          }
+          resultPath = 'results[0]';
+        }
+
+        // Request
+        await fetch(request.url, request)
+        .then((r) => {
+          // Set token counts
+          self.tokens.total.count += r?.usage?.total_tokens || 0;
+          self.tokens.input.count += r?.usage?.prompt_tokens || 0;
+          self.tokens.output.count += r?.usage?.completion_tokens || 0;
+
+          // Set token prices
+          self.tokens.total.price = (self.tokens.total.count / 1000) * TOKEN_COST_TABLE[options.model].input;
+          self.tokens.input.price = (self.tokens.input.count / 1000) * TOKEN_COST_TABLE[options.model].input;
+          self.tokens.output.price = (self.tokens.output.count / 1000) * TOKEN_COST_TABLE[options.model].output;
+
+          return resolve(_.get(r, resultPath));
+        })
+        .catch((e) => {
+          return reject(e);
+        })
+      });
+    }
+
+    await _request('moderation', options)
+    .then(async (r) => {
+      // assistant.log('callOpenAI(): moderation', r);
+      assistant.log('callOpenAI(): Moderated');
+
+      // If the moderation is not approved, return
+      if (r.flagged) {
+        return reject(new Error('Moderation not approved'));
+      }
+
+      await _request('chatgpt', options)
+      .then((r) => {
+        try {
+          return resolve(JSON.parse(r));
+        } catch (e) {
+          return reject(e);
+        }
+      })
+      .catch((e) => reject(e));
+    })
+    .catch((e) => reject(e));
+  });
+}
+
+
+module.exports = OpenAI;