backend-manager 3.2.86 → 3.2.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.86",
+  "version": "3.2.87",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -35,7 +35,7 @@
   "homepage": "https://itwcreativeworks.com",
   "dependencies": {
     "@firebase/rules-unit-testing": "^2.0.7",
-    "@google-cloud/storage": "^7.8.0",
+    "@google-cloud/storage": "^7.9.0",
     "@sendgrid/mail": "^7.7.0",
     "@sentry/node": "^6.19.7",
     "busboy": "^1.6.0",
@@ -43,7 +43,7 @@
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "firebase-admin": "^11.11.1",
-    "firebase-functions": "^4.8.0",
+    "firebase-functions": "^4.8.2",
     "fs-jetpack": "^5.1.0",
     "hcaptcha": "^0.1.1",
     "inquirer": "^8.2.5",
@@ -56,11 +56,11 @@
     "moment": "^2.30.1",
     "nanoid": "^3.3.7",
     "node-fetch": "^2.7.0",
-    "node-powertools": "^1.4.0",
+    "node-powertools": "^1.4.1",
     "npm-api": "^1.0.1",
     "paypal-server-api": "^2.0.0",
     "pushid": "^1.0.0",
-    "resolve-account": "^1.0.14",
+    "resolve-account": "^1.0.18",
     "semver": "^7.6.0",
     "shortid": "^2.2.16",
     "sizeitup": "^1.0.7",

package/src/manager/libraries/openai copy.js

@@ -0,0 +1,326 @@
+const fetch = require('wonderful-fetch');
+const jetpack = require('fs-jetpack');
+const powertools = require('node-powertools');
+const _ = require('lodash');
+const JSON5 = require('json5');
+
+const TOKEN_COST_TABLE = {
+  // Mar 6th, 2024
+  'gpt-4-turbo-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4-1106-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
+  'gpt-4': {
+    input: 0.0300,
+    output: 0.0600,
+  },
+  'gpt-3.5-turbo': {
+    input: 0.0005,
+    output: 0.0015,
+  },
+
+  // Nov 6th, 2023
+  // 'gpt-4-turbo-preview': {
+  //   input: 0.0100,
+  //   output: 0.0300,
+  // },
+  // '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;
+
+  self.assistant = assistant;
+  self.Manager = assistant.Manager;
+  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) {
+  const self = this;
+  const Manager = self.Manager;
+  const assistant = self.assistant;
+
+  return new Promise(async function(resolve, reject) {
+    options = _.merge({}, options);
+
+    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.log = typeof options.log === 'undefined' ? false : options.log;
+    options.user = options.user || assistant.getUser();
+
+    options.retries = typeof options.retries === 'undefined' ? 0 : options.retries;
+    options.retryTriggers = typeof options.retryTriggers === 'undefined' ? ['network', 'parse'] : options.retryTriggers;
+
+    options.prompt = options.prompt || {};
+    options.prompt.path = options.prompt.path || '';
+    options.prompt.content = options.prompt.content || '';
+    options.prompt.settings = options.prompt.settings || {};
+
+    options.message = options.message || {};
+    options.message.path = options.message.path || '';
+    options.message.content = options.message.content || '';
+    options.message.settings = options.message.settings || {};
+
+    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;
+
+    let attempt = 0;
+
+    function _log() {
+      if (!options.log)  {
+        return;
+      }
+
+      assistant.log('callOpenAI():', ...arguments);
+    }
+
+    function _load(input) {
+      // console.log('*** input!!!', input.content.slice(0, 50), input.path);
+      // console.log('*** input.content', input.content.slice(0, 50));
+      // console.log('*** input.path', input.path);
+      // _log('Loading', input);
+
+      let content = '';
+
+      // Load content
+      if (input.path) {
+        const exists = jetpack.exists(input.path);
+        if (!exists) {
+          return new Error(`Path ${input.path} not found`);
+        } else if (exists === 'dir') {
+          return new Error(`Path ${input.path} is a directory`);
+        }
+
+        try {
+          content = jetpack.read(input.path);
+        } catch (e) {
+          return new Error(`Error reading file ${input.path}: ${e}`);
+        }
+      } else {
+        content = input.content;
+      }
+
+      return powertools.template(content, input.settings).trim();
+    }
+
+    // Log
+    _log('Starting', self.key, options);
+
+    // Load prompt
+    const prompt = _load(options.prompt);
+    const message = _load(options.message);
+    const user = options.user?.auth?.uid || assistant.request.geolocation.ip;
+    const responseFormat = options.response === 'json' && !options.model.includes('gpt-3.5')
+      ? { type: 'json_object' }
+      : undefined;
+
+    // Log
+    _log('Prompt', prompt);
+    _log('Message', message);
+    _log('User', user);
+
+    // Check for errors
+    if (prompt instanceof Error) {
+      return reject(assistant.errorify(`Error loading prompt: ${prompt}`, {code: 400}));
+    }
+
+    if (message instanceof Error) {
+      return reject(assistant.errorify(`Error loading message: ${message}`, {code: 400}));
+    }
+
+    // Format history
+    options.history.messages.forEach((m) => {
+      m.role = m.role || 'system';
+      m.content = (m.content || '').trim();
+    });
+
+    // Request
+    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';
+          options.history.messages = options.history.messages.slice(-options.history.limit);
+          options.history.messages.unshift({
+            role: 'system',
+            content: prompt,
+          });
+
+          // Set last history item
+          const lastHistory = options.history.messages[options.history.messages.length - 1];
+
+          // If message is different than last message in history, add it
+          if (lastHistory?.content !== message) {
+            options.history.messages.push({
+              role: 'user',
+              content: message,
+            });
+          }
+
+          // Log message
+          _log('Messages', options.history.messages);
+
+          request.body = {
+            model: options.model,
+            response_format: responseFormat,
+            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: message,
+            user: 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);
+        })
+      });
+    }
+
+    // Moderate if needed
+    let moderation = null;
+    if (options.moderate) {
+      moderation = await _request('moderation', options)
+      .then(async (r) => {
+        _log('Moderated', r);
+
+        return r;
+      })
+      .catch((e) => e);
+
+      // Check for moderation flag
+      if (moderation.flagged) {
+        return reject(assistant.errorify(`This request is inappropriate`, {code: 451}));
+      }
+    }
+
+    function _attempt() {
+      const retries = options.retries;
+      const triggers = options.retryTriggers;
+
+      // Increment attempt
+      attempt++;
+
+      // Log
+      _log(`Request ${attempt}/${retries}`);
+
+      // Request
+      _request('chatgpt', options)
+      .then((r) => {
+        _log('Response', r);
+
+        // Try to parse JSON response if needed
+        try {
+          const content = options.response === 'json' ? JSON5.parse(r) : r;
+
+          // Return
+          return resolve({
+            content: content,
+            tokens: self.tokens,
+            moderation: moderation,
+          })
+        } catch (e) {
+          assistant.error('Error parsing response', r, e);
+
+          // Retry
+          if (attempt < retries && triggers.includes('parse')) {
+            return _attempt();
+          }
+
+          // Return
+          return reject(e);
+        }
+      })
+      .catch((e) => {
+        assistant.error('Error requesting', e);
+
+        // Retry
+        if (attempt < retries && triggers.includes('network')) {
+          return _attempt();
+        }
+
+        // Return
+        return reject(e);
+      });
+    }
+
+    // Make attempt
+    _attempt();
+  });
+}
+
+module.exports = OpenAI;

