feat: Add OAuth token revocation endpoint and related functionality

.env.example

@@ -442,8 +442,6 @@ OPENID_REQUIRED_ROLE_PARAMETER_PATH=
 OPENID_USERNAME_CLAIM=
 # Set to determine which user info property returned from OpenID Provider to store as the User's name
 OPENID_NAME_CLAIM=
-# Optional audience parameter for OpenID authorization requests
-OPENID_AUDIENCE=
 
 OPENID_BUTTON_LABEL=
 OPENID_IMAGE_URL=

.github/workflows/helmcharts.yml

@@ -4,13 +4,12 @@ name: Build Helm Charts on Tag
 on:
   push:
     tags:
-      - "chart-*"
+      - "*"
 
 jobs:
   release:
     permissions:
       contents: write
-      packages: write
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -27,49 +26,15 @@ jobs:
         uses: azure/setup-helm@v4
         env:
           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-      
       - name: Build Subchart Deps
         run: |
-          cd helm/librechat
-          helm dependency build  
-          cd ../librechat-rag-api
-          helm dependency build      
+          cd helm/librechat-rag-api
+          helm dependency build 
 
-      - name: Get Chart Version
-        id: chart-version
-        run: |
-          CHART_VERSION=$(echo "${{ github.ref_name }}" | cut -d'-' -f2)
-          echo "CHART_VERSION=${CHART_VERSION}" >> "$GITHUB_OUTPUT"
-
-      # Log in to GitHub Container Registry
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
+      - name: Run chart-releaser
+        uses: helm/chart-releaser-action@v1.6.0
         with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Run Helm OCI Charts Releaser
-      # This is for the librechat chart
-      - name: Release Helm OCI Charts for librechat
-        uses: appany/helm-oci-chart-releaser@v0.4.2
-        with:
-          name: librechat
-          repository: ${{ github.actor }}/librechat-chart
-          tag: ${{ steps.chart-version.outputs.CHART_VERSION }}
-          path: helm/librechat
-          registry: ghcr.io
-          registry_username: ${{ github.actor }}
-          registry_password: ${{ secrets.GITHUB_TOKEN }}
-      
-      # this is for the librechat-rag-api chart
-      - name: Release Helm OCI Charts for librechat-rag-api
-        uses: appany/helm-oci-chart-releaser@v0.4.2
-        with:
-          name: librechat-rag-api
-          repository: ${{ github.actor }}/librechat-chart
-          tag: ${{ steps.chart-version.outputs.CHART_VERSION }}
-          path: helm/librechat-rag-api
-          registry: ghcr.io
-          registry_username: ${{ github.actor }}
-          registry_password: ${{ secrets.GITHUB_TOKEN }}
+          charts_dir: helm
+          skip_existing: true
+        env:
+          CR_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/locize-i18n-sync.yml

@@ -48,7 +48,7 @@ jobs:
 
       # 2. Download translation files from locize.
       - name: Download Translations from locize
-        uses: locize/download@v2
+        uses: locize/download@v1
         with:
           project-id: ${{ secrets.LOCIZE_PROJECT_ID }}
           path: "client/src/locales"

.gitignore

@@ -13,9 +13,6 @@ pids
 *.seed
 .git
 
-# CI/CD data
-test-image*
-
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
 

Dockerfile

@@ -1,4 +1,4 @@
-# v0.8.0-rc2
+# v0.7.9
 
 # Base node image
 FROM node:20-alpine AS node

Dockerfile.multi

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

api/app/clients/AnthropicClient.js

