refactor: cost bar uses new cost table

modelHistory keeps track of all the models and their respective endpoints that are used in a conversation, so we can quickly fetch the right values to populate our cost table whenever we load a conversation rather than having to recompute the list every time

.env.example

@@ -163,10 +163,10 @@ GOOGLE_KEY=user_provided
 # GOOGLE_AUTH_HEADER=true
 
 # Gemini API (AI Studio)
-# GOOGLE_MODELS=gemini-2.5-pro,gemini-2.5-flash,gemini-2.5-flash-lite,gemini-2.0-flash,gemini-2.0-flash-lite
+# GOOGLE_MODELS=gemini-2.5-pro,gemini-2.5-flash,gemini-2.5-flash-lite-preview-06-17,gemini-2.0-flash,gemini-2.0-flash-lite
 
 # Vertex AI
-# GOOGLE_MODELS=gemini-2.5-pro,gemini-2.5-flash,gemini-2.5-flash-lite,gemini-2.0-flash-001,gemini-2.0-flash-lite-001
+# GOOGLE_MODELS=gemini-2.5-pro,gemini-2.5-flash,gemini-2.5-flash-lite-preview-06-17,gemini-2.0-flash-001,gemini-2.0-flash-lite-001
 
 # GOOGLE_TITLE_MODEL=gemini-2.0-flash-lite-001
 
@@ -196,7 +196,7 @@ GOOGLE_KEY=user_provided
 #============#
 
 OPENAI_API_KEY=user_provided
-# OPENAI_MODELS=gpt-5,gpt-5-codex,gpt-5-mini,gpt-5-nano,o3-pro,o3,o4-mini,gpt-4.1,gpt-4.1-mini,gpt-4.1-nano,o3-mini,o1-pro,o1,gpt-4o,gpt-4o-mini
+# OPENAI_MODELS=o1,o1-mini,o1-preview,gpt-4o,gpt-4.5-preview,chatgpt-4o-latest,gpt-4o-mini,gpt-3.5-turbo-0125,gpt-3.5-turbo-0301,gpt-3.5-turbo,gpt-4,gpt-4-0613,gpt-4-vision-preview,gpt-3.5-turbo-0613,gpt-3.5-turbo-16k-0613,gpt-4-0125-preview,gpt-4-turbo-preview,gpt-4-1106-preview,gpt-3.5-turbo-1106,gpt-3.5-turbo-instruct,gpt-3.5-turbo-instruct-0914,gpt-3.5-turbo-16k
 
 DEBUG_OPENAI=false
 
@@ -459,9 +459,6 @@ OPENID_CALLBACK_URL=/oauth/openid/callback
 OPENID_REQUIRED_ROLE=
 OPENID_REQUIRED_ROLE_TOKEN_KIND=
 OPENID_REQUIRED_ROLE_PARAMETER_PATH=
-OPENID_ADMIN_ROLE=
-OPENID_ADMIN_ROLE_PARAMETER_PATH=
-OPENID_ADMIN_ROLE_TOKEN_KIND=
 # Set to determine which user info property returned from OpenID Provider to store as the User's username
 OPENID_USERNAME_CLAIM=
 # Set to determine which user info property returned from OpenID Provider to store as the User's name
@@ -653,12 +650,6 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # Google tag manager id
 #ANALYTICS_GTM_ID=user provided google tag manager id
 
-# limit conversation file imports to a certain number of bytes in size to avoid the container
-# maxing out memory limitations by unremarking this line and supplying a file size in bytes
-# such as the below example of 250 mib
-# CONVERSATION_IMPORT_MAX_FILE_SIZE_BYTES=262144000
-
-
 #===============#
 # REDIS Options #
 #===============#
@@ -702,16 +693,6 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # Comma-separated list of CacheKeys (e.g., ROLES,MESSAGES)
 # FORCED_IN_MEMORY_CACHE_NAMESPACES=ROLES,MESSAGES
 
-# Leader Election Configuration (for multi-instance deployments with Redis)
-# Duration in seconds that the leader lease is valid before it expires (default: 25)
-# LEADER_LEASE_DURATION=25
-# Interval in seconds at which the leader renews its lease (default: 10)
-# LEADER_RENEW_INTERVAL=10
-# Maximum number of retry attempts when renewing the lease fails (default: 3)
-# LEADER_RENEW_ATTEMPTS=3
-# Delay in seconds between retry attempts when renewing the lease (default: 0.5)
-# LEADER_RENEW_RETRY_DELAY=0.5
-
 #==================================================#
 #                      Others                      #
 #==================================================#

.github/workflows/cache-integration-tests.yml

@@ -1,87 +0,0 @@
-name: Cache Integration Tests
-
-on:
-  pull_request:
-    branches:
-      - main
-      - dev
-      - release/*
-    paths:
-      - 'packages/api/src/cache/**'
-      - 'packages/api/src/cluster/**'
-      - 'redis-config/**'
-      - '.github/workflows/cache-integration-tests.yml'
-
-jobs:
-  cache_integration_tests:
-    name: Integration Tests that use actual Redis Cache
-    timeout-minutes: 30
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Use Node.js 20.x
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'npm'
-
-      - name: Install Redis tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y redis-server redis-tools
-
-      - name: Start Single Redis Instance
-        run: |
-          redis-server --daemonize yes --port 6379
-          sleep 2
-          # Verify single Redis is running
-          redis-cli -p 6379 ping || exit 1
-
-      - name: Start Redis Cluster
-        working-directory: redis-config
-        run: |
-          chmod +x start-cluster.sh stop-cluster.sh
-          ./start-cluster.sh
-          sleep 10
-          # Verify cluster is running
-          redis-cli -p 7001 cluster info || exit 1
-          redis-cli -p 7002 cluster info || exit 1
-          redis-cli -p 7003 cluster info || exit 1
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build packages
-        run: |
-          npm run build:data-provider
-          npm run build:data-schemas
-          npm run build:api
-
-      - name: Run cache integration tests
-        working-directory: packages/api
-        env:
-          NODE_ENV: test
-          USE_REDIS: true
-          REDIS_URI: redis://127.0.0.1:6379
-          REDIS_CLUSTER_URI: redis://127.0.0.1:7001,redis://127.0.0.1:7002,redis://127.0.0.1:7003
-        run: npm run test:cache-integration:core
-
-      - name: Run cluster integration tests
-        working-directory: packages/api
-        env:
-          NODE_ENV: test
-          USE_REDIS: true
-          REDIS_URI: redis://127.0.0.1:6379
-        run: npm run test:cache-integration:cluster
-
-      - name: Stop Redis Cluster
-        if: always()
-        working-directory: redis-config
-        run: ./stop-cluster.sh || true
-
-      - name: Stop Single Redis Instance
-        if: always()
-        run: redis-cli -p 6379 shutdown || true

.husky/pre-commit

@@ -1,2 +1,5 @@
+#!/usr/bin/env sh 
+set -e
+. "$(dirname -- "$0")/_/husky.sh"
 [ -n "$CI" ] && exit 0
 npx lint-staged --config ./.husky/lint-staged.config.js

Dockerfile

@@ -1,4 +1,4 @@
-# v0.8.1-rc1
+# v0.8.0-rc4
 
 # Base node image
 FROM node:20-alpine AS node

Dockerfile.multi

@@ -1,5 +1,5 @@
 # Dockerfile.multi
-# v0.8.1-rc1
+# v0.8.0-rc4
 
 # Base for all builds
 FROM node:20-alpine AS base-min

api/app/clients/AnthropicClient.js

@@ -1,5 +1,4 @@
 const Anthropic = require('@anthropic-ai/sdk');
-const { logger } = require('@librechat/data-schemas');
 const { HttpsProxyAgent } = require('https-proxy-agent');
 const {
   Constants,
@@ -10,7 +9,7 @@ const {
   getResponseSender,
   validateVisionModel,
 } = require('librechat-data-provider');
-const { sleep, SplitStreamHandler: _Handler } = require('@librechat/agents');
+const { SplitStreamHandler: _Handler } = require('@librechat/agents');
 const {
   Tokenizer,
   createFetch,
@@ -32,7 +31,9 @@ const {
 } = require('./prompts');
 const { spendTokens, spendStructuredTokens } = require('~/models/spendTokens');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { sleep } = require('~/server/utils');
 const BaseClient = require('./BaseClient');
+const { logger } = require('~/config');
 
 const HUMAN_PROMPT = '\n\nHuman:';
 const AI_PROMPT = '\n\nAssistant:';

api/app/clients/BaseClient.js

@@ -1,29 +1,20 @@
 const crypto = require('crypto');
 const fetch = require('node-fetch');
 const { logger } = require('@librechat/data-schemas');
+const { getBalanceConfig } = require('@librechat/api');
 const {
-  getBalanceConfig,
-  extractFileContext,
-  encodeAndFormatAudios,
-  encodeAndFormatVideos,
-  encodeAndFormatDocuments,
-} = require('@librechat/api');
-const {
-  Constants,
-  ErrorTypes,
-  FileSources,
+  supportsBalanceCheck,
+  isAgentsEndpoint,
+  isParamEndpoint,
+  EModelEndpoint,
   ContentTypes,
   excludedKeys,
-  EModelEndpoint,
-  isParamEndpoint,
-  isAgentsEndpoint,
-  supportsBalanceCheck,
+  ErrorTypes,
+  Constants,
 } = require('librechat-data-provider');
 const { getMessages, saveMessage, updateMessage, saveConvo, getConvo } = require('~/models');
-const { getStrategyFunctions } = require('~/server/services/Files/strategies');
 const { checkBalance } = require('~/models/balanceMethods');
 const { truncateToolCallOutputs } = require('./prompts');
-const countTokens = require('~/server/utils/countTokens');
 const { getFiles } = require('~/models/File');
 const TextStream = require('./TextStream');
 
@@ -242,6 +233,7 @@ class BaseClient {
       sender: 'User',
       text,
       isCreatedByUser: true,
+      targetModel: this.modelOptions?.model ?? this.model,
     };
   }
 
@@ -1207,135 +1199,8 @@ class BaseClient {
     return await this.sendCompletion(payload, opts);
   }
 
-  async addDocuments(message, attachments) {
-    const documentResult = await encodeAndFormatDocuments(
-      this.options.req,
-      attachments,
-      {
-        provider: this.options.agent?.provider,
-        useResponsesApi: this.options.agent?.model_parameters?.useResponsesApi,
-      },
-      getStrategyFunctions,
-    );
-    message.documents =
-      documentResult.documents && documentResult.documents.length
-        ? documentResult.documents
-        : undefined;
-    return documentResult.files;
-  }
-
-  async addVideos(message, attachments) {
-    const videoResult = await encodeAndFormatVideos(
-      this.options.req,
-      attachments,
-      this.options.agent.provider,
-      getStrategyFunctions,
-    );
-    message.videos =
-      videoResult.videos && videoResult.videos.length ? videoResult.videos : undefined;
-    return videoResult.files;
-  }
-
-  async addAudios(message, attachments) {
-    const audioResult = await encodeAndFormatAudios(
-      this.options.req,
-      attachments,
-      this.options.agent.provider,
-      getStrategyFunctions,
-    );
-    message.audios =
-      audioResult.audios && audioResult.audios.length ? audioResult.audios : undefined;
-    return audioResult.files;
-  }
-
-  /**
-   * Extracts text context from attachments and sets it on the message.
-   * This handles text that was already extracted from files (OCR, transcriptions, document text, etc.)
-   * @param {TMessage} message - The message to add context to
-   * @param {MongoFile[]} attachments - Array of file attachments
-   * @returns {Promise<void>}
-   */
-  async addFileContextToMessage(message, attachments) {
-    const fileContext = await extractFileContext({
-      attachments,
-      req: this.options?.req,
-      tokenCountFn: (text) => countTokens(text),
-    });
-
-    if (fileContext) {
-      message.fileContext = fileContext;
-    }
-  }
-
-  async processAttachments(message, attachments) {
-    const categorizedAttachments = {
-      images: [],
-      videos: [],
-      audios: [],
-      documents: [],
-    };
-
-    const allFiles = [];
-
-    for (const file of attachments) {
-      /** @type {FileSources} */
-      const source = file.source ?? FileSources.local;
-      if (source === FileSources.text) {
-        allFiles.push(file);
-        continue;
-      }
-      if (file.embedded === true || file.metadata?.fileIdentifier != null) {
-        allFiles.push(file);
-        continue;
-      }
-
-      if (file.type.startsWith('image/')) {
-        categorizedAttachments.images.push(file);
-      } else if (file.type === 'application/pdf') {
-        categorizedAttachments.documents.push(file);
-        allFiles.push(file);
-      } else if (file.type.startsWith('video/')) {
-        categorizedAttachments.videos.push(file);
-        allFiles.push(file);
-      } else if (file.type.startsWith('audio/')) {
-        categorizedAttachments.audios.push(file);
-        allFiles.push(file);
-      }
-    }
-
-    const [imageFiles] = await Promise.all([
-      categorizedAttachments.images.length > 0
-        ? this.addImageURLs(message, categorizedAttachments.images)
-        : Promise.resolve([]),
-      categorizedAttachments.documents.length > 0
-        ? this.addDocuments(message, categorizedAttachments.documents)
-        : Promise.resolve([]),
-      categorizedAttachments.videos.length > 0
-        ? this.addVideos(message, categorizedAttachments.videos)
-        : Promise.resolve([]),
-      categorizedAttachments.audios.length > 0
-        ? this.addAudios(message, categorizedAttachments.audios)
-        : Promise.resolve([]),
-    ]);
-
-    allFiles.push(...imageFiles);
-
-    const seenFileIds = new Set();
-    const uniqueFiles = [];
-
-    for (const file of allFiles) {
-      if (file.file_id && !seenFileIds.has(file.file_id)) {
-        seenFileIds.add(file.file_id);
-        uniqueFiles.push(file);
-      } else if (!file.file_id) {
-        uniqueFiles.push(file);
-      }
-    }
-
-    return uniqueFiles;
-  }
-
   /**
+   *
    * @param {TMessage[]} _messages
    * @returns {Promise<TMessage[]>}
    */
@@ -1384,8 +1249,7 @@ class BaseClient {
         {},
       );
 
-      await this.addFileContextToMessage(message, files);
-      await this.processAttachments(message, files);
+      await this.addImageURLs(message, files, this.visionMode);
 
       this.message_file_map[message.messageId] = files;
       return message;

api/app/clients/GoogleClient.js

@@ -1,6 +1,4 @@
 const { google } = require('googleapis');
-const { sleep } = require('@librechat/agents');
-const { logger } = require('@librechat/data-schemas');
 const { getModelMaxTokens } = require('@librechat/api');
 const { concat } = require('@langchain/core/utils/stream');
 const { ChatVertexAI } = require('@langchain/google-vertexai');
@@ -24,6 +22,8 @@ const {
 } = require('librechat-data-provider');
 const { encodeAndFormat } = require('~/server/services/Files/images');
 const { spendTokens } = require('~/models/spendTokens');