package/src/manager/libraries/openai.js

@@ -10,6 +10,10 @@ const TOKEN_COST_TABLE = {
     input: 0.0100,
     output: 0.0300,
   },
+  'gpt-4-vision-preview': {
+    input: 0.0100,
+    output: 0.0300,
+  },
   'gpt-4-1106-preview': {
     input: 0.0100,
     output: 0.0300,
@@ -42,6 +46,12 @@ const TOKEN_COST_TABLE = {
   // },
 }
 
+const UNSUPPORTED_JSON = [
+  /gpt-3.5/,
+  /gpt-4-vision/,
+];
+
+
 function OpenAI(assistant, key) {
   const self = this;
 
@@ -87,13 +97,14 @@ OpenAI.prototype.request = function (options) {
 
     options.prompt = options.prompt || {};
     options.prompt.path = options.prompt.path || '';
-    options.prompt.content = options.prompt.content || '';
+    options.prompt.text = options.prompt.text || options.prompt.content || '';
     options.prompt.settings = options.prompt.settings || {};
 
     options.message = options.message || {};
     options.message.path = options.message.path || '';
-    options.message.content = options.message.content || '';
+    options.message.text = options.message.text || options.message.content || '';
     options.message.settings = options.message.settings || {};
+    options.message.images = options.message.images || [];
 
     options.history = options.history || {};
     options.history.messages = options.history.messages || [];
@@ -119,9 +130,9 @@ OpenAI.prototype.request = function (options) {
       // console.log('*** input.path', input.path);
       // _log('Loading', input);
 
-      let content = '';
+      let text = '';
 
-      // Load content
+      // Load text
       if (input.path) {
         const exists = jetpack.exists(input.path);
         if (!exists) {
@@ -131,27 +142,33 @@ OpenAI.prototype.request = function (options) {
         }
 
         try {
-          content = jetpack.read(input.path);
+          text = jetpack.read(input.path);
         } catch (e) {
           return new Error(`Error reading file ${input.path}: ${e}`);
         }
       } else {
-        content = input.content;
+        text = input.text;
       }
 
-      return powertools.template(content, input.settings).trim();
+      return powertools.template(text, input.settings).trim();
     }
 
     // Log
     _log('Starting', self.key, options);
 
+    // Determine response format
+    let responseFormat = options.response === 'json' ? { type: 'json_object' } : undefined;
+    if (UNSUPPORTED_JSON.some((model) => options.model.match(model))) {
+      responseFormat = undefined;
+      assistant.warn(`Model ${options.model} does not support JSON response format`);
+    }
+
+    _log('responseFormat', responseFormat);
+
     // Load prompt
     const prompt = _load(options.prompt);
     const message = _load(options.message);
     const user = options.user?.auth?.uid || assistant.request.geolocation.ip;
-    const responseFormat = options.response === 'json' && !options.model.includes('gpt-3.5')
-      ? { type: 'json_object' }
-      : undefined;
 
     // Log
     _log('Prompt', prompt);
@@ -167,12 +184,6 @@ OpenAI.prototype.request = function (options) {
       return reject(assistant.errorify(`Error loading message: ${message}`, {code: 400}));
     }
 
-    // Format history
-    options.history.messages.forEach((m) => {
-      m.role = m.role || 'system';
-      m.content = (m.content || '').trim();
-    });
-
     // Request
     function _request(mode, options) {
       return new Promise(async function(resolve, reject) {
@@ -192,30 +203,57 @@ OpenAI.prototype.request = function (options) {
 
         if (mode === 'chatgpt') {
           request.url = 'https://api.openai.com/v1/chat/completions';
-          options.history.messages = options.history.messages.slice(-options.history.limit);
-          options.history.messages.unshift({
+          const history = options.history.messages.slice(-options.history.limit);
+          history.unshift({
             role: 'system',
-            content: prompt,
+            text: prompt,
+            images: [],
           });
 
           // Set last history item
-          const lastHistory = options.history.messages[options.history.messages.length - 1];
+          const lastHistory = history[history.length - 1];
 
           // If message is different than last message in history, add it
-          if (lastHistory?.content !== message) {
-            options.history.messages.push({
+          if (lastHistory?.text !== message) {
+            history.push({
               role: 'user',
-              content: message,
+              text: message,
+              images: options.message.images,
             });
           }
 
+          // Format history
+          history.map((m) => {
+            m.role = m.role || 'system';
+            m.content = [
+              { type: 'text', text: m.text },
+            ]
+
+            // Loop through and add
+            m.images.forEach((i) => {
+              if (i.url) {
+                m.content.push({
+                  type: 'image_url',
+                  image_url: {
+                    url: i.url,
+                    detail: i.detail || 'low',
+                  }
+                });
+              }
+            }),
+
+            // Delete text and images
+            delete m.text;
+            delete m.images;
+          })
+
           // Log message
-          _log('Messages', options.history.messages);
+          _log('Messages', history);
 
           request.body = {
             model: options.model,
             response_format: responseFormat,
-            messages: options.history.messages,
+            messages: history,
             temperature: options.temperature,
             max_tokens: options.maxTokens,
             user: user,
@@ -306,7 +344,17 @@ OpenAI.prototype.request = function (options) {
         }
       })
       .catch((e) => {
-        assistant.error('Error requesting', e);
+        const parsed = tryParse(e.message)?.error || {};
+        const type = parsed?.type || '';
+        const message = parsed?.message || e.message;
+
+        // Log
+        assistant.error(`Error requesting (type=${type}, message=${message})`, e);
+
+        // Check for invalid request error
+        if (type === 'invalid_request_error') {
+          return reject(assistant.errorify(message, {code: 400}));
+        }
 
         // Retry
         if (attempt < retries && triggers.includes('network')) {
@@ -323,4 +371,12 @@ OpenAI.prototype.request = function (options) {
   });
 }
 
+function tryParse(content) {
+  try {
+    return JSON5.parse(content);
+  } catch (e) {
+    return content;
+  }
+}
+
 module.exports = OpenAI;