🚀 feat: Enhance Model Handling, Logging & xAI Agent Support (#6182)

* chore: update @librechat/agents to version 2.1.9

* feat: xAI standalone provider for agents

* chore: bump librechat-data-provider version to 0.7.6997

* fix: reorder import statements and enhance user listing output

* fix: Update Docker Compose commands to support v2 syntax with fallback

* 🔧 fix: drop `reasoning_effort` for o1-preview/mini models

* chore: requireLocalAuth logging

* fix: edge case artifact message editing logic to handle `new` conversation IDs

* fix: remove `temperature` from model options in OpenAIClient if o1-mini/preview

* fix: update type annotation for fetchPromisesMap to use Promise<string[]> instead of string[]

* feat: anthropic model fetching

* fix: update model name to use EModelEndpoint.openAI in fetchModels and fetchOpenAIModels

* fix: add error handling to modelController for loadModels

* fix: add error handling and logging for model fetching in loadDefaultModels

* ci: update getAnthropicModels tests to be asynchronous

* feat: add user ID to model options in OpenAI and custom endpoint initialization

---------

Co-authored-by: Andrei Berceanu <andreicberceanu@gmail.com>
Co-authored-by: KiGamji <maloyh44@gmail.com>

api/server/controllers/ModelController.js

@@ -1,6 +1,7 @@
 const { CacheKeys } = require('librechat-data-provider');
 const { loadDefaultModels, loadConfigModels } = require('~/server/services/Config');
 const { getLogStores } = require('~/cache');
+const { logger } = require('~/config');
 
 /**
  * @param {ServerRequest} req
@@ -36,8 +37,13 @@ async function loadModels(req) {
 }
 
 async function modelController(req, res) {
-  const modelConfig = await loadModels(req);
-  res.send(modelConfig);
+  try {
+    const modelConfig = await loadModels(req);
+    res.send(modelConfig);
+  } catch (error) {
+    logger.error('Error fetching models:', error);
+    res.status(500).send({ error: error.message });
+  }
 }
 
 module.exports = { modelController, loadModels, getModelsConfig };

api/server/middleware/requireLocalAuth.js

@@ -1,32 +1,18 @@
 const passport = require('passport');
-const DebugControl = require('../../utils/debug.js');
-
-function log({ title, parameters }) {
-  DebugControl.log.functionName(title);
-  if (parameters) {
-    DebugControl.log.parameters(parameters);
-  }
-}
+const { logger } = require('~/config');
 
 const requireLocalAuth = (req, res, next) => {
   passport.authenticate('local', (err, user, info) => {
     if (err) {
-      log({
-        title: '(requireLocalAuth) Error at passport.authenticate',
-        parameters: [{ name: 'error', value: err }],
-      });
+      logger.error('[requireLocalAuth] Error at passport.authenticate:', err);
       return next(err);
     }
     if (!user) {
-      log({
-        title: '(requireLocalAuth) Error: No user',
-      });
+      logger.debug('[requireLocalAuth] Error: No user');
       return res.status(404).send(info);
     }
     if (info && info.message) {
-      log({
-        title: '(requireLocalAuth) Error: ' + info.message,
-      });
+      logger.debug('[requireLocalAuth] Error: ' + info.message);
       return res.status(422).send({ message: info.message });
     }
     req.user = user;

api/server/services/Config/loadConfigModels.js

@@ -47,7 +47,7 @@ async function loadConfigModels(req) {
   );
 
   /**
-   * @type {Record<string, string[]>}
+   * @type {Record<string, Promise<string[]>>}
    * Map for promises keyed by unique combination of baseURL and apiKey */
   const fetchPromisesMap = {};
   /**
@@ -102,7 +102,7 @@ async function loadConfigModels(req) {
 
     for (const name of associatedNames) {
       const endpoint = endpointsMap[name];
-      modelsConfig[name] = !modelData?.length ? endpoint.models.default ?? [] : modelData;
+      modelsConfig[name] = !modelData?.length ? (endpoint.models.default ?? []) : modelData;
     }
   }
 

api/server/services/Config/loadDefaultModels.js

@@ -5,8 +5,8 @@ const {
   getGoogleModels,
   getBedrockModels,
   getAnthropicModels,
-  getChatGPTBrowserModels,
 } = require('~/server/services/ModelService');
+const { logger } = require('~/config');
 
 /**
  * Loads the default models for the application.
@@ -15,31 +15,68 @@ const {
  * @param {Express.Request} req - The Express request object.
  */
 async function loadDefaultModels(req) {
-  const google = getGoogleModels();
-  const openAI = await getOpenAIModels({ user: req.user.id });
-  const anthropic = getAnthropicModels();
-  const chatGPTBrowser = getChatGPTBrowserModels();
-  const azureOpenAI = await getOpenAIModels({ user: req.user.id, azure: true });
-  const gptPlugins = await getOpenAIModels({
-    user: req.user.id,
-    azure: useAzurePlugins,
-    plugins: true,
-  });
-  const assistants = await getOpenAIModels({ assistants: true });
-  const azureAssistants = await getOpenAIModels({ azureAssistants: true });
+  try {
+    const [
+      openAI,
+      anthropic,
+      azureOpenAI,
+      gptPlugins,
+      assistants,
+      azureAssistants,
+      google,
+      bedrock,
+    ] = await Promise.all([
+      getOpenAIModels({ user: req.user.id }).catch((error) => {
+        logger.error('Error fetching OpenAI models:', error);
+        return [];
+      }),
+      getAnthropicModels({ user: req.user.id }).catch((error) => {
+        logger.error('Error fetching Anthropic models:', error);
+        return [];
+      }),
+      getOpenAIModels({ user: req.user.id, azure: true }).catch((error) => {
+        logger.error('Error fetching Azure OpenAI models:', error);
+        return [];
+      }),
+      getOpenAIModels({ user: req.user.id, azure: useAzurePlugins, plugins: true }).catch(
+        (error) => {
+          logger.error('Error fetching Plugin models:', error);
+          return [];
+        },
+      ),
+      getOpenAIModels({ assistants: true }).catch((error) => {
+        logger.error('Error fetching OpenAI Assistants API models:', error);
+        return [];
+      }),
+      getOpenAIModels({ azureAssistants: true }).catch((error) => {
+        logger.error('Error fetching Azure OpenAI Assistants API models:', error);
+        return [];
+      }),
+      Promise.resolve(getGoogleModels()).catch((error) => {
+        logger.error('Error getting Google models:', error);
+        return [];
+      }),
+      Promise.resolve(getBedrockModels()).catch((error) => {
+        logger.error('Error getting Bedrock models:', error);
+        return [];
+      }),
+    ]);
 
-  return {
-    [EModelEndpoint.openAI]: openAI,
-    [EModelEndpoint.agents]: openAI,
-    [EModelEndpoint.google]: google,
-    [EModelEndpoint.anthropic]: anthropic,
-    [EModelEndpoint.gptPlugins]: gptPlugins,
-    [EModelEndpoint.azureOpenAI]: azureOpenAI,
-    [EModelEndpoint.chatGPTBrowser]: chatGPTBrowser,
-    [EModelEndpoint.assistants]: assistants,
-    [EModelEndpoint.azureAssistants]: azureAssistants,
-    [EModelEndpoint.bedrock]: getBedrockModels(),
-  };
+    return {
+      [EModelEndpoint.openAI]: openAI,
+      [EModelEndpoint.agents]: openAI,
+      [EModelEndpoint.google]: google,
+      [EModelEndpoint.anthropic]: anthropic,
+      [EModelEndpoint.gptPlugins]: gptPlugins,
+      [EModelEndpoint.azureOpenAI]: azureOpenAI,
+      [EModelEndpoint.assistants]: assistants,
+      [EModelEndpoint.azureAssistants]: azureAssistants,
+      [EModelEndpoint.bedrock]: bedrock,
+    };
+  } catch (error) {
+    logger.error('Error fetching default models:', error);
+    throw new Error(`Failed to load default models: ${error.message}`);
+  }
 }
 
 module.exports = loadDefaultModels;

api/server/services/Endpoints/agents/initialize.js

@@ -22,6 +22,7 @@ const { getAgent } = require('~/models/Agent');
 const { logger } = require('~/config');
 
 const providerConfigMap = {
+  [Providers.XAI]: initCustom,
   [Providers.OLLAMA]: initCustom,
   [Providers.DEEPSEEK]: initCustom,
   [Providers.OPENROUTER]: initCustom,

api/server/services/Endpoints/custom/initialize.js

@@ -141,6 +141,7 @@ const initializeClient = async ({ req, res, endpointOption, optionsOnly, overrid
         },
         clientOptions,
       );
+      clientOptions.modelOptions.user = req.user.id;
       const options = getLLMConfig(apiKey, clientOptions, endpoint);
       if (!customOptions.streamRate) {
         return options;

api/server/services/Endpoints/openAI/initialize.js

@@ -141,6 +141,7 @@ const initializeClient = async ({
       },
       clientOptions,
     );
+    clientOptions.modelOptions.user = req.user.id;
     const options = getLLMConfig(apiKey, clientOptions);
     if (!clientOptions.streamRate) {
       return options;

api/server/services/Endpoints/openAI/llm.js

@@ -9,6 +9,7 @@ const { isEnabled } = require('~/server/utils');
  * @param {Object} options - Additional options for configuring the LLM.
  * @param {Object} [options.modelOptions] - Model-specific options.
  * @param {string} [options.modelOptions.model] - The name of the model to use.
+ * @param {string} [options.modelOptions.user] - The user ID
  * @param {number} [options.modelOptions.temperature] - Controls randomness in output generation (0-2).
  * @param {number} [options.modelOptions.top_p] - Controls diversity via nucleus sampling (0-1).
  * @param {number} [options.modelOptions.frequency_penalty] - Reduces repetition of token sequences (-2 to 2).

api/server/services/ModelService.js

@@ -4,7 +4,9 @@ const { HttpsProxyAgent } = require('https-proxy-agent');
 const { EModelEndpoint, defaultModels, CacheKeys } = require('librechat-data-provider');
 const { inputSchema, logAxiosError, extractBaseURL, processModelData } = require('~/utils');
 const { OllamaClient } = require('~/app/clients/OllamaClient');
+const { isUserProvided } = require('~/server/utils');
 const getLogStores = require('~/cache/getLogStores');
+const { logger } = require('~/config');
 
 /**
  * Splits a string by commas and trims each resulting value.
@@ -42,7 +44,7 @@ const fetchModels = async ({
   user,
   apiKey,
   baseURL,
-  name = 'OpenAI',
+  name = EModelEndpoint.openAI,
   azure = false,
   userIdQuery = false,
   createTokenConfig = true,
@@ -64,12 +66,19 @@ const fetchModels = async ({
 
   try {
     const options = {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
+      headers: {},
       timeout: 5000,
     };
 
+    if (name === EModelEndpoint.anthropic) {
+      options.headers = {
+        'x-api-key': apiKey,
+        'anthropic-version': process.env.ANTHROPIC_VERSION || '2023-06-01',
+      };
+    } else {
+      options.headers.Authorization = `Bearer ${apiKey}`;
+    }
+
     if (process.env.PROXY) {
       options.httpsAgent = new HttpsProxyAgent(process.env.PROXY);
     }
@@ -148,7 +157,7 @@ const fetchOpenAIModels = async (opts, _models = []) => {
       baseURL,
       azure: opts.azure,
       user: opts.user,
-      name: baseURL,
+      name: EModelEndpoint.openAI,
     });
   }
 
@@ -231,13 +240,71 @@ const getChatGPTBrowserModels = () => {
   return models;
 };
 
-const getAnthropicModels = () => {
+/**
+ * Fetches models from the Anthropic API.
+ * @async
+ * @function
+ * @param {object} opts - The options for fetching the models.
+ * @param {string} opts.user - The user ID to send to the API.
+ * @param {string[]} [_models=[]] - The models to use as a fallback.
+ */
+const fetchAnthropicModels = async (opts, _models = []) => {
+  let models = _models.slice() ?? [];
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  const anthropicBaseURL = 'https://api.anthropic.com/v1';
+  let baseURL = anthropicBaseURL;
+  let reverseProxyUrl = process.env.ANTHROPIC_REVERSE_PROXY;
+
+  if (reverseProxyUrl) {
+    baseURL = extractBaseURL(reverseProxyUrl);
+  }
+
+  if (!apiKey) {
+    return models;
+  }
+
+  const modelsCache = getLogStores(CacheKeys.MODEL_QUERIES);
+
+  const cachedModels = await modelsCache.get(baseURL);
+  if (cachedModels) {
+    return cachedModels;
+  }
+
+  if (baseURL) {
+    models = await fetchModels({
+      apiKey,
+      baseURL,
+      user: opts.user,
+      name: EModelEndpoint.anthropic,
+      tokenKey: EModelEndpoint.anthropic,
+    });
+  }
+
+  if (models.length === 0) {
+    return _models;
+  }
+
+  await modelsCache.set(baseURL, models);
+  return models;
+};
+
+const getAnthropicModels = async (opts = {}) => {
   let models = defaultModels[EModelEndpoint.anthropic];
   if (process.env.ANTHROPIC_MODELS) {
     models = splitAndTrim(process.env.ANTHROPIC_MODELS);
+    return models;
   }
 
-  return models;
+  if (isUserProvided(process.env.ANTHROPIC_API_KEY)) {
+    return models;
+  }
+
+  try {
+    return await fetchAnthropicModels(opts, models);
+  } catch (error) {
+    logger.error('Error fetching Anthropic models:', error);
+    return models;
+  }
 };
 
 const getGoogleModels = () => {

api/server/services/ModelService.spec.js

@@ -352,15 +352,15 @@ describe('splitAndTrim', () => {
 });
 
 describe('getAnthropicModels', () => {
-  it('returns default models when ANTHROPIC_MODELS is not set', () => {
+  it('returns default models when ANTHROPIC_MODELS is not set', async () => {
     delete process.env.ANTHROPIC_MODELS;
-    const models = getAnthropicModels();
+    const models = await getAnthropicModels();
     expect(models).toEqual(defaultModels[EModelEndpoint.anthropic]);
   });
 
-  it('returns models from ANTHROPIC_MODELS when set', () => {
+  it('returns models from ANTHROPIC_MODELS when set', async () => {
     process.env.ANTHROPIC_MODELS = 'claude-1, claude-2 ';
-    const models = getAnthropicModels();
+    const models = await getAnthropicModels();
     expect(models).toEqual(['claude-1', 'claude-2']);
   });
 });