Merge branch 'danny-avila:main' into main

api/cache/getLogStores.js

@@ -1,7 +1,8 @@
 const Keyv = require('keyv');
 const keyvMongo = require('./keyvMongo');
 const keyvRedis = require('./keyvRedis');
-const { math, isEnabled } = require('../server/utils');
+const { CacheKeys } = require('~/common/enums');
+const { math, isEnabled } = require('~/server/utils');
 const { logFile, violationFile } = require('./keyvFiles');
 const { BAN_DURATION, USE_REDIS } = process.env ?? {};
 
@@ -17,7 +18,12 @@ const pending_req = isEnabled(USE_REDIS)
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: 'pending_req' });
 
+const config = isEnabled(USE_REDIS)
+  ? new Keyv({ store: keyvRedis })
+  : new Keyv({ namespace: CacheKeys.CONFIG });
+
 const namespaces = {
+  config,
   pending_req,
   ban: new Keyv({ store: keyvMongo, namespace: 'bans', ttl: duration }),
   general: new Keyv({ store: logFile, namespace: 'violations' }),

api/common/enums.js

@@ -0,0 +1,15 @@
+/**
+ * @typedef {Object} CacheKeys
+ * @property {'config'} CONFIG - Key for the config cache.
+ * @property {'modelsConfig'} MODELS_CONFIG - Key for the model config cache.
+ * @property {'defaultConfig'} DEFAULT_CONFIG - Key for the default config cache.
+ * @property {'overrideConfig'} OVERRIDE_CONFIG - Key for the override config cache.
+ */
+const CacheKeys = {
+  CONFIG: 'config',
+  MODELS_CONFIG: 'modelsConfig',
+  DEFAULT_CONFIG: 'defaultConfig',
+  OVERRIDE_CONFIG: 'overrideConfig',
+};
+
+module.exports = { CacheKeys };

api/models/Preset.js

@@ -14,24 +14,53 @@ module.exports = {
   getPreset,
   getPresets: async (user, filter) => {
     try {
-      return await Preset.find({ ...filter, user }).lean();
+      const presets = await Preset.find({ ...filter, user }).lean();
+      const defaultValue = 10000;
+
+      presets.sort((a, b) => {
+        let orderA = a.order !== undefined ? a.order : defaultValue;
+        let orderB = b.order !== undefined ? b.order : defaultValue;
+
+        if (orderA !== orderB) {
+          return orderA - orderB;
+        }
+
+        return b.updatedAt - a.updatedAt;
+      });
+
+      return presets;
     } catch (error) {
       console.log(error);
       return { message: 'Error retrieving presets' };
     }
   },
-  savePreset: async (user, { presetId, newPresetId, ...preset }) => {
+  savePreset: async (user, { presetId, newPresetId, defaultPreset, ...preset }) => {
     try {
+      const setter = { $set: {} };
       const update = { presetId, ...preset };
       if (newPresetId) {
         update.presetId = newPresetId;
       }
 
-      return await Preset.findOneAndUpdate(
-        { presetId, user },
-        { $set: update },
-        { new: true, upsert: true },
-      );
+      if (defaultPreset) {
+        update.defaultPreset = defaultPreset;
+        update.order = 0;
+
+        const currentDefault = await Preset.findOne({ defaultPreset: true, user });
+
+        if (currentDefault && currentDefault.presetId !== presetId) {
+          await Preset.findByIdAndUpdate(currentDefault._id, {
+            $unset: { defaultPreset: '', order: '' },
+          });
+        }
+      } else if (defaultPreset === false) {
+        update.defaultPreset = undefined;
+        update.order = undefined;
+        setter['$unset'] = { defaultPreset: '', order: '' };
+      }
+
+      setter.$set = update;
+      return await Preset.findOneAndUpdate({ presetId, user }, setter, { new: true, upsert: true });
     } catch (error) {
       console.log(error);
       return { message: 'Error saving preset' };

api/models/schema/presetSchema.js

@@ -17,6 +17,12 @@ const presetSchema = mongoose.Schema(
       type: String,
       default: null,
     },
+    defaultPreset: {
+      type: Boolean,
+    },
+    order: {
+      type: Number,
+    },
     // google only
     examples: [{ type: mongoose.Schema.Types.Mixed }],
     ...conversationPreset,

api/server/controllers/EndpointController.js

@@ -1,95 +1,17 @@
-const { EModelEndpoint } = require('~/server/routes/endpoints/schemas');
-const { availableTools } = require('~/app/clients/tools');
-const { addOpenAPISpecs } = require('~/app/clients/tools/util/addOpenAPISpecs');
-const {
-  openAIApiKey,
-  azureOpenAIApiKey,
-  useAzurePlugins,
-  userProvidedOpenAI,
-  palmKey,
-  openAI,
-  // assistant,
-  azureOpenAI,
-  bingAI,
-  chatGPTBrowser,
-  anthropic,
-} = require('~/server/services/EndpointService').config;
+const { getLogStores } = require('~/cache');
+const { CacheKeys } = require('~/common/enums');
+const { loadDefaultEndpointsConfig } = require('~/server/services/Config');
 
-let i = 0;
 async function endpointController(req, res) {
-  let key, palmUser;
-  try {
-    key = require('~/data/auth.json');
-  } catch (e) {
-    if (i === 0) {
-      i++;
-    }
+  const cache = getLogStores(CacheKeys.CONFIG);
+  const config = await cache.get(CacheKeys.DEFAULT_CONFIG);
+  if (config) {
+    res.send(config);
+    return;
   }
-
-  if (palmKey === 'user_provided') {
-    palmUser = true;
-    if (i <= 1) {
-      i++;
-    }
-  }
-
-  const tools = await addOpenAPISpecs(availableTools);
-  function transformToolsToMap(tools) {
-    return tools.reduce((map, obj) => {
-      map[obj.pluginKey] = obj.name;
-      return map;
-    }, {});
-  }
-  const plugins = transformToolsToMap(tools);
-
-  const google = key || palmUser ? { userProvide: palmUser } : false;
-
-  const gptPlugins =
-    openAIApiKey || azureOpenAIApiKey
-      ? {
-        plugins,
-        availableAgents: ['classic', 'functions'],
-        userProvide: userProvidedOpenAI,
-        azure: useAzurePlugins,
-      }
-      : false;
-
-  let enabledEndpoints = [
-    EModelEndpoint.openAI,
-    EModelEndpoint.azureOpenAI,
-    EModelEndpoint.google,
-    EModelEndpoint.bingAI,
-    EModelEndpoint.chatGPTBrowser,
-    EModelEndpoint.gptPlugins,
-    EModelEndpoint.anthropic,
-  ];
-
-  const endpointsEnv = process.env.ENDPOINTS || '';
-  if (endpointsEnv) {
-    enabledEndpoints = endpointsEnv
-      .split(',')
-      .filter((endpoint) => endpoint?.trim())
-      .map((endpoint) => endpoint.trim());
-  }
-
-  const endpointConfig = {
-    [EModelEndpoint.openAI]: openAI,
-    [EModelEndpoint.azureOpenAI]: azureOpenAI,
-    [EModelEndpoint.google]: google,
-    [EModelEndpoint.bingAI]: bingAI,
-    [EModelEndpoint.chatGPTBrowser]: chatGPTBrowser,
-    [EModelEndpoint.gptPlugins]: gptPlugins,
-    [EModelEndpoint.anthropic]: anthropic,
-  };
-
-  const orderedAndFilteredEndpoints = enabledEndpoints.reduce((config, key, index) => {
-    if (endpointConfig[key]) {
-      config[key] = { ...(endpointConfig[key] ?? {}), order: index };
-    }
-    return config;
-  }, {});
-
-  res.send(JSON.stringify(orderedAndFilteredEndpoints));
+  const defaultConfig = await loadDefaultEndpointsConfig();
+  await cache.set(CacheKeys.DEFAULT_CONFIG, defaultConfig);
+  res.send(JSON.stringify(defaultConfig));
 }
 
 module.exports = endpointController;

api/server/controllers/ModelController.js

@@ -1,35 +1,17 @@
-const { EModelEndpoint } = require('../routes/endpoints/schemas');
-const {
-  getOpenAIModels,
-  getChatGPTBrowserModels,
-  getAnthropicModels,
-} = require('../services/ModelService');
-
-const { useAzurePlugins } = require('../services/EndpointService').config;
-
-const fitlerAssistantModels = (str) => {
-  return /gpt-4|gpt-3\\.5/i.test(str) && !/vision|instruct/i.test(str);
-};
+const { getLogStores } = require('~/cache');
+const { CacheKeys } = require('~/common/enums');
+const { loadDefaultModels } = require('~/server/services/Config');
 
 async function modelController(req, res) {
-  const openAI = await getOpenAIModels();
-  const azureOpenAI = await getOpenAIModels({ azure: true });
-  const gptPlugins = await getOpenAIModels({ azure: useAzurePlugins, plugins: true });
-  const chatGPTBrowser = getChatGPTBrowserModels();
-  const anthropic = getAnthropicModels();
-
-  res.send(
-    JSON.stringify({
-      [EModelEndpoint.openAI]: openAI,
-      [EModelEndpoint.azureOpenAI]: azureOpenAI,
-      [EModelEndpoint.assistant]: openAI.filter(fitlerAssistantModels),
-      [EModelEndpoint.google]: ['chat-bison', 'text-bison', 'codechat-bison'],
-      [EModelEndpoint.bingAI]: ['BingAI', 'Sydney'],
-      [EModelEndpoint.chatGPTBrowser]: chatGPTBrowser,
-      [EModelEndpoint.gptPlugins]: gptPlugins,
-      [EModelEndpoint.anthropic]: anthropic,
-    }),
-  );
+  const cache = getLogStores(CacheKeys.CONFIG);
+  let modelConfig = await cache.get(CacheKeys.MODELS_CONFIG);
+  if (modelConfig) {
+    res.send(modelConfig);
+    return;
+  }
+  modelConfig = await loadDefaultModels();
+  await cache.set(CacheKeys.MODELS_CONFIG, modelConfig);
+  res.send(modelConfig);
 }
 
 module.exports = modelController;

api/server/controllers/OverrideController.js

@@ -0,0 +1,27 @@
+const { getLogStores } = require('~/cache');
+const { CacheKeys } = require('~/common/enums');
+const { loadOverrideConfig } = require('~/server/services/Config');
+
+async function overrideController(req, res) {
+  const cache = getLogStores(CacheKeys.CONFIG);
+  let overrideConfig = await cache.get(CacheKeys.OVERRIDE_CONFIG);
+  if (overrideConfig) {
+    res.send(overrideConfig);
+    return;
+  } else if (overrideConfig === false) {
+    res.send(false);
+    return;
+  }
+  overrideConfig = await loadOverrideConfig();
+  const { endpointsConfig, modelsConfig } = overrideConfig;
+  if (endpointsConfig) {
+    await cache.set(CacheKeys.DEFAULT_CONFIG, endpointsConfig);
+  }
+  if (modelsConfig) {
+    await cache.set(CacheKeys.MODELS_CONFIG, modelsConfig);
+  }
+  await cache.set(CacheKeys.OVERRIDE_CONFIG, overrideConfig);
+  res.send(JSON.stringify(overrideConfig));
+}
+
+module.exports = overrideController;

api/server/index.js

@@ -71,9 +71,8 @@ const startServer = async () => {
   app.use('/api/assistants', routes.assistants);
   app.use('/api/files', routes.files);
 
-  // Static files
-  app.get('/*', function (req, res) {
-    res.sendFile(path.join(projectPath, 'dist', 'index.html'));
+  app.use((req, res) => {
+    res.status(404).sendFile(path.join(projectPath, 'dist', 'index.html'));
   });
 
   app.listen(port, host, () => {

api/server/routes/endpoints.js

@@ -1,7 +1,9 @@
 const express = require('express');
 const router = express.Router();
-const endpointController = require('../controllers/EndpointController');
+const endpointController = require('~/server/controllers/EndpointController');
+const overrideController = require('~/server/controllers/OverrideController');
 
 router.get('/', endpointController);
+router.get('/config/override', overrideController);
 
 module.exports = router;

api/server/routes/presets.js

@@ -5,9 +5,7 @@ const crypto = require('crypto');
 const requireJwtAuth = require('../middleware/requireJwtAuth');
 
 router.get('/', requireJwtAuth, async (req, res) => {
-  const presets = (await getPresets(req.user.id)).map((preset) => {
-    return preset;
-  });
+  const presets = (await getPresets(req.user.id)).map((preset) => preset);
   res.status(200).send(presets);
 });
 
@@ -17,12 +15,8 @@ router.post('/', requireJwtAuth, async (req, res) => {
   update.presetId = update?.presetId || crypto.randomUUID();
 
   try {
-    await savePreset(req.user.id, update);
-
-    const presets = (await getPresets(req.user.id)).map((preset) => {
-      return preset;
-    });
-    res.status(201).send(presets);
+    const preset = await savePreset(req.user.id, update);
+    res.status(201).send(preset);
   } catch (error) {
     console.error(error);
     res.status(500).send(error);
@@ -31,7 +25,7 @@ router.post('/', requireJwtAuth, async (req, res) => {
 
 router.post('/delete', requireJwtAuth, async (req, res) => {
   let filter = {};
-  const { presetId } = req.body.arg || {};
+  const { presetId } = req.body || {};
 
   if (presetId) {
     filter = { presetId };
@@ -40,9 +34,8 @@ router.post('/delete', requireJwtAuth, async (req, res) => {
   console.log('delete preset filter', filter);
 
   try {
-    await deletePresets(req.user.id, filter);
-    const presets = await getPresets(req.user.id);
-    res.status(201).send(presets);
+    const deleteCount = await deletePresets(req.user.id, filter);
+    res.status(201).send(deleteCount);
   } catch (error) {
     console.error(error);
     res.status(500).send(error);

api/server/services/EndpointService.js → api/server/services/Config/EndpointService.js

@@ -1,4 +1,4 @@
-const { EModelEndpoint } = require('../routes/endpoints/schemas');
+const { EModelEndpoint } = require('~/server/routes/endpoints/schemas');
 
 const {
   OPENAI_API_KEY: openAIApiKey,

api/server/services/Config/index.js

@@ -0,0 +1,13 @@
+const { config } = require('./EndpointService');
+const loadDefaultModels = require('./loadDefaultModels');
+const loadOverrideConfig = require('./loadOverrideConfig');
+const loadAsyncEndpoints = require('./loadAsyncEndpoints');
+const loadDefaultEndpointsConfig = require('./loadDefaultEConfig');
+
+module.exports = {
+  config,
+  loadDefaultModels,
+  loadOverrideConfig,
+  loadAsyncEndpoints,
+  loadDefaultEndpointsConfig,
+};