@@ -27,7 +27,6 @@ const {
 const { getModelMaxTokens, getModelMaxOutputTokens, matchModelName } = require('~/utils');
 const { spendTokens, spendStructuredTokens } = require('~/models/spendTokens');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
-const { encodeAndFormatDocuments } = require('~/server/services/Files/documents');
 const { sleep } = require('~/server/utils');
 const BaseClient = require('./BaseClient');
 const { logger } = require('~/config');
@@ -313,33 +312,6 @@ class AnthropicClient extends BaseClient {
     return files;
   }
 
-  async addDocuments(message, attachments) {
-    // Only process documents
-    const documentResult = await encodeAndFormatDocuments(
-      this.options.req,
-      attachments,
-      EModelEndpoint.anthropic,
-    );
-
-    message.documents =
-      documentResult.documents && documentResult.documents.length
-        ? documentResult.documents
-        : undefined;
-
-    return documentResult.files;
-  }
-
-  async processAttachments(message, attachments) {
-    // Process both images and documents
-    const [imageFiles, documentFiles] = await Promise.all([
-      this.addImageURLs(message, attachments),
-      this.addDocuments(message, attachments),
-    ]);
-
-    // Combine files from both processors
-    return [...imageFiles, ...documentFiles];
-  }
-
   /**
    * @param {object} params
    * @param {number} params.promptTokens
@@ -410,7 +382,7 @@ class AnthropicClient extends BaseClient {
         };
       }
 
-      const files = await this.processAttachments(latestMessage, attachments);
+      const files = await this.addImageURLs(latestMessage, attachments);
 
       this.options.attachments = files;
     }
@@ -969,7 +941,7 @@ class AnthropicClient extends BaseClient {
       const content = `<conversation_context>
   ${convo}
   </conversation_context>
-
+  
   Please generate a title for this conversation.`;
 
       const titleMessage = { role: 'user', content };

api/app/clients/BaseClient.js

@@ -1233,7 +1233,7 @@ class BaseClient {
         {},
       );
 
-      await this.processAttachments(message, files, this.visionMode);
+      await this.addImageURLs(message, files, this.visionMode);
 
       this.message_file_map[message.messageId] = files;
       return message;

api/app/clients/GoogleClient.js

@@ -268,7 +268,7 @@ class GoogleClient extends BaseClient {
     const formattedMessages = [];
     const attachments = await this.options.attachments;
     const latestMessage = { ...messages[messages.length - 1] };
-    const files = await this.processAttachments(latestMessage, attachments, VisionModes.generative);
+    const files = await this.addImageURLs(latestMessage, attachments, VisionModes.generative);
     this.options.attachments = files;
     messages[messages.length - 1] = latestMessage;
 
@@ -312,20 +312,6 @@ class GoogleClient extends BaseClient {
     return files;
   }
 
-  // eslint-disable-next-line no-unused-vars
-  async addDocuments(message, attachments) {
-    // GoogleClient doesn't support document processing yet
-    // Return empty results for consistency
-    return [];
-  }
-
-  async processAttachments(message, attachments, mode = '') {
-    // For GoogleClient, only process images
-    const imageFiles = await this.addImageURLs(message, attachments, mode);
-    const documentFiles = await this.addDocuments(message, attachments);
-    return [...imageFiles, ...documentFiles];
-  }
-
   /**
    * Builds the augmented prompt for attachments
    * TODO: Add File API Support
@@ -359,7 +345,7 @@ class GoogleClient extends BaseClient {
 
     const { prompt } = await this.buildMessagesPrompt(messages, parentMessageId);
 
-    const files = await this.processAttachments(latestMessage, attachments);
+    const files = await this.addImageURLs(latestMessage, attachments);
 
     this.options.attachments = files;
 

api/app/clients/OpenAIClient.js

@@ -372,19 +372,6 @@ class OpenAIClient extends BaseClient {
     return files;
   }
 
-  async addDocuments(message, attachments) {
-    // OpenAI doesn't support native document processing yet
-    // Return empty results for consistency
-    return [];
-  }
-
-  async processAttachments(message, attachments) {
-    // For OpenAI, only process images
-    const imageFiles = await this.addImageURLs(message, attachments);
-    const documentFiles = await this.addDocuments(message, attachments);
-    return [...imageFiles, ...documentFiles];
-  }
-
   async buildMessages(messages, parentMessageId, { promptPrefix = null }, opts) {
     let orderedMessages = this.constructor.getMessagesForConversation({
       messages,
@@ -413,7 +400,7 @@ class OpenAIClient extends BaseClient {
         };
       }
 
-      const files = await this.processAttachments(
+      const files = await this.addImageURLs(
         orderedMessages[orderedMessages.length - 1],
         attachments,
       );
@@ -1235,9 +1222,7 @@ ${convo}
       }
 
       if (this.isOmni === true && modelOptions.max_tokens != null) {
-        const paramName =
-          modelOptions.useResponsesApi === true ? 'max_output_tokens' : 'max_completion_tokens';
-        modelOptions[paramName] = modelOptions.max_tokens;
+        modelOptions.max_completion_tokens = modelOptions.max_tokens;
         delete modelOptions.max_tokens;
       }
       if (this.isOmni === true && modelOptions.temperature != null) {

api/app/clients/prompts/formatMessages.js

@@ -3,61 +3,24 @@ const { EModelEndpoint, ContentTypes } = require('librechat-data-provider');
 const { HumanMessage, AIMessage, SystemMessage } = require('@langchain/core/messages');
 
 /**
- * Formats a message with document attachments for specific endpoints.
+ * Formats a message to OpenAI Vision API payload format.
  *
  * @param {Object} params - The parameters for formatting.
  * @param {Object} params.message - The message object to format.
- * @param {Array<Object>} [params.documents] - The document attachments for the message.
+ * @param {string} [params.message.role] - The role of the message sender (must be 'user').
+ * @param {string} [params.message.content] - The text content of the message.
  * @param {EModelEndpoint} [params.endpoint] - Identifier for specific endpoint handling
- * @returns {(Object)} - The formatted message.
- */
-const formatDocumentMessage = ({ message, documents, endpoint }) => {
-  const contentParts = [];
-
-  // Add documents first (for Anthropic PDFs)
-  if (documents && documents.length > 0) {
-    contentParts.push(...documents);
-  }
-
-  // Add text content
-  contentParts.push({ type: ContentTypes.TEXT, text: message.content });
-
-  if (endpoint === EModelEndpoint.anthropic) {
-    message.content = contentParts;
-    return message;
-  }
-
-  // For other endpoints, might need different handling
-  message.content = contentParts;
-  return message;
-};
-
-/**
- * Formats a message with vision capabilities (image_urls) for specific endpoints.
- *
- * @param {Object} params - The parameters for formatting.
- * @param {Object} params.message - The message object to format.
  * @param {Array<string>} [params.image_urls] - The image_urls to attach to the message.
- * @param {EModelEndpoint} [params.endpoint] - Identifier for specific endpoint handling
  * @returns {(Object)} - The formatted message.
  */
 const formatVisionMessage = ({ message, image_urls, endpoint }) => {
-  const contentParts = [];
-
-  // Add images
-  if (image_urls && image_urls.length > 0) {
-    contentParts.push(...image_urls);
-  }
-
-  // Add text content
-  contentParts.push({ type: ContentTypes.TEXT, text: message.content });
-
   if (endpoint === EModelEndpoint.anthropic) {
-    message.content = contentParts;
+    message.content = [...image_urls, { type: ContentTypes.TEXT, text: message.content }];
     return message;
   }
 
   message.content = [{ type: ContentTypes.TEXT, text: message.content }, ...image_urls];
+
   return message;
 };
 
@@ -95,18 +58,7 @@ const formatMessage = ({ message, userName, assistantName, endpoint, langChain =
     content,
   };
 
-  const { image_urls, documents } = message;
-
-  // Handle documents
-  if (Array.isArray(documents) && documents.length > 0 && role === 'user') {
-    return formatDocumentMessage({
-      message: formattedMessage,
-      documents: message.documents,
-      endpoint,
-    });
-  }
-
-  // Handle images
+  const { image_urls } = message;
   if (Array.isArray(image_urls) && image_urls.length > 0 && role === 'user') {
     return formatVisionMessage({
       message: formattedMessage,
@@ -194,21 +146,7 @@ const formatAgentMessages = (payload) => {
       message.content = [{ type: ContentTypes.TEXT, [ContentTypes.TEXT]: message.content }];
     }
     if (message.role !== 'assistant') {
-      // Check if message has documents and preserve array structure
-      const hasDocuments =
-        Array.isArray(message.content) &&
-        message.content.some((part) => part && part.type === 'document');
-
-      if (hasDocuments && message.role === 'user') {
-        // For user messages with documents, create HumanMessage directly with array content
-        messages.push(new HumanMessage({ content: message.content }));
-      } else if (hasDocuments && message.role === 'system') {
-        // For system messages with documents, create SystemMessage directly with array content
-        messages.push(new SystemMessage({ content: message.content }));
-      } else {
-        // Use regular formatting for messages without documents
-        messages.push(formatMessage({ message, langChain: true }));
-      }
+      messages.push(formatMessage({ message, langChain: true }));
       continue;
     }
 
@@ -301,8 +239,6 @@ const formatAgentMessages = (payload) => {
 
 module.exports = {
   formatMessage,
-  formatDocumentMessage,
-  formatVisionMessage,
   formatFromLangChain,
   formatAgentMessages,
   formatLangChainMessages,

api/models/Agent.js

@@ -316,10 +316,17 @@ const updateAgent = async (searchParameter, updateData, options = {}) => {
     if (shouldCreateVersion) {
       const duplicateVersion = isDuplicateVersion(updateData, versionData, versions, actionsHash);
       if (duplicateVersion && !forceVersion) {
-        // No changes detected, return the current agent without creating a new version
-        const agentObj = currentAgent.toObject();
-        agentObj.version = versions.length;
-        return agentObj;
+        const error = new Error(
+          'Duplicate version: This would create a version identical to an existing one',
+        );
+        error.statusCode = 409;
+        error.details = {
+          duplicateVersion,
+          versionIndex: versions.findIndex(
+            (v) => JSON.stringify(duplicateVersion) === JSON.stringify(v),
+          ),
+        };
+        throw error;
       }
     }
 

api/models/Agent.spec.js

@@ -879,31 +879,45 @@ describe('models/Agent', () => {
       expect(emptyParamsAgent.model_parameters).toEqual({});
     });
 
-    test('should not create new version for duplicate updates', async () => {
-      const authorId = new mongoose.Types.ObjectId();
-      const testCases = generateVersionTestCases();
+    test('should detect duplicate versions and reject updates', async () => {
+      const originalConsoleError = console.error;
+      console.error = jest.fn();
 
-      for (const testCase of testCases) {
-        const testAgentId = `agent_${uuidv4()}`;
+      try {
+        const authorId = new mongoose.Types.ObjectId();
+        const testCases = generateVersionTestCases();
 
-        await createAgent({
-          id: testAgentId,
-          provider: 'test',
-          model: 'test-model',
-          author: authorId,
-          ...testCase.initial,
-        });
+        for (const testCase of testCases) {
+          const testAgentId = `agent_${uuidv4()}`;
 
-        const updatedAgent = await updateAgent({ id: testAgentId }, testCase.update);
-        expect(updatedAgent.versions).toHaveLength(2); // No new version created
+          await createAgent({
+            id: testAgentId,
+            provider: 'test',
+            model: 'test-model',
+            author: authorId,
+            ...testCase.initial,
+          });
 
-        // Update with duplicate data should succeed but not create a new version
-        const duplicateUpdate = await updateAgent({ id: testAgentId }, testCase.duplicate);
+          await updateAgent({ id: testAgentId }, testCase.update);
 
-        expect(duplicateUpdate.versions).toHaveLength(2); // No new version created
+          let error;
+          try {
+            await updateAgent({ id: testAgentId }, testCase.duplicate);
+          } catch (e) {
+            error = e;
+          }
 
-        const agent = await getAgent({ id: testAgentId });
-        expect(agent.versions).toHaveLength(2);
+          expect(error).toBeDefined();
+          expect(error.message).toContain('Duplicate version');
+          expect(error.statusCode).toBe(409);
+          expect(error.details).toBeDefined();
+          expect(error.details.duplicateVersion).toBeDefined();
+
+          const agent = await getAgent({ id: testAgentId });
+          expect(agent.versions).toHaveLength(2);
+        }
+      } finally {
+        console.error = originalConsoleError;
       }
     });
 
@@ -1079,13 +1093,20 @@ describe('models/Agent', () => {
       expect(secondUpdate.versions).toHaveLength(3);
 
       // Update without forceVersion and no changes should not create a version
-      const duplicateUpdate = await updateAgent(
-        { id: agentId },
-        { tools: ['listEvents_action_test.com', 'createEvent_action_test.com'] },
-        { updatingUserId: authorId.toString(), forceVersion: false },
-      );
+      let error;
+      try {
+        await updateAgent(
+          { id: agentId },
+          { tools: ['listEvents_action_test.com', 'createEvent_action_test.com'] },
+          { updatingUserId: authorId.toString(), forceVersion: false },
+        );
+      } catch (e) {
+        error = e;
+      }
 
-      expect(duplicateUpdate.versions).toHaveLength(3); // No new version created
+      expect(error).toBeDefined();
+      expect(error.message).toContain('Duplicate version');
+      expect(error.statusCode).toBe(409);
     });
 
     test('should handle isDuplicateVersion with arrays containing null/undefined values', async () => {
@@ -2379,18 +2400,11 @@ describe('models/Agent', () => {
         agent_ids: ['agent1', 'agent2'],
       });
 
-      const updatedAgent = await updateAgent(
-        { id: agentId },
-        { agent_ids: ['agent1', 'agent2', 'agent3'] },
-      );
-      expect(updatedAgent.versions).toHaveLength(2);
+      await updateAgent({ id: agentId }, { agent_ids: ['agent1', 'agent2', 'agent3'] });
 
-      // Update with same agent_ids should succeed but not create a new version
-      const duplicateUpdate = await updateAgent(
-        { id: agentId },
-        { agent_ids: ['agent1', 'agent2', 'agent3'] },
-      );
-      expect(duplicateUpdate.versions).toHaveLength(2); // No new version created
+      await expect(
+        updateAgent({ id: agentId }, { agent_ids: ['agent1', 'agent2', 'agent3'] }),
+      ).rejects.toThrow('Duplicate version');
     });
 
     test('should handle agent_ids field alongside other fields', async () => {
@@ -2529,10 +2543,9 @@ describe('models/Agent', () => {
       expect(updated.versions).toHaveLength(2);
       expect(updated.agent_ids).toEqual([]);
 
-      // Update with same empty agent_ids should succeed but not create a new version
-      const duplicateUpdate = await updateAgent({ id: agentId }, { agent_ids: [] });
-      expect(duplicateUpdate.versions).toHaveLength(2); // No new version created
-      expect(duplicateUpdate.agent_ids).toEqual([]);
+      await expect(updateAgent({ id: agentId }, { agent_ids: [] })).rejects.toThrow(
+        'Duplicate version',
+      );
     });
 
     test('should handle agent without agent_ids field', async () => {

api/models/tx.js

@@ -1,4 +1,4 @@
-const { matchModelName } = require('../utils/tokens');
+const { matchModelName } = require('../utils');
 const defaultRate = 6;
 
 /**
@@ -87,9 +87,6 @@ const tokenValues = Object.assign(
     'gpt-4.1': { prompt: 2, completion: 8 },
     'gpt-4.5': { prompt: 75, completion: 150 },
     'gpt-4o-mini': { prompt: 0.15, completion: 0.6 },
-    'gpt-5': { prompt: 1.25, completion: 10 },
-    'gpt-5-mini': { prompt: 0.25, completion: 2 },
-    'gpt-5-nano': { prompt: 0.05, completion: 0.4 },
     'gpt-4o': { prompt: 2.5, completion: 10 },
     'gpt-4o-2024-05-13': { prompt: 5, completion: 15 },
     'gpt-4-1106': { prompt: 10, completion: 30 },
@@ -150,9 +147,6 @@ const tokenValues = Object.assign(
     codestral: { prompt: 0.3, completion: 0.9 },
     'ministral-8b': { prompt: 0.1, completion: 0.1 },
     'ministral-3b': { prompt: 0.04, completion: 0.04 },
-    // GPT-OSS models
-    'gpt-oss-20b': { prompt: 0.05, completion: 0.2 },
-    'gpt-oss-120b': { prompt: 0.15, completion: 0.6 },
   },
   bedrockValues,
 );
@@ -220,12 +214,6 @@ const getValueKey = (model, endpoint) => {
     return 'gpt-4.1';
   } else if (modelName.includes('gpt-4o-2024-05-13')) {
     return 'gpt-4o-2024-05-13';
-  } else if (modelName.includes('gpt-5-nano')) {
-    return 'gpt-5-nano';
-  } else if (modelName.includes('gpt-5-mini')) {
-    return 'gpt-5-mini';
-  } else if (modelName.includes('gpt-5')) {
-    return 'gpt-5';
   } else if (modelName.includes('gpt-4o-mini')) {
     return 'gpt-4o-mini';
   } else if (modelName.includes('gpt-4o')) {

api/models/tx.spec.js

@@ -25,14 +25,8 @@ describe('getValueKey', () => {
     expect(getValueKey('gpt-4-some-other-info')).toBe('8k');
   });
 
-  it('should return "gpt-5" for model name containing "gpt-5"', () => {
-    expect(getValueKey('gpt-5-some-other-info')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-2025-01-30')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-2025-01-30-0130')).toBe('gpt-5');
-    expect(getValueKey('openai/gpt-5')).toBe('gpt-5');
-    expect(getValueKey('openai/gpt-5-2025-01-30')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-turbo')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-0130')).toBe('gpt-5');
+  it('should return undefined for model names that do not match any known patterns', () => {
+    expect(getValueKey('gpt-5-some-other-info')).toBeUndefined();
   });
 
   it('should return "gpt-3.5-turbo-1106" for model name containing "gpt-3.5-turbo-1106"', () => {
@@ -90,29 +84,6 @@ describe('getValueKey', () => {
     expect(getValueKey('gpt-4.1-nano-0125')).toBe('gpt-4.1-nano');
   });
 
-  it('should return "gpt-5" for model type of "gpt-5"', () => {
-    expect(getValueKey('gpt-5-2025-01-30')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-2025-01-30-0130')).toBe('gpt-5');
-    expect(getValueKey('openai/gpt-5')).toBe('gpt-5');
-    expect(getValueKey('openai/gpt-5-2025-01-30')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-turbo')).toBe('gpt-5');
-    expect(getValueKey('gpt-5-0130')).toBe('gpt-5');
-  });
-
-  it('should return "gpt-5-mini" for model type of "gpt-5-mini"', () => {
-    expect(getValueKey('gpt-5-mini-2025-01-30')).toBe('gpt-5-mini');
-    expect(getValueKey('openai/gpt-5-mini')).toBe('gpt-5-mini');
-    expect(getValueKey('gpt-5-mini-0130')).toBe('gpt-5-mini');
-    expect(getValueKey('gpt-5-mini-2025-01-30-0130')).toBe('gpt-5-mini');
-  });
-
-  it('should return "gpt-5-nano" for model type of "gpt-5-nano"', () => {
-    expect(getValueKey('gpt-5-nano-2025-01-30')).toBe('gpt-5-nano');
-    expect(getValueKey('openai/gpt-5-nano')).toBe('gpt-5-nano');
-    expect(getValueKey('gpt-5-nano-0130')).toBe('gpt-5-nano');
-    expect(getValueKey('gpt-5-nano-2025-01-30-0130')).toBe('gpt-5-nano');
-  });
-
   it('should return "gpt-4o" for model type of "gpt-4o"', () => {
     expect(getValueKey('gpt-4o-2024-08-06')).toBe('gpt-4o');
     expect(getValueKey('gpt-4o-2024-08-06-0718')).toBe('gpt-4o');
@@ -236,48 +207,6 @@ describe('getMultiplier', () => {
     );
   });
 
-  it('should return the correct multiplier for gpt-5', () => {
-    const valueKey = getValueKey('gpt-5-2025-01-30');
-    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-5'].prompt);
-    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5'].completion,
-    );
-    expect(getMultiplier({ model: 'gpt-5-preview', tokenType: 'prompt' })).toBe(
-      tokenValues['gpt-5'].prompt,
-    );
-    expect(getMultiplier({ model: 'openai/gpt-5', tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5'].completion,
-    );
-  });
-
-  it('should return the correct multiplier for gpt-5-mini', () => {
-    const valueKey = getValueKey('gpt-5-mini-2025-01-30');
-    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-5-mini'].prompt);
-    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-mini'].completion,
-    );
-    expect(getMultiplier({ model: 'gpt-5-mini-preview', tokenType: 'prompt' })).toBe(
-      tokenValues['gpt-5-mini'].prompt,
-    );
-    expect(getMultiplier({ model: 'openai/gpt-5-mini', tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-mini'].completion,
-    );
-  });
-
-  it('should return the correct multiplier for gpt-5-nano', () => {
-    const valueKey = getValueKey('gpt-5-nano-2025-01-30');
-    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-5-nano'].prompt);
-    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-nano'].completion,
-    );
-    expect(getMultiplier({ model: 'gpt-5-nano-preview', tokenType: 'prompt' })).toBe(
-      tokenValues['gpt-5-nano'].prompt,
-    );
-    expect(getMultiplier({ model: 'openai/gpt-5-nano', tokenType: 'completion' })).toBe(
-      tokenValues['gpt-5-nano'].completion,
-    );
-  });
-
   it('should return the correct multiplier for gpt-4o', () => {
     const valueKey = getValueKey('gpt-4o-2024-08-06');
     expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-4o'].prompt);
@@ -378,22 +307,10 @@ describe('getMultiplier', () => {
   });
 
   it('should return defaultRate if derived valueKey does not match any known patterns', () => {
-    expect(getMultiplier({ tokenType: 'prompt', model: 'gpt-10-some-other-info' })).toBe(
+    expect(getMultiplier({ tokenType: 'prompt', model: 'gpt-5-some-other-info' })).toBe(
       defaultRate,
     );
   });
-
-  it('should return correct multipliers for GPT-OSS models', () => {
-    const models = ['gpt-oss-20b', 'gpt-oss-120b'];
-    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', () => {

api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/backend",
-  "version": "v0.8.0-rc2",
+  "version": "v0.7.9",
   "description": "",
   "scripts": {
     "start": "echo 'please run this from the root directory'",
@@ -49,10 +49,10 @@
     "@langchain/google-vertexai": "^0.2.13",
     "@langchain/openai": "^0.5.18",
     "@langchain/textsplitters": "^0.1.0",
-    "@librechat/agents": "^2.4.75",
+    "@librechat/agents": "^2.4.68",
     "@librechat/api": "*",
     "@librechat/data-schemas": "*",
-    "@modelcontextprotocol/sdk": "^1.17.1",
+    "@modelcontextprotocol/sdk": "^1.17.0",
     "@node-saml/passport-saml": "^5.1.0",
     "@waylaidwanderer/fetch-event-source": "^3.0.1",
     "axios": "^1.8.2",

api/server/controllers/ErrorController.js

@@ -0,0 +1,46 @@
+const { logger } = require('~/config');
+
+//handle duplicates
+const handleDuplicateKeyError = (err, res) => {
+  logger.error('Duplicate key error:', err.keyValue);
+  const field = `${JSON.stringify(Object.keys(err.keyValue))}`;
+  const code = 409;
+  res
+    .status(code)
+    .send({ messages: `An document with that ${field} already exists.`, fields: field });
+};
+
+//handle validation errors
+const handleValidationError = (err, res) => {
+  logger.error('Validation error:', err.errors);
+  let errors = Object.values(err.errors).map((el) => el.message);
+  let fields = `${JSON.stringify(Object.values(err.errors).map((el) => el.path))}`;
+  let code = 400;
+  if (errors.length > 1) {
+    errors = errors.join(' ');
+    res.status(code).send({ messages: `${JSON.stringify(errors)}`, fields: fields });
+  } else {
+    res.status(code).send({ messages: `${JSON.stringify(errors)}`, fields: fields });
+  }
+};
+
+module.exports = (err, _req, res, _next) => {
+  try {
+    if (err.name === 'ValidationError') {
+      return handleValidationError(err, res);
+    }
+    if (err.code && err.code == 11000) {
+      return handleDuplicateKeyError(err, res);
+    }
+    // Special handling for errors like SyntaxError
+    if (err.statusCode && err.body) {
+      return res.status(err.statusCode).send(err.body);
+    }
+
+    logger.error('ErrorController => error', err);
+    return res.status(500).send('An unknown error occurred.');
+  } catch (err) {
+    logger.error('ErrorController => processing error', err);
+    return res.status(500).send('Processing error in ErrorController.');
+  }
+};

api/server/controllers/ErrorController.spec.js

@@ -1,43 +1,36 @@
-import { logger } from '@librechat/data-schemas';
-import { ErrorController } from './error';
-import type { Request, Response } from 'express';
-import type { ValidationError, MongoServerError, CustomError } from '~/types';
+const errorController = require('./ErrorController');
+const { logger } = require('~/config');
 
 // Mock the logger
-jest.mock('@librechat/data-schemas', () => ({
-  ...jest.requireActual('@librechat/data-schemas'),
+jest.mock('~/config', () => ({
   logger: {
     error: jest.fn(),
-    warn: jest.fn(),
   },
 }));
 
 describe('ErrorController', () => {
-  let mockReq: Request;
-  let mockRes: Response;
+  let mockReq, mockRes, mockNext;
 
   beforeEach(() => {
-    mockReq = {
-      originalUrl: '',
-    } as Request;
+    mockReq = {};
     mockRes = {
       status: jest.fn().mockReturnThis(),
       send: jest.fn(),
-    } as unknown as Response;
-    (logger.error as jest.Mock).mockClear();
+    };
+    mockNext = jest.fn();
+    logger.error.mockClear();
   });
 
   describe('ValidationError handling', () => {
     it('should handle ValidationError with single error', () => {
       const validationError = {
         name: 'ValidationError',
-        message: 'Validation error',
         errors: {
           email: { message: 'Email is required', path: 'email' },
         },
-      } as ValidationError;
+      };
 
-      ErrorController(validationError, mockReq, mockRes);
+      errorController(validationError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(400);
       expect(mockRes.send).toHaveBeenCalledWith({
@@ -50,14 +43,13 @@ describe('ErrorController', () => {
     it('should handle ValidationError with multiple errors', () => {
       const validationError = {
         name: 'ValidationError',
-        message: 'Validation error',
         errors: {
           email: { message: 'Email is required', path: 'email' },
           password: { message: 'Password is required', path: 'password' },
         },
-      } as ValidationError;
+      };
 
-      ErrorController(validationError, mockReq, mockRes);
+      errorController(validationError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(400);
       expect(mockRes.send).toHaveBeenCalledWith({
@@ -71,9 +63,9 @@ describe('ErrorController', () => {
       const validationError = {
         name: 'ValidationError',
         errors: {},
-      } as ValidationError;
+      };
 
-      ErrorController(validationError, mockReq, mockRes);
+      errorController(validationError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(400);
       expect(mockRes.send).toHaveBeenCalledWith({
@@ -86,59 +78,43 @@ describe('ErrorController', () => {
   describe('Duplicate key error handling', () => {
     it('should handle duplicate key error (code 11000)', () => {
       const duplicateKeyError = {
-        name: 'MongoServerError',
-        message: 'Duplicate key error',
         code: 11000,
         keyValue: { email: 'test@example.com' },
-        errmsg:
-          'E11000 duplicate key error collection: test.users index: email_1 dup key: { email: "test@example.com" }',
-      } as MongoServerError;
+      };
 
-      ErrorController(duplicateKeyError, mockReq, mockRes);
+      errorController(duplicateKeyError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(409);
       expect(mockRes.send).toHaveBeenCalledWith({
         messages: 'An document with that ["email"] already exists.',
         fields: '["email"]',
       });
-      expect(logger.warn).toHaveBeenCalledWith(
-        'Duplicate key error: E11000 duplicate key error collection: test.users index: email_1 dup key: { email: "test@example.com" }',
-      );
+      expect(logger.error).toHaveBeenCalledWith('Duplicate key error:', duplicateKeyError.keyValue);
     });
 
     it('should handle duplicate key error with multiple fields', () => {
       const duplicateKeyError = {
-        name: 'MongoServerError',
-        message: 'Duplicate key error',
         code: 11000,
         keyValue: { email: 'test@example.com', username: 'testuser' },
-        errmsg:
-          'E11000 duplicate key error collection: test.users index: email_1 dup key: { email: "test@example.com" }',
-      } as MongoServerError;
+      };
 
-      ErrorController(duplicateKeyError, mockReq, mockRes);
+      errorController(duplicateKeyError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(409);
       expect(mockRes.send).toHaveBeenCalledWith({
         messages: 'An document with that ["email","username"] already exists.',
         fields: '["email","username"]',
       });
-      expect(logger.warn).toHaveBeenCalledWith(
-        'Duplicate key error: E11000 duplicate key error collection: test.users index: email_1 dup key: { email: "test@example.com" }',
-      );
+      expect(logger.error).toHaveBeenCalledWith('Duplicate key error:', duplicateKeyError.keyValue);
     });
 
     it('should handle error with code 11000 as string', () => {
       const duplicateKeyError = {
-        name: 'MongoServerError',
-        message: 'Duplicate key error',
-        code: 11000,
+        code: '11000',
         keyValue: { email: 'test@example.com' },
-        errmsg:
-          'E11000 duplicate key error collection: test.users index: email_1 dup key: { email: "test@example.com" }',
-      } as MongoServerError;
+      };
 
-      ErrorController(duplicateKeyError, mockReq, mockRes);
+      errorController(duplicateKeyError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(409);
       expect(mockRes.send).toHaveBeenCalledWith({
@@ -153,9 +129,9 @@ describe('ErrorController', () => {
       const syntaxError = {
         statusCode: 400,
         body: 'Invalid JSON syntax',
-      } as CustomError;
+      };
 
-      ErrorController(syntaxError, mockReq, mockRes);
+      errorController(syntaxError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(400);
       expect(mockRes.send).toHaveBeenCalledWith('Invalid JSON syntax');
@@ -165,9 +141,9 @@ describe('ErrorController', () => {
       const customError = {
         statusCode: 422,
         body: { error: 'Unprocessable entity' },
-      } as CustomError;
+      };
 
-      ErrorController(customError, mockReq, mockRes);
+      errorController(customError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(422);
       expect(mockRes.send).toHaveBeenCalledWith({ error: 'Unprocessable entity' });
@@ -176,9 +152,9 @@ describe('ErrorController', () => {
     it('should handle error with statusCode but no body', () => {
       const partialError = {
         statusCode: 400,
-      } as CustomError;
+      };
 
-      ErrorController(partialError, mockReq, mockRes);
+      errorController(partialError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(500);
       expect(mockRes.send).toHaveBeenCalledWith('An unknown error occurred.');
@@ -187,9 +163,9 @@ describe('ErrorController', () => {
     it('should handle error with body but no statusCode', () => {
       const partialError = {
         body: 'Some error message',
-      } as CustomError;
+      };
 
-      ErrorController(partialError, mockReq, mockRes);
+      errorController(partialError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(500);
       expect(mockRes.send).toHaveBeenCalledWith('An unknown error occurred.');
@@ -200,7 +176,7 @@ describe('ErrorController', () => {
     it('should handle unknown errors', () => {
       const unknownError = new Error('Some unknown error');
 
-      ErrorController(unknownError, mockReq, mockRes);
+      errorController(unknownError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(500);
       expect(mockRes.send).toHaveBeenCalledWith('An unknown error occurred.');
@@ -211,31 +187,32 @@ describe('ErrorController', () => {
       const mongoError = {
         code: 11100,
         message: 'Some MongoDB error',
-      } as MongoServerError;
+      };
 
-      ErrorController(mongoError, mockReq, mockRes);
+      errorController(mongoError, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(500);
       expect(mockRes.send).toHaveBeenCalledWith('An unknown error occurred.');
       expect(logger.error).toHaveBeenCalledWith('ErrorController => error', mongoError);
     });
 
-    it('should handle generic errors', () => {
-      const genericError = new Error('Test error');
-
-      ErrorController(genericError, mockReq, mockRes);
+    it('should handle null/undefined errors', () => {
+      errorController(null, mockReq, mockRes, mockNext);
 
       expect(mockRes.status).toHaveBeenCalledWith(500);
-      expect(mockRes.send).toHaveBeenCalledWith('An unknown error occurred.');
-      expect(logger.error).toHaveBeenCalledWith('ErrorController => error', genericError);
+      expect(mockRes.send).toHaveBeenCalledWith('Processing error in ErrorController.');
+      expect(logger.error).toHaveBeenCalledWith(
+        'ErrorController => processing error',
+        expect.any(Error),
+      );
     });
   });
 
   describe('Catch block handling', () => {
     beforeEach(() => {
       // Restore logger mock to normal behavior for these tests
-      (logger.error as jest.Mock).mockRestore();
-      (logger.error as jest.Mock) = jest.fn();
+      logger.error.mockRestore();
+      logger.error = jest.fn();
     });
 
     it('should handle errors when logger.error throws', () => {
@@ -243,10 +220,10 @@ describe('ErrorController', () => {
       const freshMockRes = {
         status: jest.fn().mockReturnThis(),
         send: jest.fn(),
-      } as unknown as Response;
+      };
 
       // Mock logger to throw on the first call, succeed on the second
-      (logger.error as jest.Mock)
+      logger.error
         .mockImplementationOnce(() => {
           throw new Error('Logger error');
         })
@@ -254,7 +231,7 @@ describe('ErrorController', () => {
 
       const testError = new Error('Test error');
 
-      ErrorController(testError, mockReq, freshMockRes);
+      errorController(testError, mockReq, freshMockRes, mockNext);
 
       expect(freshMockRes.status).toHaveBeenCalledWith(500);
       expect(freshMockRes.send).toHaveBeenCalledWith('Processing error in ErrorController.');

api/server/controllers/ModelController.js

@@ -5,7 +5,6 @@ const { logger } = require('~/config');
 
 /**
  * @param {ServerRequest} req
- * @returns {Promise<TModelsConfig>} The models config.
  */
 const getModelsConfig = async (req) => {
   const cache = getLogStores(CacheKeys.CONFIG_STORE);

api/server/controllers/PluginController.js

@@ -1,16 +1,54 @@
 const { logger } = require('@librechat/data-schemas');
-const { CacheKeys, Constants } = require('librechat-data-provider');
-const {
-  getToolkitKey,
-  checkPluginAuth,
-  filterUniquePlugins,
-  convertMCPToolsToPlugins,
-} = require('@librechat/api');
+const { CacheKeys, AuthType, Constants } = require('librechat-data-provider');
 const { getCustomConfig, getCachedTools } = require('~/server/services/Config');
-const { availableTools, toolkits } = require('~/app/clients/tools');
+const { getToolkitKey } = require('~/server/services/ToolService');
 const { getMCPManager, getFlowStateManager } = require('~/config');
+const { availableTools } = require('~/app/clients/tools');
 const { getLogStores } = require('~/cache');
 
+/**
+ * Filters out duplicate plugins from the list of plugins.
+ *
+ * @param {TPlugin[]} plugins The list of plugins to filter.
+ * @returns {TPlugin[]} The list of plugins with duplicates removed.
+ */
+const filterUniquePlugins = (plugins) => {
+  const seen = new Set();
+  return plugins.filter((plugin) => {
+    const duplicate = seen.has(plugin.pluginKey);
+    seen.add(plugin.pluginKey);
+    return !duplicate;
+  });
+};
+
+/**
+ * Determines if a plugin is authenticated by checking if all required authentication fields have non-empty values.
+ * Supports alternate authentication fields, allowing validation against multiple possible environment variables.
+ *
+ * @param {TPlugin} plugin The plugin object containing the authentication configuration.
+ * @returns {boolean} True if the plugin is authenticated for all required fields, false otherwise.
+ */
+const checkPluginAuth = (plugin) => {
+  if (!plugin.authConfig || plugin.authConfig.length === 0) {
+    return false;
+  }
+
+  return plugin.authConfig.every((authFieldObj) => {
+    const authFieldOptions = authFieldObj.authField.split('||');
+    let isFieldAuthenticated = false;
+
+    for (const fieldOption of authFieldOptions) {
+      const envValue = process.env[fieldOption];
+      if (envValue && envValue.trim() !== '' && envValue !== AuthType.USER_PROVIDED) {
+        isFieldAuthenticated = true;
+        break;
+      }
+    }
+
+    return isFieldAuthenticated;
+  });
+};
+
 const getAvailablePluginsController = async (req, res) => {
   try {
     const cache = getLogStores(CacheKeys.CONFIG_STORE);
@@ -105,9 +143,9 @@ const getAvailableTools = async (req, res) => {
     const cache = getLogStores(CacheKeys.CONFIG_STORE);
     const cachedToolsArray = await cache.get(CacheKeys.TOOLS);
     const cachedUserTools = await getCachedTools({ userId });
-    const userPlugins = convertMCPToolsToPlugins({ functionTools: cachedUserTools, customConfig });
+    const userPlugins = convertMCPToolsToPlugins(cachedUserTools, customConfig);
 
-    if (cachedToolsArray != null && userPlugins != null) {
+    if (cachedToolsArray && userPlugins) {
       const dedupedTools = filterUniquePlugins([...userPlugins, ...cachedToolsArray]);
       res.status(200).json(dedupedTools);
       return;
@@ -147,9 +185,7 @@ const getAvailableTools = async (req, res) => {
       const isToolDefined = toolDefinitions[plugin.pluginKey] !== undefined;
       const isToolkit =
         plugin.toolkit === true &&
-        Object.keys(toolDefinitions).some(
-          (key) => getToolkitKey({ toolkits, toolName: key }) === plugin.pluginKey,
-        );
+        Object.keys(toolDefinitions).some((key) => getToolkitKey(key) === plugin.pluginKey);
 
       if (!isToolDefined && !isToolkit) {
         continue;
@@ -199,6 +235,58 @@ const getAvailableTools = async (req, res) => {
   }
 };
 
+/**
+ * Converts MCP function format tools to plugin format
+ * @param {Object} functionTools - Object with function format tools
+ * @param {Object} customConfig - Custom configuration for MCP servers
+ * @returns {Array} Array of plugin objects
+ */
+function convertMCPToolsToPlugins(functionTools, customConfig) {
+  const plugins = [];
+
+  for (const [toolKey, toolData] of Object.entries(functionTools)) {
+    if (!toolData.function || !toolKey.includes(Constants.mcp_delimiter)) {
+      continue;
+    }
+
+    const functionData = toolData.function;
+    const parts = toolKey.split(Constants.mcp_delimiter);
+    const serverName = parts[parts.length - 1];
+
+    const serverConfig = customConfig?.mcpServers?.[serverName];
+
+    const plugin = {
+      name: parts[0], // Use the tool name without server suffix
+      pluginKey: toolKey,
+      description: functionData.description || '',
+      authenticated: true,
+      icon: serverConfig?.iconPath,
+    };
+
+    // Build authConfig for MCP tools
+    if (!serverConfig?.customUserVars) {
+      plugin.authConfig = [];
+      plugins.push(plugin);
+      continue;
+    }
+
+    const customVarKeys = Object.keys(serverConfig.customUserVars);
+    if (customVarKeys.length === 0) {
+      plugin.authConfig = [];
+    } else {
+      plugin.authConfig = Object.entries(serverConfig.customUserVars).map(([key, value]) => ({
+        authField: key,
+        label: value.title || key,
+        description: value.description || '',
+      }));
+    }
+
+    plugins.push(plugin);
+  }
+
+  return plugins;
+}
+
 module.exports = {
   getAvailableTools,
   getAvailablePluginsController,

api/server/controllers/PluginController.spec.js

@@ -28,211 +28,19 @@ jest.mock('~/config', () => ({
 
 jest.mock('~/app/clients/tools', () => ({
   availableTools: [],
-  toolkits: [],
 }));
 
 jest.mock('~/cache', () => ({
   getLogStores: jest.fn(),
 }));
 
-jest.mock('@librechat/api', () => ({
-  getToolkitKey: jest.fn(),
-  checkPluginAuth: jest.fn(),
-  filterUniquePlugins: jest.fn(),
-  convertMCPToolsToPlugins: jest.fn(),
-}));
-
 // Import the actual module with the function we want to test
-const { getAvailableTools, getAvailablePluginsController } = require('./PluginController');
-const {
-  filterUniquePlugins,
-  checkPluginAuth,
-  convertMCPToolsToPlugins,
-  getToolkitKey,
-} = require('@librechat/api');
+const { getAvailableTools } = require('./PluginController');
 
 describe('PluginController', () => {
-  let mockReq, mockRes, mockCache;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockReq = { user: { id: 'test-user-id' } };
-    mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
-    mockCache = { get: jest.fn(), set: jest.fn() };
-    getLogStores.mockReturnValue(mockCache);
-  });
-
-  describe('getAvailablePluginsController', () => {
-    beforeEach(() => {
-      mockReq.app = { locals: { filteredTools: [], includedTools: [] } };
-    });
-
-    it('should use filterUniquePlugins to remove duplicate plugins', async () => {
-      const mockPlugins = [
-        { name: 'Plugin1', pluginKey: 'key1', description: 'First' },
-        { name: 'Plugin2', pluginKey: 'key2', description: 'Second' },
-      ];
-
-      mockCache.get.mockResolvedValue(null);
-      filterUniquePlugins.mockReturnValue(mockPlugins);
-      checkPluginAuth.mockReturnValue(true);
-
-      await getAvailablePluginsController(mockReq, mockRes);
-
-      expect(filterUniquePlugins).toHaveBeenCalled();
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      // The response includes authenticated: true for each plugin when checkPluginAuth returns true
-      expect(mockRes.json).toHaveBeenCalledWith([
-        { name: 'Plugin1', pluginKey: 'key1', description: 'First', authenticated: true },
-        { name: 'Plugin2', pluginKey: 'key2', description: 'Second', authenticated: true },
-      ]);
-    });
-
-    it('should use checkPluginAuth to verify plugin authentication', async () => {
-      const mockPlugin = { name: 'Plugin1', pluginKey: 'key1', description: 'First' };
-
-      mockCache.get.mockResolvedValue(null);
-      filterUniquePlugins.mockReturnValue([mockPlugin]);
-      checkPluginAuth.mockReturnValueOnce(true);
-
-      await getAvailablePluginsController(mockReq, mockRes);
-
-      expect(checkPluginAuth).toHaveBeenCalledWith(mockPlugin);
-      const responseData = mockRes.json.mock.calls[0][0];
-      expect(responseData[0].authenticated).toBe(true);
-    });
-
-    it('should return cached plugins when available', async () => {
-      const cachedPlugins = [
-        { name: 'CachedPlugin', pluginKey: 'cached', description: 'Cached plugin' },
-      ];
-
-      mockCache.get.mockResolvedValue(cachedPlugins);
-
-      await getAvailablePluginsController(mockReq, mockRes);
-
-      expect(filterUniquePlugins).not.toHaveBeenCalled();
-      expect(checkPluginAuth).not.toHaveBeenCalled();
-      expect(mockRes.json).toHaveBeenCalledWith(cachedPlugins);
-    });
-
-    it('should filter plugins based on includedTools', async () => {
-      const mockPlugins = [
-        { name: 'Plugin1', pluginKey: 'key1', description: 'First' },
-        { name: 'Plugin2', pluginKey: 'key2', description: 'Second' },
-      ];
-
-      mockReq.app.locals.includedTools = ['key1'];
-      mockCache.get.mockResolvedValue(null);
-      filterUniquePlugins.mockReturnValue(mockPlugins);
-      checkPluginAuth.mockReturnValue(false);
-
-      await getAvailablePluginsController(mockReq, mockRes);
-
-      const responseData = mockRes.json.mock.calls[0][0];
-      expect(responseData).toHaveLength(1);
-      expect(responseData[0].pluginKey).toBe('key1');
-    });
-  });
-
-  describe('getAvailableTools', () => {
-    it('should use convertMCPToolsToPlugins for user-specific MCP tools', async () => {
-      const mockUserTools = {
-        [`tool1${Constants.mcp_delimiter}server1`]: {
-          function: { name: 'tool1', description: 'Tool 1' },
-        },
-      };
-      const mockConvertedPlugins = [
-        {
-          name: 'tool1',
-          pluginKey: `tool1${Constants.mcp_delimiter}server1`,
-          description: 'Tool 1',
-        },
-      ];
-
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValueOnce(mockUserTools);
-      convertMCPToolsToPlugins.mockReturnValue(mockConvertedPlugins);
-      filterUniquePlugins.mockImplementation((plugins) => plugins);
-      getCustomConfig.mockResolvedValue(null);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(convertMCPToolsToPlugins).toHaveBeenCalledWith({
-        functionTools: mockUserTools,
-        customConfig: null,
-      });
-    });
-
-    it('should use filterUniquePlugins to deduplicate combined tools', async () => {
-      const mockUserPlugins = [
-        { name: 'UserTool', pluginKey: 'user-tool', description: 'User tool' },
-      ];
-      const mockManifestPlugins = [
-        { name: 'ManifestTool', pluginKey: 'manifest-tool', description: 'Manifest tool' },
-      ];
-
-      mockCache.get.mockResolvedValue(mockManifestPlugins);
-      getCachedTools.mockResolvedValueOnce({});
-      convertMCPToolsToPlugins.mockReturnValue(mockUserPlugins);
-      filterUniquePlugins.mockReturnValue([...mockUserPlugins, ...mockManifestPlugins]);
-      getCustomConfig.mockResolvedValue(null);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      // Should be called to deduplicate the combined array
-      expect(filterUniquePlugins).toHaveBeenLastCalledWith([
-        ...mockUserPlugins,
-        ...mockManifestPlugins,
-      ]);
-    });
-
-    it('should use checkPluginAuth to verify authentication status', async () => {
-      const mockPlugin = { name: 'Tool1', pluginKey: 'tool1', description: 'Tool 1' };
-
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValue({});
-      convertMCPToolsToPlugins.mockReturnValue([]);
-      filterUniquePlugins.mockReturnValue([mockPlugin]);
-      checkPluginAuth.mockReturnValue(true);
-      getCustomConfig.mockResolvedValue(null);
-
-      // Mock getCachedTools second call to return tool definitions
-      getCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce({ tool1: true });
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(checkPluginAuth).toHaveBeenCalledWith(mockPlugin);
-    });
-
-    it('should use getToolkitKey for toolkit validation', async () => {
-      const mockToolkit = {
-        name: 'Toolkit1',
-        pluginKey: 'toolkit1',
-        description: 'Toolkit 1',
-        toolkit: true,
-      };
-
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValue({});
-      convertMCPToolsToPlugins.mockReturnValue([]);
-      filterUniquePlugins.mockReturnValue([mockToolkit]);
-      checkPluginAuth.mockReturnValue(false);
-      getToolkitKey.mockReturnValue('toolkit1');
-      getCustomConfig.mockResolvedValue(null);
-
-      // Mock getCachedTools second call to return tool definitions
-      getCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce({
-        toolkit1_function: true,
-      });
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(getToolkitKey).toHaveBeenCalled();
-    });
-  });
-
   describe('plugin.icon behavior', () => {
+    let mockReq, mockRes, mockCache;
+
     const callGetAvailableToolsWithMCPServer = async (mcpServers) => {
       mockCache.get.mockResolvedValue(null);
       getCustomConfig.mockResolvedValue({ mcpServers });
@@ -242,22 +50,7 @@ describe('PluginController', () => {
           function: { name: 'test-tool', description: 'A test tool' },
         },
       };
-
-      const mockConvertedPlugin = {
-        name: 'test-tool',
-        pluginKey: `test-tool${Constants.mcp_delimiter}test-server`,
-        description: 'A test tool',
-        icon: mcpServers['test-server']?.iconPath,
-        authenticated: true,
-        authConfig: [],
-      };
-
       getCachedTools.mockResolvedValueOnce(functionTools);
-      convertMCPToolsToPlugins.mockReturnValue([mockConvertedPlugin]);
-      filterUniquePlugins.mockImplementation((plugins) => plugins);
-      checkPluginAuth.mockReturnValue(true);
-      getToolkitKey.mockReturnValue(undefined);
-
       getCachedTools.mockResolvedValueOnce({
         [`test-tool${Constants.mcp_delimiter}test-server`]: true,
       });
@@ -267,6 +60,14 @@ describe('PluginController', () => {
       return responseData.find((tool) => tool.name === 'test-tool');
     };
 
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockReq = { user: { id: 'test-user-id' } };
+      mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+      mockCache = { get: jest.fn(), set: jest.fn() };
+      getLogStores.mockReturnValue(mockCache);
+    });
+
     it('should set plugin.icon when iconPath is defined', async () => {
       const mcpServers = {
         'test-server': {
@@ -285,236 +86,4 @@ describe('PluginController', () => {
       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' },
-            },
-          },
-        },
-      };
-
-      // We need to test the actual flow where MCP manager tools are included
-      const mcpManagerTools = [
-        {
-          name: 'tool1',
-          pluginKey: `tool1${Constants.mcp_delimiter}test-server`,
-          description: 'Tool 1',
-          authenticated: true,
-        },
-      ];
-
-      // Mock the MCP manager to return tools
-      const mockMCPManager = {
-        loadManifestTools: jest.fn().mockResolvedValue(mcpManagerTools),
-      };
-      require('~/config').getMCPManager.mockReturnValue(mockMCPManager);
-
-      mockCache.get.mockResolvedValue(null);
-      getCustomConfig.mockResolvedValue(customConfig);
-
-      // First call returns user tools (empty in this case)
-      getCachedTools.mockResolvedValueOnce({});
-
-      // Mock convertMCPToolsToPlugins to return empty array for user tools
-      convertMCPToolsToPlugins.mockReturnValue([]);
-
-      // Mock filterUniquePlugins to pass through
-      filterUniquePlugins.mockImplementation((plugins) => plugins || []);
-
-      // Mock checkPluginAuth
-      checkPluginAuth.mockReturnValue(true);
-
-      // Second call returns tool definitions
-      getCachedTools.mockResolvedValueOnce({
-        [`tool1${Constants.mcp_delimiter}test-server`]: true,
-      });
-
-      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'));
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(mockRes.status).toHaveBeenCalledWith(500);
-      expect(mockRes.json).toHaveBeenCalledWith({ message: 'Cache error' });
-    });
-  });
-
-  describe('edge cases with undefined/null values', () => {
-    it('should handle undefined cache gracefully', async () => {
-      getLogStores.mockReturnValue(undefined);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(mockRes.status).toHaveBeenCalledWith(500);
-    });
-
-    it('should handle null cachedTools and cachedUserTools', async () => {
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValue(null);
-      convertMCPToolsToPlugins.mockReturnValue(undefined);
-      filterUniquePlugins.mockImplementation((plugins) => plugins || []);
-      getCustomConfig.mockResolvedValue(null);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(convertMCPToolsToPlugins).toHaveBeenCalledWith({
-        functionTools: null,
-        customConfig: null,
-      });
-    });
-
-    it('should handle when getCachedTools returns undefined', async () => {
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValue(undefined);
-      convertMCPToolsToPlugins.mockReturnValue(undefined);
-      filterUniquePlugins.mockImplementation((plugins) => plugins || []);
-      getCustomConfig.mockResolvedValue(null);
-      checkPluginAuth.mockReturnValue(false);
-
-      // Mock getCachedTools to return undefined for both calls
-      getCachedTools.mockReset();
-      getCachedTools.mockResolvedValueOnce(undefined).mockResolvedValueOnce(undefined);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(convertMCPToolsToPlugins).toHaveBeenCalledWith({
-        functionTools: undefined,
-        customConfig: null,
-      });
-    });
-
-    it('should handle cachedToolsArray and userPlugins both being defined', async () => {
-      const cachedTools = [{ name: 'CachedTool', pluginKey: 'cached-tool', description: 'Cached' }];
-      const userTools = {
-        'user-tool': { function: { name: 'user-tool', description: 'User tool' } },
-      };
-      const userPlugins = [{ name: 'UserTool', pluginKey: 'user-tool', description: 'User tool' }];
-
-      mockCache.get.mockResolvedValue(cachedTools);
-      getCachedTools.mockResolvedValue(userTools);
-      convertMCPToolsToPlugins.mockReturnValue(userPlugins);
-      filterUniquePlugins.mockReturnValue([...userPlugins, ...cachedTools]);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([...userPlugins, ...cachedTools]);
-    });
-
-    it('should handle empty toolDefinitions object', async () => {
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce({});
-      convertMCPToolsToPlugins.mockReturnValue([]);
-      filterUniquePlugins.mockImplementation((plugins) => plugins || []);
-      getCustomConfig.mockResolvedValue(null);
-      checkPluginAuth.mockReturnValue(true);
-
-      await getAvailableTools(mockReq, mockRes);
-
-      // With empty tool definitions, no tools should be in the final output
-      expect(mockRes.json).toHaveBeenCalledWith([]);
-    });
-
-    it('should handle MCP tools without customUserVars', async () => {
-      const customConfig = {
-        mcpServers: {
-          'test-server': {
-            // No customUserVars defined
-          },
-        },
-      };
-
-      const mockUserTools = {
-        [`tool1${Constants.mcp_delimiter}test-server`]: {
-          function: { name: 'tool1', description: 'Tool 1' },
-        },
-      };
-
-      mockCache.get.mockResolvedValue(null);
-      getCustomConfig.mockResolvedValue(customConfig);
-      getCachedTools.mockResolvedValueOnce(mockUserTools);
-
-      const mockPlugin = {
-        name: 'tool1',
-        pluginKey: `tool1${Constants.mcp_delimiter}test-server`,
-        description: 'Tool 1',
-        authenticated: true,
-        authConfig: [],
-      };
-
-      convertMCPToolsToPlugins.mockReturnValue([mockPlugin]);
-      filterUniquePlugins.mockImplementation((plugins) => plugins);
-      checkPluginAuth.mockReturnValue(true);
-
-      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);
-      filterUniquePlugins.mockReturnValue([]);
-      checkPluginAuth.mockReturnValue(false);
-
-      await getAvailablePluginsController(mockReq, mockRes);
-
-      expect(mockRes.status).toHaveBeenCalledWith(200);
-      expect(mockRes.json).toHaveBeenCalledWith([]);
-    });
-
-    it('should handle toolkit with undefined toolDefinitions keys', async () => {
-      const mockToolkit = {
-        name: 'Toolkit1',
-        pluginKey: 'toolkit1',
-        description: 'Toolkit 1',
-        toolkit: true,
-      };
-
-      mockCache.get.mockResolvedValue(null);
-      getCachedTools.mockResolvedValue({});
-      convertMCPToolsToPlugins.mockReturnValue([]);
-      filterUniquePlugins.mockReturnValue([mockToolkit]);
-      checkPluginAuth.mockReturnValue(false);
-      getToolkitKey.mockReturnValue(undefined);
-      getCustomConfig.mockResolvedValue(null);
-
-      // 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);
-    });
-  });
 });

api/server/controllers/TwoFactorController.js

@@ -99,36 +99,10 @@ const confirm2FA = async (req, res) => {
 
 /**
  * Disable 2FA by clearing the stored secret and backup codes.
- * Requires verification with either TOTP token or backup code if 2FA is fully enabled.
  */
 const disable2FA = async (req, res) => {
   try {
     const userId = req.user.id;
-    const { token, backupCode } = req.body;
-    const user = await getUserById(userId);
-
-    if (!user || !user.totpSecret) {
-      return res.status(400).json({ message: '2FA is not setup for this user' });
-    }
-
-    if (user.twoFactorEnabled) {
-      const secret = await getTOTPSecret(user.totpSecret);
-      let isVerified = false;
-
-      if (token) {
-        isVerified = await verifyTOTP(secret, token);
-      } else if (backupCode) {
-        isVerified = await verifyBackupCode({ user, backupCode });
-      } else {
-        return res
-          .status(400)
-          .json({ message: 'Either token or backup code is required to disable 2FA' });
-      }
-
-      if (!isVerified) {
-        return res.status(401).json({ message: 'Invalid token or backup code' });
-      }
-    }
     await updateUser(userId, { totpSecret: null, backupCodes: [], twoFactorEnabled: false });
     return res.status(200).json();
   } catch (err) {

api/server/controllers/UserController.js

@@ -1,5 +1,5 @@
 const { logger } = require('@librechat/data-schemas');
-const { webSearchKeys, extractWebSearchEnvVars, normalizeHttpError } = require('@librechat/api');
+const { webSearchKeys, extractWebSearchEnvVars } = require('@librechat/api');
 const {
   getFiles,
   updateUser,
@@ -89,8 +89,8 @@ const updateUserPluginsController = async (req, res) => {
 
       if (userPluginsService instanceof Error) {
         logger.error('[userPluginsService]', userPluginsService);
-        const { status, message } = normalizeHttpError(userPluginsService);
-        return res.status(status).send({ message });
+        const { status, message } = userPluginsService;
+        res.status(status).send({ message });
       }
     }
 
@@ -137,7 +137,7 @@ const updateUserPluginsController = async (req, res) => {
         authService = await updateUserPluginAuth(user.id, keys[i], pluginKey, values[i]);
         if (authService instanceof Error) {
           logger.error('[authService]', authService);
-          ({ status, message } = normalizeHttpError(authService));
+          ({ status, message } = authService);
         }
       }
     } else if (action === 'uninstall') {
@@ -151,7 +151,7 @@ const updateUserPluginsController = async (req, res) => {
             `[authService] Error deleting all auth for MCP tool ${pluginKey}:`,
             authService,
           );
-          ({ status, message } = normalizeHttpError(authService));
+          ({ status, message } = authService);
         }
       } else {
         // This handles:
@@ -163,7 +163,7 @@ const updateUserPluginsController = async (req, res) => {
           authService = await deleteUserPluginAuth(user.id, keys[i]); // Deletes by authField name
           if (authService instanceof Error) {
             logger.error('[authService] Error deleting specific auth key:', authService);
-            ({ status, message } = normalizeHttpError(authService));
+            ({ status, message } = authService);
           }
         }
       }
@@ -193,8 +193,7 @@ const updateUserPluginsController = async (req, res) => {
       return res.status(status).send();
     }
 
-    const normalized = normalizeHttpError({ status, message });
-    return res.status(normalized.status).send({ message: normalized.message });
+    res.status(status).send({ message });
   } catch (err) {
     logger.error('[updateUserPluginsController]', err);
     return res.status(500).json({ message: 'Something went wrong.' });

api/server/controllers/agents/client.js

@@ -226,42 +226,6 @@ class AgentClient extends BaseClient {
     return files;
   }
 
-  async addDocuments(message, attachments) {
-    const documentResult =
-      await require('~/server/services/Files/documents').encodeAndFormatDocuments(
-        this.options.req,
-        attachments,
-        this.options.agent.provider,
-      );
-    message.documents =
-      documentResult.documents && documentResult.documents.length
-        ? documentResult.documents
-        : undefined;
-    return documentResult.files;
-  }
-
-  async processAttachments(message, attachments) {
-    const [imageFiles, documentFiles] = await Promise.all([
-      this.addImageURLs(message, attachments),
-      this.addDocuments(message, attachments),
-    ]);
-
-    const allFiles = [...imageFiles, ...documentFiles];
-    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;
-  }
-
   async buildMessages(
     messages,
     parentMessageId,
@@ -295,7 +259,7 @@ class AgentClient extends BaseClient {
         };
       }
 
-      const files = await this.processAttachments(
+      const files = await this.addImageURLs(
         orderedMessages[orderedMessages.length - 1],
         attachments,
       );
@@ -318,23 +282,6 @@ class AgentClient extends BaseClient {
         assistantName: this.options?.modelLabel,
       });
 
-      if (
-        message.documents &&
-        message.documents.length > 0 &&
-        message.role === 'user' &&
-        this.options.agent.provider === EModelEndpoint.anthropic
-      ) {
-        const contentParts = [];
-        contentParts.push(...message.documents);
-        if (message.image_urls && message.image_urls.length > 0) {
-          contentParts.push(...message.image_urls);
-        }
-        const textContent =
-          typeof formattedMessage.content === 'string' ? formattedMessage.content : '';
-        contentParts.push({ type: 'text', text: textContent });
-        formattedMessage.content = contentParts;
-      }
-
       if (message.ocr && i !== orderedMessages.length - 1) {
         if (typeof formattedMessage.content === 'string') {
           formattedMessage.content = message.ocr + '\n' + formattedMessage.content;
@@ -455,34 +402,6 @@ class AgentClient extends BaseClient {
     return result;
   }
 
-  /**
-   * Creates a promise that resolves with the memory promise result or undefined after a timeout
-   * @param {Promise<(TAttachment | null)[] | undefined>} memoryPromise - The memory promise to await
-   * @param {number} timeoutMs - Timeout in milliseconds (default: 3000)
-   * @returns {Promise<(TAttachment | null)[] | undefined>}
-   */
-  async awaitMemoryWithTimeout(memoryPromise, timeoutMs = 3000) {
-    if (!memoryPromise) {
-      return;
-    }
-
-    try {
-      const timeoutPromise = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error('Memory processing timeout')), timeoutMs),
-      );
-
-      const attachments = await Promise.race([memoryPromise, timeoutPromise]);
-      return attachments;
-    } catch (error) {
-      if (error.message === 'Memory processing timeout') {
-        logger.warn('[AgentClient] Memory processing timed out after 3 seconds');
-      } else {
-        logger.error('[AgentClient] Error processing memory:', error);
-      }
-      return;
-    }
-  }
-
   /**
    * @returns {Promise<string | undefined>}
    */
@@ -593,39 +512,6 @@ class AgentClient extends BaseClient {
     return withoutKeys;
   }
 
-  /**
-   * Filters out image URLs from message content
-   * @param {BaseMessage} message - The message to filter
-   * @returns {BaseMessage} - A new message with image URLs removed
-   */
-  filterImageUrls(message) {
-    if (!message.content || typeof message.content === 'string') {
-      return message;
-    }
-
-    if (Array.isArray(message.content)) {
-      const filteredContent = message.content.filter(
-        (part) => part.type !== ContentTypes.IMAGE_URL,
-      );
-
-      if (filteredContent.length === 1 && filteredContent[0].type === ContentTypes.TEXT) {
-        const MessageClass = message.constructor;
-        return new MessageClass({
-          content: filteredContent[0].text,
-          additional_kwargs: message.additional_kwargs,
-        });
-      }
-
-      const MessageClass = message.constructor;
-      return new MessageClass({
-        content: filteredContent,
-        additional_kwargs: message.additional_kwargs,
-      });
-    }
-
-    return message;
-  }
-
   /**
    * @param {BaseMessage[]} messages
    * @returns {Promise<void | (TAttachment | null)[]>}
@@ -654,8 +540,7 @@ class AgentClient extends BaseClient {
         }
       }
 
-      const filteredMessages = messagesToProcess.map((msg) => this.filterImageUrls(msg));
-      const bufferString = getBufferString(filteredMessages);
+      const bufferString = getBufferString(messagesToProcess);
       const bufferMessage = new HumanMessage(`# Current Chat:\n\n${bufferString}`);
       return await this.processMemory([bufferMessage]);
     } catch (error) {
@@ -830,51 +715,6 @@ class AgentClient extends BaseClient {
       };
 
       const toolSet = new Set((this.options.agent.tools ?? []).map((tool) => tool && tool.name));
-
-      if (
-        this.options.agent.provider === EModelEndpoint.anthropic &&
-        payload &&
-        Array.isArray(payload)
-      ) {
-        let userMessageWithDocs = null;
-
-        if (this.userMessage?.documents) {
-          userMessageWithDocs = this.userMessage;
-        } else if (this.currentMessages?.length > 0) {
-          const lastMessage = this.currentMessages[this.currentMessages.length - 1];
-          if (lastMessage.documents?.length > 0) {
-            userMessageWithDocs = lastMessage;
-          }
-        } else if (this.messages?.length > 0) {
-          const lastMessage = this.messages[this.messages.length - 1];
-          if (lastMessage.documents?.length > 0) {
-            userMessageWithDocs = lastMessage;
-          }
-        }
-
-        if (userMessageWithDocs) {
-          for (const payloadMessage of payload) {
-            if (
-              payloadMessage.role === 'user' &&
-              userMessageWithDocs.text === payloadMessage.content
-            ) {
-              if (typeof payloadMessage.content === 'string') {
-                payloadMessage.content = [
-                  ...userMessageWithDocs.documents,
-                  { type: 'text', text: payloadMessage.content },
-                ];
-              } else if (Array.isArray(payloadMessage.content)) {
-                payloadMessage.content = [
-                  ...userMessageWithDocs.documents,
-                  ...payloadMessage.content,
-                ];
-              }
-              break;
-            }
-          }
-        }
-      }
-
       let { messages: initialMessages, indexTokenCountMap } = formatAgentMessages(
         payload,
         this.indexTokenCountMap,
@@ -1128,9 +968,11 @@ class AgentClient extends BaseClient {
       });
 
       try {
-        const attachments = await this.awaitMemoryWithTimeout(memoryPromise);
-        if (attachments && attachments.length > 0) {
-          this.artifactPromises.push(...attachments);
+        if (memoryPromise) {
+          const attachments = await memoryPromise;
+          if (attachments && attachments.length > 0) {
+            this.artifactPromises.push(...attachments);
+          }
         }
         await this.recordCollectedUsage({ context: 'message' });
       } catch (err) {
@@ -1140,9 +982,11 @@ class AgentClient extends BaseClient {
         );
       }
     } catch (err) {
-      const attachments = await this.awaitMemoryWithTimeout(memoryPromise);
-      if (attachments && attachments.length > 0) {
-        this.artifactPromises.push(...attachments);
+      if (memoryPromise) {
+        const attachments = await memoryPromise;
+        if (attachments && attachments.length > 0) {
+          this.artifactPromises.push(...attachments);
+        }
       }
       logger.error(
         '[api/server/controllers/agents/client.js #sendCompletion] Operation aborted',
@@ -1244,16 +1088,11 @@ class AgentClient extends BaseClient {
       clientOptions.configuration = options.configOptions;
     }
 
-    const shouldRemoveMaxTokens = /\b(o\d|gpt-[5-9])\b/i.test(clientOptions.model);
-    if (shouldRemoveMaxTokens && clientOptions.maxTokens != null) {
-      delete clientOptions.maxTokens;
-    } else if (!shouldRemoveMaxTokens && !clientOptions.maxTokens) {
+    // Ensure maxTokens is set for non-o1 models
+    if (!/\b(o\d)\b/i.test(clientOptions.model) && !clientOptions.maxTokens) {
       clientOptions.maxTokens = 75;
-    }
-    if (shouldRemoveMaxTokens && clientOptions?.modelKwargs?.max_completion_tokens != null) {
-      delete clientOptions.modelKwargs.max_completion_tokens;
-    } else if (shouldRemoveMaxTokens && clientOptions?.modelKwargs?.max_output_tokens != null) {
-      delete clientOptions.modelKwargs.max_output_tokens;
+    } else if (/\b(o\d)\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
+      delete clientOptions.maxTokens;
     }
 
     clientOptions = Object.assign(

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

@@ -727,464 +727,4 @@ describe('AgentClient - titleConvo', () => {
       });
     });
   });
-
-  describe('getOptions method - GPT-5+ model handling', () => {
-    let mockReq;
-    let mockRes;
-    let mockAgent;
-    let mockOptions;
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-
-      mockAgent = {
-        id: 'agent-123',
-        endpoint: EModelEndpoint.openAI,
-        provider: EModelEndpoint.openAI,
-        model_parameters: {
-          model: 'gpt-5',
-        },
-      };
-
-      mockReq = {
-        app: {
-          locals: {},
-        },
-        user: {
-          id: 'user-123',
-        },
-      };
-
-      mockRes = {};
-
-      mockOptions = {
-        req: mockReq,
-        res: mockRes,
-        agent: mockAgent,
-      };
-
-      client = new AgentClient(mockOptions);
-    });
-
-    it('should move maxTokens to modelKwargs.max_completion_tokens for GPT-5 models', () => {
-      const clientOptions = {
-        model: 'gpt-5',
-        maxTokens: 2048,
-        temperature: 0.7,
-      };
-
-      // Simulate the getOptions logic that handles GPT-5+ models
-      if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-        clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-        clientOptions.modelKwargs.max_completion_tokens = clientOptions.maxTokens;
-        delete clientOptions.maxTokens;
-      }
-
-      expect(clientOptions.maxTokens).toBeUndefined();
-      expect(clientOptions.modelKwargs).toBeDefined();
-      expect(clientOptions.modelKwargs.max_completion_tokens).toBe(2048);
-      expect(clientOptions.temperature).toBe(0.7); // Other options should remain
-    });
-
-    it('should move maxTokens to modelKwargs.max_output_tokens for GPT-5 models with useResponsesApi', () => {
-      const clientOptions = {
-        model: 'gpt-5',
-        maxTokens: 2048,
-        temperature: 0.7,
-        useResponsesApi: true,
-      };
-
-      if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-        clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-        const paramName =
-          clientOptions.useResponsesApi === true ? 'max_output_tokens' : 'max_completion_tokens';
-        clientOptions.modelKwargs[paramName] = clientOptions.maxTokens;
-        delete clientOptions.maxTokens;
-      }
-
-      expect(clientOptions.maxTokens).toBeUndefined();
-      expect(clientOptions.modelKwargs).toBeDefined();
-      expect(clientOptions.modelKwargs.max_output_tokens).toBe(2048);
-      expect(clientOptions.temperature).toBe(0.7); // Other options should remain
-    });
-
-    it('should handle GPT-5+ models with existing modelKwargs', () => {
-      const clientOptions = {
-        model: 'gpt-6',
-        maxTokens: 1500,
-        temperature: 0.8,
-        modelKwargs: {
-          customParam: 'value',
-        },
-      };
-
-      // Simulate the getOptions logic
-      if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-        clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-        clientOptions.modelKwargs.max_completion_tokens = clientOptions.maxTokens;
-        delete clientOptions.maxTokens;
-      }
-
-      expect(clientOptions.maxTokens).toBeUndefined();
-      expect(clientOptions.modelKwargs).toEqual({
-        customParam: 'value',
-        max_completion_tokens: 1500,
-      });
-    });
-
-    it('should not modify maxTokens for non-GPT-5+ models', () => {
-      const clientOptions = {
-        model: 'gpt-4',
-        maxTokens: 2048,
-        temperature: 0.7,
-      };
-
-      // Simulate the getOptions logic
-      if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-        clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-        clientOptions.modelKwargs.max_completion_tokens = clientOptions.maxTokens;
-        delete clientOptions.maxTokens;
-      }
-
-      // Should not be modified since it's GPT-4
-      expect(clientOptions.maxTokens).toBe(2048);
-      expect(clientOptions.modelKwargs).toBeUndefined();
-    });
-
-    it('should handle various GPT-5+ model formats', () => {
-      const testCases = [
-        { model: 'gpt-5', shouldTransform: true },
-        { model: 'gpt-5-turbo', shouldTransform: true },
-        { model: 'gpt-6', shouldTransform: true },
-        { model: 'gpt-7-preview', shouldTransform: true },
-        { model: 'gpt-8', shouldTransform: true },
-        { model: 'gpt-9-mini', shouldTransform: true },
-        { model: 'gpt-4', shouldTransform: false },
-        { model: 'gpt-4o', shouldTransform: false },
-        { model: 'gpt-3.5-turbo', shouldTransform: false },
-        { model: 'claude-3', shouldTransform: false },
-      ];
-
-      testCases.forEach(({ model, shouldTransform }) => {
-        const clientOptions = {
-          model,
-          maxTokens: 1000,
-        };
-
-        // Simulate the getOptions logic
-        if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-          clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-          clientOptions.modelKwargs.max_completion_tokens = clientOptions.maxTokens;
-          delete clientOptions.maxTokens;
-        }
-
-        if (shouldTransform) {
-          expect(clientOptions.maxTokens).toBeUndefined();
-          expect(clientOptions.modelKwargs?.max_completion_tokens).toBe(1000);
-        } else {
-          expect(clientOptions.maxTokens).toBe(1000);
-          expect(clientOptions.modelKwargs).toBeUndefined();
-        }
-      });
-    });
-
-    it('should not swap max token param for older models when using useResponsesApi', () => {
-      const testCases = [
-        { model: 'gpt-5', shouldTransform: true },
-        { model: 'gpt-5-turbo', shouldTransform: true },
-        { model: 'gpt-6', shouldTransform: true },
-        { model: 'gpt-7-preview', shouldTransform: true },
-        { model: 'gpt-8', shouldTransform: true },
-        { model: 'gpt-9-mini', shouldTransform: true },
-        { model: 'gpt-4', shouldTransform: false },
-        { model: 'gpt-4o', shouldTransform: false },
-        { model: 'gpt-3.5-turbo', shouldTransform: false },
-        { model: 'claude-3', shouldTransform: false },
-      ];
-
-      testCases.forEach(({ model, shouldTransform }) => {
-        const clientOptions = {
-          model,
-          maxTokens: 1000,
-          useResponsesApi: true,
-        };
-
-        if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-          clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-          const paramName =
-            clientOptions.useResponsesApi === true ? 'max_output_tokens' : 'max_completion_tokens';
-          clientOptions.modelKwargs[paramName] = clientOptions.maxTokens;
-          delete clientOptions.maxTokens;
-        }
-
-        if (shouldTransform) {
-          expect(clientOptions.maxTokens).toBeUndefined();
-          expect(clientOptions.modelKwargs?.max_output_tokens).toBe(1000);
-        } else {
-          expect(clientOptions.maxTokens).toBe(1000);
-          expect(clientOptions.modelKwargs).toBeUndefined();
-        }
-      });
-    });
-
-    it('should not transform if maxTokens is null or undefined', () => {
-      const testCases = [
-        { model: 'gpt-5', maxTokens: null },
-        { model: 'gpt-5', maxTokens: undefined },
-        { model: 'gpt-6', maxTokens: 0 }, // Should transform even if 0
-      ];
-
-      testCases.forEach(({ model, maxTokens }, index) => {
-        const clientOptions = {
-          model,
-          maxTokens,
-          temperature: 0.7,
-        };
-
-        // Simulate the getOptions logic
-        if (/\bgpt-[5-9]\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
-          clientOptions.modelKwargs = clientOptions.modelKwargs ?? {};
-          clientOptions.modelKwargs.max_completion_tokens = clientOptions.maxTokens;
-          delete clientOptions.maxTokens;
-        }
-
-        if (index < 2) {
-          // null or undefined cases
-          expect(clientOptions.maxTokens).toBe(maxTokens);
-          expect(clientOptions.modelKwargs).toBeUndefined();
-        } else {
-          // 0 case - should transform
-          expect(clientOptions.maxTokens).toBeUndefined();
-          expect(clientOptions.modelKwargs?.max_completion_tokens).toBe(0);
-        }
-      });
-    });
-  });
-
-  describe('runMemory method', () => {
-    let client;
-    let mockReq;
-    let mockRes;
-    let mockAgent;
-    let mockOptions;
-    let mockProcessMemory;
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-
-      mockAgent = {
-        id: 'agent-123',
-        endpoint: EModelEndpoint.openAI,
-        provider: EModelEndpoint.openAI,
-        model_parameters: {
-          model: 'gpt-4',
-        },
-      };
-
-      mockReq = {
-        app: {
-          locals: {
-            memory: {
-              messageWindowSize: 3,
-            },
-          },
-        },
-        user: {
-          id: 'user-123',
-          personalization: {
-            memories: true,
-          },
-        },
-      };
-
-      mockRes = {};
-
-      mockOptions = {
-        req: mockReq,
-        res: mockRes,
-        agent: mockAgent,
-      };
-
-      mockProcessMemory = jest.fn().mockResolvedValue([]);
-
-      client = new AgentClient(mockOptions);
-      client.processMemory = mockProcessMemory;
-      client.conversationId = 'convo-123';
-      client.responseMessageId = 'response-123';
-    });
-
-    it('should filter out image URLs from message content', async () => {
-      const { HumanMessage, AIMessage } = require('@langchain/core/messages');
-      const messages = [
-        new HumanMessage({
-          content: [
-            {
-              type: 'text',
-              text: 'What is in this image?',
-            },
-            {
-              type: 'image_url',
-              image_url: {
-                url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
-                detail: 'auto',
-              },
-            },
-          ],
-        }),
-        new AIMessage('I can see a small red pixel in the image.'),
-        new HumanMessage({
-          content: [
-            {
-              type: 'text',
-              text: 'What about this one?',
-            },
-            {
-              type: 'image_url',
-              image_url: {
-                url: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/',
-                detail: 'high',
-              },
-            },
-          ],
-        }),
-      ];
-
-      await client.runMemory(messages);
-
-      expect(mockProcessMemory).toHaveBeenCalledTimes(1);
-      const processedMessage = mockProcessMemory.mock.calls[0][0][0];
-
-      // Verify the buffer message was created
-      expect(processedMessage.constructor.name).toBe('HumanMessage');
-      expect(processedMessage.content).toContain('# Current Chat:');
-
-      // Verify that image URLs are not in the buffer string
-      expect(processedMessage.content).not.toContain('image_url');
-      expect(processedMessage.content).not.toContain('data:image');
-      expect(processedMessage.content).not.toContain('base64');
-
-      // Verify text content is preserved
-      expect(processedMessage.content).toContain('What is in this image?');
-      expect(processedMessage.content).toContain('I can see a small red pixel in the image.');
-      expect(processedMessage.content).toContain('What about this one?');
-    });
-
-    it('should handle messages with only text content', async () => {
-      const { HumanMessage, AIMessage } = require('@langchain/core/messages');
-      const messages = [
-        new HumanMessage('Hello, how are you?'),
-        new AIMessage('I am doing well, thank you!'),
-        new HumanMessage('That is great to hear.'),
-      ];
-
-      await client.runMemory(messages);
-
-      expect(mockProcessMemory).toHaveBeenCalledTimes(1);
-      const processedMessage = mockProcessMemory.mock.calls[0][0][0];
-
-      expect(processedMessage.content).toContain('Hello, how are you?');
-      expect(processedMessage.content).toContain('I am doing well, thank you!');
-      expect(processedMessage.content).toContain('That is great to hear.');
-    });
-
-    it('should handle mixed content types correctly', async () => {
-      const { HumanMessage } = require('@langchain/core/messages');
-      const { ContentTypes } = require('librechat-data-provider');
-
-      const messages = [
-        new HumanMessage({
-          content: [
-            {
-              type: 'text',
-              text: 'Here is some text',
-            },
-            {
-              type: ContentTypes.IMAGE_URL,
-              image_url: {
-                url: 'https://example.com/image.png',
-              },
-            },
-            {
-              type: 'text',
-              text: ' and more text',
-            },
-          ],
-        }),
-      ];
-
-      await client.runMemory(messages);
-
-      expect(mockProcessMemory).toHaveBeenCalledTimes(1);
-      const processedMessage = mockProcessMemory.mock.calls[0][0][0];
-
-      // Should contain text parts but not image URLs
-      expect(processedMessage.content).toContain('Here is some text');
-      expect(processedMessage.content).toContain('and more text');
-      expect(processedMessage.content).not.toContain('example.com/image.png');
-      expect(processedMessage.content).not.toContain('IMAGE_URL');
-    });
-
-    it('should preserve original messages without mutation', async () => {
-      const { HumanMessage } = require('@langchain/core/messages');
-      const originalContent = [
-        {
-          type: 'text',
-          text: 'Original text',
-        },
-        {
-          type: 'image_url',
-          image_url: {
-            url: 'data:image/png;base64,ABC123',
-          },
-        },
-      ];
-
-      const messages = [
-        new HumanMessage({
-          content: [...originalContent],
-        }),
-      ];
-
-      await client.runMemory(messages);
-
-      // Verify original message wasn't mutated
-      expect(messages[0].content).toHaveLength(2);
-      expect(messages[0].content[1].type).toBe('image_url');
-      expect(messages[0].content[1].image_url.url).toBe('data:image/png;base64,ABC123');
-    });
-
-    it('should handle message window size correctly', async () => {
-      const { HumanMessage, AIMessage } = require('@langchain/core/messages');
-      const messages = [
-        new HumanMessage('Message 1'),
-        new AIMessage('Response 1'),
-        new HumanMessage('Message 2'),
-        new AIMessage('Response 2'),
-        new HumanMessage('Message 3'),
-        new AIMessage('Response 3'),
-      ];
-
-      // Window size is set to 3 in mockReq
-      await client.runMemory(messages);
-
-      expect(mockProcessMemory).toHaveBeenCalledTimes(1);
-      const processedMessage = mockProcessMemory.mock.calls[0][0][0];
-
-      // Should only include last 3 messages due to window size
-      expect(processedMessage.content).toContain('Message 3');
-      expect(processedMessage.content).toContain('Response 3');
-      expect(processedMessage.content).not.toContain('Message 1');
-      expect(processedMessage.content).not.toContain('Response 1');
-    });
-
-    it('should return early if processMemory is not set', async () => {
-      const { HumanMessage } = require('@langchain/core/messages');
-      client.processMemory = null;
-
-      const result = await client.runMemory([new HumanMessage('Test')]);
-
-      expect(result).toBeUndefined();
-      expect(mockProcessMemory).not.toHaveBeenCalled();
-    });
-  });
 });

api/server/controllers/agents/errors.js

@@ -105,6 +105,8 @@ const createErrorHandler = ({ req, res, getContext, originPath = '/assistants/ch
         return res.end();
       }
       await cache.delete(cacheKey);
+      // const cancelledRun = await openai.beta.threads.runs.cancel(thread_id, run_id);
+      // logger.debug(`[${originPath}] Cancelled run:`, cancelledRun);
     } catch (error) {
       logger.error(`[${originPath}] Error cancelling run`, error);
     }
@@ -113,6 +115,7 @@ const createErrorHandler = ({ req, res, getContext, originPath = '/assistants/ch
 
     let run;
     try {
+      // run = await openai.beta.threads.runs.retrieve(thread_id, run_id);
       await recordUsage({
         ...run.usage,
         model: run.model,
@@ -125,9 +128,18 @@ const createErrorHandler = ({ req, res, getContext, originPath = '/assistants/ch
 
     let finalEvent;
     try {
+      // const errorContentPart = {
+      //   text: {
+      //     value:
+      //       error?.message ?? 'There was an error processing your request. Please try again later.',
+      //   },
+      //   type: ContentTypes.ERROR,
+      // };
+
       finalEvent = {
         final: true,
         conversation: await getConvo(req.user.id, conversationId),
+        // runMessages,
       };
     } catch (error) {
       logger.error(`[${originPath}] Error finalizing error process`, error);

api/server/controllers/agents/request.js

@@ -233,26 +233,6 @@ const AgentController = async (req, res, next, initializeClient, addTitle) => {
         );
       }
     }
-    // Edge case: sendMessage completed but abort happened during sendCompletion
-    // We need to ensure a final event is sent
-    else if (!res.headersSent && !res.finished) {
-      logger.debug(
-        '[AgentController] Handling edge case: `sendMessage` completed but aborted during `sendCompletion`',
-      );
-
-      const finalResponse = { ...response };
-      finalResponse.error = true;
-
-      sendEvent(res, {
-        final: true,
-        conversation,
-        title: conversation.title,
-        requestMessage: userMessage,
-        responseMessage: finalResponse,
-        error: { message: 'Request was aborted during completion' },
-      });
-      res.end();
-    }
 
     // Save user message if needed
     if (!client.skipSaveUserMessage) {

api/server/controllers/agents/v1.js

@@ -194,9 +194,6 @@ const updateAgentHandler = async (req, res) => {
       });
     }
 
-    // Add version count to the response
-    updatedAgent.version = updatedAgent.versions ? updatedAgent.versions.length : 0;
-
     if (updatedAgent.author) {
       updatedAgent.author = updatedAgent.author.toString();
     }

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

@@ -498,28 +498,6 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
       expect(mockRes.json).toHaveBeenCalledWith({ error: 'Agent not found' });
     });
 
-    test('should include version field in update response', async () => {
-      mockReq.user.id = existingAgentAuthorId.toString();
-      mockReq.params.id = existingAgentId;
-      mockReq.body = {
-        name: 'Updated with Version Check',
-      };
-
-      await updateAgentHandler(mockReq, mockRes);
-
-      expect(mockRes.json).toHaveBeenCalled();
-      const updatedAgent = mockRes.json.mock.calls[0][0];
-
-      // Verify version field is included and is a number
-      expect(updatedAgent).toHaveProperty('version');
-      expect(typeof updatedAgent.version).toBe('number');
-      expect(updatedAgent.version).toBeGreaterThanOrEqual(1);
-
-      // Verify in database
-      const agentInDb = await Agent.findOne({ id: existingAgentId });
-      expect(updatedAgent.version).toBe(agentInDb.versions.length);
-    });
-
     test('should handle validation errors properly', async () => {
       mockReq.user.id = existingAgentAuthorId.toString();
       mockReq.params.id = existingAgentId;

api/server/controllers/assistants/chatV1.js

@@ -152,7 +152,7 @@ const chatV1 = async (req, res) => {
         return res.end();
       }
       await cache.delete(cacheKey);
-      const cancelledRun = await openai.beta.threads.runs.cancel(run_id, { thread_id });
+      const cancelledRun = await openai.beta.threads.runs.cancel(thread_id, run_id);
       logger.debug('[/assistants/chat/] Cancelled run:', cancelledRun);
     } catch (error) {
       logger.error('[/assistants/chat/] Error cancelling run', error);
@@ -162,7 +162,7 @@ const chatV1 = async (req, res) => {
 
     let run;
     try {
-      run = await openai.beta.threads.runs.retrieve(run_id, { thread_id });
+      run = await openai.beta.threads.runs.retrieve(thread_id, run_id);
       await recordUsage({
         ...run.usage,
         model: run.model,
@@ -623,7 +623,7 @@ const chatV1 = async (req, res) => {
 
     if (!response.run.usage) {
       await sleep(3000);
-      completedRun = await openai.beta.threads.runs.retrieve(response.run.id, { thread_id });
+      completedRun = await openai.beta.threads.runs.retrieve(thread_id, response.run.id);
       if (completedRun.usage) {
         await recordUsage({
           ...completedRun.usage,

api/server/controllers/assistants/chatV2.js

@@ -467,7 +467,7 @@ const chatV2 = async (req, res) => {
 
     if (!response.run.usage) {
       await sleep(3000);
-      completedRun = await openai.beta.threads.runs.retrieve(response.run.id, { thread_id });
+      completedRun = await openai.beta.threads.runs.retrieve(thread_id, response.run.id);
       if (completedRun.usage) {
         await recordUsage({
           ...completedRun.usage,

api/server/controllers/assistants/errors.js

@@ -108,7 +108,7 @@ const createErrorHandler = ({ req, res, getContext, originPath = '/assistants/ch
         return res.end();
       }
       await cache.delete(cacheKey);
-      const cancelledRun = await openai.beta.threads.runs.cancel(run_id, { thread_id });
+      const cancelledRun = await openai.beta.threads.runs.cancel(thread_id, run_id);
       logger.debug(`[${originPath}] Cancelled run:`, cancelledRun);
     } catch (error) {
       logger.error(`[${originPath}] Error cancelling run`, error);
@@ -118,7 +118,7 @@ const createErrorHandler = ({ req, res, getContext, originPath = '/assistants/ch
 
     let run;
     try {
-      run = await openai.beta.threads.runs.retrieve(run_id, { thread_id });
+      run = await openai.beta.threads.runs.retrieve(thread_id, run_id);
       await recordUsage({
         ...run.usage,
         model: run.model,

api/server/controllers/assistants/helpers.js

@@ -173,16 +173,6 @@ const listAssistantsForAzure = async ({ req, res, version, azureConfig = {}, que
   };
 };
 
-/**
- * Initializes the OpenAI client.
- * @param {object} params - The parameters object.
- * @param {ServerRequest} params.req - The request object.
- * @param {ServerResponse} params.res - The response object.
- * @param {TEndpointOption} params.endpointOption - The endpoint options.
- * @param {boolean} params.initAppClient - Whether to initialize the app client.
- * @param {string} params.overrideEndpoint - The endpoint to override.
- * @returns {Promise<{ openai: OpenAIClient, openAIApiKey: string; client: import('~/app/clients/OpenAIClient') }>} - The initialized OpenAI client.
- */
 async function getOpenAIClient({ req, res, endpointOption, initAppClient, overrideEndpoint }) {
   let endpoint = overrideEndpoint ?? req.body.endpoint ?? req.query.endpoint;
   const version = await getCurrentVersion(req, endpoint);

api/server/controllers/assistants/v1.js

@@ -197,7 +197,7 @@ const deleteAssistant = async (req, res) => {
     await validateAuthor({ req, openai });
 
     const assistant_id = req.params.id;
-    const deletionStatus = await openai.beta.assistants.delete(assistant_id);
+    const deletionStatus = await openai.beta.assistants.del(assistant_id);
     if (deletionStatus?.deleted) {
       await deleteAssistantActions({ req, assistant_id });
     }
@@ -365,7 +365,7 @@ const uploadAssistantAvatar = async (req, res) => {
     try {
       await fs.unlink(req.file.path);
       logger.debug('[/:agent_id/avatar] Temp. image upload file deleted');
-    } catch {
+    } catch (error) {
       logger.debug('[/:agent_id/avatar] Temp. image upload file already deleted');
     }
   }

api/server/index.js

@@ -8,12 +8,14 @@ const express = require('express');
 const passport = require('passport');
 const compression = require('compression');
 const cookieParser = require('cookie-parser');
+const { isEnabled } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
 const mongoSanitize = require('express-mongo-sanitize');
-const { isEnabled, ErrorController } = require('@librechat/api');
 const { connectDb, indexSync } = require('~/db');
+
 const validateImageRequest = require('./middleware/validateImageRequest');
 const { jwtLogin, ldapLogin, passportLogin } = require('~/strategies');
+const errorController = require('./controllers/ErrorController');
 const initializeMCPs = require('./services/initializeMCPs');
 const configureSocialLogins = require('./socialLogins');
 const AppService = require('./services/AppService');
@@ -118,7 +120,8 @@ const startServer = async () => {
   app.use('/api/tags', routes.tags);
   app.use('/api/mcp', routes.mcp);
 
-  app.use(ErrorController);
+  // Add the error controller one more time after all routes
+  app.use(errorController);
 
   app.use((req, res) => {
     res.set({

api/server/index.spec.js

@@ -92,7 +92,7 @@ async function healthCheckPoll(app, retries = 0) {
     if (response.status === 200) {
       return; // App is healthy
     }
-  } catch {
+  } catch (error) {
     // Ignore connection errors during polling
   }
 

api/server/middleware/abortRun.js

@@ -47,7 +47,7 @@ async function abortRun(req, res) {
 
   try {
     await cache.set(cacheKey, 'cancelled', three_minutes);
-    const cancelledRun = await openai.beta.threads.runs.cancel(run_id, { thread_id });
+    const cancelledRun = await openai.beta.threads.runs.cancel(thread_id, run_id);
     logger.debug('[abortRun] Cancelled run:', cancelledRun);
   } catch (error) {
     logger.error('[abortRun] Error cancelling run', error);
@@ -60,7 +60,7 @@ async function abortRun(req, res) {
   }
 
   try {
-    const run = await openai.beta.threads.runs.retrieve(run_id, { thread_id });
+    const run = await openai.beta.threads.runs.retrieve(thread_id, run_id);
     await recordUsage({
       ...run.usage,
       model: run.model,

api/server/middleware/validateModel.js

@@ -33,7 +33,7 @@ const validateModel = async (req, res, next) => {
     return next();
   }
 
-  const { ILLEGAL_MODEL_REQ_SCORE: score = 1 } = process.env ?? {};
+  const { ILLEGAL_MODEL_REQ_SCORE: score = 5 } = process.env ?? {};
 
   const type = ViolationTypes.ILLEGAL_MODEL_REQUEST;
   const errorMessage = {

api/server/routes/convos.js

@@ -111,7 +111,7 @@ router.delete('/', async (req, res) => {
     /** @type {{ openai: OpenAI }} */
     const { openai } = await assistantClients[endpoint].initializeClient({ req, res });
     try {
-      const response = await openai.beta.threads.delete(thread_id);
+      const response = await openai.beta.threads.del(thread_id);
       logger.debug('Deleted OpenAI thread:', response);
     } catch (error) {
       logger.error('Error deleting OpenAI thread:', error);

api/server/routes/files/files.js

@@ -413,15 +413,13 @@ router.post('/', async (req, res) => {
       logger.error('[/files] Error deleting file:', error);
     }
     res.status(500).json({ message });
-  } finally {
-    if (cleanup) {
-      try {
-        await fs.unlink(req.file.path);
-      } catch (error) {
-        logger.error('[/files] Error deleting file after file processing:', error);
-      }
-    } else {
-      logger.debug('[/files] File processing completed without cleanup');
+  }
+
+  if (cleanup) {
+    try {
+      await fs.unlink(req.file.path);
+    } catch (error) {
+      logger.error('[/files] Error deleting file after file processing:', error);
     }
   }
 });

api/server/routes/mcp.js

@@ -300,6 +300,120 @@ router.post('/oauth/cancel/:serverName', requireJwtAuth, async (req, res) => {
   }
 });
 
+/**
+ * Revoke OAuth tokens for an MCP server
+ * This endpoint revokes OAuth tokens and disconnects the server for a fresh start
+ */
+router.post('/:serverName/oauth/revoke', requireJwtAuth, async (req, res) => {
+  try {
+    const { serverName } = req.params;
+    const user = req.user;
+
+    if (!user?.id) {
+      return res.status(401).json({ error: 'User not authenticated' });
+    }
+
+    logger.info(`[MCP OAuth Revoke] Revoking OAuth tokens for ${serverName} by user ${user.id}`);
+
+    const printConfig = false;
+    const config = await loadCustomConfig(printConfig);
+    if (!config || !config.mcpServers || !config.mcpServers[serverName]) {
+      return res.status(404).json({
+        error: `MCP server '${serverName}' not found in configuration`,
+      });
+    }
+
+    const mcpManager = getMCPManager(user.id);
+
+    // Delete OAuth access and refresh tokens
+    const baseIdentifier = `mcp:${serverName}`;
+
+    try {
+      await deleteTokens({ identifier: baseIdentifier });
+      await deleteTokens({ identifier: `${baseIdentifier}:refresh` });
+      logger.info(`[MCP OAuth Revoke] Successfully cleared OAuth tokens for ${serverName}`);
+    } catch (error) {
+      logger.warn(`[MCP OAuth Revoke] Failed to clear OAuth tokens for ${serverName}:`, error);
+    }
+
+    // Disconnect the server and clear all connection state
+    try {
+      await mcpManager.disconnectServer(serverName);
+      logger.info(`[MCP OAuth Revoke] Disconnected server: ${serverName}`);
+
+      // Clear the server from OAuth servers set to prevent it from showing as requiring OAuth
+      if (mcpManager.removeOAuthServer) {
+        mcpManager.removeOAuthServer(serverName);
+        logger.info(`[MCP OAuth Revoke] Removed ${serverName} from OAuth servers set`);
+      } else {
+        // Fallback: clear the OAuth servers set entry manually (should not be needed now)
+        const oauthServers = mcpManager.getOAuthServers();
+        if (oauthServers && oauthServers.has(serverName)) {
+          oauthServers.delete(serverName);
+          logger.info(`[MCP OAuth Revoke] Manually removed ${serverName} from OAuth servers set`);
+        }
+      }
+
+      // Clear connection state from both app and user connection maps
+      const appConnections = mcpManager.getAllConnections();
+      const userConnections = mcpManager.getUserConnections(user.id);
+
+      if (appConnections && appConnections.has(serverName)) {
+        appConnections.delete(serverName);
+        logger.info(`[MCP OAuth Revoke] Cleared ${serverName} from app connections`);
+      }
+
+      if (userConnections && userConnections.has(serverName)) {
+        userConnections.delete(serverName);
+        logger.info(`[MCP OAuth Revoke] Cleared ${serverName} from user connections`);
+      }
+    } catch (error) {
+      logger.warn(`[MCP OAuth Revoke] Failed to disconnect server ${serverName}:`, error);
+    }
+
+    // Clear cached tools for this server
+    try {
+      const userTools = (await getCachedTools({ userId: user.id })) || {};
+      const mcpDelimiter = Constants.mcp_delimiter;
+
+      for (const key of Object.keys(userTools)) {
+        if (key.endsWith(`${mcpDelimiter}${serverName}`)) {
+          delete userTools[key];
+        }
+      }
+
+      await setCachedTools(userTools, { userId: user.id });
+      logger.info(`[MCP OAuth Revoke] Cleared cached tools for ${serverName}`);
+    } catch (error) {
+      logger.warn(`[MCP OAuth Revoke] Failed to clear cached tools for ${serverName}:`, error);
+    }
+
+    // Cancel any pending OAuth flows
+    try {
+      const flowsCache = getLogStores(CacheKeys.FLOWS);
+      const flowManager = getFlowStateManager(flowsCache);
+      const flowId = MCPOAuthHandler.generateFlowId(user.id, serverName);
+      const flowState = await flowManager.getFlowState(flowId, 'mcp_oauth');
+
+      if (flowState && flowState.status === 'PENDING') {
+        await flowManager.failFlow(flowId, 'mcp_oauth', 'OAuth tokens revoked by user');
+        logger.info(`[MCP OAuth Revoke] Cancelled pending OAuth flow for ${serverName}`);
+      }
+    } catch (error) {
+      logger.warn(`[MCP OAuth Revoke] Failed to cancel OAuth flow for ${serverName}:`, error);
+    }
+
+    res.json({
+      success: true,
+      message: `OAuth tokens revoked for ${serverName}. Server can now be re-authenticated.`,
+      serverName,
+    });
+  } catch (error) {
+    logger.error('[MCP OAuth Revoke] Unexpected error', error);
+    res.status(500).json({ error: 'Failed to revoke OAuth tokens' });
+  }
+});
+
 /**
  * Reinitialize MCP server
  * This endpoint allows reinitializing a specific MCP server
@@ -337,7 +451,9 @@ router.post('/:serverName/reinitialize', requireJwtAuth, async (req, res) => {
       for (const varName of Object.keys(serverConfig.customUserVars)) {
         try {
           const value = await getUserPluginAuthValue(user.id, varName, false);
-          customUserVars[varName] = value;
+          if (value) {
+            customUserVars[varName] = value;
+          }
         } catch (err) {
           logger.error(`[MCP Reinitialize] Error fetching ${varName} for user ${user.id}:`, err);
         }
@@ -502,6 +618,10 @@ router.get('/connection/status/:serverName', requireJwtAuth, async (req, res) =>
       return res.status(401).json({ error: 'User not authenticated' });
     }
 
+    if (!serverName) {
+      return res.status(400).json({ error: 'Server name is required' });
+    }
+
     const { mcpConfig, appConnections, userConnections, oauthServers } = await getMCPSetupData(
       user.id,
     );

api/server/routes/memories.js

@@ -13,8 +13,6 @@ const { getRoleByName } = require('~/models/Role');
 
 const router = express.Router();
 
-const memoryPayloadLimit = express.json({ limit: '100kb' });
-
 const checkMemoryRead = generateCheckAccess({
   permissionType: PermissionTypes.MEMORIES,
   permissions: [Permissions.USE, Permissions.READ],
@@ -62,7 +60,6 @@ router.get('/', checkMemoryRead, async (req, res) => {
 
     const memoryConfig = req.app.locals?.memory;
     const tokenLimit = memoryConfig?.tokenLimit;
-    const charLimit = memoryConfig?.charLimit || 10000;
 
     let usagePercentage = null;
     if (tokenLimit && tokenLimit > 0) {
@@ -73,7 +70,6 @@ router.get('/', checkMemoryRead, async (req, res) => {
       memories: sortedMemories,
       totalTokens,
       tokenLimit: tokenLimit || null,
-      charLimit,
       usagePercentage,
     });
   } catch (error) {
@@ -87,7 +83,7 @@ router.get('/', checkMemoryRead, async (req, res) => {
  * Body: { key: string, value: string }
  * Returns 201 and { created: true, memory: <createdDoc> } when successful.
  */
-router.post('/', memoryPayloadLimit, checkMemoryCreate, async (req, res) => {
+router.post('/', checkMemoryCreate, async (req, res) => {
   const { key, value } = req.body;
 
   if (typeof key !== 'string' || key.trim() === '') {
@@ -98,25 +94,13 @@ router.post('/', memoryPayloadLimit, checkMemoryCreate, async (req, res) => {
     return res.status(400).json({ error: 'Value is required and must be a non-empty string.' });
   }
 
-  const memoryConfig = req.app.locals?.memory;
-  const charLimit = memoryConfig?.charLimit || 10000;
-
-  if (key.length > 1000) {
-    return res.status(400).json({
-      error: `Key exceeds maximum length of 1000 characters. Current length: ${key.length} characters.`,
-    });
-  }
-
-  if (value.length > charLimit) {
-    return res.status(400).json({
-      error: `Value exceeds maximum length of ${charLimit} characters. Current length: ${value.length} characters.`,
-    });
-  }
-
   try {
     const tokenCount = Tokenizer.getTokenCount(value, 'o200k_base');
 
     const memories = await getAllUserMemories(req.user.id);
+
+    // Check token limit
+    const memoryConfig = req.app.locals?.memory;
     const tokenLimit = memoryConfig?.tokenLimit;
 
     if (tokenLimit) {
@@ -191,7 +175,7 @@ router.patch('/preferences', checkMemoryOptOut, async (req, res) => {
  * Body: { key?: string, value: string }
  * Returns 200 and { updated: true, memory: <updatedDoc> } when successful.
  */
-router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, async (req, res) => {
+router.patch('/:key', checkMemoryUpdate, async (req, res) => {
   const { key: urlKey } = req.params;
   const { key: bodyKey, value } = req.body || {};
 
@@ -199,23 +183,9 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, async (req, res) =>
     return res.status(400).json({ error: 'Value is required and must be a non-empty string.' });
   }
 
+  // Use the key from the body if provided, otherwise use the key from the URL
   const newKey = bodyKey || urlKey;
 
-  const memoryConfig = req.app.locals?.memory;
-  const charLimit = memoryConfig?.charLimit || 10000;
-
-  if (newKey.length > 1000) {
-    return res.status(400).json({
-      error: `Key exceeds maximum length of 1000 characters. Current length: ${newKey.length} characters.`,
-    });
-  }
-
-  if (value.length > charLimit) {
-    return res.status(400).json({
-      error: `Value exceeds maximum length of ${charLimit} characters. Current length: ${value.length} characters.`,
-    });
-  }
-
   try {
     const tokenCount = Tokenizer.getTokenCount(value, 'o200k_base');
 
@@ -226,6 +196,7 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, async (req, res) =>
       return res.status(404).json({ error: 'Memory not found.' });
     }
 
+    // If the key is changing, we need to handle it specially
     if (newKey !== urlKey) {
       const keyExists = memories.find((m) => m.key === newKey);
       if (keyExists) {
@@ -248,6 +219,7 @@ router.patch('/:key', memoryPayloadLimit, checkMemoryUpdate, async (req, res) =>
         return res.status(500).json({ error: 'Failed to delete old memory.' });
       }
     } else {
+      // Key is not changing, just update the value
       const result = await setMemory({
         userId: req.user.id,
         key: newKey,

api/server/routes/oauth.js

@@ -1,10 +1,7 @@
 // file deepcode ignore NoRateLimitingForLogin: Rate limiting is handled by the `loginLimiter` middleware
 const express = require('express');
 const passport = require('passport');
-const { isEnabled } = require('@librechat/api');
 const { randomState } = require('openid-client');
-const { logger } = require('@librechat/data-schemas');
-const { ErrorTypes } = require('librechat-data-provider');
 const {
   checkBan,
   logHeaders,
@@ -13,6 +10,8 @@ const {
   checkDomainAllowed,
 } = require('~/server/middleware');
 const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
+const { isEnabled } = require('~/server/utils');
+const { logger } = require('~/config');
 
 const router = express.Router();
 
@@ -47,13 +46,13 @@ const oauthHandler = async (req, res) => {
 };
 
 router.get('/error', (req, res) => {
-  /** A single error message is pushed by passport when authentication fails. */
-  const errorMessage = req.session?.messages?.pop() || 'Unknown error';
+  // A single error message is pushed by passport when authentication fails.
   logger.error('Error in OAuth authentication:', {
-    message: errorMessage,
+    message: req.session?.messages?.pop() || 'Unknown error',
   });
 
-  res.redirect(`${domains.client}/login?redirect=false&error=${ErrorTypes.AUTH_FAILED}`);
+  // Redirect to login page with auth_failed parameter to prevent infinite redirect loops
+  res.redirect(`${domains.client}/login?redirect=false`);
 });
 
 /**

api/server/services/AppService.js

@@ -1,8 +1,9 @@
-const { loadMemoryConfig, agentsConfigSetup, loadWebSearchConfig } = require('@librechat/api');
+const { agentsConfigSetup, loadWebSearchConfig } = require('@librechat/api');
 const {
   FileSources,
   loadOCRConfig,
   EModelEndpoint,
+  loadMemoryConfig,
   getConfigDefaults,
 } = require('librechat-data-provider');
 const {

api/server/services/Artifacts/update.js

@@ -60,14 +60,7 @@ const replaceArtifactContent = (originalText, artifact, original, updated) => {
 
   // Find boundaries between ARTIFACT_START and ARTIFACT_END
   const contentStart = artifactContent.indexOf('\n', artifactContent.indexOf(ARTIFACT_START)) + 1;
-  let contentEnd = artifactContent.lastIndexOf(ARTIFACT_END);
-
-  // Special case: if contentEnd is 0, it means the only ::: found is at the start of :::artifact
-  // This indicates an incomplete artifact (no closing :::)
-  // We need to check that it's exactly at position 0 (the beginning of artifactContent)
-  if (contentEnd === 0 && artifactContent.indexOf(ARTIFACT_START) === 0) {
-    contentEnd = artifactContent.length;
-  }
+  const contentEnd = artifactContent.lastIndexOf(ARTIFACT_END);
 
   if (contentStart === -1 || contentEnd === -1) {
     return null;
@@ -79,20 +72,12 @@ const replaceArtifactContent = (originalText, artifact, original, updated) => {
 
   // Determine where to look for the original content
   let searchStart, searchEnd;
-  if (codeBlockStart !== -1) {
-    // Code block starts
+  if (codeBlockStart !== -1 && codeBlockEnd !== -1) {
+    // If code blocks exist, search between them
     searchStart = codeBlockStart + 4; // after ```\n
-
-    if (codeBlockEnd !== -1 && codeBlockEnd > codeBlockStart) {
-      // Code block has proper ending
-      searchEnd = codeBlockEnd;
-    } else {
-      // No closing backticks found or they're before the opening (shouldn't happen)
-      // This might be an incomplete artifact - search to contentEnd
-      searchEnd = contentEnd;
-    }
+    searchEnd = codeBlockEnd;
   } else {
-    // No code blocks at all
+    // Otherwise search in the whole artifact content
     searchStart = contentStart;
     searchEnd = contentEnd;
   }

api/server/services/Artifacts/update.spec.js

@@ -89,9 +89,9 @@ describe('replaceArtifactContent', () => {
   };
 
   test('should replace content within artifact boundaries', () => {
-    const original = "console.log('hello')";
+    const original = 'console.log(\'hello\')';
     const artifact = createTestArtifact(original);
-    const updated = "console.log('updated')";
+    const updated = 'console.log(\'updated\')';
 
     const result = replaceArtifactContent(artifact.text, artifact, original, updated);
     expect(result).toContain(updated);
@@ -317,182 +317,4 @@ console.log(greeting);`;
     expect(result).not.toContain('\n\n```');
     expect(result).not.toContain('```\n\n');
   });
-
-  describe('incomplete artifacts', () => {
-    test('should handle incomplete artifacts (missing closing ::: and ```)', () => {
-      const original = `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>Pomodoro</title>
-<meta name="description" content="A single-file Pomodoro timer with logs, charts, sounds, and dark mode." />
-<style>
-  :root{`;
-
-      const prefix = `Awesome idea! I'll deliver a complete single-file HTML app called "Pomodoro" with:
-- Custom session/break durations
-
-You can save this as pomodoro.html and open it directly in your browser.
-
-`;
-
-      // This simulates the real incomplete artifact case - no closing ``` or :::
-      const incompleteArtifact = `${ARTIFACT_START}{identifier="pomodoro-single-file-app" type="text/html" title="Pomodoro — Single File App"}
-\`\`\`
-${original}`;
-
-      const fullText = prefix + incompleteArtifact;
-      const message = { text: fullText };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-      expect(artifacts[0].end).toBe(fullText.length);
-
-      const updated = original.replace('Pomodoro</title>', 'Pomodoro</title>UPDATED');
-      const result = replaceArtifactContent(fullText, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain('UPDATED');
-      expect(result).toContain(prefix);
-      // Should not have added closing markers
-      expect(result).not.toMatch(/:::\s*$/);
-    });
-
-    test('should handle incomplete artifacts with only opening code block', () => {
-      const original = 'function hello() { console.log("world"); }';
-      const incompleteArtifact = `${ARTIFACT_START}{id="test"}\n\`\`\`\n${original}`;
-
-      const message = { text: incompleteArtifact };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-
-      const updated = 'function hello() { console.log("UPDATED"); }';
-      const result = replaceArtifactContent(incompleteArtifact, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain('UPDATED');
-    });
-
-    test('should handle incomplete artifacts without code blocks', () => {
-      const original = 'Some plain text content';
-      const incompleteArtifact = `${ARTIFACT_START}{id="test"}\n${original}`;
-
-      const message = { text: incompleteArtifact };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-
-      const updated = 'Some UPDATED text content';
-      const result = replaceArtifactContent(incompleteArtifact, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain('UPDATED');
-    });
-  });
-
-  describe('regression tests for edge cases', () => {
-    test('should still handle complete artifacts correctly', () => {
-      // Ensure we didn't break normal artifact handling
-      const original = 'console.log("test");';
-      const artifact = createArtifactText({ content: original });
-
-      const message = { text: artifact };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-
-      const updated = 'console.log("updated");';
-      const result = replaceArtifactContent(artifact, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain(updated);
-      expect(result).toContain(ARTIFACT_END);
-      expect(result).toMatch(/```\nconsole\.log\("updated"\);\n```/);
-    });
-
-    test('should handle multiple complete artifacts', () => {
-      // Ensure multiple artifacts still work
-      const content1 = 'First artifact';
-      const content2 = 'Second artifact';
-      const text = `${createArtifactText({ content: content1 })}\n\n${createArtifactText({ content: content2 })}`;
-
-      const message = { text };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(2);
-
-      // Update first artifact
-      const result1 = replaceArtifactContent(text, artifacts[0], content1, 'First UPDATED');
-      expect(result1).not.toBeNull();
-      expect(result1).toContain('First UPDATED');
-      expect(result1).toContain(content2);
-
-      // Update second artifact
-      const result2 = replaceArtifactContent(text, artifacts[1], content2, 'Second UPDATED');
-      expect(result2).not.toBeNull();
-      expect(result2).toContain(content1);
-      expect(result2).toContain('Second UPDATED');
-    });
-
-    test('should not mistake ::: at position 0 for artifact end in complete artifacts', () => {
-      // This tests the specific fix - ensuring contentEnd=0 doesn't break complete artifacts
-      const original = 'test content';
-      // Create an artifact that will have ::: at position 0 when substring'd
-      const artifact = `${ARTIFACT_START}\n\`\`\`\n${original}\n\`\`\`\n${ARTIFACT_END}`;
-
-      const message = { text: artifact };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-
-      const updated = 'updated content';
-      const result = replaceArtifactContent(artifact, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain(updated);
-      expect(result).toContain(ARTIFACT_END);
-    });
-
-    test('should handle empty artifacts', () => {
-      // Edge case: empty artifact
-      const artifact = `${ARTIFACT_START}\n${ARTIFACT_END}`;
-
-      const message = { text: artifact };
-      const artifacts = findAllArtifacts(message);
-
-      expect(artifacts).toHaveLength(1);
-
-      // Trying to replace non-existent content should return null
-      const result = replaceArtifactContent(artifact, artifacts[0], 'something', 'updated');
-      expect(result).toBeNull();
-    });
-
-    test('should preserve whitespace and formatting in complete artifacts', () => {
-      const original = `  function test() {
-    return {
-      value: 42
-    };
-  }`;
-      const artifact = createArtifactText({ content: original });
-
-      const message = { text: artifact };
-      const artifacts = findAllArtifacts(message);
-
-      const updated = `  function test() {
-    return {
-      value: 100
-    };
-  }`;
-      const result = replaceArtifactContent(artifact, artifacts[0], original, updated);
-
-      expect(result).not.toBeNull();
-      expect(result).toContain('value: 100');
-      // Should preserve exact formatting
-      expect(result).toMatch(
-        /```\n {2}function test\(\) \{\n {4}return \{\n {6}value: 100\n {4}\};\n {2}\}\n```/,
-      );
-    });
-  });
 });

api/server/services/AssistantService.js

@@ -281,7 +281,7 @@ function createInProgressHandler(openai, thread_id, messages) {
 
       openai.seenCompletedMessages.add(message_id);
 
-      const message = await openai.beta.threads.messages.retrieve(message_id, { thread_id });
+      const message = await openai.beta.threads.messages.retrieve(thread_id, message_id);
       if (!message?.content?.length) {
         return;
       }
@@ -435,11 +435,9 @@ async function runAssistant({
     };
   });
 
-  const tool_outputs = await processRequiredActions(openai, actions);
-  const toolRun = await openai.beta.threads.runs.submitToolOutputs(run.id, {
-    thread_id: run.thread_id,
-    tool_outputs,
-  });
+  const outputs = await processRequiredActions(openai, actions);
+
+  const toolRun = await openai.beta.threads.runs.submitToolOutputs(run.thread_id, run.id, outputs);
 
   // Recursive call with accumulated steps and messages
   return await runAssistant({

api/server/services/Config/loadDefaultModels.js

@@ -1,11 +1,12 @@
-const { logger } = require('@librechat/data-schemas');
 const { EModelEndpoint } = require('librechat-data-provider');
+const { useAzurePlugins } = require('~/server/services/Config/EndpointService').config;
 const {
-  getAnthropicModels,
-  getBedrockModels,
   getOpenAIModels,
   getGoogleModels,
+  getBedrockModels,
+  getAnthropicModels,
 } = require('~/server/services/ModelService');
+const { logger } = require('~/config');
 
 /**
  * Loads the default models for the application.
@@ -15,42 +16,58 @@ const {
  */
 async function loadDefaultModels(req) {
   try {
-    const [openAI, anthropic, azureOpenAI, assistants, azureAssistants, google, bedrock] =
-      await Promise.all([
-        getOpenAIModels({ user: req.user.id }).catch((error) => {
-          logger.error('Error fetching OpenAI models:', error);
+    const [
+      openAI,
+      anthropic,
+      azureOpenAI,
+      gptPlugins,
+      assistants,
+      azureAssistants,
+      google,
+      bedrock,
+    ] = await Promise.all([
+      getOpenAIModels({ user: req.user.id }).catch((error) => {
+        logger.error('Error fetching OpenAI models:', error);
+        return [];
+      }),
+      getAnthropicModels({ user: req.user.id }).catch((error) => {
+        logger.error('Error fetching Anthropic models:', error);
+        return [];
+      }),
+      getOpenAIModels({ user: req.user.id, azure: true }).catch((error) => {
+        logger.error('Error fetching Azure OpenAI models:', error);
+        return [];
+      }),
+      getOpenAIModels({ user: req.user.id, azure: useAzurePlugins, plugins: true }).catch(
+        (error) => {
+          logger.error('Error fetching Plugin models:', error);
           return [];
-        }),
-        getAnthropicModels({ user: req.user.id }).catch((error) => {
-          logger.error('Error fetching Anthropic models:', error);
-          return [];
-        }),
-        getOpenAIModels({ user: req.user.id, azure: true }).catch((error) => {
-          logger.error('Error fetching Azure OpenAI models:', error);
-          return [];
-        }),
-        getOpenAIModels({ assistants: true }).catch((error) => {
-          logger.error('Error fetching OpenAI Assistants API models:', error);
-          return [];
-        }),
-        getOpenAIModels({ azureAssistants: true }).catch((error) => {
-          logger.error('Error fetching Azure OpenAI Assistants API models:', error);
-          return [];
-        }),
-        Promise.resolve(getGoogleModels()).catch((error) => {
-          logger.error('Error getting Google models:', error);
-          return [];
-        }),
-        Promise.resolve(getBedrockModels()).catch((error) => {
-          logger.error('Error getting Bedrock models:', error);
-          return [];
-        }),
-      ]);
+        },
+      ),
+      getOpenAIModels({ assistants: true }).catch((error) => {
+        logger.error('Error fetching OpenAI Assistants API models:', error);
+        return [];
+      }),
+      getOpenAIModels({ azureAssistants: true }).catch((error) => {
+        logger.error('Error fetching Azure OpenAI Assistants API models:', error);
+        return [];
+      }),
+      Promise.resolve(getGoogleModels()).catch((error) => {
+        logger.error('Error getting Google models:', error);
+        return [];
+      }),
+      Promise.resolve(getBedrockModels()).catch((error) => {
+        logger.error('Error getting Bedrock models:', error);
+        return [];
+      }),
+    ]);
 
     return {
       [EModelEndpoint.openAI]: openAI,
+      [EModelEndpoint.agents]: openAI,
       [EModelEndpoint.google]: google,
       [EModelEndpoint.anthropic]: anthropic,
+      [EModelEndpoint.gptPlugins]: gptPlugins,
       [EModelEndpoint.azureOpenAI]: azureOpenAI,
       [EModelEndpoint.assistants]: assistants,
       [EModelEndpoint.azureAssistants]: azureAssistants,

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

@@ -1,6 +1,6 @@
-const { logger } = require('@librechat/data-schemas');
 const { isAgentsEndpoint, removeNullishValues, Constants } = require('librechat-data-provider');
 const { loadAgent } = require('~/models/Agent');
+const { logger } = require('~/config');
 
 const buildOptions = (req, endpoint, parsedBody, endpointType) => {
   const { spec, iconURL, agent_id, instructions, ...model_parameters } = parsedBody;

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

@@ -1,5 +1,4 @@
 const { logger } = require('@librechat/data-schemas');
-const { validateAgentModel } = require('@librechat/api');
 const { createContentAggregator } = require('@librechat/agents');
 const {
   Constants,
@@ -12,12 +11,10 @@ const {
   getDefaultHandlers,
 } = require('~/server/controllers/agents/callbacks');
 const { initializeAgent } = require('~/server/services/Endpoints/agents/agent');
-const { getModelsConfig } = require('~/server/controllers/ModelController');
 const { getCustomEndpointConfig } = require('~/server/services/Config');
 const { loadAgentTools } = require('~/server/services/ToolService');
 const AgentClient = require('~/server/controllers/agents/client');
 const { getAgent } = require('~/models/Agent');
-const { logViolation } = require('~/cache');
 
 function createToolLoader() {
   /**
@@ -75,19 +72,6 @@ const initializeClient = async ({ req, res, endpointOption }) => {
     throw new Error('Agent not found');
   }
 
-  const modelsConfig = await getModelsConfig(req);
-  const validationResult = await validateAgentModel({
-    req,
-    res,
-    modelsConfig,
-    logViolation,
-    agent: primaryAgent,
-  });
-
-  if (!validationResult.isValid) {
-    throw new Error(validationResult.error?.message);
-  }
-
   const agentConfigs = new Map();
   /** @type {Set<string>} */
   const allowedProviders = new Set(req?.app?.locals?.[EModelEndpoint.agents]?.allowedProviders);
@@ -117,19 +101,6 @@ const initializeClient = async ({ req, res, endpointOption }) => {
       if (!agent) {
         throw new Error(`Agent ${agentId} not found`);
       }
-
-      const validationResult = await validateAgentModel({
-        req,
-        res,
-        agent,
-        modelsConfig,
-        logViolation,
-      });
-
-      if (!validationResult.isValid) {
-        throw new Error(validationResult.error?.message);
-      }
-
       const config = await initializeAgent({
         req,
         res,

api/server/services/Endpoints/assistants/initalize.js

@@ -6,7 +6,7 @@ const {
   getUserKeyExpiry,
   checkUserKeyExpiry,
 } = require('~/server/services/UserService');
-const OAIClient = require('~/app/clients/OpenAIClient');
+const OpenAIClient = require('~/app/clients/OpenAIClient');
 const { isUserProvided } = require('~/server/utils');
 
 const initializeClient = async ({ req, res, endpointOption, version, initAppClient = false }) => {
@@ -79,7 +79,7 @@ const initializeClient = async ({ req, res, endpointOption, version, initAppClie
   openai.res = res;
 
   if (endpointOption && initAppClient) {
-    const client = new OAIClient(apiKey, clientOptions);
+    const client = new OpenAIClient(apiKey, clientOptions);
     return {
       client,
       openai,

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

@@ -3,11 +3,11 @@ const { ProxyAgent } = require('undici');
 const { constructAzureURL, isUserProvided, resolveHeaders } = require('@librechat/api');
 const { ErrorTypes, EModelEndpoint, mapModelToAzureConfig } = require('librechat-data-provider');
 const {
-  checkUserKeyExpiry,
   getUserKeyValues,
   getUserKeyExpiry,
+  checkUserKeyExpiry,
 } = require('~/server/services/UserService');
-const OAIClient = require('~/app/clients/OpenAIClient');
+const OpenAIClient = require('~/app/clients/OpenAIClient');
 
 class Files {
   constructor(client) {
@@ -184,7 +184,7 @@ const initializeClient = async ({ req, res, version, endpointOption, initAppClie
   }
 
   if (endpointOption && initAppClient) {
-    const client = new OAIClient(apiKey, clientOptions);
+    const client = new OpenAIClient(apiKey, clientOptions);
     return {
       client,
       openai,

api/server/services/Files/documents/encode.js

@@ -1,166 +0,0 @@
-const { EModelEndpoint } = require('librechat-data-provider');
-const { getStrategyFunctions } = require('~/server/services/Files/strategies');
-const { validateAnthropicPdf } = require('../validation/pdfValidator');
-
-/**
- * Converts a readable stream to a buffer.
- *
- * @param {NodeJS.ReadableStream} stream - The readable stream to convert.
- * @returns {Promise<Buffer>} - Promise resolving to the buffer.
- */
-async function streamToBuffer(stream) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-
-    stream.on('data', (chunk) => {
-      chunks.push(chunk);
-    });
-
-    stream.on('end', () => {
-      try {
-        const buffer = Buffer.concat(chunks);
-        chunks.length = 0; // Clear the array
-        resolve(buffer);
-      } catch (err) {
-        reject(err);
-      }
-    });
-
-    stream.on('error', (error) => {
-      chunks.length = 0;
-      reject(error);
-    });
-  }).finally(() => {
-    // Clean up the stream if required
-    if (stream.destroy && typeof stream.destroy === 'function') {
-      stream.destroy();
-    }
-  });
-}
-
-/**
- * Processes and encodes document files for various endpoints
- *
- * @param {Express.Request} req - Express request object
- * @param {MongoFile[]} files - Array of file objects to process
- * @param {string} endpoint - The endpoint identifier (e.g., EModelEndpoint.anthropic)
- * @returns {Promise<{documents: MessageContentDocument[], files: MongoFile[]}>}
- */
-async function encodeAndFormatDocuments(req, files, endpoint) {
-  const promises = [];
-  /** @type {Record<FileSources, Pick<ReturnType<typeof getStrategyFunctions>, 'prepareDocumentPayload' | 'getDownloadStream'>>} */
-  const encodingMethods = {};
-  /** @type {{ documents: MessageContentDocument[]; files: MongoFile[] }} */
-  const result = {
-    documents: [],
-    files: [],
-  };
-
-  if (!files || !files.length) {
-    return result;
-  }
-
-  // Filter for document files only
-  const documentFiles = files.filter(
-    (file) => file.type === 'application/pdf' || file.type?.startsWith('application/'), // Future: support for other document types
-  );
-
-  if (!documentFiles.length) {
-    return result;
-  }
-
-  for (let file of documentFiles) {
-    /** @type {FileSources} */
-    const source = file.source ?? 'local';
-
-    // Only process PDFs for Anthropic for now
-    if (file.type !== 'application/pdf' || endpoint !== EModelEndpoint.anthropic) {
-      continue;
-    }
-
-    if (!encodingMethods[source]) {
-      encodingMethods[source] = getStrategyFunctions(source);
-    }
-
-    // Prepare file metadata
-    const fileMetadata = {
-      file_id: file.file_id || file._id,
-      temp_file_id: file.temp_file_id,
-      filepath: file.filepath,
-      source: file.source,
-      filename: file.filename,
-      type: file.type,
-    };
-
-    promises.push([file, fileMetadata]);
-  }
-
-  const results = await Promise.allSettled(
-    promises.map(async ([file, fileMetadata]) => {
-      if (!file || !fileMetadata) {
-        return { file: null, content: null, metadata: fileMetadata };
-      }
-
-      try {
-        const source = file.source ?? 'local';
-        const { getDownloadStream } = encodingMethods[source];
-
-        const stream = await getDownloadStream(req, file.filepath);
-        const buffer = await streamToBuffer(stream);
-        const documentContent = buffer.toString('base64');
-
-        return {
-          file,
-          content: documentContent,
-          metadata: fileMetadata,
-        };
-      } catch (error) {
-        console.error(`Error processing document ${file.filename}:`, error);
-        return { file, content: null, metadata: fileMetadata };
-      }
-    }),
-  );
-
-  for (const settledResult of results) {
-    if (settledResult.status === 'rejected') {
-      console.error('Document processing failed:', settledResult.reason);
-      continue;
-    }
-
-    const { file, content, metadata } = settledResult.value;
-
-    if (!content || !file) {
-      if (metadata) {
-        result.files.push(metadata);
-      }
-      continue;
-    }
-
-    if (file.type === 'application/pdf' && endpoint === EModelEndpoint.anthropic) {
-      const pdfBuffer = Buffer.from(content, 'base64');
-      const validation = await validateAnthropicPdf(pdfBuffer, pdfBuffer.length);
-
-      if (!validation.isValid) {
-        throw new Error(`PDF validation failed: ${validation.error}`);
-      }
-
-      const documentPart = {
-        type: 'document',
-        source: {
-          type: 'base64',
-          media_type: 'application/pdf',
-          data: content,
-        },
-      };
-
-      result.documents.push(documentPart);
-      result.files.push(metadata);
-    }
-  }
-
-  return result;
-}
-
-module.exports = {
-  encodeAndFormatDocuments,
-};

api/server/services/Files/documents/index.js

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

api/server/services/Files/process.js

@@ -391,17 +391,7 @@ const processFileUpload = async ({ req, res, metadata }) => {
   const isAssistantUpload = isAssistantsEndpoint(metadata.endpoint);
   const assistantSource =
     metadata.endpoint === EModelEndpoint.azureAssistants ? FileSources.azure : FileSources.openai;
-
-  // Use local storage for Anthropic native PDF support, vectordb for others
-  const isAnthropicUpload = metadata.endpoint === EModelEndpoint.anthropic;
-  let source;
-  if (isAssistantUpload) {
-    source = assistantSource;
-  } else if (isAnthropicUpload) {
-    source = FileSources.local;
-  } else {
-    source = FileSources.vectordb;
-  }
+  const source = isAssistantUpload ? assistantSource : FileSources.vectordb;
   const { handleFileUpload } = getStrategyFunctions(source);
   const { file_id, temp_file_id } = metadata;
 

api/server/services/Files/validation/pdfValidator.js

@@ -1,77 +0,0 @@
-const { logger } = require('~/config');
-const { anthropicPdfSizeLimit } = require('librechat-data-provider');
-
-/**
- * Validates if a PDF meets Anthropic's requirements
- * @param {Buffer} pdfBuffer - The PDF file as a buffer
- * @param {number} fileSize - The file size in bytes
- * @returns {Promise<{isValid: boolean, error?: string}>}
- */
-async function validateAnthropicPdf(pdfBuffer, fileSize) {
-  try {
-    // Check file size (32MB limit)
-    if (fileSize > anthropicPdfSizeLimit) {
-      return {
-        isValid: false,
-        error: `PDF file size (${Math.round(fileSize / (1024 * 1024))}MB) exceeds Anthropic's 32MB limit`,
-      };
-    }
-
-    // Basic PDF header validation
-    if (!pdfBuffer || pdfBuffer.length < 5) {
-      return {
-        isValid: false,
-        error: 'Invalid PDF file: too small or corrupted',
-      };
-    }
-
-    // Check PDF magic bytes
-    const pdfHeader = pdfBuffer.subarray(0, 5).toString();
-    if (!pdfHeader.startsWith('%PDF-')) {
-      return {
-        isValid: false,
-        error: 'Invalid PDF file: missing PDF header',
-      };
-    }
-
-    // Check for password protection/encryption
-    const pdfContent = pdfBuffer.toString('binary');
-    if (
-      pdfContent.includes('/Encrypt ') ||
-      pdfContent.includes('/U (') ||
-      pdfContent.includes('/O (')
-    ) {
-      return {
-        isValid: false,
-        error: 'PDF is password-protected or encrypted. Anthropic requires unencrypted PDFs.',
-      };
-    }
-
-    // Estimate page count (this is a rough estimation)
-    const pageMatches = pdfContent.match(/\/Type[\s]*\/Page[^s]/g);
-    const estimatedPages = pageMatches ? pageMatches.length : 1;
-
-    if (estimatedPages > 100) {
-      return {
-        isValid: false,
-        error: `PDF has approximately ${estimatedPages} pages, exceeding Anthropic's 100-page limit`,
-      };
-    }
-
-    logger.debug(
-      `PDF validation passed: ${Math.round(fileSize / 1024)}KB, ~${estimatedPages} pages`,
-    );
-
-    return { isValid: true };
-  } catch (error) {
-    logger.error('PDF validation error:', error);
-    return {
-      isValid: false,
-      error: 'Failed to validate PDF file',
-    };
-  }
-}
-
-module.exports = {
-  validateAnthropicPdf,
-};

api/server/services/MCP.js

@@ -339,7 +339,7 @@ async function getServerConnectionStatus(
   serverName,
   appConnections,
   userConnections,
-  oauthServers,
+  _oauthServers,
 ) {
   const getConnectionState = () =>
     appConnections.get(serverName)?.connectionState ??
@@ -349,7 +349,36 @@ async function getServerConnectionStatus(
   const baseConnectionState = getConnectionState();
   let finalConnectionState = baseConnectionState;
 
-  if (baseConnectionState === 'disconnected' && oauthServers.has(serverName)) {
+  const mcpManager = getMCPManager(userId);
+
+  const hasOAuthConfig = mcpManager.serverRequiresOAuth(serverName);
+
+  if (hasOAuthConfig) {
+    const baseIdentifier = `mcp:${serverName}`;
+    try {
+      const accessToken = await findToken({ identifier: baseIdentifier });
+
+      if (!accessToken) {
+        // No tokens found, server should be considered disconnected regardless of in-memory state
+        finalConnectionState = 'disconnected';
+        logger.debug(
+          `[Connection Status] No OAuth tokens found for ${serverName}, marking as disconnected`,
+        );
+      } else if (baseConnectionState === 'disconnected') {
+        // Tokens exist but connection shows disconnected, check OAuth flow status
+        const { hasActiveFlow, hasFailedFlow } = await checkOAuthFlowStatus(userId, serverName);
+
+        if (hasFailedFlow) {
+          finalConnectionState = 'error';
+        } else if (hasActiveFlow) {
+          finalConnectionState = 'connecting';
+        }
+      }
+    } catch (error) {
+      logger.warn(`[Connection Status] Error checking tokens for ${serverName}:`, error);
+      finalConnectionState = 'disconnected';
+    }
+  } else if (baseConnectionState === 'disconnected') {
     const { hasActiveFlow, hasFailedFlow } = await checkOAuthFlowStatus(userId, serverName);
 
     if (hasFailedFlow) {
@@ -359,8 +388,19 @@ async function getServerConnectionStatus(
     }
   }
 
+  let requiresOAuth = hasOAuthConfig;
+  if (hasOAuthConfig) {
+    try {
+      const baseIdentifier = `mcp:${serverName}`;
+      const accessToken = await findToken({ identifier: baseIdentifier });
+      requiresOAuth = !accessToken;
+    } catch (_error) {
+      requiresOAuth = true;
+    }
+  }
+
   return {
-    requiresOAuth: oauthServers.has(serverName),
+    requiresOAuth,
     connectionState: finalConnectionState,
   };
 }

api/server/services/Runs/RunManager.js

@@ -91,10 +91,11 @@ class RunManager {
    * @param {boolean} [params.final] - The end of the run polling loop, due to `requires_action`, `cancelling`, `cancelled`, `failed`, `completed`, or `expired` statuses.
    */
   async fetchRunSteps({ openai, thread_id, run_id, runStatus, final = false }) {
-    // const { data: steps, first_id, last_id, has_more } = await openai.beta.threads.runs.steps.list(run_id, { thread_id });
+    // const { data: steps, first_id, last_id, has_more } = await openai.beta.threads.runs.steps.list(thread_id, run_id);
     const { data: _steps } = await openai.beta.threads.runs.steps.list(
+      thread_id,
       run_id,
-      { thread_id },
+      {},
       {
         timeout: 3000,
         maxRetries: 5,

api/server/services/Runs/StreamRunManager.js

@@ -573,9 +573,9 @@ class StreamRunManager {
     let toolRun;
     try {
       toolRun = this.openai.beta.threads.runs.submitToolOutputsStream(
+        run.thread_id,
         run.id,
         {
-          thread_id: run.thread_id,
           tool_outputs,
           stream: true,
         },

api/server/services/Runs/handle.js

@@ -33,7 +33,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
  * @param {string} [params.body.model] - Optional. The ID of the model to be used for this run.
  * @param {string} [params.body.instructions] - Optional. Override the default system message of the assistant.
  * @param {string} [params.body.additional_instructions] - Optional. Appends additional instructions
- * at the end of the instructions for the run. This is useful for modifying
+ * at theend of the instructions for the run. This is useful for modifying
  * the behavior on a per-run basis without overriding other instructions.
  * @param {Object[]} [params.body.tools] - Optional. Override the tools the assistant can use for this run.
  * @param {string[]} [params.body.file_ids] - Optional.
@@ -179,7 +179,7 @@ async function waitForRun({
  * @return {Promise<RunStep[]>} A promise that resolves to an array of RunStep objects.
  */
 async function _retrieveRunSteps({ openai, thread_id, run_id }) {
-  const runSteps = await openai.beta.threads.runs.steps.list(run_id, { thread_id });
+  const runSteps = await openai.beta.threads.runs.steps.list(thread_id, run_id);
   return runSteps;
 }
 

api/server/services/Threads/manage.js

@@ -192,8 +192,7 @@ async function addThreadMetadata({ openai, thread_id, messageId, messages }) {
   const promises = [];
   for (const message of messages) {
     promises.push(
-      openai.beta.threads.messages.update(message.id, {
-        thread_id,
+      openai.beta.threads.messages.update(thread_id, message.id, {
         metadata: {
           messageId,
         },
@@ -264,8 +263,7 @@ async function syncMessages({
     }
 
     modifyPromises.push(
-      openai.beta.threads.messages.update(apiMessage.id, {
-        thread_id,
+      openai.beta.threads.messages.update(thread_id, apiMessage.id, {
         metadata: {
           messageId: dbMessage.messageId,
         },
@@ -415,7 +413,7 @@ async function checkMessageGaps({
 }) {
   const promises = [];
   promises.push(openai.beta.threads.messages.list(thread_id, defaultOrderQuery));
-  promises.push(openai.beta.threads.runs.steps.list(run_id, { thread_id }));
+  promises.push(openai.beta.threads.runs.steps.list(thread_id, run_id));
   /** @type {[{ data: ThreadMessage[] }, { data: RunStep[] }]} */
   const [response, stepsResponse] = await Promise.all(promises);
 

api/server/services/ToolService.js

@@ -1,7 +1,6 @@
 const fs = require('fs');
 const path = require('path');
 const { sleep } = require('@librechat/agents');
-const { getToolkitKey } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
 const { zodToJsonSchema } = require('zod-to-json-schema');
 const { Calculator } = require('@langchain/community/tools/calculator');
@@ -12,6 +11,7 @@ const {
   ErrorTypes,
   ContentTypes,
   imageGenTools,
+  EToolResources,
   EModelEndpoint,
   actionDelimiter,
   ImageVisionTool,
@@ -40,6 +40,30 @@ const { recordUsage } = require('~/server/services/Threads');
 const { loadTools } = require('~/app/clients/tools/util');
 const { redactMessage } = require('~/config/parsers');
 
+/**
+ * @param {string} toolName
+ * @returns {string | undefined} toolKey
+ */
+function getToolkitKey(toolName) {
+  /** @type {string|undefined} */
+  let toolkitKey;
+  for (const toolkit of toolkits) {
+    if (toolName.startsWith(EToolResources.image_edit)) {
+      const splitMatches = toolkit.pluginKey.split('_');
+      const suffix = splitMatches[splitMatches.length - 1];
+      if (toolName.endsWith(suffix)) {
+        toolkitKey = toolkit.pluginKey;
+        break;
+      }
+    }
+    if (toolName.startsWith(toolkit.pluginKey)) {
+      toolkitKey = toolkit.pluginKey;
+      break;
+    }
+  }
+  return toolkitKey;
+}
+
 /**
  * Loads and formats tools from the specified tool directory.
  *
@@ -121,7 +145,7 @@ function loadAndFormatTools({ directory, adminFilter = [], adminIncluded = [] })
   for (const toolInstance of basicToolInstances) {
     const formattedTool = formatToOpenAIAssistantTool(toolInstance);
     let toolName = formattedTool[Tools.function].name;
-    toolName = getToolkitKey({ toolkits, toolName }) ?? toolName;
+    toolName = getToolkitKey(toolName) ?? toolName;
     if (filter.has(toolName) && included.size === 0) {
       continue;
     }

api/server/services/start/interface.js

@@ -2,11 +2,11 @@ const {
   SystemRoles,
   Permissions,
   PermissionTypes,
+  isMemoryEnabled,
   removeNullishValues,
 } = require('librechat-data-provider');
-const { logger } = require('@librechat/data-schemas');
-const { isMemoryEnabled } = require('@librechat/api');
 const { updateAccessPermissions } = require('~/models/Role');
+const { logger } = require('~/config');
 
 /**
  * Loads the default interface object.

api/strategies/ldapStrategy.js

@@ -1,10 +1,10 @@
 const fs = require('fs');
-const { isEnabled } = require('@librechat/api');
 const LdapStrategy = require('passport-ldapauth');
+const { SystemRoles } = require('librechat-data-provider');
 const { logger } = require('@librechat/data-schemas');
-const { SystemRoles, ErrorTypes } = require('librechat-data-provider');
 const { createUser, findUser, updateUser, countUsers } = require('~/models');
 const { getBalanceConfig } = require('~/server/services/Config');
+const { isEnabled } = require('~/server/utils');
 
 const {
   LDAP_URL,
@@ -90,14 +90,6 @@ const ldapLogin = new LdapStrategy(ldapOptions, async (userinfo, done) => {
       (LDAP_ID && userinfo[LDAP_ID]) || userinfo.uid || userinfo.sAMAccountName || userinfo.mail;
 
     let user = await findUser({ ldapId });
-    if (user && user.provider !== 'ldap') {
-      logger.info(
-        `[ldapStrategy] User ${user.email} already exists with provider ${user.provider}`,
-      );
-      return done(null, false, {
-        message: ErrorTypes.AUTH_FAILED,
-      });
-    }
 
     const fullNameAttributes = LDAP_FULL_NAME && LDAP_FULL_NAME.split(',');
     const fullName =

api/strategies/openidStrategy.js

@@ -3,9 +3,9 @@ const fetch = require('node-fetch');
 const passport = require('passport');
 const client = require('openid-client');
 const jwtDecode = require('jsonwebtoken/decode');
+const { CacheKeys } = require('librechat-data-provider');
 const { HttpsProxyAgent } = require('https-proxy-agent');
 const { hashToken, logger } = require('@librechat/data-schemas');
-const { CacheKeys, ErrorTypes } = require('librechat-data-provider');
 const { Strategy: OpenIDStrategy } = require('openid-client/passport');
 const { isEnabled, safeStringify, logHeaders } = require('@librechat/api');
 const { getStrategyFunctions } = require('~/server/services/Files/strategies');
@@ -104,14 +104,6 @@ class CustomOpenIDStrategy extends OpenIDStrategy {
     if (options?.state && !params.has('state')) {
       params.set('state', options.state);
     }
-
-    if (process.env.OPENID_AUDIENCE) {
-      params.set('audience', process.env.OPENID_AUDIENCE);
-      logger.debug(
-        `[openidStrategy] Adding audience to authorization request: ${process.env.OPENID_AUDIENCE}`,
-      );
-    }
-
     return params;
   }
 }
@@ -320,14 +312,6 @@ async function setupOpenId() {
               } for openidId: ${claims.sub}`,
             );
           }
-          if (user != null && user.provider !== 'openid') {
-            logger.info(
-              `[openidStrategy] Attempted OpenID login by user ${user.email}, was registered with "${user.provider}" provider`,
-            );
-            return done(null, false, {
-              message: ErrorTypes.AUTH_FAILED,
-            });
-          }
           const userinfo = {
             ...claims,
             ...(await getUserInfo(openidConfig, tokenset.access_token, claims.sub)),
@@ -369,7 +353,7 @@ async function setupOpenId() {
             username = userinfo[process.env.OPENID_USERNAME_CLAIM];
           } else {
             username = convertToUsername(
-              userinfo.preferred_username || userinfo.username || userinfo.email,
+              userinfo.username || userinfo.given_name || userinfo.email,
             );
           }
 

api/strategies/openidStrategy.spec.js

@@ -1,8 +1,7 @@
 const fetch = require('node-fetch');
 const jwtDecode = require('jsonwebtoken/decode');
-const { ErrorTypes } = require('librechat-data-provider');
-const { findUser, createUser, updateUser } = require('~/models');
 const { setupOpenId } = require('./openidStrategy');
+const { findUser, createUser, updateUser } = require('~/models');
 
 // --- Mocks ---
 jest.mock('node-fetch');
@@ -51,9 +50,11 @@ jest.mock('openid-client', () => {
       issuer: 'https://fake-issuer.com',
       // Add any other properties needed by the implementation
     }),
-    fetchUserInfo: jest.fn().mockImplementation(() => {
+    fetchUserInfo: jest.fn().mockImplementation((config, accessToken, sub) => {
       // Only return additional properties, but don't override any claims
-      return Promise.resolve({});
+      return Promise.resolve({
+        preferred_username: 'preferred_username',
+      });
     }),
     customFetch: Symbol('customFetch'),
   };
@@ -103,7 +104,6 @@ describe('setupOpenId', () => {
       given_name: 'First',
       family_name: 'Last',
       name: 'My Full',
-      preferred_username: 'testusername',
       username: 'flast',
       picture: 'https://example.com/avatar.png',
     }),
@@ -156,20 +156,20 @@ describe('setupOpenId', () => {
     verifyCallback = require('openid-client/passport').__getVerifyCallback();
   });
 
-  it('should create a new user with correct username when preferred_username claim exists', async () => {
-    // Arrange – our userinfo already has preferred_username 'testusername'
+  it('should create a new user with correct username when username claim exists', async () => {
+    // Arrange – our userinfo already has username 'flast'
     const userinfo = tokenset.claims();
 
     // Act
     const { user } = await validate(tokenset);
 
     // Assert
-    expect(user.username).toBe(userinfo.preferred_username);
+    expect(user.username).toBe(userinfo.username);
     expect(createUser).toHaveBeenCalledWith(
       expect.objectContaining({
         provider: 'openid',
         openidId: userinfo.sub,
-        username: userinfo.preferred_username,
+        username: userinfo.username,
         email: userinfo.email,
         name: `${userinfo.given_name} ${userinfo.family_name}`,
       }),
@@ -179,12 +179,12 @@ describe('setupOpenId', () => {
     );
   });
 
-  it('should use username as username when preferred_username claim is missing', async () => {
-    // Arrange – remove preferred_username from userinfo
+  it('should use given_name as username when username claim is missing', async () => {
+    // Arrange – remove username from userinfo
     const userinfo = { ...tokenset.claims() };
-    delete userinfo.preferred_username;
-    // Expect the username to be the "username"
-    const expectUsername = userinfo.username;
+    delete userinfo.username;
+    // Expect the username to be the given name (unchanged case)
+    const expectUsername = userinfo.given_name;
 
     // Act
     const { user } = await validate({ ...tokenset, claims: () => userinfo });
@@ -199,11 +199,11 @@ describe('setupOpenId', () => {
     );
   });
 
-  it('should use email as username when username and preferred_username are missing', async () => {
-    // Arrange – remove username and preferred_username
+  it('should use email as username when username and given_name are missing', async () => {
+    // Arrange – remove username and given_name
     const userinfo = { ...tokenset.claims() };
     delete userinfo.username;
-    delete userinfo.preferred_username;
+    delete userinfo.given_name;
     const expectUsername = userinfo.email;
 
     // Act
@@ -262,20 +262,17 @@ describe('setupOpenId', () => {
   });
 
   it('should update an existing user on login', async () => {
-    // Arrange – simulate that a user already exists with openid provider
+    // Arrange – simulate that a user already exists
     const existingUser = {
       _id: 'existingUserId',
-      provider: 'openid',
+      provider: 'local',
       email: tokenset.claims().email,
       openidId: '',
       username: '',
       name: '',
     };
     findUser.mockImplementation(async (query) => {
-      if (
-        query.openidId === tokenset.claims().sub ||
-        (query.email === tokenset.claims().email && query.provider === 'openid')
-      ) {
+      if (query.openidId === tokenset.claims().sub || query.email === tokenset.claims().email) {
         return existingUser;
       }
       return null;
@@ -292,44 +289,18 @@ describe('setupOpenId', () => {
       expect.objectContaining({
         provider: 'openid',
         openidId: userinfo.sub,
-        username: userinfo.preferred_username,
+        username: userinfo.username,
         name: `${userinfo.given_name} ${userinfo.family_name}`,
       }),
     );
   });
 
-  it('should block login when email exists with different provider', async () => {
-    // Arrange – simulate that a user exists with same email but different provider
-    const existingUser = {
-      _id: 'existingUserId',
-      provider: 'google',
-      email: tokenset.claims().email,
-      googleId: 'some-google-id',
-      username: 'existinguser',
-      name: 'Existing User',
-    };
-    findUser.mockImplementation(async (query) => {
-      if (query.email === tokenset.claims().email && !query.provider) {
-        return existingUser;
-      }
-      return null;
-    });
-
-    // Act
-    const result = await validate(tokenset);
-
-    // Assert – verify that the strategy rejects login
-    expect(result.user).toBe(false);
-    expect(result.details.message).toBe(ErrorTypes.AUTH_FAILED);
-    expect(createUser).not.toHaveBeenCalled();
-    expect(updateUser).not.toHaveBeenCalled();
-  });
-
   it('should enforce the required role and reject login if missing', async () => {
     // Arrange – simulate a token without the required role.
     jwtDecode.mockReturnValue({
       roles: ['SomeOtherRole'],
     });
+    const userinfo = tokenset.claims();
 
     // Act
     const { user, details } = await validate(tokenset);
@@ -340,6 +311,9 @@ describe('setupOpenId', () => {
   });
 
   it('should attempt to download and save the avatar if picture is provided', async () => {
+    // Arrange – ensure userinfo contains a picture URL
+    const userinfo = tokenset.claims();
+
     // Act
     const { user } = await validate(tokenset);
 

api/strategies/process.js

@@ -22,12 +22,9 @@ const handleExistingUser = async (oldUser, avatarUrl) => {
   const isLocal = fileStrategy === FileSources.local;
 
   let updatedAvatar = false;
-  const hasManualFlag =
-    typeof oldUser?.avatar === 'string' && oldUser.avatar.includes('?manual=true');
-
-  if (isLocal && (!oldUser?.avatar || !hasManualFlag)) {
+  if (isLocal && (oldUser.avatar === null || !oldUser.avatar.includes('?manual=true'))) {
     updatedAvatar = avatarUrl;
-  } else if (!isLocal && (!oldUser?.avatar || !hasManualFlag)) {
+  } else if (!isLocal && (oldUser.avatar === null || !oldUser.avatar.includes('?manual=true'))) {
     const userId = oldUser._id;
     const resizedBuffer = await resizeAvatar({
       userId,

api/strategies/process.test.js

@@ -1,164 +0,0 @@
-const { FileSources } = require('librechat-data-provider');
-const { handleExistingUser } = require('./process');
-
-jest.mock('~/server/services/Files/strategies', () => ({
-  getStrategyFunctions: jest.fn(),
-}));
-
-jest.mock('~/server/services/Files/images/avatar', () => ({
-  resizeAvatar: jest.fn(),
-}));
-
-jest.mock('~/models', () => ({
-  updateUser: jest.fn(),
-  createUser: jest.fn(),
-  getUserById: jest.fn(),
-}));
-
-jest.mock('~/server/services/Config', () => ({
-  getBalanceConfig: jest.fn(),
-}));
-
-const { getStrategyFunctions } = require('~/server/services/Files/strategies');
-const { resizeAvatar } = require('~/server/services/Files/images/avatar');
-const { updateUser } = require('~/models');
-
-describe('handleExistingUser', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    process.env.CDN_PROVIDER = FileSources.local;
-  });
-
-  it('should handle null avatar without throwing error', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: null,
-    };
-    const avatarUrl = 'https://example.com/avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should handle undefined avatar without throwing error', async () => {
-    const oldUser = {
-      _id: 'user123',
-      // avatar is undefined
-    };
-    const avatarUrl = 'https://example.com/avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should not update avatar if it has manual=true flag', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: 'https://example.com/avatar.png?manual=true',
-    };
-    const avatarUrl = 'https://example.com/new-avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).not.toHaveBeenCalled();
-  });
-
-  it('should update avatar for local storage when avatar has no manual flag', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: 'https://example.com/old-avatar.png',
-    };
-    const avatarUrl = 'https://example.com/new-avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should process avatar for non-local storage', async () => {
-    process.env.CDN_PROVIDER = 's3';
-
-    const mockProcessAvatar = jest.fn().mockResolvedValue('processed-avatar-url');
-    getStrategyFunctions.mockReturnValue({ processAvatar: mockProcessAvatar });
-    resizeAvatar.mockResolvedValue(Buffer.from('resized-image'));
-
-    const oldUser = {
-      _id: 'user123',
-      avatar: null,
-    };
-    const avatarUrl = 'https://example.com/avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(resizeAvatar).toHaveBeenCalledWith({
-      userId: 'user123',
-      input: avatarUrl,
-    });
-    expect(mockProcessAvatar).toHaveBeenCalledWith({
-      buffer: Buffer.from('resized-image'),
-      userId: 'user123',
-      manual: 'false',
-    });
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: 'processed-avatar-url' });
-  });
-
-  it('should not update if avatar already has manual flag in non-local storage', async () => {
-    process.env.CDN_PROVIDER = 's3';
-
-    const oldUser = {
-      _id: 'user123',
-      avatar: 'https://cdn.example.com/avatar.png?manual=true',
-    };
-    const avatarUrl = 'https://example.com/new-avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(resizeAvatar).not.toHaveBeenCalled();
-    expect(updateUser).not.toHaveBeenCalled();
-  });
-
-  it('should handle avatar with query parameters but without manual flag', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: 'https://example.com/avatar.png?size=large&format=webp',
-    };
-    const avatarUrl = 'https://example.com/new-avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should handle empty string avatar', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: '',
-    };
-    const avatarUrl = 'https://example.com/avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should handle avatar with manual=false parameter', async () => {
-    const oldUser = {
-      _id: 'user123',
-      avatar: 'https://example.com/avatar.png?manual=false',
-    };
-    const avatarUrl = 'https://example.com/new-avatar.png';
-
-    await handleExistingUser(oldUser, avatarUrl);
-
-    expect(updateUser).toHaveBeenCalledWith('user123', { avatar: avatarUrl });
-  });
-
-  it('should handle oldUser being null gracefully', async () => {
-    const avatarUrl = 'https://example.com/avatar.png';
-
-    // This should throw an error when trying to access oldUser._id
-    await expect(handleExistingUser(null, avatarUrl)).rejects.toThrow();
-  });
-});

api/strategies/samlStrategy.js

@@ -2,7 +2,6 @@ const fs = require('fs');
 const path = require('path');
 const fetch = require('node-fetch');
 const passport = require('passport');
-const { ErrorTypes } = require('librechat-data-provider');
 const { hashToken, logger } = require('@librechat/data-schemas');
 const { Strategy: SamlStrategy } = require('@node-saml/passport-saml');
 const { getStrategyFunctions } = require('~/server/services/Files/strategies');
@@ -204,15 +203,6 @@ async function setupSaml() {
             );
           }
 
-          if (user && user.provider !== 'saml') {
-            logger.info(
-              `[samlStrategy] User ${user.email} already exists with provider ${user.provider}`,
-            );
-            return done(null, false, {
-              message: ErrorTypes.AUTH_FAILED,
-            });
-          }
-
           const fullName = getFullName(profile);
 
           const username = convertToUsername(

api/strategies/samlStrategy.spec.js

@@ -378,11 +378,11 @@ u7wlOSk+oFzDIO/UILIA
   });
 
   it('should update an existing user on login', async () => {
-    // Set up findUser to return an existing user with saml provider
+    // Set up findUser to return an existing user
     const { findUser } = require('~/models');
     const existingUser = {
       _id: 'existing-user-id',
-      provider: 'saml',
+      provider: 'local',
       email: baseProfile.email,
       samlId: '',
       username: 'oldusername',
@@ -400,26 +400,6 @@ u7wlOSk+oFzDIO/UILIA
     expect(user.email).toBe(baseProfile.email);
   });
 
-  it('should block login when email exists with different provider', async () => {
-    // Set up findUser to return a user with different provider
-    const { findUser } = require('~/models');
-    const existingUser = {
-      _id: 'existing-user-id',
-      provider: 'google',
-      email: baseProfile.email,
-      googleId: 'some-google-id',
-      username: 'existinguser',
-      name: 'Existing User',
-    };
-    findUser.mockResolvedValue(existingUser);
-
-    const profile = { ...baseProfile };
-    const result = await validate(profile);
-
-    expect(result.user).toBe(false);
-    expect(result.details.message).toBe(require('librechat-data-provider').ErrorTypes.AUTH_FAILED);
-  });
-
   it('should attempt to download and save the avatar if picture is provided', async () => {
     const profile = { ...baseProfile };
 

api/strategies/socialLogin.js

@@ -1,7 +1,6 @@
-const { isEnabled } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
-const { ErrorTypes } = require('librechat-data-provider');
 const { createSocialUser, handleExistingUser } = require('./process');
+const { isEnabled } = require('~/server/utils');
 const { findUser } = require('~/models');
 
 const socialLogin =
@@ -12,20 +11,12 @@ const socialLogin =
         profile,
       });
 
-      const existingUser = await findUser({ email: email.trim() });
+      const oldUser = await findUser({ email: email.trim() });
       const ALLOW_SOCIAL_REGISTRATION = isEnabled(process.env.ALLOW_SOCIAL_REGISTRATION);
 
-      if (existingUser?.provider === provider) {
-        await handleExistingUser(existingUser, avatarUrl);
-        return cb(null, existingUser);
-      } else if (existingUser) {
-        logger.info(
-          `[${provider}Login] User ${email} already exists with provider ${existingUser.provider}`,
-        );
-        const error = new Error(ErrorTypes.AUTH_FAILED);
-        error.code = ErrorTypes.AUTH_FAILED;
-        error.provider = existingUser.provider;
-        return cb(error);
+      if (oldUser) {
+        await handleExistingUser(oldUser, avatarUrl);
+        return cb(null, oldUser);
       }
 
       if (ALLOW_SOCIAL_REGISTRATION) {

api/typedefs.js

@@ -1370,7 +1370,7 @@
  * @property {string} [model] - The model that the assistant used for this run.
  * @property {string} [instructions] - The instructions that the assistant used for this run.
  * @property {string} [additional_instructions] - Optional. Appends additional instructions
- * at the end of the instructions for the run. This is useful for modifying
+ * at theend of the instructions for the run. This is useful for modifying
  * @property {Tool[]} [tools] - The list of tools used for this run.
  * @property {string[]} [file_ids] - The list of File IDs used for this run.
  * @property {Object} [metadata] - Metadata associated with this run.

api/utils/tokens.js

@@ -19,9 +19,6 @@ const openAIModels = {
   'gpt-4.1': 1047576,
   'gpt-4.1-mini': 1047576,
   'gpt-4.1-nano': 1047576,
-  'gpt-5': 400000,
-  'gpt-5-mini': 400000,
-  'gpt-5-nano': 400000,
   'gpt-4o': 127500, // -500 from max
   'gpt-4o-mini': 127500, // -500 from max
   'gpt-4o-2024-05-13': 127500, // -500 from max
@@ -237,9 +234,6 @@ const aggregateModels = {
   ...xAIModels,
   // misc.
   kimi: 131000,
-  // GPT-OSS
-  'gpt-oss-20b': 131000,
-  'gpt-oss-120b': 131000,
 };
 
 const maxTokensMap = {
@@ -256,11 +250,6 @@ const modelMaxOutputs = {
   o1: 32268, // -500 from max: 32,768
   'o1-mini': 65136, // -500 from max: 65,536
   'o1-preview': 32268, // -500 from max: 32,768
-  'gpt-5': 128000,
-  'gpt-5-mini': 128000,
-  'gpt-5-nano': 128000,
-  'gpt-oss-20b': 131000,
-  'gpt-oss-120b': 131000,
   system_default: 1024,
 };
 
@@ -479,11 +468,10 @@ const tiktokenModels = new Set([
 ]);
 
 module.exports = {
+  tiktokenModels,
+  maxTokensMap,
   inputSchema,
   modelSchema,
-  maxTokensMap,
-  tiktokenModels,
-  maxOutputTokensMap,
   matchModelName,
   processModelData,
   getModelMaxTokens,

api/utils/tokens.spec.js

@@ -1,11 +1,5 @@
 const { EModelEndpoint } = require('librechat-data-provider');
-const {
-  maxOutputTokensMap,
-  getModelMaxTokens,
-  processModelData,
-  matchModelName,
-  maxTokensMap,
-} = require('./tokens');
+const { getModelMaxTokens, processModelData, matchModelName, maxTokensMap } = require('./tokens');
 
 describe('getModelMaxTokens', () => {
   test('should return correct tokens for exact match', () => {
@@ -156,35 +150,6 @@ describe('getModelMaxTokens', () => {
     );
   });
 
-  test('should return correct tokens for gpt-5 matches', () => {
-    expect(getModelMaxTokens('gpt-5')).toBe(maxTokensMap[EModelEndpoint.openAI]['gpt-5']);
-    expect(getModelMaxTokens('gpt-5-preview')).toBe(maxTokensMap[EModelEndpoint.openAI]['gpt-5']);
-    expect(getModelMaxTokens('openai/gpt-5')).toBe(maxTokensMap[EModelEndpoint.openAI]['gpt-5']);
-    expect(getModelMaxTokens('gpt-5-2025-01-30')).toBe(
-      maxTokensMap[EModelEndpoint.openAI]['gpt-5'],
-    );
-  });
-
-  test('should return correct tokens for gpt-5-mini matches', () => {
-    expect(getModelMaxTokens('gpt-5-mini')).toBe(maxTokensMap[EModelEndpoint.openAI]['gpt-5-mini']);
-    expect(getModelMaxTokens('gpt-5-mini-preview')).toBe(
-      maxTokensMap[EModelEndpoint.openAI]['gpt-5-mini'],
-    );
-    expect(getModelMaxTokens('openai/gpt-5-mini')).toBe(
-      maxTokensMap[EModelEndpoint.openAI]['gpt-5-mini'],
-    );
-  });
-
-  test('should return correct tokens for gpt-5-nano matches', () => {
-    expect(getModelMaxTokens('gpt-5-nano')).toBe(maxTokensMap[EModelEndpoint.openAI]['gpt-5-nano']);
-    expect(getModelMaxTokens('gpt-5-nano-preview')).toBe(
-      maxTokensMap[EModelEndpoint.openAI]['gpt-5-nano'],
-    );
-    expect(getModelMaxTokens('openai/gpt-5-nano')).toBe(
-      maxTokensMap[EModelEndpoint.openAI]['gpt-5-nano'],
-    );
-  });
-
   test('should return correct tokens for Anthropic models', () => {
     const models = [
       'claude-2.1',
@@ -384,39 +349,6 @@ describe('getModelMaxTokens', () => {
     expect(getModelMaxTokens('o3')).toBe(o3Tokens);
     expect(getModelMaxTokens('openai/o3')).toBe(o3Tokens);
   });
-
-  test('should return correct tokens for GPT-OSS models', () => {
-    const expected = maxTokensMap[EModelEndpoint.openAI]['gpt-oss-20b'];
-    ['gpt-oss-20b', 'gpt-oss-120b', 'openai/gpt-oss-20b', 'openai/gpt-oss-120b'].forEach((name) => {
-      expect(getModelMaxTokens(name)).toBe(expected);
-    });
-  });
-
-  test('should return correct max output tokens for GPT-5 models', () => {
-    const { getModelMaxOutputTokens } = require('./tokens');
-    ['gpt-5', 'gpt-5-mini', 'gpt-5-nano'].forEach((model) => {
-      expect(getModelMaxOutputTokens(model)).toBe(maxOutputTokensMap[EModelEndpoint.openAI][model]);
-      expect(getModelMaxOutputTokens(model, EModelEndpoint.openAI)).toBe(
-        maxOutputTokensMap[EModelEndpoint.openAI][model],
-      );
-      expect(getModelMaxOutputTokens(model, EModelEndpoint.azureOpenAI)).toBe(
-        maxOutputTokensMap[EModelEndpoint.azureOpenAI][model],
-      );
-    });
-  });
-
-  test('should return correct max output tokens for GPT-OSS models', () => {
-    const { getModelMaxOutputTokens } = require('./tokens');
-    ['gpt-oss-20b', 'gpt-oss-120b'].forEach((model) => {
-      expect(getModelMaxOutputTokens(model)).toBe(maxOutputTokensMap[EModelEndpoint.openAI][model]);
-      expect(getModelMaxOutputTokens(model, EModelEndpoint.openAI)).toBe(
-        maxOutputTokensMap[EModelEndpoint.openAI][model],
-      );
-      expect(getModelMaxOutputTokens(model, EModelEndpoint.azureOpenAI)).toBe(
-        maxOutputTokensMap[EModelEndpoint.azureOpenAI][model],
-      );
-    });
-  });
 });
 
 describe('matchModelName', () => {
@@ -488,25 +420,6 @@ describe('matchModelName', () => {
     expect(matchModelName('gpt-4.1-nano-2024-08-06')).toBe('gpt-4.1-nano');
   });
 
-  it('should return the closest matching key for gpt-5 matches', () => {
-    expect(matchModelName('openai/gpt-5')).toBe('gpt-5');
-    expect(matchModelName('gpt-5-preview')).toBe('gpt-5');
-    expect(matchModelName('gpt-5-2025-01-30')).toBe('gpt-5');
-    expect(matchModelName('gpt-5-2025-01-30-0130')).toBe('gpt-5');
-  });
-
-  it('should return the closest matching key for gpt-5-mini matches', () => {
-    expect(matchModelName('openai/gpt-5-mini')).toBe('gpt-5-mini');
-    expect(matchModelName('gpt-5-mini-preview')).toBe('gpt-5-mini');
-    expect(matchModelName('gpt-5-mini-2025-01-30')).toBe('gpt-5-mini');
-  });
-
-  it('should return the closest matching key for gpt-5-nano matches', () => {
-    expect(matchModelName('openai/gpt-5-nano')).toBe('gpt-5-nano');
-    expect(matchModelName('gpt-5-nano-preview')).toBe('gpt-5-nano');
-    expect(matchModelName('gpt-5-nano-2025-01-30')).toBe('gpt-5-nano');
-  });
-
   // Tests for Google models
   it('should return the exact model name if it exists in maxTokensMap - Google models', () => {
     expect(matchModelName('text-bison-32k', EModelEndpoint.google)).toBe('text-bison-32k');

client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/frontend",
-  "version": "v0.8.0-rc2",
+  "version": "v0.7.9",
   "description": "",
   "type": "module",
   "scripts": {

client/src/Providers/ArtifactsContext.tsx

@@ -1,46 +0,0 @@
-import React, { createContext, useContext, useMemo } from 'react';
-import type { TMessage } from 'librechat-data-provider';
-import { useChatContext } from './ChatContext';
-import { getLatestText } from '~/utils';
-
-interface ArtifactsContextValue {
-  isSubmitting: boolean;
-  latestMessageId: string | null;
-  latestMessageText: string;
-  conversationId: string | null;
-}
-
-const ArtifactsContext = createContext<ArtifactsContextValue | undefined>(undefined);
-
-export function ArtifactsProvider({ children }: { children: React.ReactNode }) {
-  const { isSubmitting, latestMessage, conversation } = useChatContext();
-
-  const latestMessageText = useMemo(() => {
-    return getLatestText({
-      messageId: latestMessage?.messageId ?? null,
-      text: latestMessage?.text ?? null,
-      content: latestMessage?.content ?? null,
-    } as TMessage);
-  }, [latestMessage?.messageId, latestMessage?.text, latestMessage?.content]);
-
-  /** Context value only created when relevant values change */
-  const contextValue = useMemo<ArtifactsContextValue>(
-    () => ({
-      isSubmitting,
-      latestMessageText,
-      latestMessageId: latestMessage?.messageId ?? null,
-      conversationId: conversation?.conversationId ?? null,
-    }),
-    [isSubmitting, latestMessage?.messageId, latestMessageText, conversation?.conversationId],
-  );
-
-  return <ArtifactsContext.Provider value={contextValue}>{children}</ArtifactsContext.Provider>;
-}
-
-export function useArtifactsContext() {
-  const context = useContext(ArtifactsContext);
-  if (!context) {
-    throw new Error('useArtifactsContext must be used within ArtifactsProvider');
-  }
-  return context;
-}

client/src/Providers/index.ts

@@ -23,5 +23,4 @@ export * from './SetConvoContext';
 export * from './SearchContext';
 export * from './BadgeRowContext';
 export * from './SidePanelContext';
-export * from './ArtifactsContext';
 export { default as BadgeRowProvider } from './BadgeRowContext';

client/src/components/Artifacts/ArtifactCodeEditor.tsx

@@ -1,5 +1,5 @@
 import debounce from 'lodash/debounce';
-import React, { useMemo, useState, useEffect, useCallback } from 'react';
+import React, { memo, useEffect, useMemo, useCallback } from 'react';
 import {
   useSandpack,
   SandpackCodeEditor,
@@ -10,8 +10,8 @@ import type { SandpackBundlerFile } from '@codesandbox/sandpack-client';
 import type { CodeEditorRef } from '@codesandbox/sandpack-react';
 import type { ArtifactFiles, Artifact } from '~/common';
 import { useEditArtifact, useGetStartupConfig } from '~/data-provider';
-import { useEditorContext, useArtifactsContext } from '~/Providers';
 import { sharedFiles, sharedOptions } from '~/utils/artifacts';
+import { useEditorContext } from '~/Providers';
 
 const createDebouncedMutation = (
   callback: (params: {
@@ -29,21 +29,18 @@ const CodeEditor = ({
   editorRef,
 }: {
   fileKey: string;
-  readOnly?: boolean;
+  readOnly: boolean;
   artifact: Artifact;
   editorRef: React.MutableRefObject<CodeEditorRef>;
 }) => {
   const { sandpack } = useSandpack();
-  const [currentUpdate, setCurrentUpdate] = useState<string | null>(null);
   const { isMutating, setIsMutating, setCurrentCode } = useEditorContext();
   const editArtifact = useEditArtifact({
-    onMutate: (vars) => {
+    onMutate: () => {
       setIsMutating(true);
-      setCurrentUpdate(vars.updated);
     },
     onSuccess: () => {
       setIsMutating(false);
-      setCurrentUpdate(null);
     },
     onError: () => {
       setIsMutating(false);
@@ -74,14 +71,8 @@ const CodeEditor = ({
     }
 
     const currentCode = (sandpack.files['/' + fileKey] as SandpackBundlerFile | undefined)?.code;
-    const isNotOriginal =
-      currentCode && artifact.content != null && currentCode.trim() !== artifact.content.trim();
-    const isNotRepeated =
-      currentUpdate == null
-        ? true
-        : currentCode != null && currentCode.trim() !== currentUpdate.trim();
 
-    if (artifact.content && isNotOriginal && isNotRepeated) {
+    if (currentCode && artifact.content != null && currentCode.trim() !== artifact.content.trim()) {
       setCurrentCode(currentCode);
       debouncedMutation({
         index: artifact.index,
@@ -101,9 +92,8 @@ const CodeEditor = ({
     artifact.messageId,
     readOnly,
     isMutating,
-    currentUpdate,
-    setIsMutating,
     sandpack.files,
+    setIsMutating,
     setCurrentCode,
     debouncedMutation,
   ]);
@@ -112,32 +102,33 @@ const CodeEditor = ({
     <SandpackCodeEditor
       ref={editorRef}
       showTabs={false}
+      readOnly={readOnly}
       showRunButton={false}
       showLineNumbers={true}
       showInlineErrors={true}
-      readOnly={readOnly === true}
       className="hljs language-javascript bg-black"
     />
   );
 };
 
-export const ArtifactCodeEditor = function ({
+export const ArtifactCodeEditor = memo(function ({
   files,
   fileKey,
   template,
   artifact,
   editorRef,
   sharedProps,
+  isSubmitting,
 }: {
   fileKey: string;
   artifact: Artifact;
   files: ArtifactFiles;
+  isSubmitting: boolean;
   template: SandpackProviderProps['template'];
   sharedProps: Partial<SandpackProviderProps>;
   editorRef: React.MutableRefObject<CodeEditorRef>;
 }) {
   const { data: config } = useGetStartupConfig();
-  const { isSubmitting } = useArtifactsContext();
   const options: typeof sharedOptions = useMemo(() => {
     if (!config) {
       return sharedOptions;
@@ -147,10 +138,6 @@ export const ArtifactCodeEditor = function ({
       bundlerURL: template === 'static' ? config.staticBundlerURL : config.bundlerURL,
     };
   }, [config, template]);
-  const [readOnly, setReadOnly] = useState(isSubmitting ?? false);
-  useEffect(() => {
-    setReadOnly(isSubmitting ?? false);
-  }, [isSubmitting]);
 
   if (Object.keys(files).length === 0) {
     return null;
@@ -167,7 +154,12 @@ export const ArtifactCodeEditor = function ({
       {...sharedProps}
       template={template}
     >
-      <CodeEditor fileKey={fileKey} artifact={artifact} editorRef={editorRef} readOnly={readOnly} />
+      <CodeEditor
+        editorRef={editorRef}
+        fileKey={fileKey}
+        readOnly={isSubmitting}
+        artifact={artifact}
+      />
     </StyledProvider>
   );
-};
+});

client/src/components/Artifacts/ArtifactTabs.tsx

@@ -2,12 +2,12 @@ import { useRef, useEffect } from 'react';
 import * as Tabs from '@radix-ui/react-tabs';
 import type { SandpackPreviewRef, CodeEditorRef } from '@codesandbox/sandpack-react';
 import type { Artifact } from '~/common';
-import { useEditorContext, useArtifactsContext } from '~/Providers';
 import useArtifactProps from '~/hooks/Artifacts/useArtifactProps';
 import { useAutoScroll } from '~/hooks/Artifacts/useAutoScroll';
 import { ArtifactCodeEditor } from './ArtifactCodeEditor';
 import { useGetStartupConfig } from '~/data-provider';
 import { ArtifactPreview } from './ArtifactPreview';
+import { useEditorContext } from '~/Providers';
 import { cn } from '~/utils';
 
 export default function ArtifactTabs({
@@ -15,13 +15,14 @@ export default function ArtifactTabs({
   isMermaid,
   editorRef,
   previewRef,
+  isSubmitting,
 }: {
   artifact: Artifact;
   isMermaid: boolean;
+  isSubmitting: boolean;
   editorRef: React.MutableRefObject<CodeEditorRef>;
   previewRef: React.MutableRefObject<SandpackPreviewRef>;
 }) {
-  const { isSubmitting } = useArtifactsContext();
   const { currentCode, setCurrentCode } = useEditorContext();
   const { data: startupConfig } = useGetStartupConfig();
   const lastIdRef = useRef<string | null>(null);
@@ -51,6 +52,7 @@ export default function ArtifactTabs({
           artifact={artifact}
           editorRef={editorRef}
           sharedProps={sharedProps}
+          isSubmitting={isSubmitting}
         />
       </Tabs.Content>
       <Tabs.Content

client/src/components/Artifacts/Artifacts.tsx

@@ -29,6 +29,7 @@ export default function Artifacts() {
     isMermaid,
     setActiveTab,
     currentIndex,
+    isSubmitting,
     cycleArtifact,
     currentArtifact,
     orderedArtifactIds,
@@ -115,6 +116,7 @@ export default function Artifacts() {
           <ArtifactTabs
             isMermaid={isMermaid}
             artifact={currentArtifact}
+            isSubmitting={isSubmitting}
             editorRef={editorRef as React.MutableRefObject<CodeEditorRef>}
             previewRef={previewRef as React.MutableRefObject<SandpackPreviewRef>}
           />

client/src/components/Auth/Login.tsx

@@ -1,7 +1,6 @@
-import { useEffect, useState } from 'react';
-import { ErrorTypes } from 'librechat-data-provider';
-import { OpenIDIcon, useToastContext } from '@librechat/client';
 import { useOutletContext, useSearchParams } from 'react-router-dom';
+import { useEffect, useState } from 'react';
+import { OpenIDIcon } from '@librechat/client';
 import type { TLoginLayoutContext } from '~/common';
 import { ErrorMessage } from '~/components/Auth/ErrorMessage';
 import SocialButton from '~/components/Auth/SocialButton';
@@ -12,7 +11,6 @@ import LoginForm from './LoginForm';
 
 function Login() {
   const localize = useLocalize();
-  const { showToast } = useToastContext();
   const { error, setError, login } = useAuthContext();
   const { startupConfig } = useOutletContext<TLoginLayoutContext>();
 
@@ -23,19 +21,6 @@ function Login() {
   // Persist the disable flag locally so that once detected, auto-redirect stays disabled.
   const [isAutoRedirectDisabled, setIsAutoRedirectDisabled] = useState(disableAutoRedirect);
 
-  useEffect(() => {
-    const oauthError = searchParams?.get('error');
-    if (oauthError && oauthError === ErrorTypes.AUTH_FAILED) {
-      showToast({
-        message: localize('com_auth_error_oauth_failed'),
-        status: 'error',
-      });
-      const newParams = new URLSearchParams(searchParams);
-      newParams.delete('error');
-      setSearchParams(newParams, { replace: true });
-    }
-  }, [searchParams, setSearchParams, showToast, localize]);
-
   // Once the disable flag is detected, update local state and remove the parameter from the URL.
   useEffect(() => {
     if (disableAutoRedirect) {

client/src/components/Chat/Input/Files/AttachFileChat.tsx

@@ -36,7 +36,6 @@ function AttachFileChat({ disableInputs }: { disableInputs: boolean }) {
         disabled={disableInputs}
         conversationId={conversationId}
         endpointFileConfig={endpointFileConfig}
-        endpoint={endpoint}
       />
     );
   }

client/src/components/Chat/Input/Files/AttachFileMenu.tsx

@@ -1,7 +1,7 @@
 import React, { useRef, useState, useMemo } from 'react';
 import * as Ariakit from '@ariakit/react';
 import { useSetRecoilState } from 'recoil';
-import { FileSearch, ImageUpIcon, TerminalSquareIcon, FileType2Icon, FileText } from 'lucide-react';
+import { FileSearch, ImageUpIcon, TerminalSquareIcon, FileType2Icon } from 'lucide-react';
 import { FileUpload, TooltipAnchor, DropdownPopup, AttachmentIcon } from '@librechat/client';
 import { EToolResources, EModelEndpoint, defaultAgentCapabilities } from 'librechat-data-provider';
 import type { EndpointFileConfig } from 'librechat-data-provider';
@@ -13,15 +13,9 @@ interface AttachFileMenuProps {
   conversationId: string;
   disabled?: boolean | null;
   endpointFileConfig?: EndpointFileConfig;
-  endpoint?: string | null;
 }
 
-const AttachFileMenu = ({
-  disabled,
-  conversationId,
-  endpointFileConfig,
-  endpoint,
-}: AttachFileMenuProps) => {
+const AttachFileMenu = ({ disabled, conversationId, endpointFileConfig }: AttachFileMenuProps) => {
   const localize = useLocalize();
   const isUploadDisabled = disabled ?? false;
   const inputRef = useRef<HTMLInputElement>(null);
@@ -29,7 +23,7 @@ const AttachFileMenu = ({
   const setEphemeralAgent = useSetRecoilState(ephemeralAgentByConvoId(conversationId));
   const [toolResource, setToolResource] = useState<EToolResources | undefined>();
   const { handleFileChange } = useFileHandling({
-    overrideEndpoint: endpoint === EModelEndpoint.anthropic ? undefined : EModelEndpoint.agents,
+    overrideEndpoint: EModelEndpoint.agents,
     overrideEndpointFileConfig: endpointFileConfig,
   });
 
@@ -40,18 +34,12 @@ const AttachFileMenu = ({
    * */
   const capabilities = useAgentCapabilities(agentsConfig?.capabilities ?? defaultAgentCapabilities);
 
-  const handleUploadClick = (fileType?: 'image' | 'document') => {
+  const handleUploadClick = (isImage?: boolean) => {
     if (!inputRef.current) {
       return;
     }
     inputRef.current.value = '';
-    if (fileType === 'image') {
-      inputRef.current.accept = 'image/*';
-    } else if (fileType === 'document') {
-      inputRef.current.accept = '.pdf,application/pdf';
-    } else {
-      inputRef.current.accept = '';
-    }
+    inputRef.current.accept = isImage === true ? 'image/*' : '';
     inputRef.current.click();
     inputRef.current.accept = '';
   };
@@ -62,24 +50,12 @@ const AttachFileMenu = ({
         label: localize('com_ui_upload_image_input'),
         onClick: () => {
           setToolResource(undefined);
-          handleUploadClick('image');
+          handleUploadClick(true);
         },
         icon: <ImageUpIcon className="icon-md" />,
       },
     ];
 
-    // Add document upload option for Anthropic endpoints
-    if (endpoint === EModelEndpoint.anthropic) {
-      items.push({
-        label: 'Upload to Provider',
-        onClick: () => {
-          setToolResource(undefined);
-          handleUploadClick('document');
-        },
-        icon: <FileText className="icon-md" />,
-      });
-    }
-
     if (capabilities.ocrEnabled) {
       items.push({
         label: localize('com_ui_upload_ocr_text'),
@@ -119,7 +95,7 @@ const AttachFileMenu = ({
     }
 
     return items;
-  }, [capabilities, localize, setToolResource, setEphemeralAgent, endpoint]);
+  }, [capabilities, localize, setToolResource, setEphemeralAgent]);
 
   const menuTrigger = (
     <TooltipAnchor

client/src/components/Chat/Presentation.tsx

@@ -4,7 +4,7 @@ import { FileSources, LocalStorageKeys } from 'librechat-data-provider';
 import type { ExtendedFile } from '~/common';
 import { useDeleteFilesMutation } from '~/data-provider';
 import DragDropWrapper from '~/components/Chat/Input/Files/DragDropWrapper';
-import { EditorProvider, SidePanelProvider, ArtifactsProvider } from '~/Providers';
+import { EditorProvider, SidePanelProvider } from '~/Providers';
 import Artifacts from '~/components/Artifacts/Artifacts';
 import { SidePanelGroup } from '~/components/SidePanel';
 import { useSetFilesToDelete } from '~/hooks';
@@ -66,11 +66,9 @@ export default function Presentation({ children }: { children: React.ReactNode }
           defaultCollapsed={defaultCollapsed}
           artifacts={
             artifactsVisibility === true && Object.keys(artifacts ?? {}).length > 0 ? (
-              <ArtifactsProvider>
-                <EditorProvider>
-                  <Artifacts />
-                </EditorProvider>
-              </ArtifactsProvider>
+              <EditorProvider>
+                <Artifacts />
+              </EditorProvider>
             ) : null
           }
         >

client/src/components/Endpoints/MessageEndpointIcon.tsx

@@ -25,7 +25,7 @@ type EndpointIcon = {
 
 function getOpenAIColor(_model: string | null | undefined) {
   const model = _model?.toLowerCase() ?? '';
-  if (model && (/\b(o\d)\b/i.test(model) || /\bgpt-[5-9]\b/i.test(model))) {
+  if (model && /\b(o\d)\b/i.test(model)) {
     return '#000000';
   }
   return model.includes('gpt-4') ? '#AB68FF' : '#19C37D';

client/src/components/MCP/CustomUserVarsSection.tsx

@@ -1,6 +1,6 @@
 import React, { useMemo } from 'react';
 import { useForm, Controller } from 'react-hook-form';
-import { Input, Label, Button, TooltipAnchor, CircleHelpIcon } from '@librechat/client';
+import { Input, Label, Button } from '@librechat/client';
 import { useMCPAuthValuesQuery } from '~/data-provider/Tools/queries';
 import { useLocalize } from '~/hooks';
 
@@ -31,25 +31,16 @@ function AuthField({ name, config, hasValue, control, errors }: AuthFieldProps)
   return (
     <div className="space-y-2">
       <div className="flex items-center justify-between">
-        <TooltipAnchor
-          enableHTML={true}
-          description={config.description || ''}
-          render={
-            <div className="flex items-center gap-2">
-              <Label htmlFor={name} className="text-sm font-medium">
-                {config.title}
-              </Label>
-              <CircleHelpIcon className="h-6 w-6 cursor-help text-text-secondary transition-colors hover:text-text-primary" />
-            </div>
-          }
-        />
+        <Label htmlFor={name} className="text-sm font-medium">
+          {config.title}
+        </Label>
         {hasValue ? (
-          <div className="flex min-w-fit items-center gap-2 whitespace-nowrap rounded-full border border-border-light px-2 py-0.5 text-xs font-medium text-text-secondary">
+          <div className="flex min-w-fit items-center gap-2 whitespace-nowrap rounded-full border border-border-medium px-2 py-0.5 text-xs font-medium text-text-secondary">
             <div className="h-1.5 w-1.5 rounded-full bg-green-500" />
             <span>{localize('com_ui_set')}</span>
           </div>
         ) : (
-          <div className="flex min-w-fit items-center gap-2 whitespace-nowrap rounded-full border border-border-light px-2 py-0.5 text-xs font-medium text-text-secondary">
+          <div className="flex min-w-fit items-center gap-2 whitespace-nowrap rounded-full border border-border-medium px-2 py-0.5 text-xs font-medium text-text-secondary">
             <div className="h-1.5 w-1.5 rounded-full border border-border-medium" />
             <span>{localize('com_ui_unset')}</span>
           </div>
@@ -69,10 +60,16 @@ function AuthField({ name, config, hasValue, control, errors }: AuthFieldProps)
                 ? localize('com_ui_mcp_update_var', { 0: config.title })
                 : localize('com_ui_mcp_enter_var', { 0: config.title })
             }
-            className="w-full shadow-sm sm:text-sm"
+            className="w-full rounded-md border-gray-300 shadow-sm focus:border-indigo-500 focus:ring-indigo-500 dark:border-gray-600 dark:bg-gray-700 dark:text-white sm:text-sm"
           />
         )}
       />
+      {config.description && (
+        <p
+          className="text-xs text-text-secondary [&_a]:text-blue-500 [&_a]:hover:text-blue-600 dark:[&_a]:text-blue-400 dark:[&_a]:hover:text-blue-300"
+          dangerouslySetInnerHTML={{ __html: config.description }}
+        />
+      )}
       {errors[name] && <p className="text-xs text-red-500">{errors[name]?.message}</p>}
     </div>
   );
@@ -117,11 +114,15 @@ export default function CustomUserVarsSection({
   };
 
   if (!fields || Object.keys(fields).length === 0) {
-    return null;
+    return (
+      <div className="p-4 text-center text-sm text-gray-500">
+        {localize('com_sidepanel_mcp_no_custom_vars', { '0': serverName })}
+      </div>
+    );
   }
 
   return (
-    <div className="flex-1 space-y-4">
+    <div className="space-y-4">
       <form onSubmit={handleSubmit(onFormSubmit)} className="space-y-4">
         {Object.entries(fields).map(([key, config]) => {
           const hasValue = authValuesData?.authValueFlags?.[key] || false;
@@ -139,11 +140,21 @@ export default function CustomUserVarsSection({
         })}
       </form>
 
-      <div className="flex justify-end gap-2">
-        <Button onClick={handleRevokeClick} variant="destructive" disabled={isSubmitting}>
+      <div className="flex justify-end gap-2 pt-2">
+        <Button
+          onClick={handleRevokeClick}
+          className="bg-red-600 text-white hover:bg-red-700 dark:hover:bg-red-800"
+          disabled={isSubmitting}
+          size="sm"
+        >
           {localize('com_ui_revoke')}
         </Button>
-        <Button onClick={handleSubmit(onFormSubmit)} variant="submit" disabled={isSubmitting}>
+        <Button
+          onClick={handleSubmit(onFormSubmit)}
+          className="bg-green-500 text-white hover:bg-green-600"
+          disabled={isSubmitting}
+          size="sm"
+        >
           {isSubmitting ? localize('com_ui_saving') : localize('com_ui_save')}
         </Button>
       </div>

client/src/components/MCP/MCPConfigDialog.tsx

@@ -1,11 +1,11 @@
 import React from 'react';
-import { KeyRound, PlugZap, AlertTriangle } from 'lucide-react';
+import { Loader2, KeyRound, PlugZap, AlertTriangle } from 'lucide-react';
 import {
-  Spinner,
   OGDialog,
   OGDialogTitle,
   OGDialogHeader,
   OGDialogContent,
+  OGDialogDescription,
 } from '@librechat/client';
 import type { MCPServerStatus } from 'librechat-data-provider';
 import ServerInitializationSection from './ServerInitializationSection';
@@ -45,6 +45,9 @@ export default function MCPConfigDialog({
   const dialogTitle = hasFields
     ? localize('com_ui_configure_mcp_variables_for', { 0: serverName })
     : `${serverName} MCP Server`;
+  const dialogDescription = hasFields
+    ? localize('com_ui_mcp_dialog_desc')
+    : `Manage connection and settings for the ${serverName} MCP server.`;
 
   // Helper function to render status badge based on connection state
   const renderStatusBadge = () => {
@@ -57,7 +60,7 @@ export default function MCPConfigDialog({
     if (connectionState === 'connecting') {
       return (
         <div className="flex items-center gap-2 rounded-full bg-blue-50 px-2 py-0.5 text-xs font-medium text-blue-600 dark:bg-blue-950 dark:text-blue-400">
-          <Spinner className="h-3 w-3" />
+          <Loader2 className="h-3 w-3 animate-spin" />
           <span>{localize('com_ui_connecting')}</span>
         </div>
       );
@@ -104,30 +107,32 @@ export default function MCPConfigDialog({
 
   return (
     <OGDialog open={isOpen} onOpenChange={onOpenChange}>
-      <OGDialogContent className="flex max-h-screen w-11/12 max-w-lg flex-col space-y-2">
+      <OGDialogContent className="flex max-h-[90vh] w-full max-w-md flex-col">
         <OGDialogHeader>
           <div className="flex items-center gap-3">
-            <OGDialogTitle className="text-xl">
-              {dialogTitle.charAt(0).toUpperCase() + dialogTitle.slice(1)}
-            </OGDialogTitle>
+            <OGDialogTitle>{dialogTitle}</OGDialogTitle>
             {renderStatusBadge()}
           </div>
+          <OGDialogDescription>{dialogDescription}</OGDialogDescription>
         </OGDialogHeader>
 
-        {/* Custom User Variables Section */}
-        <CustomUserVarsSection
-          serverName={serverName}
-          fields={fieldsSchema}
-          onSave={onSave}
-          onRevoke={onRevoke || (() => {})}
-          isSubmitting={isSubmitting}
-        />
+        {/* Content */}
+        <div className="flex-1 overflow-y-auto p-6">
+          {/* Custom User Variables Section */}
+          <CustomUserVarsSection
+            serverName={serverName}
+            fields={fieldsSchema}
+            onSave={onSave}
+            onRevoke={onRevoke || (() => {})}
+            isSubmitting={isSubmitting}
+          />
+        </div>
 
-        {/* Server Initialization Section */}
+        {/* Server Initialization Section - Always show for OAuth servers or when custom vars exist */}
         <ServerInitializationSection
           serverName={serverName}
           requiresOAuth={serverStatus?.requiresOAuth || false}
-          hasCustomUserVars={fieldsSchema && Object.keys(fieldsSchema).length > 0}
+          hasCustomUserVars={hasFields}
         />
       </OGDialogContent>
     </OGDialog>

client/src/components/MCP/MCPServerStatusIcon.tsx

@@ -1,6 +1,5 @@
 import React from 'react';
-import { Spinner } from '@librechat/client';
-import { SettingsIcon, AlertTriangle, KeyRound, PlugZap, X } from 'lucide-react';
+import { SettingsIcon, AlertTriangle, Loader2, KeyRound, PlugZap, X } from 'lucide-react';
 import type { MCPServerStatus, TPlugin } from 'librechat-data-provider';
 import { useLocalize } from '~/hooks';
 
@@ -74,8 +73,8 @@ export default function MCPServerStatusIcon({
   }
 
   if (connectionState === 'connected') {
-    // Only show config button if there are customUserVars to configure
-    if (hasCustomUserVars) {
+    // Show config button if there are customUserVars to configure OR if it's an OAuth server (for revoke functionality)
+    if (hasCustomUserVars || requiresOAuth) {
       const isAuthenticated = tool?.authenticated || requiresOAuth;
       return (
         <AuthenticatedStatusIcon
@@ -85,7 +84,7 @@ export default function MCPServerStatusIcon({
         />
       );
     }
-    return null; // No config button for connected servers without customUserVars
+    return null; // No config button for connected servers without customUserVars or OAuth
   }
 
   return null;
@@ -97,12 +96,12 @@ function InitializingStatusIcon({ serverName, onCancel, canCancel }: Initializin
       <button
         type="button"
         onClick={onCancel}
-        className="group flex h-6 w-6 items-center justify-center rounded p-1 hover:bg-red-100 dark:hover:bg-red-900/20"
+        className="flex h-6 w-6 items-center justify-center rounded p-1 hover:bg-red-100 dark:hover:bg-red-900/20"
         aria-label={localize('com_ui_cancel')}
         title={localize('com_ui_cancel')}
       >
-        <div className="relative h-4 w-4">
-          <Spinner className="h-4 w-4 group-hover:opacity-0" />
+        <div className="group relative h-4 w-4">
+          <Loader2 className="h-4 w-4 animate-spin text-blue-500 group-hover:opacity-0" />
           <X className="absolute inset-0 h-4 w-4 text-red-500 opacity-0 group-hover:opacity-100" />
         </div>
       </button>
@@ -111,8 +110,8 @@ function InitializingStatusIcon({ serverName, onCancel, canCancel }: Initializin
 
   return (
     <div className="flex h-6 w-6 items-center justify-center rounded p-1">
-      <Spinner
-        className="h-4 w-4"
+      <Loader2
+        className="h-4 w-4 animate-spin text-blue-500"
         aria-label={localize('com_nav_mcp_status_connecting', { 0: serverName })}
       />
     </div>
@@ -122,8 +121,8 @@ function InitializingStatusIcon({ serverName, onCancel, canCancel }: Initializin
 function ConnectingStatusIcon({ serverName }: StatusIconProps) {
   return (
     <div className="flex h-6 w-6 items-center justify-center rounded p-1">
-      <Spinner
-        className="h-4 w-4"
+      <Loader2
+        className="h-4 w-4 animate-spin text-blue-500"
         aria-label={localize('com_nav_mcp_status_connecting', { 0: serverName })}
       />
     </div>

client/src/components/MCP/ServerInitializationSection.tsx

@@ -1,28 +1,28 @@
-import React from 'react';
-import { RefreshCw } from 'lucide-react';
-import { Button, Spinner } from '@librechat/client';
+import React, { useCallback } from 'react';
+import { Button } from '@librechat/client';
+import { RefreshCw, Link } from 'lucide-react';
 import { useMCPServerManager } from '~/hooks/MCP/useMCPServerManager';
 import { useLocalize } from '~/hooks';
 
 interface ServerInitializationSectionProps {
-  sidePanel?: boolean;
   serverName: string;
   requiresOAuth: boolean;
   hasCustomUserVars?: boolean;
 }
 
 export default function ServerInitializationSection({
-  sidePanel = false,
   serverName,
   requiresOAuth,
   hasCustomUserVars = false,
 }: ServerInitializationSectionProps) {
   const localize = useLocalize();
 
+  // Use the centralized server manager instead of the old initialization hook so we can handle multiple oauth flows at once
   const {
     initializeServer,
     connectionStatus,
     cancelOAuthFlow,
+    revokeOAuthFlow,
     isInitializing,
     isCancellable,
     getOAuthUrl,
@@ -34,66 +34,99 @@ export default function ServerInitializationSection({
   const isServerInitializing = isInitializing(serverName);
   const serverOAuthUrl = getOAuthUrl(serverName);
 
-  const shouldShowReinit = isConnected && (requiresOAuth || hasCustomUserVars);
-  const shouldShowInit = !isConnected && !serverOAuthUrl;
+  const handleInitializeClick = useCallback(() => {
+    initializeServer(serverName, false);
+  }, [initializeServer, serverName]);
 
-  if (!shouldShowReinit && !shouldShowInit && !serverOAuthUrl) {
-    return null;
-  }
+  const handleCancelClick = useCallback(() => {
+    cancelOAuthFlow(serverName);
+  }, [cancelOAuthFlow, serverName]);
 
-  if (serverOAuthUrl) {
+  if (isConnected && (requiresOAuth || hasCustomUserVars)) {
     return (
-      <>
-        <div className="flex items-center gap-2">
-          <Button
-            onClick={() => cancelOAuthFlow(serverName)}
-            disabled={!canCancel}
-            variant="outline"
-            title={!canCancel ? 'disabled' : undefined}
-          >
-            {localize('com_ui_cancel')}
-          </Button>
-          <Button
-            variant="submit"
-            onClick={() => window.open(serverOAuthUrl, '_blank', 'noopener,noreferrer')}
-            className="flex-1"
-          >
-            {localize('com_ui_continue_oauth')}
-          </Button>
-        </div>
-      </>
+      <div className="flex justify-start">
+        <button
+          onClick={handleInitializeClick}
+          disabled={isServerInitializing}
+          className="flex items-center gap-1 text-xs text-gray-400 hover:text-gray-600 disabled:opacity-50 dark:text-gray-500 dark:hover:text-gray-400"
+        >
+          <RefreshCw className={`h-3 w-3 ${isServerInitializing ? 'animate-spin' : ''}`} />
+          {isServerInitializing ? localize('com_ui_loading') : localize('com_ui_reinitialize')}
+        </button>
+      </div>
     );
   }
 
-  // Unified button rendering
-  const isReinit = shouldShowReinit;
-  const outerClass = isReinit ? 'flex justify-start' : 'flex justify-end';
-  const buttonVariant = isReinit ? undefined : 'default';
-  const buttonText = isServerInitializing
-    ? localize('com_ui_loading')
-    : isReinit
-      ? localize('com_ui_reinitialize')
-      : requiresOAuth
-        ? localize('com_ui_authenticate')
-        : localize('com_ui_mcp_initialize');
-  const icon = isServerInitializing ? (
-    <Spinner className="h-4 w-4" />
-  ) : (
-    <RefreshCw className="h-4 w-4" />
-  );
+  if (isConnected) {
+    return null;
+  }
 
   return (
-    <div className={outerClass}>
-      <Button
-        variant={buttonVariant}
-        onClick={() => initializeServer(serverName, false)}
-        disabled={isServerInitializing}
-        size={sidePanel ? 'sm' : 'default'}
-        className="w-full"
-      >
-        {icon}
-        {buttonText}
-      </Button>
+    <div className="rounded-lg border border-amber-200 bg-amber-50 p-4 dark:border-amber-700 dark:bg-amber-900/20">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <span className="text-sm font-medium text-amber-800 dark:text-amber-200">
+            {requiresOAuth
+              ? localize('com_ui_mcp_not_authenticated', { 0: serverName })
+              : localize('com_ui_mcp_not_initialized', { 0: serverName })}
+          </span>
+        </div>
+        {/* Only show authenticate button when OAuth URL is not present */}
+        {!serverOAuthUrl && (
+          <Button
+            onClick={handleInitializeClick}
+            disabled={isServerInitializing}
+            className="btn btn-primary focus:shadow-outline flex w-full items-center justify-center px-4 py-2 font-semibold text-white hover:bg-green-600 focus:border-green-500"
+          >
+            {isServerInitializing ? (
+              <>
+                <RefreshCw className="h-4 w-4 animate-spin" />
+                {localize('com_ui_loading')}
+              </>
+            ) : (
+              <>
+                <RefreshCw className="h-4 w-4" />
+                {requiresOAuth
+                  ? localize('com_ui_authenticate')
+                  : localize('com_ui_mcp_initialize')}
+              </>
+            )}
+          </Button>
+        )}
+      </div>
+
+      {/* OAuth URL display */}
+      {serverOAuthUrl && (
+        <div className="mt-4 rounded-lg border border-blue-200 bg-blue-50 p-3 dark:border-blue-700 dark:bg-blue-900/20">
+          <div className="mb-2 flex items-center gap-2">
+            <div className="flex h-4 w-4 items-center justify-center rounded-full bg-blue-500">
+              <Link className="h-2.5 w-2.5 text-white" />
+            </div>
+            <span className="text-sm font-medium text-blue-700 dark:text-blue-300">
+              {localize('com_ui_auth_url')}
+            </span>
+          </div>
+          <div className="flex items-center gap-2">
+            <Button
+              onClick={() => window.open(serverOAuthUrl, '_blank', 'noopener,noreferrer')}
+              className="flex-1 bg-green-600 text-white hover:bg-green-700 dark:hover:bg-green-800"
+            >
+              {localize('com_ui_continue_oauth')}
+            </Button>
+            <Button
+              onClick={handleCancelClick}
+              disabled={!canCancel}
+              className="bg-gray-200 text-gray-700 hover:bg-gray-300 disabled:cursor-not-allowed disabled:opacity-50 dark:bg-gray-700 dark:text-gray-200 dark:hover:bg-gray-600"
+              title={!canCancel ? 'disabled' : undefined}
+            >
+              {localize('com_ui_cancel')}
+            </Button>
+          </div>
+          <p className="mt-2 text-xs text-blue-600 dark:text-blue-400">
+            {localize('com_ui_oauth_flow_desc')}
+          </p>
+        </div>
+      )}
     </div>
   );
 }

client/src/components/Messages/Content/Error.tsx

@@ -1,5 +1,6 @@
 // file deepcode ignore HardcodedNonCryptoSecret: No hardcoded secrets
 import { ViolationTypes, ErrorTypes, alternateName } from 'librechat-data-provider';
+import type { TOpenAIMessage } from 'librechat-data-provider';
 import type { LocalizeFunction } from '~/common';
 import { formatJSON, extractJson, isJson } from '~/utils/json';
 import { useLocalize } from '~/hooks';
@@ -24,7 +25,7 @@ type TTokenBalance = {
   prev_count: number;
   violation_count: number;
   date: Date;
-  generations?: unknown[];
+  generations?: TOpenAIMessage[];
 };
 
 type TExpiredKey = {
@@ -43,17 +44,6 @@ const errorMessages = {
   [ErrorTypes.NO_BASE_URL]: 'com_error_no_base_url',
   [ErrorTypes.INVALID_ACTION]: `com_error_${ErrorTypes.INVALID_ACTION}`,
   [ErrorTypes.INVALID_REQUEST]: `com_error_${ErrorTypes.INVALID_REQUEST}`,
-  [ErrorTypes.MISSING_MODEL]: (json: TGenericError, localize: LocalizeFunction) => {
-    const { info: endpoint } = json;
-    const provider = (alternateName[endpoint ?? ''] as string | undefined) ?? endpoint ?? 'unknown';
-    return localize('com_error_missing_model', { 0: provider });
-  },
-  [ErrorTypes.MODELS_NOT_LOADED]: 'com_error_models_not_loaded',
-  [ErrorTypes.ENDPOINT_MODELS_NOT_LOADED]: (json: TGenericError, localize: LocalizeFunction) => {
-    const { info: endpoint } = json;
-    const provider = (alternateName[endpoint ?? ''] as string | undefined) ?? endpoint ?? 'unknown';
-    return localize('com_error_endpoint_models_not_loaded', { 0: provider });
-  },
   [ErrorTypes.NO_SYSTEM_MESSAGES]: `com_error_${ErrorTypes.NO_SYSTEM_MESSAGES}`,
   [ErrorTypes.EXPIRED_USER_KEY]: (json: TExpiredKey, localize: LocalizeFunction) => {
     const { expiredAt, endpoint } = json;
@@ -75,12 +65,6 @@ const errorMessages = {
   [ErrorTypes.GOOGLE_TOOL_CONFLICT]: 'com_error_google_tool_conflict',
   [ViolationTypes.BAN]:
     'Your account has been temporarily banned due to violations of our service.',
-  [ViolationTypes.ILLEGAL_MODEL_REQUEST]: (json: TGenericError, localize: LocalizeFunction) => {
-    const { info } = json;
-    const [endpoint, model = 'unknown'] = info?.split('|') ?? [];
-    const provider = (alternateName[endpoint ?? ''] as string | undefined) ?? endpoint ?? 'unknown';
-    return localize('com_error_illegal_model_request', { 0: model, 1: provider });
-  },
   invalid_api_key:
     'Invalid API key. Please check your API key and try again. You can do this by clicking on the model logo in the left corner of the textbox and selecting "Set Token" for the current selected endpoint. Thank you for your understanding.',
   insufficient_quota:

client/src/components/Nav/ExportConversation/ExportModal.tsx

@@ -72,7 +72,7 @@ export default function ExportModal({
 
   const { exportConversation } = useExportConversation({
     conversation,
-    filename: filenamify(filename),
+    filename,
     type,
     includeOptions,
     exportBranches,
@@ -95,7 +95,7 @@ export default function ExportModal({
                 <Input
                   id="filename"
                   value={filename}
-                  onChange={(e) => setFileName(e.target.value || '')}
+                  onChange={(e) => setFileName(filenamify(e.target.value || ''))}
                   placeholder={localize('com_nav_export_filename_placeholder')}
                 />
               </div>

client/src/components/Nav/SettingsTabs/Account/Account.tsx

@@ -7,7 +7,7 @@ import BackupCodesItem from './BackupCodesItem';
 import { useAuthContext } from '~/hooks';
 
 function Account() {
-  const { user } = useAuthContext();
+  const user = useAuthContext();
 
   return (
     <div className="flex flex-col gap-3 p-1 text-sm text-text-primary">
@@ -17,12 +17,12 @@ function Account() {
       <div className="pb-3">
         <Avatar />
       </div>
-      {user?.provider === 'local' && (
+      {user?.user?.provider === 'local' && (
         <>
           <div className="pb-3">
             <EnableTwoFactorItem />
           </div>
-          {user?.twoFactorEnabled && (
+          {user?.user?.twoFactorEnabled && (
             <div className="pb-3">
               <BackupCodesItem />
             </div>

client/src/components/Nav/SettingsTabs/Account/TwoFactorAuthentication.tsx

@@ -39,8 +39,8 @@ const TwoFactorAuthentication: React.FC = () => {
   const [secret, setSecret] = useState<string>('');
   const [otpauthUrl, setOtpauthUrl] = useState<string>('');
   const [downloaded, setDownloaded] = useState<boolean>(false);
+  const [disableToken, setDisableToken] = useState<string>('');
   const [backupCodes, setBackupCodes] = useState<string[]>([]);
-  const [_disableToken, setDisableToken] = useState<string>('');
   const [isDialogOpen, setDialogOpen] = useState<boolean>(false);
   const [verificationToken, setVerificationToken] = useState<string>('');
   const [phase, setPhase] = useState<Phase>(user?.twoFactorEnabled ? 'disable' : 'setup');
@@ -166,26 +166,32 @@ const TwoFactorAuthentication: React.FC = () => {
         payload.token = token.trim();
       }
 
-      disable2FAMutate(payload, {
+      verify2FAMutate(payload, {
         onSuccess: () => {
-          showToast({ message: localize('com_ui_2fa_disabled') });
-          setDialogOpen(false);
-          setUser(
-            (prev) =>
-              ({
-                ...prev,
-                totpSecret: '',
-                backupCodes: [],
-                twoFactorEnabled: false,
-              }) as TUser,
-          );
-          setPhase('setup');
-          setOtpauthUrl('');
+          disable2FAMutate(undefined, {
+            onSuccess: () => {
+              showToast({ message: localize('com_ui_2fa_disabled') });
+              setDialogOpen(false);
+              setUser(
+                (prev) =>
+                  ({
+                    ...prev,
+                    totpSecret: '',
+                    backupCodes: [],
+                    twoFactorEnabled: false,
+                  }) as TUser,
+              );
+              setPhase('setup');
+              setOtpauthUrl('');
+            },
+            onError: () =>
+              showToast({ message: localize('com_ui_2fa_disable_error'), status: 'error' }),
+          });
         },
         onError: () => showToast({ message: localize('com_ui_2fa_invalid'), status: 'error' }),
       });
     },
-    [disable2FAMutate, showToast, localize, setUser],
+    [verify2FAMutate, disable2FAMutate, showToast, localize, setUser],
   );
 
   return (

client/src/components/Nav/SettingsTabs/General/General.tsx

@@ -105,8 +105,6 @@ export const LangSelector = ({
     { value: 'nl-NL', label: localize('com_nav_lang_dutch') },
     { value: 'id-ID', label: localize('com_nav_lang_indonesia') },
     { value: 'fi-FI', label: localize('com_nav_lang_finnish') },
-    { value: 'bo', label: localize('com_nav_lang_tibetan') },
-    { value: 'uk-UA', label: localize('com_nav_lang_ukrainian') },
   ];
 
   return (

client/src/components/SidePanel/Agents/AgentPanel.test.tsx

@@ -1,380 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import * as React from 'react';
-import { describe, it, expect, beforeEach, jest } from '@jest/globals';
-import { render, waitFor, fireEvent } from '@testing-library/react';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import type { Agent } from 'librechat-data-provider';
-
-// Mock toast context - define this after all mocks
-let mockShowToast: jest.Mock;
-
-// Mock notification severity enum before other imports
-jest.mock('~/common/types', () => ({
-  NotificationSeverity: {
-    SUCCESS: 'success',
-    ERROR: 'error',
-    INFO: 'info',
-    WARNING: 'warning',
-  },
-}));
-
-// Mock store to prevent import errors
-jest.mock('~/store/toast', () => ({
-  default: () => ({
-    showToast: jest.fn(),
-  }),
-}));
-
-jest.mock('~/store', () => {});
-
-// Mock the data service to control network responses
-jest.mock('librechat-data-provider', () => {
-  const actualModule = jest.requireActual('librechat-data-provider') as any;
-  return {
-    ...actualModule,
-    dataService: {
-      updateAgent: jest.fn(),
-    },
-    Tools: {
-      execute_code: 'execute_code',
-      file_search: 'file_search',
-      web_search: 'web_search',
-    },
-    Constants: {
-      EPHEMERAL_AGENT_ID: 'ephemeral',
-    },
-    SystemRoles: {
-      ADMIN: 'ADMIN',
-    },
-    EModelEndpoint: {
-      agents: 'agents',
-      chatGPTBrowser: 'chatGPTBrowser',
-      gptPlugins: 'gptPlugins',
-    },
-    isAssistantsEndpoint: jest.fn(() => false),
-  };
-});
-
-jest.mock('@librechat/client', () => ({
-  Button: ({ children, onClick, ...props }: any) => (
-    <button onClick={onClick} {...props}>
-      {children}
-    </button>
-  ),
-  useToastContext: () => ({
-    get showToast() {
-      return mockShowToast || jest.fn();
-    },
-  }),
-}));
-
-// Mock other dependencies
-jest.mock('librechat-data-provider/react-query', () => ({
-  useGetModelsQuery: () => ({ data: {} }),
-}));
-
-jest.mock('~/utils', () => ({
-  createProviderOption: jest.fn((provider: string) => ({ value: provider, label: provider })),
-  getDefaultAgentFormValues: jest.fn(() => ({
-    id: '',
-    name: '',
-    description: '',
-    model: '',
-    provider: '',
-  })),
-}));
-
-jest.mock('~/hooks', () => ({
-  useSelectAgent: () => ({ onSelect: jest.fn() }),
-  useLocalize: () => (key: string) => key,
-  useAuthContext: () => ({ user: { id: 'user-123', role: 'USER' } }),
-}));
-
-jest.mock('~/Providers/AgentPanelContext', () => ({
-  useAgentPanelContext: () => ({
-    activePanel: 'builder',
-    agentsConfig: { allowedProviders: [] },
-    setActivePanel: jest.fn(),
-    endpointsConfig: {},
-    setCurrentAgentId: jest.fn(),
-    agent_id: 'agent-123',
-  }),
-}));
-
-jest.mock('~/common', () => ({
-  Panel: {
-    model: 'model',
-    builder: 'builder',
-    advanced: 'advanced',
-  },
-}));
-
-// Mock child components to simplify testing
-jest.mock('./AgentPanelSkeleton', () => ({
-  __esModule: true,
-  default: () => <div>{`Loading...`}</div>,
-}));
-
-jest.mock('./Advanced/AdvancedPanel', () => ({
-  __esModule: true,
-  default: () => <div>{`Advanced Panel`}</div>,
-}));
-
-jest.mock('./AgentConfig', () => ({
-  __esModule: true,
-  default: () => <div>{`Agent Config`}</div>,
-}));
-
-jest.mock('./AgentSelect', () => ({
-  __esModule: true,
-  default: () => <div>{`Agent Select`}</div>,
-}));
-
-jest.mock('./ModelPanel', () => ({
-  __esModule: true,
-  default: () => <div>{`Model Panel`}</div>,
-}));
-
-// Mock AgentFooter to provide a save button
-jest.mock('./AgentFooter', () => ({
-  __esModule: true,
-  default: () => (
-    <button type="submit" data-testid="save-agent-button">
-      {`Save Agent`}
-    </button>
-  ),
-}));
-
-// Mock react-hook-form to capture form submission
-let mockFormSubmitHandler: (() => void) | null = null;
-
-jest.mock('react-hook-form', () => {
-  const actual = jest.requireActual('react-hook-form') as any;
-  return {
-    ...actual,
-    useForm: () => {
-      const methods = actual.useForm({
-        defaultValues: {
-          id: 'agent-123',
-          name: 'Test Agent',
-          description: 'Test description',
-          model: 'gpt-4',
-          provider: 'openai',
-          tools: [],
-          execute_code: false,
-          file_search: false,
-          web_search: false,
-        },
-      });
-
-      return {
-        ...methods,
-        handleSubmit: (onSubmit: any) => (e?: any) => {
-          e?.preventDefault?.();
-          mockFormSubmitHandler = () => onSubmit(methods.getValues());
-          return mockFormSubmitHandler;
-        },
-      };
-    },
-    FormProvider: ({ children }: any) => children,
-    useWatch: () => 'agent-123',
-  };
-});
-
-// Import after mocks
-import { dataService } from 'librechat-data-provider';
-import { useGetAgentByIdQuery } from '~/data-provider';
-import AgentPanel from './AgentPanel';
-
-// Mock useGetAgentByIdQuery
-jest.mock('~/data-provider', () => {
-  const actual = jest.requireActual('~/data-provider') as any;
-  return {
-    ...actual,
-    useGetAgentByIdQuery: jest.fn(),
-    useUpdateAgentMutation: actual.useUpdateAgentMutation,
-  };
-});
-
-// Test wrapper with QueryClient
-const createWrapper = () => {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: { retry: false },
-      mutations: { retry: false },
-    },
-  });
-
-  return ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  );
-};
-
-// Test helpers
-const setupMocks = () => {
-  const mockUseGetAgentByIdQuery = useGetAgentByIdQuery as jest.MockedFunction<
-    typeof useGetAgentByIdQuery
-  >;
-  const mockUpdateAgent = dataService.updateAgent as jest.MockedFunction<
-    typeof dataService.updateAgent
-  >;
-
-  return { mockUseGetAgentByIdQuery, mockUpdateAgent };
-};
-
-const mockAgentQuery = (
-  mockUseGetAgentByIdQuery: jest.MockedFunction<typeof useGetAgentByIdQuery>,
-  agent: Partial<Agent>,
-) => {
-  mockUseGetAgentByIdQuery.mockReturnValue({
-    data: {
-      id: 'agent-123',
-      author: 'user-123',
-      isCollaborative: false,
-      ...agent,
-    } as Agent,
-    isInitialLoading: false,
-  } as any);
-};
-
-const createMockAgent = (overrides: Partial<Agent> = {}): Agent =>
-  ({
-    id: 'agent-123',
-    provider: 'openai',
-    model: 'gpt-4',
-    ...overrides,
-  }) as Agent;
-
-const renderAndSubmitForm = async () => {
-  const Wrapper = createWrapper();
-  const { container, rerender } = render(<AgentPanel />, { wrapper: Wrapper });
-
-  const form = container.querySelector('form');
-  expect(form).toBeTruthy();
-
-  fireEvent.submit(form!);
-
-  if (mockFormSubmitHandler) {
-    mockFormSubmitHandler();
-  }
-
-  return { container, rerender, form };
-};
-
-describe('AgentPanel - Update Agent Toast Messages', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockShowToast = jest.fn();
-    mockFormSubmitHandler = null;
-  });
-
-  describe('AgentPanel', () => {
-    it('should show "no changes" toast when version does not change', async () => {
-      const { mockUseGetAgentByIdQuery, mockUpdateAgent } = setupMocks();
-
-      // Mock the agent query with version 2
-      mockAgentQuery(mockUseGetAgentByIdQuery, {
-        name: 'Test Agent',
-        version: 2,
-      });
-
-      // Mock network response - same version
-      mockUpdateAgent.mockResolvedValue(createMockAgent({ name: 'Test Agent', version: 2 }));
-
-      await renderAndSubmitForm();
-
-      // Wait for the toast to be shown
-      await waitFor(() => {
-        expect(mockShowToast).toHaveBeenCalledWith({
-          message: 'com_ui_no_changes',
-          status: 'info',
-        });
-      });
-    });
-
-    it('should show "update success" toast when version changes', async () => {
-      const { mockUseGetAgentByIdQuery, mockUpdateAgent } = setupMocks();
-
-      // Mock the agent query with version 2
-      mockAgentQuery(mockUseGetAgentByIdQuery, {
-        name: 'Test Agent',
-        version: 2,
-      });
-
-      // Mock network response - different version
-      mockUpdateAgent.mockResolvedValue(createMockAgent({ name: 'Test Agent', version: 3 }));
-
-      await renderAndSubmitForm();
-
-      await waitFor(() => {
-        expect(mockShowToast).toHaveBeenCalledWith({
-          message: 'com_assistants_update_success Test Agent',
-        });
-      });
-    });
-
-    it('should show "update success" with default name when agent has no name', async () => {
-      const { mockUseGetAgentByIdQuery, mockUpdateAgent } = setupMocks();
-
-      // Mock the agent query without name
-      mockAgentQuery(mockUseGetAgentByIdQuery, {
-        version: 1,
-      });
-
-      // Mock network response - no name
-      mockUpdateAgent.mockResolvedValue(createMockAgent({ version: 2 }));
-
-      await renderAndSubmitForm();
-
-      await waitFor(() => {
-        expect(mockShowToast).toHaveBeenCalledWith({
-          message: 'com_assistants_update_success com_ui_agent',
-        });
-      });
-    });
-
-    it('should show "update success" when agent query has no version (undefined)', async () => {
-      const { mockUseGetAgentByIdQuery, mockUpdateAgent } = setupMocks();
-
-      // Mock the agent query with no version data
-      mockAgentQuery(mockUseGetAgentByIdQuery, {
-        name: 'Test Agent',
-        // No version property
-      });
-
-      mockUpdateAgent.mockResolvedValue(createMockAgent({ name: 'Test Agent', version: 1 }));
-
-      await renderAndSubmitForm();
-
-      await waitFor(() => {
-        expect(mockShowToast).toHaveBeenCalledWith({
-          message: 'com_assistants_update_success Test Agent',
-        });
-      });
-    });
-
-    it('should show error toast on update failure', async () => {
-      const { mockUseGetAgentByIdQuery, mockUpdateAgent } = setupMocks();
-
-      // Mock the agent query
-      mockAgentQuery(mockUseGetAgentByIdQuery, {
-        name: 'Test Agent',
-        version: 1,
-      });
-
-      // Mock network error
-      mockUpdateAgent.mockRejectedValue(new Error('Update failed'));
-
-      await renderAndSubmitForm();
-
-      await waitFor(() => {
-        expect(mockShowToast).toHaveBeenCalledWith({
-          message: 'com_agents_update_error com_ui_error: Update failed',
-          status: 'error',
-        });
-      });
-    });
-  });
-});

client/src/components/SidePanel/Agents/AgentPanel.tsx

@@ -1,5 +1,5 @@
 import { Plus } from 'lucide-react';
-import React, { useMemo, useCallback, useRef } from 'react';
+import React, { useMemo, useCallback } from 'react';
 import { Button, useToastContext } from '@librechat/client';
 import { useWatch, useForm, FormProvider } from 'react-hook-form';
 import { useGetModelsQuery } from 'librechat-data-provider/react-query';
@@ -54,7 +54,6 @@ export default function AgentPanel() {
 
   const { control, handleSubmit, reset } = methods;
   const agent_id = useWatch({ control, name: 'id' });
-  const previousVersionRef = useRef<number | undefined>();
 
   const allowedProviders = useMemo(
     () => new Set(agentsConfig?.allowedProviders),
@@ -78,29 +77,50 @@ export default function AgentPanel() {
 
   /* Mutations */
   const update = useUpdateAgentMutation({
-    onMutate: () => {
-      // Store the current version before mutation
-      previousVersionRef.current = agentQuery.data?.version;
-    },
     onSuccess: (data) => {
-      // Check if agent version is the same (no changes were made)
-      if (previousVersionRef.current !== undefined && data.version === previousVersionRef.current) {
-        showToast({
-          message: localize('com_ui_no_changes'),
-          status: 'info',
-        });
-      } else {
-        showToast({
-          message: `${localize('com_assistants_update_success')} ${
-            data.name ?? localize('com_ui_agent')
-          }`,
-        });
-      }
-      // Clear the ref after use
-      previousVersionRef.current = undefined;
+      showToast({
+        message: `${localize('com_assistants_update_success')} ${
+          data.name ?? localize('com_ui_agent')
+        }`,
+      });
     },
     onError: (err) => {
-      const error = err as Error;
+      const error = err as Error & {
+        statusCode?: number;
+        details?: { duplicateVersion?: any; versionIndex?: number };
+        response?: { status?: number; data?: any };
+      };
+
+      const isDuplicateVersionError =
+        (error.statusCode === 409 && error.details?.duplicateVersion) ||
+        (error.response?.status === 409 && error.response?.data?.details?.duplicateVersion);
+
+      if (isDuplicateVersionError) {
+        let versionIndex: number | undefined = undefined;
+
+        if (error.details?.versionIndex !== undefined) {
+          versionIndex = error.details.versionIndex;
+        } else if (error.response?.data?.details?.versionIndex !== undefined) {
+          versionIndex = error.response.data.details.versionIndex;
+        }
+
+        if (versionIndex === undefined || versionIndex < 0) {
+          showToast({
+            message: localize('com_agents_update_error'),
+            status: 'error',
+            duration: 5000,
+          });
+        } else {
+          showToast({
+            message: localize('com_ui_agent_version_duplicate', { versionIndex: versionIndex + 1 }),
+            status: 'error',
+            duration: 10000,
+          });
+        }
+
+        return;
+      }
+
       showToast({
         message: `${localize('com_agents_update_error')}${
           error.message ? ` ${localize('com_ui_error')}: ${error.message}` : ''

client/src/components/SidePanel/MCP/MCPPanel.tsx

@@ -6,8 +6,8 @@ import { Constants, QueryKeys } from 'librechat-data-provider';
 import { useUpdateUserPluginsMutation } from 'librechat-data-provider/react-query';
 import type { TUpdateUserPlugins } from 'librechat-data-provider';
 import ServerInitializationSection from '~/components/MCP/ServerInitializationSection';
-import { useMCPConnectionStatusQuery } from '~/data-provider/Tools/queries';
 import CustomUserVarsSection from '~/components/MCP/CustomUserVarsSection';
+import { useMCPConnectionStatusQuery } from '~/data-provider/Tools/queries';
 import BadgeRowProvider from '~/Providers/BadgeRowContext';
 import { useGetStartupConfig } from '~/data-provider';
 import MCPPanelSkeleton from './MCPPanelSkeleton';
@@ -127,12 +127,20 @@ function MCPPanelContent() {
     const serverStatus = connectionStatus[selectedServerNameForEditing];
 
     return (
-      <div className="h-auto max-w-full space-y-4 overflow-x-hidden py-2">
-        <Button variant="outline" onClick={handleGoBackToList} size="sm">
+      <div className="h-auto max-w-full overflow-x-hidden p-3">
+        <Button
+          variant="outline"
+          onClick={handleGoBackToList}
+          className="mb-3 flex items-center px-3 py-2 text-sm"
+        >
           <ChevronLeft className="mr-1 h-4 w-4" />
           {localize('com_ui_back')}
         </Button>
 
+        <h3 className="mb-3 text-lg font-medium">
+          {localize('com_sidepanel_mcp_variables_for', { '0': serverBeingEdited.serverName })}
+        </h3>
+
         <div className="mb-4">
           <CustomUserVarsSection
             serverName={selectedServerNameForEditing}
@@ -152,7 +160,6 @@ function MCPPanelContent() {
         </div>
 
         <ServerInitializationSection
-          sidePanel={true}
           serverName={selectedServerNameForEditing}
           requiresOAuth={serverStatus?.requiresOAuth || false}
           hasCustomUserVars={
@@ -165,7 +172,7 @@ function MCPPanelContent() {
   } else {
     // Server List View
     return (
-      <div className="h-auto max-w-full overflow-x-hidden py-2">
+      <div className="h-auto max-w-full overflow-x-hidden p-3">
         <div className="space-y-2">
           {mcpServerDefinitions.map((server) => {
             const serverStatus = connectionStatus[server.serverName];
@@ -182,7 +189,7 @@ function MCPPanelContent() {
                     <span>{server.serverName}</span>
                     {serverStatus && (
                       <span
-                        className={`rounded-xl px-2 py-0.5 text-xs ${
+                        className={`rounded px-2 py-0.5 text-xs ${
                           isConnected
                             ? 'bg-green-100 text-green-700 dark:bg-green-900 dark:text-green-300'
                             : 'bg-gray-100 text-gray-700 dark:bg-gray-800 dark:text-gray-300'

client/src/data-provider/Agents/mutations.ts

@@ -43,7 +43,11 @@ export const useCreateAgentMutation = (
  */
 export const useUpdateAgentMutation = (
   options?: t.UpdateAgentMutationOptions,
-): UseMutationResult<t.Agent, Error, { agent_id: string; data: t.AgentUpdateParams }> => {
+): UseMutationResult<
+  t.Agent,
+  t.DuplicateVersionError,
+  { agent_id: string; data: t.AgentUpdateParams }
+> => {
   const queryClient = useQueryClient();
   return useMutation(
     ({ agent_id, data }: { agent_id: string; data: t.AgentUpdateParams }) => {
@@ -55,7 +59,8 @@ export const useUpdateAgentMutation = (
     {
       onMutate: (variables) => options?.onMutate?.(variables),
       onError: (error, variables, context) => {
-        return options?.onError?.(error, variables, context);
+        const typedError = error as t.DuplicateVersionError;
+        return options?.onError?.(typedError, variables, context);
       },
       onSuccess: (updatedAgent, variables, context) => {
         const listRes = queryClient.getQueryData<t.AgentListResponse>([

client/src/data-provider/Auth/mutations.ts

@@ -134,12 +134,12 @@ export const useConfirmTwoFactorMutation = (): UseMutationResult<
 export const useDisableTwoFactorMutation = (): UseMutationResult<
   t.TDisable2FAResponse,
   unknown,
-  t.TDisable2FARequest | undefined,
+  void,
   unknown
 > => {
   const queryClient = useQueryClient();
-  return useMutation((payload?: t.TDisable2FARequest) => dataService.disableTwoFactor(payload), {
-    onSuccess: () => {
+  return useMutation(() => dataService.disableTwoFactor(), {
+    onSuccess: (data) => {
       queryClient.setQueryData([QueryKeys.user, '2fa'], null);
     },
   });