✨ feat: Add subfolder support for model specs (#9165)

- Add optional `folder` field to TModelSpec type and schema
- Create ModelSpecFolder component for hierarchical display
- Implement expand/collapse functionality for folders
- Update search results to show folder context
- Sort folders alphabetically and specs by order/label
- Maintain backward compatibility (specs without folders appear at root)

This enhancement allows organizing model specs into categories/folders
for better organization and improved user experience when dealing with
many model configurations.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -40,13 +40,6 @@ NO_INDEX=true
 # Defaulted to 1.
 TRUST_PROXY=1
 
-# Minimum password length for user authentication
-# Default: 8
-# Note: When using LDAP authentication, you may want to set this to 1 
-# to bypass local password validation, as LDAP servers handle their own
-# password policies.
-# MIN_PASSWORD_LENGTH=8
-
 #===============#
 # JSON Logging  #
 #===============#
@@ -163,10 +156,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 +189,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 +452,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 +643,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 #
 #===============#
@@ -676,10 +660,6 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # REDIS_URI=rediss://127.0.0.1:6380
 # REDIS_CA=/path/to/ca-cert.pem
 
-# Elasticache may need to use an alternate dnsLookup for TLS connections.  see "Special Note: Aws Elasticache Clusters with TLS" on this webpage: https://www.npmjs.com/package/ioredis
-# Enable alternative dnsLookup for redis
-# REDIS_USE_ALTERNATIVE_DNS_LOOKUP=true
-
 # Redis authentication (if required)
 # REDIS_USERNAME=your_redis_username
 # REDIS_PASSWORD=your_redis_password
@@ -699,8 +679,8 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # REDIS_PING_INTERVAL=300
 
 # Force specific cache namespaces to use in-memory storage even when Redis is enabled
-# Comma-separated list of CacheKeys (e.g., ROLES,MESSAGES)
-# FORCED_IN_MEMORY_CACHE_NAMESPACES=ROLES,MESSAGES
+# Comma-separated list of CacheKeys (e.g., STATIC_CONFIG,ROLES,MESSAGES)
+# FORCED_IN_MEMORY_CACHE_NAMESPACES=STATIC_CONFIG,ROLES
 
 #==================================================#
 #                      Others                      #

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

@@ -1,78 +0,0 @@
-name: Cache Integration Tests
-
-on:
-  pull_request:
-    branches:
-      - main
-      - dev
-      - release/*
-    paths:
-      - 'packages/api/src/cache/**'
-      - 'redis-config/**'
-      - '.github/workflows/cache-integration-tests.yml'
-
-jobs:
-  cache_integration_tests:
-    name: Run Cache Integration Tests
-    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
-
-      - 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

.github/workflows/i18n-unused-keys.yml

@@ -1,10 +1,5 @@
 name: Detect Unused i18next Strings
 
-# This workflow checks for unused i18n keys in translation files.
-# It has special handling for:
-# - com_ui_special_var_* keys that are dynamically constructed
-# - com_agents_category_* keys that are stored in the database and used dynamically
-
 on:
   pull_request:
     paths:
@@ -12,7 +7,6 @@ on:
       - "api/**"
       - "packages/data-provider/src/**"
       - "packages/client/**"
-      - "packages/data-schemas/src/**"
 
 jobs:
   detect-unused-i18n-keys:
@@ -30,7 +24,7 @@ jobs:
 
           # Define paths
           I18N_FILE="client/src/locales/en/translation.json"
-          SOURCE_DIRS=("client/src" "api" "packages/data-provider/src" "packages/client" "packages/data-schemas/src")
+          SOURCE_DIRS=("client/src" "api" "packages/data-provider/src" "packages/client")
 
           # Check if translation file exists
           if [[ ! -f "$I18N_FILE" ]]; then
@@ -58,31 +52,6 @@ jobs:
                 fi
               done
               
-              # Also check if the key is directly used somewhere
-              if [[ "$FOUND" == false ]]; then
-                for DIR in "${SOURCE_DIRS[@]}"; do
-                  if grep -r --include=\*.{js,jsx,ts,tsx} -q "$KEY" "$DIR"; then
-                    FOUND=true
-                    break
-                  fi
-                done
-              fi
-            # Special case for agent category keys that are dynamically used from database
-            elif [[ "$KEY" == com_agents_category_* ]]; then
-              # Check if agent category localization is being used
-              for DIR in "${SOURCE_DIRS[@]}"; do
-                # Check for dynamic category label/description usage
-                if grep -r --include=\*.{js,jsx,ts,tsx} -E "category\.(label|description).*startsWith.*['\"]com_" "$DIR" > /dev/null 2>&1 || \
-                   # Check for the method that defines these keys
-                   grep -r --include=\*.{js,jsx,ts,tsx} "ensureDefaultCategories" "$DIR" > /dev/null 2>&1 || \
-                   # Check for direct usage in agentCategory.ts
-                   grep -r --include=\*.ts -E "label:.*['\"]$KEY['\"]" "$DIR" > /dev/null 2>&1 || \
-                   grep -r --include=\*.ts -E "description:.*['\"]$KEY['\"]" "$DIR" > /dev/null 2>&1; then
-                  FOUND=true
-                  break
-                fi
-              done
-              
               # Also check if the key is directly used somewhere
               if [[ "$FOUND" == false ]]; then
                 for DIR in "${SOURCE_DIRS[@]}"; do

.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.0
+# v0.8.0-rc2
 
 # Base node image
 FROM node:20-alpine AS node
@@ -30,7 +30,7 @@ RUN \
     # Allow mounting of these files, which have no default
     touch .env ; \
     # Create directories for the volumes to inherit the correct permissions
-    mkdir -p /app/client/public/images /app/api/logs /app/uploads ; \
+    mkdir -p /app/client/public/images /app/api/logs ; \
     npm config set fetch-retry-maxtimeout 600000 ; \
     npm config set fetch-retries 5 ; \
     npm config set fetch-retry-mintimeout 15000 ; \
@@ -44,6 +44,8 @@ RUN \
     npm prune --production; \
     npm cache clean --force
 
+RUN mkdir -p /app/client/public/images /app/api/logs
+
 # Node API setup
 EXPOSE 3080
 ENV HOST=0.0.0.0

Dockerfile.multi

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

MODEL_SPEC_FOLDERS.md

@@ -0,0 +1,147 @@
+# Model Spec Subfolder Support
+
+This enhancement adds the ability to organize model specs into subfolders/categories for better organization and user experience.
+
+## Feature Overview
+
+Model specs can now be grouped into folders by adding an optional `folder` field to each spec. This helps organize related models together, making it easier for users to find and select the appropriate model for their needs.
+
+## Configuration
+
+### Basic Usage
+
+Add a `folder` field to any model spec in your `librechat.yaml`:
+
+```yaml
+modelSpecs:
+  list:
+    - name: "gpt4_turbo"
+      label: "GPT-4 Turbo"
+      folder: "OpenAI Models"  # This spec will appear under "OpenAI Models" folder
+      preset:
+        endpoint: "openAI"
+        model: "gpt-4-turbo-preview"
+```
+
+### Folder Structure
+
+- **With Folder**: Model specs with the `folder` field will be grouped under that folder name
+- **Without Folder**: Model specs without the `folder` field appear at the root level
+- **Multiple Folders**: You can create as many folders as needed to organize your models
+- **Alphabetical Sorting**: Folders are sorted alphabetically, and specs within folders are sorted by their `order` field or label
+
+### Example Configuration
+
+```yaml
+modelSpecs:
+  list:
+    # OpenAI Models Category
+    - name: "gpt4_turbo"
+      label: "GPT-4 Turbo"
+      folder: "OpenAI Models"
+      preset:
+        endpoint: "openAI"
+        model: "gpt-4-turbo-preview"
+      
+    - name: "gpt35_turbo"
+      label: "GPT-3.5 Turbo"
+      folder: "OpenAI Models"
+      preset:
+        endpoint: "openAI"
+        model: "gpt-3.5-turbo"
+    
+    # Anthropic Models Category
+    - name: "claude3_opus"
+      label: "Claude 3 Opus"
+      folder: "Anthropic Models"
+      preset:
+        endpoint: "anthropic"
+        model: "claude-3-opus-20240229"
+    
+    # Root level model (no folder)
+    - name: "quick_chat"
+      label: "Quick Chat"
+      preset:
+        endpoint: "openAI"
+        model: "gpt-3.5-turbo"
+```
+
+## UI Features
+
+### Folder Display
+- Folders are displayed with expand/collapse functionality
+- Folder icons change between open/closed states
+- Indentation shows the hierarchy clearly
+
+### Search Integration
+- When searching for models, the folder path is shown for context
+- Search works across all models regardless of folder structure
+
+### User Experience
+- Folders start expanded by default for easy access
+- Click on folder header to expand/collapse
+- Selected model is highlighted with a checkmark
+- Folder state is preserved during the session
+
+## Benefits
+
+1. **Better Organization**: Group related models together (e.g., by provider, capability, or use case)
+2. **Improved Navigation**: Users can quickly find models in organized categories
+3. **Scalability**: Handles large numbers of model specs without overwhelming the UI
+4. **Backward Compatible**: Existing configurations without folders continue to work
+5. **Flexible Structure**: Mix foldered and non-foldered specs as needed
+
+## Use Cases
+
+### By Provider
+```yaml
+folder: "OpenAI Models"
+folder: "Anthropic Models"
+folder: "Google Models"
+```
+
+### By Capability
+```yaml
+folder: "Vision Models"
+folder: "Code Models"
+folder: "Creative Writing"
+```
+
+### By Performance Tier
+```yaml
+folder: "Premium Models"
+folder: "Standard Models"
+folder: "Budget Models"
+```
+
+### By Department/Team
+```yaml
+folder: "Engineering Team"
+folder: "Marketing Team"
+folder: "Research Team"
+```
+
+## Implementation Details
+
+### Type Changes
+- Added optional `folder?: string` field to `TModelSpec` type
+- Updated `tModelSpecSchema` to include the folder field validation
+
+### Components
+- Created `ModelSpecFolder` component for rendering folder structure
+- Updated `ModelSelector` to use folder-aware rendering
+- Enhanced search results to show folder context
+
+### Behavior
+- Folders are collapsible with state management
+- Models are sorted within folders by order/label
+- Root-level models appear after all folders
+
+## Migration
+
+No migration needed - the feature is fully backward compatible. Existing model specs without the `folder` field will continue to work and appear at the root level.
+
+## See Also
+
+- `librechat.example.subfolder.yaml` - Complete example configuration
+- GitHub Issue #9165 - Original feature request

README.md

@@ -65,17 +65,14 @@
 
 - 🔦 **Agents & Tools Integration**:  
   - **[LibreChat Agents](https://www.librechat.ai/docs/features/agents)**:
-    - No-Code Custom Assistants: Build specialized, AI-driven helpers
-    - Agent Marketplace: Discover and deploy community-built agents
-    - Collaborative Sharing: Share agents with specific users and groups
-    - Flexible & Extensible: Use MCP Servers, tools, file search, code execution, and more
+    - No-Code Custom Assistants: Build specialized, AI-driven helpers without coding  
+    - Flexible & Extensible: Use MCP Servers, tools, file search, code execution, and more  
     - Compatible with Custom Endpoints, OpenAI, Azure, Anthropic, AWS Bedrock, Google, Vertex AI, Responses API, and more
     - [Model Context Protocol (MCP) Support](https://modelcontextprotocol.io/clients#librechat) for Tools
 
 - 🔍 **Web Search**:  
   - Search the internet and retrieve relevant information to enhance your AI context
   - Combines search providers, content scrapers, and result rerankers for optimal results
-  - **Customizable Jina Reranking**: Configure custom Jina API URLs for reranking services
   - **[Learn More →](https://www.librechat.ai/docs/features/web_search)**
 
 - 🪄 **Generative UI with Code Artifacts**:  
@@ -90,18 +87,15 @@
   - Create, Save, & Share Custom Presets  
   - Switch between AI Endpoints and Presets mid-chat
   - Edit, Resubmit, and Continue Messages with Conversation branching  
-  - Create and share prompts with specific users and groups
   - [Fork Messages & Conversations](https://www.librechat.ai/docs/features/fork) for Advanced Context control
 
 - 💬 **Multimodal & File Interactions**:  
   - Upload and analyze images with Claude 3, GPT-4.5, GPT-4o, o1, Llama-Vision, and Gemini 📸  
   - Chat with Files using Custom Endpoints, OpenAI, Azure, Anthropic, AWS Bedrock, & Google 🗃️
 
-- 🌎 **Multilingual UI**:
-  - English, 中文 (简体), 中文 (繁體), العربية, Deutsch, Español, Français, Italiano
-  - Polski, Português (PT), Português (BR), Русский, 日本語, Svenska, 한국어, Tiếng Việt
-  - Türkçe, Nederlands, עברית, Català, Čeština, Dansk, Eesti, فارسی
-  - Suomi, Magyar, Հայերեն, Bahasa Indonesia, ქართული, Latviešu, ไทย, ئۇيغۇرچە
+- 🌎 **Multilingual UI**:  
+  - English, 中文, Deutsch, Español, Français, Italiano, Polski, Português Brasileiro
+  - Русский, 日本語, Svenska, 한국어, Tiếng Việt, 繁體中文, العربية, Türkçe, Nederlands, עברית
 
 - 🧠 **Reasoning UI**:  
   - Dynamic Reasoning UI for Chain-of-Thought/Reasoning AI models like DeepSeek-R1

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,18 +9,8 @@ const {
   getResponseSender,
   validateVisionModel,
 } = require('librechat-data-provider');
-const { sleep, SplitStreamHandler: _Handler } = require('@librechat/agents');
-const {
-  Tokenizer,
-  createFetch,
-  matchModelName,
-  getClaudeHeaders,
-  getModelMaxTokens,
-  configureReasoning,
-  checkPromptCacheSupport,
-  getModelMaxOutputTokens,
-  createStreamEventHandlers,
-} = require('@librechat/api');
+const { SplitStreamHandler: _Handler } = require('@librechat/agents');
+const { Tokenizer, createFetch, createStreamEventHandlers } = require('@librechat/api');
 const {
   truncateText,
   formatMessage,
@@ -30,9 +19,17 @@ const {
   parseParamFromPrompt,
   createContextHandlers,
 } = require('./prompts');
+const {
+  getClaudeHeaders,
+  configureReasoning,
+  checkPromptCacheSupport,
+} = require('~/server/services/Endpoints/anthropic/helpers');
+const { getModelMaxTokens, getModelMaxOutputTokens, matchModelName } = require('~/utils');
 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,31 +1,21 @@
 const crypto = require('crypto');
 const fetch = require('node-fetch');
-const { logger } = require('@librechat/data-schemas');
 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');
+const { logger } = require('~/config');
 
 class BaseClient {
   constructor(apiKey, options = {}) {
@@ -122,15 +112,13 @@ class BaseClient {
    * If a correction to the token usage is needed, the method should return an object with the corrected token counts.
    * Should only be used if `recordCollectedUsage` was not used instead.
    * @param {string} [model]
-   * @param {AppConfig['balance']} [balance]
    * @param {number} promptTokens
    * @param {number} completionTokens
    * @returns {Promise<void>}
    */
-  async recordTokenUsage({ model, balance, promptTokens, completionTokens }) {
+  async recordTokenUsage({ model, promptTokens, completionTokens }) {
     logger.debug('[BaseClient] `recordTokenUsage` not implemented.', {
       model,
-      balance,
       promptTokens,
       completionTokens,
     });
@@ -583,7 +571,6 @@ class BaseClient {
   }
 
   async sendMessage(message, opts = {}) {
-    const appConfig = this.options.req?.config;
     /** @type {Promise<TMessage>} */
     let userMessagePromise;
     const { user, head, isEdited, conversationId, responseMessageId, saveOptions, userMessage } =
@@ -670,9 +657,9 @@ class BaseClient {
       }
     }
 
-    const balanceConfig = getBalanceConfig(appConfig);
+    const balance = this.options.req?.app?.locals?.balance;
     if (
-      balanceConfig?.enabled &&
+      balance?.enabled &&
       supportsBalanceCheck[this.options.endpointType ?? this.options.endpoint]
     ) {
       await checkBalance({
@@ -771,7 +758,6 @@ class BaseClient {
           usage,
           promptTokens,
           completionTokens,
-          balance: balanceConfig,
           model: responseMessage.model,
         });
       }
@@ -1207,135 +1193,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 +1243,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,7 +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');
 const { Tokenizer, getSafetySettings } = require('@librechat/api');
@@ -24,6 +21,9 @@ const {
 } = require('librechat-data-provider');
 const { encodeAndFormat } = require('~/server/services/Files/images');
 const { spendTokens } = require('~/models/spendTokens');
+const { getModelMaxTokens } = require('~/utils');
+const { sleep } = require('~/server/utils');
+const { logger } = require('~/config');
 const {
   formatMessage,
   createContextHandlers,

api/app/clients/OpenAIClient.js

@@ -1,15 +1,13 @@
-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,
   createFetch,
   resolveHeaders,
   constructAzureURL,
-  getModelMaxTokens,
   genAzureChatCompletion,
-  getModelMaxOutputTokens,
   createStreamEventHandlers,
 } = require('@librechat/api');
 const {
@@ -33,16 +31,17 @@ const {
   titleInstruction,
   createContextHandlers,
 } = require('./prompts');
+const { extractBaseURL, getModelMaxTokens, getModelMaxOutputTokens } = require('~/utils');
 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 { createLLM, RunManager } = require('./llm');
 const { summaryBuffer } = require('./memory');
 const { runTitleChain } = require('./chains');
-const { extractBaseURL } = require('~/utils');
 const { tokenSplit } = require('./document');
 const BaseClient = require('./BaseClient');
+const { logger } = require('~/config');
 
 class OpenAIClient extends BaseClient {
   constructor(apiKey, options = {}) {
@@ -613,8 +612,79 @@ class OpenAIClient extends BaseClient {
     return (reply ?? '').trim();
   }
 
-  initializeLLM() {
-    throw new Error('Deprecated');
+  initializeLLM({
+    model = openAISettings.model.default,
+    modelName,
+    temperature = 0.2,
+    max_tokens,
+    streaming,
+    context,
+    tokenBuffer,
+    initialMessageCount,
+    conversationId,
+  }) {
+    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 { req, res, debug } = this.options;
+    const runManager = new RunManager({ req, res, debug, abortController: this.abortController });
+    this.runManager = runManager;
+
+    const llm = createLLM({
+      modelOptions,
+      configOptions,
+      openAIApiKey: this.apiKey,
+      azure: this.azure,
+      streaming,
+      callbacks: runManager.createCallbacks({
+        context,
+        tokenBuffer,
+        conversationId: this.conversationId ?? conversationId,
+        initialMessageCount,
+      }),
+    });
+
+    return llm;
   }
 
   /**
@@ -632,7 +702,6 @@ class OpenAIClient extends BaseClient {
    *                            In case of failure, it will return the default title, "New Chat".
    */
   async titleConvo({ text, conversationId, responseText = '' }) {
-    const appConfig = this.options.req?.config;
     this.conversationId = conversationId;
 
     if (this.options.attachments) {
@@ -661,7 +730,8 @@ class OpenAIClient extends BaseClient {
       max_tokens: 16,
     };
 
-    const azureConfig = appConfig?.endpoints?.[EModelEndpoint.azureOpenAI];
+    /** @type {TAzureConfig | undefined} */
+    const azureConfig = this.options?.req?.app?.locals?.[EModelEndpoint.azureOpenAI];
 
     const resetTitleOptions = !!(
       (this.azure && azureConfig) ||
@@ -1050,7 +1120,6 @@ ${convo}
   }
 
   async chatCompletion({ payload, onProgress, abortController = null }) {
-    const appConfig = this.options.req?.config;
     let error = null;
     let intermediateReply = [];
     const errorCallback = (err) => (error = err);
@@ -1096,7 +1165,8 @@ ${convo}
         opts.fetchOptions.agent = new HttpsProxyAgent(this.options.proxy);
       }
 
-      const azureConfig = appConfig?.endpoints?.[EModelEndpoint.azureOpenAI];
+      /** @type {TAzureConfig | undefined} */
+      const azureConfig = this.options?.req?.app?.locals?.[EModelEndpoint.azureOpenAI];
 
       if (
         (this.azure && this.isVisionModel && azureConfig) ||

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/callbacks/createStartHandler.js

@@ -0,0 +1,95 @@
+const { promptTokensEstimate } = require('openai-chat-tokens');
+const { EModelEndpoint, supportsBalanceCheck } = require('librechat-data-provider');
+const { formatFromLangChain } = require('~/app/clients/prompts');
+const { getBalanceConfig } = require('~/server/services/Config');
+const { checkBalance } = require('~/models/balanceMethods');
+const { logger } = require('~/config');
+
+const createStartHandler = ({
+  context,
+  conversationId,
+  tokenBuffer = 0,
+  initialMessageCount,
+  manager,
+}) => {
+  return async (_llm, _messages, runId, parentRunId, extraParams) => {
+    const { invocation_params } = extraParams;
+    const { model, functions, function_call } = invocation_params;
+    const messages = _messages[0].map(formatFromLangChain);
+
+    logger.debug(`[createStartHandler] handleChatModelStart: ${context}`, {
+      model,
+      function_call,
+    });
+
+    if (context !== 'title') {
+      logger.debug(`[createStartHandler] handleChatModelStart: ${context}`, {
+        functions,
+      });
+    }
+
+    const payload = { messages };
+    let prelimPromptTokens = 1;
+
+    if (functions) {
+      payload.functions = functions;
+      prelimPromptTokens += 2;
+    }
+
+    if (function_call) {
+      payload.function_call = function_call;
+      prelimPromptTokens -= 5;
+    }
+
+    prelimPromptTokens += promptTokensEstimate(payload);
+    logger.debug('[createStartHandler]', {
+      prelimPromptTokens,
+      tokenBuffer,
+    });
+    prelimPromptTokens += tokenBuffer;
+
+    try {
+      const balance = await getBalanceConfig();
+      if (balance?.enabled && supportsBalanceCheck[EModelEndpoint.openAI]) {
+        const generations =
+          initialMessageCount && messages.length > initialMessageCount
+            ? messages.slice(initialMessageCount)
+            : null;
+        await checkBalance({
+          req: manager.req,
+          res: manager.res,
+          txData: {
+            user: manager.user,
+            tokenType: 'prompt',
+            amount: prelimPromptTokens,
+            debug: manager.debug,
+            generations,
+            model,
+            endpoint: EModelEndpoint.openAI,
+          },
+        });
+      }
+    } catch (err) {
+      logger.error(`[createStartHandler][${context}] checkBalance error`, err);
+      manager.abortController.abort();
+      if (context === 'summary' || context === 'plugins') {
+        manager.addRun(runId, { conversationId, error: err.message });
+        throw new Error(err);
+      }
+      return;
+    }
+
+    manager.addRun(runId, {
+      model,
+      messages,
+      functions,
+      function_call,
+      runId,
+      parentRunId,
+      conversationId,
+      prelimPromptTokens,
+    });
+  };
+};
+
+module.exports = createStartHandler;

api/app/clients/callbacks/index.js

@@ -0,0 +1,5 @@
+const createStartHandler = require('./createStartHandler');
+
+module.exports = {
+  createStartHandler,
+};

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/RunManager.js

@@ -0,0 +1,105 @@
+const { createStartHandler } = require('~/app/clients/callbacks');
+const { spendTokens } = require('~/models/spendTokens');
+const { logger } = require('~/config');
+
+class RunManager {
+  constructor(fields) {
+    const { req, res, abortController, debug } = fields;
+    this.abortController = abortController;
+    this.user = req.user.id;
+    this.req = req;
+    this.res = res;
+    this.debug = debug;
+    this.runs = new Map();
+    this.convos = new Map();
+  }
+
+  addRun(runId, runData) {
+    if (!this.runs.has(runId)) {
+      this.runs.set(runId, runData);
+      if (runData.conversationId) {
+        this.convos.set(runData.conversationId, runId);
+      }
+      return runData;
+    } else {
+      const existingData = this.runs.get(runId);
+      const update = { ...existingData, ...runData };
+      this.runs.set(runId, update);
+      if (update.conversationId) {
+        this.convos.set(update.conversationId, runId);
+      }
+      return update;
+    }
+  }
+
+  removeRun(runId) {
+    if (this.runs.has(runId)) {
+      this.runs.delete(runId);
+    } else {
+      logger.error(`[api/app/clients/llm/RunManager] Run with ID ${runId} does not exist.`);
+    }
+  }
+
+  getAllRuns() {
+    return Array.from(this.runs.values());
+  }
+
+  getRunById(runId) {
+    return this.runs.get(runId);
+  }
+
+  getRunByConversationId(conversationId) {
+    const runId = this.convos.get(conversationId);
+    return { run: this.runs.get(runId), runId };
+  }
+
+  createCallbacks(metadata) {
+    return [
+      {
+        handleChatModelStart: createStartHandler({ ...metadata, manager: this }),
+        handleLLMEnd: async (output, runId, _parentRunId) => {
+          const { llmOutput, ..._output } = output;
+          logger.debug(`[RunManager] handleLLMEnd: ${JSON.stringify(metadata)}`, {
+            runId,
+            _parentRunId,
+            llmOutput,
+          });
+
+          if (metadata.context !== 'title') {
+            logger.debug('[RunManager] handleLLMEnd:', {
+              output: _output,
+            });
+          }
+
+          const { tokenUsage } = output.llmOutput;
+          const run = this.getRunById(runId);
+          this.removeRun(runId);
+
+          const txData = {
+            user: this.user,
+            model: run?.model ?? 'gpt-3.5-turbo',
+            ...metadata,
+          };
+
+          await spendTokens(txData, tokenUsage);
+        },
+        handleLLMError: async (err) => {
+          logger.error(`[RunManager] handleLLMError: ${JSON.stringify(metadata)}`, err);
+          if (metadata.context === 'title') {
+            return;
+          } else if (metadata.context === 'plugins') {
+            throw new Error(err);
+          }
+          const { conversationId } = metadata;
+          const { run } = this.getRunByConversationId(conversationId);
+          if (run && run.error) {
+            const { error } = run;
+            throw new Error(error);
+          }
+        },
+      },
+    ];
+  }
+}
+
+module.exports = RunManager;

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,9 @@
+const createLLM = require('./createLLM');
+const RunManager = require('./RunManager');
 const createCoherePayload = require('./createCoherePayload');
 
 module.exports = {
+  createLLM,
+  RunManager,
   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/prompts/createContextHandlers.js

@@ -1,6 +1,7 @@
 const axios = require('axios');
+const { isEnabled } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { isEnabled, generateShortLivedToken } = require('@librechat/api');
+const { generateShortLivedToken } = require('~/server/services/AuthService');
 
 const footer = `Use the context as your learned knowledge to better answer the user.
 

api/app/clients/specs/BaseClient.test.js

@@ -2,14 +2,6 @@ const { Constants } = require('librechat-data-provider');
 const { initializeFakeClient } = require('./FakeClient');
 
 jest.mock('~/db/connect');
-jest.mock('~/server/services/Config', () => ({
-  getAppConfig: jest.fn().mockResolvedValue({
-    // Default app config for tests
-    paths: { uploads: '/tmp' },
-    fileStrategy: 'local',
-    memory: { disabled: false },
-  }),
-}));
 jest.mock('~/models', () => ({
   User: jest.fn(),
   Key: jest.fn(),

api/app/clients/specs/FakeClient.js

@@ -1,5 +1,5 @@
-const { getModelMaxTokens } = require('@librechat/api');
 const BaseClient = require('../BaseClient');
+const { getModelMaxTokens } = require('../../../utils');
 
 class FakeClient extends BaseClient {
   constructor(apiKey, options = {}) {

api/app/clients/tools/index.js

@@ -1,4 +1,4 @@
-const manifest = require('./manifest');
+const availableTools = require('./manifest.json');
 
 // Structured Tools
 const DALLE3 = require('./structured/DALLE3');
@@ -13,8 +13,23 @@ const TraversaalSearch = require('./structured/TraversaalSearch');
 const createOpenAIImageTools = require('./structured/OpenAIImageTools');
 const TavilySearchResults = require('./structured/TavilySearchResults');
 
+/** @type {Record<string, TPlugin | undefined>} */
+const manifestToolMap = {};
+
+/** @type {Array<TPlugin>} */
+const toolkits = [];
+
+availableTools.forEach((tool) => {
+  manifestToolMap[tool.pluginKey] = tool;
+  if (tool.toolkit === true) {
+    toolkits.push(tool);
+  }
+});
+
 module.exports = {
-  ...manifest,
+  toolkits,
+  availableTools,
+  manifestToolMap,
   // Structured Tools
   DALLE3,
   FluxAPI,

api/app/clients/tools/manifest.js

@@ -1,20 +0,0 @@
-const availableTools = require('./manifest.json');
-
-/** @type {Record<string, TPlugin | undefined>} */
-const manifestToolMap = {};
-
-/** @type {Array<TPlugin>} */
-const toolkits = [];
-
-availableTools.forEach((tool) => {
-  manifestToolMap[tool.pluginKey] = tool;
-  if (tool.toolkit === true) {
-    toolkits.push(tool);
-  }
-});
-
-module.exports = {
-  toolkits,
-  availableTools,
-  manifestToolMap,
-};

api/app/clients/tools/manifest.json

@@ -49,7 +49,7 @@
     "pluginKey": "image_gen_oai",
     "toolkit": true,
     "description": "Image Generation and Editing using OpenAI's latest state-of-the-art models",
-    "icon": "assets/image_gen_oai.png",
+    "icon": "/assets/image_gen_oai.png",
     "authConfig": [
       {
         "authField": "IMAGE_GEN_OAI_API_KEY",
@@ -75,7 +75,7 @@
     "name": "Browser",
     "pluginKey": "web-browser",
     "description": "Scrape and summarize webpage data",
-    "icon": "assets/web-browser.svg",
+    "icon": "/assets/web-browser.svg",
     "authConfig": [
       {
         "authField": "OPENAI_API_KEY",
@@ -170,7 +170,7 @@
     "name": "OpenWeather",
     "pluginKey": "open_weather",
     "description": "Get weather forecasts and historical data from the OpenWeather API",
-    "icon": "assets/openweather.png",
+    "icon": "/assets/openweather.png",
     "authConfig": [
       {
         "authField": "OPENWEATHER_API_KEY",

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,13 +1,14 @@
 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');
 const { FileContext, ContentTypes } = require('librechat-data-provider');
+const { getImageBasename } = require('~/server/services/Files/images');
 const extractBaseURL = require('~/utils/extractBaseURL');
+const logger = require('~/config/winston');
 
 const displayMessage =
   "DALL-E 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/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

@@ -1,16 +1,69 @@
+const { z } = require('zod');
 const axios = require('axios');
 const { v4 } = require('uuid');
 const OpenAI = require('openai');
 const FormData = require('form-data');
 const { ProxyAgent } = require('undici');
 const { tool } = require('@langchain/core/tools');
+const { logAxiosError } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { logAxiosError, oaiToolkit } = require('@librechat/api');
 const { ContentTypes, EImageOutputType } = require('librechat-data-provider');
 const { getStrategyFunctions } = require('~/server/services/Files/strategies');
-const extractBaseURL = require('~/utils/extractBaseURL');
+const { extractBaseURL } = require('~/utils');
 const { getFiles } = require('~/models/File');
 
+/** Default descriptions for image generation tool  */
+const DEFAULT_IMAGE_GEN_DESCRIPTION = `
+Generates high-quality, original images based solely on text, not using any uploaded reference images.
+
+When to use \`image_gen_oai\`:
+- To create entirely new images from detailed text descriptions that do NOT reference any image files.
+
+When NOT to use \`image_gen_oai\`:
+- If the user has uploaded any images and requests modifications, enhancements, or remixing based on those uploads → use \`image_edit_oai\` instead.
+
+Generated image IDs will be returned in the response, so you can refer to them in future requests made to \`image_edit_oai\`.
+`.trim();
+
+/** Default description for image editing tool  */
+const DEFAULT_IMAGE_EDIT_DESCRIPTION =
+  `Generates high-quality, original images based on text and one or more uploaded/referenced images.
+
+When to use \`image_edit_oai\`:
+- The user wants to modify, extend, or remix one **or more** uploaded images, either:
+- Previously generated, or in the current request (both to be included in the \`image_ids\` array).
+- Always when the user refers to uploaded images for editing, enhancement, remixing, style transfer, or combining elements.
+- Any current or existing images are to be used as visual guides.
+- If there are any files in the current request, they are more likely than not expected as references for image edit requests.
+
+When NOT to use \`image_edit_oai\`:
+- Brand-new generations that do not rely on an existing image → use \`image_gen_oai\` instead.
+
+Both generated and referenced image IDs will be returned in the response, so you can refer to them in future requests made to \`image_edit_oai\`.
+`.trim();
+
+/** Default prompt descriptions  */
+const DEFAULT_IMAGE_GEN_PROMPT_DESCRIPTION = `Describe the image you want in detail. 
+      Be highly specific—break your idea into layers: 
+      (1) main concept and subject,
+      (2) composition and position,
+      (3) lighting and mood,
+      (4) style, medium, or camera details,
+      (5) important features (age, expression, clothing, etc.),
+      (6) background.
+      Use positive, descriptive language and specify what should be included, not what to avoid. 
+      List number and characteristics of people/objects, and mention style/technical requirements (e.g., "DSLR photo, 85mm lens, golden hour").
+      Do not reference any uploaded images—use for new image creation from text only.`;
+
+const DEFAULT_IMAGE_EDIT_PROMPT_DESCRIPTION = `Describe the changes, enhancements, or new ideas to apply to the uploaded image(s).
+      Be highly specific—break your request into layers: 
+      (1) main concept or transformation,
+      (2) specific edits/replacements or composition guidance,
+      (3) desired style, mood, or technique,
+      (4) features/items to keep, change, or add (such as objects, people, clothing, lighting, etc.).
+      Use positive, descriptive language and clarify what should be included or changed, not what to avoid.
+      Always base this prompt on the most recently uploaded reference images.`;
+
 const displayMessage =
   "The tool 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.";
 
@@ -38,6 +91,22 @@ function returnValue(value) {
   return value;
 }
 
+const getImageGenDescription = () => {
+  return process.env.IMAGE_GEN_OAI_DESCRIPTION || DEFAULT_IMAGE_GEN_DESCRIPTION;
+};
+
+const getImageEditDescription = () => {
+  return process.env.IMAGE_EDIT_OAI_DESCRIPTION || DEFAULT_IMAGE_EDIT_DESCRIPTION;
+};
+
+const getImageGenPromptDescription = () => {
+  return process.env.IMAGE_GEN_OAI_PROMPT_DESCRIPTION || DEFAULT_IMAGE_GEN_PROMPT_DESCRIPTION;
+};
+
+const getImageEditPromptDescription = () => {
+  return process.env.IMAGE_EDIT_OAI_PROMPT_DESCRIPTION || DEFAULT_IMAGE_EDIT_PROMPT_DESCRIPTION;
+};
+
 function createAbortHandler() {
   return function () {
     logger.debug('[ImageGenOAI] Image generation aborted');
@@ -52,9 +121,7 @@ function createAbortHandler() {
  * @param {string} fields.IMAGE_GEN_OAI_API_KEY - The OpenAI API key
  * @param {boolean} [fields.override] - Whether to override the API key check, necessary for app initialization
  * @param {MongoFile[]} [fields.imageFiles] - The images to be used for editing
- * @param {string} [fields.imageOutputType] - The image output type configuration
- * @param {string} [fields.fileStrategy] - The file storage strategy
- * @returns {Array<ReturnType<tool>>} - Array of image tools
+ * @returns {Array} - Array of image tools
  */
 function createOpenAIImageTools(fields = {}) {
   /** @type {boolean} Used to initialize the Tool without necessary variables. */
@@ -64,8 +131,8 @@ function createOpenAIImageTools(fields = {}) {
     throw new Error('This tool is only available for agents.');
   }
   const { req } = fields;
-  const imageOutputType = fields.imageOutputType || EImageOutputType.PNG;
-  const appFileStrategy = fields.fileStrategy;
+  const imageOutputType = req?.app.locals.imageOutputType || EImageOutputType.PNG;
+  const appFileStrategy = req?.app.locals.fileStrategy;
 
   const getApiKey = () => {
     const apiKey = process.env.IMAGE_GEN_OAI_API_KEY ?? '';
@@ -218,7 +285,46 @@ Error Message: ${error.message}`);
       ];
       return [response, { content, file_ids }];
     },
-    oaiToolkit.image_gen_oai,
+    {
+      name: 'image_gen_oai',
+      description: getImageGenDescription(),
+      schema: z.object({
+        prompt: z.string().max(32000).describe(getImageGenPromptDescription()),
+        background: z
+          .enum(['transparent', 'opaque', 'auto'])
+          .optional()
+          .describe(
+            'Sets transparency for the background. Must be one of transparent, opaque or auto (default). When transparent, the output format should be png or webp.',
+          ),
+        /*
+        n: z
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .optional()
+          .describe('The number of images to generate. Must be between 1 and 10.'),
+        output_compression: z
+          .number()
+          .int()
+          .min(0)
+          .max(100)
+          .optional()
+          .describe('The compression level (0-100%) for webp or jpeg formats. Defaults to 100.'),
+           */
+        quality: z
+          .enum(['auto', 'high', 'medium', 'low'])
+          .optional()
+          .describe('The quality of the image. One of auto (default), high, medium, or low.'),
+        size: z
+          .enum(['auto', '1024x1024', '1536x1024', '1024x1536'])
+          .optional()
+          .describe(
+            'The size of the generated image. One of 1024x1024, 1536x1024 (landscape), 1024x1536 (portrait), or auto (default).',
+          ),
+      }),
+      responseFormat: 'content_and_artifact',
+    },
   );
 
   /**
@@ -411,7 +517,48 @@ Error Message: ${error.message || 'Unknown error'}`);
         }
       }
     },
-    oaiToolkit.image_edit_oai,
+    {
+      name: 'image_edit_oai',
+      description: getImageEditDescription(),
+      schema: z.object({
+        image_ids: z
+          .array(z.string())
+          .min(1)
+          .describe(
+            `
+IDs (image ID strings) of previously generated or uploaded images that should guide the edit.
+
+Guidelines:
+- If the user's request depends on any prior image(s), copy their image IDs into the \`image_ids\` array (in the same order the user refers to them).  
+- Never invent or hallucinate IDs; only use IDs that are still visible in the conversation context.
+- If no earlier image is relevant, omit the field entirely.
+`.trim(),
+          ),
+        prompt: z.string().max(32000).describe(getImageEditPromptDescription()),
+        /*
+        n: z
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .optional()
+          .describe('The number of images to generate. Must be between 1 and 10. Defaults to 1.'),
+        */
+        quality: z
+          .enum(['auto', 'high', 'medium', 'low'])
+          .optional()
+          .describe(
+            'The quality of the image. One of auto (default), high, medium, or low. High/medium/low only supported for gpt-image-1.',
+          ),
+        size: z
+          .enum(['auto', '1024x1024', '1536x1024', '1024x1536', '256x256', '512x512'])
+          .optional()
+          .describe(
+            'The size of the generated images. For gpt-image-1: auto (default), 1024x1024, 1536x1024, 1024x1536. For dall-e-2: 256x256, 512x512, 1024x1024.',
+          ),
+      }),
+      responseFormat: 'content_and_artifact',
+    },
   );
 
   return [imageGenTool, imageEditTool];

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

@@ -6,19 +6,19 @@ 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.";
+  '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.';
 
 class StableDiffusionAPI extends Tool {
   constructor(fields) {
     super();
     /** @type {string} User ID */
     this.userId = fields.userId;
-    /** @type {ServerRequest | undefined} Express Request object, only provided by ToolService */
+    /** @type {Express.Request | undefined} Express Request object, only provided by ToolService */
     this.req = fields.req;
     /** @type {boolean} Used to initialize the Tool without necessary variables. */
     this.override = fields.override ?? false;
@@ -44,7 +44,7 @@ class StableDiffusionAPI extends Tool {
 // "negative_prompt":"semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime, out of frame, low quality, ugly, mutation, deformed"
 // - Generate images only once per human query unless explicitly requested by the user`;
     this.description =
-      "You can generate images using text with 'stable-diffusion'. This tool is exclusively for visual content.";
+      'You can generate images using text with \'stable-diffusion\'. This tool is exclusively for visual content.';
     this.schema = z.object({
       prompt: z
         .string()

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/structured/YouTube.js

@@ -1,9 +1,9 @@
-const { ytToolkit } = require('@librechat/api');
+const { z } = require('zod');
 const { tool } = require('@langchain/core/tools');
 const { youtube } = require('@googleapis/youtube');
-const { logger } = require('@librechat/data-schemas');
 const { YoutubeTranscript } = require('youtube-transcript');
 const { getApiKey } = require('./credentials');
+const { logger } = require('~/config');
 
 function extractVideoId(url) {
   const rawIdRegex = /^[a-zA-Z0-9_-]{11}$/;
@@ -29,7 +29,7 @@ function parseTranscript(transcriptResponse) {
     .map((entry) => entry.text.trim())
     .filter((text) => text)
     .join(' ')
-    .replaceAll(''', "'");
+    .replaceAll(''', '\'');
 }
 
 function createYouTubeTools(fields = {}) {
@@ -42,94 +42,160 @@ function createYouTubeTools(fields = {}) {
     auth: apiKey,
   });
 
-  const searchTool = tool(async ({ query, maxResults = 5 }) => {
-    const response = await youtubeClient.search.list({
-      part: 'snippet',
-      q: query,
-      type: 'video',
-      maxResults: maxResults || 5,
-    });
-    const result = response.data.items.map((item) => ({
-      title: item.snippet.title,
-      description: item.snippet.description,
-      url: `https://www.youtube.com/watch?v=${item.id.videoId}`,
-    }));
-    return JSON.stringify(result, null, 2);
-  }, ytToolkit.youtube_search);
+  const searchTool = tool(
+    async ({ query, maxResults = 5 }) => {
+      const response = await youtubeClient.search.list({
+        part: 'snippet',
+        q: query,
+        type: 'video',
+        maxResults: maxResults || 5,
+      });
+      const result = response.data.items.map((item) => ({
+        title: item.snippet.title,
+        description: item.snippet.description,
+        url: `https://www.youtube.com/watch?v=${item.id.videoId}`,
+      }));
+      return JSON.stringify(result, null, 2);
+    },
+    {
+      name: 'youtube_search',
+      description: `Search for YouTube videos by keyword or phrase.
+- Required: query (search terms to find videos)
+- Optional: maxResults (number of videos to return, 1-50, default: 5)
+- Returns: List of videos with titles, descriptions, and URLs
+- Use for: Finding specific videos, exploring content, research
+Example: query="cooking pasta tutorials" maxResults=3`,
+      schema: z.object({
+        query: z.string().describe('Search query terms'),
+        maxResults: z.number().int().min(1).max(50).optional().describe('Number of results (1-50)'),
+      }),
+    },
+  );
 
-  const infoTool = tool(async ({ url }) => {
-    const videoId = extractVideoId(url);
-    if (!videoId) {
-      throw new Error('Invalid YouTube URL or video ID');
-    }
+  const infoTool = tool(
+    async ({ url }) => {
+      const videoId = extractVideoId(url);
+      if (!videoId) {
+        throw new Error('Invalid YouTube URL or video ID');
+      }
 
-    const response = await youtubeClient.videos.list({
-      part: 'snippet,statistics',
-      id: videoId,
-    });
+      const response = await youtubeClient.videos.list({
+        part: 'snippet,statistics',
+        id: videoId,
+      });
 
-    if (!response.data.items?.length) {
-      throw new Error('Video not found');
-    }
-    const video = response.data.items[0];
+      if (!response.data.items?.length) {
+        throw new Error('Video not found');
+      }
+      const video = response.data.items[0];
 
-    const result = {
-      title: video.snippet.title,
-      description: video.snippet.description,
-      views: video.statistics.viewCount,
-      likes: video.statistics.likeCount,
-      comments: video.statistics.commentCount,
-    };
-    return JSON.stringify(result, null, 2);
-  }, ytToolkit.youtube_info);
+      const result = {
+        title: video.snippet.title,
+        description: video.snippet.description,
+        views: video.statistics.viewCount,
+        likes: video.statistics.likeCount,
+        comments: video.statistics.commentCount,
+      };
+      return JSON.stringify(result, null, 2);
+    },
+    {
+      name: 'youtube_info',
+      description: `Get detailed metadata and statistics for a specific YouTube video.
+- Required: url (full YouTube URL or video ID)
+- Returns: Video title, description, view count, like count, comment count
+- Use for: Getting video metrics and basic metadata
+- DO NOT USE FOR VIDEO SUMMARIES, USE TRANSCRIPTS FOR COMPREHENSIVE ANALYSIS
+- Accepts both full URLs and video IDs
+Example: url="https://youtube.com/watch?v=abc123" or url="abc123"`,
+      schema: z.object({
+        url: z.string().describe('YouTube video URL or ID'),
+      }),
+    },
+  );
 
-  const commentsTool = tool(async ({ url, maxResults = 10 }) => {
-    const videoId = extractVideoId(url);
-    if (!videoId) {
-      throw new Error('Invalid YouTube URL or video ID');
-    }
+  const commentsTool = tool(
+    async ({ url, maxResults = 10 }) => {
+      const videoId = extractVideoId(url);
+      if (!videoId) {
+        throw new Error('Invalid YouTube URL or video ID');
+      }
 
-    const response = await youtubeClient.commentThreads.list({
-      part: 'snippet',
-      videoId,
-      maxResults: maxResults || 10,
-    });
+      const response = await youtubeClient.commentThreads.list({
+        part: 'snippet',
+        videoId,
+        maxResults: maxResults || 10,
+      });
 
-    const result = response.data.items.map((item) => ({
-      author: item.snippet.topLevelComment.snippet.authorDisplayName,
-      text: item.snippet.topLevelComment.snippet.textDisplay,
-      likes: item.snippet.topLevelComment.snippet.likeCount,
-    }));
-    return JSON.stringify(result, null, 2);
-  }, ytToolkit.youtube_comments);
+      const result = response.data.items.map((item) => ({
+        author: item.snippet.topLevelComment.snippet.authorDisplayName,
+        text: item.snippet.topLevelComment.snippet.textDisplay,
+        likes: item.snippet.topLevelComment.snippet.likeCount,
+      }));
+      return JSON.stringify(result, null, 2);
+    },
+    {
+      name: 'youtube_comments',
+      description: `Retrieve top-level comments from a YouTube video.
+- Required: url (full YouTube URL or video ID)
+- Optional: maxResults (number of comments, 1-50, default: 10)
+- Returns: Comment text, author names, like counts
+- Use for: Sentiment analysis, audience feedback, engagement review
+Example: url="abc123" maxResults=20`,
+      schema: z.object({
+        url: z.string().describe('YouTube video URL or ID'),
+        maxResults: z
+          .number()
+          .int()
+          .min(1)
+          .max(50)
+          .optional()
+          .describe('Number of comments to retrieve'),
+      }),
+    },
+  );
 
-  const transcriptTool = tool(async ({ url }) => {
-    const videoId = extractVideoId(url);
-    if (!videoId) {
-      throw new Error('Invalid YouTube URL or video ID');
-    }
-
-    try {
-      try {
-        const transcript = await YoutubeTranscript.fetchTranscript(videoId, { lang: 'en' });
-        return parseTranscript(transcript);
-      } catch (e) {
-        logger.error(e);
+  const transcriptTool = tool(
+    async ({ url }) => {
+      const videoId = extractVideoId(url);
+      if (!videoId) {
+        throw new Error('Invalid YouTube URL or video ID');
       }
 
       try {
-        const transcript = await YoutubeTranscript.fetchTranscript(videoId, { lang: 'de' });
-        return parseTranscript(transcript);
-      } catch (e) {
-        logger.error(e);
-      }
+        try {
+          const transcript = await YoutubeTranscript.fetchTranscript(videoId, { lang: 'en' });
+          return parseTranscript(transcript);
+        } catch (e) {
+          logger.error(e);
+        }
 
-      const transcript = await YoutubeTranscript.fetchTranscript(videoId);
-      return parseTranscript(transcript);
-    } catch (error) {
-      throw new Error(`Failed to fetch transcript: ${error.message}`);
-    }
-  }, ytToolkit.youtube_transcript);
+        try {
+          const transcript = await YoutubeTranscript.fetchTranscript(videoId, { lang: 'de' });
+          return parseTranscript(transcript);
+        } catch (e) {
+          logger.error(e);
+        }
+
+        const transcript = await YoutubeTranscript.fetchTranscript(videoId);
+        return parseTranscript(transcript);
+      } catch (error) {
+        throw new Error(`Failed to fetch transcript: ${error.message}`);
+      }
+    },
+    {
+      name: 'youtube_transcript',
+      description: `Fetch and parse the transcript/captions of a YouTube video.
+- Required: url (full YouTube URL or video ID)
+- Returns: Full video transcript as plain text
+- Use for: Content analysis, summarization, translation reference
+- This is the "Go-to" tool for analyzing actual video content
+- Attempts to fetch English first, then German, then any available language
+Example: url="https://youtube.com/watch?v=abc123"`,
+      schema: z.object({
+        url: z.string().describe('YouTube video URL or ID'),
+      }),
+    },
+  );
 
   return [searchTool, infoTool, commentsTool, transcriptTool];
 }

api/app/clients/tools/structured/specs/DALLE3-proxy.spec.js

@@ -1,9 +1,43 @@
 const DALLE3 = require('../DALLE3');
 const { ProxyAgent } = require('undici');
 
-jest.mock('tiktoken');
 const processFileURL = jest.fn();
 
+jest.mock('~/server/services/Files/images', () => ({
+  getImageBasename: jest.fn().mockImplementation((url) => {
+    const parts = url.split('/');
+    const lastPart = parts.pop();
+    const imageExtensionRegex = /\.(jpg|jpeg|png|gif|bmp|tiff|svg)$/i;
+    if (imageExtensionRegex.test(lastPart)) {
+      return lastPart;
+    }
+    return '';
+  }),
+}));
+
+jest.mock('fs', () => {
+  return {
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    promises: {
+      writeFile: jest.fn(),
+      readFile: jest.fn(),
+      unlink: jest.fn(),
+    },
+  };
+});
+
+jest.mock('path', () => {
+  return {
+    resolve: jest.fn(),
+    join: jest.fn(),
+    relative: jest.fn(),
+    extname: jest.fn().mockImplementation((filename) => {
+      return filename.slice(filename.lastIndexOf('.'));
+    }),
+  };
+});
+
 describe('DALLE3 Proxy Configuration', () => {
   let originalEnv;
 

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

@@ -1,8 +1,9 @@
 const OpenAI = require('openai');
-const { logger } = require('@librechat/data-schemas');
 const DALLE3 = require('../DALLE3');
+const logger = require('~/config/winston');
 
 jest.mock('openai');
+
 jest.mock('@librechat/data-schemas', () => {
   return {
     logger: {
@@ -25,6 +26,25 @@ jest.mock('tiktoken', () => {
 
 const processFileURL = jest.fn();
 
+jest.mock('~/server/services/Files/images', () => ({
+  getImageBasename: jest.fn().mockImplementation((url) => {
+    // Split the URL by '/'
+    const parts = url.split('/');
+
+    // Get the last part of the URL
+    const lastPart = parts.pop();
+
+    // Check if the last part of the URL matches the image extension regex
+    const imageExtensionRegex = /\.(jpg|jpeg|png|gif|bmp|tiff|svg)$/i;
+    if (imageExtensionRegex.test(lastPart)) {
+      return lastPart;
+    }
+
+    // If the regex test fails, return an empty string
+    return '';
+  }),
+}));
+
 const generate = jest.fn();
 OpenAI.mockImplementation(() => ({
   images: {

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

@@ -2,9 +2,9 @@ const { z } = require('zod');
 const axios = require('axios');
 const { tool } = require('@langchain/core/tools');
 const { logger } = require('@librechat/data-schemas');
-const { generateShortLivedToken } = require('@librechat/api');
 const { Tools, EToolResources } = require('librechat-data-provider');
 const { filterFilesByAgentAccess } = require('~/server/services/Files/permissions');
+const { generateShortLivedToken } = require('~/server/services/AuthService');
 const { getFiles } = require('~/models/File');
 
 /**
@@ -68,19 +68,18 @@ 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 }) => {
   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.';
       }
@@ -143,9 +142,9 @@ const createFileSearchTool = async ({ userId, files, entity_id, fileCitations =
       const formattedString = formattedResults
         .map(
           (result, index) =>
-            `File: ${result.filename}${
-              fileCitations ? `\nAnchor: \\ue202turn0file${index} (${result.filename})` : ''
-            }\nRelevance: ${(1.0 - result.distance).toFixed(4)}\nContent: ${result.content}\n`,
+            `File: ${result.filename}\nAnchor: \\ue202turn0file${index} (${result.filename})\nRelevance: ${(1.0 - result.distance).toFixed(4)}\nContent: ${
+              result.content
+            }\n`,
         )
         .join('\n---\n');
 
@@ -159,14 +158,12 @@ const createFileSearchTool = async ({ userId, files, entity_id, fileCitations =
         pageRelevance: result.page ? { [result.page]: 1.0 - result.distance } : {},
       }));
 
-      return [formattedString, { [Tools.file_search]: { sources, fileCitations } }];
+      return [formattedString, { [Tools.file_search]: { sources } }];
     },
     {
       name: Tools.file_search,
       responseFormat: 'content_and_artifact',
-      description: `Performs semantic search across attached "${Tools.file_search}" documents using natural language queries. This tool analyzes the content of uploaded files to find relevant information, quotes, and passages that best match your query. Use this to extract specific information or find relevant sections within the available documents.${
-        fileCitations
-          ? `
+      description: `Performs semantic search across attached "${Tools.file_search}" documents using natural language queries. This tool analyzes the content of uploaded files to find relevant information, quotes, and passages that best match your query. Use this to extract specific information or find relevant sections within the available documents.
 
 **CITE FILE SEARCH RESULTS:**
 Use anchor markers immediately after statements derived from file content. Reference the filename in your text:
@@ -174,9 +171,7 @@ Use anchor markers immediately after statements derived from file content. Refer
 - Page reference: "According to report.docx... \\ue202turn0file1"
 - Multi-file: "Multiple sources confirm... \\ue200\\ue202turn0file0\\ue202turn0file1\\ue201"
 
-**ALWAYS mention the filename in your text before the citation marker. NEVER use markdown links or footnotes.**`
-          : ''
-      }`,
+**ALWAYS mention the filename in your text before the citation marker. NEVER use markdown links or footnotes.**`,
       schema: z.object({
         query: z
           .string()

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,21 +1,9 @@
 const { logger } = require('@librechat/data-schemas');
 const { SerpAPI } = require('@langchain/community/tools/serpapi');
 const { Calculator } = require('@langchain/community/tools/calculator');
+const { mcpToolPattern, loadWebSearchAuth } = require('@librechat/api');
 const { EnvVar, createCodeExecutionTool, createSearchTool } = require('@librechat/agents');
-const {
-  checkAccess,
-  createSafeUser,
-  mcpToolPattern,
-  loadWebSearchAuth,
-} = require('@librechat/api');
-const {
-  Tools,
-  Constants,
-  Permissions,
-  EToolResources,
-  PermissionTypes,
-  replaceSpecialVars,
-} = require('librechat-data-provider');
+const { Tools, Constants, EToolResources, replaceSpecialVars } = require('librechat-data-provider');
 const {
   availableTools,
   manifestToolMap,
@@ -38,8 +26,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 { getRoleByName } = require('~/models/Role');
+const { getCachedTools } = require('~/server/services/Config');
 
 /**
  * Validates the availability and authentication of tools for a user based on environment variables or user-specific plugin authentication values.
@@ -134,21 +121,18 @@ const getAuthFields = (toolKey) => {
 
 /**
  *
- * @param {object} params
- * @param {string} params.user
+ * @param {object} object
+ * @param {string} object.user
  * @param {Record<string, Record<string, string>>} [object.userMCPAuthMap]
  * @param {AbortSignal} [object.signal]
- * @param {Pick<Agent, 'id' | 'provider' | 'model'>} [params.agent]
- * @param {string} [params.model]
- * @param {EModelEndpoint} [params.endpoint]
- * @param {LoadToolOptions} [params.options]
- * @param {boolean} [params.useSpecs]
- * @param {Array<string>} params.tools
- * @param {boolean} [params.functions]
- * @param {boolean} [params.returnMap]
- * @param {AppConfig['webSearch']} [params.webSearch]
- * @param {AppConfig['fileStrategy']} [params.fileStrategy]
- * @param {AppConfig['imageOutputType']} [params.imageOutputType]
+ * @param {Pick<Agent, 'id' | 'provider' | 'model'>} [object.agent]
+ * @param {string} [object.model]
+ * @param {EModelEndpoint} [object.endpoint]
+ * @param {LoadToolOptions} [object.options]
+ * @param {boolean} [object.useSpecs]
+ * @param {Array<string>} object.tools
+ * @param {boolean} [object.functions]
+ * @param {boolean} [object.returnMap]
  * @returns {Promise<{ loadedTools: Tool[], toolContextMap: Object<string, any> } | Record<string,Tool>>}
  */
 const loadTools = async ({
@@ -162,9 +146,6 @@ const loadTools = async ({
   options = {},
   functions = true,
   returnMap = false,
-  webSearch,
-  fileStrategy,
-  imageOutputType,
 }) => {
   const toolConstructors = {
     flux: FluxAPI,
@@ -223,8 +204,6 @@ const loadTools = async ({
         ...authValues,
         isAgent: !!agent,
         req: options.req,
-        imageOutputType,
-        fileStrategy,
         imageFiles,
       });
     },
@@ -240,7 +219,7 @@ const loadTools = async ({
   const imageGenOptions = {
     isAgent: !!agent,
     req: options.req,
-    fileStrategy,
+    fileStrategy: options.fileStrategy,
     processFileURL: options.processFileURL,
     returnMetadata: options.returnMetadata,
     uploadImageBuffer: options.uploadImageBuffer,
@@ -255,6 +234,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) {
@@ -293,36 +273,15 @@ const loadTools = async ({
         if (toolContext) {
           toolContextMap[tool] = toolContext;
         }
-
-        /** @type {boolean | undefined} Check if user has FILE_CITATIONS permission */
-        let fileCitations;
-        if (fileCitations == null && options.req?.user != null) {
-          try {
-            fileCitations = await checkAccess({
-              user: options.req.user,
-              permissionType: PermissionTypes.FILE_CITATIONS,
-              permissions: [Permissions.USE],
-              getRoleByName,
-            });
-          } catch (error) {
-            logger.error('[handleTools] FILE_CITATIONS permission check failed:', error);
-            fileCitations = false;
-          }
-        }
-
-        return createFileSearchTool({
-          userId: user,
-          files,
-          entity_id: agent?.id,
-          fileCitations,
-        });
+        return createFileSearchTool({ req: options.req, files, entity_id: agent?.id });
       };
       continue;
     } else if (tool === Tools.web_search) {
+      const webSearchConfig = options?.req?.app?.locals?.webSearch;
       const result = await loadWebSearchAuth({
         userId: user,
         loadAuthValues,
-        webSearchConfig: webSearch,
+        webSearchConfig,
       });
       const { onSearchResults, onGetHighlights } = options?.[Tools.web_search] ?? {};
       requestedTools[tool] = async () => {
@@ -344,34 +303,36 @@ 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 */
-        continue;
-      }
-      if (serverName && options.req?.config?.mcpConfig?.[serverName] == null) {
-        logger.warn(
-          `MCP server "${serverName}" for "${toolName}" tool is not configured${agent?.id != null && agent.id ? ` but attached to "${agent.id}"` : ''}`,
-        );
-        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 +375,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(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

@@ -9,27 +9,7 @@ const mockPluginService = {
 
 jest.mock('~/server/services/PluginService', () => mockPluginService);
 
-jest.mock('~/server/services/Config', () => ({
-  getAppConfig: jest.fn().mockResolvedValue({
-    // Default app config for tool tests
-    paths: { uploads: '/tmp' },
-    fileStrategy: 'local',
-    filteredTools: [],
-    includedTools: [],
-  }),
-  getCachedTools: jest.fn().mockResolvedValue({
-    // Default cached tools for tests
-    dalle: {
-      type: 'function',
-      function: {
-        name: 'dalle',
-        description: 'DALL-E image generation',
-        parameters: {},
-      },
-    },
-  }),
-}));
-
+const { BaseLLM } = require('@langchain/openai');
 const { Calculator } = require('@langchain/community/tools/calculator');
 
 const { User } = require('~/db/models');
@@ -171,6 +151,7 @@ describe('Tool Handlers', () => {
     beforeAll(async () => {
       const toolMap = await loadTools({
         user: fakeUser._id,
+        model: BaseLLM,
         tools: sampleTools,
         returnMap: true,
         useSpecs: true,
@@ -264,6 +245,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 +255,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,36 +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 || '',
+  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 */
@@ -75,9 +52,6 @@ const cacheConfig = {
   REDIS_CONNECT_TIMEOUT: math(process.env.REDIS_CONNECT_TIMEOUT, 10000),
   /** Queue commands when disconnected */
   REDIS_ENABLE_OFFLINE_QUEUE: isEnabled(process.env.REDIS_ENABLE_OFFLINE_QUEUE ?? 'true'),
-  /** flag to modify redis connection by adding dnsLookup this is required when connecting to elasticache for ioredis
-   * see "Special Note: Aws Elasticache Clusters with TLS" on this webpage:  https://www.npmjs.com/package/ioredis **/
-  REDIS_USE_ALTERNATIVE_DNS_LOOKUP: isEnabled(process.env.REDIS_USE_ALTERNATIVE_DNS_LOOKUP),
   /** Enable redis cluster without the need of multiple URIs */
   USE_REDIS_CLUSTER: isEnabled(process.env.USE_REDIS_CLUSTER ?? 'false'),
   CI: isEnabled(process.env.CI),
@@ -86,4 +60,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,55 @@ 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 () => {
-      process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES = ' ROLES, MESSAGES ';
+    test('should parse comma-separated cache keys correctly', () => {
+      process.env.FORCED_IN_MEMORY_CACHE_NAMESPACES = ' ROLES, STATIC_CONFIG ,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',
+        'STATIC_CONFIG',
+        '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' }),
@@ -35,8 +31,8 @@ const namespaces = {
   [CacheKeys.SAML_SESSION]: sessionCache(CacheKeys.SAML_SESSION),
 
   [CacheKeys.ROLES]: standardCache(CacheKeys.ROLES),
-  [CacheKeys.APP_CONFIG]: standardCache(CacheKeys.APP_CONFIG),
   [CacheKeys.CONFIG_STORE]: standardCache(CacheKeys.CONFIG_STORE),
+  [CacheKeys.STATIC_CONFIG]: standardCache(CacheKeys.STATIC_CONFIG),
   [CacheKeys.PENDING_REQ]: standardCache(CacheKeys.PENDING_REQ),
   [CacheKeys.ENCODED_DOMAINS]: new Keyv({ store: keyvMongo, namespace: CacheKeys.ENCODED_DOMAINS }),
   [CacheKeys.ABORT_KEYS]: standardCache(CacheKeys.ABORT_KEYS, Time.TEN_MINUTES),

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,26 +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 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 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}${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
@@ -34,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');
@@ -49,20 +49,12 @@ 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),
-                }
-              : {}),
             redisOptions,
-            clusterRetryStrategy: (times: number) => {
+            clusterRetryStrategy: (times) => {
               if (
                 cacheConfig.REDIS_RETRY_MAX_ATTEMPTS > 0 &&
                 times > cacheConfig.REDIS_RETRY_MAX_ATTEMPTS
@@ -92,7 +84,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`);
   });
 
@@ -101,7 +93,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);
@@ -122,20 +114,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
@@ -151,9 +145,6 @@ if (cacheConfig.USE_REDIS) {
       },
     },
     disableOfflineQueue: !cacheConfig.REDIS_ENABLE_OFFLINE_QUEUE,
-    ...(cacheConfig.REDIS_PING_INTERVAL > 0
-      ? { pingInterval: cacheConfig.REDIS_PING_INTERVAL * 1000 }
-      : {}),
   };
 
   keyvRedisClient =
@@ -190,6 +181,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, GLOBAL_PREFIX_SEPARATOR };
+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,14 +49,6 @@ 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
  *
@@ -69,6 +61,8 @@ const getAgents = async (searchParameter) => await Agent.find(searchParameter).l
  */
 const loadEphemeralAgent = async ({ req, agent_id, endpoint, model_parameters: _m }) => {
   const { model, ...model_parameters } = _m;
+  /** @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);
@@ -86,18 +80,22 @@ const loadEphemeralAgent = async ({ req, agent_id, endpoint, model_parameters: _
 
   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(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}`);
     }
   }
 
@@ -683,7 +681,7 @@ const getListAgents = async (searchParameter) => {
  * This function also updates the corresponding projects to include or exclude the agent ID.
  *
  * @param {Object} params - Parameters for updating the agent's projects.
- * @param {IUser} params.user - Parameters for updating the agent's projects.
+ * @param {MongoUser} params.user - Parameters for updating the agent's projects.
  * @param {string} params.agentId - The ID of the agent to update.
  * @param {string[]} [params.projectIds] - Array of project IDs to add to the agent.
  * @param {string[]} [params.removeProjectIds] - Array of project IDs to remove from the agent.
@@ -837,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 (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 (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 (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

@@ -1,5 +1,6 @@
 const { logger } = require('@librechat/data-schemas');
 const { createTempChatExpirationDate } = require('@librechat/api');
+const { getCustomConfig } = require('~/server/services/Config/getCustomConfig');
 const { getMessages, deleteMessages } = require('./Message');
 const { Conversation } = require('~/db/models');
 
@@ -101,8 +102,8 @@ module.exports = {
 
       if (req?.body?.isTemporary) {
         try {
-          const appConfig = req.config;
-          update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+          const customConfig = await getCustomConfig();
+          update.expiredAt = createTempChatExpirationDate(customConfig);
         } catch (err) {
           logger.error('Error creating temporary chat expiration date:', err);
           logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
@@ -174,7 +175,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/Conversation.spec.js

@@ -13,8 +13,9 @@ const {
   saveConvo,
   getConvo,
 } = require('./Conversation');
-jest.mock('~/server/services/Config/app');
+jest.mock('~/server/services/Config/getCustomConfig');
 jest.mock('./Message');
+const { getCustomConfig } = require('~/server/services/Config/getCustomConfig');
 const { getMessages, deleteMessages } = require('./Message');
 
 const { Conversation } = require('~/db/models');
@@ -49,11 +50,6 @@ describe('Conversation Operations', () => {
     mockReq = {
       user: { id: 'user123' },
       body: {},
-      config: {
-        interfaceConfig: {
-          temporaryChatRetention: 24, // Default 24 hours
-        },
-      },
     };
 
     mockConversationData = {
@@ -122,8 +118,12 @@ describe('Conversation Operations', () => {
 
   describe('isTemporary conversation handling', () => {
     it('should save a conversation with expiredAt when isTemporary is true', async () => {
-      // Mock app config with 24 hour retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 24;
+      // Mock custom config with 24 hour retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 24,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -167,8 +167,12 @@ describe('Conversation Operations', () => {
     });
 
     it('should use custom retention period from config', async () => {
-      // Mock app config with 48 hour retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 48;
+      // Mock custom config with 48 hour retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 48,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -190,8 +194,12 @@ describe('Conversation Operations', () => {
     });
 
     it('should handle minimum retention period (1 hour)', async () => {
-      // Mock app config with less than minimum retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 0.5; // Half hour - should be clamped to 1 hour
+      // Mock custom config with less than minimum retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 0.5, // Half hour - should be clamped to 1 hour
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -213,8 +221,12 @@ describe('Conversation Operations', () => {
     });
 
     it('should handle maximum retention period (8760 hours)', async () => {
-      // Mock app config with more than maximum retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 10000; // Should be clamped to 8760 hours
+      // Mock custom config with more than maximum retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 10000, // Should be clamped to 8760 hours
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -235,36 +247,22 @@ describe('Conversation Operations', () => {
       );
     });
 
-    it('should handle missing config gracefully', async () => {
-      // Simulate missing config - should use default retention period
-      delete mockReq.config;
+    it('should handle getCustomConfig errors gracefully', async () => {
+      // Mock getCustomConfig to throw an error
+      getCustomConfig.mockRejectedValue(new Error('Config service unavailable'));
 
       mockReq.body = { isTemporary: true };
 
-      const beforeSave = new Date();
       const result = await saveConvo(mockReq, mockConversationData);
-      const afterSave = new Date();
 
-      // Should still save the conversation with default retention period (30 days)
+      // Should still save the conversation but with expiredAt as null
       expect(result.conversationId).toBe(mockConversationData.conversationId);
-      expect(result.expiredAt).toBeDefined();
-      expect(result.expiredAt).toBeInstanceOf(Date);
-
-      // Verify expiredAt is approximately 30 days in the future (720 hours)
-      const expectedExpirationTime = new Date(beforeSave.getTime() + 720 * 60 * 60 * 1000);
-      const actualExpirationTime = new Date(result.expiredAt);
-
-      expect(actualExpirationTime.getTime()).toBeGreaterThanOrEqual(
-        expectedExpirationTime.getTime() - 1000,
-      );
-      expect(actualExpirationTime.getTime()).toBeLessThanOrEqual(
-        new Date(afterSave.getTime() + 720 * 60 * 60 * 1000 + 1000).getTime(),
-      );
+      expect(result.expiredAt).toBeNull();
     });
 
     it('should use default retention when config is not provided', async () => {
-      // Mock getAppConfig to return empty config
-      mockReq.config = {}; // Empty config
+      // Mock getCustomConfig to return empty config
+      getCustomConfig.mockResolvedValue({});
 
       mockReq.body = { isTemporary: true };
 
@@ -287,7 +285,11 @@ describe('Conversation Operations', () => {
 
     it('should update expiredAt when saving existing temporary conversation', async () => {
       // First save a temporary conversation
-      mockReq.config.interfaceConfig.temporaryChatRetention = 24;
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 24,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
       const firstSave = await saveConvo(mockReq, mockConversationData);

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/File.spec.js

@@ -211,7 +211,7 @@ describe('File Access Control', () => {
       expect(accessMap.get(fileIds[1])).toBe(false);
     });
 
-    it('should deny access when user only has VIEW permission and needs access for deletion', async () => {
+    it('should deny access when user only has VIEW permission', async () => {
       const userId = new mongoose.Types.ObjectId();
       const authorId = new mongoose.Types.ObjectId();
       const agentId = uuidv4();
@@ -263,71 +263,12 @@ describe('File Access Control', () => {
         role: SystemRoles.USER,
         fileIds,
         agentId,
-        isDelete: true,
       });
 
       // Should have no access to any files when only VIEW permission
       expect(accessMap.get(fileIds[0])).toBe(false);
       expect(accessMap.get(fileIds[1])).toBe(false);
     });
-
-    it('should grant access when user has VIEW permission', async () => {
-      const userId = new mongoose.Types.ObjectId();
-      const authorId = new mongoose.Types.ObjectId();
-      const agentId = uuidv4();
-      const fileIds = [uuidv4(), uuidv4()];
-
-      // Create users
-      await User.create({
-        _id: userId,
-        email: 'user@example.com',
-        emailVerified: true,
-        provider: 'local',
-      });
-
-      await User.create({
-        _id: authorId,
-        email: 'author@example.com',
-        emailVerified: true,
-        provider: 'local',
-      });
-
-      // Create agent with files
-      const agent = await createAgent({
-        id: agentId,
-        name: 'View-Only Agent',
-        author: authorId,
-        model: 'gpt-4',
-        provider: 'openai',
-        tool_resources: {
-          file_search: {
-            file_ids: fileIds,
-          },
-        },
-      });
-
-      // Grant only VIEW permission to user on the agent
-      await grantPermission({
-        principalType: PrincipalType.USER,
-        principalId: userId,
-        resourceType: ResourceType.AGENT,
-        resourceId: agent._id,
-        accessRoleId: AccessRoleIds.AGENT_VIEWER,
-        grantedBy: authorId,
-      });
-
-      // Check access for files
-      const { hasAccessToFilesViaAgent } = require('~/server/services/Files/permissions');
-      const accessMap = await hasAccessToFilesViaAgent({
-        userId: userId,
-        role: SystemRoles.USER,
-        fileIds,
-        agentId,
-      });
-
-      expect(accessMap.get(fileIds[0])).toBe(true);
-      expect(accessMap.get(fileIds[1])).toBe(true);
-    });
   });
 
   describe('getFiles with agent access control', () => {

api/models/Message.js

@@ -1,6 +1,7 @@
 const { z } = require('zod');
 const { logger } = require('@librechat/data-schemas');
 const { createTempChatExpirationDate } = require('@librechat/api');
+const { getCustomConfig } = require('~/server/services/Config/getCustomConfig');
 const { Message } = require('~/db/models');
 
 const idSchema = z.string().uuid();
@@ -10,7 +11,7 @@ const idSchema = z.string().uuid();
  *
  * @async
  * @function saveMessage
- * @param {ServerRequest} req - The request object containing user information.
+ * @param {Express.Request} req - The request object containing user information.
  * @param {Object} params - The message data object.
  * @param {string} params.endpoint - The endpoint where the message originated.
  * @param {string} params.iconURL - The URL of the sender's icon.
@@ -56,8 +57,8 @@ async function saveMessage(req, params, metadata) {
 
     if (req?.body?.isTemporary) {
       try {
-        const appConfig = req.config;
-        update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+        const customConfig = await getCustomConfig();
+        update.expiredAt = createTempChatExpirationDate(customConfig);
       } catch (err) {
         logger.error('Error creating temporary chat expiration date:', err);
         logger.info(`---\`saveMessage\` context: ${metadata?.context}`);

api/models/Message.spec.js

@@ -13,7 +13,8 @@ const {
   deleteMessagesSince,
 } = require('./Message');
 
-jest.mock('~/server/services/Config/app');
+jest.mock('~/server/services/Config/getCustomConfig');
+const { getCustomConfig } = require('~/server/services/Config/getCustomConfig');
 
 /**
  * @type {import('mongoose').Model<import('@librechat/data-schemas').IMessage>}
@@ -43,11 +44,6 @@ describe('Message Operations', () => {
 
     mockReq = {
       user: { id: 'user123' },
-      config: {
-        interfaceConfig: {
-          temporaryChatRetention: 24, // Default 24 hours
-        },
-      },
     };
 
     mockMessageData = {
@@ -330,8 +326,12 @@ describe('Message Operations', () => {
     });
 
     it('should save a message with expiredAt when isTemporary is true', async () => {
-      // Mock app config with 24 hour retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 24;
+      // Mock custom config with 24 hour retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 24,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -375,8 +375,12 @@ describe('Message Operations', () => {
     });
 
     it('should use custom retention period from config', async () => {
-      // Mock app config with 48 hour retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 48;
+      // Mock custom config with 48 hour retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 48,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -398,8 +402,12 @@ describe('Message Operations', () => {
     });
 
     it('should handle minimum retention period (1 hour)', async () => {
-      // Mock app config with less than minimum retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 0.5; // Half hour - should be clamped to 1 hour
+      // Mock custom config with less than minimum retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 0.5, // Half hour - should be clamped to 1 hour
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -421,8 +429,12 @@ describe('Message Operations', () => {
     });
 
     it('should handle maximum retention period (8760 hours)', async () => {
-      // Mock app config with more than maximum retention
-      mockReq.config.interfaceConfig.temporaryChatRetention = 10000; // Should be clamped to 8760 hours
+      // Mock custom config with more than maximum retention
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 10000, // Should be clamped to 8760 hours
+        },
+      });
 
       mockReq.body = { isTemporary: true };
 
@@ -443,36 +455,22 @@ describe('Message Operations', () => {
       );
     });
 
-    it('should handle missing config gracefully', async () => {
-      // Simulate missing config - should use default retention period
-      delete mockReq.config;
+    it('should handle getCustomConfig errors gracefully', async () => {
+      // Mock getCustomConfig to throw an error
+      getCustomConfig.mockRejectedValue(new Error('Config service unavailable'));
 
       mockReq.body = { isTemporary: true };
 
-      const beforeSave = new Date();
       const result = await saveMessage(mockReq, mockMessageData);
-      const afterSave = new Date();
 
-      // Should still save the message with default retention period (30 days)
+      // Should still save the message but with expiredAt as null
       expect(result.messageId).toBe('msg123');
-      expect(result.expiredAt).toBeDefined();
-      expect(result.expiredAt).toBeInstanceOf(Date);
-
-      // Verify expiredAt is approximately 30 days in the future (720 hours)
-      const expectedExpirationTime = new Date(beforeSave.getTime() + 720 * 60 * 60 * 1000);
-      const actualExpirationTime = new Date(result.expiredAt);
-
-      expect(actualExpirationTime.getTime()).toBeGreaterThanOrEqual(
-        expectedExpirationTime.getTime() - 1000,
-      );
-      expect(actualExpirationTime.getTime()).toBeLessThanOrEqual(
-        new Date(afterSave.getTime() + 720 * 60 * 60 * 1000 + 1000).getTime(),
-      );
+      expect(result.expiredAt).toBeNull();
     });
 
     it('should use default retention when config is not provided', async () => {
-      // Mock getAppConfig to return empty config
-      mockReq.config = {}; // Empty config
+      // Mock getCustomConfig to return empty config
+      getCustomConfig.mockResolvedValue({});
 
       mockReq.body = { isTemporary: true };
 
@@ -495,7 +493,11 @@ describe('Message Operations', () => {
 
     it('should not update expiredAt on message update', async () => {
       // First save a temporary message
-      mockReq.config.interfaceConfig.temporaryChatRetention = 24;
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 24,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
       const savedMessage = await saveMessage(mockReq, mockMessageData);
@@ -518,7 +520,11 @@ describe('Message Operations', () => {
 
     it('should preserve expiredAt when saving existing temporary message', async () => {
       // First save a temporary message
-      mockReq.config.interfaceConfig.temporaryChatRetention = 24;
+      getCustomConfig.mockResolvedValue({
+        interface: {
+          temporaryChatRetention: 24,
+        },
+      });
 
       mockReq.body = { isTemporary: true };
       const firstSave = await saveMessage(mockReq, mockMessageData);

api/models/Prompt.js

@@ -269,7 +269,7 @@ async function getListPromptGroupsByAccess({
   const baseQuery = { ...otherParams, _id: { $in: accessibleIds } };
 
   // Add cursor condition
-  if (after && typeof after === 'string' && after !== 'undefined' && after !== 'null') {
+  if (after) {
     try {
       const cursor = JSON.parse(Buffer.from(after, 'base64').toString('utf8'));
       const { updatedAt, _id } = cursor;

api/models/Transaction.js

@@ -1,4 +1,5 @@
 const { logger } = require('@librechat/data-schemas');
+const { getBalanceConfig } = require('~/server/services/Config');
 const { getMultiplier, getCacheMultiplier } = require('./tx');
 const { Transaction, Balance } = require('~/db/models');
 
@@ -186,23 +187,20 @@ async function createAutoRefillTransaction(txData) {
 
 /**
  * Static method to create a transaction and update the balance
- * @param {txData} _txData - Transaction data.
+ * @param {txData} txData - Transaction data.
  */
-async function createTransaction(_txData) {
-  const { balance, transactions, ...txData } = _txData;
+async function createTransaction(txData) {
   if (txData.rawAmount != null && isNaN(txData.rawAmount)) {
     return;
   }
 
-  if (transactions?.enabled === false) {
-    return;
-  }
-
   const transaction = new Transaction(txData);
   transaction.endpointTokenConfig = txData.endpointTokenConfig;
   calculateTokenValue(transaction);
 
   await transaction.save();
+
+  const balance = await getBalanceConfig();
   if (!balance?.enabled) {
     return;
   }
@@ -223,14 +221,9 @@ async function createTransaction(_txData) {
 
 /**
  * Static method to create a structured transaction and update the balance
- * @param {txData} _txData - Transaction data.
+ * @param {txData} txData - Transaction data.
  */
-async function createStructuredTransaction(_txData) {
-  const { balance, transactions, ...txData } = _txData;
-  if (transactions?.enabled === false) {
-    return;
-  }
-
+async function createStructuredTransaction(txData) {
   const transaction = new Transaction({
     ...txData,
     endpointTokenConfig: txData.endpointTokenConfig,
@@ -240,6 +233,7 @@ async function createStructuredTransaction(_txData) {
 
   await transaction.save();
 
+  const balance = await getBalanceConfig();
   if (!balance?.enabled) {
     return;
   }

api/models/Transaction.spec.js

@@ -1,9 +1,13 @@
 const mongoose = require('mongoose');
 const { MongoMemoryServer } = require('mongodb-memory-server');
 const { spendTokens, spendStructuredTokens } = require('./spendTokens');
+const { getBalanceConfig } = require('~/server/services/Config');
 const { getMultiplier, getCacheMultiplier } = require('./tx');
-const { createTransaction, createStructuredTransaction } = require('./Transaction');
-const { Balance, Transaction } = require('~/db/models');
+const { createTransaction } = require('./Transaction');
+const { Balance } = require('~/db/models');
+
+// Mock the custom config module so we can control the balance flag.
+jest.mock('~/server/services/Config');
 
 let mongoServer;
 beforeAll(async () => {
@@ -19,6 +23,8 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await mongoose.connection.dropDatabase();
+  // Default: enable balance updates in tests.
+  getBalanceConfig.mockResolvedValue({ enabled: true });
 });
 
 describe('Regular Token Spending Tests', () => {
@@ -35,7 +41,6 @@ describe('Regular Token Spending Tests', () => {
       model,
       context: 'test',
       endpointTokenConfig: null,
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -69,7 +74,6 @@ describe('Regular Token Spending Tests', () => {
       model,
       context: 'test',
       endpointTokenConfig: null,
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -100,7 +104,6 @@ describe('Regular Token Spending Tests', () => {
       model,
       context: 'test',
       endpointTokenConfig: null,
-      balance: { enabled: true },
     };
 
     const tokenUsage = {};
@@ -125,7 +128,6 @@ describe('Regular Token Spending Tests', () => {
       model,
       context: 'test',
       endpointTokenConfig: null,
-      balance: { enabled: true },
     };
 
     const tokenUsage = { promptTokens: 100 };
@@ -141,7 +143,8 @@ describe('Regular Token Spending Tests', () => {
   });
 
   test('spendTokens should not update balance when balance feature is disabled', async () => {
-    // Arrange: Balance config is now passed directly in txData
+    // Arrange: Override the config to disable balance updates.
+    getBalanceConfig.mockResolvedValue({ balance: { enabled: false } });
     const userId = new mongoose.Types.ObjectId();
     const initialBalance = 10000000;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
@@ -153,7 +156,6 @@ describe('Regular Token Spending Tests', () => {
       model,
       context: 'test',
       endpointTokenConfig: null,
-      balance: { enabled: false },
     };
 
     const tokenUsage = {
@@ -184,7 +186,6 @@ describe('Structured Token Spending Tests', () => {
       model,
       context: 'message',
       endpointTokenConfig: null,
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -238,7 +239,6 @@ describe('Structured Token Spending Tests', () => {
       conversationId: 'test-convo',
       model,
       context: 'message',
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -271,7 +271,6 @@ describe('Structured Token Spending Tests', () => {
       conversationId: 'test-convo',
       model,
       context: 'message',
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -303,7 +302,6 @@ describe('Structured Token Spending Tests', () => {
       conversationId: 'test-convo',
       model,
       context: 'message',
-      balance: { enabled: true },
     };
 
     const tokenUsage = {};
@@ -330,7 +328,6 @@ describe('Structured Token Spending Tests', () => {
       conversationId: 'test-convo',
       model,
       context: 'incomplete',
-      balance: { enabled: true },
     };
 
     const tokenUsage = {
@@ -367,7 +364,6 @@ describe('NaN Handling Tests', () => {
       endpointTokenConfig: null,
       rawAmount: NaN,
       tokenType: 'prompt',
-      balance: { enabled: true },
     };
 
     // Act
@@ -379,188 +375,3 @@ describe('NaN Handling Tests', () => {
     expect(balance.tokenCredits).toBe(initialBalance);
   });
 });
-
-describe('Transactions Config Tests', () => {
-  test('createTransaction should not save when transactions.enabled is false', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'gpt-3.5-turbo';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'test',
-      endpointTokenConfig: null,
-      rawAmount: -100,
-      tokenType: 'prompt',
-      transactions: { enabled: false },
-    };
-
-    // Act
-    const result = await createTransaction(txData);
-
-    // Assert: No transaction should be created
-    expect(result).toBeUndefined();
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(0);
-    const balance = await Balance.findOne({ user: userId });
-    expect(balance.tokenCredits).toBe(initialBalance);
-  });
-
-  test('createTransaction should save when transactions.enabled is true', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'gpt-3.5-turbo';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'test',
-      endpointTokenConfig: null,
-      rawAmount: -100,
-      tokenType: 'prompt',
-      transactions: { enabled: true },
-      balance: { enabled: true },
-    };
-
-    // Act
-    const result = await createTransaction(txData);
-
-    // Assert: Transaction should be created
-    expect(result).toBeDefined();
-    expect(result.balance).toBeLessThan(initialBalance);
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(1);
-    expect(transactions[0].rawAmount).toBe(-100);
-  });
-
-  test('createTransaction should save when balance.enabled is true even if transactions config is missing', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'gpt-3.5-turbo';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'test',
-      endpointTokenConfig: null,
-      rawAmount: -100,
-      tokenType: 'prompt',
-      balance: { enabled: true },
-      // No transactions config provided
-    };
-
-    // Act
-    const result = await createTransaction(txData);
-
-    // Assert: Transaction should be created (backward compatibility)
-    expect(result).toBeDefined();
-    expect(result.balance).toBeLessThan(initialBalance);
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(1);
-  });
-
-  test('createTransaction should save transaction but not update balance when balance is disabled but transactions enabled', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'gpt-3.5-turbo';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'test',
-      endpointTokenConfig: null,
-      rawAmount: -100,
-      tokenType: 'prompt',
-      transactions: { enabled: true },
-      balance: { enabled: false },
-    };
-
-    // Act
-    const result = await createTransaction(txData);
-
-    // Assert: Transaction should be created but balance unchanged
-    expect(result).toBeUndefined();
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(1);
-    expect(transactions[0].rawAmount).toBe(-100);
-    const balance = await Balance.findOne({ user: userId });
-    expect(balance.tokenCredits).toBe(initialBalance);
-  });
-
-  test('createStructuredTransaction should not save when transactions.enabled is false', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'claude-3-5-sonnet';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'message',
-      tokenType: 'prompt',
-      inputTokens: -10,
-      writeTokens: -100,
-      readTokens: -5,
-      transactions: { enabled: false },
-    };
-
-    // Act
-    const result = await createStructuredTransaction(txData);
-
-    // Assert: No transaction should be created
-    expect(result).toBeUndefined();
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(0);
-    const balance = await Balance.findOne({ user: userId });
-    expect(balance.tokenCredits).toBe(initialBalance);
-  });
-
-  test('createStructuredTransaction should save transaction but not update balance when balance is disabled but transactions enabled', async () => {
-    // Arrange
-    const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000;
-    await Balance.create({ user: userId, tokenCredits: initialBalance });
-
-    const model = 'claude-3-5-sonnet';
-    const txData = {
-      user: userId,
-      conversationId: 'test-conversation-id',
-      model,
-      context: 'message',
-      tokenType: 'prompt',
-      inputTokens: -10,
-      writeTokens: -100,
-      readTokens: -5,
-      transactions: { enabled: true },
-      balance: { enabled: false },
-    };
-
-    // Act
-    const result = await createStructuredTransaction(txData);
-
-    // Assert: Transaction should be created but balance unchanged
-    expect(result).toBeUndefined();
-    const transactions = await Transaction.find({ user: userId });
-    expect(transactions).toHaveLength(1);
-    expect(transactions[0].inputTokens).toBe(-10);
-    expect(transactions[0].writeTokens).toBe(-100);
-    expect(transactions[0].readTokens).toBe(-5);
-    const balance = await Balance.findOne({ user: userId });
-    expect(balance.tokenCredits).toBe(initialBalance);
-  });
-});

api/models/balanceMethods.js

@@ -118,7 +118,7 @@ const addIntervalToDate = (date, value, unit) => {
  * @async
  * @function
  * @param {Object} params - The function parameters.
- * @param {ServerRequest} params.req - The Express request object.
+ * @param {Express.Request} params.req - The Express request object.
  * @param {Express.Response} params.res - The Express response object.
  * @param {Object} params.txData - The transaction data.
  * @param {string} params.txData.user - The user ID or identifier.

api/models/convoStructure.spec.js

@@ -1,9 +1,47 @@
 const mongoose = require('mongoose');
-const { buildTree } = require('librechat-data-provider');
 const { MongoMemoryServer } = require('mongodb-memory-server');
 const { getMessages, bulkSaveMessages } = require('./Message');
 const { Message } = require('~/db/models');
 
+// Original version of buildTree function
+function buildTree({ messages, fileMap }) {
+  if (messages === null) {
+    return null;
+  }
+
+  const messageMap = {};
+  const rootMessages = [];
+  const childrenCount = {};
+
+  messages.forEach((message) => {
+    const parentId = message.parentMessageId ?? '';
+    childrenCount[parentId] = (childrenCount[parentId] || 0) + 1;
+
+    const extendedMessage = {
+      ...message,
+      children: [],
+      depth: 0,
+      siblingIndex: childrenCount[parentId] - 1,
+    };
+
+    if (message.files && fileMap) {
+      extendedMessage.files = message.files.map((file) => fileMap[file.file_id ?? ''] ?? file);
+    }
+
+    messageMap[message.messageId] = extendedMessage;
+
+    const parentMessage = messageMap[parentId];
+    if (parentMessage) {
+      parentMessage.children.push(extendedMessage);
+      extendedMessage.depth = parentMessage.depth + 1;
+    } else {
+      rootMessages.push(extendedMessage);
+    }
+  });
+
+  return rootMessages;
+}
+
 let mongod;
 beforeAll(async () => {
   mongod = await MongoMemoryServer.create();

api/models/index.js

@@ -24,15 +24,8 @@ const { getConvoTitle, getConvo, saveConvo, deleteConvos } = require('./Conversa
 const { getPreset, getPresets, savePreset, deletePresets } = require('./Preset');
 const { File } = require('~/db/models');
 
-const seedDatabase = async () => {
-  await methods.initializeRoles();
-  await methods.seedDefaultRoles();
-  await methods.ensureDefaultCategories();
-};
-
 module.exports = {
   ...methods,
-  seedDatabase,
   comparePassword,
   findFileById,
   createFile,

api/models/interface.js

@@ -1,24 +0,0 @@
-const { logger } = require('@librechat/data-schemas');
-const { updateInterfacePermissions: updateInterfacePerms } = require('@librechat/api');
-const { getRoleByName, updateAccessPermissions } = require('./Role');
-
-/**
- * Update interface permissions based on app configuration.
- * Must be done independently from loading the app config.
- * @param {AppConfig} appConfig
- */
-async function updateInterfacePermissions(appConfig) {
-  try {
-    await updateInterfacePerms({
-      appConfig,
-      getRoleByName,
-      updateAccessPermissions,
-    });
-  } catch (error) {
-    logger.error('Error updating interface permissions:', error);
-  }
-}
-
-module.exports = {
-  updateInterfacePermissions,
-};

api/models/spendTokens.js

@@ -1,11 +1,17 @@
-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.
  *
  * @function
  * @async
- * @param {txData} txData - Transaction data.
+ * @param {Object} txData - Transaction data.
+ * @param {mongoose.Schema.Types.ObjectId} txData.user - The user ID.
+ * @param {String} txData.conversationId - The ID of the conversation.
+ * @param {String} txData.model - The model name.
+ * @param {String} txData.context - The context in which the transaction is made.
+ * @param {EndpointTokenConfig} [txData.endpointTokenConfig] - The current endpoint token config.
+ * @param {String} [txData.valueKey] - The value key (optional).
  * @param {Object} tokenUsage - The number of tokens used.
  * @param {Number} tokenUsage.promptTokens - The number of prompt tokens used.
  * @param {Number} tokenUsage.completionTokens - The number of completion tokens used.
@@ -63,7 +69,13 @@ const spendTokens = async (txData, tokenUsage) => {
  *
  * @function
  * @async
- * @param {txData} txData - Transaction data.
+ * @param {Object} txData - Transaction data.
+ * @param {mongoose.Schema.Types.ObjectId} txData.user - The user ID.
+ * @param {String} txData.conversationId - The ID of the conversation.
+ * @param {String} txData.model - The model name.
+ * @param {String} txData.context - The context in which the transaction is made.
+ * @param {EndpointTokenConfig} [txData.endpointTokenConfig] - The current endpoint token config.
+ * @param {String} [txData.valueKey] - The value key (optional).
  * @param {Object} tokenUsage - The number of tokens used.
  * @param {Object} tokenUsage.promptTokens - The number of prompt tokens used.
  * @param {Number} tokenUsage.promptTokens.input - The number of input tokens.

api/models/spendTokens.spec.js

@@ -5,6 +5,7 @@ const { createTransaction, createAutoRefillTransaction } = require('./Transactio
 
 require('~/db/models');
 
+// Mock the logger to prevent console output during tests
 jest.mock('~/config', () => ({
   logger: {
     debug: jest.fn(),
@@ -12,6 +13,10 @@ jest.mock('~/config', () => ({
   },
 }));
 
+// Mock the Config service
+const { getBalanceConfig } = require('~/server/services/Config');
+jest.mock('~/server/services/Config');
+
 describe('spendTokens', () => {
   let mongoServer;
   let userId;
@@ -39,7 +44,8 @@ describe('spendTokens', () => {
     // Create a new user ID for each test
     userId = new mongoose.Types.ObjectId();
 
-    // Balance config is now passed directly in txData
+    // Mock the balance config to be enabled by default
+    getBalanceConfig.mockResolvedValue({ enabled: true });
   });
 
   it('should create transactions for both prompt and completion tokens', async () => {
@@ -54,7 +60,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'gpt-3.5-turbo',
       context: 'test',
-      balance: { enabled: true },
     };
     const tokenUsage = {
       promptTokens: 100,
@@ -93,7 +98,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'gpt-3.5-turbo',
       context: 'test',
-      balance: { enabled: true },
     };
     const tokenUsage = {
       promptTokens: 100,
@@ -123,7 +127,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'gpt-3.5-turbo',
       context: 'test',
-      balance: { enabled: true },
     };
     const tokenUsage = {};
 
@@ -135,7 +138,8 @@ describe('spendTokens', () => {
   });
 
   it('should not update balance when the balance feature is disabled', async () => {
-    // Balance is now passed directly in txData
+    // Override configuration: disable balance updates
+    getBalanceConfig.mockResolvedValue({ enabled: false });
     // Create a balance for the user
     await Balance.create({
       user: userId,
@@ -147,7 +151,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'gpt-3.5-turbo',
       context: 'test',
-      balance: { enabled: false },
     };
     const tokenUsage = {
       promptTokens: 100,
@@ -177,7 +180,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'gpt-4', // Using a more expensive model
       context: 'test',
-      balance: { enabled: true },
     };
 
     // Spending more tokens than the user has balance for
@@ -231,7 +233,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo-1',
       model: 'gpt-4',
       context: 'test',
-      balance: { enabled: true },
     };
 
     const tokenUsage1 = {
@@ -251,7 +252,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo-2',
       model: 'gpt-4',
       context: 'test',
-      balance: { enabled: true },
     };
 
     const tokenUsage2 = {
@@ -292,7 +292,6 @@ describe('spendTokens', () => {
       tokenType: 'completion',
       rawAmount: -100,
       context: 'test',
-      balance: { enabled: true },
     });
 
     console.log('Direct Transaction.create result:', directResult);
@@ -317,7 +316,6 @@ describe('spendTokens', () => {
         conversationId: `test-convo-${model}`,
         model,
         context: 'test',
-        balance: { enabled: true },
       };
 
       const tokenUsage = {
@@ -354,7 +352,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo-1',
       model: 'claude-3-5-sonnet',
       context: 'test',
-      balance: { enabled: true },
     };
 
     const tokenUsage1 = {
@@ -378,7 +375,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo-2',
       model: 'claude-3-5-sonnet',
       context: 'test',
-      balance: { enabled: true },
     };
 
     const tokenUsage2 = {
@@ -430,7 +426,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'claude-3-5-sonnet', // Using a model that supports structured tokens
       context: 'test',
-      balance: { enabled: true },
     };
 
     // Spending more tokens than the user has balance for
@@ -510,7 +505,6 @@ describe('spendTokens', () => {
         conversationId,
         user: userId,
         model: usage.model,
-        balance: { enabled: true },
       };
 
       // Calculate expected spend for this transaction
@@ -623,7 +617,6 @@ describe('spendTokens', () => {
           tokenType: 'credits',
           context: 'concurrent-refill-test',
           rawAmount: refillAmount,
-          balance: { enabled: true },
         }),
       );
     }
@@ -690,7 +683,6 @@ describe('spendTokens', () => {
       conversationId: 'test-convo',
       model: 'claude-3-5-sonnet',
       context: 'test',
-      balance: { enabled: true },
     };
     const tokenUsage = {
       promptTokens: {

api/models/tx.js

@@ -1,4 +1,4 @@
-const { matchModelName } = require('@librechat/api');
+const { matchModelName } = require('../utils/tokens');
 const defaultRate = 6;
 
 /**
@@ -111,8 +111,8 @@ const tokenValues = Object.assign(
     'claude-': { prompt: 0.8, completion: 2.4 },
     'command-r-plus': { prompt: 3, completion: 15 },
     'command-r': { prompt: 0.5, completion: 1.5 },
-    'deepseek-reasoner': { prompt: 0.28, completion: 0.42 },
-    deepseek: { prompt: 0.28, completion: 0.42 },
+    '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 },
@@ -124,8 +124,7 @@ const tokenValues = Object.assign(
     '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.3, completion: 2.5 },
-    'gemini-2.5-flash-lite': { prompt: 0.1, completion: 0.4 },
+    '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 },
@@ -152,19 +151,8 @@ const tokenValues = Object.assign(
     'ministral-8b': { prompt: 0.1, completion: 0.1 },
     'ministral-3b': { prompt: 0.04, completion: 0.04 },
     // GPT-OSS models
-    'gpt-oss': { prompt: 0.05, completion: 0.2 },
-    'gpt-oss:20b': { prompt: 0.05, completion: 0.2 },
     '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)
-    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.5v': { prompt: 0.6, completion: 1.8 },
-    'glm-4.5-air': { prompt: 0.14, completion: 0.86 },
-    'glm-4.6': { prompt: 0.5, completion: 1.75 },
   },
   bedrockValues,
 );

api/models/tx.spec.js

@@ -184,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', () => {
@@ -404,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', () => {
@@ -593,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',
@@ -636,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',
@@ -794,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(

api/models/userMethods.js

@@ -3,7 +3,7 @@ const bcrypt = require('bcryptjs');
 /**
  * Compares the provided password with the user's password.
  *
- * @param {IUser} user - The user to compare the password for.
+ * @param {MongoUser} user - The user to compare the password for.
  * @param {string} candidatePassword - The password to test against the user's password.
  * @returns {Promise<boolean>} A promise that resolves to a boolean indicating if the password matches.
  */

api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/backend",
-  "version": "v0.8.0",
+  "version": "v0.8.0-rc2",
   "description": "",
   "scripts": {
     "start": "echo 'please run this from the root directory'",
@@ -47,15 +47,16 @@
     "@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.85",
+    "@librechat/agents": "^2.4.76",
     "@librechat/api": "*",
     "@librechat/data-schemas": "*",
     "@microsoft/microsoft-graph-client": "^3.0.7",
     "@modelcontextprotocol/sdk": "^1.17.1",
     "@node-saml/passport-saml": "^5.1.0",
     "@waylaidwanderer/fetch-event-source": "^3.0.1",
-    "axios": "^1.12.1",
+    "axios": "^1.8.2",
     "bcryptjs": "^2.4.3",
     "compression": "^1.8.1",
     "connect-redis": "^8.1.0",
@@ -93,9 +94,10 @@
     "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",
+    "openai-chat-tokens": "^0.2.8",
     "openid-client": "^6.5.0",
     "passport": "^0.6.0",
     "passport-apple": "^2.0.2",

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,17 +71,11 @@ 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());
+      const token = setOpenIDAuthTokens(tokenset, res);
       return res.status(200).send({ token, user });
     } catch (error) {
       logger.error('[refreshController] OpenID token refresh error', error);
@@ -103,25 +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)
-      void getOAuthReconnectionManager()
-        .reconnectServers(userId)
-        .catch((err) => {
-          logger.error('Error reconnecting OAuth MCP servers:', 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)
@@ -132,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/OverrideController.js

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

api/server/controllers/PluginController.js

@@ -1,9 +1,21 @@
 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,
+  getCustomConfig,
+} = require('~/server/services/Config');
+const { loadAndFormatTools } = require('~/server/services/ToolService');
 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) => {
@@ -15,9 +27,8 @@ const getAvailablePluginsController = async (req, res) => {
       return;
     }
 
-    const appConfig = await getAppConfig({ role: req.user?.role });
     /** @type {{ filteredTools: string[], includedTools: string[] }} */
-    const { filteredTools = [], includedTools = [] } = appConfig;
+    const { filteredTools = [], includedTools = [] } = req.app.locals;
     /** @type {import('@librechat/api').LCManifestTool[]} */
     const pluginManifest = availableTools;
 
@@ -63,28 +74,63 @@ const getAvailableTools = async (req, res) => {
       logger.warn('[getAvailableTools] User ID not found in request');
       return res.status(401).json({ message: 'Unauthorized' });
     }
+    const customConfig = await getCustomConfig();
     const cache = getLogStores(CacheKeys.CONFIG_STORE);
     const cachedToolsArray = await cache.get(CacheKeys.TOOLS);
+    const cachedUserTools = await getCachedTools({ userId });
+    const userPlugins =
+      cachedUserTools != null
+        ? convertMCPToolsToPlugins({ functionTools: cachedUserTools, customConfig })
+        : undefined;
 
-    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);
+    if (cachedToolsArray != null && userPlugins != null) {
+      const dedupedTools = filterUniquePlugins([...userPlugins, ...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();
+    let toolDefinitions = await getCachedTools({ includeGlobal: true });
+    let prelimCachedTools;
 
-    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;
+    // TODO: this is a temp fix until app config is refactored
+    if (!toolDefinitions) {
+      toolDefinitions = loadAndFormatTools({
+        adminFilter: req.app.locals?.filteredTools,
+        adminIncluded: req.app.locals?.includedTools,
+        directory: req.app.locals?.paths.structuredTools,
+      });
+      prelimCachedTools = toolDefinitions;
     }
 
     /** @type {import('@librechat/api').LCManifestTool[]} */
     let pluginManifest = availableTools;
+    if (customConfig?.mcpServers != 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,
+            customConfig,
+          });
+          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);
@@ -96,13 +142,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 +156,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 = customConfig?.mcpServers?.[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([...(userPlugins ?? []), ...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,25 +1,33 @@
-const { getCachedTools, getAppConfig } = require('~/server/services/Config');
+const { Constants } = require('librechat-data-provider');
+const { getCustomConfig, getCachedTools } = require('~/server/services/Config');
 const { getLogStores } = require('~/cache');
 
+// Mock the dependencies
 jest.mock('@librechat/data-schemas', () => ({
   logger: {
     debug: jest.fn(),
     error: jest.fn(),
-    warn: jest.fn(),
   },
 }));
 
 jest.mock('~/server/services/Config', () => ({
+  getCustomConfig: jest.fn(),
   getCachedTools: jest.fn(),
-  getAppConfig: jest.fn().mockResolvedValue({
-    filteredTools: [],
-    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('~/server/services/ToolService', () => ({
+  getToolkitKey: jest.fn(),
+  loadAndFormatTools: jest.fn(),
+}));
+
+jest.mock('~/config', () => ({
+  getMCPManager: jest.fn(() => ({
+    loadAllManifestTools: jest.fn().mockResolvedValue([]),
+  })),
+  getFlowStateManager: jest.fn(),
+}));
 
 jest.mock('~/app/clients/tools', () => ({
   availableTools: [],
@@ -31,6 +39,7 @@ jest.mock('~/cache', () => ({
 }));
 
 const { getAvailableTools, getAvailablePluginsController } = require('./PluginController');
+const { loadAndFormatTools } = require('~/server/services/ToolService');
 
 describe('PluginController', () => {
   let mockReq, mockRes, mockCache;
@@ -39,9 +48,12 @@ describe('PluginController', () => {
     jest.clearAllMocks();
     mockReq = {
       user: { id: 'test-user-id' },
-      config: {
-        filteredTools: [],
-        includedTools: [],
+      app: {
+        locals: {
+          paths: { structuredTools: '/mock/path' },
+          filteredTools: null,
+          includedTools: null,
+        },
       },
     };
     mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
@@ -51,19 +63,13 @@ describe('PluginController', () => {
     // Clear availableTools and toolkits arrays before each test
     require('~/app/clients/tools').availableTools.length = 0;
     require('~/app/clients/tools').toolkits.length = 0;
-
-    // Reset getCachedTools mock to ensure clean state
-    getCachedTools.mockReset();
-
-    // Reset getAppConfig mock to ensure clean state with default values
-    getAppConfig.mockReset();
-    getAppConfig.mockResolvedValue({
-      filteredTools: [],
-      includedTools: [],
-    });
   });
 
   describe('getAvailablePluginsController', () => {
+    beforeEach(() => {
+      mockReq.app = { locals: { filteredTools: [], includedTools: [] } };
+    });
+
     it('should use filterUniquePlugins to remove duplicate plugins', async () => {
       // Add plugins with duplicates to availableTools
       const mockPlugins = [
@@ -76,17 +82,10 @@ describe('PluginController', () => {
 
       mockCache.get.mockResolvedValue(null);
 
-      // Configure getAppConfig to return the expected config
-      getAppConfig.mockResolvedValueOnce({
-        filteredTools: [],
-        includedTools: [],
-      });
-
       await getAvailablePluginsController(mockReq, mockRes);
 
       expect(mockRes.status).toHaveBeenCalledWith(200);
       const responseData = mockRes.json.mock.calls[0][0];
-      // The real filterUniquePlugins should have removed the duplicate
       expect(responseData).toHaveLength(2);
       expect(responseData[0].pluginKey).toBe('key1');
       expect(responseData[1].pluginKey).toBe('key2');
@@ -100,16 +99,10 @@ describe('PluginController', () => {
       require('~/app/clients/tools').availableTools.push(mockPlugin);
       mockCache.get.mockResolvedValue(null);
 
-      // Configure getAppConfig to return the expected config
-      getAppConfig.mockResolvedValueOnce({
-        filteredTools: [],
-        includedTools: [],
-      });
-
       await getAvailablePluginsController(mockReq, mockRes);
 
       const responseData = mockRes.json.mock.calls[0][0];
-      // The real checkPluginAuth returns false for plugins without authConfig, so authenticated property is not added
+      // checkPluginAuth returns false, so authenticated property is not added
       expect(responseData[0].authenticated).toBeUndefined();
     });
 
@@ -133,14 +126,9 @@ describe('PluginController', () => {
       ];
 
       require('~/app/clients/tools').availableTools.push(...mockPlugins);
+      mockReq.app.locals.includedTools = ['key1'];
       mockCache.get.mockResolvedValue(null);
 
-      // Configure getAppConfig to return config with includedTools
-      getAppConfig.mockResolvedValueOnce({
-        filteredTools: [],
-        includedTools: ['key1'],
-      });
-
       await getAvailablePluginsController(mockReq, mockRes);
 
       const responseData = mockRes.json.mock.calls[0][0];
@@ -150,6 +138,37 @@ 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);
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock second call to return tool definitions
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+
+      await getAvailableTools(mockReq, mockRes);
+
+      const responseData = mockRes.json.mock.calls[0][0];
+      // convertMCPToolsToPlugins should have converted the tool
+      expect(responseData.length).toBeGreaterThan(0);
+      const convertedTool = responseData.find(
+        (tool) => tool.pluginKey === `tool1${Constants.mcp_delimiter}server1`,
+      );
+      expect(convertedTool).toBeDefined();
+      expect(convertedTool.name).toBe('tool1');
+    });
+
     it('should use filterUniquePlugins to deduplicate combined tools', async () => {
       const mockUserTools = {
         'user-tool': {
@@ -169,17 +188,15 @@ describe('PluginController', () => {
 
       mockCache.get.mockResolvedValue(mockCachedPlugins);
       getCachedTools.mockResolvedValueOnce(mockUserTools);
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock second call to return tool definitions
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
 
       await getAvailableTools(mockReq, mockRes);
 
-      expect(mockRes.status).toHaveBeenCalledWith(200);
       const responseData = mockRes.json.mock.calls[0][0];
-      expect(Array.isArray(responseData)).toBe(true);
-      // The real filterUniquePlugins should have deduplicated tools with same pluginKey
+      // Should have deduplicated tools with same pluginKey
       const userToolCount = responseData.filter((tool) => tool.pluginKey === 'user-tool').length;
       expect(userToolCount).toBe(1);
     });
@@ -196,8 +213,11 @@ describe('PluginController', () => {
       require('~/app/clients/tools').availableTools.push(mockPlugin);
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns the tool definitions
-      getCachedTools.mockResolvedValueOnce({
+      getCachedTools.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock loadAndFormatTools to return tool definitions including our tool
+      loadAndFormatTools.mockReturnValue({
         tool1: {
           type: 'function',
           function: {
@@ -207,10 +227,6 @@ describe('PluginController', () => {
           },
         },
       });
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -219,7 +235,7 @@ describe('PluginController', () => {
       expect(Array.isArray(responseData)).toBe(true);
       const tool = responseData.find((t) => t.pluginKey === 'tool1');
       expect(tool).toBeDefined();
-      // The real checkPluginAuth returns false for plugins without authConfig, so authenticated property is not added
+      // checkPluginAuth returns false, so authenticated property is not added
       expect(tool.authenticated).toBeUndefined();
     });
 
@@ -241,8 +257,11 @@ describe('PluginController', () => {
       });
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns the tool definitions
-      getCachedTools.mockResolvedValueOnce({
+      getCachedTools.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock loadAndFormatTools to return tool definitions
+      loadAndFormatTools.mockReturnValue({
         toolkit1_function: {
           type: 'function',
           function: {
@@ -252,10 +271,6 @@ describe('PluginController', () => {
           },
         },
       });
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -267,7 +282,120 @@ describe('PluginController', () => {
     });
   });
 
+  describe('plugin.icon behavior', () => {
+    const callGetAvailableToolsWithMCPServer = async (mcpServers) => {
+      mockCache.get.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue({ mcpServers });
+
+      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
+      const mockMCPManager = {
+        getAllToolFunctions: jest.fn().mockResolvedValue(functionTools),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      getCachedTools.mockResolvedValueOnce({});
+
+      // Mock loadAndFormatTools to return empty object since these are MCP tools
+      loadAndFormatTools.mockReturnValue({});
+
+      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 mcpServers = {
+        'test-server': {
+          iconPath: '/path/to/icon.png',
+        },
+      };
+      const testTool = await callGetAvailableToolsWithMCPServer(mcpServers);
+      expect(testTool.icon).toBe('/path/to/icon.png');
+    });
+
+    it('should set plugin.icon to undefined when iconPath is not defined', async () => {
+      const mcpServers = {
+        'test-server': {},
+      };
+      const testTool = await callGetAvailableToolsWithMCPServer(mcpServers);
+      expect(testTool.icon).toBeUndefined();
+    });
+  });
+
   describe('helper function integration', () => {
+    it('should properly handle MCP tools with custom user variables', async () => {
+      const customConfig = {
+        mcpServers: {
+          '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),
+      };
+      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
+
+      mockCache.get.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue(customConfig);
+
+      // First call returns user tools (empty in this case)
+      getCachedTools.mockResolvedValueOnce({});
+
+      // Mock loadAndFormatTools to return empty object for MCP tools
+      loadAndFormatTools.mockReturnValue({});
+
+      // Second call returns tool definitions including our MCP tool
+      getCachedTools.mockResolvedValueOnce(mcpToolFunctions);
+
+      await getAvailableTools(mockReq, mockRes);
+
+      const responseData = mockRes.json.mock.calls[0][0];
+
+      // 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,47 +417,65 @@ describe('PluginController', () => {
 
     it('should handle null cachedTools and cachedUserTools', async () => {
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns empty object instead of null
-      getCachedTools.mockResolvedValueOnce({});
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
+      getCachedTools.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock loadAndFormatTools to return empty object when getCachedTools returns null
+      loadAndFormatTools.mockReturnValue({});
 
       await getAvailableTools(mockReq, mockRes);
 
       // Should handle null values gracefully
       expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([]);
     });
 
     it('should handle when getCachedTools returns undefined', async () => {
       mockCache.get.mockResolvedValue(null);
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
+      getCustomConfig.mockResolvedValue(null);
 
-      // Mock getCachedTools to return undefined
+      // Mock loadAndFormatTools to return empty object when getCachedTools returns undefined
+      loadAndFormatTools.mockReturnValue({});
+
+      // Mock getCachedTools to return undefined for both calls
       getCachedTools.mockReset();
-      getCachedTools.mockResolvedValueOnce(undefined);
+      getCachedTools.mockResolvedValueOnce(undefined).mockResolvedValueOnce(undefined);
 
       await getAvailableTools(mockReq, mockRes);
 
       // Should handle undefined values gracefully
       expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([]);
+    });
+
+    it('should handle cachedToolsArray and userPlugins 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.mockResolvedValue(userTools);
+      getCustomConfig.mockResolvedValue(null);
+
+      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
-      getCachedTools.mockReset();
-      getCachedTools.mockResolvedValue({});
-      mockReq.config = {}; // No mcpConfig at all
-
-      // Ensure no plugins are available
-      require('~/app/clients/tools').availableTools.length = 0;
+      getCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce({});
+      getCustomConfig.mockResolvedValue(null);
 
       await getAvailableTools(mockReq, mockRes);
 
@@ -337,13 +483,40 @@ describe('PluginController', () => {
       expect(mockRes.json).toHaveBeenCalledWith([]);
     });
 
-    it('should handle undefined filteredTools and includedTools', async () => {
-      mockReq.config = {};
-      mockCache.get.mockResolvedValue(null);
+    it('should handle MCP tools without customUserVars', async () => {
+      const customConfig = {
+        mcpServers: {
+          'test-server': {
+            // No customUserVars defined
+          },
+        },
+      };
 
-      // Configure getAppConfig to return config with undefined properties
-      // The controller will use default values [] for filteredTools and includedTools
-      getAppConfig.mockResolvedValueOnce({});
+      const mockUserTools = {
+        [`tool1${Constants.mcp_delimiter}test-server`]: {
+          function: { name: 'tool1', description: 'Tool 1' },
+        },
+      };
+
+      mockCache.get.mockResolvedValue(null);
+      getCustomConfig.mockResolvedValue(customConfig);
+      getCachedTools.mockResolvedValueOnce(mockUserTools);
+
+      getCachedTools.mockResolvedValueOnce({
+        [`tool1${Constants.mcp_delimiter}test-server`]: true,
+      });
+
+      await getAvailableTools(mockReq, mockRes);
+
+      const responseData = mockRes.json.mock.calls[0][0];
+      expect(responseData[0].authenticated).toBe(true);
+      // The actual implementation doesn't set authConfig on tools without customUserVars
+      expect(responseData[0].authConfig).toEqual([]);
+    });
+
+    it('should handle req.app.locals with undefined filteredTools and includedTools', async () => {
+      mockReq.app = { locals: {} };
+      mockCache.get.mockResolvedValue(null);
 
       await getAvailablePluginsController(mockReq, mockRes);
 
@@ -359,135 +532,32 @@ describe('PluginController', () => {
         toolkit: true,
       };
 
-      // No need to mock app.locals anymore as it's not used
+      // Ensure req.app.locals is properly mocked
+      mockReq.app = {
+        locals: {
+          filteredTools: [],
+          includedTools: [],
+          paths: { structuredTools: '/mock/path' },
+        },
+      };
 
       // Add the toolkit to availableTools
       require('~/app/clients/tools').availableTools.push(mockToolkit);
 
       mockCache.get.mockResolvedValue(null);
-      // getCachedTools returns empty object to avoid null reference error
-      getCachedTools.mockResolvedValueOnce({});
-      mockReq.config = {
-        mcpConfig: null,
-        paths: { structuredTools: '/mock/path' },
-      };
+      getCachedTools.mockResolvedValue({});
+      getCustomConfig.mockResolvedValue(null);
+
+      // Mock loadAndFormatTools to return an empty object when toolDefinitions is null
+      loadAndFormatTools.mockReturnValue({});
+
+      // Mock getCachedTools second call to return null
+      getCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce(null);
 
       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,37 +1,28 @@
-const { logger, webSearchKeys } = require('@librechat/data-schemas');
-const { Tools, CacheKeys, Constants, FileSources } = require('librechat-data-provider');
-const {
-  MCPOAuthHandler,
-  MCPTokenStorage,
-  normalizeHttpError,
-  extractWebSearchEnvVars,
-} = require('@librechat/api');
+const { logger } = require('@librechat/data-schemas');
+const { webSearchKeys, extractWebSearchEnvVars, normalizeHttpError } = 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 { Transaction, Balance, User } = require('~/db/models');
 const { deleteToolCalls } = require('~/models/ToolCall');
-const { getLogStores } = require('~/cache');
+const { deleteAllSharedLinks } = require('~/models');
+const { getMCPManager } = require('~/config');
 
 const getUserController = async (req, res) => {
-  const appConfig = await getAppConfig({ role: req.user?.role });
-  /** @type {IUser} */
+  /** @type {MongoUser} */
   const userData = req.user.toObject != null ? req.user.toObject() : { ...req.user };
   /**
    * These fields should not exist due to secure field selection, but deletion
@@ -40,7 +31,7 @@ const getUserController = async (req, res) => {
   delete userData.password;
   delete userData.totpSecret;
   delete userData.backupCodes;
-  if (appConfig.fileStrategy === FileSources.s3 && userData.avatar) {
+  if (req.app.locals.fileStrategy === FileSources.s3 && userData.avatar) {
     const avatarNeedsRefresh = needsRefresh(userData.avatar, 3600);
     if (!avatarNeedsRefresh) {
       return res.status(200).send(userData);
@@ -96,7 +87,6 @@ const deleteUserFiles = async (req) => {
 };
 
 const updateUserPluginsController = async (req, res) => {
-  const appConfig = await getAppConfig({ role: req.user?.role });
   const { user } = req;
   const { pluginKey, action, auth, isEntityTool } = req.body;
   try {
@@ -141,7 +131,7 @@ const updateUserPluginsController = async (req, res) => {
 
     if (pluginKey === Tools.web_search) {
       /** @type  {TCustomConfig['webSearch']} */
-      const webSearchConfig = appConfig?.webSearch;
+      const webSearchConfig = req.app.locals?.webSearch;
       keys = extractWebSearchEnvVars({
         keys: action === 'install' ? keys : webSearchKeys,
         config: webSearchConfig,
@@ -169,15 +159,6 @@ const updateUserPluginsController = async (req, res) => {
           );
           ({ status, message } = normalizeHttpError(authService));
         }
-        try {
-          // if the MCP server uses OAuth, perform a full cleanup and token revocation
-          await maybeUninstallOAuthMCP(user.id, pluginKey, appConfig);
-        } catch (error) {
-          logger.error(
-            `[updateUserPluginsController] Error uninstalling OAuth MCP for ${pluginKey}:`,
-            error,
-          );
-        }
       } else {
         // This handles:
         // 1. Web_search uninstall (keys will be populated with all webSearchKeys if auth was {}).
@@ -203,7 +184,7 @@ const updateUserPluginsController = async (req, res) => {
             // Extract server name from pluginKey (format: "mcp_<serverName>")
             const serverName = pluginKey.replace(Constants.mcp_prefix, '');
             logger.info(
-              `[updateUserPluginsController] Attempting disconnect of MCP server "${serverName}" for user ${user.id} after plugin auth update.`,
+              `[updateUserPluginsController] Disconnecting MCP server ${serverName} for user ${user.id} after plugin auth update for ${pluginKey}.`,
             );
             await mcpManager.disconnectUserConnection(user.id, serverName);
           }
@@ -285,107 +266,6 @@ const resendVerificationController = async (req, res) => {
   }
 };
 
-/**
- * OAuth MCP specific uninstall logic
- */
-const maybeUninstallOAuthMCP = async (userId, pluginKey, appConfig) => {
-  if (!pluginKey.startsWith(Constants.mcp_prefix)) {
-    // this is not an MCP server, so nothing to do here
-    return;
-  }
-
-  const serverName = pluginKey.replace(Constants.mcp_prefix, '');
-  const mcpManager = getMCPManager(userId);
-  const serverConfig = mcpManager.getRawConfig(serverName) ?? appConfig?.mcpServers?.[serverName];
-
-  if (!mcpManager.getOAuthServers().has(serverName)) {
-    // this server does not use OAuth, so nothing to do here as well
-    return;
-  }
-
-  // 1. get client info used for revocation (client id, secret)
-  const clientTokenData = await MCPTokenStorage.getClientInfoAndMetadata({
-    userId,
-    serverName,
-    findToken,
-  });
-  if (clientTokenData == null) {
-    return;
-  }
-  const { clientInfo, clientMetadata } = clientTokenData;
-
-  // 2. get decrypted tokens before deletion
-  const tokens = await MCPTokenStorage.getTokens({
-    userId,
-    serverName,
-    findToken,
-  });
-
-  // 3. revoke OAuth tokens at the provider
-  const revocationEndpoint =
-    serverConfig.oauth?.revocation_endpoint ?? clientMetadata.revocation_endpoint;
-  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,
-      );
-    } catch (error) {
-      logger.error(`Error revoking OAuth access token for ${serverName}:`, error);
-    }
-  }
-
-  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,
-      );
-    } catch (error) {
-      logger.error(`Error revoking OAuth refresh token for ${serverName}:`, error);
-    }
-  }
-
-  // 4. delete tokens from the DB after revocation attempts
-  await MCPTokenStorage.deleteUserTokens({
-    userId,
-    serverName,
-    deleteToken: async (filter) => {
-      await Token.deleteOne(filter);
-    },
-  });
-
-  // 5. clear the flow state for the OAuth tokens
-  const flowsCache = getLogStores(CacheKeys.FLOWS);
-  const flowManager = getFlowStateManager(flowsCache);
-  const flowId = MCPOAuthHandler.generateFlowId(userId, serverName);
-  await flowManager.deleteFlow(flowId, 'mcp_get_tokens');
-  await flowManager.deleteFlow(flowId, 'mcp_oauth');
-};
-
 module.exports = {
   getUserController,
   getTermsStatusController,

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

@@ -1,342 +0,0 @@
-const { Tools } = require('librechat-data-provider');
-
-// Mock all dependencies before requiring the module
-jest.mock('nanoid', () => ({
-  nanoid: jest.fn(() => 'mock-id'),
-}));
-
-jest.mock('@librechat/api', () => ({
-  sendEvent: jest.fn(),
-}));
-
-jest.mock('@librechat/data-schemas', () => ({
-  logger: {
-    error: jest.fn(),
-  },
-}));
-
-jest.mock('@librechat/agents', () => ({
-  EnvVar: { CODE_API_KEY: 'CODE_API_KEY' },
-  Providers: { GOOGLE: 'google' },
-  GraphEvents: {},
-  getMessageId: jest.fn(),
-  ToolEndHandler: jest.fn(),
-  handleToolCalls: jest.fn(),
-  ChatModelStreamHandler: jest.fn(),
-}));
-
-jest.mock('~/server/services/Files/Citations', () => ({
-  processFileCitations: jest.fn(),
-}));
-
-jest.mock('~/server/services/Files/Code/process', () => ({
-  processCodeOutput: jest.fn(),
-}));
-
-jest.mock('~/server/services/Tools/credentials', () => ({
-  loadAuthValues: jest.fn(),
-}));
-
-jest.mock('~/server/services/Files/process', () => ({
-  saveBase64Image: jest.fn(),
-}));
-
-describe('createToolEndCallback', () => {
-  let req, res, artifactPromises, createToolEndCallback;
-  let logger;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Get the mocked logger
-    logger = require('@librechat/data-schemas').logger;
-
-    // Now require the module after all mocks are set up
-    const callbacks = require('../callbacks');
-    createToolEndCallback = callbacks.createToolEndCallback;
-
-    req = {
-      user: { id: 'user123' },
-    };
-    res = {
-      headersSent: false,
-      write: jest.fn(),
-    };
-    artifactPromises = [];
-  });
-
-  describe('ui_resources artifact handling', () => {
-    it('should process ui_resources artifact and return attachment when headers not sent', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: {
-              0: { type: 'button', label: 'Click me' },
-              1: { type: 'input', placeholder: 'Enter text' },
-            },
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-
-      // Wait for all promises to resolve
-      const results = await Promise.all(artifactPromises);
-
-      // When headers are not sent, it returns attachment without writing
-      expect(res.write).not.toHaveBeenCalled();
-
-      const attachment = results[0];
-      expect(attachment).toEqual({
-        type: Tools.ui_resources,
-        messageId: 'run456',
-        toolCallId: 'tool123',
-        conversationId: 'thread789',
-        [Tools.ui_resources]: {
-          0: { type: 'button', label: 'Click me' },
-          1: { type: 'input', placeholder: 'Enter text' },
-        },
-      });
-    });
-
-    it('should write to response when headers are already sent', async () => {
-      res.headersSent = true;
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: {
-              0: { type: 'carousel', items: [] },
-            },
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-      const results = await Promise.all(artifactPromises);
-
-      expect(res.write).toHaveBeenCalled();
-      expect(results[0]).toEqual({
-        type: Tools.ui_resources,
-        messageId: 'run456',
-        toolCallId: 'tool123',
-        conversationId: 'thread789',
-        [Tools.ui_resources]: {
-          0: { type: 'carousel', items: [] },
-        },
-      });
-    });
-
-    it('should handle errors when processing ui_resources', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      // Mock res.write to throw an error
-      res.headersSent = true;
-      res.write.mockImplementation(() => {
-        throw new Error('Write failed');
-      });
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: {
-              0: { type: 'test' },
-            },
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-      const results = await Promise.all(artifactPromises);
-
-      expect(logger.error).toHaveBeenCalledWith(
-        'Error processing artifact content:',
-        expect.any(Error),
-      );
-      expect(results[0]).toBeNull();
-    });
-
-    it('should handle multiple artifacts including ui_resources', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: {
-              0: { type: 'chart', data: [] },
-            },
-          },
-          [Tools.web_search]: {
-            results: ['result1', 'result2'],
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-      const results = await Promise.all(artifactPromises);
-
-      // Both ui_resources and web_search should be processed
-      expect(artifactPromises).toHaveLength(2);
-      expect(results).toHaveLength(2);
-
-      // Check ui_resources attachment
-      const uiResourceAttachment = results.find((r) => r?.type === Tools.ui_resources);
-      expect(uiResourceAttachment).toBeTruthy();
-      expect(uiResourceAttachment[Tools.ui_resources]).toEqual({
-        0: { type: 'chart', data: [] },
-      });
-
-      // Check web_search attachment
-      const webSearchAttachment = results.find((r) => r?.type === Tools.web_search);
-      expect(webSearchAttachment).toBeTruthy();
-      expect(webSearchAttachment[Tools.web_search]).toEqual({
-        results: ['result1', 'result2'],
-      });
-    });
-
-    it('should not process artifacts when output has no artifacts', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const output = {
-        tool_call_id: 'tool123',
-        content: 'Some regular content',
-        // No artifact property
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-
-      expect(artifactPromises).toHaveLength(0);
-      expect(res.write).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle empty ui_resources data object', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: {},
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-      const results = await Promise.all(artifactPromises);
-
-      expect(results[0]).toEqual({
-        type: Tools.ui_resources,
-        messageId: 'run456',
-        toolCallId: 'tool123',
-        conversationId: 'thread789',
-        [Tools.ui_resources]: {},
-      });
-    });
-
-    it('should handle ui_resources with complex nested data', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const complexData = {
-        0: {
-          type: 'form',
-          fields: [
-            { name: 'field1', type: 'text', required: true },
-            { name: 'field2', type: 'select', options: ['a', 'b', 'c'] },
-          ],
-          nested: {
-            deep: {
-              value: 123,
-              array: [1, 2, 3],
-            },
-          },
-        },
-      };
-
-      const output = {
-        tool_call_id: 'tool123',
-        artifact: {
-          [Tools.ui_resources]: {
-            data: complexData,
-          },
-        },
-      };
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output }, metadata);
-      const results = await Promise.all(artifactPromises);
-
-      expect(results[0][Tools.ui_resources]).toEqual(complexData);
-    });
-
-    it('should handle when output is undefined', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback({ output: undefined }, metadata);
-
-      expect(artifactPromises).toHaveLength(0);
-      expect(res.write).not.toHaveBeenCalled();
-    });
-
-    it('should handle when data parameter is undefined', async () => {
-      const toolEndCallback = createToolEndCallback({ req, res, artifactPromises });
-
-      const metadata = {
-        run_id: 'run456',
-        thread_id: 'thread789',
-      };
-
-      await toolEndCallback(undefined, metadata);
-
-      expect(artifactPromises).toHaveLength(0);
-      expect(res.write).not.toHaveBeenCalled();
-    });
-  });
-});

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/callbacks.js

@@ -246,7 +246,6 @@ function createToolEndCallback({ req, res, artifactPromises }) {
           const attachment = await processFileCitations({
             user,
             metadata,
-            appConfig: req.config,
             toolArtifact: output.artifact,
             toolCallId: output.tool_call_id,
           });
@@ -265,30 +264,6 @@ function createToolEndCallback({ req, res, artifactPromises }) {
       );
     }
 
-    // TODO: a lot of duplicated code in createToolEndCallback
-    // we should refactor this to use a helper function in a follow-up PR
-    if (output.artifact[Tools.ui_resources]) {
-      artifactPromises.push(
-        (async () => {
-          const attachment = {
-            type: Tools.ui_resources,
-            messageId: metadata.run_id,
-            toolCallId: output.tool_call_id,
-            conversationId: metadata.thread_id,
-            [Tools.ui_resources]: output.artifact[Tools.ui_resources].data,
-          };
-          if (!res.headersSent) {
-            return attachment;
-          }
-          res.write(`event: attachment\ndata: ${JSON.stringify(attachment)}\n\n`);
-          return attachment;
-        })().catch((error) => {
-          logger.error('Error processing artifact content:', error);
-          return null;
-        }),
-      );
-    }
-
     if (output.artifact[Tools.web_search]) {
       artifactPromises.push(
         (async () => {

api/server/controllers/agents/client.js

@@ -7,12 +7,8 @@ const {
   createRun,
   Tokenizer,
   checkAccess,
-  logAxiosError,
-  resolveHeaders,
-  getBalanceConfig,
   memoryInstructions,
   formatContentStrings,
-  getTransactionsConfig,
   createMemoryProcessor,
 } = require('@librechat/api');
 const {
@@ -89,10 +85,11 @@ function createTokenCounter(encoding) {
 }
 
 function logToolError(graph, error, toolId) {
-  logAxiosError({
+  logger.error(
+    '[api/server/controllers/agents/client.js #chatCompletion] Tool Error',
     error,
-    message: `[api/server/controllers/agents/client.js #chatCompletion] Tool Error "${toolId}"`,
-  });
+    toolId,
+  );
 }
 
 class AgentClient extends BaseClient {
@@ -211,13 +208,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;
   }
 
@@ -245,18 +245,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;
     }
@@ -276,21 +277,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))) {
@@ -445,8 +446,8 @@ class AgentClient extends BaseClient {
       );
       return;
     }
-    const appConfig = this.options.req.config;
-    const memoryConfig = appConfig.memory;
+    /** @type {TCustomConfig['memory']} */
+    const memoryConfig = this.options.req?.app?.locals?.memory;
     if (!memoryConfig || memoryConfig.disabled === true) {
       return;
     }
@@ -454,7 +455,7 @@ class AgentClient extends BaseClient {
     /** @type {Agent} */
     let prelimAgent;
     const allowedProviders = new Set(
-      appConfig?.endpoints?.[EModelEndpoint.agents]?.allowedProviders,
+      this.options.req?.app?.locals?.[EModelEndpoint.agents]?.allowedProviders,
     );
     try {
       if (memoryConfig.agent?.id != null && memoryConfig.agent.id !== this.options.agent.id) {
@@ -576,8 +577,8 @@ class AgentClient extends BaseClient {
       if (this.processMemory == null) {
         return;
       }
-      const appConfig = this.options.req.config;
-      const memoryConfig = appConfig.memory;
+      /** @type {TCustomConfig['memory']} */
+      const memoryConfig = this.options.req?.app?.locals?.memory;
       const messageWindowSize = memoryConfig?.messageWindowSize ?? 5;
 
       let messagesToProcess = [...messages];
@@ -619,17 +620,9 @@ class AgentClient extends BaseClient {
    * @param {Object} params
    * @param {string} [params.model]
    * @param {string} [params.context='message']
-   * @param {AppConfig['balance']} [params.balance]
-   * @param {AppConfig['transactions']} [params.transactions]
    * @param {UsageMetadata[]} [params.collectedUsage=this.collectedUsage]
    */
-  async recordCollectedUsage({
-    model,
-    balance,
-    transactions,
-    context = 'message',
-    collectedUsage = this.collectedUsage,
-  }) {
+  async recordCollectedUsage({ model, context = 'message', collectedUsage = this.collectedUsage }) {
     if (!collectedUsage || !collectedUsage.length) {
       return;
     }
@@ -651,8 +644,6 @@ class AgentClient extends BaseClient {
 
       const txMetadata = {
         context,
-        balance,
-        transactions,
         conversationId: this.conversationId,
         user: this.user ?? this.options.req.user?.id,
         endpointTokenConfig: this.options.endpointTokenConfig,
@@ -770,9 +761,8 @@ class AgentClient extends BaseClient {
         abortController = new AbortController();
       }
 
-      const appConfig = this.options.req.config;
-      /** @type {AppConfig['endpoints']['agents']} */
-      const agentsEConfig = appConfig.endpoints?.[EModelEndpoint.agents];
+      /** @type {TCustomConfig['endpoints']['agents']} */
+      const agentsEConfig = this.options.req.app.locals[EModelEndpoint.agents];
 
       config = {
         configurable: {
@@ -868,10 +858,11 @@ class AgentClient extends BaseClient {
         if (agent.useLegacyContent === true) {
           messages = formatContentStrings(messages);
         }
-        const defaultHeaders =
-          agent.model_parameters?.clientOptions?.defaultHeaders ??
-          agent.model_parameters?.configuration?.defaultHeaders;
-        if (defaultHeaders?.['anthropic-beta']?.includes('prompt-caching')) {
+        if (
+          agent.model_parameters?.clientOptions?.defaultHeaders?.['anthropic-beta']?.includes(
+            'prompt-caching',
+          )
+        ) {
           messages = addCacheControl(messages);
         }
 
@@ -879,16 +870,6 @@ class AgentClient extends BaseClient {
           memoryPromise = this.runMemory(messages);
         }
 
-        /** Resolve request-based headers for Custom Endpoints. Note: if this is added to
-         *  non-custom endpoints, needs consideration of varying provider header configs.
-         */
-        if (agent.model_parameters?.configuration?.defaultHeaders != null) {
-          agent.model_parameters.configuration.defaultHeaders = resolveHeaders({
-            headers: agent.model_parameters.configuration.defaultHeaders,
-            body: config.configurable.requestBody,
-          });
-        }
-
         run = await createRun({
           agent,
           req: this.options.req,
@@ -1049,13 +1030,7 @@ class AgentClient extends BaseClient {
           this.artifactPromises.push(...attachments);
         }
 
-        const balanceConfig = getBalanceConfig(appConfig);
-        const transactionsConfig = getTransactionsConfig(appConfig);
-        await this.recordCollectedUsage({
-          context: 'message',
-          balance: balanceConfig,
-          transactions: transactionsConfig,
-        });
+        await this.recordCollectedUsage({ context: 'message' });
       } catch (err) {
         logger.error(
           '[api/server/controllers/agents/client.js #chatCompletion] Error recording collected usage',
@@ -1096,7 +1071,6 @@ class AgentClient extends BaseClient {
     }
     const { handleLLMEnd, collected: collectedMetadata } = createMetadataAggregator();
     const { req, res, agent } = this.options;
-    const appConfig = req.config;
     let endpoint = agent.endpoint;
 
     /** @type {import('@librechat/agents').ClientOptions} */
@@ -1104,41 +1078,29 @@ class AgentClient extends BaseClient {
       model: agent.model || agent.model_parameters.model,
     };
 
-    let titleProviderConfig = getProviderConfig({ provider: endpoint, appConfig });
+    let titleProviderConfig = await getProviderConfig(endpoint);
 
     /** @type {TEndpoint | undefined} */
     const endpointConfig =
-      appConfig.endpoints?.all ??
-      appConfig.endpoints?.[endpoint] ??
-      titleProviderConfig.customEndpointConfig;
+      req.app.locals.all ?? req.app.locals[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({
-          provider: endpointConfig.titleEndpoint,
-          appConfig,
-        });
+        titleProviderConfig = await getProviderConfig(endpointConfig.titleEndpoint);
         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
         endpoint = agent.endpoint;
-        titleProviderConfig = getProviderConfig({ provider: endpoint, appConfig });
+        titleProviderConfig = await getProviderConfig(endpoint);
       }
     }
 
@@ -1203,20 +1165,6 @@ class AgentClient extends BaseClient {
       clientOptions.json = true;
     }
 
-    /** Resolve request-based headers for Custom Endpoints. Note: if this is added to
-     *  non-custom endpoints, needs consideration of varying provider header configs.
-     */
-    if (clientOptions?.configuration?.defaultHeaders != null) {
-      clientOptions.configuration.defaultHeaders = resolveHeaders({
-        headers: clientOptions.configuration.defaultHeaders,
-        body: {
-          messageId: this.responseMessageId,
-          conversationId: this.conversationId,
-          parentMessageId: this.parentMessageId,
-        },
-      });
-    }
-
     try {
       const titleResult = await this.run.generateTitle({
         provider,
@@ -1255,14 +1203,10 @@ class AgentClient extends BaseClient {
         };
       });
 
-      const balanceConfig = getBalanceConfig(appConfig);
-      const transactionsConfig = getTransactionsConfig(appConfig);
       await this.recordCollectedUsage({
-        collectedUsage,
-        context: 'title',
         model: clientOptions.model,
-        balance: balanceConfig,
-        transactions: transactionsConfig,
+        context: 'title',
+        collectedUsage,
       }).catch((err) => {
         logger.error(
           '[api/server/controllers/agents/client.js #titleConvo] Error recording collected usage',
@@ -1281,26 +1225,17 @@ class AgentClient extends BaseClient {
    * @param {object} params
    * @param {number} params.promptTokens
    * @param {number} params.completionTokens
-   * @param {string} [params.model]
    * @param {OpenAIUsageMetadata} [params.usage]
-   * @param {AppConfig['balance']} [params.balance]
+   * @param {string} [params.model]
    * @param {string} [params.context='message']
    * @returns {Promise<void>}
    */
-  async recordTokenUsage({
-    model,
-    usage,
-    balance,
-    promptTokens,
-    completionTokens,
-    context = 'message',
-  }) {
+  async recordTokenUsage({ model, promptTokens, completionTokens, usage, context = 'message' }) {
     try {
       await spendTokens(
         {
           model,
           context,
-          balance,
           conversationId: this.conversationId,
           user: this.user ?? this.options.req.user?.id,
           endpointTokenConfig: this.options.endpointTokenConfig,
@@ -1317,7 +1252,6 @@ class AgentClient extends BaseClient {
         await spendTokens(
           {
             model,
-            balance,
             context: 'reasoning',
             conversationId: this.conversationId,
             user: this.user ?? this.options.req.user?.id,

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

@@ -41,16 +41,8 @@ describe('AgentClient - titleConvo', () => {
 
     // Mock request and response
     mockReq = {
-      user: {
-        id: 'user-123',
-      },
-      body: {
-        model: 'gpt-4',
-        endpoint: EModelEndpoint.openAI,
-        key: null,
-      },
-      config: {
-        endpoints: {
+      app: {
+        locals: {
           [EModelEndpoint.openAI]: {
             // Match the agent endpoint
             titleModel: 'gpt-3.5-turbo',
@@ -60,6 +52,14 @@ describe('AgentClient - titleConvo', () => {
           },
         },
       },
+      user: {
+        id: 'user-123',
+      },
+      body: {
+        model: 'gpt-4',
+        endpoint: EModelEndpoint.openAI,
+        key: null,
+      },
     };
 
     mockRes = {};
@@ -143,7 +143,7 @@ describe('AgentClient - titleConvo', () => {
 
     it('should handle missing endpoint config gracefully', async () => {
       // Remove endpoint config
-      mockReq.config = { endpoints: {} };
+      mockReq.app.locals[EModelEndpoint.openAI] = undefined;
 
       const text = 'Test conversation text';
       const abortController = new AbortController();
@@ -161,16 +161,7 @@ describe('AgentClient - titleConvo', () => {
 
     it('should use agent model when titleModel is not provided', async () => {
       // Remove titleModel from config
-      mockReq.config = {
-        endpoints: {
-          [EModelEndpoint.openAI]: {
-            titlePrompt: 'Custom title prompt',
-            titleMethod: 'structured',
-            titlePromptTemplate: 'Template: {{content}}',
-            // titleModel is omitted
-          },
-        },
-      };
+      delete mockReq.app.locals[EModelEndpoint.openAI].titleModel;
 
       const text = 'Test conversation text';
       const abortController = new AbortController();
@@ -182,16 +173,7 @@ describe('AgentClient - titleConvo', () => {
     });
 
     it('should not use titleModel when it equals CURRENT_MODEL constant', async () => {
-      mockReq.config = {
-        endpoints: {
-          [EModelEndpoint.openAI]: {
-            titleModel: Constants.CURRENT_MODEL,
-            titlePrompt: 'Custom title prompt',
-            titleMethod: 'structured',
-            titlePromptTemplate: 'Template: {{content}}',
-          },
-        },
-      };
+      mockReq.app.locals[EModelEndpoint.openAI].titleModel = Constants.CURRENT_MODEL;
 
       const text = 'Test conversation text';
       const abortController = new AbortController();
@@ -234,12 +216,6 @@ describe('AgentClient - titleConvo', () => {
         model: 'gpt-3.5-turbo',
         context: 'title',
         collectedUsage: expect.any(Array),
-        balance: {
-          enabled: false,
-        },
-        transactions: {
-          enabled: true,
-        },
       });
     });
 
@@ -263,142 +239,16 @@ 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;
       process.env.ANTHROPIC_API_KEY = 'test-api-key';
 
       // Add titleEndpoint to the config
-      mockReq.config = {
-        endpoints: {
-          [EModelEndpoint.openAI]: {
-            titleModel: 'gpt-3.5-turbo',
-            titleEndpoint: EModelEndpoint.anthropic,
-            titleMethod: 'structured',
-            titlePrompt: 'Custom title prompt',
-            titlePromptTemplate: 'Custom template',
-          },
-        },
-      };
+      mockReq.app.locals[EModelEndpoint.openAI].titleEndpoint = EModelEndpoint.anthropic;
+      mockReq.app.locals[EModelEndpoint.openAI].titleMethod = 'structured';
+      mockReq.app.locals[EModelEndpoint.openAI].titlePrompt = 'Custom title prompt';
+      mockReq.app.locals[EModelEndpoint.openAI].titlePromptTemplate = 'Custom template';
 
       const text = 'Test conversation text';
       const abortController = new AbortController();
@@ -424,16 +274,18 @@ describe('AgentClient - titleConvo', () => {
     });
 
     it('should use all config when endpoint config is missing', async () => {
-      // Set 'all' config without endpoint-specific config
-      mockReq.config = {
-        endpoints: {
-          all: {
-            titleModel: 'gpt-4o-mini',
-            titlePrompt: 'All config title prompt',
-            titleMethod: 'completion',
-            titlePromptTemplate: 'All config template: {{content}}',
-          },
-        },
+      // Remove endpoint-specific config
+      delete mockReq.app.locals[EModelEndpoint.openAI].titleModel;
+      delete mockReq.app.locals[EModelEndpoint.openAI].titlePrompt;
+      delete mockReq.app.locals[EModelEndpoint.openAI].titleMethod;
+      delete mockReq.app.locals[EModelEndpoint.openAI].titlePromptTemplate;
+
+      // Set 'all' config
+      mockReq.app.locals.all = {
+        titleModel: 'gpt-4o-mini',
+        titlePrompt: 'All config title prompt',
+        titleMethod: 'completion',
+        titlePromptTemplate: 'All config template: {{content}}',
       };
 
       const text = 'Test conversation text';
@@ -457,21 +309,17 @@ describe('AgentClient - titleConvo', () => {
 
     it('should prioritize all config over endpoint config for title settings', async () => {
       // Set both endpoint and 'all' config
-      mockReq.config = {
-        endpoints: {
-          [EModelEndpoint.openAI]: {
-            titleModel: 'gpt-3.5-turbo',
-            titlePrompt: 'Endpoint title prompt',
-            titleMethod: 'structured',
-            // titlePromptTemplate is omitted to test fallback
-          },
-          all: {
-            titleModel: 'gpt-4o-mini',
-            titlePrompt: 'All config title prompt',
-            titleMethod: 'completion',
-            titlePromptTemplate: 'All config template',
-          },
-        },
+      mockReq.app.locals[EModelEndpoint.openAI].titleModel = 'gpt-3.5-turbo';
+      mockReq.app.locals[EModelEndpoint.openAI].titlePrompt = 'Endpoint title prompt';
+      mockReq.app.locals[EModelEndpoint.openAI].titleMethod = 'structured';
+      // Remove titlePromptTemplate from endpoint config to test fallback
+      delete mockReq.app.locals[EModelEndpoint.openAI].titlePromptTemplate;
+
+      mockReq.app.locals.all = {
+        titleModel: 'gpt-4o-mini',
+        titlePrompt: 'All config title prompt',
+        titleMethod: 'completion',
+        titlePromptTemplate: 'All config template',
       };
 
       const text = 'Test conversation text';
@@ -498,18 +346,17 @@ describe('AgentClient - titleConvo', () => {
       const originalApiKey = process.env.ANTHROPIC_API_KEY;
       process.env.ANTHROPIC_API_KEY = 'test-anthropic-key';
 
+      // Remove endpoint-specific config to test 'all' config
+      delete mockReq.app.locals[EModelEndpoint.openAI];
+
       // Set comprehensive 'all' config with all new title options
-      mockReq.config = {
-        endpoints: {
-          all: {
-            titleConvo: true,
-            titleModel: 'claude-3-haiku-20240307',
-            titleMethod: 'completion', // Testing the new default method
-            titlePrompt: 'Generate a concise, descriptive title for this conversation',
-            titlePromptTemplate: 'Conversation summary: {{content}}',
-            titleEndpoint: EModelEndpoint.anthropic, // Should switch provider to Anthropic
-          },
-        },
+      mockReq.app.locals.all = {
+        titleConvo: true,
+        titleModel: 'claude-3-haiku-20240307',
+        titleMethod: 'completion', // Testing the new default method
+        titlePrompt: 'Generate a concise, descriptive title for this conversation',
+        titlePromptTemplate: 'Conversation summary: {{content}}',
+        titleEndpoint: EModelEndpoint.anthropic, // Should switch provider to Anthropic
       };
 
       const text = 'Test conversation about AI and machine learning';
@@ -555,16 +402,15 @@ describe('AgentClient - titleConvo', () => {
         // Clear previous calls
         mockRun.generateTitle.mockClear();
 
+        // Remove endpoint config
+        delete mockReq.app.locals[EModelEndpoint.openAI];
+
         // Set 'all' config with specific titleMethod
-        mockReq.config = {
-          endpoints: {
-            all: {
-              titleModel: 'gpt-4o-mini',
-              titleMethod: method,
-              titlePrompt: `Testing ${method} method`,
-              titlePromptTemplate: `Template for ${method}: {{content}}`,
-            },
-          },
+        mockReq.app.locals.all = {
+          titleModel: 'gpt-4o-mini',
+          titleMethod: method,
+          titlePrompt: `Testing ${method} method`,
+          titlePromptTemplate: `Template for ${method}: {{content}}`,
         };
 
         const text = `Test conversation for ${method} method`;
@@ -609,33 +455,29 @@ describe('AgentClient - titleConvo', () => {
         // Set up Azure endpoint with serverless config
         mockAgent.endpoint = EModelEndpoint.azureOpenAI;
         mockAgent.provider = EModelEndpoint.azureOpenAI;
-        mockReq.config = {
-          endpoints: {
-            [EModelEndpoint.azureOpenAI]: {
-              titleConvo: true,
-              titleModel: 'grok-3',
-              titleMethod: 'completion',
-              titlePrompt: 'Azure serverless title prompt',
-              streamRate: 35,
-              modelGroupMap: {
+        mockReq.app.locals[EModelEndpoint.azureOpenAI] = {
+          titleConvo: true,
+          titleModel: 'grok-3',
+          titleMethod: 'completion',
+          titlePrompt: 'Azure serverless title prompt',
+          streamRate: 35,
+          modelGroupMap: {
+            'grok-3': {
+              group: 'Azure AI Foundry',
+              deploymentName: 'grok-3',
+            },
+          },
+          groupMap: {
+            'Azure AI Foundry': {
+              apiKey: '${AZURE_API_KEY}',
+              baseURL: 'https://test.services.ai.azure.com/models',
+              version: '2024-05-01-preview',
+              serverless: true,
+              models: {
                 'grok-3': {
-                  group: 'Azure AI Foundry',
                   deploymentName: 'grok-3',
                 },
               },
-              groupMap: {
-                'Azure AI Foundry': {
-                  apiKey: '${AZURE_API_KEY}',
-                  baseURL: 'https://test.services.ai.azure.com/models',
-                  version: '2024-05-01-preview',
-                  serverless: true,
-                  models: {
-                    'grok-3': {
-                      deploymentName: 'grok-3',
-                    },
-                  },
-                },
-              },
             },
           },
         };
@@ -661,32 +503,28 @@ describe('AgentClient - titleConvo', () => {
         // Set up Azure endpoint
         mockAgent.endpoint = EModelEndpoint.azureOpenAI;
         mockAgent.provider = EModelEndpoint.azureOpenAI;
-        mockReq.config = {
-          endpoints: {
-            [EModelEndpoint.azureOpenAI]: {
-              titleConvo: true,
-              titleModel: 'gpt-4o',
-              titleMethod: 'structured',
-              titlePrompt: 'Azure instance title prompt',
-              streamRate: 35,
-              modelGroupMap: {
+        mockReq.app.locals[EModelEndpoint.azureOpenAI] = {
+          titleConvo: true,
+          titleModel: 'gpt-4o',
+          titleMethod: 'structured',
+          titlePrompt: 'Azure instance title prompt',
+          streamRate: 35,
+          modelGroupMap: {
+            'gpt-4o': {
+              group: 'eastus',
+              deploymentName: 'gpt-4o',
+            },
+          },
+          groupMap: {
+            eastus: {
+              apiKey: '${EASTUS_API_KEY}',
+              instanceName: 'region-instance',
+              version: '2024-02-15-preview',
+              models: {
                 'gpt-4o': {
-                  group: 'eastus',
                   deploymentName: 'gpt-4o',
                 },
               },
-              groupMap: {
-                eastus: {
-                  apiKey: '${EASTUS_API_KEY}',
-                  instanceName: 'region-instance',
-                  version: '2024-02-15-preview',
-                  models: {
-                    'gpt-4o': {
-                      deploymentName: 'gpt-4o',
-                    },
-                  },
-                },
-              },
             },
           },
         };
@@ -713,33 +551,29 @@ describe('AgentClient - titleConvo', () => {
         mockAgent.endpoint = EModelEndpoint.azureOpenAI;
         mockAgent.provider = EModelEndpoint.azureOpenAI;
         mockAgent.model_parameters.model = 'gpt-4o-latest';
-        mockReq.config = {
-          endpoints: {
-            [EModelEndpoint.azureOpenAI]: {
-              titleConvo: true,
-              titleModel: Constants.CURRENT_MODEL,
-              titleMethod: 'functions',
-              streamRate: 35,
-              modelGroupMap: {
+        mockReq.app.locals[EModelEndpoint.azureOpenAI] = {
+          titleConvo: true,
+          titleModel: Constants.CURRENT_MODEL,
+          titleMethod: 'functions',
+          streamRate: 35,
+          modelGroupMap: {
+            'gpt-4o-latest': {
+              group: 'region-eastus',
+              deploymentName: 'gpt-4o-mini',
+              version: '2024-02-15-preview',
+            },
+          },
+          groupMap: {
+            'region-eastus': {
+              apiKey: '${EASTUS2_API_KEY}',
+              instanceName: 'test-instance',
+              version: '2024-12-01-preview',
+              models: {
                 'gpt-4o-latest': {
-                  group: 'region-eastus',
                   deploymentName: 'gpt-4o-mini',
                   version: '2024-02-15-preview',
                 },
               },
-              groupMap: {
-                'region-eastus': {
-                  apiKey: '${EASTUS2_API_KEY}',
-                  instanceName: 'test-instance',
-                  version: '2024-12-01-preview',
-                  models: {
-                    'gpt-4o-latest': {
-                      deploymentName: 'gpt-4o-mini',
-                      version: '2024-02-15-preview',
-                    },
-                  },
-                },
-              },
             },
           },
         };
@@ -764,58 +598,54 @@ describe('AgentClient - titleConvo', () => {
         // Set up Azure endpoint
         mockAgent.endpoint = EModelEndpoint.azureOpenAI;
         mockAgent.provider = EModelEndpoint.azureOpenAI;
-        mockReq.config = {
-          endpoints: {
-            [EModelEndpoint.azureOpenAI]: {
-              titleConvo: true,
-              titleModel: 'o1-mini',
-              titleMethod: 'completion',
-              streamRate: 35,
-              modelGroupMap: {
+        mockReq.app.locals[EModelEndpoint.azureOpenAI] = {
+          titleConvo: true,
+          titleModel: 'o1-mini',
+          titleMethod: 'completion',
+          streamRate: 35,
+          modelGroupMap: {
+            'gpt-4o': {
+              group: 'eastus',
+              deploymentName: 'gpt-4o',
+            },
+            'o1-mini': {
+              group: 'region-eastus',
+              deploymentName: 'o1-mini',
+            },
+            'codex-mini': {
+              group: 'codex-mini',
+              deploymentName: 'codex-mini',
+            },
+          },
+          groupMap: {
+            eastus: {
+              apiKey: '${EASTUS_API_KEY}',
+              instanceName: 'region-eastus',
+              version: '2024-02-15-preview',
+              models: {
                 'gpt-4o': {
-                  group: 'eastus',
                   deploymentName: 'gpt-4o',
                 },
+              },
+            },
+            'region-eastus': {
+              apiKey: '${EASTUS2_API_KEY}',
+              instanceName: 'region-eastus2',
+              version: '2024-12-01-preview',
+              models: {
                 'o1-mini': {
-                  group: 'region-eastus',
                   deploymentName: 'o1-mini',
                 },
-                'codex-mini': {
-                  group: 'codex-mini',
-                  deploymentName: 'codex-mini',
-                },
               },
-              groupMap: {
-                eastus: {
-                  apiKey: '${EASTUS_API_KEY}',
-                  instanceName: 'region-eastus',
-                  version: '2024-02-15-preview',
-                  models: {
-                    'gpt-4o': {
-                      deploymentName: 'gpt-4o',
-                    },
-                  },
-                },
-                'region-eastus': {
-                  apiKey: '${EASTUS2_API_KEY}',
-                  instanceName: 'region-eastus2',
-                  version: '2024-12-01-preview',
-                  models: {
-                    'o1-mini': {
-                      deploymentName: 'o1-mini',
-                    },
-                  },
-                },
+            },
+            'codex-mini': {
+              apiKey: '${AZURE_API_KEY}',
+              baseURL: 'https://example.cognitiveservices.azure.com/openai/',
+              version: '2025-04-01-preview',
+              serverless: true,
+              models: {
                 'codex-mini': {
-                  apiKey: '${AZURE_API_KEY}',
-                  baseURL: 'https://example.cognitiveservices.azure.com/openai/',
-                  version: '2025-04-01-preview',
-                  serverless: true,
-                  models: {
-                    'codex-mini': {
-                      deploymentName: 'codex-mini',
-                    },
-                  },
+                  deploymentName: 'codex-mini',
                 },
               },
             },
@@ -849,34 +679,33 @@ describe('AgentClient - titleConvo', () => {
         mockReq.body.endpoint = EModelEndpoint.azureOpenAI;
         mockReq.body.model = 'gpt-4';
 
+        // Remove Azure-specific config
+        delete mockReq.app.locals[EModelEndpoint.azureOpenAI];
+
         // Set 'all' config as fallback with a serverless Azure config
-        mockReq.config = {
-          endpoints: {
-            all: {
-              titleConvo: true,
-              titleModel: 'gpt-4',
-              titleMethod: 'structured',
-              titlePrompt: 'Fallback title prompt from all config',
-              titlePromptTemplate: 'Template: {{content}}',
-              modelGroupMap: {
+        mockReq.app.locals.all = {
+          titleConvo: true,
+          titleModel: 'gpt-4',
+          titleMethod: 'structured',
+          titlePrompt: 'Fallback title prompt from all config',
+          titlePromptTemplate: 'Template: {{content}}',
+          modelGroupMap: {
+            'gpt-4': {
+              group: 'default-group',
+              deploymentName: 'gpt-4',
+            },
+          },
+          groupMap: {
+            'default-group': {
+              apiKey: '${AZURE_API_KEY}',
+              baseURL: 'https://default.openai.azure.com/',
+              version: '2024-02-15-preview',
+              serverless: true,
+              models: {
                 'gpt-4': {
-                  group: 'default-group',
                   deploymentName: 'gpt-4',
                 },
               },
-              groupMap: {
-                'default-group': {
-                  apiKey: '${AZURE_API_KEY}',
-                  baseURL: 'https://default.openai.azure.com/',
-                  version: '2024-02-15-preview',
-                  serverless: true,
-                  models: {
-                    'gpt-4': {
-                      deploymentName: 'gpt-4',
-                    },
-                  },
-                },
-              },
             },
           },
         };
@@ -1153,6 +982,13 @@ describe('AgentClient - titleConvo', () => {
       };
 
       mockReq = {
+        app: {
+          locals: {
+            memory: {
+              messageWindowSize: 3,
+            },
+          },
+        },
         user: {
           id: 'user-123',
           personalization: {
@@ -1161,13 +997,6 @@ describe('AgentClient - titleConvo', () => {
         },
       };
 
-      // Mock getAppConfig for memory tests
-      mockReq.config = {
-        memory: {
-          messageWindowSize: 3,
-        },
-      };
-
       mockRes = {};
 
       mockOptions = {

api/server/controllers/agents/errors.js

@@ -21,7 +21,7 @@ const getLogStores = require('~/cache/getLogStores');
 
 /**
  * @typedef {Object} ErrorHandlerDependencies
- * @property {ServerRequest} req - The Express request object
+ * @property {Express.Request} req - The Express request object
  * @property {Express.Response} res - The Express response object
  * @property {() => ErrorHandlerContext} getContext - Function to get the current context
  * @property {string} [originPath] - The origin path for the error handler

api/server/controllers/agents/v1.js

@@ -2,15 +2,9 @@ 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,
   SystemRoles,
   FileSources,
   ResourceType,
@@ -71,13 +65,13 @@ 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);
-      } else if (systemTools[tool]) {
-        agentData.tools.push(tool);
-      } else if (tool.includes(Constants.mcp_delimiter)) {
+      }
+
+      if (systemTools[tool]) {
         agentData.tools.push(tool);
       }
     }
@@ -203,32 +197,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 +254,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 +287,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 +381,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,11 +483,10 @@ 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 {
-    const appConfig = req.config;
     filterFile({ req, file: req.file, image: true, isAvatar: true });
     const { agent_id } = req.params;
     if (!agent_id) {
@@ -540,7 +510,9 @@ const uploadAgentAvatarHandler = async (req, res) => {
     }
 
     const buffer = await fs.readFile(req.file.path);
-    const fileStrategy = getFileStrategy(appConfig, { isAvatar: true });
+
+    const fileStrategy = getFileStrategy(req.app.locals, { isAvatar: true });
+
     const resizedBuffer = await resizeAvatar({
       userId: req.user.id,
       input: buffer,

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/chatV1.js

@@ -1,7 +1,7 @@
 const { v4 } = require('uuid');
 const { sleep } = require('@librechat/agents');
+const { sendEvent } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { sendEvent, getBalanceConfig, getModelMaxTokens } = require('@librechat/api');
 const {
   Time,
   Constants,
@@ -34,6 +34,7 @@ const { checkBalance } = require('~/models/balanceMethods');
 const { getConvo } = require('~/models/Conversation');
 const getLogStores = require('~/cache/getLogStores');
 const { countTokens } = require('~/server/utils');
+const { getModelMaxTokens } = require('~/utils');
 const { getOpenAIClient } = require('./helpers');
 
 /**
@@ -46,7 +47,6 @@ const { getOpenAIClient } = require('./helpers');
  * @returns {void}
  */
 const chatV1 = async (req, res) => {
-  const appConfig = req.config;
   logger.debug('[/assistants/chat/] req.body', req.body);
 
   const {
@@ -251,8 +251,8 @@ const chatV1 = async (req, res) => {
     }
 
     const checkBalanceBeforeRun = async () => {
-      const balanceConfig = getBalanceConfig(appConfig);
-      if (!balanceConfig?.enabled) {
+      const balance = req.app?.locals?.balance;
+      if (!balance?.enabled) {
         return;
       }
       const transactions =

api/server/controllers/assistants/chatV2.js

@@ -1,7 +1,7 @@
 const { v4 } = require('uuid');
 const { sleep } = require('@librechat/agents');
+const { sendEvent } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { sendEvent, getBalanceConfig, getModelMaxTokens } = require('@librechat/api');
 const {
   Time,
   Constants,
@@ -31,19 +31,19 @@ const { checkBalance } = require('~/models/balanceMethods');
 const { getConvo } = require('~/models/Conversation');
 const getLogStores = require('~/cache/getLogStores');
 const { countTokens } = require('~/server/utils');
+const { getModelMaxTokens } = require('~/utils');
 const { getOpenAIClient } = require('./helpers');
 
 /**
  * @route POST /
  * @desc Chat with an assistant
  * @access Public
- * @param {ServerRequest} req - The request object, containing the request data.
+ * @param {Express.Request} req - The request object, containing the request data.
  * @param {Express.Response} res - The response object, used to send back a response.
  * @returns {void}
  */
 const chatV2 = async (req, res) => {
   logger.debug('[/assistants/chat/] req.body', req.body);
-  const appConfig = req.config;
 
   /** @type {{files: MongoFile[]}} */
   const {
@@ -126,8 +126,8 @@ const chatV2 = async (req, res) => {
     }
 
     const checkBalanceBeforeRun = async () => {
-      const balanceConfig = getBalanceConfig(appConfig);
-      if (!balanceConfig?.enabled) {
+      const balance = req.app?.locals?.balance;
+      if (!balance?.enabled) {
         return;
       }
       const transactions =
@@ -374,9 +374,9 @@ const chatV2 = async (req, res) => {
       };
 
       /** @type {undefined | TAssistantEndpoint} */
-      const config = appConfig.endpoints?.[endpoint] ?? {};
+      const config = req.app.locals[endpoint] ?? {};
       /** @type {undefined | TBaseEndpoint} */
-      const allConfig = appConfig.endpoints?.all;
+      const allConfig = req.app.locals.all;
 
       const streamRunManager = new StreamRunManager({
         req,

api/server/controllers/assistants/errors.js

@@ -22,7 +22,7 @@ const getLogStores = require('~/cache/getLogStores');
 
 /**
  * @typedef {Object} ErrorHandlerDependencies
- * @property {ServerRequest} req - The Express request object
+ * @property {Express.Request} req - The Express request object
  * @property {Express.Response} res - The Express response object
  * @property {() => ErrorHandlerContext} getContext - Function to get the current context
  * @property {string} [originPath] - The origin path for the error handler

api/server/controllers/assistants/helpers.js

@@ -11,7 +11,7 @@ const { initializeClient } = require('~/server/services/Endpoints/assistants');
 const { getEndpointsConfig } = require('~/server/services/Config');
 
 /**
- * @param {ServerRequest} req
+ * @param {Express.Request} req
  * @param {string} [endpoint]
  * @returns {Promise<string>}
  */
@@ -210,7 +210,6 @@ async function getOpenAIClient({ req, res, endpointOption, initAppClient, overri
  * @returns {Promise<AssistantListResponse>} 200 - success response - application/json
  */
 const fetchAssistants = async ({ req, res, overrideEndpoint }) => {
-  const appConfig = req.config;
   const {
     limit = 100,
     order = 'desc',
@@ -231,20 +230,20 @@ const fetchAssistants = async ({ req, res, overrideEndpoint }) => {
   if (endpoint === EModelEndpoint.assistants) {
     ({ body } = await listAllAssistants({ req, res, version, query }));
   } else if (endpoint === EModelEndpoint.azureAssistants) {
-    const azureConfig = appConfig.endpoints?.[EModelEndpoint.azureOpenAI];
+    const azureConfig = req.app.locals[EModelEndpoint.azureOpenAI];
     body = await listAssistantsForAzure({ req, res, version, azureConfig, query });
   }
 
   if (req.user.role === SystemRoles.ADMIN) {
     return body;
-  } else if (!appConfig.endpoints?.[endpoint]) {
+  } else if (!req.app.locals[endpoint]) {
     return body;
   }
 
   body.data = filterAssistants({
     userId: req.user.id,
     assistants: body.data,
-    assistantsConfig: appConfig.endpoints?.[endpoint],
+    assistantsConfig: req.app.locals[endpoint],
   });
   return body;
 };

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) => {
@@ -258,9 +258,8 @@ function filterAssistantDocs({ documents, userId, assistantsConfig = {} }) {
  */
 const getAssistantDocuments = async (req, res) => {
   try {
-    const appConfig = req.config;
     const endpoint = req.query;
-    const assistantsConfig = appConfig.endpoints?.[endpoint];
+    const assistantsConfig = req.app.locals[endpoint];
     const documents = await getAssistants(
       {},
       {
@@ -297,7 +296,6 @@ const getAssistantDocuments = async (req, res) => {
  */
 const uploadAssistantAvatar = async (req, res) => {
   try {
-    const appConfig = req.config;
     filterFile({ req, file: req.file, image: true, isAvatar: true });
     const { assistant_id } = req.params;
     if (!assistant_id) {
@@ -339,7 +337,7 @@ const uploadAssistantAvatar = async (req, res) => {
     const metadata = {
       ..._metadata,
       avatar: image.filepath,
-      avatar_source: appConfig.fileStrategy,
+      avatar_source: req.app.locals.fileStrategy,
     };
 
     const promises = [];
@@ -349,7 +347,7 @@ const uploadAssistantAvatar = async (req, res) => {
         {
           avatar: {
             filepath: image.filepath,
-            source: appConfig.fileStrategy,
+            source: req.app.locals.fileStrategy,
           },
           user: req.user.id,
         },

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) => {
@@ -94,7 +94,7 @@ const createAssistant = async (req, res) => {
 /**
  * Modifies an assistant.
  * @param {object} params
- * @param {ServerRequest} params.req
+ * @param {Express.Request} params.req
  * @param {OpenAIClient} params.openai
  * @param {string} params.assistant_id
  * @param {AssistantUpdateParams} params.updateData
@@ -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) {
@@ -199,7 +199,7 @@ const updateAssistant = async ({ req, openai, assistant_id, updateData }) => {
 /**
  * Modifies an assistant with the resource file id.
  * @param {object} params
- * @param {ServerRequest} params.req
+ * @param {Express.Request} params.req
  * @param {OpenAIClient} params.openai
  * @param {string} params.assistant_id
  * @param {string} params.tool_resource
@@ -227,7 +227,7 @@ const addResourceFileId = async ({ req, openai, assistant_id, tool_resource, fil
 /**
  * Deletes a file ID from an assistant's resource.
  * @param {object} params
- * @param {ServerRequest} params.req
+ * @param {Express.Request} params.req
  * @param {OpenAIClient} params.openai
  * @param {string} params.assistant_id
  * @param {string} [params.tool_resource]