+const { sleep } = require('~/server/utils');
+const { logger } = require('~/config');
 const {
   formatMessage,
   createContextHandlers,

api/app/clients/OllamaClient.js

@@ -2,7 +2,7 @@ const { z } = require('zod');
 const axios = require('axios');
 const { Ollama } = require('ollama');
 const { sleep } = require('@librechat/agents');
-const { resolveHeaders } = require('@librechat/api');
+const { logAxiosError } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
 const { Constants } = require('librechat-data-provider');
 const { deriveBaseURL } = require('~/utils');
@@ -44,7 +44,6 @@ class OllamaClient {
   constructor(options = {}) {
     const host = deriveBaseURL(options.baseURL ?? 'http://localhost:11434');
     this.streamRate = options.streamRate ?? Constants.DEFAULT_STREAM_RATE;
-    this.headers = options.headers ?? {};
     /** @type {Ollama} */
     this.client = new Ollama({ host });
   }
@@ -52,32 +51,27 @@ class OllamaClient {
   /**
    * Fetches Ollama models from the specified base API path.
    * @param {string} baseURL
-   * @param {Object} [options] - Optional configuration
-   * @param {Partial<IUser>} [options.user] - User object for header resolution
-   * @param {Record<string, string>} [options.headers] - Headers to include in the request
    * @returns {Promise<string[]>} The Ollama models.
-   * @throws {Error} Throws if the Ollama API request fails
    */
-  static async fetchModels(baseURL, options = {}) {
+  static async fetchModels(baseURL) {
+    let models = [];
     if (!baseURL) {
+      return models;
+    }
+    try {
+      const ollamaEndpoint = deriveBaseURL(baseURL);
+      /** @type {Promise<AxiosResponse<OllamaListResponse>>} */
+      const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
+        timeout: 5000,
+      });
+      models = response.data.models.map((tag) => tag.name);
+      return models;
+    } catch (error) {
+      const logMessage =
+        "Failed to fetch models from Ollama API. If you are not using Ollama directly, and instead, through some aggregator or reverse proxy that handles fetching via OpenAI spec, ensure the name of the endpoint doesn't start with `ollama` (case-insensitive).";
+      logAxiosError({ message: logMessage, error });
       return [];
     }
-
-    const ollamaEndpoint = deriveBaseURL(baseURL);
-
-    const resolvedHeaders = resolveHeaders({
-      headers: options.headers,
-      user: options.user,
-    });
-
-    /** @type {Promise<AxiosResponse<OllamaListResponse>>} */
-    const response = await axios.get(`${ollamaEndpoint}/api/tags`, {
-      headers: resolvedHeaders,
-      timeout: 5000,
-    });
-
-    const models = response.data.models.map((tag) => tag.name);
-    return models;
   }
 
   /**

api/app/clients/OpenAIClient.js

@@ -1,6 +1,6 @@
-const { logger } = require('@librechat/data-schemas');
+const { OllamaClient } = require('./OllamaClient');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { sleep, SplitStreamHandler, CustomOpenAIClient: OpenAI } = require('@librechat/agents');
+const { SplitStreamHandler, CustomOpenAIClient: OpenAI } = require('@librechat/agents');
 const {
   isEnabled,
   Tokenizer,
@@ -34,15 +34,16 @@ const {
   createContextHandlers,
 } = require('./prompts');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { addSpaceIfNeeded, sleep } = require('~/server/utils');
 const { spendTokens } = require('~/models/spendTokens');
-const { addSpaceIfNeeded } = require('~/server/utils');
 const { handleOpenAIErrors } = require('./tools/util');
-const { OllamaClient } = require('./OllamaClient');
 const { summaryBuffer } = require('./memory');
 const { runTitleChain } = require('./chains');
 const { extractBaseURL } = require('~/utils');
 const { tokenSplit } = require('./document');
 const BaseClient = require('./BaseClient');
+const { createLLM } = require('./llm');
+const { logger } = require('~/config');
 
 class OpenAIClient extends BaseClient {
   constructor(apiKey, options = {}) {
@@ -613,8 +614,65 @@ class OpenAIClient extends BaseClient {
     return (reply ?? '').trim();
   }
 
-  initializeLLM() {
-    throw new Error('Deprecated');
+  initializeLLM({
+    model = openAISettings.model.default,
+    modelName,
+    temperature = 0.2,
+    max_tokens,
+    streaming,
+  }) {
+    const modelOptions = {
+      modelName: modelName ?? model,
+      temperature,
+      user: this.user,
+    };
+
+    if (max_tokens) {
+      modelOptions.max_tokens = max_tokens;
+    }
+
+    const configOptions = {};
+
+    if (this.langchainProxy) {
+      configOptions.basePath = this.langchainProxy;
+    }
+
+    if (this.useOpenRouter) {
+      configOptions.basePath = 'https://openrouter.ai/api/v1';
+      configOptions.baseOptions = {
+        headers: {
+          'HTTP-Referer': 'https://librechat.ai',
+          'X-Title': 'LibreChat',
+        },
+      };
+    }
+
+    const { headers } = this.options;
+    if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+      configOptions.baseOptions = {
+        headers: resolveHeaders({
+          headers: {
+            ...headers,
+            ...configOptions?.baseOptions?.headers,
+          },
+        }),
+      };
+    }
+
+    if (this.options.proxy) {
+      configOptions.httpAgent = new HttpsProxyAgent(this.options.proxy);
+      configOptions.httpsAgent = new HttpsProxyAgent(this.options.proxy);
+    }
+
+    const llm = createLLM({
+      modelOptions,
+      configOptions,
+      openAIApiKey: this.apiKey,
+      azure: this.azure,
+      streaming,
+    });
+
+    return llm;
   }
 
   /**

api/app/clients/TextStream.js

@@ -1,5 +1,5 @@
 const { Readable } = require('stream');
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 class TextStream extends Readable {
   constructor(text, options = {}) {

api/app/clients/agents/CustomAgent/outputParser.js

@@ -1,5 +1,5 @@
-const { logger } = require('@librechat/data-schemas');
 const { ZeroShotAgentOutputParser } = require('langchain/agents');
+const { logger } = require('~/config');
 
 class CustomOutputParser extends ZeroShotAgentOutputParser {
   constructor(fields) {

api/app/clients/chains/runTitleChain.js

@@ -1,7 +1,7 @@
 const { z } = require('zod');
-const { logger } = require('@librechat/data-schemas');
 const { langPrompt, createTitlePrompt, escapeBraces, getSnippet } = require('../prompts');
 const { createStructuredOutputChainFromZod } = require('langchain/chains/openai_functions');
+const { logger } = require('~/config');
 
 const langSchema = z.object({
   language: z.string().describe('The language of the input text (full noun, no abbreviations).'),

api/app/clients/llm/createLLM.js

@@ -0,0 +1,81 @@
+const { ChatOpenAI } = require('@langchain/openai');
+const { isEnabled, sanitizeModelName, constructAzureURL } = require('@librechat/api');
+
+/**
+ * Creates a new instance of a language model (LLM) for chat interactions.
+ *
+ * @param {Object} options - The options for creating the LLM.
+ * @param {ModelOptions} options.modelOptions - The options specific to the model, including modelName, temperature, presence_penalty, frequency_penalty, and other model-related settings.
+ * @param {ConfigOptions} options.configOptions - Configuration options for the API requests, including proxy settings and custom headers.
+ * @param {Callbacks} [options.callbacks] - Callback functions for managing the lifecycle of the LLM, including token buffers, context, and initial message count.
+ * @param {boolean} [options.streaming=false] - Determines if the LLM should operate in streaming mode.
+ * @param {string} options.openAIApiKey - The API key for OpenAI, used for authentication.
+ * @param {AzureOptions} [options.azure={}] - Optional Azure-specific configurations. If provided, Azure configurations take precedence over OpenAI configurations.
+ *
+ * @returns {ChatOpenAI} An instance of the ChatOpenAI class, configured with the provided options.
+ *
+ * @example
+ * const llm = createLLM({
+ *   modelOptions: { modelName: 'gpt-4o-mini', temperature: 0.2 },
+ *   configOptions: { basePath: 'https://example.api/path' },
+ *   callbacks: { onMessage: handleMessage },
+ *   openAIApiKey: 'your-api-key'
+ * });
+ */
+function createLLM({
+  modelOptions,
+  configOptions,
+  callbacks,
+  streaming = false,
+  openAIApiKey,
+  azure = {},
+}) {
+  let credentials = { openAIApiKey };
+  let configuration = {
+    apiKey: openAIApiKey,
+    ...(configOptions.basePath && { baseURL: configOptions.basePath }),
+  };
+
+  /**  @type {AzureOptions} */
+  let azureOptions = {};
+  if (azure) {
+    const useModelName = isEnabled(process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME);
+
+    credentials = {};
+    configuration = {};
+    azureOptions = azure;
+
+    azureOptions.azureOpenAIApiDeploymentName = useModelName
+      ? sanitizeModelName(modelOptions.modelName)
+      : azureOptions.azureOpenAIApiDeploymentName;
+  }
+
+  if (azure && process.env.AZURE_OPENAI_DEFAULT_MODEL) {
+    modelOptions.modelName = process.env.AZURE_OPENAI_DEFAULT_MODEL;
+  }
+
+  if (azure && configOptions.basePath) {
+    const azureURL = constructAzureURL({
+      baseURL: configOptions.basePath,
+      azureOptions,
+    });
+    azureOptions.azureOpenAIBasePath = azureURL.split(
+      `/${azureOptions.azureOpenAIApiDeploymentName}`,
+    )[0];
+  }
+
+  return new ChatOpenAI(
+    {
+      streaming,
+      credentials,
+      configuration,
+      ...azureOptions,
+      ...modelOptions,
+      ...credentials,
+      callbacks,
+    },
+    configOptions,
+  );
+}
+
+module.exports = createLLM;

api/app/clients/llm/index.js

@@ -1,5 +1,7 @@
+const createLLM = require('./createLLM');
 const createCoherePayload = require('./createCoherePayload');
 
 module.exports = {
+  createLLM,
   createCoherePayload,
 };

api/app/clients/memory/summaryBuffer.demo.js

@@ -0,0 +1,31 @@
+require('dotenv').config();
+const { ChatOpenAI } = require('@langchain/openai');
+const { getBufferString, ConversationSummaryBufferMemory } = require('langchain/memory');
+
+const chatPromptMemory = new ConversationSummaryBufferMemory({
+  llm: new ChatOpenAI({ modelName: 'gpt-4o-mini', temperature: 0 }),
+  maxTokenLimit: 10,
+  returnMessages: true,
+});
+
+(async () => {
+  await chatPromptMemory.saveContext({ input: 'hi my name\'s Danny' }, { output: 'whats up' });
+  await chatPromptMemory.saveContext({ input: 'not much you' }, { output: 'not much' });
+  await chatPromptMemory.saveContext(
+    { input: 'are you excited for the olympics?' },
+    { output: 'not really' },
+  );
+
+  // We can also utilize the predict_new_summary method directly.
+  const messages = await chatPromptMemory.chatHistory.getMessages();
+  console.log('MESSAGES\n\n');
+  console.log(JSON.stringify(messages));
+  const previous_summary = '';
+  const predictSummary = await chatPromptMemory.predictNewSummary(messages, previous_summary);
+  console.log('SUMMARY\n\n');
+  console.log(JSON.stringify(getBufferString([{ role: 'system', content: predictSummary }])));
+
+  // const { history } = await chatPromptMemory.loadMemoryVariables({});
+  // console.log('HISTORY\n\n');
+  // console.log(JSON.stringify(history));
+})();

api/app/clients/memory/summaryBuffer.js

@@ -1,7 +1,7 @@
-const { logger } = require('@librechat/data-schemas');
 const { ConversationSummaryBufferMemory, ChatMessageHistory } = require('langchain/memory');
 const { formatLangChainMessages, SUMMARY_PROMPT } = require('../prompts');
 const { predictNewSummary } = require('../chains');
+const { logger } = require('~/config');
 
 const createSummaryBufferMemory = ({ llm, prompt, messages, ...rest }) => {
   const chatHistory = new ChatMessageHistory(messages);

api/app/clients/output_parsers/addImages.js

@@ -1,4 +1,4 @@
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 /**
  * The `addImages` function corrects any erroneous image URLs in the `responseMessage.text`

api/app/clients/prompts/artifacts.js

@@ -3,7 +3,6 @@ const { EModelEndpoint, ArtifactModes } = require('librechat-data-provider');
 const { generateShadcnPrompt } = require('~/app/clients/prompts/shadcn-docs/generate');
 const { components } = require('~/app/clients/prompts/shadcn-docs/components');
 
-/** @deprecated */
 // eslint-disable-next-line no-unused-vars
 const artifactsPromptV1 = dedent`The assistant can create and reference artifacts during conversations.
   
@@ -116,7 +115,6 @@ Here are some examples of correct usage of artifacts:
     </assistant_response>
   </example>
 </examples>`;
-
 const artifactsPrompt = dedent`The assistant can create and reference artifacts during conversations.
   
 Artifacts are for substantial, self-contained content that users might modify or reuse, displayed in a separate UI window for clarity.
@@ -167,10 +165,6 @@ Artifacts are for substantial, self-contained content that users might modify or
     - SVG: "image/svg+xml"
       - The user interface will render the Scalable Vector Graphics (SVG) image within the artifact tags.
       - The assistant should specify the viewbox of the SVG rather than defining a width/height
-    - Markdown: "text/markdown" or "text/md"
-      - The user interface will render Markdown content placed within the artifact tags.
-      - Supports standard Markdown syntax including headers, lists, links, images, code blocks, tables, and more.
-      - Both "text/markdown" and "text/md" are accepted as valid MIME types for Markdown content.
     - Mermaid Diagrams: "application/vnd.mermaid"
       - The user interface will render Mermaid diagrams placed within the artifact tags.
     - React Components: "application/vnd.react"
@@ -372,10 +366,6 @@ Artifacts are for substantial, self-contained content that users might modify or
     - SVG: "image/svg+xml"
       - The user interface will render the Scalable Vector Graphics (SVG) image within the artifact tags.
       - The assistant should specify the viewbox of the SVG rather than defining a width/height
-    - Markdown: "text/markdown" or "text/md"
-      - The user interface will render Markdown content placed within the artifact tags.
-      - Supports standard Markdown syntax including headers, lists, links, images, code blocks, tables, and more.
-      - Both "text/markdown" and "text/md" are accepted as valid MIME types for Markdown content.
     - Mermaid Diagrams: "application/vnd.mermaid"
       - The user interface will render Mermaid diagrams placed within the artifact tags.
     - React Components: "application/vnd.react"

api/app/clients/tools/structured/AzureAISearch.js

@@ -1,7 +1,7 @@
 const { z } = require('zod');
 const { Tool } = require('@langchain/core/tools');
-const { logger } = require('@librechat/data-schemas');
 const { SearchClient, AzureKeyCredential } = require('@azure/search-documents');
+const { logger } = require('~/config');
 
 class AzureAISearch extends Tool {
   // Constants for default values
@@ -18,7 +18,7 @@ class AzureAISearch extends Tool {
     super();
     this.name = 'azure-ai-search';
     this.description =
-      "Use the 'azure-ai-search' tool to retrieve search results relevant to your input";
+      'Use the \'azure-ai-search\' tool to retrieve search results relevant to your input';
     /* Used to initialize the Tool without necessary variables. */
     this.override = fields.override ?? false;
 

api/app/clients/tools/structured/DALLE3.js

@@ -1,8 +1,9 @@
 const { z } = require('zod');
 const path = require('path');
 const OpenAI = require('openai');
+const fetch = require('node-fetch');
 const { v4: uuidv4 } = require('uuid');
-const { ProxyAgent, fetch } = require('undici');
+const { ProxyAgent } = require('undici');
 const { Tool } = require('@langchain/core/tools');
 const { logger } = require('@librechat/data-schemas');
 const { getImageBasename } = require('@librechat/api');

api/app/clients/tools/structured/FluxAPI.js

@@ -3,12 +3,12 @@ const axios = require('axios');
 const fetch = require('node-fetch');
 const { v4: uuidv4 } = require('uuid');
 const { Tool } = require('@langchain/core/tools');
-const { logger } = require('@librechat/data-schemas');
 const { HttpsProxyAgent } = require('https-proxy-agent');
 const { FileContext, ContentTypes } = require('librechat-data-provider');
+const { logger } = require('~/config');
 
 const displayMessage =
-  "Flux displayed an image. All generated images are already plainly visible, so don't repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.";
+  'Flux displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.';
 
 /**
  * FluxAPI - A tool for generating high-quality images from text prompts using the Flux API.

api/app/clients/tools/structured/OpenAIImageTools.js

@@ -5,7 +5,6 @@ const FormData = require('form-data');
 const { ProxyAgent } = require('undici');
 const { tool } = require('@langchain/core/tools');
 const { logger } = require('@librechat/data-schemas');
-const { HttpsProxyAgent } = require('https-proxy-agent');
 const { logAxiosError, oaiToolkit } = require('@librechat/api');
 const { ContentTypes, EImageOutputType } = require('librechat-data-provider');
 const { getStrategyFunctions } = require('~/server/services/Files/strategies');
@@ -349,7 +348,16 @@ Error Message: ${error.message}`);
         };
 
         if (process.env.PROXY) {
-          axiosConfig.httpsAgent = new HttpsProxyAgent(process.env.PROXY);
+          try {
+            const url = new URL(process.env.PROXY);
+            axiosConfig.proxy = {
+              host: url.hostname.replace(/^\[|\]$/g, ''),
+              port: url.port ? parseInt(url.port, 10) : undefined,
+              protocol: url.protocol.replace(':', ''),
+            };
+          } catch (error) {
+            logger.error('Error parsing proxy URL:', error);
+          }
         }
 
         if (process.env.IMAGE_GEN_OAI_AZURE_API_VERSION && process.env.IMAGE_GEN_OAI_BASEURL) {

api/app/clients/tools/structured/StableDiffusion.js

@@ -6,9 +6,9 @@ const axios = require('axios');
 const sharp = require('sharp');
 const { v4: uuidv4 } = require('uuid');
 const { Tool } = require('@langchain/core/tools');
-const { logger } = require('@librechat/data-schemas');
 const { FileContext, ContentTypes } = require('librechat-data-provider');
 const paths = require('~/config/paths');
+const { logger } = require('~/config');
 
 const displayMessage =
   "Stable Diffusion displayed an image. All generated images are already plainly visible, so don't repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.";

api/app/clients/tools/structured/TraversaalSearch.js

@@ -1,7 +1,7 @@
 const { z } = require('zod');
 const { Tool } = require('@langchain/core/tools');
-const { logger } = require('@librechat/data-schemas');
 const { getEnvironmentVariable } = require('@langchain/core/utils/env');
+const { logger } = require('~/config');
 
 /**
  * Tool for the Traversaal AI search API, Ares.
@@ -21,7 +21,7 @@ class TraversaalSearch extends Tool {
       query: z
         .string()
         .describe(
-          "A properly written sentence to be interpreted by an AI to search the web according to the user's request.",
+          'A properly written sentence to be interpreted by an AI to search the web according to the user\'s request.',
         ),
     });
 
@@ -38,6 +38,7 @@ class TraversaalSearch extends Tool {
     return apiKey;
   }
 
+  // eslint-disable-next-line no-unused-vars
   async _call({ query }, _runManager) {
     const body = {
       query: [query],

api/app/clients/tools/structured/Wolfram.js

@@ -1,8 +1,8 @@
 /* eslint-disable no-useless-escape */
-const { z } = require('zod');
 const axios = require('axios');
+const { z } = require('zod');
 const { Tool } = require('@langchain/core/tools');
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 class WolframAlphaAPI extends Tool {
   constructor(fields) {

api/app/clients/tools/util/fileSearch.js

@@ -68,19 +68,19 @@ const primeFiles = async (options) => {
 /**
  *
  * @param {Object} options
- * @param {string} options.userId
+ * @param {ServerRequest} options.req
  * @param {Array<{ file_id: string; filename: string }>} options.files
  * @param {string} [options.entity_id]
  * @param {boolean} [options.fileCitations=false] - Whether to include citation instructions
  * @returns
  */
-const createFileSearchTool = async ({ userId, files, entity_id, fileCitations = false }) => {
+const createFileSearchTool = async ({ req, files, entity_id, fileCitations = false }) => {
   return tool(
     async ({ query }) => {
       if (files.length === 0) {
         return 'No files to search. Instruct the user to add files for the search.';
       }
-      const jwtToken = generateShortLivedToken(userId);
+      const jwtToken = generateShortLivedToken(req.user.id);
       if (!jwtToken) {
         return 'There was an error authenticating the file search request.';
       }

api/app/clients/tools/util/handleOpenAIErrors.js

@@ -1,5 +1,5 @@
 const OpenAI = require('openai');
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 /**
  * Handles errors that may occur when making requests to OpenAI's API.

api/app/clients/tools/util/handleTools.js

@@ -1,13 +1,8 @@
 const { logger } = require('@librechat/data-schemas');
 const { SerpAPI } = require('@langchain/community/tools/serpapi');
 const { Calculator } = require('@langchain/community/tools/calculator');
+const { mcpToolPattern, loadWebSearchAuth, checkAccess } = require('@librechat/api');
 const { EnvVar, createCodeExecutionTool, createSearchTool } = require('@librechat/agents');
-const {
-  checkAccess,
-  createSafeUser,
-  mcpToolPattern,
-  loadWebSearchAuth,
-} = require('@librechat/api');
 const {
   Tools,
   Constants,
@@ -38,7 +33,7 @@ const { createFileSearchTool, primeFiles: primeSearchFiles } = require('./fileSe
 const { getUserPluginAuthValue } = require('~/server/services/PluginService');
 const { createMCPTool, createMCPTools } = require('~/server/services/MCP');
 const { loadAuthValues } = require('~/server/services/Tools/credentials');
-const { getMCPServerTools } = require('~/server/services/Config');
+const { getCachedTools } = require('~/server/services/Config');
 const { getRoleByName } = require('~/models/Role');
 
 /**
@@ -255,6 +250,7 @@ const loadTools = async ({
 
   /** @type {Record<string, string>} */
   const toolContextMap = {};
+  const cachedTools = (await getCachedTools({ userId: user, includeGlobal: true })) ?? {};
   const requestedMCPTools = {};
 
   for (const tool of tools) {
@@ -311,7 +307,7 @@ const loadTools = async ({
         }
 
         return createFileSearchTool({
-          userId: user,
+          req: options.req,
           files,
           entity_id: agent?.id,
           fileCitations,
@@ -344,7 +340,7 @@ Current Date & Time: ${replaceSpecialVars({ text: '{{iso_datetime}}' })}
         });
       };
       continue;
-    } else if (tool && mcpToolPattern.test(tool)) {
+    } else if (tool && cachedTools && mcpToolPattern.test(tool)) {
       const [toolName, serverName] = tool.split(Constants.mcp_delimiter);
       if (toolName === Constants.mcp_server) {
         /** Placeholder used for UI purposes */
@@ -357,21 +353,33 @@ Current Date & Time: ${replaceSpecialVars({ text: '{{iso_datetime}}' })}
         continue;
       }
       if (toolName === Constants.mcp_all) {
-        requestedMCPTools[serverName] = [
-          {
-            type: 'all',
+        const currentMCPGenerator = async (index) =>
+          createMCPTools({
+            req: options.req,
+            res: options.res,
+            index,
             serverName,
-          },
-        ];
+            userMCPAuthMap,
+            model: agent?.model ?? model,
+            provider: agent?.provider ?? endpoint,
+            signal,
+          });
+        requestedMCPTools[serverName] = [currentMCPGenerator];
         continue;
       }
-
+      const currentMCPGenerator = async (index) =>
+        createMCPTool({
+          index,
+          req: options.req,
+          res: options.res,
+          toolKey: tool,
+          userMCPAuthMap,
+          model: agent?.model ?? model,
+          provider: agent?.provider ?? endpoint,
+          signal,
+        });
       requestedMCPTools[serverName] = requestedMCPTools[serverName] || [];
-      requestedMCPTools[serverName].push({
-        type: 'single',
-        toolKey: tool,
-        serverName,
-      });
+      requestedMCPTools[serverName].push(currentMCPGenerator);
       continue;
     }
 
@@ -414,65 +422,24 @@ Current Date & Time: ${replaceSpecialVars({ text: '{{iso_datetime}}' })}
   const mcpToolPromises = [];
   /** MCP server tools are initialized sequentially by server */
   let index = -1;
-  const failedMCPServers = new Set();
-  const safeUser = createSafeUser(options.req?.user);
-  for (const [serverName, toolConfigs] of Object.entries(requestedMCPTools)) {
+  for (const [serverName, generators] of Object.entries(requestedMCPTools)) {
     index++;
-    /** @type {LCAvailableTools} */
-    let availableTools;
-    for (const config of toolConfigs) {
+    for (const generator of generators) {
       try {
-        if (failedMCPServers.has(serverName)) {
-          continue;
-        }
-        const mcpParams = {
-          index,
-          signal,
-          user: safeUser,
-          userMCPAuthMap,
-          res: options.res,
-          model: agent?.model ?? model,
-          serverName: config.serverName,
-          provider: agent?.provider ?? endpoint,
-        };
-
-        if (config.type === 'all' && toolConfigs.length === 1) {
-          /** Handle async loading for single 'all' tool config */
+        if (generator && generators.length === 1) {
           mcpToolPromises.push(
-            createMCPTools(mcpParams).catch((error) => {
+            generator(index).catch((error) => {
               logger.error(`Error loading ${serverName} tools:`, error);
               return null;
             }),
           );
           continue;
         }
-        if (!availableTools) {
-          try {
-            availableTools = await getMCPServerTools(safeUser.id, serverName);
-          } catch (error) {
-            logger.error(`Error fetching available tools for MCP server ${serverName}:`, error);
-          }
-        }
-
-        /** Handle synchronous loading */
-        const mcpTool =
-          config.type === 'all'
-            ? await createMCPTools(mcpParams)
-            : await createMCPTool({
-                ...mcpParams,
-                availableTools,
-                toolKey: config.toolKey,
-              });
-
+        const mcpTool = await generator(index);
         if (Array.isArray(mcpTool)) {
           loadedTools.push(...mcpTool);
         } else if (mcpTool) {
           loadedTools.push(mcpTool);
-        } else {
-          failedMCPServers.add(serverName);
-          logger.warn(
-            `MCP tool creation failed for "${config.toolKey}", server may be unavailable or unauthenticated.`,
-          );
         }
       } catch (error) {
         logger.error(`Error loading MCP tool for server ${serverName}:`, error);

api/app/clients/tools/util/handleTools.test.js

@@ -30,6 +30,7 @@ jest.mock('~/server/services/Config', () => ({
   }),
 }));
 
+const { BaseLLM } = require('@langchain/openai');
 const { Calculator } = require('@langchain/community/tools/calculator');
 
 const { User } = require('~/db/models');
@@ -171,6 +172,7 @@ describe('Tool Handlers', () => {
     beforeAll(async () => {
       const toolMap = await loadTools({
         user: fakeUser._id,
+        model: BaseLLM,
         tools: sampleTools,
         returnMap: true,
         useSpecs: true,
@@ -264,6 +266,7 @@ describe('Tool Handlers', () => {
     it('returns an empty object when no tools are requested', async () => {
       toolFunctions = await loadTools({
         user: fakeUser._id,
+        model: BaseLLM,
         returnMap: true,
         useSpecs: true,
       });
@@ -273,6 +276,7 @@ describe('Tool Handlers', () => {
       process.env.SD_WEBUI_URL = mockCredential;
       toolFunctions = await loadTools({
         user: fakeUser._id,
+        model: BaseLLM,
         tools: ['stable-diffusion'],
         functions: true,
         returnMap: true,

api/cache/cacheConfig.js

@@ -1,7 +1,6 @@
-import { readFileSync, existsSync } from 'fs';
-import { logger } from '@librechat/data-schemas';
-import { CacheKeys } from 'librechat-data-provider';
-import { math, isEnabled } from '~/utils';
+const fs = require('fs');
+const { math, isEnabled } = require('@librechat/api');
+const { CacheKeys } = require('librechat-data-provider');
 
 // To ensure that different deployments do not interfere with each other's cache, we use a prefix for the Redis keys.
 // This prefix is usually the deployment ID, which is often passed to the container or pod as an env var.
@@ -25,7 +24,7 @@ const FORCED_IN_MEMORY_CACHE_NAMESPACES = process.env.FORCED_IN_MEMORY_CACHE_NAM
 
 // Validate against CacheKeys enum
 if (FORCED_IN_MEMORY_CACHE_NAMESPACES.length > 0) {
-  const validKeys = Object.values(CacheKeys) as string[];
+  const validKeys = Object.values(CacheKeys);
   const invalidKeys = FORCED_IN_MEMORY_CACHE_NAMESPACES.filter((key) => !validKeys.includes(key));
 
   if (invalidKeys.length > 0) {
@@ -35,37 +34,14 @@ if (FORCED_IN_MEMORY_CACHE_NAMESPACES.length > 0) {
   }
 }
 
-/** Helper function to safely read Redis CA certificate from file
- * @returns {string|null} The contents of the CA certificate file, or null if not set or on error
- */
-const getRedisCA = (): string | null => {
-  const caPath = process.env.REDIS_CA;
-  if (!caPath) {
-    return null;
-  }
-
-  try {
-    if (existsSync(caPath)) {
-      return readFileSync(caPath, 'utf8');
-    } else {
-      logger.warn(`Redis CA certificate file not found: ${caPath}`);
-      return null;
-    }
-  } catch (error) {
-    logger.error(`Failed to read Redis CA certificate file '${caPath}':`, error);
-    return null;
-  }
-};
-
 const cacheConfig = {
   FORCED_IN_MEMORY_CACHE_NAMESPACES,
   USE_REDIS,
   REDIS_URI: process.env.REDIS_URI,
   REDIS_USERNAME: process.env.REDIS_USERNAME,
   REDIS_PASSWORD: process.env.REDIS_PASSWORD,
-  REDIS_CA: getRedisCA(),
-  REDIS_KEY_PREFIX: process.env[REDIS_KEY_PREFIX_VAR ?? ''] || REDIS_KEY_PREFIX || '',
-  GLOBAL_PREFIX_SEPARATOR: '::',
+  REDIS_CA: process.env.REDIS_CA ? fs.readFileSync(process.env.REDIS_CA, 'utf8') : null,
+  REDIS_KEY_PREFIX: process.env[REDIS_KEY_PREFIX_VAR] || REDIS_KEY_PREFIX || '',
   REDIS_MAX_LISTENERS: math(process.env.REDIS_MAX_LISTENERS, 40),
   REDIS_PING_INTERVAL: math(process.env.REDIS_PING_INTERVAL, 0),
   /** Max delay between reconnection attempts in ms */
@@ -87,4 +63,4 @@ const cacheConfig = {
   BAN_DURATION: math(process.env.BAN_DURATION, 7200000), // 2 hours
 };
 
-export { cacheConfig };
+module.exports = { cacheConfig };

api/cache/cacheConfig.spec.js

@@ -1,8 +1,12 @@
+const fs = require('fs');
+
 describe('cacheConfig', () => {
-  let originalEnv: NodeJS.ProcessEnv;
+  let originalEnv;
+  let originalReadFileSync;
 
   beforeEach(() => {
     originalEnv = { ...process.env };
+    originalReadFileSync = fs.readFileSync;
 
     // Clear all related env vars first
     delete process.env.REDIS_URI;
@@ -14,116 +18,116 @@ describe('cacheConfig', () => {
     delete process.env.REDIS_PING_INTERVAL;
     delete process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES;
 
-    // Clear module cache
+    // Clear require cache
     jest.resetModules();
   });
 
   afterEach(() => {
     process.env = originalEnv;
+    fs.readFileSync = originalReadFileSync;
     jest.resetModules();
   });
 
   describe('REDIS_KEY_PREFIX validation and resolution', () => {
-    test('should throw error when both REDIS_KEY_PREFIX_VAR and REDIS_KEY_PREFIX are set', async () => {
+    test('should throw error when both REDIS_KEY_PREFIX_VAR and REDIS_KEY_PREFIX are set', () => {
       process.env.REDIS_KEY_PREFIX_VAR = 'DEPLOYMENT_ID';
       process.env.REDIS_KEY_PREFIX = 'manual-prefix';
 
-      await expect(async () => {
-        await import('../cacheConfig');
-      }).rejects.toThrow('Only either REDIS_KEY_PREFIX_VAR or REDIS_KEY_PREFIX can be set.');
+      expect(() => {
+        require('./cacheConfig');
+      }).toThrow('Only either REDIS_KEY_PREFIX_VAR or REDIS_KEY_PREFIX can be set.');
     });
 
-    test('should resolve REDIS_KEY_PREFIX from variable reference', async () => {
+    test('should resolve REDIS_KEY_PREFIX from variable reference', () => {
       process.env.REDIS_KEY_PREFIX_VAR = 'DEPLOYMENT_ID';
       process.env.DEPLOYMENT_ID = 'test-deployment-123';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_KEY_PREFIX).toBe('test-deployment-123');
     });
 
-    test('should use direct REDIS_KEY_PREFIX value', async () => {
+    test('should use direct REDIS_KEY_PREFIX value', () => {
       process.env.REDIS_KEY_PREFIX = 'direct-prefix';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_KEY_PREFIX).toBe('direct-prefix');
     });
 
-    test('should default to empty string when no prefix is configured', async () => {
-      const { cacheConfig } = await import('../cacheConfig');
+    test('should default to empty string when no prefix is configured', () => {
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_KEY_PREFIX).toBe('');
     });
 
-    test('should handle empty variable reference', async () => {
+    test('should handle empty variable reference', () => {
       process.env.REDIS_KEY_PREFIX_VAR = 'EMPTY_VAR';
       process.env.EMPTY_VAR = '';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_KEY_PREFIX).toBe('');
     });
 
-    test('should handle undefined variable reference', async () => {
+    test('should handle undefined variable reference', () => {
       process.env.REDIS_KEY_PREFIX_VAR = 'UNDEFINED_VAR';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_KEY_PREFIX).toBe('');
     });
   });
 
   describe('USE_REDIS and REDIS_URI validation', () => {
-    test('should throw error when USE_REDIS is enabled but REDIS_URI is not set', async () => {
+    test('should throw error when USE_REDIS is enabled but REDIS_URI is not set', () => {
       process.env.USE_REDIS = 'true';
 
-      await expect(async () => {
-        await import('../cacheConfig');
-      }).rejects.toThrow('USE_REDIS is enabled but REDIS_URI is not set.');
+      expect(() => {
+        require('./cacheConfig');
+      }).toThrow('USE_REDIS is enabled but REDIS_URI is not set.');
     });
 
-    test('should not throw error when USE_REDIS is enabled and REDIS_URI is set', async () => {
+    test('should not throw error when USE_REDIS is enabled and REDIS_URI is set', () => {
       process.env.USE_REDIS = 'true';
       process.env.REDIS_URI = 'redis://localhost:6379';
 
-      const importModule = async () => {
-        await import('../cacheConfig');
-      };
-      await expect(importModule()).resolves.not.toThrow();
+      expect(() => {
+        require('./cacheConfig');
+      }).not.toThrow();
     });
 
-    test('should handle empty REDIS_URI when USE_REDIS is enabled', async () => {
+    test('should handle empty REDIS_URI when USE_REDIS is enabled', () => {
       process.env.USE_REDIS = 'true';
       process.env.REDIS_URI = '';
 
-      await expect(async () => {
-        await import('../cacheConfig');
-      }).rejects.toThrow('USE_REDIS is enabled but REDIS_URI is not set.');
+      expect(() => {
+        require('./cacheConfig');
+      }).toThrow('USE_REDIS is enabled but REDIS_URI is not set.');
     });
   });
 
   describe('USE_REDIS_CLUSTER configuration', () => {
-    test('should default to false when USE_REDIS_CLUSTER is not set', async () => {
-      const { cacheConfig } = await import('../cacheConfig');
+    test('should default to false when USE_REDIS_CLUSTER is not set', () => {
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.USE_REDIS_CLUSTER).toBe(false);
     });
 
-    test('should be false when USE_REDIS_CLUSTER is set to false', async () => {
+    test('should be false when USE_REDIS_CLUSTER is set to false', () => {
       process.env.USE_REDIS_CLUSTER = 'false';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.USE_REDIS_CLUSTER).toBe(false);
     });
 
-    test('should be true when USE_REDIS_CLUSTER is set to true', async () => {
+    test('should be true when USE_REDIS_CLUSTER is set to true', () => {
       process.env.USE_REDIS_CLUSTER = 'true';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.USE_REDIS_CLUSTER).toBe(true);
     });
 
-    test('should work with USE_REDIS enabled and REDIS_URI set', async () => {
+    test('should work with USE_REDIS enabled and REDIS_URI set', () => {
       process.env.USE_REDIS_CLUSTER = 'true';
       process.env.USE_REDIS = 'true';
       process.env.REDIS_URI = 'redis://localhost:6379';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.USE_REDIS_CLUSTER).toBe(true);
       expect(cacheConfig.USE_REDIS).toBe(true);
       expect(cacheConfig.REDIS_URI).toBe('redis://localhost:6379');
@@ -131,51 +135,54 @@ describe('cacheConfig', () => {
   });
 
   describe('REDIS_CA file reading', () => {
-    test('should be null when REDIS_CA is not set', async () => {
-      const { cacheConfig } = await import('../cacheConfig');
+    test('should be null when REDIS_CA is not set', () => {
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_CA).toBeNull();
     });
   });
 
   describe('REDIS_PING_INTERVAL configuration', () => {
-    test('should default to 0 when REDIS_PING_INTERVAL is not set', async () => {
-      const { cacheConfig } = await import('../cacheConfig');
+    test('should default to 0 when REDIS_PING_INTERVAL is not set', () => {
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_PING_INTERVAL).toBe(0);
     });
 
-    test('should use provided REDIS_PING_INTERVAL value', async () => {
+    test('should use provided REDIS_PING_INTERVAL value', () => {
       process.env.REDIS_PING_INTERVAL = '300';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.REDIS_PING_INTERVAL).toBe(300);
     });
   });
 
   describe('FORCED_IN_MEMORY_CACHE_NAMESPACES validation', () => {
-    test('should parse comma-separated cache keys correctly', async () => {
+    test('should parse comma-separated cache keys correctly', () => {
       process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES = ' ROLES, MESSAGES ';
 
-      const { cacheConfig } = await import('../cacheConfig');
-      expect(cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES).toEqual(['ROLES', 'MESSAGES']);
+      const { cacheConfig } = require('./cacheConfig');
+      expect(cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES).toEqual([
+        'ROLES',
+        'MESSAGES',
+      ]);
     });
 
-    test('should throw error for invalid cache keys', async () => {
+    test('should throw error for invalid cache keys', () => {
       process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES = 'INVALID_KEY,ROLES';
 
-      await expect(async () => {
-        await import('../cacheConfig');
-      }).rejects.toThrow('Invalid cache keys in FORCED_IN_MEMORY_CACHE_NAMESPACES: INVALID_KEY');
+      expect(() => {
+        require('./cacheConfig');
+      }).toThrow('Invalid cache keys in FORCED_IN_MEMORY_CACHE_NAMESPACES: INVALID_KEY');
     });
 
-    test('should handle empty string gracefully', async () => {
+    test('should handle empty string gracefully', () => {
       process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES = '';
 
-      const { cacheConfig } = await import('../cacheConfig');
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES).toEqual([]);
     });
 
-    test('should handle undefined env var gracefully', async () => {
-      const { cacheConfig } = await import('../cacheConfig');
+    test('should handle undefined env var gracefully', () => {
+      const { cacheConfig } = require('./cacheConfig');
       expect(cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES).toEqual([]);
     });
   });

api/cache/cacheFactory.js

@@ -0,0 +1,108 @@
+const KeyvRedis = require('@keyv/redis').default;
+const { Keyv } = require('keyv');
+const { RedisStore } = require('rate-limit-redis');
+const { Time } = require('librechat-data-provider');
+const { logger } = require('@librechat/data-schemas');
+const { RedisStore: ConnectRedis } = require('connect-redis');
+const MemoryStore = require('memorystore')(require('express-session'));
+const { keyvRedisClient, ioredisClient, GLOBAL_PREFIX_SEPARATOR } = require('./redisClients');
+const { cacheConfig } = require('./cacheConfig');
+const { violationFile } = require('./keyvFiles');
+
+/**
+ * Creates a cache instance using Redis or a fallback store. Suitable for general caching needs.
+ * @param {string} namespace - The cache namespace.
+ * @param {number} [ttl] - Time to live for cache entries.
+ * @param {object} [fallbackStore] - Optional fallback store if Redis is not used.
+ * @returns {Keyv} Cache instance.
+ */
+const standardCache = (namespace, ttl = undefined, fallbackStore = undefined) => {
+  if (
+    cacheConfig.USE_REDIS &&
+    !cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES?.includes(namespace)
+  ) {
+    try {
+      const keyvRedis = new KeyvRedis(keyvRedisClient);
+      const cache = new Keyv(keyvRedis, { namespace, ttl });
+      keyvRedis.namespace = cacheConfig.REDIS_KEY_PREFIX;
+      keyvRedis.keyPrefixSeparator = GLOBAL_PREFIX_SEPARATOR;
+
+      cache.on('error', (err) => {
+        logger.error(`Cache error in namespace ${namespace}:`, err);
+      });
+
+      return cache;
+    } catch (err) {
+      logger.error(`Failed to create Redis cache for namespace ${namespace}:`, err);
+      throw err;
+    }
+  }
+  if (fallbackStore) return new Keyv({ store: fallbackStore, namespace, ttl });
+  return new Keyv({ namespace, ttl });
+};
+
+/**
+ * Creates a cache instance for storing violation data.
+ * Uses a file-based fallback store if Redis is not enabled.
+ * @param {string} namespace - The cache namespace for violations.
+ * @param {number} [ttl] - Time to live for cache entries.
+ * @returns {Keyv} Cache instance for violations.
+ */
+const violationCache = (namespace, ttl = undefined) => {
+  return standardCache(`violations:${namespace}`, ttl, violationFile);
+};
+
+/**
+ * Creates a session cache instance using Redis or in-memory store.
+ * @param {string} namespace - The session namespace.
+ * @param {number} [ttl] - Time to live for session entries.
+ * @returns {MemoryStore | ConnectRedis} Session store instance.
+ */
+const sessionCache = (namespace, ttl = undefined) => {
+  namespace = namespace.endsWith(':') ? namespace : `${namespace}:`;
+  if (!cacheConfig.USE_REDIS) return new MemoryStore({ ttl, checkPeriod: Time.ONE_DAY });
+  const store = new ConnectRedis({ client: ioredisClient, ttl, prefix: namespace });
+  if (ioredisClient) {
+    ioredisClient.on('error', (err) => {
+      logger.error(`Session store Redis error for namespace ${namespace}:`, err);
+    });
+  }
+  return store;
+};
+
+/**
+ * Creates a rate limiter cache using Redis.
+ * @param {string} prefix - The key prefix for rate limiting.
+ * @returns {RedisStore|undefined} RedisStore instance or undefined if Redis is not used.
+ */
+const limiterCache = (prefix) => {
+  if (!prefix) throw new Error('prefix is required');
+  if (!cacheConfig.USE_REDIS) return undefined;
+  prefix = prefix.endsWith(':') ? prefix : `${prefix}:`;
+
+  try {
+    if (!ioredisClient) {
+      logger.warn(`Redis client not available for rate limiter with prefix ${prefix}`);
+      return undefined;
+    }
+
+    return new RedisStore({ sendCommand, prefix });
+  } catch (err) {
+    logger.error(`Failed to create Redis rate limiter for prefix ${prefix}:`, err);
+    return undefined;
+  }
+};
+
+const sendCommand = (...args) => {
+  if (!ioredisClient) {
+    logger.warn('Redis client not available for command execution');
+    return Promise.reject(new Error('Redis client not available'));
+  }
+
+  return ioredisClient.call(...args).catch((err) => {
+    logger.error('Redis command execution failed:', err);
+    throw err;
+  });
+};
+
+module.exports = { standardCache, sessionCache, violationCache, limiterCache };

api/cache/cacheFactory.spec.js

@@ -0,0 +1,432 @@
+const { Time } = require('librechat-data-provider');
+
+// Mock dependencies first
+const mockKeyvRedis = {
+  namespace: '',
+  keyPrefixSeparator: '',
+};
+
+const mockKeyv = jest.fn().mockReturnValue({
+  mock: 'keyv',
+  on: jest.fn(),
+});
+const mockConnectRedis = jest.fn().mockReturnValue({ mock: 'connectRedis' });
+const mockMemoryStore = jest.fn().mockReturnValue({ mock: 'memoryStore' });
+const mockRedisStore = jest.fn().mockReturnValue({ mock: 'redisStore' });
+
+const mockIoredisClient = {
+  call: jest.fn(),
+  on: jest.fn(),
+};
+
+const mockKeyvRedisClient = {};
+const mockViolationFile = {};
+
+// Mock modules before requiring the main module
+jest.mock('@keyv/redis', () => ({
+  default: jest.fn().mockImplementation(() => mockKeyvRedis),
+}));
+
+jest.mock('keyv', () => ({
+  Keyv: mockKeyv,
+}));
+
+jest.mock('./cacheConfig', () => ({
+  cacheConfig: {
+    USE_REDIS: false,
+    REDIS_KEY_PREFIX: 'test',
+    FORCED_IN_MEMORY_CACHE_NAMESPACES: [],
+  },
+}));
+
+jest.mock('./redisClients', () => ({
+  keyvRedisClient: mockKeyvRedisClient,
+  ioredisClient: mockIoredisClient,
+  GLOBAL_PREFIX_SEPARATOR: '::',
+}));
+
+jest.mock('./keyvFiles', () => ({
+  violationFile: mockViolationFile,
+}));
+
+jest.mock('connect-redis', () => ({ RedisStore: mockConnectRedis }));
+
+jest.mock('memorystore', () => jest.fn(() => mockMemoryStore));
+
+jest.mock('rate-limit-redis', () => ({
+  RedisStore: mockRedisStore,
+}));
+
+jest.mock('@librechat/data-schemas', () => ({
+  logger: {
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+  },
+}));
+
+// Import after mocking
+const { standardCache, sessionCache, violationCache, limiterCache } = require('./cacheFactory');
+const { cacheConfig } = require('./cacheConfig');
+
+describe('cacheFactory', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Reset cache config mock
+    cacheConfig.USE_REDIS = false;
+    cacheConfig.REDIS_KEY_PREFIX = 'test';
+    cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES = [];
+  });
+
+  describe('redisCache', () => {
+    it('should create Redis cache when USE_REDIS is true', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'test-namespace';
+      const ttl = 3600;
+
+      standardCache(namespace, ttl);
+
+      expect(require('@keyv/redis').default).toHaveBeenCalledWith(mockKeyvRedisClient);
+      expect(mockKeyv).toHaveBeenCalledWith(mockKeyvRedis, { namespace, ttl });
+      expect(mockKeyvRedis.namespace).toBe(cacheConfig.REDIS_KEY_PREFIX);
+      expect(mockKeyvRedis.keyPrefixSeparator).toBe('::');
+    });
+
+    it('should create Redis cache with undefined ttl when not provided', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'test-namespace';
+
+      standardCache(namespace);
+
+      expect(mockKeyv).toHaveBeenCalledWith(mockKeyvRedis, { namespace, ttl: undefined });
+    });
+
+    it('should use fallback store when USE_REDIS is false and fallbackStore is provided', () => {
+      cacheConfig.USE_REDIS = false;
+      const namespace = 'test-namespace';
+      const ttl = 3600;
+      const fallbackStore = { some: 'store' };
+
+      standardCache(namespace, ttl, fallbackStore);
+
+      expect(mockKeyv).toHaveBeenCalledWith({ store: fallbackStore, namespace, ttl });
+    });
+
+    it('should create default Keyv instance when USE_REDIS is false and no fallbackStore', () => {
+      cacheConfig.USE_REDIS = false;
+      const namespace = 'test-namespace';
+      const ttl = 3600;
+
+      standardCache(namespace, ttl);
+
+      expect(mockKeyv).toHaveBeenCalledWith({ namespace, ttl });
+    });
+
+    it('should handle namespace and ttl as undefined', () => {
+      cacheConfig.USE_REDIS = false;
+
+      standardCache();
+
+      expect(mockKeyv).toHaveBeenCalledWith({ namespace: undefined, ttl: undefined });
+    });
+
+    it('should use fallback when namespace is in FORCED_IN_MEMORY_CACHE_NAMESPACES', () => {
+      cacheConfig.USE_REDIS = true;
+      cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES = ['forced-memory'];
+      const namespace = 'forced-memory';
+      const ttl = 3600;
+
+      standardCache(namespace, ttl);
+
+      expect(require('@keyv/redis').default).not.toHaveBeenCalled();
+      expect(mockKeyv).toHaveBeenCalledWith({ namespace, ttl });
+    });
+
+    it('should use Redis when namespace is not in FORCED_IN_MEMORY_CACHE_NAMESPACES', () => {
+      cacheConfig.USE_REDIS = true;
+      cacheConfig.FORCED_IN_MEMORY_CACHE_NAMESPACES = ['other-namespace'];
+      const namespace = 'test-namespace';
+      const ttl = 3600;
+
+      standardCache(namespace, ttl);
+
+      expect(require('@keyv/redis').default).toHaveBeenCalledWith(mockKeyvRedisClient);
+      expect(mockKeyv).toHaveBeenCalledWith(mockKeyvRedis, { namespace, ttl });
+    });
+
+    it('should throw error when Redis cache creation fails', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'test-namespace';
+      const ttl = 3600;
+      const testError = new Error('Redis connection failed');
+
+      const KeyvRedis = require('@keyv/redis').default;
+      KeyvRedis.mockImplementationOnce(() => {
+        throw testError;
+      });
+
+      expect(() => standardCache(namespace, ttl)).toThrow('Redis connection failed');
+
+      const { logger } = require('@librechat/data-schemas');
+      expect(logger.error).toHaveBeenCalledWith(
+        `Failed to create Redis cache for namespace ${namespace}:`,
+        testError,
+      );
+
+      expect(mockKeyv).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('violationCache', () => {
+    it('should create violation cache with prefixed namespace', () => {
+      const namespace = 'test-violations';
+      const ttl = 7200;
+
+      // We can't easily mock the internal redisCache call since it's in the same module
+      // But we can test that the function executes without throwing
+      expect(() => violationCache(namespace, ttl)).not.toThrow();
+    });
+
+    it('should create violation cache with undefined ttl', () => {
+      const namespace = 'test-violations';
+
+      violationCache(namespace);
+
+      // The function should call redisCache with violations: prefixed namespace
+      // Since we can't easily mock the internal redisCache call, we test the behavior
+      expect(() => violationCache(namespace)).not.toThrow();
+    });
+
+    it('should handle undefined namespace', () => {
+      expect(() => violationCache(undefined)).not.toThrow();
+    });
+  });
+
+  describe('sessionCache', () => {
+    it('should return MemoryStore when USE_REDIS is false', () => {
+      cacheConfig.USE_REDIS = false;
+      const namespace = 'sessions';
+      const ttl = 86400;
+
+      const result = sessionCache(namespace, ttl);
+
+      expect(mockMemoryStore).toHaveBeenCalledWith({ ttl, checkPeriod: Time.ONE_DAY });
+      expect(result).toBe(mockMemoryStore());
+    });
+
+    it('should return ConnectRedis when USE_REDIS is true', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions';
+      const ttl = 86400;
+
+      const result = sessionCache(namespace, ttl);
+
+      expect(mockConnectRedis).toHaveBeenCalledWith({
+        client: mockIoredisClient,
+        ttl,
+        prefix: `${namespace}:`,
+      });
+      expect(result).toBe(mockConnectRedis());
+    });
+
+    it('should add colon to namespace if not present', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions';
+
+      sessionCache(namespace);
+
+      expect(mockConnectRedis).toHaveBeenCalledWith({
+        client: mockIoredisClient,
+        ttl: undefined,
+        prefix: 'sessions:',
+      });
+    });
+
+    it('should not add colon to namespace if already present', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions:';
+
+      sessionCache(namespace);
+
+      expect(mockConnectRedis).toHaveBeenCalledWith({
+        client: mockIoredisClient,
+        ttl: undefined,
+        prefix: 'sessions:',
+      });
+    });
+
+    it('should handle undefined ttl', () => {
+      cacheConfig.USE_REDIS = false;
+      const namespace = 'sessions';
+
+      sessionCache(namespace);
+
+      expect(mockMemoryStore).toHaveBeenCalledWith({
+        ttl: undefined,
+        checkPeriod: Time.ONE_DAY,
+      });
+    });
+
+    it('should throw error when ConnectRedis constructor fails', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions';
+      const ttl = 86400;
+
+      // Mock ConnectRedis to throw an error during construction
+      const redisError = new Error('Redis connection failed');
+      mockConnectRedis.mockImplementationOnce(() => {
+        throw redisError;
+      });
+
+      // The error should propagate up, not be caught
+      expect(() => sessionCache(namespace, ttl)).toThrow('Redis connection failed');
+
+      // Verify that MemoryStore was NOT used as fallback
+      expect(mockMemoryStore).not.toHaveBeenCalled();
+    });
+
+    it('should register error handler but let errors propagate to Express', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions';
+
+      // Create a mock session store with middleware methods
+      const mockSessionStore = {
+        get: jest.fn(),
+        set: jest.fn(),
+        destroy: jest.fn(),
+      };
+      mockConnectRedis.mockReturnValue(mockSessionStore);
+
+      const store = sessionCache(namespace);
+
+      // Verify error handler was registered
+      expect(mockIoredisClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+
+      // Get the error handler
+      const errorHandler = mockIoredisClient.on.mock.calls.find((call) => call[0] === 'error')[1];
+
+      // Simulate an error from Redis during a session operation
+      const redisError = new Error('Socket closed unexpectedly');
+
+      // The error handler should log but not swallow the error
+      const { logger } = require('@librechat/data-schemas');
+      errorHandler(redisError);
+
+      expect(logger.error).toHaveBeenCalledWith(
+        `Session store Redis error for namespace ${namespace}::`,
+        redisError,
+      );
+
+      // Now simulate what happens when session middleware tries to use the store
+      const callback = jest.fn();
+      mockSessionStore.get.mockImplementation((sid, cb) => {
+        cb(new Error('Redis connection lost'));
+      });
+
+      // Call the store's get method (as Express session would)
+      store.get('test-session-id', callback);
+
+      // The error should be passed to the callback, not swallowed
+      expect(callback).toHaveBeenCalledWith(new Error('Redis connection lost'));
+    });
+
+    it('should handle null ioredisClient gracefully', () => {
+      cacheConfig.USE_REDIS = true;
+      const namespace = 'sessions';
+
+      // Temporarily set ioredisClient to null (simulating connection not established)
+      const originalClient = require('./redisClients').ioredisClient;
+      require('./redisClients').ioredisClient = null;
+
+      // ConnectRedis might accept null client but would fail on first use
+      // The important thing is it doesn't throw uncaught exceptions during construction
+      const store = sessionCache(namespace);
+      expect(store).toBeDefined();
+
+      // Restore original client
+      require('./redisClients').ioredisClient = originalClient;
+    });
+  });
+
+  describe('limiterCache', () => {
+    it('should return undefined when USE_REDIS is false', () => {
+      cacheConfig.USE_REDIS = false;
+      const result = limiterCache('prefix');
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return RedisStore when USE_REDIS is true', () => {
+      cacheConfig.USE_REDIS = true;
+      const result = limiterCache('rate-limit');
+
+      expect(mockRedisStore).toHaveBeenCalledWith({
+        sendCommand: expect.any(Function),
+        prefix: `rate-limit:`,
+      });
+      expect(result).toBe(mockRedisStore());
+    });
+
+    it('should add colon to prefix if not present', () => {
+      cacheConfig.USE_REDIS = true;
+      limiterCache('rate-limit');
+
+      expect(mockRedisStore).toHaveBeenCalledWith({
+        sendCommand: expect.any(Function),
+        prefix: 'rate-limit:',
+      });
+    });
+
+    it('should not add colon to prefix if already present', () => {
+      cacheConfig.USE_REDIS = true;
+      limiterCache('rate-limit:');
+
+      expect(mockRedisStore).toHaveBeenCalledWith({
+        sendCommand: expect.any(Function),
+        prefix: 'rate-limit:',
+      });
+    });
+
+    it('should pass sendCommand function that calls ioredisClient.call', async () => {
+      cacheConfig.USE_REDIS = true;
+      mockIoredisClient.call.mockResolvedValue('test-value');
+
+      limiterCache('rate-limit');
+
+      const sendCommandCall = mockRedisStore.mock.calls[0][0];
+      const sendCommand = sendCommandCall.sendCommand;
+
+      // Test that sendCommand properly delegates to ioredisClient.call
+      const args = ['GET', 'test-key'];
+      const result = await sendCommand(...args);
+
+      expect(mockIoredisClient.call).toHaveBeenCalledWith(...args);
+      expect(result).toBe('test-value');
+    });
+
+    it('should handle sendCommand errors properly', async () => {
+      cacheConfig.USE_REDIS = true;
+
+      // Mock the call method to reject with an error
+      const testError = new Error('Redis error');
+      mockIoredisClient.call.mockRejectedValue(testError);
+
+      limiterCache('rate-limit');
+
+      const sendCommandCall = mockRedisStore.mock.calls[0][0];
+      const sendCommand = sendCommandCall.sendCommand;
+
+      // Test that sendCommand properly handles errors
+      const args = ['GET', 'test-key'];
+
+      await expect(sendCommand(...args)).rejects.toThrow('Redis error');
+      expect(mockIoredisClient.call).toHaveBeenCalledWith(...args);
+    });
+
+    it('should handle undefined prefix', () => {
+      cacheConfig.USE_REDIS = true;
+      expect(() => limiterCache()).toThrow('prefix is required');
+    });
+  });
+});

api/cache/clearPendingReq.js

@@ -1,5 +1,5 @@
-const { isEnabled } = require('@librechat/api');
 const { Time, CacheKeys } = require('librechat-data-provider');
+const { isEnabled } = require('~/server/utils');
 const getLogStores = require('./getLogStores');
 
 const { USE_REDIS, LIMIT_CONCURRENT_MESSAGES } = process.env ?? {};

api/cache/getLogStores.js

@@ -1,13 +1,9 @@
+const { cacheConfig } = require('./cacheConfig');
 const { Keyv } = require('keyv');
-const { Time, CacheKeys, ViolationTypes } = require('librechat-data-provider');
-const {
-  logFile,
-  keyvMongo,
-  cacheConfig,
-  sessionCache,
-  standardCache,
-  violationCache,
-} = require('@librechat/api');
+const { CacheKeys, ViolationTypes, Time } = require('librechat-data-provider');
+const { logFile } = require('./keyvFiles');
+const keyvMongo = require('./keyvMongo');
+const { standardCache, sessionCache, violationCache } = require('./cacheFactory');
 
 const namespaces = {
   [ViolationTypes.GENERAL]: new Keyv({ store: logFile, namespace: 'violations' }),

api/cache/index.js

@@ -1,4 +1,5 @@
+const keyvFiles = require('./keyvFiles');
 const getLogStores = require('./getLogStores');
 const logViolation = require('./logViolation');
 
-module.exports = { getLogStores, logViolation };
+module.exports = { ...keyvFiles, getLogStores, logViolation };

api/cache/keyvFiles.js

@@ -0,0 +1,9 @@
+const { KeyvFile } = require('keyv-file');
+
+const logFile = new KeyvFile({ filename: './data/logs.json' }).setMaxListeners(20);
+const violationFile = new KeyvFile({ filename: './data/violations.json' }).setMaxListeners(20);
+
+module.exports = {
+  logFile,
+  violationFile,
+};

api/cache/keyvMongo.js

@@ -1,69 +1,65 @@
-import mongoose from 'mongoose';
-import { EventEmitter } from 'events';
-import { GridFSBucket } from 'mongodb';
-import { logger } from '@librechat/data-schemas';
-import type { Db, ReadPreference, Collection } from 'mongodb';
+// api/cache/keyvMongo.js
+const mongoose = require('mongoose');
+const EventEmitter = require('events');
+const { GridFSBucket } = require('mongodb');
+const { logger } = require('~/config');
 
-interface KeyvMongoOptions {
-  url?: string;
-  collection?: string;
-  useGridFS?: boolean;
-  readPreference?: ReadPreference;
-}
-
-interface GridFSClient {
-  bucket: GridFSBucket;
-  store: Collection;
-  db: Db;
-}
-
-interface CollectionClient {
-  store: Collection;
-  db: Db;
-}
-
-type Client = GridFSClient | CollectionClient;
-
-const storeMap = new Map<string, Client>();
+const storeMap = new Map();
 
 class KeyvMongoCustom extends EventEmitter {
-  private opts: KeyvMongoOptions;
-  public ttlSupport: boolean;
-  public namespace?: string;
-
-  constructor(options: KeyvMongoOptions = {}) {
+  constructor(url, options = {}) {
     super();
 
+    url = url || {};
+    if (typeof url === 'string') {
+      url = { url };
+    }
+    if (url.uri) {
+      url = { url: url.uri, ...url };
+    }
+
     this.opts = {
       url: 'mongodb://127.0.0.1:27017',
       collection: 'keyv',
+      ...url,
       ...options,
     };
 
     this.ttlSupport = false;
+
+    // Filter valid options
+    const keyvMongoKeys = new Set([
+      'url',
+      'collection',
+      'namespace',
+      'serialize',
+      'deserialize',
+      'uri',
+      'useGridFS',
+      'dialect',
+    ]);
+    this.opts = Object.fromEntries(Object.entries(this.opts).filter(([k]) => keyvMongoKeys.has(k)));
   }
 
   // Helper to access the store WITHOUT storing a promise on the instance
-  private async _getClient(): Promise<Client> {
+  _getClient() {
     const storeKey = `${this.opts.collection}:${this.opts.useGridFS ? 'gridfs' : 'collection'}`;
 
     // If we already have the store initialized, return it directly
     if (storeMap.has(storeKey)) {
-      return storeMap.get(storeKey)!;
+      return Promise.resolve(storeMap.get(storeKey));
     }
 
     // Check mongoose connection state
     if (mongoose.connection.readyState !== 1) {
-      throw new Error('Mongoose connection not ready. Ensure connectDb() is called first.');
+      return Promise.reject(
+        new Error('Mongoose connection not ready. Ensure connectDb() is called first.'),
+      );
     }
 
     try {
-      const db = mongoose.connection.db as unknown as Db | undefined;
-      if (!db) {
-        throw new Error('MongoDB database not available');
-      }
-
-      let client: Client;
+      const db = mongoose.connection.db;
+      let client;
 
       if (this.opts.useGridFS) {
         const bucket = new GridFSBucket(db, {
@@ -79,17 +75,17 @@ class KeyvMongoCustom extends EventEmitter {
       }
 
       storeMap.set(storeKey, client);
-      return client;
+      return Promise.resolve(client);
     } catch (error) {
       this.emit('error', error);
-      throw error;
+      return Promise.reject(error);
     }
   }
 
-  async get(key: string): Promise<unknown> {
+  async get(key) {
     const client = await this._getClient();
 
-    if (this.opts.useGridFS && this.isGridFSClient(client)) {
+    if (this.opts.useGridFS) {
       await client.store.updateOne(
         {
           filename: key,
@@ -104,7 +100,7 @@ class KeyvMongoCustom extends EventEmitter {
       const stream = client.bucket.openDownloadStreamByName(key);
 
       return new Promise((resolve) => {
-        const resp: Uint8Array[] = [];
+        const resp = [];
         stream.on('error', () => {
           resolve(undefined);
         });
@@ -114,7 +110,7 @@ class KeyvMongoCustom extends EventEmitter {
           resolve(data);
         });
 
-        stream.on('data', (chunk: Uint8Array) => {
+        stream.on('data', (chunk) => {
           resp.push(chunk);
         });
       });
@@ -129,7 +125,7 @@ class KeyvMongoCustom extends EventEmitter {
     return document.value;
   }
 
-  async getMany(keys: string[]): Promise<unknown[]> {
+  async getMany(keys) {
     const client = await this._getClient();
 
     if (this.opts.useGridFS) {
@@ -139,9 +135,9 @@ class KeyvMongoCustom extends EventEmitter {
       }
 
       const values = await Promise.allSettled(promises);
-      const data: unknown[] = [];
+      const data = [];
       for (const value of values) {
-        data.push(value.status === 'fulfilled' ? value.value : undefined);
+        data.push(value.value);
       }
 
       return data;
@@ -152,7 +148,7 @@ class KeyvMongoCustom extends EventEmitter {
       .project({ _id: 0, value: 1, key: 1 })
       .toArray();
 
-    const results: unknown[] = [...keys];
+    const results = [...keys];
     let i = 0;
     for (const key of keys) {
       const rowIndex = values.findIndex((row) => row.key === key);
@@ -163,11 +159,11 @@ class KeyvMongoCustom extends EventEmitter {
     return results;
   }
 
-  async set(key: string, value: string, ttl?: number): Promise<unknown> {
+  async set(key, value, ttl) {
     const client = await this._getClient();
     const expiresAt = typeof ttl === 'number' ? new Date(Date.now() + ttl) : null;
 
-    if (this.opts.useGridFS && this.isGridFSClient(client)) {
+    if (this.opts.useGridFS) {
       const stream = client.bucket.openUploadStream(key, {
         metadata: {
           expiresAt,
@@ -190,18 +186,20 @@ class KeyvMongoCustom extends EventEmitter {
     );
   }
 
-  async delete(key: string): Promise<boolean> {
+  async delete(key) {
+    if (typeof key !== 'string') {
+      return false;
+    }
+
     const client = await this._getClient();
 
-    if (this.opts.useGridFS && this.isGridFSClient(client)) {
+    if (this.opts.useGridFS) {
       try {
         const bucket = new GridFSBucket(client.db, {
           bucketName: this.opts.collection,
         });
         const files = await bucket.find({ filename: key }).toArray();
-        if (files.length > 0) {
-          await client.bucket.delete(files[0]._id);
-        }
+        await client.bucket.delete(files[0]._id);
         return true;
       } catch {
         return false;
@@ -212,10 +210,10 @@ class KeyvMongoCustom extends EventEmitter {
     return object.deletedCount > 0;
   }
 
-  async deleteMany(keys: string[]): Promise<boolean> {
+  async deleteMany(keys) {
     const client = await this._getClient();
 
-    if (this.opts.useGridFS && this.isGridFSClient(client)) {
+    if (this.opts.useGridFS) {
       const bucket = new GridFSBucket(client.db, {
         bucketName: this.opts.collection,
       });
@@ -232,17 +230,15 @@ class KeyvMongoCustom extends EventEmitter {
     return object.deletedCount > 0;
   }
 
-  async clear(): Promise<void> {
+  async clear() {
     const client = await this._getClient();
 
-    if (this.opts.useGridFS && this.isGridFSClient(client)) {
+    if (this.opts.useGridFS) {
       try {
         await client.bucket.drop();
-      } catch (error: unknown) {
+      } catch (error) {
         // Throw error if not "namespace not found" error
-        const errorCode =
-          error instanceof Error && 'code' in error ? (error as { code?: number }).code : undefined;
-        if (errorCode !== 26) {
+        if (!(error.code === 26)) {
           throw error;
         }
       }
@@ -253,7 +249,7 @@ class KeyvMongoCustom extends EventEmitter {
     });
   }
 
-  async has(key: string): Promise<boolean> {
+  async has(key) {
     const client = await this._getClient();
     const filter = { [this.opts.useGridFS ? 'filename' : 'key']: { $eq: key } };
     const document = await client.store.countDocuments(filter, { limit: 1 });
@@ -261,14 +257,10 @@ class KeyvMongoCustom extends EventEmitter {
   }
 
   // No-op disconnect
-  async disconnect(): Promise<boolean> {
+  async disconnect() {
     // This is a no-op since we don't want to close the shared mongoose connection
     return true;
   }
-
-  private isGridFSClient(client: Client): client is GridFSClient {
-    return (client as GridFSClient).bucket != null;
-  }
 }
 
 const keyvMongo = new KeyvMongoCustom({
@@ -277,4 +269,4 @@ const keyvMongo = new KeyvMongoCustom({
 
 keyvMongo.on('error', (err) => logger.error('KeyvMongo connection error:', err));
 
-export default keyvMongo;
+module.exports = keyvMongo;

api/cache/logViolation.js

@@ -1,4 +1,4 @@
-const { isEnabled } = require('@librechat/api');
+const { isEnabled } = require('~/server/utils');
 const { ViolationTypes } = require('librechat-data-provider');
 const getLogStores = require('./getLogStores');
 const banViolation = require('./banViolation');

api/cache/redisClients.js

@@ -1,24 +1,26 @@
-import IoRedis from 'ioredis';
-import type { Redis, Cluster } from 'ioredis';
-import { logger } from '@librechat/data-schemas';
-import { createClient, createCluster } from '@keyv/redis';
-import type { RedisClientType, RedisClusterType } from '@redis/client';
-import { cacheConfig } from './cacheConfig';
+const IoRedis = require('ioredis');
+const { logger } = require('@librechat/data-schemas');
+const { createClient, createCluster } = require('@keyv/redis');
+const { cacheConfig } = require('./cacheConfig');
 
-const urls = cacheConfig.REDIS_URI?.split(',').map((uri) => new URL(uri)) || [];
-const username = urls?.[0]?.username || cacheConfig.REDIS_USERNAME;
-const password = urls?.[0]?.password || cacheConfig.REDIS_PASSWORD;
+const GLOBAL_PREFIX_SEPARATOR = '::';
+
+const urls = cacheConfig.REDIS_URI?.split(',').map((uri) => new URL(uri));
+const username = urls?.[0].username || cacheConfig.REDIS_USERNAME;
+const password = urls?.[0].password || cacheConfig.REDIS_PASSWORD;
 const ca = cacheConfig.REDIS_CA;
 
-let ioredisClient: Redis | Cluster | null = null;
+/** @type {import('ioredis').Redis | import('ioredis').Cluster | null} */
+let ioredisClient = null;
 if (cacheConfig.USE_REDIS) {
-  const redisOptions: Record<string, unknown> = {
+  /** @type {import('ioredis').RedisOptions | import('ioredis').ClusterOptions} */
+  const redisOptions = {
     username: username,
     password: password,
     tls: ca ? { ca } : undefined,
-    keyPrefix: `${cacheConfig.REDIS_KEY_PREFIX}${cacheConfig.GLOBAL_PREFIX_SEPARATOR}`,
+    keyPrefix: `${cacheConfig.REDIS_KEY_PREFIX}${GLOBAL_PREFIX_SEPARATOR}`,
     maxListeners: cacheConfig.REDIS_MAX_LISTENERS,
-    retryStrategy: (times: number) => {
+    retryStrategy: (times) => {
       if (
         cacheConfig.REDIS_RETRY_MAX_ATTEMPTS > 0 &&
         times > cacheConfig.REDIS_RETRY_MAX_ATTEMPTS
@@ -32,7 +34,7 @@ if (cacheConfig.USE_REDIS) {
       logger.info(`ioredis reconnecting... attempt ${times}, delay ${delay}ms`);
       return delay;
     },
-    reconnectOnError: (err: Error) => {
+    reconnectOnError: (err) => {
       const targetError = 'READONLY';
       if (err.message.includes(targetError)) {
         logger.warn('ioredis reconnecting due to READONLY error');
@@ -47,20 +49,15 @@ if (cacheConfig.USE_REDIS) {
 
   ioredisClient =
     urls.length === 1 && !cacheConfig.USE_REDIS_CLUSTER
-      ? new IoRedis(cacheConfig.REDIS_URI!, redisOptions)
+      ? new IoRedis(cacheConfig.REDIS_URI, redisOptions)
       : new IoRedis.Cluster(
           urls.map((url) => ({ host: url.hostname, port: parseInt(url.port, 10) || 6379 })),
           {
             ...(cacheConfig.REDIS_USE_ALTERNATIVE_DNS_LOOKUP
-              ? {
-                  dnsLookup: (
-                    address: string,
-                    callback: (err: Error | null, address: string) => void,
-                  ) => callback(null, address),
-                }
+              ? { dnsLookup: (address, callback) => callback(null, address) }
               : {}),
             redisOptions,
-            clusterRetryStrategy: (times: number) => {
+            clusterRetryStrategy: (times) => {
               if (
                 cacheConfig.REDIS_RETRY_MAX_ATTEMPTS > 0 &&
                 times > cacheConfig.REDIS_RETRY_MAX_ATTEMPTS
@@ -90,7 +87,7 @@ if (cacheConfig.USE_REDIS) {
     logger.info('ioredis client ready');
   });
 
-  ioredisClient.on('reconnecting', (delay: number) => {
+  ioredisClient.on('reconnecting', (delay) => {
     logger.info(`ioredis client reconnecting in ${delay}ms`);
   });
 
@@ -99,7 +96,7 @@ if (cacheConfig.USE_REDIS) {
   });
 
   /** Ping Interval to keep the Redis server connection alive (if enabled) */
-  let pingInterval: NodeJS.Timeout | null = null;
+  let pingInterval = null;
   const clearPingInterval = () => {
     if (pingInterval) {
       clearInterval(pingInterval);
@@ -120,20 +117,22 @@ if (cacheConfig.USE_REDIS) {
   }
 }
 
-let keyvRedisClient: RedisClientType | RedisClusterType | null = null;
+/** @type {import('@keyv/redis').RedisClient | import('@keyv/redis').RedisCluster | null} */
+let keyvRedisClient = null;
 if (cacheConfig.USE_REDIS) {
   /**
    * ** WARNING ** Keyv Redis client does not support Prefix like ioredis above.
    * The prefix feature will be handled by the Keyv-Redis store in cacheFactory.js
+   * @type {import('@keyv/redis').RedisClientOptions | import('@keyv/redis').RedisClusterOptions}
    */
-  const redisOptions: Record<string, unknown> = {
+  const redisOptions = {
     username,
     password,
     socket: {
       tls: ca != null,
       ca,
       connectTimeout: cacheConfig.REDIS_CONNECT_TIMEOUT,
-      reconnectStrategy: (retries: number) => {
+      reconnectStrategy: (retries) => {
         if (
           cacheConfig.REDIS_RETRY_MAX_ATTEMPTS > 0 &&
           retries > cacheConfig.REDIS_RETRY_MAX_ATTEMPTS
@@ -149,9 +148,6 @@ if (cacheConfig.USE_REDIS) {
       },
     },
     disableOfflineQueue: !cacheConfig.REDIS_ENABLE_OFFLINE_QUEUE,
-    ...(cacheConfig.REDIS_PING_INTERVAL > 0
-      ? { pingInterval: cacheConfig.REDIS_PING_INTERVAL * 1000 }
-      : {}),
   };
 
   keyvRedisClient =
@@ -188,6 +184,27 @@ if (cacheConfig.USE_REDIS) {
     logger.error('@keyv/redis initial connection failed:', err);
     throw err;
   });
+
+  /** Ping Interval to keep the Redis server connection alive (if enabled) */
+  let pingInterval = null;
+  const clearPingInterval = () => {
+    if (pingInterval) {
+      clearInterval(pingInterval);
+      pingInterval = null;
+    }
+  };
+
+  if (cacheConfig.REDIS_PING_INTERVAL > 0) {
+    pingInterval = setInterval(() => {
+      if (keyvRedisClient && keyvRedisClient.isReady) {
+        keyvRedisClient.ping().catch((err) => {
+          logger.error('@keyv/redis ping failed:', err);
+        });
+      }
+    }, cacheConfig.REDIS_PING_INTERVAL * 1000);
+    keyvRedisClient.on('disconnect', clearPingInterval);
+    keyvRedisClient.on('end', clearPingInterval);
+  }
 }
 
-export { ioredisClient, keyvRedisClient };
+module.exports = { ioredisClient, keyvRedisClient, GLOBAL_PREFIX_SEPARATOR };

api/config/index.js

@@ -1,6 +1,6 @@
+const { MCPManager, FlowStateManager } = require('@librechat/api');
 const { EventSource } = require('eventsource');
 const { Time } = require('librechat-data-provider');
-const { MCPManager, FlowStateManager, OAuthReconnectionManager } = require('@librechat/api');
 const logger = require('./winston');
 
 global.EventSource = EventSource;
@@ -26,6 +26,4 @@ module.exports = {
   createMCPManager: MCPManager.createInstance,
   getMCPManager: MCPManager.getInstance,
   getFlowStateManager,
-  createOAuthReconnectionManager: OAuthReconnectionManager.createInstance,
-  getOAuthReconnectionManager: OAuthReconnectionManager.getInstance,
 };

api/db/indexSync.js

@@ -1,8 +1,10 @@
 const mongoose = require('mongoose');
 const { MeiliSearch } = require('meilisearch');
 const { logger } = require('@librechat/data-schemas');
+const { FlowStateManager } = require('@librechat/api');
 const { CacheKeys } = require('librechat-data-provider');
-const { isEnabled, FlowStateManager } = require('@librechat/api');
+
+const { isEnabled } = require('~/server/utils');
 const { getLogStores } = require('~/cache');
 
 const Conversation = mongoose.models.Conversation;
@@ -29,265 +31,79 @@ class MeiliSearchClient {
   }
 }
 
-/**
- * Deletes documents from MeiliSearch index that are missing the user field
- * @param {import('meilisearch').Index} index - MeiliSearch index instance
- * @param {string} indexName - Name of the index for logging
- * @returns {Promise<number>} - Number of documents deleted
- */
-async function deleteDocumentsWithoutUserField(index, indexName) {
-  let deletedCount = 0;
-  let offset = 0;
-  const batchSize = 1000;
-
-  try {
-    while (true) {
-      const searchResult = await index.search('', {
-        limit: batchSize,
-        offset: offset,
-      });
-
-      if (searchResult.hits.length === 0) {
-        break;
-      }
-
-      const idsToDelete = searchResult.hits.filter((hit) => !hit.user).map((hit) => hit.id);
-
-      if (idsToDelete.length > 0) {
-        logger.info(
-          `[indexSync] Deleting ${idsToDelete.length} documents without user field from ${indexName} index`,
-        );
-        await index.deleteDocuments(idsToDelete);
-        deletedCount += idsToDelete.length;
-      }
-
-      if (searchResult.hits.length < batchSize) {
-        break;
-      }
-
-      offset += batchSize;
-    }
-
-    if (deletedCount > 0) {
-      logger.info(`[indexSync] Deleted ${deletedCount} orphaned documents from ${indexName} index`);
-    }
-  } catch (error) {
-    logger.error(`[indexSync] Error deleting documents from ${indexName}:`, error);
-  }
-
-  return deletedCount;
-}
-
-/**
- * Ensures indexes have proper filterable attributes configured and checks if documents have user field
- * @param {MeiliSearch} client - MeiliSearch client instance
- * @returns {Promise<{settingsUpdated: boolean, orphanedDocsFound: boolean}>} - Status of what was done
- */
-async function ensureFilterableAttributes(client) {
-  let settingsUpdated = false;
-  let hasOrphanedDocs = false;
-
-  try {
-    // Check and update messages index
-    try {
-      const messagesIndex = client.index('messages');
-      const settings = await messagesIndex.getSettings();
-
-      if (!settings.filterableAttributes || !settings.filterableAttributes.includes('user')) {
-        logger.info('[indexSync] Configuring messages index to filter by user...');
-        await messagesIndex.updateSettings({
-          filterableAttributes: ['user'],
-        });
-        logger.info('[indexSync] Messages index configured for user filtering');
-        settingsUpdated = true;
-      }
-
-      // Check if existing documents have user field indexed
-      try {
-        const searchResult = await messagesIndex.search('', { limit: 1 });
-        if (searchResult.hits.length > 0 && !searchResult.hits[0].user) {
-          logger.info(
-            '[indexSync] Existing messages missing user field, will clean up orphaned documents...',
-          );
-          hasOrphanedDocs = true;
-        }
-      } catch (searchError) {
-        logger.debug('[indexSync] Could not check message documents:', searchError.message);
-      }
-    } catch (error) {
-      if (error.code !== 'index_not_found') {
-        logger.warn('[indexSync] Could not check/update messages index settings:', error.message);
-      }
-    }
-
-    // Check and update conversations index
-    try {
-      const convosIndex = client.index('convos');
-      const settings = await convosIndex.getSettings();
-
-      if (!settings.filterableAttributes || !settings.filterableAttributes.includes('user')) {
-        logger.info('[indexSync] Configuring convos index to filter by user...');
-        await convosIndex.updateSettings({
-          filterableAttributes: ['user'],
-        });
-        logger.info('[indexSync] Convos index configured for user filtering');
-        settingsUpdated = true;
-      }
-
-      // Check if existing documents have user field indexed
-      try {
-        const searchResult = await convosIndex.search('', { limit: 1 });
-        if (searchResult.hits.length > 0 && !searchResult.hits[0].user) {
-          logger.info(
-            '[indexSync] Existing conversations missing user field, will clean up orphaned documents...',
-          );
-          hasOrphanedDocs = true;
-        }
-      } catch (searchError) {
-        logger.debug('[indexSync] Could not check conversation documents:', searchError.message);
-      }
-    } catch (error) {
-      if (error.code !== 'index_not_found') {
-        logger.warn('[indexSync] Could not check/update convos index settings:', error.message);
-      }
-    }
-
-    // If either index has orphaned documents, clean them up (but don't force resync)
-    if (hasOrphanedDocs) {
-      try {
-        const messagesIndex = client.index('messages');
-        await deleteDocumentsWithoutUserField(messagesIndex, 'messages');
-      } catch (error) {
-        logger.debug('[indexSync] Could not clean up messages:', error.message);
-      }
-
-      try {
-        const convosIndex = client.index('convos');
-        await deleteDocumentsWithoutUserField(convosIndex, 'convos');
-      } catch (error) {
-        logger.debug('[indexSync] Could not clean up convos:', error.message);
-      }
-
-      logger.info('[indexSync] Orphaned documents cleaned up without forcing resync.');
-    }
-
-    if (settingsUpdated) {
-      logger.info('[indexSync] Index settings updated. Full re-sync will be triggered.');
-    }
-  } catch (error) {
-    logger.error('[indexSync] Error ensuring filterable attributes:', error);
-  }
-
-  return { settingsUpdated, orphanedDocsFound: hasOrphanedDocs };
-}
-
 /**
  * Performs the actual sync operations for messages and conversations
- * @param {FlowStateManager} flowManager - Flow state manager instance
- * @param {string} flowId - Flow identifier
- * @param {string} flowType - Flow type
  */
-async function performSync(flowManager, flowId, flowType) {
-  try {
-    const client = MeiliSearchClient.getInstance();
+async function performSync() {
+  const client = MeiliSearchClient.getInstance();
 
-    const { status } = await client.health();
-    if (status !== 'available') {
-      throw new Error('Meilisearch not available');
-    }
-
-    if (indexingDisabled === true) {
-      logger.info('[indexSync] Indexing is disabled, skipping...');
-      return { messagesSync: false, convosSync: false };
-    }
-
-    /** Ensures indexes have proper filterable attributes configured */
-    const { settingsUpdated, orphanedDocsFound: _orphanedDocsFound } =
-      await ensureFilterableAttributes(client);
-
-    let messagesSync = false;
-    let convosSync = false;
-
-    // Only reset flags if settings were actually updated (not just for orphaned doc cleanup)
-    if (settingsUpdated) {
-      logger.info(
-        '[indexSync] Settings updated. Forcing full re-sync to reindex with new configuration...',
-      );
-
-      // Reset sync flags to force full re-sync
-      await Message.collection.updateMany({ _meiliIndex: true }, { $set: { _meiliIndex: false } });
-      await Conversation.collection.updateMany(
-        { _meiliIndex: true },
-        { $set: { _meiliIndex: false } },
-      );
-    }
-
-    // Check if we need to sync messages
-    const messageProgress = await Message.getSyncProgress();
-    if (!messageProgress.isComplete || settingsUpdated) {
-      logger.info(
-        `[indexSync] Messages need syncing: ${messageProgress.totalProcessed}/${messageProgress.totalDocuments} indexed`,
-      );
-
-      // Check if we should do a full sync or incremental
-      const messageCount = await Message.countDocuments();
-      const messagesIndexed = messageProgress.totalProcessed;
-      const syncThreshold = parseInt(process.env.MEILI_SYNC_THRESHOLD || '1000', 10);
-
-      if (messageCount - messagesIndexed > syncThreshold) {
-        logger.info('[indexSync] Starting full message sync due to large difference');
-        await Message.syncWithMeili();
-        messagesSync = true;
-      } else if (messageCount !== messagesIndexed) {
-        logger.warn('[indexSync] Messages out of sync, performing incremental sync');
-        await Message.syncWithMeili();
-        messagesSync = true;
-      }
-    } else {
-      logger.info(
-        `[indexSync] Messages are fully synced: ${messageProgress.totalProcessed}/${messageProgress.totalDocuments}`,
-      );
-    }
-
-    // Check if we need to sync conversations
-    const convoProgress = await Conversation.getSyncProgress();
-    if (!convoProgress.isComplete || settingsUpdated) {
-      logger.info(
-        `[indexSync] Conversations need syncing: ${convoProgress.totalProcessed}/${convoProgress.totalDocuments} indexed`,
-      );
-
-      const convoCount = await Conversation.countDocuments();
-      const convosIndexed = convoProgress.totalProcessed;
-      const syncThreshold = parseInt(process.env.MEILI_SYNC_THRESHOLD || '1000', 10);
-
-      if (convoCount - convosIndexed > syncThreshold) {
-        logger.info('[indexSync] Starting full conversation sync due to large difference');
-        await Conversation.syncWithMeili();
-        convosSync = true;
-      } else if (convoCount !== convosIndexed) {
-        logger.warn('[indexSync] Convos out of sync, performing incremental sync');
-        await Conversation.syncWithMeili();
-        convosSync = true;
-      }
-    } else {
-      logger.info(
-        `[indexSync] Conversations are fully synced: ${convoProgress.totalProcessed}/${convoProgress.totalDocuments}`,
-      );
-    }
-
-    return { messagesSync, convosSync };
-  } finally {
-    if (indexingDisabled === true) {
-      logger.info('[indexSync] Indexing is disabled, skipping cleanup...');
-    } else if (flowManager && flowId && flowType) {
-      try {
-        await flowManager.deleteFlow(flowId, flowType);
-        logger.debug('[indexSync] Flow state cleaned up');
-      } catch (cleanupErr) {
-        logger.debug('[indexSync] Could not clean up flow state:', cleanupErr.message);
-      }
-    }
+  const { status } = await client.health();
+  if (status !== 'available') {
+    throw new Error('Meilisearch not available');
   }
+
+  if (indexingDisabled === true) {
+    logger.info('[indexSync] Indexing is disabled, skipping...');
+    return { messagesSync: false, convosSync: false };
+  }
+
+  let messagesSync = false;
+  let convosSync = false;
+
+  // Check if we need to sync messages
+  const messageProgress = await Message.getSyncProgress();
+  if (!messageProgress.isComplete) {
+    logger.info(
+      `[indexSync] Messages need syncing: ${messageProgress.totalProcessed}/${messageProgress.totalDocuments} indexed`,
+    );
+
+    // Check if we should do a full sync or incremental
+    const messageCount = await Message.countDocuments();
+    const messagesIndexed = messageProgress.totalProcessed;
+    const syncThreshold = parseInt(process.env.MEILI_SYNC_THRESHOLD || '1000', 10);
+
+    if (messageCount - messagesIndexed > syncThreshold) {
+      logger.info('[indexSync] Starting full message sync due to large difference');
+      await Message.syncWithMeili();
+      messagesSync = true;
+    } else if (messageCount !== messagesIndexed) {
+      logger.warn('[indexSync] Messages out of sync, performing incremental sync');
+      await Message.syncWithMeili();
+      messagesSync = true;
+    }
+  } else {
+    logger.info(
+      `[indexSync] Messages are fully synced: ${messageProgress.totalProcessed}/${messageProgress.totalDocuments}`,
+    );
+  }
+
+  // Check if we need to sync conversations
+  const convoProgress = await Conversation.getSyncProgress();
+  if (!convoProgress.isComplete) {
+    logger.info(
+      `[indexSync] Conversations need syncing: ${convoProgress.totalProcessed}/${convoProgress.totalDocuments} indexed`,
+    );
+
+    const convoCount = await Conversation.countDocuments();
+    const convosIndexed = convoProgress.totalProcessed;
+    const syncThreshold = parseInt(process.env.MEILI_SYNC_THRESHOLD || '1000', 10);
+
+    if (convoCount - convosIndexed > syncThreshold) {
+      logger.info('[indexSync] Starting full conversation sync due to large difference');
+      await Conversation.syncWithMeili();
+      convosSync = true;
+    } else if (convoCount !== convosIndexed) {
+      logger.warn('[indexSync] Convos out of sync, performing incremental sync');
+      await Conversation.syncWithMeili();
+      convosSync = true;
+    }
+  } else {
+    logger.info(
+      `[indexSync] Conversations are fully synced: ${convoProgress.totalProcessed}/${convoProgress.totalDocuments}`,
+    );
+  }
+
+  return { messagesSync, convosSync };
 }
 
 /**
@@ -300,26 +116,24 @@ async function indexSync() {
 
   logger.info('[indexSync] Starting index synchronization check...');
 
-  // Get or create FlowStateManager instance
-  const flowsCache = getLogStores(CacheKeys.FLOWS);
-  if (!flowsCache) {
-    logger.warn('[indexSync] Flows cache not available, falling back to direct sync');
-    return await performSync(null, null, null);
-  }
-
-  const flowManager = new FlowStateManager(flowsCache, {
-    ttl: 60000 * 10, // 10 minutes TTL for sync operations
-  });
-
-  // Use a unique flow ID for the sync operation
-  const flowId = 'meili-index-sync';
-  const flowType = 'MEILI_SYNC';
-
   try {
+    // Get or create FlowStateManager instance
+    const flowsCache = getLogStores(CacheKeys.FLOWS);
+    if (!flowsCache) {
+      logger.warn('[indexSync] Flows cache not available, falling back to direct sync');
+      return await performSync();
+    }
+
+    const flowManager = new FlowStateManager(flowsCache, {
+      ttl: 60000 * 10, // 10 minutes TTL for sync operations
+    });
+
+    // Use a unique flow ID for the sync operation
+    const flowId = 'meili-index-sync';
+    const flowType = 'MEILI_SYNC';
+
     // This will only execute the handler if no other instance is running the sync
-    const result = await flowManager.createFlowWithHandler(flowId, flowType, () =>
-      performSync(flowManager, flowId, flowType),
-    );
+    const result = await flowManager.createFlowWithHandler(flowId, flowType, performSync);
 
     if (result.messagesSync || result.convosSync) {
       logger.info('[indexSync] Sync completed successfully');

api/models/Agent.js

@@ -11,7 +11,7 @@ const {
   getProjectByName,
 } = require('./Project');
 const { removeAllPermissions } = require('~/server/services/PermissionService');
-const { getMCPServerTools } = require('~/server/services/Config');
+const { getCachedTools } = require('~/server/services/Config');
 const { getActions } = require('./Action');
 const { Agent } = require('~/db/models');
 
@@ -49,68 +49,53 @@ const createAgent = async (agentData) => {
  */
 const getAgent = async (searchParameter) => await Agent.findOne(searchParameter).lean();
 
-/**
- * Get multiple agent documents based on the provided search parameters.
- *
- * @param {Object} searchParameter - The search parameters to find agents.
- * @returns {Promise<Agent[]>} Array of agent documents as plain objects.
- */
-const getAgents = async (searchParameter) => await Agent.find(searchParameter).lean();
-
 /**
  * Load an agent based on the provided ID
  *
  * @param {Object} params
  * @param {ServerRequest} params.req
- * @param {string} params.spec
  * @param {string} params.agent_id
  * @param {string} params.endpoint
  * @param {import('@librechat/agents').ClientOptions} [params.model_parameters]
  * @returns {Promise<Agent|null>} The agent document as a plain object, or null if not found.
  */
-const loadEphemeralAgent = async ({ req, spec, agent_id, endpoint, model_parameters: _m }) => {
+const loadEphemeralAgent = async ({ req, agent_id, endpoint, model_parameters: _m }) => {
   const { model, ...model_parameters } = _m;
-  const modelSpecs = req.config?.modelSpecs?.list;
-  /** @type {TModelSpec | null} */
-  let modelSpec = null;
-  if (spec != null && spec !== '') {
-    modelSpec = modelSpecs?.find((s) => s.name === spec) || null;
-  }
+  /** @type {Record<string, FunctionTool>} */
+  const availableTools = await getCachedTools({ userId: req.user.id, includeGlobal: true });
   /** @type {TEphemeralAgent | null} */
   const ephemeralAgent = req.body.ephemeralAgent;
   const mcpServers = new Set(ephemeralAgent?.mcp);
-  const userId = req.user?.id; // note: userId cannot be undefined at runtime
-  if (modelSpec?.mcpServers) {
-    for (const mcpServer of modelSpec.mcpServers) {
-      mcpServers.add(mcpServer);
-    }
-  }
   /** @type {string[]} */
   const tools = [];
-  if (ephemeralAgent?.execute_code === true || modelSpec?.executeCode === true) {
+  if (ephemeralAgent?.execute_code === true) {
     tools.push(Tools.execute_code);
   }
-  if (ephemeralAgent?.file_search === true || modelSpec?.fileSearch === true) {
+  if (ephemeralAgent?.file_search === true) {
     tools.push(Tools.file_search);
   }
-  if (ephemeralAgent?.web_search === true || modelSpec?.webSearch === true) {
+  if (ephemeralAgent?.web_search === true) {
     tools.push(Tools.web_search);
   }
 
   const addedServers = new Set();
   if (mcpServers.size > 0) {
+    for (const toolName of Object.keys(availableTools)) {
+      if (!toolName.includes(mcp_delimiter)) {
+        continue;
+      }
+      const mcpServer = toolName.split(mcp_delimiter)?.[1];
+      if (mcpServer && mcpServers.has(mcpServer)) {
+        addedServers.add(mcpServer);
+        tools.push(toolName);
+      }
+    }
+
     for (const mcpServer of mcpServers) {
       if (addedServers.has(mcpServer)) {
         continue;
       }
-      const serverTools = await getMCPServerTools(userId, mcpServer);
-      if (!serverTools) {
-        tools.push(`${mcp_all}${mcp_delimiter}${mcpServer}`);
-        addedServers.add(mcpServer);
-        continue;
-      }
-      tools.push(...Object.keys(serverTools));
-      addedServers.add(mcpServer);
+      tools.push(`${mcp_all}${mcp_delimiter}${mcpServer}`);
     }
   }
 
@@ -135,18 +120,17 @@ const loadEphemeralAgent = async ({ req, spec, agent_id, endpoint, model_paramet
  *
  * @param {Object} params
  * @param {ServerRequest} params.req
- * @param {string} params.spec
  * @param {string} params.agent_id
  * @param {string} params.endpoint
  * @param {import('@librechat/agents').ClientOptions} [params.model_parameters]
  * @returns {Promise<Agent|null>} The agent document as a plain object, or null if not found.
  */
-const loadAgent = async ({ req, spec, agent_id, endpoint, model_parameters }) => {
+const loadAgent = async ({ req, agent_id, endpoint, model_parameters }) => {
   if (!agent_id) {
     return null;
   }
   if (agent_id === EPHEMERAL_AGENT_ID) {
-    return await loadEphemeralAgent({ req, spec, agent_id, endpoint, model_parameters });
+    return await loadEphemeralAgent({ req, agent_id, endpoint, model_parameters });
   }
   const agent = await getAgent({
     id: agent_id,
@@ -851,7 +835,6 @@ const countPromotedAgents = async () => {
 
 module.exports = {
   getAgent,
-  getAgents,
   loadAgent,
   createAgent,
   updateAgent,

api/models/Agent.spec.js

@@ -8,7 +8,6 @@ process.env.CREDS_IV = '0123456789abcdef';
 
 jest.mock('~/server/services/Config', () => ({
   getCachedTools: jest.fn(),
-  getMCPServerTools: jest.fn(),
 }));
 
 const mongoose = require('mongoose');
@@ -31,7 +30,7 @@ const {
   generateActionMetadataHash,
 } = require('./Agent');
 const permissionService = require('~/server/services/PermissionService');
-const { getCachedTools, getMCPServerTools } = require('~/server/services/Config');
+const { getCachedTools } = require('~/server/services/Config');
 const { AclEntry } = require('~/db/models');
 
 /**
@@ -1930,16 +1929,6 @@ describe('models/Agent', () => {
         another_tool: {},
       });
 
-      // Mock getMCPServerTools to return tools for each server
-      getMCPServerTools.mockImplementation(async (_userId, server) => {
-        if (server === 'server1') {
-          return { tool1_mcp_server1: {} };
-        } else if (server === 'server2') {
-          return { tool2_mcp_server2: {} };
-        }
-        return null;
-      });
-
       const mockReq = {
         user: { id: 'user123' },
         body: {
@@ -2124,14 +2113,6 @@ describe('models/Agent', () => {
 
         getCachedTools.mockResolvedValue(availableTools);
 
-        // Mock getMCPServerTools to return all tools for server1
-        getMCPServerTools.mockImplementation(async (_userId, server) => {
-          if (server === 'server1') {
-            return availableTools; // All 100 tools belong to server1
-          }
-          return null;
-        });
-
         const mockReq = {
           user: { id: 'user123' },
           body: {
@@ -2673,17 +2654,6 @@ describe('models/Agent', () => {
         tool_mcp_server2: {}, // Different server
       });
 
-      // Mock getMCPServerTools to return only tools matching the server
-      getMCPServerTools.mockImplementation(async (_userId, server) => {
-        if (server === 'server1') {
-          // Only return tool that correctly matches server1 format
-          return { tool_mcp_server1: {} };
-        } else if (server === 'server2') {
-          return { tool_mcp_server2: {} };
-        }
-        return null;
-      });
-
       const mockReq = {
         user: { id: 'user123' },
         body: {

api/models/Categories.js

@@ -1,4 +1,4 @@
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 const options = [
   {

api/models/Conversation.js

@@ -112,8 +112,17 @@ module.exports = {
         update.expiredAt = null;
       }
 
-      /** @type {{ $set: Partial<TConversation>; $unset?: Record<keyof TConversation, number> }} */
+      /** @type {{ $set: Partial<TConversation>; $addToSet?: Record<string, any>; $unset?: Record<keyof TConversation, number> }} */
       const updateOperation = { $set: update };
+
+      if (convo.model && convo.endpoint) {
+        updateOperation.$addToSet = {
+          modelHistory: {
+            model: convo.model,
+            endpoint: convo.endpoint,
+          },
+        };
+      }
       if (metadata && metadata.unsetFields && Object.keys(metadata.unsetFields).length > 0) {
         updateOperation.$unset = metadata.unsetFields;
       }
@@ -174,7 +183,7 @@ module.exports = {
 
     if (search) {
       try {
-        const meiliResults = await Conversation.meiliSearch(search, { filter: `user = "${user}"` });
+        const meiliResults = await Conversation.meiliSearch(search);
         const matchingIds = Array.isArray(meiliResults.hits)
           ? meiliResults.hits.map((result) => result.conversationId)
           : [];

api/models/ConversationTag.js

@@ -239,46 +239,10 @@ const updateTagsForConversation = async (user, conversationId, tags) => {
   }
 };
 
-/**
- * Increments tag counts for existing tags only.
- * @param {string} user - The user ID.
- * @param {string[]} tags - Array of tag names to increment
- * @returns {Promise<void>}
- */
-const bulkIncrementTagCounts = async (user, tags) => {
-  if (!tags || tags.length === 0) {
-    return;
-  }
-
-  try {
-    const uniqueTags = [...new Set(tags.filter(Boolean))];
-    if (uniqueTags.length === 0) {
-      return;
-    }
-
-    const bulkOps = uniqueTags.map((tag) => ({
-      updateOne: {
-        filter: { user, tag },
-        update: { $inc: { count: 1 } },
-      },
-    }));
-
-    const result = await ConversationTag.bulkWrite(bulkOps);
-    if (result && result.modifiedCount > 0) {
-      logger.debug(
-        `user: ${user} | Incremented tag counts - modified ${result.modifiedCount} tags`,
-      );
-    }
-  } catch (error) {
-    logger.error('[bulkIncrementTagCounts] Error incrementing tag counts', error);
-  }
-};
-
 module.exports = {
   getConversationTags,
   createConversationTag,
   updateConversationTag,
   deleteConversationTag,
-  bulkIncrementTagCounts,
   updateTagsForConversation,
 };

api/models/File.js

@@ -42,7 +42,7 @@ const getToolFilesByIds = async (fileIds, toolResourceSet) => {
       $or: [],
     };
 
-    if (toolResourceSet.has(EToolResources.context)) {
+    if (toolResourceSet.has(EToolResources.ocr)) {
       filter.$or.push({ text: { $exists: true, $ne: null }, context: FileContext.agents });
     }
     if (toolResourceSet.has(EToolResources.file_search)) {

api/models/spendTokens.js

@@ -1,4 +1,4 @@
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 const { createTransaction, createStructuredTransaction } = require('./Transaction');
 /**
  * Creates up to two transactions to record the spending of tokens.

api/models/tx.js

@@ -1,4 +1,4 @@
-const { matchModelName, findMatchingPattern } = require('@librechat/api');
+const { matchModelName } = require('@librechat/api');
 const defaultRate = 6;
 
 /**
@@ -6,58 +6,44 @@ const defaultRate = 6;
  * source: https://aws.amazon.com/bedrock/pricing/
  * */
 const bedrockValues = {
-  // Basic llama2 patterns (base defaults to smallest variant)
-  llama2: { prompt: 0.75, completion: 1.0 },
-  'llama-2': { prompt: 0.75, completion: 1.0 },
+  // Basic llama2 patterns
   'llama2-13b': { prompt: 0.75, completion: 1.0 },
+  'llama2:13b': { prompt: 0.75, completion: 1.0 },
   'llama2:70b': { prompt: 1.95, completion: 2.56 },
   'llama2-70b': { prompt: 1.95, completion: 2.56 },
 
-  // Basic llama3 patterns (base defaults to smallest variant)
-  llama3: { prompt: 0.3, completion: 0.6 },
-  'llama-3': { prompt: 0.3, completion: 0.6 },
+  // Basic llama3 patterns
   'llama3-8b': { prompt: 0.3, completion: 0.6 },
   'llama3:8b': { prompt: 0.3, completion: 0.6 },
   'llama3-70b': { prompt: 2.65, completion: 3.5 },
   'llama3:70b': { prompt: 2.65, completion: 3.5 },
 
-  // llama3-x-Nb pattern (base defaults to smallest variant)
-  'llama3-1': { prompt: 0.22, completion: 0.22 },
+  // llama3-x-Nb pattern
   'llama3-1-8b': { prompt: 0.22, completion: 0.22 },
   'llama3-1-70b': { prompt: 0.72, completion: 0.72 },
   'llama3-1-405b': { prompt: 2.4, completion: 2.4 },
-  'llama3-2': { prompt: 0.1, completion: 0.1 },
   'llama3-2-1b': { prompt: 0.1, completion: 0.1 },
   'llama3-2-3b': { prompt: 0.15, completion: 0.15 },
   'llama3-2-11b': { prompt: 0.16, completion: 0.16 },
   'llama3-2-90b': { prompt: 0.72, completion: 0.72 },
-  'llama3-3': { prompt: 2.65, completion: 3.5 },
-  'llama3-3-70b': { prompt: 2.65, completion: 3.5 },
 
-  // llama3.x:Nb pattern (base defaults to smallest variant)
-  'llama3.1': { prompt: 0.22, completion: 0.22 },
+  // llama3.x:Nb pattern
   'llama3.1:8b': { prompt: 0.22, completion: 0.22 },
   'llama3.1:70b': { prompt: 0.72, completion: 0.72 },
   'llama3.1:405b': { prompt: 2.4, completion: 2.4 },
-  'llama3.2': { prompt: 0.1, completion: 0.1 },
   'llama3.2:1b': { prompt: 0.1, completion: 0.1 },
   'llama3.2:3b': { prompt: 0.15, completion: 0.15 },
   'llama3.2:11b': { prompt: 0.16, completion: 0.16 },
   'llama3.2:90b': { prompt: 0.72, completion: 0.72 },
-  'llama3.3': { prompt: 2.65, completion: 3.5 },
-  'llama3.3:70b': { prompt: 2.65, completion: 3.5 },
 
-  // llama-3.x-Nb pattern (base defaults to smallest variant)
-  'llama-3.1': { prompt: 0.22, completion: 0.22 },
+  // llama-3.x-Nb pattern
   'llama-3.1-8b': { prompt: 0.22, completion: 0.22 },
   'llama-3.1-70b': { prompt: 0.72, completion: 0.72 },
   'llama-3.1-405b': { prompt: 2.4, completion: 2.4 },
-  'llama-3.2': { prompt: 0.1, completion: 0.1 },
   'llama-3.2-1b': { prompt: 0.1, completion: 0.1 },
   'llama-3.2-3b': { prompt: 0.15, completion: 0.15 },
   'llama-3.2-11b': { prompt: 0.16, completion: 0.16 },
   'llama-3.2-90b': { prompt: 0.72, completion: 0.72 },
-  'llama-3.3': { prompt: 2.65, completion: 3.5 },
   'llama-3.3-70b': { prompt: 2.65, completion: 3.5 },
   'mistral-7b': { prompt: 0.15, completion: 0.2 },
   'mistral-small': { prompt: 0.15, completion: 0.2 },
@@ -66,19 +52,15 @@ const bedrockValues = {
   'mistral-large-2407': { prompt: 3.0, completion: 9.0 },
   'command-text': { prompt: 1.5, completion: 2.0 },
   'command-light': { prompt: 0.3, completion: 0.6 },
-  // AI21 models
-  'j2-mid': { prompt: 12.5, completion: 12.5 },
-  'j2-ultra': { prompt: 18.8, completion: 18.8 },
-  'jamba-instruct': { prompt: 0.5, completion: 0.7 },
-  // Amazon Titan models
-  'titan-text-lite': { prompt: 0.15, completion: 0.2 },
-  'titan-text-express': { prompt: 0.2, completion: 0.6 },
-  'titan-text-premier': { prompt: 0.5, completion: 1.5 },
-  // Amazon Nova models
-  'nova-micro': { prompt: 0.035, completion: 0.14 },
-  'nova-lite': { prompt: 0.06, completion: 0.24 },
-  'nova-pro': { prompt: 0.8, completion: 3.2 },
-  'nova-premier': { prompt: 2.5, completion: 12.5 },
+  'ai21.j2-mid-v1': { prompt: 12.5, completion: 12.5 },
+  'ai21.j2-ultra-v1': { prompt: 18.8, completion: 18.8 },
+  'ai21.jamba-instruct-v1:0': { prompt: 0.5, completion: 0.7 },
+  'amazon.titan-text-lite-v1': { prompt: 0.15, completion: 0.2 },
+  'amazon.titan-text-express-v1': { prompt: 0.2, completion: 0.6 },
+  'amazon.titan-text-premier-v1:0': { prompt: 0.5, completion: 1.5 },
+  'amazon.nova-micro-v1:0': { prompt: 0.035, completion: 0.14 },
+  'amazon.nova-lite-v1:0': { prompt: 0.06, completion: 0.24 },
+  'amazon.nova-pro-v1:0': { prompt: 0.8, completion: 3.2 },
   'deepseek.r1': { prompt: 1.35, completion: 5.4 },
 };
 
@@ -89,136 +71,88 @@ const bedrockValues = {
  */
 const tokenValues = Object.assign(
   {
-    // Legacy token size mappings (generic patterns - check LAST)
     '8k': { prompt: 30, completion: 60 },
     '32k': { prompt: 60, completion: 120 },
     '4k': { prompt: 1.5, completion: 2 },
     '16k': { prompt: 3, completion: 4 },
-    // Generic fallback patterns (check LAST)
-    'claude-': { prompt: 0.8, completion: 2.4 },
-    deepseek: { prompt: 0.28, completion: 0.42 },
-    command: { prompt: 0.38, completion: 0.38 },
-    gemma: { prompt: 0.02, completion: 0.04 }, // Base pattern (using gemma-3n-e4b pricing)
-    gemini: { prompt: 0.5, completion: 1.5 },
-    'gpt-oss': { prompt: 0.05, completion: 0.2 },
-    // Specific model variants (check FIRST - more specific patterns at end)
     'gpt-3.5-turbo-1106': { prompt: 1, completion: 2 },
-    'gpt-3.5-turbo-0125': { prompt: 0.5, completion: 1.5 },
-    'gpt-4-1106': { prompt: 10, completion: 30 },
-    'gpt-4.1': { prompt: 2, completion: 8 },
-    'gpt-4.1-nano': { prompt: 0.1, completion: 0.4 },
-    'gpt-4.1-mini': { prompt: 0.4, completion: 1.6 },
-    'gpt-4.5': { prompt: 75, completion: 150 },
-    'gpt-4o': { prompt: 2.5, completion: 10 },
-    'gpt-4o-2024-05-13': { prompt: 5, completion: 15 },
-    'gpt-4o-mini': { prompt: 0.15, completion: 0.6 },
-    'gpt-5': { prompt: 1.25, completion: 10 },
-    'gpt-5-nano': { prompt: 0.05, completion: 0.4 },
-    'gpt-5-mini': { prompt: 0.25, completion: 2 },
-    'gpt-5-pro': { prompt: 15, completion: 120 },
-    o1: { prompt: 15, completion: 60 },
+    'o4-mini': { prompt: 1.1, completion: 4.4 },
+    'o3-mini': { prompt: 1.1, completion: 4.4 },
+    o3: { prompt: 2, completion: 8 },
     'o1-mini': { prompt: 1.1, completion: 4.4 },
     'o1-preview': { prompt: 15, completion: 60 },
-    o3: { prompt: 2, completion: 8 },
-    'o3-mini': { prompt: 1.1, completion: 4.4 },
-    'o4-mini': { prompt: 1.1, completion: 4.4 },
-    'claude-instant': { prompt: 0.8, completion: 2.4 },
-    'claude-2': { prompt: 8, completion: 24 },
-    'claude-2.1': { prompt: 8, completion: 24 },
-    'claude-3-haiku': { prompt: 0.25, completion: 1.25 },
-    'claude-3-sonnet': { prompt: 3, completion: 15 },
+    o1: { prompt: 15, completion: 60 },
+    'gpt-4.1-nano': { prompt: 0.1, completion: 0.4 },
+    'gpt-4.1-mini': { prompt: 0.4, completion: 1.6 },
+    'gpt-4.1': { prompt: 2, completion: 8 },
+    'gpt-4.5': { prompt: 75, completion: 150 },
+    'gpt-4o-mini': { prompt: 0.15, completion: 0.6 },
+    'gpt-5': { prompt: 1.25, completion: 10 },
+    'gpt-5-mini': { prompt: 0.25, completion: 2 },
+    'gpt-5-nano': { prompt: 0.05, completion: 0.4 },
+    'gpt-4o': { prompt: 2.5, completion: 10 },
+    'gpt-4o-2024-05-13': { prompt: 5, completion: 15 },
+    'gpt-4-1106': { prompt: 10, completion: 30 },
+    'gpt-3.5-turbo-0125': { prompt: 0.5, completion: 1.5 },
     'claude-3-opus': { prompt: 15, completion: 75 },
-    'claude-3-5-haiku': { prompt: 0.8, completion: 4 },
-    'claude-3.5-haiku': { prompt: 0.8, completion: 4 },
+    'claude-3-sonnet': { prompt: 3, completion: 15 },
     'claude-3-5-sonnet': { prompt: 3, completion: 15 },
     'claude-3.5-sonnet': { prompt: 3, completion: 15 },
     'claude-3-7-sonnet': { prompt: 3, completion: 15 },
     'claude-3.7-sonnet': { prompt: 3, completion: 15 },
-    'claude-haiku-4-5': { prompt: 1, completion: 5 },
-    'claude-opus-4': { prompt: 15, completion: 75 },
+    'claude-3-5-haiku': { prompt: 0.8, completion: 4 },
+    'claude-3.5-haiku': { prompt: 0.8, completion: 4 },
+    'claude-3-haiku': { prompt: 0.25, completion: 1.25 },
     'claude-sonnet-4': { prompt: 3, completion: 15 },
-    'command-r': { prompt: 0.5, completion: 1.5 },
+    'claude-opus-4': { prompt: 15, completion: 75 },
+    'claude-2.1': { prompt: 8, completion: 24 },
+    'claude-2': { prompt: 8, completion: 24 },
+    'claude-instant': { prompt: 0.8, completion: 2.4 },
+    'claude-': { prompt: 0.8, completion: 2.4 },
     'command-r-plus': { prompt: 3, completion: 15 },
-    'command-text': { prompt: 1.5, completion: 2.0 },
-    'deepseek-reasoner': { prompt: 0.28, completion: 0.42 },
-    'deepseek-r1': { prompt: 0.4, completion: 2.0 },
-    'deepseek-v3': { prompt: 0.2, completion: 0.8 },
-    'gemma-2': { prompt: 0.01, completion: 0.03 }, // Base pattern (using gemma-2-9b pricing)
-    'gemma-3': { prompt: 0.02, completion: 0.04 }, // Base pattern (using gemma-3n-e4b pricing)
-    'gemma-3-27b': { prompt: 0.09, completion: 0.16 },
-    'gemini-1.5': { prompt: 2.5, completion: 10 },
-    'gemini-1.5-flash': { prompt: 0.15, completion: 0.6 },
-    'gemini-1.5-flash-8b': { prompt: 0.075, completion: 0.3 },
-    'gemini-2.0': { prompt: 0.1, completion: 0.4 }, // Base pattern (using 2.0-flash pricing)
-    'gemini-2.0-flash': { prompt: 0.1, completion: 0.4 },
+    'command-r': { prompt: 0.5, completion: 1.5 },
+    'deepseek-reasoner': { prompt: 0.55, completion: 2.19 },
+    deepseek: { prompt: 0.14, completion: 0.28 },
+    /* cohere doesn't have rates for the older command models,
+  so this was from https://artificialanalysis.ai/models/command-light/providers */
+    command: { prompt: 0.38, completion: 0.38 },
+    gemma: { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
+    'gemma-2': { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
+    'gemma-3': { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
+    'gemma-3-27b': { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
     'gemini-2.0-flash-lite': { prompt: 0.075, completion: 0.3 },
-    'gemini-2.5': { prompt: 0.3, completion: 2.5 }, // Base pattern (using 2.5-flash pricing)
-    'gemini-2.5-flash': { prompt: 0.3, completion: 2.5 },
-    'gemini-2.5-flash-lite': { prompt: 0.1, completion: 0.4 },
+    'gemini-2.0-flash': { prompt: 0.1, completion: 0.4 },
+    'gemini-2.0': { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
     'gemini-2.5-pro': { prompt: 1.25, completion: 10 },
+    'gemini-2.5-flash': { prompt: 0.15, completion: 3.5 },
+    'gemini-2.5': { prompt: 0, completion: 0 }, // Free for a period of time
+    'gemini-1.5-flash-8b': { prompt: 0.075, completion: 0.3 },
+    'gemini-1.5-flash': { prompt: 0.15, completion: 0.6 },
+    'gemini-1.5': { prompt: 2.5, completion: 10 },
     'gemini-pro-vision': { prompt: 0.5, completion: 1.5 },
-    grok: { prompt: 2.0, completion: 10.0 }, // Base pattern defaults to grok-2
-    'grok-beta': { prompt: 5.0, completion: 15.0 },
-    'grok-vision-beta': { prompt: 5.0, completion: 15.0 },
-    'grok-2': { prompt: 2.0, completion: 10.0 },
-    'grok-2-1212': { prompt: 2.0, completion: 10.0 },
-    'grok-2-latest': { prompt: 2.0, completion: 10.0 },
-    'grok-2-vision': { prompt: 2.0, completion: 10.0 },
+    gemini: { prompt: 0.5, completion: 1.5 },
     'grok-2-vision-1212': { prompt: 2.0, completion: 10.0 },
     'grok-2-vision-latest': { prompt: 2.0, completion: 10.0 },
-    'grok-3': { prompt: 3.0, completion: 15.0 },
-    'grok-3-fast': { prompt: 5.0, completion: 25.0 },
-    'grok-3-mini': { prompt: 0.3, completion: 0.5 },
+    'grok-2-vision': { prompt: 2.0, completion: 10.0 },
+    'grok-vision-beta': { prompt: 5.0, completion: 15.0 },
+    'grok-2-1212': { prompt: 2.0, completion: 10.0 },
+    'grok-2-latest': { prompt: 2.0, completion: 10.0 },
+    'grok-2': { prompt: 2.0, completion: 10.0 },
     'grok-3-mini-fast': { prompt: 0.6, completion: 4 },
+    'grok-3-mini': { prompt: 0.3, completion: 0.5 },
+    'grok-3-fast': { prompt: 5.0, completion: 25.0 },
+    'grok-3': { prompt: 3.0, completion: 15.0 },
     'grok-4': { prompt: 3.0, completion: 15.0 },
-    codestral: { prompt: 0.3, completion: 0.9 },
-    'ministral-3b': { prompt: 0.04, completion: 0.04 },
-    'ministral-8b': { prompt: 0.1, completion: 0.1 },
-    'mistral-nemo': { prompt: 0.15, completion: 0.15 },
-    'mistral-saba': { prompt: 0.2, completion: 0.6 },
-    'pixtral-large': { prompt: 2.0, completion: 6.0 },
+    'grok-beta': { prompt: 5.0, completion: 15.0 },
     'mistral-large': { prompt: 2.0, completion: 6.0 },
-    'mixtral-8x22b': { prompt: 0.65, completion: 0.65 },
-    kimi: { prompt: 0.14, completion: 2.49 }, // Base pattern (using kimi-k2 pricing)
-    // GPT-OSS models (specific sizes)
-    'gpt-oss:20b': { prompt: 0.05, completion: 0.2 },
+    'pixtral-large': { prompt: 2.0, completion: 6.0 },
+    'mistral-saba': { prompt: 0.2, completion: 0.6 },
+    codestral: { prompt: 0.3, completion: 0.9 },
+    'ministral-8b': { prompt: 0.1, completion: 0.1 },
+    'ministral-3b': { prompt: 0.04, completion: 0.04 },
+    // GPT-OSS models
     'gpt-oss-20b': { prompt: 0.05, completion: 0.2 },
-    'gpt-oss:120b': { prompt: 0.15, completion: 0.6 },
     'gpt-oss-120b': { prompt: 0.15, completion: 0.6 },
-    // GLM models (Zhipu AI) - general to specific
-    glm4: { prompt: 0.1, completion: 0.1 },
-    'glm-4': { prompt: 0.1, completion: 0.1 },
-    'glm-4-32b': { prompt: 0.1, completion: 0.1 },
-    'glm-4.5': { prompt: 0.35, completion: 1.55 },
-    'glm-4.5-air': { prompt: 0.14, completion: 0.86 },
-    'glm-4.5v': { prompt: 0.6, completion: 1.8 },
-    'glm-4.6': { prompt: 0.5, completion: 1.75 },
-    // Qwen models
-    qwen: { prompt: 0.08, completion: 0.33 }, // Qwen base pattern (using qwen2.5-72b pricing)
-    'qwen2.5': { prompt: 0.08, completion: 0.33 }, // Qwen 2.5 base pattern
-    'qwen-turbo': { prompt: 0.05, completion: 0.2 },
-    'qwen-plus': { prompt: 0.4, completion: 1.2 },
-    'qwen-max': { prompt: 1.6, completion: 6.4 },
-    'qwq-32b': { prompt: 0.15, completion: 0.4 },
-    // Qwen3 models
-    qwen3: { prompt: 0.035, completion: 0.138 }, // Qwen3 base pattern (using qwen3-4b pricing)
-    'qwen3-8b': { prompt: 0.035, completion: 0.138 },
-    'qwen3-14b': { prompt: 0.05, completion: 0.22 },
-    'qwen3-30b-a3b': { prompt: 0.06, completion: 0.22 },
-    'qwen3-32b': { prompt: 0.05, completion: 0.2 },
-    'qwen3-235b-a22b': { prompt: 0.08, completion: 0.55 },
-    // Qwen3 VL (Vision-Language) models
-    'qwen3-vl-8b-thinking': { prompt: 0.18, completion: 2.1 },
-    'qwen3-vl-8b-instruct': { prompt: 0.18, completion: 0.69 },
-    'qwen3-vl-30b-a3b': { prompt: 0.29, completion: 1.0 },
-    'qwen3-vl-235b-a22b': { prompt: 0.3, completion: 1.2 },
-    // Qwen3 specialized models
-    'qwen3-max': { prompt: 1.2, completion: 6 },
-    'qwen3-coder': { prompt: 0.22, completion: 0.95 },
-    'qwen3-coder-30b-a3b': { prompt: 0.06, completion: 0.25 },
-    'qwen3-coder-plus': { prompt: 1, completion: 5 },
-    'qwen3-coder-flash': { prompt: 0.3, completion: 1.5 },
-    'qwen3-next-80b-a3b': { prompt: 0.1, completion: 0.8 },
   },
   bedrockValues,
 );
@@ -249,39 +183,67 @@ const cacheTokenValues = {
  * @returns {string|undefined} The key corresponding to the model name, or undefined if no match is found.
  */
 const getValueKey = (model, endpoint) => {
-  if (!model || typeof model !== 'string') {
-    return undefined;
-  }
-
-  // Use findMatchingPattern directly against tokenValues for efficient lookup
-  if (!endpoint || (typeof endpoint === 'string' && !tokenValues[endpoint])) {
-    const matchedKey = findMatchingPattern(model, tokenValues);
-    if (matchedKey) {
-      return matchedKey;
-    }
-  }
-
-  // Fallback: use matchModelName for edge cases and legacy handling
   const modelName = matchModelName(model, endpoint);
   if (!modelName) {
     return undefined;
   }
 
-  // Legacy token size mappings and aliases for older models
   if (modelName.includes('gpt-3.5-turbo-16k')) {
     return '16k';
+  } else if (modelName.includes('gpt-3.5-turbo-0125')) {
+    return 'gpt-3.5-turbo-0125';
+  } else if (modelName.includes('gpt-3.5-turbo-1106')) {
+    return 'gpt-3.5-turbo-1106';
   } else if (modelName.includes('gpt-3.5')) {
     return '4k';
+  } else if (modelName.includes('o4-mini')) {
+    return 'o4-mini';
+  } else if (modelName.includes('o4')) {
+    return 'o4';
+  } else if (modelName.includes('o3-mini')) {
+    return 'o3-mini';
+  } else if (modelName.includes('o3')) {
+    return 'o3';
+  } else if (modelName.includes('o1-preview')) {
+    return 'o1-preview';
+  } else if (modelName.includes('o1-mini')) {
+    return 'o1-mini';
+  } else if (modelName.includes('o1')) {
+    return 'o1';
+  } else if (modelName.includes('gpt-4.5')) {
+    return 'gpt-4.5';
+  } else if (modelName.includes('gpt-4.1-nano')) {
+    return 'gpt-4.1-nano';
+  } else if (modelName.includes('gpt-4.1-mini')) {
+    return 'gpt-4.1-mini';
+  } else if (modelName.includes('gpt-4.1')) {
+    return 'gpt-4.1';
+  } else if (modelName.includes('gpt-4o-2024-05-13')) {
+    return 'gpt-4o-2024-05-13';
+  } else if (modelName.includes('gpt-5-nano')) {
+    return 'gpt-5-nano';
+  } else if (modelName.includes('gpt-5-mini')) {
+    return 'gpt-5-mini';
+  } else if (modelName.includes('gpt-5')) {
+    return 'gpt-5';
+  } else if (modelName.includes('gpt-4o-mini')) {
+    return 'gpt-4o-mini';
+  } else if (modelName.includes('gpt-4o')) {
+    return 'gpt-4o';
   } else if (modelName.includes('gpt-4-vision')) {
-    return 'gpt-4-1106'; // Alias for gpt-4-vision
+    return 'gpt-4-1106';
+  } else if (modelName.includes('gpt-4-1106')) {
+    return 'gpt-4-1106';
   } else if (modelName.includes('gpt-4-0125')) {
-    return 'gpt-4-1106'; // Alias for gpt-4-0125
+    return 'gpt-4-1106';
   } else if (modelName.includes('gpt-4-turbo')) {
-    return 'gpt-4-1106'; // Alias for gpt-4-turbo
+    return 'gpt-4-1106';
   } else if (modelName.includes('gpt-4-32k')) {
     return '32k';
   } else if (modelName.includes('gpt-4')) {
     return '8k';
+  } else if (tokenValues[modelName]) {
+    return modelName;
   }
 
   return undefined;

api/models/tx.spec.js

@@ -1,4 +1,3 @@
-const { maxTokensMap } = require('@librechat/api');
 const { EModelEndpoint } = require('librechat-data-provider');
 const {
   defaultRate,
@@ -114,14 +113,6 @@ describe('getValueKey', () => {
     expect(getValueKey('gpt-5-nano-2025-01-30-0130')).toBe('gpt-5-nano');
   });
 
-  it('should return "gpt-5-pro" for model type of "gpt-5-pro"', () => {
-    expect(getValueKey('gpt-5-pro-2025-01-30')).toBe('gpt-5-pro');
-    expect(getValueKey('openai/gpt-5-pro')).toBe('gpt-5-pro');
-    expect(getValueKey('gpt-5-pro-0130')).toBe('gpt-5-pro');
-    expect(getValueKey('gpt-5-pro-2025-01-30-0130')).toBe('gpt-5-pro');
-    expect(getValueKey('gpt-5-pro-preview')).toBe('gpt-5-pro');
-  });
-
   it('should return "gpt-4o" for model type of "gpt-4o"', () => {
     expect(getValueKey('gpt-4o-2024-08-06')).toBe('gpt-4o');
     expect(getValueKey('gpt-4o-2024-08-06-0718')).toBe('gpt-4o');
@@ -193,16 +184,6 @@ describe('getValueKey', () => {
     expect(getValueKey('claude-3.5-haiku-turbo')).toBe('claude-3.5-haiku');
     expect(getValueKey('claude-3.5-haiku-0125')).toBe('claude-3.5-haiku');
   });
-
-  it('should return expected value keys for "gpt-oss" models', () => {
-    expect(getValueKey('openai/gpt-oss-120b')).toBe('gpt-oss-120b');
-    expect(getValueKey('openai/gpt-oss:120b')).toBe('gpt-oss:120b');
-    expect(getValueKey('openai/gpt-oss-570b')).toBe('gpt-oss');
-    expect(getValueKey('gpt-oss-570b')).toBe('gpt-oss');
-    expect(getValueKey('groq/gpt-oss-1080b')).toBe('gpt-oss');
-    expect(getValueKey('gpt-oss-20b')).toBe('gpt-oss-20b');
-    expect(getValueKey('oai/gpt-oss:20b')).toBe('gpt-oss:20b');
-  });
 });
 
 describe('getMultiplier', () => {
@@ -297,20 +278,6 @@ describe('getMultiplier', () => {
     );
   });
 
-  it('should return the correct multiplier for gpt-5-pro', () => {
-    const valueKey = getValueKey('gpt-5-pro-2025-01-30');
-    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-5-pro'].prompt);
-    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-pro'].completion,
-    );
-    expect(getMultiplier({ model: 'gpt-5-pro-preview', tokenType: 'prompt' })).toBe(
-      tokenValues['gpt-5-pro'].prompt,
-    );
-    expect(getMultiplier({ model: 'openai/gpt-5-pro', tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-pro'].completion,
-    );
-  });
-
   it('should return the correct multiplier for gpt-4o', () => {
     const valueKey = getValueKey('gpt-4o-2024-08-06');
     expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-4o'].prompt);
@@ -427,18 +394,6 @@ describe('getMultiplier', () => {
       expect(getMultiplier({ model: key, tokenType: 'completion' })).toBe(expectedCompletion);
     });
   });
-
-  it('should return correct multipliers for GLM models', () => {
-    const models = ['glm-4.6', 'glm-4.5v', 'glm-4.5-air', 'glm-4.5', 'glm-4-32b', 'glm-4', 'glm4'];
-    models.forEach((key) => {
-      const expectedPrompt = tokenValues[key].prompt;
-      const expectedCompletion = tokenValues[key].completion;
-      expect(getMultiplier({ valueKey: key, tokenType: 'prompt' })).toBe(expectedPrompt);
-      expect(getMultiplier({ valueKey: key, tokenType: 'completion' })).toBe(expectedCompletion);
-      expect(getMultiplier({ model: key, tokenType: 'prompt' })).toBe(expectedPrompt);
-      expect(getMultiplier({ model: key, tokenType: 'completion' })).toBe(expectedCompletion);
-    });
-  });
 });
 
 describe('AWS Bedrock Model Tests', () => {
@@ -494,249 +449,6 @@ describe('AWS Bedrock Model Tests', () => {
   });
 });
 
-describe('Amazon Model Tests', () => {
-  describe('Amazon Nova Models', () => {
-    it('should return correct pricing for nova-premier', () => {
-      expect(getMultiplier({ model: 'nova-premier', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-premier'].prompt,
-      );
-      expect(getMultiplier({ model: 'nova-premier', tokenType: 'completion' })).toBe(
-        tokenValues['nova-premier'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-premier-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-premier'].prompt,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-premier-v1:0', tokenType: 'completion' })).toBe(
-        tokenValues['nova-premier'].completion,
-      );
-    });
-
-    it('should return correct pricing for nova-pro', () => {
-      expect(getMultiplier({ model: 'nova-pro', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-pro'].prompt,
-      );
-      expect(getMultiplier({ model: 'nova-pro', tokenType: 'completion' })).toBe(
-        tokenValues['nova-pro'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-pro-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-pro'].prompt,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-pro-v1:0', tokenType: 'completion' })).toBe(
-        tokenValues['nova-pro'].completion,
-      );
-    });
-
-    it('should return correct pricing for nova-lite', () => {
-      expect(getMultiplier({ model: 'nova-lite', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-lite'].prompt,
-      );
-      expect(getMultiplier({ model: 'nova-lite', tokenType: 'completion' })).toBe(
-        tokenValues['nova-lite'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-lite-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-lite'].prompt,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-lite-v1:0', tokenType: 'completion' })).toBe(
-        tokenValues['nova-lite'].completion,
-      );
-    });
-
-    it('should return correct pricing for nova-micro', () => {
-      expect(getMultiplier({ model: 'nova-micro', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-micro'].prompt,
-      );
-      expect(getMultiplier({ model: 'nova-micro', tokenType: 'completion' })).toBe(
-        tokenValues['nova-micro'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-micro-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['nova-micro'].prompt,
-      );
-      expect(getMultiplier({ model: 'amazon.nova-micro-v1:0', tokenType: 'completion' })).toBe(
-        tokenValues['nova-micro'].completion,
-      );
-    });
-
-    it('should match both short and full model names to the same pricing', () => {
-      const models = ['nova-micro', 'nova-lite', 'nova-pro', 'nova-premier'];
-      const fullModels = [
-        'amazon.nova-micro-v1:0',
-        'amazon.nova-lite-v1:0',
-        'amazon.nova-pro-v1:0',
-        'amazon.nova-premier-v1:0',
-      ];
-
-      models.forEach((shortModel, i) => {
-        const fullModel = fullModels[i];
-        const shortPrompt = getMultiplier({ model: shortModel, tokenType: 'prompt' });
-        const fullPrompt = getMultiplier({ model: fullModel, tokenType: 'prompt' });
-        const shortCompletion = getMultiplier({ model: shortModel, tokenType: 'completion' });
-        const fullCompletion = getMultiplier({ model: fullModel, tokenType: 'completion' });
-
-        expect(shortPrompt).toBe(fullPrompt);
-        expect(shortCompletion).toBe(fullCompletion);
-        expect(shortPrompt).toBe(tokenValues[shortModel].prompt);
-        expect(shortCompletion).toBe(tokenValues[shortModel].completion);
-      });
-    });
-  });
-
-  describe('Amazon Titan Models', () => {
-    it('should return correct pricing for titan-text-premier', () => {
-      expect(getMultiplier({ model: 'titan-text-premier', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-premier'].prompt,
-      );
-      expect(getMultiplier({ model: 'titan-text-premier', tokenType: 'completion' })).toBe(
-        tokenValues['titan-text-premier'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.titan-text-premier-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-premier'].prompt,
-      );
-      expect(
-        getMultiplier({ model: 'amazon.titan-text-premier-v1:0', tokenType: 'completion' }),
-      ).toBe(tokenValues['titan-text-premier'].completion);
-    });
-
-    it('should return correct pricing for titan-text-express', () => {
-      expect(getMultiplier({ model: 'titan-text-express', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-express'].prompt,
-      );
-      expect(getMultiplier({ model: 'titan-text-express', tokenType: 'completion' })).toBe(
-        tokenValues['titan-text-express'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.titan-text-express-v1', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-express'].prompt,
-      );
-      expect(
-        getMultiplier({ model: 'amazon.titan-text-express-v1', tokenType: 'completion' }),
-      ).toBe(tokenValues['titan-text-express'].completion);
-    });
-
-    it('should return correct pricing for titan-text-lite', () => {
-      expect(getMultiplier({ model: 'titan-text-lite', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-lite'].prompt,
-      );
-      expect(getMultiplier({ model: 'titan-text-lite', tokenType: 'completion' })).toBe(
-        tokenValues['titan-text-lite'].completion,
-      );
-      expect(getMultiplier({ model: 'amazon.titan-text-lite-v1', tokenType: 'prompt' })).toBe(
-        tokenValues['titan-text-lite'].prompt,
-      );
-      expect(getMultiplier({ model: 'amazon.titan-text-lite-v1', tokenType: 'completion' })).toBe(
-        tokenValues['titan-text-lite'].completion,
-      );
-    });
-
-    it('should match both short and full model names to the same pricing', () => {
-      const models = ['titan-text-lite', 'titan-text-express', 'titan-text-premier'];
-      const fullModels = [
-        'amazon.titan-text-lite-v1',
-        'amazon.titan-text-express-v1',
-        'amazon.titan-text-premier-v1:0',
-      ];
-
-      models.forEach((shortModel, i) => {
-        const fullModel = fullModels[i];
-        const shortPrompt = getMultiplier({ model: shortModel, tokenType: 'prompt' });
-        const fullPrompt = getMultiplier({ model: fullModel, tokenType: 'prompt' });
-        const shortCompletion = getMultiplier({ model: shortModel, tokenType: 'completion' });
-        const fullCompletion = getMultiplier({ model: fullModel, tokenType: 'completion' });
-
-        expect(shortPrompt).toBe(fullPrompt);
-        expect(shortCompletion).toBe(fullCompletion);
-        expect(shortPrompt).toBe(tokenValues[shortModel].prompt);
-        expect(shortCompletion).toBe(tokenValues[shortModel].completion);
-      });
-    });
-  });
-});
-
-describe('AI21 Model Tests', () => {
-  describe('AI21 J2 Models', () => {
-    it('should return correct pricing for j2-mid', () => {
-      expect(getMultiplier({ model: 'j2-mid', tokenType: 'prompt' })).toBe(
-        tokenValues['j2-mid'].prompt,
-      );
-      expect(getMultiplier({ model: 'j2-mid', tokenType: 'completion' })).toBe(
-        tokenValues['j2-mid'].completion,
-      );
-      expect(getMultiplier({ model: 'ai21.j2-mid-v1', tokenType: 'prompt' })).toBe(
-        tokenValues['j2-mid'].prompt,
-      );
-      expect(getMultiplier({ model: 'ai21.j2-mid-v1', tokenType: 'completion' })).toBe(
-        tokenValues['j2-mid'].completion,
-      );
-    });
-
-    it('should return correct pricing for j2-ultra', () => {
-      expect(getMultiplier({ model: 'j2-ultra', tokenType: 'prompt' })).toBe(
-        tokenValues['j2-ultra'].prompt,
-      );
-      expect(getMultiplier({ model: 'j2-ultra', tokenType: 'completion' })).toBe(
-        tokenValues['j2-ultra'].completion,
-      );
-      expect(getMultiplier({ model: 'ai21.j2-ultra-v1', tokenType: 'prompt' })).toBe(
-        tokenValues['j2-ultra'].prompt,
-      );
-      expect(getMultiplier({ model: 'ai21.j2-ultra-v1', tokenType: 'completion' })).toBe(
-        tokenValues['j2-ultra'].completion,
-      );
-    });
-
-    it('should match both short and full model names to the same pricing', () => {
-      const models = ['j2-mid', 'j2-ultra'];
-      const fullModels = ['ai21.j2-mid-v1', 'ai21.j2-ultra-v1'];
-
-      models.forEach((shortModel, i) => {
-        const fullModel = fullModels[i];
-        const shortPrompt = getMultiplier({ model: shortModel, tokenType: 'prompt' });
-        const fullPrompt = getMultiplier({ model: fullModel, tokenType: 'prompt' });
-        const shortCompletion = getMultiplier({ model: shortModel, tokenType: 'completion' });
-        const fullCompletion = getMultiplier({ model: fullModel, tokenType: 'completion' });
-
-        expect(shortPrompt).toBe(fullPrompt);
-        expect(shortCompletion).toBe(fullCompletion);
-        expect(shortPrompt).toBe(tokenValues[shortModel].prompt);
-        expect(shortCompletion).toBe(tokenValues[shortModel].completion);
-      });
-    });
-  });
-
-  describe('AI21 Jamba Models', () => {
-    it('should return correct pricing for jamba-instruct', () => {
-      expect(getMultiplier({ model: 'jamba-instruct', tokenType: 'prompt' })).toBe(
-        tokenValues['jamba-instruct'].prompt,
-      );
-      expect(getMultiplier({ model: 'jamba-instruct', tokenType: 'completion' })).toBe(
-        tokenValues['jamba-instruct'].completion,
-      );
-      expect(getMultiplier({ model: 'ai21.jamba-instruct-v1:0', tokenType: 'prompt' })).toBe(
-        tokenValues['jamba-instruct'].prompt,
-      );
-      expect(getMultiplier({ model: 'ai21.jamba-instruct-v1:0', tokenType: 'completion' })).toBe(
-        tokenValues['jamba-instruct'].completion,
-      );
-    });
-
-    it('should match both short and full model names to the same pricing', () => {
-      const shortPrompt = getMultiplier({ model: 'jamba-instruct', tokenType: 'prompt' });
-      const fullPrompt = getMultiplier({
-        model: 'ai21.jamba-instruct-v1:0',
-        tokenType: 'prompt',
-      });
-      const shortCompletion = getMultiplier({ model: 'jamba-instruct', tokenType: 'completion' });
-      const fullCompletion = getMultiplier({
-        model: 'ai21.jamba-instruct-v1:0',
-        tokenType: 'completion',
-      });
-
-      expect(shortPrompt).toBe(fullPrompt);
-      expect(shortCompletion).toBe(fullCompletion);
-      expect(shortPrompt).toBe(tokenValues['jamba-instruct'].prompt);
-      expect(shortCompletion).toBe(tokenValues['jamba-instruct'].completion);
-    });
-  });
-});
-
 describe('Deepseek Model Tests', () => {
   const deepseekModels = ['deepseek-chat', 'deepseek-coder', 'deepseek-reasoner', 'deepseek.r1'];
 
@@ -768,187 +480,6 @@ describe('Deepseek Model Tests', () => {
   });
 });
 
-describe('Qwen3 Model Tests', () => {
-  describe('Qwen3 Base Models', () => {
-    it('should return correct pricing for qwen3 base pattern', () => {
-      expect(getMultiplier({ model: 'qwen3', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-4b (falls back to qwen3)', () => {
-      expect(getMultiplier({ model: 'qwen3-4b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-4b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-8b', () => {
-      expect(getMultiplier({ model: 'qwen3-8b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-8b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-8b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-8b'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-14b', () => {
-      expect(getMultiplier({ model: 'qwen3-14b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-14b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-14b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-14b'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-235b-a22b', () => {
-      expect(getMultiplier({ model: 'qwen3-235b-a22b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-235b-a22b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-235b-a22b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-235b-a22b'].completion,
-      );
-    });
-
-    it('should handle model name variations with provider prefixes', () => {
-      const models = [
-        { input: 'qwen3', expected: 'qwen3' },
-        { input: 'qwen3-4b', expected: 'qwen3' },
-        { input: 'qwen3-8b', expected: 'qwen3-8b' },
-        { input: 'qwen3-32b', expected: 'qwen3-32b' },
-      ];
-      models.forEach(({ input, expected }) => {
-        const withPrefix = `alibaba/${input}`;
-        expect(getMultiplier({ model: withPrefix, tokenType: 'prompt' })).toBe(
-          tokenValues[expected].prompt,
-        );
-        expect(getMultiplier({ model: withPrefix, tokenType: 'completion' })).toBe(
-          tokenValues[expected].completion,
-        );
-      });
-    });
-  });
-
-  describe('Qwen3 VL (Vision-Language) Models', () => {
-    it('should return correct pricing for qwen3-vl-8b-thinking', () => {
-      expect(getMultiplier({ model: 'qwen3-vl-8b-thinking', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-vl-8b-thinking'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-vl-8b-thinking', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-vl-8b-thinking'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-vl-8b-instruct', () => {
-      expect(getMultiplier({ model: 'qwen3-vl-8b-instruct', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-vl-8b-instruct'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-vl-8b-instruct', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-vl-8b-instruct'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-vl-30b-a3b', () => {
-      expect(getMultiplier({ model: 'qwen3-vl-30b-a3b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-vl-30b-a3b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-vl-30b-a3b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-vl-30b-a3b'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-vl-235b-a22b', () => {
-      expect(getMultiplier({ model: 'qwen3-vl-235b-a22b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-vl-235b-a22b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-vl-235b-a22b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-vl-235b-a22b'].completion,
-      );
-    });
-  });
-
-  describe('Qwen3 Specialized Models', () => {
-    it('should return correct pricing for qwen3-max', () => {
-      expect(getMultiplier({ model: 'qwen3-max', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-max'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-max', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-max'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-coder', () => {
-      expect(getMultiplier({ model: 'qwen3-coder', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-coder'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-coder', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-coder'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-coder-plus', () => {
-      expect(getMultiplier({ model: 'qwen3-coder-plus', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-coder-plus'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-coder-plus', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-coder-plus'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-coder-flash', () => {
-      expect(getMultiplier({ model: 'qwen3-coder-flash', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-coder-flash'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-coder-flash', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-coder-flash'].completion,
-      );
-    });
-
-    it('should return correct pricing for qwen3-next-80b-a3b', () => {
-      expect(getMultiplier({ model: 'qwen3-next-80b-a3b', tokenType: 'prompt' })).toBe(
-        tokenValues['qwen3-next-80b-a3b'].prompt,
-      );
-      expect(getMultiplier({ model: 'qwen3-next-80b-a3b', tokenType: 'completion' })).toBe(
-        tokenValues['qwen3-next-80b-a3b'].completion,
-      );
-    });
-  });
-
-  describe('Qwen3 Model Variations', () => {
-    it('should handle all qwen3 models with provider prefixes', () => {
-      const models = ['qwen3', 'qwen3-8b', 'qwen3-max', 'qwen3-coder', 'qwen3-vl-8b-instruct'];
-      const prefixes = ['alibaba', 'qwen', 'openrouter'];
-
-      models.forEach((model) => {
-        prefixes.forEach((prefix) => {
-          const fullModel = `${prefix}/${model}`;
-          expect(getMultiplier({ model: fullModel, tokenType: 'prompt' })).toBe(
-            tokenValues[model].prompt,
-          );
-          expect(getMultiplier({ model: fullModel, tokenType: 'completion' })).toBe(
-            tokenValues[model].completion,
-          );
-        });
-      });
-    });
-
-    it('should handle qwen3-4b falling back to qwen3 base pattern', () => {
-      const testCases = ['qwen3-4b', 'alibaba/qwen3-4b', 'qwen/qwen3-4b-preview'];
-      testCases.forEach((model) => {
-        expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(tokenValues['qwen3'].prompt);
-        expect(getMultiplier({ model, tokenType: 'completion' })).toBe(
-          tokenValues['qwen3'].completion,
-        );
-      });
-    });
-  });
-});
-
 describe('getCacheMultiplier', () => {
   it('should return the correct cache multiplier for a given valueKey and cacheType', () => {
     expect(getCacheMultiplier({ valueKey: 'claude-3-5-sonnet', cacheType: 'write' })).toBe(
@@ -1040,9 +571,6 @@ describe('getCacheMultiplier', () => {
 
 describe('Google Model Tests', () => {
   const googleModels = [
-    'gemini-2.5-pro',
-    'gemini-2.5-flash',
-    'gemini-2.5-flash-lite',
     'gemini-2.5-pro-preview-05-06',
     'gemini-2.5-flash-preview-04-17',
     'gemini-2.5-exp',
@@ -1083,9 +611,6 @@ describe('Google Model Tests', () => {
 
   it('should map to the correct model keys', () => {
     const expected = {
-      'gemini-2.5-pro': 'gemini-2.5-pro',
-      'gemini-2.5-flash': 'gemini-2.5-flash',
-      'gemini-2.5-flash-lite': 'gemini-2.5-flash-lite',
       'gemini-2.5-pro-preview-05-06': 'gemini-2.5-pro',
       'gemini-2.5-flash-preview-04-17': 'gemini-2.5-flash',
       'gemini-2.5-exp': 'gemini-2.5',
@@ -1241,110 +766,6 @@ describe('Grok Model Tests - Pricing', () => {
   });
 });
 
-describe('GLM Model Tests', () => {
-  it('should return expected value keys for GLM models', () => {
-    expect(getValueKey('glm-4.6')).toBe('glm-4.6');
-    expect(getValueKey('glm-4.5')).toBe('glm-4.5');
-    expect(getValueKey('glm-4.5v')).toBe('glm-4.5v');
-    expect(getValueKey('glm-4.5-air')).toBe('glm-4.5-air');
-    expect(getValueKey('glm-4-32b')).toBe('glm-4-32b');
-    expect(getValueKey('glm-4')).toBe('glm-4');
-    expect(getValueKey('glm4')).toBe('glm4');
-  });
-
-  it('should match GLM model variations with provider prefixes', () => {
-    expect(getValueKey('z-ai/glm-4.6')).toBe('glm-4.6');
-    expect(getValueKey('z-ai/glm-4.5')).toBe('glm-4.5');
-    expect(getValueKey('z-ai/glm-4.5-air')).toBe('glm-4.5-air');
-    expect(getValueKey('z-ai/glm-4.5v')).toBe('glm-4.5v');
-    expect(getValueKey('z-ai/glm-4-32b')).toBe('glm-4-32b');
-
-    expect(getValueKey('zai/glm-4.6')).toBe('glm-4.6');
-    expect(getValueKey('zai/glm-4.5')).toBe('glm-4.5');
-    expect(getValueKey('zai/glm-4.5-air')).toBe('glm-4.5-air');
-    expect(getValueKey('zai/glm-4.5v')).toBe('glm-4.5v');
-
-    expect(getValueKey('zai-org/GLM-4.6')).toBe('glm-4.6');
-    expect(getValueKey('zai-org/GLM-4.5')).toBe('glm-4.5');
-    expect(getValueKey('zai-org/GLM-4.5-Air')).toBe('glm-4.5-air');
-    expect(getValueKey('zai-org/GLM-4.5V')).toBe('glm-4.5v');
-    expect(getValueKey('zai-org/GLM-4-32B-0414')).toBe('glm-4-32b');
-  });
-
-  it('should match GLM model variations with suffixes', () => {
-    expect(getValueKey('glm-4.6-fp8')).toBe('glm-4.6');
-    expect(getValueKey('zai-org/GLM-4.6-FP8')).toBe('glm-4.6');
-    expect(getValueKey('zai-org/GLM-4.5-Air-FP8')).toBe('glm-4.5-air');
-  });
-
-  it('should prioritize more specific GLM model patterns', () => {
-    expect(getValueKey('glm-4.5-air-something')).toBe('glm-4.5-air');
-    expect(getValueKey('glm-4.5-something')).toBe('glm-4.5');
-    expect(getValueKey('glm-4.5v-something')).toBe('glm-4.5v');
-  });
-
-  it('should return correct multipliers for all GLM models', () => {
-    expect(getMultiplier({ model: 'glm-4.6', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.6'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4.6', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4.6'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm-4.5v', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.5v'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4.5v', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4.5v'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm-4.5-air', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.5-air'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4.5-air', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4.5-air'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm-4.5', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.5'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4.5', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4.5'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm-4-32b', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4-32b'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4-32b', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4-32b'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm-4', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4'].prompt,
-    );
-    expect(getMultiplier({ model: 'glm-4', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4'].completion,
-    );
-
-    expect(getMultiplier({ model: 'glm4', tokenType: 'prompt' })).toBe(tokenValues['glm4'].prompt);
-    expect(getMultiplier({ model: 'glm4', tokenType: 'completion' })).toBe(
-      tokenValues['glm4'].completion,
-    );
-  });
-
-  it('should return correct multipliers for GLM models with provider prefixes', () => {
-    expect(getMultiplier({ model: 'z-ai/glm-4.6', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.6'].prompt,
-    );
-    expect(getMultiplier({ model: 'zai/glm-4.5-air', tokenType: 'completion' })).toBe(
-      tokenValues['glm-4.5-air'].completion,
-    );
-    expect(getMultiplier({ model: 'zai-org/GLM-4.5V', tokenType: 'prompt' })).toBe(
-      tokenValues['glm-4.5v'].prompt,
-    );
-  });
-});
-
 describe('Claude Model Tests', () => {
   it('should return correct prompt and completion rates for Claude 4 models', () => {
     expect(getMultiplier({ model: 'claude-sonnet-4', tokenType: 'prompt' })).toBe(
@@ -1361,37 +782,6 @@ describe('Claude Model Tests', () => {
     );
   });
 
-  it('should return correct prompt and completion rates for Claude Haiku 4.5', () => {
-    expect(getMultiplier({ model: 'claude-haiku-4-5', tokenType: 'prompt' })).toBe(
-      tokenValues['claude-haiku-4-5'].prompt,
-    );
-    expect(getMultiplier({ model: 'claude-haiku-4-5', tokenType: 'completion' })).toBe(
-      tokenValues['claude-haiku-4-5'].completion,
-    );
-  });
-
-  it('should handle Claude Haiku 4.5 model name variations', () => {
-    const modelVariations = [
-      'claude-haiku-4-5',
-      'claude-haiku-4-5-20250420',
-      'claude-haiku-4-5-latest',
-      'anthropic/claude-haiku-4-5',
-      'claude-haiku-4-5/anthropic',
-      'claude-haiku-4-5-preview',
-    ];
-
-    modelVariations.forEach((model) => {
-      const valueKey = getValueKey(model);
-      expect(valueKey).toBe('claude-haiku-4-5');
-      expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(
-        tokenValues['claude-haiku-4-5'].prompt,
-      );
-      expect(getMultiplier({ model, tokenType: 'completion' })).toBe(
-        tokenValues['claude-haiku-4-5'].completion,
-      );
-    });
-  });
-
   it('should handle Claude 4 model name variations with different prefixes and suffixes', () => {
     const modelVariations = [
       'claude-sonnet-4',
@@ -1469,119 +859,3 @@ describe('Claude Model Tests', () => {
     });
   });
 });
-
-describe('tokens.ts and tx.js sync validation', () => {
-  it('should resolve all models in maxTokensMap to pricing via getValueKey', () => {
-    const tokensKeys = Object.keys(maxTokensMap[EModelEndpoint.openAI]);
-    const txKeys = Object.keys(tokenValues);
-
-    const unresolved = [];
-
-    tokensKeys.forEach((key) => {
-      // Skip legacy token size mappings (e.g., '4k', '8k', '16k', '32k')
-      if (/^\d+k$/.test(key)) return;
-
-      // Skip generic pattern keys (end with '-' or ':')
-      if (key.endsWith('-') || key.endsWith(':')) return;
-
-      // Try to resolve via getValueKey
-      const resolvedKey = getValueKey(key);
-
-      // If it resolves and the resolved key has pricing, success
-      if (resolvedKey && txKeys.includes(resolvedKey)) return;
-
-      // If it resolves to a legacy key (4k, 8k, etc), also OK
-      if (resolvedKey && /^\d+k$/.test(resolvedKey)) return;
-
-      // If we get here, this model can't get pricing - flag it
-      unresolved.push({
-        key,
-        resolvedKey: resolvedKey || 'undefined',
-        context: maxTokensMap[EModelEndpoint.openAI][key],
-      });
-    });
-
-    if (unresolved.length > 0) {
-      console.log('\nModels that cannot resolve to pricing via getValueKey:');
-      unresolved.forEach(({ key, resolvedKey, context }) => {
-        console.log(`  - '${key}' → '${resolvedKey}' (context: ${context})`);
-      });
-    }
-
-    expect(unresolved).toEqual([]);
-  });
-
-  it('should not have redundant dated variants with same pricing and context as base model', () => {
-    const txKeys = Object.keys(tokenValues);
-    const redundant = [];
-
-    txKeys.forEach((key) => {
-      // Check if this is a dated variant (ends with -YYYY-MM-DD)
-      if (key.match(/.*-\d{4}-\d{2}-\d{2}$/)) {
-        const baseKey = key.replace(/-\d{4}-\d{2}-\d{2}$/, '');
-
-        if (txKeys.includes(baseKey)) {
-          const variantPricing = tokenValues[key];
-          const basePricing = tokenValues[baseKey];
-          const variantContext = maxTokensMap[EModelEndpoint.openAI][key];
-          const baseContext = maxTokensMap[EModelEndpoint.openAI][baseKey];
-
-          const samePricing =
-            variantPricing.prompt === basePricing.prompt &&
-            variantPricing.completion === basePricing.completion;
-          const sameContext = variantContext === baseContext;
-
-          if (samePricing && sameContext) {
-            redundant.push({
-              key,
-              baseKey,
-              pricing: `${variantPricing.prompt}/${variantPricing.completion}`,
-              context: variantContext,
-            });
-          }
-        }
-      }
-    });
-
-    if (redundant.length > 0) {
-      console.log('\nRedundant dated variants found (same pricing and context as base):');
-      redundant.forEach(({ key, baseKey, pricing, context }) => {
-        console.log(`  - '${key}' → '${baseKey}' (pricing: ${pricing}, context: ${context})`);
-        console.log(`    Can be removed - pattern matching will handle it`);
-      });
-    }
-
-    expect(redundant).toEqual([]);
-  });
-
-  it('should have context windows in tokens.ts for all models with pricing in tx.js (openAI catch-all)', () => {
-    const txKeys = Object.keys(tokenValues);
-    const missingContext = [];
-
-    txKeys.forEach((key) => {
-      // Skip legacy token size mappings (4k, 8k, 16k, 32k)
-      if (/^\d+k$/.test(key)) return;
-
-      // Check if this model has a context window defined
-      const context = maxTokensMap[EModelEndpoint.openAI][key];
-
-      if (!context) {
-        const pricing = tokenValues[key];
-        missingContext.push({
-          key,
-          pricing: `${pricing.prompt}/${pricing.completion}`,
-        });
-      }
-    });
-
-    if (missingContext.length > 0) {
-      console.log('\nModels with pricing but missing context in tokens.ts:');
-      missingContext.forEach(({ key, pricing }) => {
-        console.log(`  - '${key}' (pricing: ${pricing})`);
-        console.log(`    Add to tokens.ts openAIModels/bedrockModels/etc.`);
-      });
-    }
-
-    expect(missingContext).toEqual([]);
-  });
-});

api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/backend",
-  "version": "v0.8.1-rc1",
+  "version": "v0.8.0-rc4",
   "description": "",
   "scripts": {
     "start": "echo 'please run this from the root directory'",
@@ -47,8 +47,9 @@
     "@langchain/core": "^0.3.62",
     "@langchain/google-genai": "^0.2.13",
     "@langchain/google-vertexai": "^0.2.13",
+    "@langchain/openai": "^0.5.18",
     "@langchain/textsplitters": "^0.1.0",
-    "@librechat/agents": "^2.4.90",
+    "@librechat/agents": "^2.4.79",
     "@librechat/api": "*",
     "@librechat/data-schemas": "*",
     "@microsoft/microsoft-graph-client": "^3.0.7",
@@ -93,7 +94,7 @@
     "multer": "^2.0.2",
     "nanoid": "^3.3.7",
     "node-fetch": "^2.7.0",
-    "nodemailer": "^7.0.9",
+    "nodemailer": "^6.9.15",
     "ollama": "^0.5.0",
     "openai": "^5.10.1",
     "openid-client": "^6.5.0",

api/server/controllers/AuthController.js

@@ -1,8 +1,8 @@
 const cookies = require('cookie');
 const jwt = require('jsonwebtoken');
 const openIdClient = require('openid-client');
+const { isEnabled } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { isEnabled, findOpenIDUser } = require('@librechat/api');
 const {
   requestPasswordReset,
   setOpenIDAuthTokens,
@@ -11,9 +11,8 @@ const {
   registerUser,
 } = require('~/server/services/AuthService');
 const { findUser, getUserById, deleteAllUserSessions, findSession } = require('~/models');
-const { getGraphApiToken } = require('~/server/services/GraphTokenService');
-const { getOAuthReconnectionManager } = require('~/config');
 const { getOpenIdConfig } = require('~/strategies');
+const { getGraphApiToken } = require('~/server/services/GraphTokenService');
 
 const registrationController = async (req, res) => {
   try {
@@ -72,14 +71,8 @@ const refreshController = async (req, res) => {
       const openIdConfig = getOpenIdConfig();
       const tokenset = await openIdClient.refreshTokenGrant(openIdConfig, refreshToken);
       const claims = tokenset.claims();
-      const { user, error } = await findOpenIDUser({
-        findUser,
-        email: claims.email,
-        openidId: claims.sub,
-        idOnTheSource: claims.oid,
-        strategyName: 'refreshController',
-      });
-      if (error || !user) {
+      const user = await findUser({ email: claims.email });
+      if (!user) {
         return res.status(401).redirect('/login');
       }
       const token = setOpenIDAuthTokens(tokenset, res, user._id.toString());
@@ -103,29 +96,14 @@ const refreshController = async (req, res) => {
       return res.status(200).send({ token, user });
     }
 
-    /** Session with the hashed refresh token */
-    const session = await findSession(
-      {
-        userId: userId,
-        refreshToken: refreshToken,
-      },
-      { lean: false },
-    );
+    // Find the session with the hashed refresh token
+    const session = await findSession({
+      userId: userId,
+      refreshToken: refreshToken,
+    });
 
     if (session && session.expiration > new Date()) {
-      const token = await setAuthTokens(userId, res, session);
-
-      // trigger OAuth MCP server reconnection asynchronously (best effort)
-      try {
-        void getOAuthReconnectionManager()
-          .reconnectServers(userId)
-          .catch((err) => {
-            logger.error('[refreshController] Error reconnecting OAuth MCP servers:', err);
-          });
-      } catch (err) {
-        logger.warn(`[refreshController] Cannot attempt OAuth MCP servers reconnection:`, err);
-      }
-
+      const token = await setAuthTokens(userId, res, session._id);
       res.status(200).send({ token, user });
     } else if (req?.query?.retry) {
       // Retrying from a refresh token request that failed (401)
@@ -136,7 +114,7 @@ const refreshController = async (req, res) => {
       res.status(401).send('Refresh token expired or not found for this user');
     }
   } catch (err) {
-    logger.error(`[refreshController] Invalid refresh token:`, err);
+    logger.error(`[refreshController] Refresh token: ${refreshToken}`, err);
     res.status(403).send('Invalid refresh token');
   }
 };

api/server/controllers/ModelController.js

@@ -1,7 +1,7 @@
-const { logger } = require('@librechat/data-schemas');
 const { CacheKeys } = require('librechat-data-provider');
 const { loadDefaultModels, loadConfigModels } = require('~/server/services/Config');
 const { getLogStores } = require('~/cache');
+const { logger } = require('~/config');
 
 /**
  * @param {ServerRequest} req

api/server/controllers/PluginController.js

@@ -1,9 +1,16 @@
 const { logger } = require('@librechat/data-schemas');
-const { CacheKeys } = require('librechat-data-provider');
-const { getToolkitKey, checkPluginAuth, filterUniquePlugins } = require('@librechat/api');
-const { getCachedTools, setCachedTools } = require('~/server/services/Config');
+const { CacheKeys, Constants } = require('librechat-data-provider');
+const {
+  getToolkitKey,
+  checkPluginAuth,
+  filterUniquePlugins,
+  convertMCPToolToPlugin,
+  convertMCPToolsToPlugins,
+} = require('@librechat/api');
+const { getCachedTools, setCachedTools, mergeUserTools } = require('~/server/services/Config');
 const { availableTools, toolkits } = require('~/app/clients/tools');
 const { getAppConfig } = require('~/server/services/Config');
+const { getMCPManager } = require('~/config');
 const { getLogStores } = require('~/cache');
 
 const getAvailablePluginsController = async (req, res) => {
@@ -65,27 +72,63 @@ const getAvailableTools = async (req, res) => {
     }
     const cache = getLogStores(CacheKeys.CONFIG_STORE);
     const cachedToolsArray = await cache.get(CacheKeys.TOOLS);
+    const cachedUserTools = await getCachedTools({ userId });
 
     const appConfig = req.config ?? (await getAppConfig({ role: req.user?.role }));
 
-    // Return early if we have cached tools
-    if (cachedToolsArray != null) {
-      res.status(200).json(cachedToolsArray);
+    /** @type {TPlugin[]} */
+    let mcpPlugins;
+    if (appConfig?.mcpConfig) {
+      const mcpManager = getMCPManager();
+      mcpPlugins =
+        cachedUserTools != null
+          ? convertMCPToolsToPlugins({ functionTools: cachedUserTools, mcpManager })
+          : undefined;
+    }
+
+    if (
+      cachedToolsArray != null &&
+      (appConfig?.mcpConfig != null ? mcpPlugins != null && mcpPlugins.length > 0 : true)
+    ) {
+      const dedupedTools = filterUniquePlugins([...(mcpPlugins ?? []), ...cachedToolsArray]);
+      res.status(200).json(dedupedTools);
       return;
     }
 
     /** @type {Record<string, FunctionTool> | null} Get tool definitions to filter which tools are actually available */
-    let toolDefinitions = await getCachedTools();
-
-    if (toolDefinitions == null && appConfig?.availableTools != null) {
-      logger.warn('[getAvailableTools] Tool cache was empty, re-initializing from app config');
-      await setCachedTools(appConfig.availableTools);
-      toolDefinitions = appConfig.availableTools;
-    }
+    let toolDefinitions = await getCachedTools({ includeGlobal: true });
+    let prelimCachedTools;
 
     /** @type {import('@librechat/api').LCManifestTool[]} */
     let pluginManifest = availableTools;
 
+    if (appConfig?.mcpConfig != null) {
+      try {
+        const mcpManager = getMCPManager();
+        const mcpTools = await mcpManager.getAllToolFunctions(userId);
+        prelimCachedTools = prelimCachedTools ?? {};
+        for (const [toolKey, toolData] of Object.entries(mcpTools)) {
+          const plugin = convertMCPToolToPlugin({
+            toolKey,
+            toolData,
+            mcpManager,
+          });
+          if (plugin) {
+            pluginManifest.push(plugin);
+          }
+          prelimCachedTools[toolKey] = toolData;
+        }
+        await mergeUserTools({ userId, cachedUserTools, userTools: prelimCachedTools });
+      } catch (error) {
+        logger.error(
+          '[getAvailableTools] Error loading MCP Tools, servers may still be initializing:',
+          error,
+        );
+      }
+    } else if (prelimCachedTools != null) {
+      await setCachedTools(prelimCachedTools, { isGlobal: true });
+    }
+
     /** @type {TPlugin[]} Deduplicate and authenticate plugins */
     const uniquePlugins = filterUniquePlugins(pluginManifest);
     const authenticatedPlugins = uniquePlugins.map((plugin) => {
@@ -96,13 +139,13 @@ const getAvailableTools = async (req, res) => {
       }
     });
 
-    /** Filter plugins based on availability */
+    /** Filter plugins based on availability and add MCP-specific auth config */
     const toolsOutput = [];
     for (const plugin of authenticatedPlugins) {
-      const isToolDefined = toolDefinitions?.[plugin.pluginKey] !== undefined;
+      const isToolDefined = toolDefinitions[plugin.pluginKey] !== undefined;
       const isToolkit =
         plugin.toolkit === true &&
-        Object.keys(toolDefinitions ?? {}).some(
+        Object.keys(toolDefinitions).some(
           (key) => getToolkitKey({ toolkits, toolName: key }) === plugin.pluginKey,
         );
 
@@ -110,13 +153,39 @@ const getAvailableTools = async (req, res) => {
         continue;
       }
 
-      toolsOutput.push(plugin);
+      const toolToAdd = { ...plugin };
+
+      if (plugin.pluginKey.includes(Constants.mcp_delimiter)) {
+        const parts = plugin.pluginKey.split(Constants.mcp_delimiter);
+        const serverName = parts[parts.length - 1];
+        const serverConfig = appConfig?.mcpConfig?.[serverName];
+
+        if (serverConfig?.customUserVars) {
+          const customVarKeys = Object.keys(serverConfig.customUserVars);
+          if (customVarKeys.length === 0) {
+            toolToAdd.authConfig = [];
+            toolToAdd.authenticated = true;
+          } else {
+            toolToAdd.authConfig = Object.entries(serverConfig.customUserVars).map(
+              ([key, value]) => ({
+                authField: key,
+                label: value.title || key,
+                description: value.description || '',
+              }),
+            );
+            toolToAdd.authenticated = false;
+          }
+        }
+      }
+
+      toolsOutput.push(toolToAdd);
     }
 
     const finalTools = filterUniquePlugins(toolsOutput);
     await cache.set(CacheKeys.TOOLS, finalTools);
 
-    res.status(200).json(finalTools);
+    const dedupedTools = filterUniquePlugins([...(mcpPlugins ?? []), ...finalTools]);
+    res.status(200).json(dedupedTools);
   } catch (error) {
     logger.error('[getAvailableTools]', error);
     res.status(500).json({ message: error.message });

api/server/controllers/PluginController.spec.js

@@ -1,3 +1,4 @@
+const { Constants } = require('librechat-data-provider');
 const { getCachedTools, getAppConfig } = require('~/server/services/Config');
 const { getLogStores } = require('~/cache');
 
@@ -16,10 +17,18 @@ jest.mock('~/server/services/Config', () => ({
     includedTools: [],
   }),
   setCachedTools: jest.fn(),
+  mergeUserTools: jest.fn(),
 }));
 
 // loadAndFormatTools mock removed - no longer used in PluginController
-// getMCPManager mock removed - no longer used in PluginController
+
+jest.mock('~/config', () => ({
+  getMCPManager: jest.fn(() => ({
+    getAllToolFunctions: jest.fn().mockResolvedValue({}),
+    getRawConfig: jest.fn().mockReturnValue({}),
+  })),
+  getFlowStateManager: jest.fn(),
+}));
 
 jest.mock('~/app/clients/tools', () => ({
   availableTools: [],
@@ -150,6 +159,52 @@ describe('PluginController', () => {
   });
 
   describe('getAvailableTools', () => {
+    it('should use convertMCPToolsToPlugins for user-specific MCP tools', async () => {
+      const mockUserTools = {
+        [`tool1${Constants.mcp_delimiter}server1`]: {
+          type: 'function',
+          function: {
+            name: `tool1${Constants.mcp_delimiter}server1`,
+            description: 'Tool 1',
+            parameters: { type: 'object', properties: {} },
+          },
+        },
+      };
+
+      mockCache.get.mockResolvedValue(null);
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+      mockReq.config = {
+        mcpConfig: {
+          server1: {},
+        },
+        paths: { structuredTools: '/mock/path' },
+      };
+
+      // Mock MCP manager to return empty tools initially (since getAllToolFunctions is called)
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue({}),
+        getRawConfig: jest.fn().mockReturnValue({}),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      // Mock second call to return tool definitions (includeGlobal: true)
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+
+      await getAvailableTools(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      const responseData = mockRes.json.mock.calls[0][0];
+      expect(responseData).toBeDefined();
+      expect(Array.isArray(responseData)).toBe(true);
+      expect(responseData.length).toBeGreaterThan(0);
+      const convertedTool = responseData.find(
+        (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}server1`,
+      );
+      expect(convertedTool).toBeDefined();
+      // The real convertMCPToolsToPlugins extracts the name from the delimiter
+      expect(convertedTool.name).toBe('tool1');
+    });
+
     it('should use filterUniquePlugins to deduplicate combined tools', async () => {
       const mockUserTools = {
         'user-tool': {
@@ -174,6 +229,9 @@ describe('PluginController', () => {
         paths: { structuredTools: '/mock/path' },
       };
 
+      // Mock second call to return tool definitions
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+
       await getAvailableTools(mockReq, mockRes);
 
       expect(mockRes.status).toHaveBeenCalledWith(200);
@@ -196,7 +254,14 @@ describe('PluginController', () => {
       require('~/app/clients/tools').availableTools.push(mockPlugin);
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns the tool definitions
+      // First call returns null for user tools
+      getCachedTools.mockResolvedValueOnce(null);
+      mockReq.config = {
+        mcpConfig: null,
+        paths: { structuredTools: '/mock/path' },
+      };
+
+      // Second call (with includeGlobal: true) returns the tool definitions
       getCachedTools.mockResolvedValueOnce({
         tool1: {
           type: 'function',
@@ -207,10 +272,6 @@ describe('PluginController', () => {
           },
         },
       });
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -241,7 +302,14 @@ describe('PluginController', () => {
       });
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns the tool definitions
+      // First call returns null for user tools
+      getCachedTools.mockResolvedValueOnce(null);
+      mockReq.config = {
+        mcpConfig: null,
+        paths: { structuredTools: '/mock/path' },
+      };
+
+      // Second call (with includeGlobal: true) returns the tool definitions
       getCachedTools.mockResolvedValueOnce({
         toolkit1_function: {
           type: 'function',
@@ -252,10 +320,6 @@ describe('PluginController', () => {
           },
         },
       });
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -267,7 +331,126 @@ describe('PluginController', () => {
     });
   });
 
+  describe('plugin.icon behavior', () => {
+    const callGetAvailableToolsWithMCPServer = async (serverConfig) => {
+      mockCache.get.mockResolvedValue(null);
+
+      const functionTools = {
+        [`test-tool${Constants.mcp_delimiter}test-server`]: {
+          type: 'function',
+          function: {
+            name: `test-tool${Constants.mcp_delimiter}test-server`,
+            description: 'A test tool',
+            parameters: { type: 'object', properties: {} },
+          },
+        },
+      };
+
+      // Mock the MCP manager to return tools and server config
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue(functionTools),
+        getRawConfig: jest.fn().mockReturnValue(serverConfig),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      // First call returns empty user tools
+      getCachedTools.mockResolvedValueOnce({});
+
+      // Mock getAppConfig to return the mcpConfig
+      mockReq.config = {
+        mcpConfig: {
+          'test-server': serverConfig,
+        },
+      };
+
+      // Second call (with includeGlobal: true) returns the tool definitions
+      getCachedTools.mockResolvedValueOnce(functionTools);
+
+      await getAvailableTools(mockReq, mockRes);
+      const responseData = mockRes.json.mock.calls[0][0];
+      return responseData.find(
+        (tool) => tool.pluginKey === `test-tool${Constants.mcp_delimiter}test-server`,
+      );
+    };
+
+    it('should set plugin.icon when iconPath is defined', async () => {
+      const serverConfig = {
+        iconPath: '/path/to/icon.png',
+      };
+      const testTool = await callGetAvailableToolsWithMCPServer(serverConfig);
+      expect(testTool.icon).toBe('/path/to/icon.png');
+    });
+
+    it('should set plugin.icon to undefined when iconPath is not defined', async () => {
+      const serverConfig = {};
+      const testTool = await callGetAvailableToolsWithMCPServer(serverConfig);
+      expect(testTool.icon).toBeUndefined();
+    });
+  });
+
   describe('helper function integration', () => {
+    it('should properly handle MCP tools with custom user variables', async () => {
+      const appConfig = {
+        mcpConfig: {
+          'test-server': {
+            customUserVars: {
+              API_KEY: { title: 'API Key', description: 'Your API key' },
+            },
+          },
+        },
+      };
+
+      // Mock MCP tools returned by getAllToolFunctions
+      const mcpToolFunctions = {
+        [`tool1${Constants.mcp_delimiter}test-server`]: {
+          type: 'function',
+          function: {
+            name: `tool1${Constants.mcp_delimiter}test-server`,
+            description: 'Tool 1',
+            parameters: {},
+          },
+        },
+      };
+
+      // Mock the MCP manager to return tools
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue(mcpToolFunctions),
+        getRawConfig: jest.fn().mockReturnValue({
+          customUserVars: {
+            API_KEY: { title: 'API Key', description: 'Your API key' },
+          },
+        }),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      mockCache.get.mockResolvedValue(null);
+      mockReq.config = appConfig;
+
+      // First call returns user tools (empty in this case)
+      getCachedTools.mockResolvedValueOnce({});
+
+      // Second call (with includeGlobal: true) returns tool definitions including our MCP tool
+      getCachedTools.mockResolvedValueOnce(mcpToolFunctions);
+
+      await getAvailableTools(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      const responseData = mockRes.json.mock.calls[0][0];
+      expect(Array.isArray(responseData)).toBe(true);
+
+      // Find the MCP tool in the response
+      const mcpTool = responseData.find(
+        (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}test-server`,
+      );
+
+      // The actual implementation adds authConfig and sets authenticated to false when customUserVars exist
+      expect(mcpTool).toBeDefined();
+      expect(mcpTool.authConfig).toEqual([
+        { authField: 'API_KEY', label: 'API Key', description: 'Your API key' },
+      ]);
+      expect(mcpTool.authenticated).toBe(false);
+    });
+
     it('should handle error cases gracefully', async () => {
       mockCache.get.mockRejectedValue(new Error('Cache error'));
 
@@ -289,13 +472,23 @@ describe('PluginController', () => {
 
     it('should handle null cachedTools and cachedUserTools', async () => {
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns empty object instead of null
-      getCachedTools.mockResolvedValueOnce({});
+      // First call returns null for user tools
+      getCachedTools.mockResolvedValueOnce(null);
       mockReq.config = {
         mcpConfig: null,
         paths: { structuredTools: '/mock/path' },
       };
 
+      // Mock MCP manager to return no tools
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue({}),
+        getRawConfig: jest.fn().mockReturnValue({}),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      // Second call (with includeGlobal: true) returns empty object instead of null
+      getCachedTools.mockResolvedValueOnce({});
+
       await getAvailableTools(mockReq, mockRes);
 
       // Should handle null values gracefully
@@ -310,9 +503,9 @@ describe('PluginController', () => {
         paths: { structuredTools: '/mock/path' },
       };
 
-      // Mock getCachedTools to return undefined
+      // Mock getCachedTools to return undefined for both calls
       getCachedTools.mockReset();
-      getCachedTools.mockResolvedValueOnce(undefined);
+      getCachedTools.mockResolvedValueOnce(undefined).mockResolvedValueOnce(undefined);
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -321,6 +514,51 @@ describe('PluginController', () => {
       expect(mockRes.json).toHaveBeenCalledWith([]);
     });
 
+    it('should handle `cachedToolsArray` and `mcpPlugins` both being defined', async () => {
+      const cachedTools = [{ name: 'CachedTool', pluginKey: 'cached-tool', description: 'Cached' }];
+      // Use MCP delimiter for the user tool so convertMCPToolsToPlugins works
+      const userTools = {
+        [`user-tool${Constants.mcp_delimiter}server1`]: {
+          type: 'function',
+          function: {
+            name: `user-tool${Constants.mcp_delimiter}server1`,
+            description: 'User tool',
+            parameters: {},
+          },
+        },
+      };
+
+      mockCache.get.mockResolvedValue(cachedTools);
+      getCachedTools.mockResolvedValueOnce(userTools);
+      mockReq.config = {
+        mcpConfig: {
+          server1: {},
+        },
+        paths: { structuredTools: '/mock/path' },
+      };
+
+      // Mock MCP manager to return empty tools initially
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue({}),
+        getRawConfig: jest.fn().mockReturnValue({}),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      // The controller expects a second call to getCachedTools
+      getCachedTools.mockResolvedValueOnce({
+        'cached-tool': { type: 'function', function: { name: 'cached-tool' } },
+        [`user-tool${Constants.mcp_delimiter}server1`]:
+          userTools[`user-tool${Constants.mcp_delimiter}server1`],
+      });
+
+      await getAvailableTools(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      const responseData = mockRes.json.mock.calls[0][0];
+      // Should have both cached and user tools
+      expect(responseData.length).toBeGreaterThanOrEqual(2);
+    });
+
     it('should handle empty toolDefinitions object', async () => {
       mockCache.get.mockResolvedValue(null);
       // Reset getCachedTools to ensure clean state
@@ -331,12 +569,76 @@ describe('PluginController', () => {
       // Ensure no plugins are available
       require('~/app/clients/tools').availableTools.length = 0;
 
+      // Reset MCP manager to default state
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue({}),
+        getRawConfig: jest.fn().mockReturnValue({}),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
       await getAvailableTools(mockReq, mockRes);
 
       // With empty tool definitions, no tools should be in the final output
       expect(mockRes.json).toHaveBeenCalledWith([]);
     });
 
+    it('should handle MCP tools without customUserVars', async () => {
+      const appConfig = {
+        mcpConfig: {
+          'test-server': {
+            // No customUserVars defined
+          },
+        },
+      };
+
+      const mockUserTools = {
+        [`tool1${Constants.mcp_delimiter}test-server`]: {
+          type: 'function',
+          function: {
+            name: `tool1${Constants.mcp_delimiter}test-server`,
+            description: 'Tool 1',
+            parameters: { type: 'object', properties: {} },
+          },
+        },
+      };
+
+      // Mock the MCP manager to return the tools
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue(mockUserTools),
+        getRawConfig: jest.fn().mockReturnValue({
+          // No customUserVars defined
+        }),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      mockCache.get.mockResolvedValue(null);
+      mockReq.config = appConfig;
+      // First call returns empty user tools
+      getCachedTools.mockResolvedValueOnce({});
+
+      // Second call (with includeGlobal: true) returns the tool definitions
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+
+      // Ensure no plugins in availableTools for clean test
+      require('~/app/clients/tools').availableTools.length = 0;
+
+      await getAvailableTools(mockReq, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      const responseData = mockRes.json.mock.calls[0][0];
+      expect(Array.isArray(responseData)).toBe(true);
+      expect(responseData.length).toBeGreaterThan(0);
+
+      const mcpTool = responseData.find(
+        (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}test-server`,
+      );
+
+      expect(mcpTool).toBeDefined();
+      expect(mcpTool.authenticated).toBe(true);
+      // The actual implementation sets authConfig to empty array when no customUserVars
+      expect(mcpTool.authConfig).toEqual([]);
+    });
+
     it('should handle undefined filteredTools and includedTools', async () => {
       mockReq.config = {};
       mockCache.get.mockResolvedValue(null);
@@ -365,129 +667,20 @@ describe('PluginController', () => {
       require('~/app/clients/tools').availableTools.push(mockToolkit);
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns empty object to avoid null reference error
+      // First call returns empty object
       getCachedTools.mockResolvedValueOnce({});
       mockReq.config = {
         mcpConfig: null,
         paths: { structuredTools: '/mock/path' },
       };
 
+      // Second call (with includeGlobal: true) returns empty object to avoid null reference error
+      getCachedTools.mockResolvedValueOnce({});
+
       await getAvailableTools(mockReq, mockRes);
 
       // Should handle null toolDefinitions gracefully
       expect(mockRes.status).toHaveBeenCalledWith(200);
     });
-
-    it('should handle undefined toolDefinitions when checking isToolDefined (traversaal_search bug)', async () => {
-      // This test reproduces the bug where toolDefinitions is undefined
-      // and accessing toolDefinitions[plugin.pluginKey] causes a TypeError
-      const mockPlugin = {
-        name: 'Traversaal Search',
-        pluginKey: 'traversaal_search',
-        description: 'Search plugin',
-      };
-
-      // Add the plugin to availableTools
-      require('~/app/clients/tools').availableTools.push(mockPlugin);
-
-      mockCache.get.mockResolvedValue(null);
-
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
-
-      // CRITICAL: getCachedTools returns undefined
-      // This is what causes the bug when trying to access toolDefinitions[plugin.pluginKey]
-      getCachedTools.mockResolvedValueOnce(undefined);
-
-      // This should not throw an error with the optional chaining fix
-      await getAvailableTools(mockReq, mockRes);
-
-      // Should handle undefined toolDefinitions gracefully and return empty array
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([]);
-    });
-
-    it('should re-initialize tools from appConfig when cache returns null', async () => {
-      // Setup: Initial state with tools in appConfig
-      const mockAppTools = {
-        tool1: {
-          type: 'function',
-          function: {
-            name: 'tool1',
-            description: 'Tool 1',
-            parameters: {},
-          },
-        },
-        tool2: {
-          type: 'function',
-          function: {
-            name: 'tool2',
-            description: 'Tool 2',
-            parameters: {},
-          },
-        },
-      };
-
-      // Add matching plugins to availableTools
-      require('~/app/clients/tools').availableTools.push(
-        { name: 'Tool 1', pluginKey: 'tool1', description: 'Tool 1' },
-        { name: 'Tool 2', pluginKey: 'tool2', description: 'Tool 2' },
-      );
-
-      // Simulate cache cleared state (returns null)
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValueOnce(null); // Global tools (cache cleared)
-
-      mockReq.config = {
-        filteredTools: [],
-        includedTools: [],
-        availableTools: mockAppTools,
-      };
-
-      // Mock setCachedTools to verify it's called to re-initialize
-      const { setCachedTools } = require('~/server/services/Config');
-
-      await getAvailableTools(mockReq, mockRes);
-
-      // Should have re-initialized the cache with tools from appConfig
-      expect(setCachedTools).toHaveBeenCalledWith(mockAppTools);
-
-      // Should still return tools successfully
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      const responseData = mockRes.json.mock.calls[0][0];
-      expect(responseData).toHaveLength(2);
-      expect(responseData.find((t) => t.pluginKey === 'tool1')).toBeDefined();
-      expect(responseData.find((t) => t.pluginKey === 'tool2')).toBeDefined();
-    });
-
-    it('should handle cache clear without appConfig.availableTools gracefully', async () => {
-      // Setup: appConfig without availableTools
-      getAppConfig.mockResolvedValue({
-        filteredTools: [],
-        includedTools: [],
-        // No availableTools property
-      });
-
-      // Clear availableTools array
-      require('~/app/clients/tools').availableTools.length = 0;
-
-      // Cache returns null (cleared state)
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValueOnce(null); // Global tools (cache cleared)
-
-      mockReq.config = {
-        filteredTools: [],
-        includedTools: [],
-        // No availableTools
-      };
-
-      await getAvailableTools(mockReq, mockRes);
-
-      // Should handle gracefully without crashing
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([]);
-    });
   });
 });

api/server/controllers/UserController.js

@@ -1,33 +1,37 @@
-const { logger, webSearchKeys } = require('@librechat/data-schemas');
-const { Tools, CacheKeys, Constants, FileSources } = require('librechat-data-provider');
+const { logger } = require('@librechat/data-schemas');
 const {
-  MCPOAuthHandler,
-  MCPTokenStorage,
-  normalizeHttpError,
+  webSearchKeys,
   extractWebSearchEnvVars,
+  normalizeHttpError,
+  MCPTokenStorage,
 } = require('@librechat/api');
 const {
   getFiles,
-  findToken,
   updateUser,
   deleteFiles,
   deleteConvos,
   deletePresets,
   deleteMessages,
   deleteUserById,
-  deleteAllSharedLinks,
   deleteAllUserSessions,
 } = require('~/models');
 const { updateUserPluginAuth, deleteUserPluginAuth } = require('~/server/services/PluginService');
 const { updateUserPluginsService, deleteUserKey } = require('~/server/services/UserService');
 const { verifyEmail, resendVerificationEmail } = require('~/server/services/AuthService');
 const { needsRefresh, getNewS3URL } = require('~/server/services/Files/S3/crud');
+const { Tools, Constants, FileSources } = require('librechat-data-provider');
 const { processDeleteRequest } = require('~/server/services/Files/process');
 const { Transaction, Balance, User, Token } = require('~/db/models');
-const { getMCPManager, getFlowStateManager } = require('~/config');
 const { getAppConfig } = require('~/server/services/Config');
 const { deleteToolCalls } = require('~/models/ToolCall');
+const { deleteAllSharedLinks } = require('~/models');
+const { getMCPManager } = require('~/config');
+const { MCPOAuthHandler } = require('@librechat/api');
+const { getFlowStateManager } = require('~/config');
+const { CacheKeys } = require('librechat-data-provider');
 const { getLogStores } = require('~/cache');
+const { clearMCPServerTools } = require('~/server/services/Config/mcpToolsCache');
+const { findToken } = require('~/models');
 
 const getUserController = async (req, res) => {
   const appConfig = await getAppConfig({ role: req.user?.role });
@@ -327,23 +331,16 @@ const maybeUninstallOAuthMCP = async (userId, pluginKey, appConfig) => {
   const revocationEndpointAuthMethodsSupported =
     serverConfig.oauth?.revocation_endpoint_auth_methods_supported ??
     clientMetadata.revocation_endpoint_auth_methods_supported;
-  const oauthHeaders = serverConfig.oauth_headers ?? {};
 
   if (tokens?.access_token) {
     try {
-      await MCPOAuthHandler.revokeOAuthToken(
-        serverName,
-        tokens.access_token,
-        'access',
-        {
-          serverUrl: serverConfig.url,
-          clientId: clientInfo.client_id,
-          clientSecret: clientInfo.client_secret ?? '',
-          revocationEndpoint,
-          revocationEndpointAuthMethodsSupported,
-        },
-        oauthHeaders,
-      );
+      await MCPOAuthHandler.revokeOAuthToken(serverName, tokens.access_token, 'access', {
+        serverUrl: serverConfig.url,
+        clientId: clientInfo.client_id,
+        clientSecret: clientInfo.client_secret ?? '',
+        revocationEndpoint,
+        revocationEndpointAuthMethodsSupported,
+      });
     } catch (error) {
       logger.error(`Error revoking OAuth access token for ${serverName}:`, error);
     }
@@ -351,19 +348,13 @@ const maybeUninstallOAuthMCP = async (userId, pluginKey, appConfig) => {
 
   if (tokens?.refresh_token) {
     try {
-      await MCPOAuthHandler.revokeOAuthToken(
-        serverName,
-        tokens.refresh_token,
-        'refresh',
-        {
-          serverUrl: serverConfig.url,
-          clientId: clientInfo.client_id,
-          clientSecret: clientInfo.client_secret ?? '',
-          revocationEndpoint,
-          revocationEndpointAuthMethodsSupported,
-        },
-        oauthHeaders,
-      );
+      await MCPOAuthHandler.revokeOAuthToken(serverName, tokens.refresh_token, 'refresh', {
+        serverUrl: serverConfig.url,
+        clientId: clientInfo.client_id,
+        clientSecret: clientInfo.client_secret ?? '',
+        revocationEndpoint,
+        revocationEndpointAuthMethodsSupported,
+      });
     } catch (error) {
       logger.error(`Error revoking OAuth refresh token for ${serverName}:`, error);
     }
@@ -384,6 +375,9 @@ const maybeUninstallOAuthMCP = async (userId, pluginKey, appConfig) => {
   const flowId = MCPOAuthHandler.generateFlowId(userId, serverName);
   await flowManager.deleteFlow(flowId, 'mcp_get_tokens');
   await flowManager.deleteFlow(flowId, 'mcp_oauth');
+
+  // 6. clear the tools cache for the server
+  await clearMCPServerTools({ userId, serverName });
 };
 
 module.exports = {

api/server/controllers/agents/__tests__/v1.spec.js

@@ -158,7 +158,7 @@ describe('duplicateAgent', () => {
     });
   });
 
-  it('should convert `tool_resources.ocr` to `tool_resources.context`', async () => {
+  it('should handle tool_resources.ocr correctly', async () => {
     const mockAgent = {
       id: 'agent_123',
       name: 'Test Agent',
@@ -178,7 +178,7 @@ describe('duplicateAgent', () => {
     expect(createAgent).toHaveBeenCalledWith(
       expect.objectContaining({
         tool_resources: {
-          context: { enabled: true, config: 'test' },
+          ocr: { enabled: true, config: 'test' },
         },
       }),
     );

api/server/controllers/agents/client.js

@@ -8,7 +8,6 @@ const {
   Tokenizer,
   checkAccess,
   logAxiosError,
-  sanitizeTitle,
   resolveHeaders,
   getBalanceConfig,
   memoryInstructions,
@@ -212,13 +211,16 @@ class AgentClient extends BaseClient {
    * @returns {Promise<Array<Partial<MongoFile>>>}
    */
   async addImageURLs(message, attachments) {
-    const { files, image_urls } = await encodeAndFormat(
+    const { files, text, image_urls } = await encodeAndFormat(
       this.options.req,
       attachments,
       this.options.agent.provider,
       VisionModes.agents,
     );
     message.image_urls = image_urls.length ? image_urls : undefined;
+    if (text && text.length) {
+      message.ocr = text;
+    }
     return files;
   }
 
@@ -246,18 +248,19 @@ class AgentClient extends BaseClient {
 
     if (this.options.attachments) {
       const attachments = await this.options.attachments;
-      const latestMessage = orderedMessages[orderedMessages.length - 1];
 
       if (this.message_file_map) {
-        this.message_file_map[latestMessage.messageId] = attachments;
+        this.message_file_map[orderedMessages[orderedMessages.length - 1].messageId] = attachments;
       } else {
         this.message_file_map = {
-          [latestMessage.messageId]: attachments,
+          [orderedMessages[orderedMessages.length - 1].messageId]: attachments,
         };
       }
 
-      await this.addFileContextToMessage(latestMessage, attachments);
-      const files = await this.processAttachments(latestMessage, attachments);
+      const files = await this.addImageURLs(
+        orderedMessages[orderedMessages.length - 1],
+        attachments,
+      );
 
       this.options.attachments = files;
     }
@@ -277,21 +280,21 @@ class AgentClient extends BaseClient {
         assistantName: this.options?.modelLabel,
       });
 
-      if (message.fileContext && i !== orderedMessages.length - 1) {
+      if (message.ocr && i !== orderedMessages.length - 1) {
         if (typeof formattedMessage.content === 'string') {
-          formattedMessage.content = message.fileContext + '\n' + formattedMessage.content;
+          formattedMessage.content = message.ocr + '\n' + formattedMessage.content;
         } else {
           const textPart = formattedMessage.content.find((part) => part.type === 'text');
           textPart
-            ? (textPart.text = message.fileContext + '\n' + textPart.text)
-            : formattedMessage.content.unshift({ type: 'text', text: message.fileContext });
+            ? (textPart.text = message.ocr + '\n' + textPart.text)
+            : formattedMessage.content.unshift({ type: 'text', text: message.ocr });
         }
-      } else if (message.fileContext && i === orderedMessages.length - 1) {
-        systemContent = [systemContent, message.fileContext].join('\n');
+      } else if (message.ocr && i === orderedMessages.length - 1) {
+        systemContent = [systemContent, message.ocr].join('\n');
       }
 
       const needsTokenCount =
-        (this.contextStrategy && !orderedMessages[i].tokenCount) || message.fileContext;
+        (this.contextStrategy && !orderedMessages[i].tokenCount) || message.ocr;
 
       /* If tokens were never counted, or, is a Vision request and the message has files, count again */
       if (needsTokenCount || (this.isVisionModel && (message.image_urls || message.files))) {
@@ -776,7 +779,6 @@ class AgentClient extends BaseClient {
       const agentsEConfig = appConfig.endpoints?.[EModelEndpoint.agents];
 
       config = {
-        runName: 'AgentRun',
         configurable: {
           thread_id: this.conversationId,
           last_agent_index: this.agentConfigs?.size ?? 0,
@@ -1114,18 +1116,11 @@ class AgentClient extends BaseClient {
       appConfig.endpoints?.[endpoint] ??
       titleProviderConfig.customEndpointConfig;
     if (!endpointConfig) {
-      logger.debug(
-        `[api/server/controllers/agents/client.js #titleConvo] No endpoint config for "${endpoint}"`,
+      logger.warn(
+        '[api/server/controllers/agents/client.js #titleConvo] Error getting endpoint config',
       );
     }
 
-    if (endpointConfig?.titleConvo === false) {
-      logger.debug(
-        `[api/server/controllers/agents/client.js #titleConvo] Title generation disabled for endpoint "${endpoint}"`,
-      );
-      return;
-    }
-
     if (endpointConfig?.titleEndpoint && endpointConfig.titleEndpoint !== endpoint) {
       try {
         titleProviderConfig = getProviderConfig({
@@ -1135,7 +1130,7 @@ class AgentClient extends BaseClient {
         endpoint = endpointConfig.titleEndpoint;
       } catch (error) {
         logger.warn(
-          `[api/server/controllers/agents/client.js #titleConvo] Error getting title endpoint config for "${endpointConfig.titleEndpoint}", falling back to default`,
+          `[api/server/controllers/agents/client.js #titleConvo] Error getting title endpoint config for ${endpointConfig.titleEndpoint}, falling back to default`,
           error,
         );
         // Fall back to original provider config
@@ -1235,10 +1230,6 @@ class AgentClient extends BaseClient {
               handleLLMEnd,
             },
           ],
-          configurable: {
-            thread_id: this.conversationId,
-            user_id: this.user ?? this.options.req.user?.id,
-          },
         },
       });
 
@@ -1276,7 +1267,7 @@ class AgentClient extends BaseClient {
         );
       });
 
-      return sanitizeTitle(titleResult.title);
+      return titleResult.title;
     } catch (err) {
       logger.error('[api/server/controllers/agents/client.js #titleConvo] Error', err);
       return;

api/server/controllers/agents/client.test.js

@@ -10,10 +10,6 @@ jest.mock('@librechat/agents', () => ({
   }),
 }));
 
-jest.mock('@librechat/api', () => ({
-  ...jest.requireActual('@librechat/api'),
-}));
-
 describe('AgentClient - titleConvo', () => {
   let client;
   let mockRun;
@@ -256,38 +252,6 @@ describe('AgentClient - titleConvo', () => {
       expect(result).toBe('Generated Title');
     });
 
-    it('should sanitize the generated title by removing think blocks', async () => {
-      const titleWithThinkBlock = '<think>reasoning about the title</think> User Hi Greeting';
-      mockRun.generateTitle.mockResolvedValue({
-        title: titleWithThinkBlock,
-      });
-
-      const text = 'Test conversation text';
-      const abortController = new AbortController();
-
-      const result = await client.titleConvo({ text, abortController });
-
-      // Should remove the <think> block and return only the clean title
-      expect(result).toBe('User Hi Greeting');
-      expect(result).not.toContain('<think>');
-      expect(result).not.toContain('</think>');
-    });
-
-    it('should return fallback title when sanitization results in empty string', async () => {
-      const titleOnlyThinkBlock = '<think>only reasoning no actual title</think>';
-      mockRun.generateTitle.mockResolvedValue({
-        title: titleOnlyThinkBlock,
-      });
-
-      const text = 'Test conversation text';
-      const abortController = new AbortController();
-
-      const result = await client.titleConvo({ text, abortController });
-
-      // Should return the fallback title since sanitization would result in empty string
-      expect(result).toBe('Untitled Conversation');
-    });
-
     it('should handle errors gracefully and return undefined', async () => {
       mockRun.generateTitle.mockRejectedValue(new Error('Title generation failed'));
 
@@ -299,125 +263,6 @@ describe('AgentClient - titleConvo', () => {
       expect(result).toBeUndefined();
     });
 
-    it('should skip title generation when titleConvo is set to false', async () => {
-      // Set titleConvo to false in endpoint config
-      mockReq.config = {
-        endpoints: {
-          [EModelEndpoint.openAI]: {
-            titleConvo: false,
-            titleModel: 'gpt-3.5-turbo',
-            titlePrompt: 'Custom title prompt',
-            titleMethod: 'structured',
-            titlePromptTemplate: 'Template: {{content}}',
-          },
-        },
-      };
-
-      const text = 'Test conversation text';
-      const abortController = new AbortController();
-
-      const result = await client.titleConvo({ text, abortController });
-
-      // Should return undefined without generating title
-      expect(result).toBeUndefined();
-
-      // generateTitle should NOT have been called
-      expect(mockRun.generateTitle).not.toHaveBeenCalled();
-
-      // recordCollectedUsage should NOT have been called
-      expect(client.recordCollectedUsage).not.toHaveBeenCalled();
-    });
-
-    it('should skip title generation when titleConvo is false in all config', async () => {
-      // Set titleConvo to false in "all" config
-      mockReq.config = {
-        endpoints: {
-          all: {
-            titleConvo: false,
-            titleModel: 'gpt-4o-mini',
-            titlePrompt: 'All config title prompt',
-            titleMethod: 'completion',
-            titlePromptTemplate: 'All config template',
-          },
-        },
-      };
-
-      const text = 'Test conversation text';
-      const abortController = new AbortController();
-
-      const result = await client.titleConvo({ text, abortController });
-
-      // Should return undefined without generating title
-      expect(result).toBeUndefined();
-
-      // generateTitle should NOT have been called
-      expect(mockRun.generateTitle).not.toHaveBeenCalled();
-
-      // recordCollectedUsage should NOT have been called
-      expect(client.recordCollectedUsage).not.toHaveBeenCalled();
-    });
-
-    it('should skip title generation when titleConvo is false for custom endpoint scenario', async () => {
-      // This test validates the behavior when customEndpointConfig (retrieved via
-      // getProviderConfig for custom endpoints) has titleConvo: false.
-      //
-      // The code path is:
-      // 1. endpoints?.all is checked (undefined in this test)
-      // 2. endpoints?.[endpoint] is checked (our test config)
-      // 3. Would fall back to titleProviderConfig.customEndpointConfig (for real custom endpoints)
-      //
-      // We simulate a custom endpoint scenario using a dynamically named endpoint config
-
-      // Create a unique endpoint name that represents a custom endpoint
-      const customEndpointName = 'customEndpoint';
-
-      // Configure the endpoint to have titleConvo: false
-      // This simulates what would be in customEndpointConfig for a real custom endpoint
-      mockReq.config = {
-        endpoints: {
-          // No 'all' config - so it will check endpoints[endpoint]
-          // This config represents what customEndpointConfig would contain
-          [customEndpointName]: {
-            titleConvo: false,
-            titleModel: 'custom-model-v1',
-            titlePrompt: 'Custom endpoint title prompt',
-            titleMethod: 'completion',
-            titlePromptTemplate: 'Custom template: {{content}}',
-            baseURL: 'https://api.custom-llm.com/v1',
-            apiKey: 'test-custom-key',
-            // Additional custom endpoint properties
-            models: {
-              default: ['custom-model-v1', 'custom-model-v2'],
-            },
-          },
-        },
-      };
-
-      // Set up agent to use our custom endpoint
-      // Use openAI as base but override with custom endpoint name for this test
-      mockAgent.endpoint = EModelEndpoint.openAI;
-      mockAgent.provider = EModelEndpoint.openAI;
-
-      // Override the endpoint in the config to point to our custom config
-      mockReq.config.endpoints[EModelEndpoint.openAI] =
-        mockReq.config.endpoints[customEndpointName];
-      delete mockReq.config.endpoints[customEndpointName];
-
-      const text = 'Test custom endpoint conversation';
-      const abortController = new AbortController();
-
-      const result = await client.titleConvo({ text, abortController });
-
-      // Should return undefined without generating title because titleConvo is false
-      expect(result).toBeUndefined();
-
-      // generateTitle should NOT have been called
-      expect(mockRun.generateTitle).not.toHaveBeenCalled();
-
-      // recordCollectedUsage should NOT have been called
-      expect(client.recordCollectedUsage).not.toHaveBeenCalled();
-    });
-
     it('should pass titleEndpoint configuration to generateTitle', async () => {
       // Mock the API key just for this test
       const originalApiKey = process.env.ANTHROPIC_API_KEY;

api/server/controllers/agents/v1.js

@@ -2,12 +2,7 @@ const { z } = require('zod');
 const fs = require('fs').promises;
 const { nanoid } = require('nanoid');
 const { logger } = require('@librechat/data-schemas');
-const {
-  agentCreateSchema,
-  agentUpdateSchema,
-  mergeAgentOcrConversion,
-  convertOcrToContextInPlace,
-} = require('@librechat/api');
+const { agentCreateSchema, agentUpdateSchema } = require('@librechat/api');
 const {
   Tools,
   Constants,
@@ -71,7 +66,7 @@ const createAgentHandler = async (req, res) => {
     agentData.author = userId;
     agentData.tools = [];
 
-    const availableTools = await getCachedTools();
+    const availableTools = await getCachedTools({ includeGlobal: true });
     for (const tool of tools) {
       if (availableTools[tool]) {
         agentData.tools.push(tool);
@@ -203,32 +198,19 @@ const getAgentHandler = async (req, res, expandProperties = false) => {
  * @param {object} req.params - Request params
  * @param {string} req.params.id - Agent identifier.
  * @param {AgentUpdateParams} req.body - The Agent update parameters.
- * @returns {Promise<Agent>} 200 - success response - application/json
+ * @returns {Agent} 200 - success response - application/json
  */
 const updateAgentHandler = async (req, res) => {
   try {
     const id = req.params.id;
     const validatedData = agentUpdateSchema.parse(req.body);
     const { _id, ...updateData } = removeNullishValues(validatedData);
-
-    // Convert OCR to context in incoming updateData
-    convertOcrToContextInPlace(updateData);
-
     const existingAgent = await getAgent({ id });
 
     if (!existingAgent) {
       return res.status(404).json({ error: 'Agent not found' });
     }
 
-    // Convert legacy OCR tool resource to context format in existing agent
-    const ocrConversion = mergeAgentOcrConversion(existingAgent, updateData);
-    if (ocrConversion.tool_resources) {
-      updateData.tool_resources = ocrConversion.tool_resources;
-    }
-    if (ocrConversion.tools) {
-      updateData.tools = ocrConversion.tools;
-    }
-
     let updatedAgent =
       Object.keys(updateData).length > 0
         ? await updateAgent({ id }, updateData, {
@@ -273,7 +255,7 @@ const updateAgentHandler = async (req, res) => {
  * @param {object} req - Express Request
  * @param {object} req.params - Request params
  * @param {string} req.params.id - Agent identifier.
- * @returns {Promise<Agent>} 201 - success response - application/json
+ * @returns {Agent} 201 - success response - application/json
  */
 const duplicateAgentHandler = async (req, res) => {
   const { id } = req.params;
@@ -306,19 +288,9 @@ const duplicateAgentHandler = async (req, res) => {
       hour12: false,
     })})`;
 
-    if (_tool_resources?.[EToolResources.context]) {
-      cloneData.tool_resources = {
-        [EToolResources.context]: _tool_resources[EToolResources.context],
-      };
-    }
-
     if (_tool_resources?.[EToolResources.ocr]) {
       cloneData.tool_resources = {
-        /** Legacy conversion from `ocr` to `context` */
-        [EToolResources.context]: {
-          ...(_tool_resources[EToolResources.context] ?? {}),
-          ..._tool_resources[EToolResources.ocr],
-        },
+        [EToolResources.ocr]: _tool_resources[EToolResources.ocr],
       };
     }
 
@@ -410,7 +382,7 @@ const duplicateAgentHandler = async (req, res) => {
  * @param {object} req - Express Request
  * @param {object} req.params - Request params
  * @param {string} req.params.id - Agent identifier.
- * @returns {Promise<Agent>} 200 - success response - application/json
+ * @returns {Agent} 200 - success response - application/json
  */
 const deleteAgentHandler = async (req, res) => {
   try {
@@ -512,7 +484,7 @@ const getListAgentsHandler = async (req, res) => {
  * @param {Express.Multer.File} req.file - The avatar image file.
  * @param {object} req.body - Request body
  * @param {string} [req.body.avatar] - Optional avatar for the agent's avatar.
- * @returns {Promise<void>} 200 - success response - application/json
+ * @returns {Object} 200 - success response - application/json
  */
 const uploadAgentAvatarHandler = async (req, res) => {
   try {

api/server/controllers/agents/v1.spec.js

@@ -512,7 +512,6 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
       mockReq.params.id = existingAgentId;
       mockReq.body = {
         tool_resources: {
-          /** Legacy conversion from `ocr` to `context` */
           ocr: {
             file_ids: ['ocr1', 'ocr2'],
           },
@@ -532,8 +531,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
 
       const updatedAgent = mockRes.json.mock.calls[0][0];
       expect(updatedAgent.tool_resources).toBeDefined();
-      expect(updatedAgent.tool_resources.ocr).toBeUndefined();
-      expect(updatedAgent.tool_resources.context).toBeDefined();
+      expect(updatedAgent.tool_resources.ocr).toBeDefined();
       expect(updatedAgent.tool_resources.execute_code).toBeDefined();
       expect(updatedAgent.tool_resources.invalid_tool).toBeUndefined();
     });

api/server/controllers/assistants/v1.js

@@ -31,7 +31,7 @@ const createAssistant = async (req, res) => {
     delete assistantData.conversation_starters;
     delete assistantData.append_current_datetime;
 
-    const toolDefinitions = await getCachedTools();
+    const toolDefinitions = await getCachedTools({ includeGlobal: true });
 
     assistantData.tools = tools
       .map((tool) => {
@@ -136,7 +136,7 @@ const patchAssistant = async (req, res) => {
       ...updateData
     } = req.body;
 
-    const toolDefinitions = await getCachedTools();
+    const toolDefinitions = await getCachedTools({ includeGlobal: true });
 
     updateData.tools = (updateData.tools ?? [])
       .map((tool) => {

api/server/controllers/assistants/v2.js

@@ -28,7 +28,7 @@ const createAssistant = async (req, res) => {
     delete assistantData.conversation_starters;
     delete assistantData.append_current_datetime;
 
-    const toolDefinitions = await getCachedTools();
+    const toolDefinitions = await getCachedTools({ includeGlobal: true });
 
     assistantData.tools = tools
       .map((tool) => {
@@ -125,7 +125,7 @@ const updateAssistant = async ({ req, openai, assistant_id, updateData }) => {
 
   let hasFileSearch = false;
   for (const tool of updateData.tools ?? []) {
-    const toolDefinitions = await getCachedTools();
+    const toolDefinitions = await getCachedTools({ includeGlobal: true });
     let actualTool = typeof tool === 'string' ? toolDefinitions[tool] : tool;
 
     if (!actualTool && manifestToolMap[tool] && manifestToolMap[tool].toolkit === true) {

api/server/controllers/auth/LoginController.js

@@ -1,6 +1,6 @@
-const { logger } = require('@librechat/data-schemas');
 const { generate2FATempToken } = require('~/server/services/twoFactorService');
 const { setAuthTokens } = require('~/server/services/AuthService');
+const { logger } = require('~/config');
 
 const loginController = async (req, res) => {
   try {

api/server/controllers/auth/LogoutController.js

@@ -1,8 +1,8 @@
 const cookies = require('cookie');
-const { isEnabled } = require('@librechat/api');
-const { logger } = require('@librechat/data-schemas');
-const { logoutUser } = require('~/server/services/AuthService');
 const { getOpenIdConfig } = require('~/strategies');
+const { logoutUser } = require('~/server/services/AuthService');
+const { isEnabled } = require('~/server/utils');
+const { logger } = require('~/config');
 
 const logoutController = async (req, res) => {
   const refreshToken = req.headers.cookie ? cookies.parse(req.headers.cookie).refreshToken : null;

api/server/controllers/mcp.js

@@ -1,126 +0,0 @@
-/**
- * MCP Tools Controller
- * Handles MCP-specific tool endpoints, decoupled from regular LibreChat tools
- */
-const { logger } = require('@librechat/data-schemas');
-const { Constants } = require('librechat-data-provider');
-const {
-  cacheMCPServerTools,
-  getMCPServerTools,
-  getAppConfig,
-} = require('~/server/services/Config');
-const { getMCPManager } = require('~/config');
-
-/**
- * Get all MCP tools available to the user
- */
-const getMCPTools = async (req, res) => {
-  try {
-    const userId = req.user?.id;
-    if (!userId) {
-      logger.warn('[getMCPTools] User ID not found in request');
-      return res.status(401).json({ message: 'Unauthorized' });
-    }
-
-    const appConfig = req.config ?? (await getAppConfig({ role: req.user?.role }));
-    if (!appConfig?.mcpConfig) {
-      return res.status(200).json({ servers: {} });
-    }
-
-    const mcpManager = getMCPManager();
-    const configuredServers = Object.keys(appConfig.mcpConfig);
-    const mcpServers = {};
-
-    const cachePromises = configuredServers.map((serverName) =>
-      getMCPServerTools(userId, serverName).then((tools) => ({ serverName, tools })),
-    );
-    const cacheResults = await Promise.all(cachePromises);
-
-    const serverToolsMap = new Map();
-    for (const { serverName, tools } of cacheResults) {
-      if (tools) {
-        serverToolsMap.set(serverName, tools);
-        continue;
-      }
-
-      const serverTools = await mcpManager.getServerToolFunctions(userId, serverName);
-      if (!serverTools) {
-        logger.debug(`[getMCPTools] No tools found for server ${serverName}`);
-        continue;
-      }
-      serverToolsMap.set(serverName, serverTools);
-
-      if (Object.keys(serverTools).length > 0) {
-        // Cache asynchronously without blocking
-        cacheMCPServerTools({ userId, serverName, serverTools }).catch((err) =>
-          logger.error(`[getMCPTools] Failed to cache tools for ${serverName}:`, err),
-        );
-      }
-    }
-
-    // Process each configured server
-    for (const serverName of configuredServers) {
-      try {
-        const serverTools = serverToolsMap.get(serverName);
-
-        // Get server config once
-        const serverConfig = appConfig.mcpConfig[serverName];
-        const rawServerConfig = mcpManager.getRawConfig(serverName);
-
-        // Initialize server object with all server-level data
-        const server = {
-          name: serverName,
-          icon: rawServerConfig?.iconPath || '',
-          authenticated: true,
-          authConfig: [],
-          tools: [],
-        };
-
-        // Set authentication config once for the server
-        if (serverConfig?.customUserVars) {
-          const customVarKeys = Object.keys(serverConfig.customUserVars);
-          if (customVarKeys.length > 0) {
-            server.authConfig = Object.entries(serverConfig.customUserVars).map(([key, value]) => ({
-              authField: key,
-              label: value.title || key,
-              description: value.description || '',
-            }));
-            server.authenticated = false;
-          }
-        }
-
-        // Process tools efficiently - no need for convertMCPToolToPlugin
-        if (serverTools) {
-          for (const [toolKey, toolData] of Object.entries(serverTools)) {
-            if (!toolData.function || !toolKey.includes(Constants.mcp_delimiter)) {
-              continue;
-            }
-
-            const toolName = toolKey.split(Constants.mcp_delimiter)[0];
-            server.tools.push({
-              name: toolName,
-              pluginKey: toolKey,
-              description: toolData.function.description || '',
-            });
-          }
-        }
-
-        // Only add server if it has tools or is configured
-        if (server.tools.length > 0 || serverConfig) {
-          mcpServers[serverName] = server;
-        }
-      } catch (error) {
-        logger.error(`[getMCPTools] Error loading tools for server ${serverName}:`, error);
-      }
-    }
-
-    res.status(200).json({ servers: mcpServers });
-  } catch (error) {
-    logger.error('[getMCPTools]', error);
-    res.status(500).json({ message: error.message });
-  }
-};
-
-module.exports = {
-  getMCPTools,
-};

api/server/index.js

@@ -10,14 +10,8 @@ const compression = require('compression');
 const cookieParser = require('cookie-parser');
 const { logger } = require('@librechat/data-schemas');
 const mongoSanitize = require('express-mongo-sanitize');
-const {
-  isEnabled,
-  ErrorController,
-  performStartupChecks,
-  initializeFileStorage,
-} = require('@librechat/api');
+const { isEnabled, ErrorController } = require('@librechat/api');
 const { connectDb, indexSync } = require('~/db');
-const initializeOAuthReconnectManager = require('./services/initializeOAuthReconnectManager');
 const createValidateImageRequest = require('./middleware/validateImageRequest');
 const { jwtLogin, ldapLogin, passportLogin } = require('~/strategies');
 const { updateInterfacePermissions } = require('~/models/interface');
@@ -54,11 +48,9 @@ const startServer = async () => {
   app.set('trust proxy', trusted_proxy);
 
   await seedDatabase();
-  const appConfig = await getAppConfig();
-  initializeFileStorage(appConfig);
-  await performStartupChecks(appConfig);
-  await updateInterfacePermissions(appConfig);
 
+  const appConfig = await getAppConfig();
+  await updateInterfacePermissions(appConfig);
   const indexPath = path.join(appConfig.paths.dist, 'index.html');
   let indexHTML = fs.readFileSync(indexPath, 'utf8');
 
@@ -162,7 +154,7 @@ const startServer = async () => {
     res.send(updatedIndexHtml);
   });
 
-  app.listen(port, host, async () => {
+  app.listen(port, host, () => {
     if (host === '0.0.0.0') {
       logger.info(
         `Server listening on all interfaces at port ${port}. Use http://localhost:${port} to access it`,
@@ -171,9 +163,7 @@ const startServer = async () => {
       logger.info(`Server listening at http://${host == '0.0.0.0' ? 'localhost' : host}:${port}`);
     }
 
-    await initializeMCPs();
-    await initializeOAuthReconnectManager();
-    await checkMigrations();
+    initializeMCPs().then(() => checkMigrations());
   });
 };
 

api/server/middleware/accessResources/fileAccess.js

@@ -1,7 +1,7 @@
 const { logger } = require('@librechat/data-schemas');
 const { PermissionBits, hasPermissions, ResourceType } = require('librechat-data-provider');
 const { getEffectivePermissions } = require('~/server/services/PermissionService');
-const { getAgents } = require('~/models/Agent');
+const { getAgent } = require('~/models/Agent');
 const { getFiles } = require('~/models/File');
 
 /**
@@ -10,12 +10,11 @@ const { getFiles } = require('~/models/File');
  */
 const checkAgentBasedFileAccess = async ({ userId, role, fileId }) => {
   try {
-    /** Agents that have this file in their tool_resources */
-    const agentsWithFile = await getAgents({
+    // Find agents that have this file in their tool_resources
+    const agentsWithFile = await getAgent({
       $or: [
-        { 'tool_resources.execute_code.file_ids': fileId },
         { 'tool_resources.file_search.file_ids': fileId },
-        { 'tool_resources.context.file_ids': fileId },
+        { 'tool_resources.execute_code.file_ids': fileId },
         { 'tool_resources.ocr.file_ids': fileId },
       ],
     });
@@ -25,7 +24,7 @@ const checkAgentBasedFileAccess = async ({ userId, role, fileId }) => {
     }
 
     // Check if user has access to any of these agents
-    for (const agent of agentsWithFile) {
+    for (const agent of Array.isArray(agentsWithFile) ? agentsWithFile : [agentsWithFile]) {
       // Check if user is the agent author
       if (agent.author && agent.author.toString() === userId) {
         logger.debug(`[fileAccess] User is author of agent ${agent.id}`);
@@ -84,6 +83,7 @@ const fileAccess = async (req, res, next) => {
       });
     }
 
+    // Get the file
     const [file] = await getFiles({ file_id: fileId });
     if (!file) {
       return res.status(404).json({
@@ -92,18 +92,20 @@ const fileAccess = async (req, res, next) => {
       });
     }
 
+    // Check if user owns the file
     if (file.user && file.user.toString() === userId) {
       req.fileAccess = { file };
       return next();
     }
 
-    /** Agent-based access (file inherits agent permissions) */
+    // Check agent-based access (file inherits agent permissions)
     const hasAgentAccess = await checkAgentBasedFileAccess({ userId, role: userRole, fileId });
     if (hasAgentAccess) {
       req.fileAccess = { file };
       return next();
     }
 
+    // No access
     logger.warn(`[fileAccess] User ${userId} denied access to file ${fileId}`);
     return res.status(403).json({
       error: 'Forbidden',

api/server/middleware/accessResources/fileAccess.spec.js

@@ -1,483 +0,0 @@
-const mongoose = require('mongoose');
-const { ResourceType, PrincipalType, PrincipalModel } = require('librechat-data-provider');
-const { MongoMemoryServer } = require('mongodb-memory-server');
-const { fileAccess } = require('./fileAccess');
-const { User, Role, AclEntry } = require('~/db/models');
-const { createAgent } = require('~/models/Agent');
-const { createFile } = require('~/models/File');
-
-describe('fileAccess middleware', () => {
-  let mongoServer;
-  let req, res, next;
-  let testUser, otherUser, thirdUser;
-
-  beforeAll(async () => {
-    mongoServer = await MongoMemoryServer.create();
-    const mongoUri = mongoServer.getUri();
-    await mongoose.connect(mongoUri);
-  });
-
-  afterAll(async () => {
-    await mongoose.disconnect();
-    await mongoServer.stop();
-  });
-
-  beforeEach(async () => {
-    await mongoose.connection.dropDatabase();
-
-    // Create test role
-    await Role.create({
-      name: 'test-role',
-      permissions: {
-        AGENTS: {
-          USE: true,
-          CREATE: true,
-          SHARED_GLOBAL: false,
-        },
-      },
-    });
-
-    // Create test users
-    testUser = await User.create({
-      email: 'test@example.com',
-      name: 'Test User',
-      username: 'testuser',
-      role: 'test-role',
-    });
-
-    otherUser = await User.create({
-      email: 'other@example.com',
-      name: 'Other User',
-      username: 'otheruser',
-      role: 'test-role',
-    });
-
-    thirdUser = await User.create({
-      email: 'third@example.com',
-      name: 'Third User',
-      username: 'thirduser',
-      role: 'test-role',
-    });
-
-    // Setup request/response objects
-    req = {
-      user: { id: testUser._id.toString(), role: testUser.role },
-      params: {},
-    };
-    res = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn(),
-    };
-    next = jest.fn();
-
-    jest.clearAllMocks();
-  });
-
-  describe('basic file access', () => {
-    test('should allow access when user owns the file', async () => {
-      // Create a file owned by testUser
-      await createFile({
-        user: testUser._id.toString(),
-        file_id: 'file_owned_by_user',
-        filepath: '/test/file.txt',
-        filename: 'file.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      req.params.file_id = 'file_owned_by_user';
-      await fileAccess(req, res, next);
-
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-      expect(req.fileAccess.file).toBeDefined();
-      expect(res.status).not.toHaveBeenCalled();
-    });
-
-    test('should deny access when user does not own the file and no agent access', async () => {
-      // Create a file owned by otherUser
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'file_owned_by_other',
-        filepath: '/test/file.txt',
-        filename: 'file.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      req.params.file_id = 'file_owned_by_other';
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(403);
-      expect(res.json).toHaveBeenCalledWith({
-        error: 'Forbidden',
-        message: 'Insufficient permissions to access this file',
-      });
-    });
-
-    test('should return 404 when file does not exist', async () => {
-      req.params.file_id = 'non_existent_file';
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(404);
-      expect(res.json).toHaveBeenCalledWith({
-        error: 'Not Found',
-        message: 'File not found',
-      });
-    });
-
-    test('should return 400 when file_id is missing', async () => {
-      // Don't set file_id in params
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(400);
-      expect(res.json).toHaveBeenCalledWith({
-        error: 'Bad Request',
-        message: 'file_id is required',
-      });
-    });
-
-    test('should return 401 when user is not authenticated', async () => {
-      req.user = null;
-      req.params.file_id = 'some_file';
-
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(401);
-      expect(res.json).toHaveBeenCalledWith({
-        error: 'Unauthorized',
-        message: 'Authentication required',
-      });
-    });
-  });
-
-  describe('agent-based file access', () => {
-    beforeEach(async () => {
-      // Create a file owned by otherUser (not testUser)
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'shared_file_via_agent',
-        filepath: '/test/shared.txt',
-        filename: 'shared.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-    });
-
-    test('should allow access when user is author of agent with file', async () => {
-      // Create agent owned by testUser with the file
-      await createAgent({
-        id: `agent_${Date.now()}`,
-        name: 'Test Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: testUser._id,
-        tool_resources: {
-          file_search: {
-            file_ids: ['shared_file_via_agent'],
-          },
-        },
-      });
-
-      req.params.file_id = 'shared_file_via_agent';
-      await fileAccess(req, res, next);
-
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-      expect(req.fileAccess.file).toBeDefined();
-    });
-
-    test('should allow access when user has VIEW permission on agent with file', async () => {
-      // Create agent owned by otherUser
-      const agent = await createAgent({
-        id: `agent_${Date.now()}`,
-        name: 'Shared Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: otherUser._id,
-        tool_resources: {
-          execute_code: {
-            file_ids: ['shared_file_via_agent'],
-          },
-        },
-      });
-
-      // Grant VIEW permission to testUser
-      await AclEntry.create({
-        principalType: PrincipalType.USER,
-        principalId: testUser._id,
-        principalModel: PrincipalModel.USER,
-        resourceType: ResourceType.AGENT,
-        resourceId: agent._id,
-        permBits: 1, // VIEW permission
-        grantedBy: otherUser._id,
-      });
-
-      req.params.file_id = 'shared_file_via_agent';
-      await fileAccess(req, res, next);
-
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-    });
-
-    test('should check file in ocr tool_resources', async () => {
-      await createAgent({
-        id: `agent_ocr_${Date.now()}`,
-        name: 'OCR Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: testUser._id,
-        tool_resources: {
-          ocr: {
-            file_ids: ['shared_file_via_agent'],
-          },
-        },
-      });
-
-      req.params.file_id = 'shared_file_via_agent';
-      await fileAccess(req, res, next);
-
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-    });
-
-    test('should deny access when user has no permission on agent with file', async () => {
-      // Create agent owned by otherUser without granting permission to testUser
-      const agent = await createAgent({
-        id: `agent_${Date.now()}`,
-        name: 'Private Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: otherUser._id,
-        tool_resources: {
-          file_search: {
-            file_ids: ['shared_file_via_agent'],
-          },
-        },
-      });
-
-      // Create ACL entry for otherUser only (owner)
-      await AclEntry.create({
-        principalType: PrincipalType.USER,
-        principalId: otherUser._id,
-        principalModel: PrincipalModel.USER,
-        resourceType: ResourceType.AGENT,
-        resourceId: agent._id,
-        permBits: 15, // All permissions
-        grantedBy: otherUser._id,
-      });
-
-      req.params.file_id = 'shared_file_via_agent';
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(403);
-    });
-  });
-
-  describe('multiple agents with same file', () => {
-    /**
-     * This test suite verifies that when multiple agents have the same file,
-     * all agents are checked for permissions, not just the first one found.
-     * This ensures users can access files through any agent they have permission for.
-     */
-
-    test('should check ALL agents with file, not just first one', async () => {
-      // Create a file owned by someone else
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'multi_agent_file',
-        filepath: '/test/multi.txt',
-        filename: 'multi.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      // Create first agent (owned by otherUser, no access for testUser)
-      const agent1 = await createAgent({
-        id: 'agent_no_access',
-        name: 'No Access Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: otherUser._id,
-        tool_resources: {
-          file_search: {
-            file_ids: ['multi_agent_file'],
-          },
-        },
-      });
-
-      // Create ACL for agent1 - only otherUser has access
-      await AclEntry.create({
-        principalType: PrincipalType.USER,
-        principalId: otherUser._id,
-        principalModel: PrincipalModel.USER,
-        resourceType: ResourceType.AGENT,
-        resourceId: agent1._id,
-        permBits: 15,
-        grantedBy: otherUser._id,
-      });
-
-      // Create second agent (owned by thirdUser, but testUser has VIEW access)
-      const agent2 = await createAgent({
-        id: 'agent_with_access',
-        name: 'Accessible Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: thirdUser._id,
-        tool_resources: {
-          file_search: {
-            file_ids: ['multi_agent_file'],
-          },
-        },
-      });
-
-      // Grant testUser VIEW access to agent2
-      await AclEntry.create({
-        principalType: PrincipalType.USER,
-        principalId: testUser._id,
-        principalModel: PrincipalModel.USER,
-        resourceType: ResourceType.AGENT,
-        resourceId: agent2._id,
-        permBits: 1, // VIEW permission
-        grantedBy: thirdUser._id,
-      });
-
-      req.params.file_id = 'multi_agent_file';
-      await fileAccess(req, res, next);
-
-      /**
-       * Should succeed because testUser has access to agent2,
-       * even though they don't have access to agent1.
-       * The fix ensures all agents are checked, not just the first one.
-       */
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-      expect(res.status).not.toHaveBeenCalled();
-    });
-
-    test('should find file in any agent tool_resources type', async () => {
-      // Create a file
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'multi_tool_file',
-        filepath: '/test/tool.txt',
-        filename: 'tool.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      // Agent 1: file in file_search (no access for testUser)
-      await createAgent({
-        id: 'agent_file_search',
-        name: 'File Search Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: otherUser._id,
-        tool_resources: {
-          file_search: {
-            file_ids: ['multi_tool_file'],
-          },
-        },
-      });
-
-      // Agent 2: same file in execute_code (testUser has access)
-      await createAgent({
-        id: 'agent_execute_code',
-        name: 'Execute Code Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: thirdUser._id,
-        tool_resources: {
-          execute_code: {
-            file_ids: ['multi_tool_file'],
-          },
-        },
-      });
-
-      // Agent 3: same file in ocr (testUser also has access)
-      await createAgent({
-        id: 'agent_ocr',
-        name: 'OCR Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: testUser._id, // testUser owns this one
-        tool_resources: {
-          ocr: {
-            file_ids: ['multi_tool_file'],
-          },
-        },
-      });
-
-      req.params.file_id = 'multi_tool_file';
-      await fileAccess(req, res, next);
-
-      /**
-       * Should succeed because testUser owns agent3,
-       * even if other agents with the file are found first.
-       */
-      expect(next).toHaveBeenCalled();
-      expect(req.fileAccess).toBeDefined();
-    });
-  });
-
-  describe('edge cases', () => {
-    test('should handle agent with empty tool_resources', async () => {
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'orphan_file',
-        filepath: '/test/orphan.txt',
-        filename: 'orphan.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      // Create agent with no files in tool_resources
-      await createAgent({
-        id: `agent_empty_${Date.now()}`,
-        name: 'Empty Resources Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: testUser._id,
-        tool_resources: {},
-      });
-
-      req.params.file_id = 'orphan_file';
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(403);
-    });
-
-    test('should handle agent with null tool_resources', async () => {
-      await createFile({
-        user: otherUser._id.toString(),
-        file_id: 'another_orphan_file',
-        filepath: '/test/orphan2.txt',
-        filename: 'orphan2.txt',
-        type: 'text/plain',
-        size: 100,
-      });
-
-      // Create agent with null tool_resources
-      await createAgent({
-        id: `agent_null_${Date.now()}`,
-        name: 'Null Resources Agent',
-        provider: 'openai',
-        model: 'gpt-4',
-        author: testUser._id,
-        tool_resources: null,
-      });
-
-      req.params.file_id = 'another_orphan_file';
-      await fileAccess(req, res, next);
-
-      expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(403);
-    });
-  });
-});

api/server/middleware/canDeleteAccount.js

@@ -1,6 +1,6 @@
-const { isEnabled } = require('@librechat/api');
-const { logger } = require('@librechat/data-schemas');
 const { SystemRoles } = require('librechat-data-provider');
+const { isEnabled } = require('~/server/utils');
+const { logger } = require('~/config');
 
 /**
  * Checks if the user can delete their account

api/server/middleware/checkBan.js

@@ -1,9 +1,9 @@
 const { Keyv } = require('keyv');
 const uap = require('ua-parser-js');
 const { logger } = require('@librechat/data-schemas');
-const { isEnabled, keyvMongo } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
-const { removePorts } = require('~/server/utils');
+const { isEnabled, removePorts } = require('~/server/utils');
+const keyvMongo = require('~/cache/keyvMongo');
 const denyRequest = require('./denyRequest');
 const { getLogStores } = require('~/cache');
 const { findUser } = require('~/models');

api/server/middleware/checkDomainAllowed.js

@@ -1,5 +1,5 @@
 const { logger } = require('@librechat/data-schemas');
-const { isEmailDomainAllowed } = require('@librechat/api');
+const { isEmailDomainAllowed } = require('~/server/services/domains');
 const { getAppConfig } = require('~/server/services/Config');
 
 /**

api/server/middleware/checkPeoplePickerAccess.js

@@ -1,6 +1,6 @@
-const { logger } = require('@librechat/data-schemas');
 const { PrincipalType, PermissionTypes, Permissions } = require('librechat-data-provider');
 const { getRoleByName } = require('~/models/Role');
+const { logger } = require('~/config');
 
 /**
  * Middleware to check if user has permission to access people picker functionality

api/server/middleware/checkPeoplePickerAccess.spec.js

@@ -1,11 +1,10 @@
-const { logger } = require('@librechat/data-schemas');
 const { PrincipalType, PermissionTypes, Permissions } = require('librechat-data-provider');
 const { checkPeoplePickerAccess } = require('./checkPeoplePickerAccess');
 const { getRoleByName } = require('~/models/Role');
+const { logger } = require('~/config');
 
 jest.mock('~/models/Role');
-jest.mock('@librechat/data-schemas', () => ({
-  ...jest.requireActual('@librechat/data-schemas'),
+jest.mock('~/config', () => ({
   logger: {
     error: jest.fn(),
   },

api/server/middleware/concurrentLimiter.js

@@ -1,7 +1,7 @@
-const { isEnabled } = require('@librechat/api');
 const { Time, CacheKeys, ViolationTypes } = require('librechat-data-provider');
 const clearPendingReq = require('~/cache/clearPendingReq');
 const { logViolation, getLogStores } = require('~/cache');
+const { isEnabled } = require('~/server/utils');
 const denyRequest = require('./denyRequest');
 
 const {

api/server/middleware/limiters/forkLimiters.js

@@ -1,6 +1,6 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
+const { limiterCache } = require('~/cache/cacheFactory');
 const logViolation = require('~/cache/logViolation');
 
 const getEnvironmentVariables = () => {

api/server/middleware/limiters/importLimiters.js

@@ -1,6 +1,6 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
+const { limiterCache } = require('~/cache/cacheFactory');
 const logViolation = require('~/cache/logViolation');
 
 const getEnvironmentVariables = () => {

api/server/middleware/limiters/loginLimiter.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts } = require('~/server/utils');
+const { limiterCache } = require('~/cache/cacheFactory');
 const { logViolation } = require('~/cache');
 
 const { LOGIN_WINDOW = 5, LOGIN_MAX = 7, LOGIN_VIOLATION_SCORE: score } = process.env;

api/server/middleware/limiters/messageLimiters.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const denyRequest = require('~/server/middleware/denyRequest');
+const { limiterCache } = require('~/cache/cacheFactory');
 const { logViolation } = require('~/cache');
 
 const {

api/server/middleware/limiters/registerLimiter.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts } = require('~/server/utils');
+const { limiterCache } = require('~/cache/cacheFactory');
 const { logViolation } = require('~/cache');
 
 const { REGISTER_WINDOW = 60, REGISTER_MAX = 5, REGISTRATION_VIOLATION_SCORE: score } = process.env;

api/server/middleware/limiters/resetPasswordLimiter.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts } = require('~/server/utils');
+const { limiterCache } = require('~/cache/cacheFactory');
 const { logViolation } = require('~/cache');
 
 const {

api/server/middleware/limiters/sttLimiters.js

@@ -1,6 +1,6 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
+const { limiterCache } = require('~/cache/cacheFactory');
 const logViolation = require('~/cache/logViolation');
 
 const getEnvironmentVariables = () => {

api/server/middleware/limiters/toolCallLimiter.js

@@ -1,6 +1,6 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
+const { limiterCache } = require('~/cache/cacheFactory');
 const logViolation = require('~/cache/logViolation');
 
 const { TOOL_CALL_VIOLATION_SCORE: score } = process.env;

api/server/middleware/limiters/ttsLimiters.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const logViolation = require('~/cache/logViolation');
+const { limiterCache } = require('~/cache/cacheFactory');
 
 const getEnvironmentVariables = () => {
   const TTS_IP_MAX = parseInt(process.env.TTS_IP_MAX) || 100;

api/server/middleware/limiters/uploadLimiters.js

@@ -1,6 +1,6 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
+const { limiterCache } = require('~/cache/cacheFactory');
 const logViolation = require('~/cache/logViolation');
 
 const getEnvironmentVariables = () => {

api/server/middleware/limiters/verifyEmailLimiter.js

@@ -1,7 +1,7 @@
 const rateLimit = require('express-rate-limit');
-const { limiterCache } = require('@librechat/api');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts } = require('~/server/utils');
+const { limiterCache } = require('~/cache/cacheFactory');
 const { logViolation } = require('~/cache');
 
 const {

api/server/middleware/logHeaders.js

@@ -1,4 +1,4 @@
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 /**
  * Middleware to log Forwarded Headers

api/server/middleware/moderateText.js

@@ -1,8 +1,8 @@
 const axios = require('axios');
-const { isEnabled } = require('@librechat/api');
-const { logger } = require('@librechat/data-schemas');
 const { ErrorTypes } = require('librechat-data-provider');
+const { isEnabled } = require('~/server/utils');
 const denyRequest = require('./denyRequest');
+const { logger } = require('~/config');
 
 async function moderateText(req, res, next) {
   if (!isEnabled(process.env.OPENAI_MODERATION)) {

api/server/middleware/optionalJwtAuth.js

@@ -1,6 +1,6 @@
 const cookies = require('cookie');
+const { isEnabled } = require('~/server/utils');
 const passport = require('passport');
-const { isEnabled } = require('@librechat/api');
 
 // This middleware does not require authentication,
 // but if the user is authenticated, it will set the user object.

api/server/middleware/requireJwtAuth.js

@@ -1,6 +1,6 @@
-const cookies = require('cookie');
 const passport = require('passport');
-const { isEnabled } = require('@librechat/api');
+const cookies = require('cookie');
+const { isEnabled } = require('~/server/utils');
 
 /**
  * Custom Middleware to handle JWT authentication, with support for OpenID token reuse

api/server/middleware/requireLocalAuth.js

@@ -1,5 +1,5 @@
 const passport = require('passport');
-const { logger } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 const requireLocalAuth = (req, res, next) => {
   passport.authenticate('local', (err, user, info) => {

api/server/middleware/validatePasswordReset.js

@@ -1,5 +1,5 @@
-const { isEnabled } = require('@librechat/api');
-const { logger } = require('@librechat/data-schemas');
+const { isEnabled } = require('~/server/utils');
+const { logger } = require('~/config');
 
 function validatePasswordReset(req, res, next) {
   if (isEnabled(process.env.ALLOW_PASSWORD_RESET)) {

api/server/middleware/validateRegistration.js

@@ -1,4 +1,4 @@
-const { isEnabled } = require('@librechat/api');
+const { isEnabled } = require('~/server/utils');
 
 function validateRegistration(req, res, next) {
   if (req.invite) {

api/server/routes/__tests__/costs.spec.js

@@ -0,0 +1,680 @@
+const express = require('express');
+const request = require('supertest');
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+
+jest.mock('@librechat/data-schemas', () => ({
+  logger: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+  createMethods: jest.fn(() => ({})),
+  createModels: jest.fn(() => ({})),
+}));
+
+jest.mock('~/server/middleware', () => ({
+  requireJwtAuth: (req, res, next) => next(),
+  validateMessageReq: (req, res, next) => next(),
+}));
+
+jest.mock('~/models', () => ({
+  getConvo: jest.fn(),
+  saveConvo: jest.fn(),
+  saveMessage: jest.fn(),
+  getMessage: jest.fn(),
+  getMessages: jest.fn(),
+  updateMessage: jest.fn(),
+  deleteMessages: jest.fn(),
+}));
+
+jest.mock('~/db/models', () => {
+  let User, Message, Transaction, Conversation;
+
+  return {
+    get User() {
+      return User;
+    },
+    get Message() {
+      return Message;
+    },
+    get Transaction() {
+      return Transaction;
+    },
+    get Conversation() {
+      return Conversation;
+    },
+    setUser: (model) => {
+      User = model;
+    },
+    setMessage: (model) => {
+      Message = model;
+    },
+    setTransaction: (model) => {
+      Transaction = model;
+    },
+    setConversation: (model) => {
+      Conversation = model;
+    },
+  };
+});
+
+describe('Costs Endpoint', () => {
+  let app;
+  let mongoServer;
+  let messagesRouter;
+  let User, Message, Transaction, Conversation;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    await mongoose.connect(mongoServer.getUri());
+
+    const userSchema = new mongoose.Schema({
+      _id: String,
+      name: String,
+      email: String,
+    });
+
+    const conversationSchema = new mongoose.Schema({
+      conversationId: String,
+      user: String,
+      title: String,
+      createdAt: Date,
+    });
+
+    const messageSchema = new mongoose.Schema({
+      messageId: String,
+      conversationId: String,
+      user: String,
+      isCreatedByUser: Boolean,
+      tokenCount: Number,
+      createdAt: Date,
+    });
+
+    const transactionSchema = new mongoose.Schema({
+      conversationId: String,
+      user: String,
+      tokenType: String,
+      tokenValue: Number,
+      createdAt: Date,
+    });
+
+    User = mongoose.model('User', userSchema);
+    Conversation = mongoose.model('Conversation', conversationSchema);
+    Message = mongoose.model('Message', messageSchema);
+    Transaction = mongoose.model('Transaction', transactionSchema);
+
+    const dbModels = require('~/db/models');
+    dbModels.setUser(User);
+    dbModels.setMessage(Message);
+    dbModels.setTransaction(Transaction);
+    dbModels.setConversation(Conversation);
+
+    require('~/db/models');
+
+    try {
+      messagesRouter = require('../messages');
+    } catch (error) {
+      console.error('Error loading messages router:', error);
+      throw error;
+    }
+
+    app = express();
+    app.use(express.json());
+    app.use((req, res, next) => {
+      req.user = { id: 'test-user-id' };
+      next();
+    });
+    app.use('/api/messages', messagesRouter);
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  beforeEach(async () => {
+    await User.deleteMany({});
+    await Conversation.deleteMany({});
+    await Message.deleteMany({});
+    await Transaction.deleteMany({});
+  });
+
+  describe('GET /:conversationId/costs', () => {
+    const conversationId = 'test-conversation-123';
+    const userId = 'test-user-id';
+
+    it('should return cost data for valid conversation', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      const aiMessage = new Message({
+        messageId: 'ai-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: false,
+        tokenCount: 150,
+        createdAt: new Date('2024-01-01T10:01:00Z'),
+      });
+
+      await Promise.all([userMessage.save(), aiMessage.save()]);
+
+      const promptTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 500000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      const completionTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'completion',
+        tokenValue: 750000,
+        createdAt: new Date('2024-01-01T10:01:30Z'),
+      });
+
+      await Promise.all([promptTransaction.save(), completionTransaction.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toMatchObject({
+        conversationId,
+        totals: {
+          prompt: { usd: 0.5, tokenCount: 100 },
+          completion: { usd: 0.75, tokenCount: 150 },
+          total: { usd: 1.25, tokenCount: 250 },
+        },
+        perMessage: [
+          { messageId: 'user-msg-1', tokenType: 'prompt', tokenCount: 100, usd: 0.5 },
+          { messageId: 'ai-msg-1', tokenType: 'completion', tokenCount: 150, usd: 0.75 },
+        ],
+      });
+    });
+
+    it('should return empty data for conversation with no messages', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toMatchObject({
+        conversationId,
+        totals: {
+          prompt: { usd: 0, tokenCount: 0 },
+          completion: { usd: 0, tokenCount: 0 },
+          total: { usd: 0, tokenCount: 0 },
+        },
+        perMessage: [],
+      });
+    });
+
+    it('should handle messages without transactions', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      const aiMessage = new Message({
+        messageId: 'ai-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: false,
+        tokenCount: 150,
+        createdAt: new Date('2024-01-01T10:01:00Z'),
+      });
+
+      await Promise.all([userMessage.save(), aiMessage.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0);
+      expect(response.body.totals.completion.usd).toBe(0);
+      expect(response.body.totals.total.usd).toBe(0);
+    });
+
+    it('should aggregate multiple transactions correctly', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await userMessage.save();
+
+      const promptTransaction1 = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 300000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      const promptTransaction2 = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 200000,
+        createdAt: new Date('2024-01-01T10:00:45Z'),
+      });
+
+      await Promise.all([promptTransaction1.save(), promptTransaction2.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0.5);
+      expect(response.body.perMessage[0].usd).toBe(0.5);
+    });
+
+    it('should handle null tokenCount values', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: null,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await userMessage.save();
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.tokenCount).toBe(0);
+    });
+
+    it('should handle null tokenValue in transactions', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await userMessage.save();
+
+      const promptTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: null,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      await promptTransaction.save();
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0);
+    });
+
+    it('should handle negative tokenValue using Math.abs', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await userMessage.save();
+
+      const promptTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: -500000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      await promptTransaction.save();
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0.5);
+    });
+
+    it('should filter by user correctly', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const otherUserId = 'other-user-id';
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      const otherUserMessage = new Message({
+        messageId: 'other-user-msg-1',
+        conversationId,
+        user: otherUserId,
+        isCreatedByUser: true,
+        tokenCount: 200,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await Promise.all([userMessage.save(), otherUserMessage.save()]);
+
+      const userTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 500000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      const otherUserTransaction = new Transaction({
+        conversationId,
+        user: otherUserId,
+        tokenType: 'prompt',
+        tokenValue: 1000000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      await Promise.all([userTransaction.save(), otherUserTransaction.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0.5);
+      expect(response.body.perMessage).toHaveLength(1);
+      expect(response.body.perMessage[0].messageId).toBe('user-msg-1');
+    });
+
+    it('should filter transactions by tokenType', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      await userMessage.save();
+
+      const promptTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 500000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      const otherTransaction = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'other',
+        tokenValue: 1000000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      await Promise.all([promptTransaction.save(), otherTransaction.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.totals.prompt.usd).toBe(0.5);
+      expect(response.body.totals.completion.usd).toBe(0);
+      expect(response.body.totals.total.usd).toBe(0.5);
+    });
+
+    it('should map transactions to messages chronologically', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      const userMessage1 = new Message({
+        messageId: 'user-msg-1',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 100,
+        createdAt: new Date('2024-01-01T10:00:00Z'),
+      });
+
+      const userMessage2 = new Message({
+        messageId: 'user-msg-2',
+        conversationId,
+        user: userId,
+        isCreatedByUser: true,
+        tokenCount: 200,
+        createdAt: new Date('2024-01-01T10:01:00Z'),
+      });
+
+      await Promise.all([userMessage1.save(), userMessage2.save()]);
+
+      const promptTransaction1 = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 500000,
+        createdAt: new Date('2024-01-01T10:00:30Z'),
+      });
+
+      const promptTransaction2 = new Transaction({
+        conversationId,
+        user: userId,
+        tokenType: 'prompt',
+        tokenValue: 1000000,
+        createdAt: new Date('2024-01-01T10:01:30Z'),
+      });
+
+      await Promise.all([promptTransaction1.save(), promptTransaction2.save()]);
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(200);
+      expect(response.body.perMessage).toHaveLength(2);
+      expect(response.body.perMessage[0].messageId).toBe('user-msg-1');
+      expect(response.body.perMessage[0].usd).toBe(0.5);
+      expect(response.body.perMessage[1].messageId).toBe('user-msg-2');
+      expect(response.body.perMessage[1].usd).toBe(1.0);
+    });
+
+    it('should handle database errors', async () => {
+      const { getConvo } = require('~/models');
+      getConvo.mockResolvedValue({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+      });
+
+      const conversation = new Conversation({
+        conversationId,
+        user: userId,
+        title: 'Test Conversation',
+        createdAt: new Date('2024-01-01T09:00:00Z'),
+      });
+
+      await conversation.save();
+
+      await mongoose.connection.close();
+
+      const response = await request(app).get(`/api/messages/${conversationId}/costs`);
+
+      expect(response.status).toBe(500);
+      expect(response.body).toHaveProperty('error');
+    });
+  });
+});

api/server/routes/__tests__/ldap.spec.js

@@ -1,13 +1,10 @@
-const express = require('express');
 const request = require('supertest');
-const { isEnabled } = require('@librechat/api');
+const express = require('express');
 const { getLdapConfig } = require('~/server/services/Config/ldap');
+const { isEnabled } = require('~/server/utils');
 
 jest.mock('~/server/services/Config/ldap');
-jest.mock('@librechat/api', () => ({
-  ...jest.requireActual('@librechat/api'),
-  isEnabled: jest.fn(),
-}));
+jest.mock('~/server/utils');
 
 const app = express();
 

api/server/routes/__tests__/mcp.spec.js

@@ -11,9 +11,6 @@ jest.mock('@librechat/api', () => ({
     completeOAuthFlow: jest.fn(),
     generateFlowId: jest.fn(),
   },
-  MCPTokenStorage: {
-    storeTokens: jest.fn(),
-  },
   getUserMCPAuthMap: jest.fn(),
 }));
 
@@ -47,12 +44,11 @@ jest.mock('~/models', () => ({
 jest.mock('~/server/services/Config', () => ({
   setCachedTools: jest.fn(),
   getCachedTools: jest.fn(),
-  getMCPServerTools: jest.fn(),
   loadCustomConfig: jest.fn(),
 }));
 
-jest.mock('~/server/services/Config/mcp', () => ({
-  updateMCPServerTools: jest.fn(),
+jest.mock('~/server/services/Config/mcpToolsCache', () => ({
+  updateMCPUserTools: jest.fn(),
 }));
 
 jest.mock('~/server/services/MCP', () => ({
@@ -128,13 +124,8 @@ describe('MCP Routes', () => {
         }),
       };
 
-      const mockMcpManager = {
-        getRawConfig: jest.fn().mockReturnValue({}),
-      };
-
       getLogStores.mockReturnValue({});
       require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
-      require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
 
       MCPOAuthHandler.initiateOAuthFlow.mockResolvedValue({
         authorizationUrl: 'https://oauth.example.com/auth',
@@ -152,7 +143,6 @@ describe('MCP Routes', () => {
         'test-server',
         'https://test-server.com',
         'test-user-id',
-        {},
         { clientId: 'test-client-id' },
       );
     });
@@ -244,7 +234,7 @@ describe('MCP Routes', () => {
   });
 
   describe('GET /:serverName/oauth/callback', () => {
-    const { MCPOAuthHandler, MCPTokenStorage } = require('@librechat/api');
+    const { MCPOAuthHandler } = require('@librechat/api');
     const { getLogStores } = require('~/cache');
 
     it('should redirect to error page when OAuth error is received', async () => {
@@ -290,7 +280,6 @@ describe('MCP Routes', () => {
     it('should handle OAuth callback successfully', async () => {
       const mockFlowManager = {
         completeFlow: jest.fn().mockResolvedValue(),
-        deleteFlow: jest.fn().mockResolvedValue(true),
       };
       const mockFlowState = {
         serverName: 'test-server',
@@ -306,7 +295,6 @@ describe('MCP Routes', () => {
 
       MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);
       MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockResolvedValue();
       getLogStores.mockReturnValue({});
       require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
 
@@ -321,7 +309,6 @@ describe('MCP Routes', () => {
       };
       const mockMcpManager = {
         getUserConnection: jest.fn().mockResolvedValue(mockUserConnection),
-        getRawConfig: jest.fn().mockReturnValue({}),
       };
       require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
 
@@ -344,26 +331,12 @@ describe('MCP Routes', () => {
         'test-flow-id',
         'test-auth-code',
         mockFlowManager,
-        {},
       );
-      expect(MCPTokenStorage.storeTokens).toHaveBeenCalledWith(
-        expect.objectContaining({
-          userId: 'test-user-id',
-          serverName: 'test-server',
-          tokens: mockTokens,
-          clientInfo: mockFlowState.clientInfo,
-          metadata: mockFlowState.metadata,
-        }),
-      );
-      const storeInvocation = MCPTokenStorage.storeTokens.mock.invocationCallOrder[0];
-      const connectInvocation = mockMcpManager.getUserConnection.mock.invocationCallOrder[0];
-      expect(storeInvocation).toBeLessThan(connectInvocation);
       expect(mockFlowManager.completeFlow).toHaveBeenCalledWith(
         'tool-flow-123',
         'mcp_oauth',
         mockTokens,
       );
-      expect(mockFlowManager.deleteFlow).toHaveBeenCalledWith('test-flow-id', 'mcp_get_tokens');
     });
 
     it('should redirect to error page when callback processing fails', async () => {
@@ -381,7 +354,6 @@ describe('MCP Routes', () => {
     it('should handle system-level OAuth completion', async () => {
       const mockFlowManager = {
         completeFlow: jest.fn().mockResolvedValue(),
-        deleteFlow: jest.fn().mockResolvedValue(true),
       };
       const mockFlowState = {
         serverName: 'test-server',
@@ -397,15 +369,9 @@ describe('MCP Routes', () => {
 
       MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);
       MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockResolvedValue();
       getLogStores.mockReturnValue({});
       require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
 
-      const mockMcpManager = {
-        getRawConfig: jest.fn().mockReturnValue({}),
-      };
-      require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
-
       const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({
         code: 'test-auth-code',
         state: 'test-flow-id',
@@ -413,13 +379,11 @@ describe('MCP Routes', () => {
 
       expect(response.status).toBe(302);
       expect(response.headers.location).toBe('/oauth/success?serverName=test-server');
-      expect(mockFlowManager.deleteFlow).toHaveBeenCalledWith('test-flow-id', 'mcp_get_tokens');
     });
 
     it('should handle reconnection failure after OAuth', async () => {
       const mockFlowManager = {
         completeFlow: jest.fn().mockResolvedValue(),
-        deleteFlow: jest.fn().mockResolvedValue(true),
       };
       const mockFlowState = {
         serverName: 'test-server',
@@ -435,13 +399,11 @@ describe('MCP Routes', () => {
 
       MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);
       MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockResolvedValue();
       getLogStores.mockReturnValue({});
       require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
 
       const mockMcpManager = {
         getUserConnection: jest.fn().mockRejectedValue(new Error('Reconnection failed')),
-        getRawConfig: jest.fn().mockReturnValue({}),
       };
       require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
 
@@ -456,46 +418,6 @@ describe('MCP Routes', () => {
 
       expect(response.status).toBe(302);
       expect(response.headers.location).toBe('/oauth/success?serverName=test-server');
-      expect(MCPTokenStorage.storeTokens).toHaveBeenCalled();
-      expect(mockFlowManager.deleteFlow).toHaveBeenCalledWith('test-flow-id', 'mcp_get_tokens');
-    });
-
-    it('should redirect to error page if token storage fails', async () => {
-      const mockFlowManager = {
-        completeFlow: jest.fn().mockResolvedValue(),
-        deleteFlow: jest.fn().mockResolvedValue(true),
-      };
-      const mockFlowState = {
-        serverName: 'test-server',
-        userId: 'test-user-id',
-        metadata: { toolFlowId: 'tool-flow-123' },
-        clientInfo: {},
-        codeVerifier: 'test-verifier',
-      };
-      const mockTokens = {
-        access_token: 'test-access-token',
-        refresh_token: 'test-refresh-token',
-      };
-
-      MCPOAuthHandler.getFlowState.mockResolvedValue(mockFlowState);
-      MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockRejectedValue(new Error('store failed'));
-      getLogStores.mockReturnValue({});
-      require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
-
-      const mockMcpManager = {
-        getUserConnection: jest.fn(),
-      };
-      require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
-
-      const response = await request(app).get('/api/mcp/test-server/oauth/callback').query({
-        code: 'test-auth-code',
-        state: 'test-flow-id',
-      });
-
-      expect(response.status).toBe(302);
-      expect(response.headers.location).toBe('/oauth/error?error=callback_failed');
-      expect(mockMcpManager.getUserConnection).not.toHaveBeenCalled();
     });
   });
 
@@ -856,10 +778,10 @@ describe('MCP Routes', () => {
       require('~/cache').getLogStores.mockReturnValue({});
 
       const { getCachedTools, setCachedTools } = require('~/server/services/Config');
-      const { updateMCPServerTools } = require('~/server/services/Config/mcp');
+      const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');
       getCachedTools.mockResolvedValue({});
       setCachedTools.mockResolvedValue();
-      updateMCPServerTools.mockResolvedValue();
+      updateMCPUserTools.mockResolvedValue();
 
       require('~/server/services/Tools/mcp').reinitMCPServer.mockResolvedValue({
         success: true,
@@ -914,10 +836,10 @@ describe('MCP Routes', () => {
       ]);
 
       const { getCachedTools, setCachedTools } = require('~/server/services/Config');
-      const { updateMCPServerTools } = require('~/server/services/Config/mcp');
+      const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');
       getCachedTools.mockResolvedValue({});
       setCachedTools.mockResolvedValue();
-      updateMCPServerTools.mockResolvedValue();
+      updateMCPUserTools.mockResolvedValue();
 
       require('~/server/services/Tools/mcp').reinitMCPServer.mockResolvedValue({
         success: true,
@@ -1221,11 +1143,7 @@ describe('MCP Routes', () => {
 
   describe('GET /:serverName/oauth/callback - Edge Cases', () => {
     it('should handle OAuth callback without toolFlowId (falsy toolFlowId)', async () => {
-      const { MCPOAuthHandler, MCPTokenStorage } = require('@librechat/api');
-      const mockTokens = {
-        access_token: 'edge-access-token',
-        refresh_token: 'edge-refresh-token',
-      };
+      const { MCPOAuthHandler } = require('@librechat/api');
       MCPOAuthHandler.getFlowState = jest.fn().mockResolvedValue({
         id: 'test-flow-id',
         userId: 'test-user-id',
@@ -1237,8 +1155,6 @@ describe('MCP Routes', () => {
         clientInfo: {},
         codeVerifier: 'test-verifier',
       });
-      MCPOAuthHandler.completeOAuthFlow = jest.fn().mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockResolvedValue();
 
       const mockFlowManager = {
         completeFlow: jest.fn(),
@@ -1249,7 +1165,6 @@ describe('MCP Routes', () => {
         getUserConnection: jest.fn().mockResolvedValue({
           fetchTools: jest.fn().mockResolvedValue([]),
         }),
-        getRawConfig: jest.fn().mockReturnValue({}),
       };
       require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
 
@@ -1264,11 +1179,6 @@ describe('MCP Routes', () => {
     it('should handle null cached tools in OAuth callback (triggers || {} fallback)', async () => {
       const { getCachedTools } = require('~/server/services/Config');
       getCachedTools.mockResolvedValue(null);
-      const { MCPOAuthHandler, MCPTokenStorage } = require('@librechat/api');
-      const mockTokens = {
-        access_token: 'edge-access-token',
-        refresh_token: 'edge-refresh-token',
-      };
 
       const mockFlowManager = {
         getFlowState: jest.fn().mockResolvedValue({
@@ -1281,15 +1191,6 @@ describe('MCP Routes', () => {
         completeFlow: jest.fn(),
       };
       require('~/config').getFlowStateManager.mockReturnValue(mockFlowManager);
-      MCPOAuthHandler.getFlowState.mockResolvedValue({
-        serverName: 'test-server',
-        userId: 'test-user-id',
-        metadata: { serverUrl: 'https://example.com', oauth: {} },
-        clientInfo: {},
-        codeVerifier: 'test-verifier',
-      });
-      MCPOAuthHandler.completeOAuthFlow.mockResolvedValue(mockTokens);
-      MCPTokenStorage.storeTokens.mockResolvedValue();
 
       const mockMcpManager = {
         getUserConnection: jest.fn().mockResolvedValue({
@@ -1297,7 +1198,6 @@ describe('MCP Routes', () => {
             .fn()
             .mockResolvedValue([{ name: 'test-tool', description: 'Test tool' }]),
         }),
-        getRawConfig: jest.fn().mockReturnValue({}),
       };
       require('~/config').getMCPManager.mockReturnValue(mockMcpManager);
 

api/server/routes/agents/actions.js

@@ -1,19 +1,20 @@
 const express = require('express');
 const { nanoid } = require('nanoid');
 const { logger } = require('@librechat/data-schemas');
-const { generateCheckAccess, isActionDomainAllowed } = require('@librechat/api');
+const { generateCheckAccess } = require('@librechat/api');
 const {
   Permissions,
   ResourceType,
-  PermissionBits,
   PermissionTypes,
   actionDelimiter,
+  PermissionBits,
   removeNullishValues,
 } = require('librechat-data-provider');
 const { encryptMetadata, domainParser } = require('~/server/services/ActionService');
 const { findAccessibleResources } = require('~/server/services/PermissionService');
 const { getAgent, updateAgent, getListAgentsByAccess } = require('~/models/Agent');
 const { updateAction, getActions, deleteAction } = require('~/models/Action');
+const { isActionDomainAllowed } = require('~/server/services/domains');
 const { canAccessAgentResource } = require('~/server/middleware');
 const { getRoleByName } = require('~/models/Role');
 

api/server/routes/agents/index.js

@@ -1,5 +1,4 @@
 const express = require('express');
-const { isEnabled } = require('@librechat/api');
 const {
   uaParser,
   checkBan,
@@ -9,6 +8,7 @@ const {
   concurrentLimiter,
   messageUserLimiter,
 } = require('~/server/middleware');
+const { isEnabled } = require('~/server/utils');
 const { v1 } = require('./v1');
 const chat = require('./chat');