backend-manager 3.2.85 → 3.2.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "3.2.85",
+  "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",
@@ -71,4 +71,4 @@
     "wonderful-log": "^1.0.5",
     "yargs": "^17.7.2"
   }
-}
+}

package/src/manager/helpers/assistant.js

@@ -349,7 +349,7 @@ BackendAssistant.prototype.errorify = function (e, options) {
   // Construct error
   const newError = e instanceof Error
     ? e
-    : new Error(stringify(e));
+    : new Error(stringifyNonStrings(e));
 
   // Fix code
   // options.code = newError.code || options.code;
@@ -474,7 +474,7 @@ function isBetween(value, min, max) {
   return value >= min && value <= max;
 }
 
-function stringify(e) {
+function stringifyNonStrings(e) {
   if (typeof e === 'string') {
     return e;
   } else {
@@ -942,30 +942,33 @@ BackendAssistant.prototype.parseMultipartFormData = function (options) {
   });
 }
 
-function stringify(obj, replacer, spaces, cycleReplacer) {
-  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
-}
-
-// https://github.com/moll/json-stringify-safe/blob/master/stringify.js
-function serializer(replacer, cycleReplacer) {
-  var stack = [], keys = []
-
-  if (cycleReplacer == null) cycleReplacer = function(key, value) {
-    if (stack[0] === value) return '[Circular ~]'
-    return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`;
-  }
-
-  return function(key, value) {
-    if (stack.length > 0) {
-      var thisPos = stack.indexOf(this)
-      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
-      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
-      if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
-    }
-    else stack.push(value)
-
-    return replacer == null ? value : replacer.call(this, key, value)
-  }
-}
+// Not sure what this is for? But it has a good serializer code
+// Disabled 2024-03-21 because there was another stringify() function that i was intending to use but it was actually using this
+// It was adding escaped quotes to strings
+// function stringify(obj, replacer, spaces, cycleReplacer) {
+//   return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
+// }
+
+// // https://github.com/moll/json-stringify-safe/blob/master/stringify.js
+// function serializer(replacer, cycleReplacer) {
+//   var stack = [], keys = []
+
+//   if (cycleReplacer == null) cycleReplacer = function(key, value) {
+//     if (stack[0] === value) return '[Circular ~]'
+//     return `[Circular ~.${keys.slice(0, stack.indexOf(value)).join('.')}]`;
+//   }
+
+//   return function(key, value) {
+//     if (stack.length > 0) {
+//       var thisPos = stack.indexOf(this)
+//       ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
+//       ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+//       if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
+//     }
+//     else stack.push(value)
+
+//     return replacer == null ? value : replacer.call(this, key, value)
+//   }
+// }
 
 module.exports = BackendAssistant;

package/src/manager/helpers/middleware.js

@@ -34,6 +34,7 @@ Middleware.prototype.run = function (libPath, options) {
     options.setupAnalytics = typeof options.setupAnalytics === 'boolean' ? options.setupAnalytics : true;
     options.setupUsage = typeof options.setupUsage === 'boolean' ? options.setupUsage : true;
     options.setupSettings = typeof options.setupSettings === 'undefined' ? true : options.setupSettings;
+    options.cleanSettings = typeof options.cleanSettings === 'undefined' ? true : options.cleanSettings;
     options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
 
     // Log
@@ -80,12 +81,19 @@ Middleware.prototype.run = function (libPath, options) {
     if (options.setupSettings) {
       // assistant.log(`Middleware.process(): Resolving settings with schema ${options.schema}...`);
 
+      // Resolve settings
       try {
         assistant.settings = Manager.Settings().resolve(assistant, options.schema, data);
       } catch (e) {
         return assistant.respond(new Error(`Unable to resolve schema ${options.schema}: ${e.message}`), {code: 500, sentry: true});
       }
 
+      // Clean settings by looping through and trimming all strings
+      if (options.cleanSettings) {
+        clean(assistant.settings);
+      }
+
+      // Log
       assistant.log(`Middleware.process(): Resolved settings with schema ${options.schema}`, JSON.stringify(assistant.settings));
     }
 
@@ -106,4 +114,15 @@ Middleware.prototype.run = function (libPath, options) {
   });
 };
 
+function clean(obj) {
+  for (let key in obj) {
+    if (typeof obj[key] === 'object') {
+      clean(obj[key]);
+    } else if (typeof obj[key] === 'string') {
+      obj[key] = obj[key]
+        .trim();
+    }
+  }
+}
+
 module.exports = Middleware;

package/src/manager/helpers/settings.js

@@ -42,22 +42,36 @@ Settings.prototype.resolve = function (assistant, schema, settings) {
   // Resolve settings
   self.settings = powertools.defaults(settings, schema);
 
-  // Check for missing required keys
-  powertools.getKeys(schema).forEach((key) => {
-    const isRequired = key.endsWith('.required') ? _.get(schema, key, false) : false;
+  // Iterate each key and check for some things
+  processSchema(schema, (path, schemaNode) => {
+    const originalValue = _.get(settings, path);
+    const resolvedValue = _.get(self.settings, path);
+    let replaceValue = undefined;
+
+    // assistant.log('Found:', path, schemaNode);
+    // assistant.log('originalValue:', originalValue);
+    // assistant.log('resolvedValue:', resolvedValue);
+
+    // Check if this node is marked as required
+    if (schemaNode.required && typeof originalValue === 'undefined') {
+      throw assistant.errorify(`Required key {${path}} is missing in settings`, {code: 400});
+    }
 
-    // Skip if not required
-    if (!isRequired) {
-      return;
+    // Clean
+    if (schemaNode.clean) {
+      if (schemaNode.clean instanceof RegExp) {
+        replaceValue = resolvedValue.replace(schemaNode.clean, '');
+      } else if (typeof schemaNode.clean === 'function') {
+        replaceValue = schemaNode.clean(resolvedValue);
+      }
     }
 
-    // Use regex to replace '.required' only if it's at the end of the string
-    const settingsKey = key.replace(/\.required$/, '');
+    // assistant.log('replaceValue:', replaceValue);
 
-    // Check if the required key is missing
-    if (typeof _.get(settings, settingsKey, undefined) === 'undefined') {
-      // Handle the missing required key as needed
-      throw assistant.errorify(`Required key '${settingsKey}' is missing in settings`, {code: 400});
+    // Replace
+    if (typeof replaceValue !== 'undefined' && replaceValue !== resolvedValue) {
+      assistant.warn(`Replacing ${path}: originalValue=${originalValue}, resolvedValue=${resolvedValue}, replaceValue=${replaceValue}`);
+      _.set(self.settings, path, replaceValue);
     }
   });
 
@@ -92,6 +106,23 @@ Settings.prototype.constant = function (name, options) {
   }
 };
 
+function processSchema(schema, fn, path) {
+  path = path || '';
+
+  // Base case: Check if the current level has 'types' and 'default', indicating metadata
+  if (schema.hasOwnProperty('types') && schema.hasOwnProperty('default')) {
+    // Call the processing function with the current path and schema as arguments
+    fn(path, schema);
+    return;
+  }
+
+  // Recursive case: Iterate through nested keys if we're not at a metadata node
+  Object.keys(schema).forEach(key => {
+    const nextPath = path ? `${path}.${key}` : key;
+    processSchema(schema[key], fn, nextPath);
+  });
+}
+
 function loadSchema(assistant, schema, settings) {
   const planId = assistant.request.user.plan.id;
 

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;