feat: implement search parameter updates

* refactor: streamline model preset handling in conversation setup

* refactor: integrate navigation and location hooks in chat functions and event handlers, prevent cache from fetching on final event handling

* fix: prevent adding code interpreter non-image output to file list on message attachment event, fix all unhandled edge cases when this is done (treating the file download as an image attachment, undefined fields, message tokenCount issues, use of `startsWith` on undefined "text") although it is now prevent altogether

* chore: remove unused jailbreak prop from MinimalIcon component in EndpointIcon

* feat: add new SVG icons (MobileSidebar, Sidebar, XAIcon), fix: xAI styling in dark vs. light modes, adjust styling of Landing icons

* fix: open conversation in new tab on navigation with ctrl/meta key

* refactor: update Nav & Header to use close/open sidebar buttons, as well as redesign "New Chat"/"Bookmarks" buttons to the top of the Nav, matching the latest design of ChatGPT for simplicity and to free up space

* chore: remove unused isToggleHovering state and simplify opacity logic in Nav component

* style: match mobile nav to mobile header

.env.example

@@ -231,6 +231,14 @@ AZURE_AI_SEARCH_SEARCH_OPTION_QUERY_TYPE=
 AZURE_AI_SEARCH_SEARCH_OPTION_TOP=
 AZURE_AI_SEARCH_SEARCH_OPTION_SELECT=
 
+# OpenAI Image Tools Customization
+#----------------
+# IMAGE_GEN_OAI_DESCRIPTION_WITH_FILES=Custom description for image generation tool when files are present
+# IMAGE_GEN_OAI_DESCRIPTION_NO_FILES=Custom description for image generation tool when no files are present
+# IMAGE_EDIT_OAI_DESCRIPTION=Custom description for image editing tool
+# IMAGE_GEN_OAI_PROMPT_DESCRIPTION=Custom prompt description for image generation tool
+# IMAGE_EDIT_OAI_PROMPT_DESCRIPTION=Custom prompt description for image editing tool
+
 # DALL·E
 #----------------
 # DALLE_API_KEY=

.github/CONTRIBUTING.md

@@ -24,22 +24,40 @@ Project maintainers have the right and responsibility to remove, edit, or reject
 
 ## To contribute to this project, please adhere to the following guidelines:
 
-## 1. Development notes
+## 1. Development Setup
 
-1. Before starting work, make sure your main branch has the latest commits with `npm run update`
-2. Run linting command to find errors: `npm run lint`. Alternatively, ensure husky pre-commit checks are functioning.
+1. Use Node.JS 20.x.
+2. Install typescript globally: `npm i -g typescript`.
+3. Run `npm ci` to install dependencies.
+4. Build the data provider: `npm run build:data-provider`.
+5. Build MCP: `npm run build:mcp`.
+6. Build data schemas: `npm run build:data-schemas`.
+7. Setup and run unit tests:
+    - Copy `.env.test`: `cp api/test/.env.test.example api/test/.env.test`.
+    - Run backend unit tests: `npm run test:api`.
+    - Run frontend unit tests: `npm run test:client`.
+8. Setup and run integration tests:
+    - Build client: `cd client && npm run build`.
+    - Create `.env`: `cp .env.example .env`.
+    - Install [MongoDB Community Edition](https://www.mongodb.com/docs/manual/administration/install-community/), ensure that `mongosh` connects to your local instance.
+    - Run: `npx install playwright`, then `npx playwright install`.
+    - Copy `config.local`: `cp e2e/config.local.example.ts e2e/config.local.ts`.
+    - Copy `librechat.yaml`: `cp librechat.example.yaml librechat.yaml`.
+    - Run: `npm run e2e`.
+
+## 2. Development Notes
+
+1. Before starting work, make sure your main branch has the latest commits with `npm run update`.
+3. Run linting command to find errors: `npm run lint`. Alternatively, ensure husky pre-commit checks are functioning.
 3. After your changes, reinstall packages in your current branch using `npm run reinstall` and ensure everything still works. 
     - Restart the ESLint server ("ESLint: Restart ESLint Server" in VS Code command bar) and your IDE after reinstalling or updating.
 4. Clear web app localStorage and cookies before and after changes.
-5. For frontend changes:
-    - Install typescript globally: `npm i -g typescript`.
-    - Compile typescript before and after changes to check for introduced errors: `cd client && tsc --noEmit`.
-6. Run tests locally:
-    - Backend unit tests: `npm run test:api`
-    - Frontend unit tests: `npm run test:client`
-    - Integration tests: `npm run e2e` (requires playwright installed, `npx install playwright`)
+5. For frontend changes, compile typescript before and after changes to check for introduced errors: `cd client && npm run build`.
+6. Run backend unit tests: `npm run test:api`.
+7. Run frontend unit tests: `npm run test:client`.
+8. Run integration tests: `npm run e2e`.
 
-## 2. Git Workflow
+## 3. Git Workflow
 
 We utilize a GitFlow workflow to manage changes to this project's codebase. Follow these general steps when contributing code:
 
@@ -49,7 +67,7 @@ We utilize a GitFlow workflow to manage changes to this project's codebase. Foll
 4. Submit a pull request with a clear and concise description of your changes and the reasons behind them.
 5. We will review your pull request, provide feedback as needed, and eventually merge the approved changes into the main branch.
 
-## 3. Commit Message Format
+## 4. Commit Message Format
 
 We follow the [semantic format](https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716) for commit messages.
 
@@ -76,7 +94,7 @@ feat: add hat wobble
 ```
 
 
-## 4. Pull Request Process
+## 5. Pull Request Process
 
 When submitting a pull request, please follow these guidelines:
 
@@ -91,7 +109,7 @@ Ensure that your changes meet the following criteria:
 - The commit history is clean and easy to follow. You can use `git rebase` or `git merge --squash` to clean your commit history before submitting the pull request.
 - The pull request description clearly outlines the changes and the reasons behind them. Be sure to include the steps to test the pull request.
 
-## 5. Naming Conventions
+## 6. Naming Conventions
 
 Apply the following naming conventions to branches, labels, and other Git-related entities:
 
@@ -100,7 +118,7 @@ Apply the following naming conventions to branches, labels, and other Git-relate
 - **JS/TS:** Directories and file names: Descriptive and camelCase. First letter uppercased for React files (e.g., `helperFunction.ts, ReactComponent.tsx`).
 - **Docs:** Directories and file names: Descriptive and snake_case (e.g., `config_files.md`).
 
-## 6. TypeScript Conversion
+## 7. TypeScript Conversion
 
 1. **Original State**: The project was initially developed entirely in JavaScript (JS).
 
@@ -126,7 +144,7 @@ Apply the following naming conventions to branches, labels, and other Git-relate
       
    - **Current Stance**: At present, this backend transition is of lower priority and might not be pursued.
 
-## 7. Module Import Conventions
+## 8. Module Import Conventions
 
 - `npm` packages first, 
      - from shortest line (top) to longest (bottom)

.github/ISSUE_TEMPLATE/BUG-REPORT.yml

@@ -79,6 +79,8 @@ body:
 
         For UI-related issues, browser console logs can be very helpful. You can provide these as screenshots or paste the text here.
       render: shell
+    validations:
+      required: true
   - type: textarea
     id: screenshots
     attributes:

.gitignore

@@ -52,6 +52,9 @@ bower_components/
 *.d.ts
 !vite-env.d.ts
 
+# Cline
+.clineignore
+
 # Floobits
 .floo
 .floobit

Dockerfile

@@ -3,7 +3,15 @@
 # Base node image
 FROM node:20-alpine AS node
 
-RUN apk --no-cache add curl
+# Install jemalloc
+RUN apk add --no-cache jemalloc
+
+# Set environment variable to use jemalloc
+ENV LD_PRELOAD=/usr/lib/libjemalloc.so.2
+
+# Add `uv` for extended MCP support
+COPY --from=ghcr.io/astral-sh/uv:0.6.13 /uv /uvx /bin/
+RUN uv --version
 
 RUN mkdir -p /app && chown node:node /app
 WORKDIR /app
@@ -38,4 +46,4 @@ CMD ["npm", "run", "backend"]
 # WORKDIR /usr/share/nginx/html
 # COPY --from=node /app/client/dist /usr/share/nginx/html
 # COPY client/nginx.conf /etc/nginx/conf.d/default.conf
-# ENTRYPOINT ["nginx", "-g", "daemon off;"]
+# ENTRYPOINT ["nginx", "-g", "daemon off;"]

Dockerfile.multi

@@ -3,6 +3,10 @@
 
 # Base for all builds
 FROM node:20-alpine AS base-min
+# Install jemalloc
+RUN apk add --no-cache jemalloc
+# Set environment variable to use jemalloc
+ENV LD_PRELOAD=/usr/lib/libjemalloc.so.2
 WORKDIR /app
 RUN apk --no-cache add curl
 RUN npm config set fetch-retry-maxtimeout 600000 && \
@@ -50,6 +54,9 @@ RUN npm run build
 
 # API setup (including client dist)
 FROM base-min AS api-build
+# Add `uv` for extended MCP support
+COPY --from=ghcr.io/astral-sh/uv:0.6.13 /uv /uvx /bin/
+RUN uv --version
 WORKDIR /app
 # Install only production deps
 RUN npm ci --omit=dev

README.md

@@ -74,6 +74,11 @@
 - 🪄 **Generative UI with Code Artifacts**:  
   - [Code Artifacts](https://youtu.be/GfTj7O4gmd0?si=WJbdnemZpJzBrJo3) allow creation of React, HTML, and Mermaid diagrams directly in chat
 
+- 🎨 **Image Generation & Editing**
+  - Text-to-image and image-to-image with [GPT-Image-1](https://www.librechat.ai/docs/features/image_gen#1--openai-image-tools-recommended)
+  - Text-to-image with [DALL-E (3/2)](https://www.librechat.ai/docs/features/image_gen#2--dalle-legacy), [Stable Diffusion](https://www.librechat.ai/docs/features/image_gen#3--stable-diffusion-local), [Flux](https://www.librechat.ai/docs/features/image_gen#4--flux), or any [MCP server](https://www.librechat.ai/docs/features/image_gen#5--model-context-protocol-mcp)
+  - Produce stunning visuals from prompts or refine existing images with a single instruction
+
 - 💾 **Presets & Context Management**:  
   - Create, Save, & Share Custom Presets  
   - Switch between AI Endpoints and Presets mid-chat

api/app/clients/AnthropicClient.js

@@ -4,11 +4,12 @@ const {
   Constants,
   ErrorTypes,
   EModelEndpoint,
+  parseTextParts,
   anthropicSettings,
   getResponseSender,
   validateVisionModel,
 } = require('librechat-data-provider');
-const { SplitStreamHandler: _Handler, GraphEvents } = require('@librechat/agents');
+const { SplitStreamHandler: _Handler } = require('@librechat/agents');
 const {
   truncateText,
   formatMessage,
@@ -25,10 +26,11 @@ const {
 const { getModelMaxTokens, getModelMaxOutputTokens, matchModelName } = require('~/utils');
 const { spendTokens, spendStructuredTokens } = require('~/models/spendTokens');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { createFetch, createStreamEventHandlers } = require('./generators');
 const Tokenizer = require('~/server/services/Tokenizer');
-const { logger, sendEvent } = require('~/config');
 const { sleep } = require('~/server/utils');
 const BaseClient = require('./BaseClient');
+const { logger } = require('~/config');
 
 const HUMAN_PROMPT = '\n\nHuman:';
 const AI_PROMPT = '\n\nAssistant:';
@@ -183,7 +185,10 @@ class AnthropicClient extends BaseClient {
   getClient(requestOptions) {
     /** @type {Anthropic.ClientOptions} */
     const options = {
-      fetch: this.fetch,
+      fetch: createFetch({
+        directEndpoint: this.options.directEndpoint,
+        reverseProxyUrl: this.options.reverseProxyUrl,
+      }),
       apiKey: this.apiKey,
     };
 
@@ -413,6 +418,9 @@ class AnthropicClient extends BaseClient {
             this.contextHandlers?.processFile(file);
             continue;
           }
+          if (file.metadata?.fileIdentifier) {
+            continue;
+          }
 
           orderedMessages[i].tokenCount += this.calculateImageTokenCost({
             width: file.width,
@@ -696,15 +704,8 @@ class AnthropicClient extends BaseClient {
       if (msg.text != null && msg.text && msg.text.startsWith(':::thinking')) {
         msg.text = msg.text.replace(/:::thinking.*?:::/gs, '').trim();
       } else if (msg.content != null) {
-        /** @type {import('@librechat/agents').MessageContentComplex} */
-        const newContent = [];
-        for (let part of msg.content) {
-          if (part.think != null) {
-            continue;
-          }
-          newContent.push(part);
-        }
-        msg.content = newContent;
+        msg.text = parseTextParts(msg.content, true);
+        delete msg.content;
       }
 
       return msg;
@@ -801,14 +802,11 @@ class AnthropicClient extends BaseClient {
     }
 
     logger.debug('[AnthropicClient]', { ...requestOptions });
+    const handlers = createStreamEventHandlers(this.options.res);
     this.streamHandler = new SplitStreamHandler({
       accumulate: true,
       runId: this.responseMessageId,
-      handlers: {
-        [GraphEvents.ON_RUN_STEP]: (event) => sendEvent(this.options.res, event),
-        [GraphEvents.ON_MESSAGE_DELTA]: (event) => sendEvent(this.options.res, event),
-        [GraphEvents.ON_REASONING_DELTA]: (event) => sendEvent(this.options.res, event),
-      },
+      handlers,
     });
 
     let intermediateReply = this.streamHandler.tokens;

api/app/clients/BaseClient.js

@@ -28,15 +28,10 @@ class BaseClient {
       month: 'long',
       day: 'numeric',
     });
-    this.fetch = this.fetch.bind(this);
     /** @type {boolean} */
     this.skipSaveConvo = false;
     /** @type {boolean} */
     this.skipSaveUserMessage = false;
-    /** @type {ClientDatabaseSavePromise} */
-    this.userMessagePromise;
-    /** @type {ClientDatabaseSavePromise} */
-    this.responsePromise;
     /** @type {string} */
     this.user;
     /** @type {string} */
@@ -564,6 +559,8 @@ class BaseClient {
   }
 
   async sendMessage(message, opts = {}) {
+    /** @type {Promise<TMessage>} */
+    let userMessagePromise;
     const { user, head, isEdited, conversationId, responseMessageId, saveOptions, userMessage } =
       await this.handleStartMethods(message, opts);
 
@@ -625,11 +622,11 @@ class BaseClient {
     }
 
     if (!isEdited && !this.skipSaveUserMessage) {
-      this.userMessagePromise = this.saveMessageToDatabase(userMessage, saveOptions, user);
+      userMessagePromise = this.saveMessageToDatabase(userMessage, saveOptions, user);
       this.savedMessageIds.add(userMessage.messageId);
       if (typeof opts?.getReqData === 'function') {
         opts.getReqData({
-          userMessagePromise: this.userMessagePromise,
+          userMessagePromise,
         });
       }
     }
@@ -655,7 +652,9 @@ class BaseClient {
 
     /** @type {string|string[]|undefined} */
     const completion = await this.sendCompletion(payload, opts);
-    this.abortController.requestCompleted = true;
+    if (this.abortController) {
+      this.abortController.requestCompleted = true;
+    }
 
     /** @type {TMessage} */
     const responseMessage = {
@@ -676,7 +675,8 @@ class BaseClient {
       responseMessage.text = addSpaceIfNeeded(generation) + completion;
     } else if (
       Array.isArray(completion) &&
-      isParamEndpoint(this.options.endpoint, this.options.endpointType)
+      (this.clientName === EModelEndpoint.agents ||
+        isParamEndpoint(this.options.endpoint, this.options.endpointType))
     ) {
       responseMessage.text = '';
       responseMessage.content = completion;
@@ -702,7 +702,13 @@ class BaseClient {
       if (usage != null && Number(usage[this.outputTokensKey]) > 0) {
         responseMessage.tokenCount = usage[this.outputTokensKey];
         completionTokens = responseMessage.tokenCount;
-        await this.updateUserMessageTokenCount({ usage, tokenCountMap, userMessage, opts });
+        await this.updateUserMessageTokenCount({
+          usage,
+          tokenCountMap,
+          userMessage,
+          userMessagePromise,
+          opts,
+        });
       } else {
         responseMessage.tokenCount = this.getTokenCountForResponse(responseMessage);
         completionTokens = responseMessage.tokenCount;
@@ -711,8 +717,8 @@ class BaseClient {
       await this.recordTokenUsage({ promptTokens, completionTokens, usage });
     }
 
-    if (this.userMessagePromise) {
-      await this.userMessagePromise;
+    if (userMessagePromise) {
+      await userMessagePromise;
     }
 
     if (this.artifactPromises) {
@@ -727,7 +733,11 @@ class BaseClient {
       }
     }
 
-    this.responsePromise = this.saveMessageToDatabase(responseMessage, saveOptions, user);
+    responseMessage.databasePromise = this.saveMessageToDatabase(
+      responseMessage,
+      saveOptions,
+      user,
+    );
     this.savedMessageIds.add(responseMessage.messageId);
     delete responseMessage.tokenCount;
     return responseMessage;
@@ -748,9 +758,16 @@ class BaseClient {
    * @param {StreamUsage} params.usage
    * @param {Record<string, number>} params.tokenCountMap
    * @param {TMessage} params.userMessage
+   * @param {Promise<TMessage>} params.userMessagePromise
    * @param {object} params.opts
    */
-  async updateUserMessageTokenCount({ usage, tokenCountMap, userMessage, opts }) {
+  async updateUserMessageTokenCount({
+    usage,
+    tokenCountMap,
+    userMessage,
+    userMessagePromise,
+    opts,
+  }) {
     /** @type {boolean} */
     const shouldUpdateCount =
       this.calculateCurrentTokenCount != null &&
@@ -786,7 +803,7 @@ class BaseClient {
       Note: we update the user message to be sure it gets the calculated token count;
       though `AskController` saves the user message, EditController does not
     */
-    await this.userMessagePromise;
+    await userMessagePromise;
     await this.updateMessageInDatabase({
       messageId: userMessage.messageId,
       tokenCount: userMessageTokenCount,
@@ -852,7 +869,7 @@ class BaseClient {
     }
 
     const savedMessage = await saveMessage(
-      this.options.req,
+      this.options?.req,
       {
         ...message,
         endpoint: this.options.endpoint,
@@ -876,7 +893,7 @@ class BaseClient {
     const existingConvo =
       this.fetchedConvo === true
         ? null
-        : await getConvo(this.options.req?.user?.id, message.conversationId);
+        : await getConvo(this.options?.req?.user?.id, message.conversationId);
 
     const unsetFields = {};
     const exceptions = new Set(['spec', 'iconURL']);
@@ -896,7 +913,7 @@ class BaseClient {
       }
     }
 
-    const conversation = await saveConvo(this.options.req, fieldsToKeep, {
+    const conversation = await saveConvo(this.options?.req, fieldsToKeep, {
       context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo',
       unsetFields,
     });

api/app/clients/ChatGPTClient.js

@@ -1,4 +1,4 @@
-const Keyv = require('keyv');
+const { Keyv } = require('keyv');
 const crypto = require('crypto');
 const { CohereClient } = require('cohere-ai');
 const { fetchEventSource } = require('@waylaidwanderer/fetch-event-source');
@@ -339,7 +339,7 @@ class ChatGPTClient extends BaseClient {
     opts.body = JSON.stringify(modelOptions);
 
     if (modelOptions.stream) {
-      // eslint-disable-next-line no-async-promise-executor
+
       return new Promise(async (resolve, reject) => {
         try {
           let done = false;

api/app/clients/GoogleClient.js

@@ -9,6 +9,7 @@ const {
   validateVisionModel,
   getResponseSender,
   endpointSettings,
+  parseTextParts,
   EModelEndpoint,
   ContentTypes,
   VisionModes,
@@ -317,6 +318,9 @@ class GoogleClient extends BaseClient {
           this.contextHandlers?.processFile(file);
           continue;
         }
+        if (file.metadata?.fileIdentifier) {
+          continue;
+        }
       }
 
       this.augmentedPrompt = await this.contextHandlers.createContext();
@@ -774,6 +778,22 @@ class GoogleClient extends BaseClient {
     return this.usage;
   }
 
+  getMessageMapMethod() {
+    /**
+     * @param {TMessage} msg
+     */
+    return (msg) => {
+      if (msg.text != null && msg.text && msg.text.startsWith(':::thinking')) {
+        msg.text = msg.text.replace(/:::thinking.*?:::/gs, '').trim();
+      } else if (msg.content != null) {
+        msg.text = parseTextParts(msg.content, true);
+        delete msg.content;
+      }
+
+      return msg;
+    };
+  }
+
   /**
    * Calculates the correct token count for the current user message based on the token count map and API usage.
    * Edge case: If the calculation results in a negative value, it returns the original estimate.

api/app/clients/OpenAIClient.js

@@ -1,11 +1,11 @@
-const OpenAI = require('openai');
 const { OllamaClient } = require('./OllamaClient');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { SplitStreamHandler, GraphEvents } = require('@librechat/agents');
+const { SplitStreamHandler, CustomOpenAIClient: OpenAI } = require('@librechat/agents');
 const {
   Constants,
   ImageDetail,
   ContentTypes,
+  parseTextParts,
   EModelEndpoint,
   resolveHeaders,
   KnownEndpoints,
@@ -31,17 +31,18 @@ const {
   createContextHandlers,
 } = require('./prompts');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { createFetch, createStreamEventHandlers } = require('./generators');
 const { addSpaceIfNeeded, isEnabled, sleep } = require('~/server/utils');
 const Tokenizer = require('~/server/services/Tokenizer');
 const { spendTokens } = require('~/models/spendTokens');
 const { handleOpenAIErrors } = require('./tools/util');
 const { createLLM, RunManager } = require('./llm');
-const { logger, sendEvent } = require('~/config');
 const ChatGPTClient = require('./ChatGPTClient');
 const { summaryBuffer } = require('./memory');
 const { runTitleChain } = require('./chains');
 const { tokenSplit } = require('./document');
 const BaseClient = require('./BaseClient');
+const { logger } = require('~/config');
 
 class OpenAIClient extends BaseClient {
   constructor(apiKey, options = {}) {
@@ -107,7 +108,7 @@ class OpenAIClient extends BaseClient {
       this.checkVisionRequest(this.options.attachments);
     }
 
-    const omniPattern = /\b(o1|o3)\b/i;
+    const omniPattern = /\b(o\d)\b/i;
     this.isOmni = omniPattern.test(this.modelOptions.model);
 
     const { OPENAI_FORCE_PROMPT } = process.env ?? {};
@@ -454,6 +455,9 @@ class OpenAIClient extends BaseClient {
             this.contextHandlers?.processFile(file);
             continue;
           }
+          if (file.metadata?.fileIdentifier) {
+            continue;
+          }
 
           orderedMessages[i].tokenCount += this.calculateImageTokenCost({
             width: file.width,
@@ -608,7 +612,7 @@ class OpenAIClient extends BaseClient {
         return result.trim();
       }
 
-      logger.debug('[OpenAIClient] sendCompletion: result', result);
+      logger.debug('[OpenAIClient] sendCompletion: result', { ...result });
 
       if (this.isChatCompletion) {
         reply = result.choices[0].message.content;
@@ -817,7 +821,7 @@ ${convo}
 
         const completionTokens = this.getTokenCount(title);
 
-        this.recordTokenUsage({ promptTokens, completionTokens, context: 'title' });
+        await this.recordTokenUsage({ promptTokens, completionTokens, context: 'title' });
       } catch (e) {
         logger.error(
           '[OpenAIClient] There was an issue generating the title with the completion method',
@@ -1121,15 +1125,8 @@ ${convo}
       if (msg.text != null && msg.text && msg.text.startsWith(':::thinking')) {
         msg.text = msg.text.replace(/:::thinking.*?:::/gs, '').trim();
       } else if (msg.content != null) {
-        /** @type {import('@librechat/agents').MessageContentComplex} */
-        const newContent = [];
-        for (let part of msg.content) {
-          if (part.think != null) {
-            continue;
-          }
-          newContent.push(part);
-        }
-        msg.content = newContent;
+        msg.text = parseTextParts(msg.content, true);
+        delete msg.content;
       }
 
       return msg;
@@ -1243,6 +1240,9 @@ ${convo}
         modelOptions.max_completion_tokens = modelOptions.max_tokens;
         delete modelOptions.max_tokens;
       }
+      if (this.isOmni === true && modelOptions.temperature != null) {
+        delete modelOptions.temperature;
+      }
 
       if (process.env.OPENAI_ORGANIZATION) {
         opts.organization = process.env.OPENAI_ORGANIZATION;
@@ -1251,7 +1251,10 @@ ${convo}
       let chatCompletion;
       /** @type {OpenAI} */
       const openai = new OpenAI({
-        fetch: this.fetch,
+        fetch: createFetch({
+          directEndpoint: this.options.directEndpoint,
+          reverseProxyUrl: this.options.reverseProxyUrl,
+        }),
         apiKey: this.apiKey,
         ...opts,
       });
@@ -1281,12 +1284,13 @@ ${convo}
       }
 
       if (this.options.addParams && typeof this.options.addParams === 'object') {
+        const addParams = { ...this.options.addParams };
         modelOptions = {
           ...modelOptions,
-          ...this.options.addParams,
+          ...addParams,
         };
         logger.debug('[OpenAIClient] chatCompletion: added params', {
-          addParams: this.options.addParams,
+          addParams: addParams,
           modelOptions,
         });
       }
@@ -1315,11 +1319,12 @@ ${convo}
       }
 
       if (this.options.dropParams && Array.isArray(this.options.dropParams)) {
-        this.options.dropParams.forEach((param) => {
+        const dropParams = [...this.options.dropParams];
+        dropParams.forEach((param) => {
           delete modelOptions[param];
         });
         logger.debug('[OpenAIClient] chatCompletion: dropped params', {
-          dropParams: this.options.dropParams,
+          dropParams: dropParams,
           modelOptions,
         });
       }
@@ -1361,15 +1366,12 @@ ${convo}
         delete modelOptions.reasoning_effort;
       }
 
+      const handlers = createStreamEventHandlers(this.options.res);
       this.streamHandler = new SplitStreamHandler({
         reasoningKey,
         accumulate: true,
         runId: this.responseMessageId,
-        handlers: {
-          [GraphEvents.ON_RUN_STEP]: (event) => sendEvent(this.options.res, event),
-          [GraphEvents.ON_MESSAGE_DELTA]: (event) => sendEvent(this.options.res, event),
-          [GraphEvents.ON_REASONING_DELTA]: (event) => sendEvent(this.options.res, event),
-        },
+        handlers,
       });
 
       intermediateReply = this.streamHandler.tokens;
@@ -1473,6 +1475,11 @@ ${convo}
           });
       }
 
+      if (openai.abortHandler && abortController.signal) {
+        abortController.signal.removeEventListener('abort', openai.abortHandler);
+        openai.abortHandler = undefined;
+      }
+
       if (!chatCompletion && UnexpectedRoleError) {
         throw new Error(
           'OpenAI error: Invalid final message: OpenAI expects final message to include role=assistant',

api/app/clients/PluginsClient.js

@@ -252,12 +252,14 @@ class PluginsClient extends OpenAIClient {
       await this.recordTokenUsage(responseMessage);
     }
 
-    this.responsePromise = this.saveMessageToDatabase(responseMessage, saveOptions, user);
+    const databasePromise = this.saveMessageToDatabase(responseMessage, saveOptions, user);
     delete responseMessage.tokenCount;
-    return { ...responseMessage, ...result };
+    return { ...responseMessage, ...result, databasePromise };
   }
 
   async sendMessage(message, opts = {}) {
+    /** @type {Promise<TMessage>} */
+    let userMessagePromise;
     /** @type {{ filteredTools: string[], includedTools: string[] }} */
     const { filteredTools = [], includedTools = [] } = this.options.req.app.locals;
 
@@ -327,10 +329,10 @@ class PluginsClient extends OpenAIClient {
     }
 
     if (!this.skipSaveUserMessage) {
-      this.userMessagePromise = this.saveMessageToDatabase(userMessage, saveOptions, user);
+      userMessagePromise = this.saveMessageToDatabase(userMessage, saveOptions, user);
       if (typeof opts?.getReqData === 'function') {
         opts.getReqData({
-          userMessagePromise: this.userMessagePromise,
+          userMessagePromise,
         });
       }
     }

api/app/clients/generators.js

@@ -0,0 +1,71 @@
+const fetch = require('node-fetch');
+const { GraphEvents } = require('@librechat/agents');
+const { logger, sendEvent } = require('~/config');
+const { sleep } = require('~/server/utils');
+
+/**
+ * Makes a function to make HTTP request and logs the process.
+ * @param {Object} params
+ * @param {boolean} [params.directEndpoint] - Whether to use a direct endpoint.
+ * @param {string} [params.reverseProxyUrl] - The reverse proxy URL to use for the request.
+ * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+ */
+function createFetch({ directEndpoint = false, reverseProxyUrl = '' }) {
+  /**
+   * Makes an HTTP request and logs the process.
+   * @param {RequestInfo} url - The URL to make the request to. Can be a string or a Request object.
+   * @param {RequestInit} [init] - Optional init options for the request.
+   * @returns {Promise<Response>} - A promise that resolves to the response of the fetch request.
+   */
+  return async (_url, init) => {
+    let url = _url;
+    if (directEndpoint) {
+      url = reverseProxyUrl;
+    }
+    logger.debug(`Making request to ${url}`);
+    if (typeof Bun !== 'undefined') {
+      return await fetch(url, init);
+    }
+    return await fetch(url, init);
+  };
+}
+
+// Add this at the module level outside the class
+/**
+ * Creates event handlers for stream events that don't capture client references
+ * @param {Object} res - The response object to send events to
+ * @returns {Object} Object containing handler functions
+ */
+function createStreamEventHandlers(res) {
+  return {
+    [GraphEvents.ON_RUN_STEP]: (event) => {
+      if (res) {
+        sendEvent(res, event);
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: (event) => {
+      if (res) {
+        sendEvent(res, event);
+      }
+    },
+    [GraphEvents.ON_REASONING_DELTA]: (event) => {
+      if (res) {
+        sendEvent(res, event);
+      }
+    },
+  };
+}
+
+function createHandleLLMNewToken(streamRate) {
+  return async () => {
+    if (streamRate) {
+      await sleep(streamRate);
+    }
+  };
+}
+
+module.exports = {
+  createFetch,
+  createHandleLLMNewToken,
+  createStreamEventHandlers,
+};

api/app/clients/llm/createLLM.js

@@ -34,6 +34,7 @@ function createLLM({
   let credentials = { openAIApiKey };
   let configuration = {
     apiKey: openAIApiKey,
+    ...(configOptions.basePath && { baseURL: configOptions.basePath }),
   };
 
   /**  @type {AzureOptions} */

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

@@ -32,7 +32,7 @@ jest.mock('~/models', () => ({
 
 const { getConvo, saveConvo } = require('~/models');
 
-jest.mock('@langchain/openai', () => {
+jest.mock('@librechat/agents', () => {
   return {
     ChatOpenAI: jest.fn().mockImplementation(() => {
       return {};

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

@@ -1,9 +1,7 @@
 jest.mock('~/cache/getLogStores');
 require('dotenv').config();
-const OpenAI = require('openai');
-const getLogStores = require('~/cache/getLogStores');
 const { fetchEventSource } = require('@waylaidwanderer/fetch-event-source');
-const { genAzureChatCompletion } = require('~/utils/azureUtils');
+const getLogStores = require('~/cache/getLogStores');
 const OpenAIClient = require('../OpenAIClient');
 jest.mock('meilisearch');
 
@@ -36,19 +34,21 @@ jest.mock('~/models', () => ({
   updateFileUsage: jest.fn(),
 }));
 
-jest.mock('@langchain/openai', () => {
-  return {
-    ChatOpenAI: jest.fn().mockImplementation(() => {
-      return {};
-    }),
-  };
+// Import the actual module but mock specific parts
+const agents = jest.requireActual('@librechat/agents');
+const { CustomOpenAIClient } = agents;
+
+// Also mock ChatOpenAI to prevent real API calls
+agents.ChatOpenAI = jest.fn().mockImplementation(() => {
+  return {};
+});
+agents.AzureChatOpenAI = jest.fn().mockImplementation(() => {
+  return {};
 });
 
-jest.mock('openai');
-
-jest.spyOn(OpenAI, 'constructor').mockImplementation(function (...options) {
-  // We can add additional logic here if needed
-  return new OpenAI(...options);
+// Mock only the CustomOpenAIClient constructor
+jest.spyOn(CustomOpenAIClient, 'constructor').mockImplementation(function (...options) {
+  return new CustomOpenAIClient(...options);
 });
 
 const finalChatCompletion = jest.fn().mockResolvedValue({
@@ -120,7 +120,13 @@ const create = jest.fn().mockResolvedValue({
   ],
 });
 
-OpenAI.mockImplementation(() => ({
+// Mock the implementation of CustomOpenAIClient instances
+jest.spyOn(CustomOpenAIClient.prototype, 'constructor').mockImplementation(function () {
+  return this;
+});
+
+// Create a mock for the CustomOpenAIClient class
+const mockCustomOpenAIClient = jest.fn().mockImplementation(() => ({
   beta: {
     chat: {
       completions: {
@@ -135,6 +141,8 @@ OpenAI.mockImplementation(() => ({
   },
 }));
 
+CustomOpenAIClient.mockImplementation = mockCustomOpenAIClient;
+
 describe('OpenAIClient', () => {
   beforeEach(() => {
     const mockCache = {
@@ -559,41 +567,6 @@ describe('OpenAIClient', () => {
       expect(requestBody).toHaveProperty('model');
       expect(requestBody.model).toBe(model);
     });
-
-    it('[Azure OpenAI] should call chatCompletion and OpenAI.stream with correct args', async () => {
-      // Set a default model
-      process.env.AZURE_OPENAI_DEFAULT_MODEL = 'gpt4-turbo';
-
-      const onProgress = jest.fn().mockImplementation(() => ({}));
-      client.azure = defaultAzureOptions;
-      const chatCompletion = jest.spyOn(client, 'chatCompletion');
-      await client.sendMessage('Hi mom!', {
-        replaceOptions: true,
-        ...defaultOptions,
-        modelOptions: { model: 'gpt4-turbo', stream: true },
-        onProgress,
-        azure: defaultAzureOptions,
-      });
-
-      expect(chatCompletion).toHaveBeenCalled();
-      expect(chatCompletion.mock.calls.length).toBe(1);
-
-      const chatCompletionArgs = chatCompletion.mock.calls[0][0];
-      const { payload } = chatCompletionArgs;
-
-      expect(payload[0].role).toBe('user');
-      expect(payload[0].content).toBe('Hi mom!');
-
-      // Azure OpenAI does not use the model property, and will error if it's passed
-      // This check ensures the model property is not present
-      const streamArgs = stream.mock.calls[0][0];
-      expect(streamArgs).not.toHaveProperty('model');
-
-      // Check if the baseURL is correct
-      const constructorArgs = OpenAI.mock.calls[0][0];
-      const expectedURL = genAzureChatCompletion(defaultAzureOptions).split('/chat')[0];
-      expect(constructorArgs.baseURL).toBe(expectedURL);
-    });
   });
 
   describe('checkVisionRequest functionality', () => {

api/app/clients/tools/index.js

@@ -10,6 +10,7 @@ const StructuredACS = require('./structured/AzureAISearch');
 const StructuredSD = require('./structured/StableDiffusion');
 const GoogleSearchAPI = require('./structured/GoogleSearch');
 const TraversaalSearch = require('./structured/TraversaalSearch');
+const createOpenAIImageTools = require('./structured/OpenAIImageTools');
 const TavilySearchResults = require('./structured/TavilySearchResults');
 
 /** @type {Record<string, TPlugin | undefined>} */
@@ -40,4 +41,5 @@ module.exports = {
   StructuredWolfram,
   createYouTubeTools,
   TavilySearchResults,
+  createOpenAIImageTools,
 };

api/app/clients/tools/manifest.json

@@ -44,6 +44,20 @@
       }
     ]
   },
+  {
+    "name": "OpenAI Image Tools",
+    "pluginKey": "image_gen_oai",
+    "toolkit": true,
+    "description": "Image Generation and Editing using OpenAI's latest state-of-the-art models",
+    "icon": "/assets/image_gen_oai.png",
+    "authConfig": [
+      {
+        "authField": "IMAGE_GEN_OAI_API_KEY",
+        "label": "OpenAI Image Tools API Key",
+        "description": "Your OpenAI API Key for Image Generation and Editing"
+      }
+    ]
+  },
   {
     "name": "Wolfram",
     "pluginKey": "wolfram",

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

@@ -0,0 +1,518 @@
+const { z } = require('zod');
+const axios = require('axios');
+const { v4 } = require('uuid');
+const OpenAI = require('openai');
+const FormData = require('form-data');
+const { tool } = require('@langchain/core/tools');
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const { ContentTypes, EImageOutputType } = require('librechat-data-provider');
+const { getStrategyFunctions } = require('~/server/services/Files/strategies');
+const { logAxiosError, extractBaseURL } = require('~/utils');
+const { getFiles } = require('~/models/File');
+const { logger } = require('~/config');
+
+/** Default descriptions for image generation tool  */
+const DEFAULT_IMAGE_GEN_DESCRIPTION = `
+Generates high-quality, original images based solely on text, not using any uploaded reference images.
+
+When to use \`image_gen_oai\`:
+- To create entirely new images from detailed text descriptions that do NOT reference any image files.
+
+When NOT to use \`image_gen_oai\`:
+- If the user has uploaded any images and requests modifications, enhancements, or remixing based on those uploads → use \`image_edit_oai\` instead.
+
+Generated image IDs will be returned in the response, so you can refer to them in future requests made to \`image_edit_oai\`.
+`.trim();
+
+/** Default description for image editing tool  */
+const DEFAULT_IMAGE_EDIT_DESCRIPTION =
+  `Generates high-quality, original images based on text and one or more uploaded/referenced images.
+
+When to use \`image_edit_oai\`:
+- The user wants to modify, extend, or remix one **or more** uploaded images, either:
+  - Previously generated, or in the current request (both to be included in the \`image_ids\` array).
+- Always when the user refers to uploaded images for editing, enhancement, remixing, style transfer, or combining elements.
+- Any current or existing images are to be used as visual guides.
+- If there are any files in the current request, they are more likely than not expected as references for image edit requests.
+
+When NOT to use \`image_edit_oai\`:
+- Brand-new generations that do not rely on an existing image → use \`image_gen_oai\` instead.
+
+Both generated and referenced image IDs will be returned in the response, so you can refer to them in future requests made to \`image_edit_oai\`.
+`.trim();
+
+/** Default prompt descriptions  */
+const DEFAULT_IMAGE_GEN_PROMPT_DESCRIPTION = `Describe the image you want in detail. 
+      Be highly specific—break your idea into layers: 
+      (1) main concept and subject,
+      (2) composition and position,
+      (3) lighting and mood,
+      (4) style, medium, or camera details,
+      (5) important features (age, expression, clothing, etc.),
+      (6) background.
+      Use positive, descriptive language and specify what should be included, not what to avoid. 
+      List number and characteristics of people/objects, and mention style/technical requirements (e.g., "DSLR photo, 85mm lens, golden hour").
+      Do not reference any uploaded images—use for new image creation from text only.`;
+
+const DEFAULT_IMAGE_EDIT_PROMPT_DESCRIPTION = `Describe the changes, enhancements, or new ideas to apply to the uploaded image(s).
+      Be highly specific—break your request into layers: 
+      (1) main concept or transformation,
+      (2) specific edits/replacements or composition guidance,
+      (3) desired style, mood, or technique,
+      (4) features/items to keep, change, or add (such as objects, people, clothing, lighting, etc.).
+      Use positive, descriptive language and clarify what should be included or changed, not what to avoid.
+      Always base this prompt on the most recently uploaded reference images.`;
+
+const displayMessage =
+  'The tool displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.';
+
+/**
+ * Replaces unwanted characters from the input string
+ * @param {string} inputString - The input string to process
+ * @returns {string} - The processed string
+ */
+function replaceUnwantedChars(inputString) {
+  return inputString
+    .replace(/\r\n|\r|\n/g, ' ')
+    .replace(/"/g, '')
+    .trim();
+}
+
+function returnValue(value) {
+  if (typeof value === 'string') {
+    return [value, {}];
+  } else if (typeof value === 'object') {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    return [displayMessage, value];
+  }
+  return value;
+}
+
+const getImageGenDescription = () => {
+  return process.env.IMAGE_GEN_OAI_DESCRIPTION || DEFAULT_IMAGE_GEN_DESCRIPTION;
+};
+
+const getImageEditDescription = () => {
+  return process.env.IMAGE_EDIT_OAI_DESCRIPTION || DEFAULT_IMAGE_EDIT_DESCRIPTION;
+};
+
+const getImageGenPromptDescription = () => {
+  return process.env.IMAGE_GEN_OAI_PROMPT_DESCRIPTION || DEFAULT_IMAGE_GEN_PROMPT_DESCRIPTION;
+};
+
+const getImageEditPromptDescription = () => {
+  return process.env.IMAGE_EDIT_OAI_PROMPT_DESCRIPTION || DEFAULT_IMAGE_EDIT_PROMPT_DESCRIPTION;
+};
+
+/**
+ * Creates OpenAI Image tools (generation and editing)
+ * @param {Object} fields - Configuration fields
+ * @param {ServerRequest} fields.req - Whether the tool is being used in an agent context
+ * @param {boolean} fields.isAgent - Whether the tool is being used in an agent context
+ * @param {string} fields.IMAGE_GEN_OAI_API_KEY - The OpenAI API key
+ * @param {boolean} [fields.override] - Whether to override the API key check, necessary for app initialization
+ * @param {MongoFile[]} [fields.imageFiles] - The images to be used for editing
+ * @returns {Array} - Array of image tools
+ */
+function createOpenAIImageTools(fields = {}) {
+  /** @type {boolean} Used to initialize the Tool without necessary variables. */
+  const override = fields.override ?? false;
+  /** @type {boolean} */
+  if (!override && !fields.isAgent) {
+    throw new Error('This tool is only available for agents.');
+  }
+  const { req } = fields;
+  const imageOutputType = req?.app.locals.imageOutputType || EImageOutputType.PNG;
+  const appFileStrategy = req?.app.locals.fileStrategy;
+
+  const getApiKey = () => {
+    const apiKey = process.env.IMAGE_GEN_OAI_API_KEY ?? '';
+    if (!apiKey && !override) {
+      throw new Error('Missing IMAGE_GEN_OAI_API_KEY environment variable.');
+    }
+    return apiKey;
+  };
+
+  let apiKey = fields.IMAGE_GEN_OAI_API_KEY ?? getApiKey();
+  const closureConfig = { apiKey };
+
+  let baseURL = 'https://api.openai.com/v1/';
+  if (!override && process.env.IMAGE_GEN_OAI_BASEURL) {
+    baseURL = extractBaseURL(process.env.IMAGE_GEN_OAI_BASEURL);
+    closureConfig.baseURL = baseURL;
+  }
+
+  // Note: Azure may not yet support the latest image generation models
+  if (
+    !override &&
+    process.env.IMAGE_GEN_OAI_AZURE_API_VERSION &&
+    process.env.IMAGE_GEN_OAI_BASEURL
+  ) {
+    baseURL = process.env.IMAGE_GEN_OAI_BASEURL;
+    closureConfig.baseURL = baseURL;
+    closureConfig.defaultQuery = { 'api-version': process.env.IMAGE_GEN_OAI_AZURE_API_VERSION };
+    closureConfig.defaultHeaders = {
+      'api-key': process.env.IMAGE_GEN_OAI_API_KEY,
+      'Content-Type': 'application/json',
+    };
+    closureConfig.apiKey = process.env.IMAGE_GEN_OAI_API_KEY;
+  }
+
+  const imageFiles = fields.imageFiles ?? [];
+
+  /**
+   * Image Generation Tool
+   */
+  const imageGenTool = tool(
+    async (
+      {
+        prompt,
+        background = 'auto',
+        n = 1,
+        output_compression = 100,
+        quality = 'auto',
+        size = 'auto',
+      },
+      runnableConfig,
+    ) => {
+      if (!prompt) {
+        throw new Error('Missing required field: prompt');
+      }
+      const clientConfig = { ...closureConfig };
+      if (process.env.PROXY) {
+        clientConfig.httpAgent = new HttpsProxyAgent(process.env.PROXY);
+      }
+
+      /** @type {OpenAI} */
+      const openai = new OpenAI(clientConfig);
+      let output_format = imageOutputType;
+      if (
+        background === 'transparent' &&
+        output_format !== EImageOutputType.PNG &&
+        output_format !== EImageOutputType.WEBP
+      ) {
+        logger.warn(
+          '[ImageGenOAI] Transparent background requires PNG or WebP format, defaulting to PNG',
+        );
+        output_format = EImageOutputType.PNG;
+      }
+
+      let resp;
+      try {
+        const derivedSignal = runnableConfig?.signal
+          ? AbortSignal.any([runnableConfig.signal])
+          : undefined;
+        resp = await openai.images.generate(
+          {
+            model: 'gpt-image-1',
+            prompt: replaceUnwantedChars(prompt),
+            n: Math.min(Math.max(1, n), 10),
+            background,
+            output_format,
+            output_compression:
+              output_format === EImageOutputType.WEBP || output_format === EImageOutputType.JPEG
+                ? output_compression
+                : undefined,
+            quality,
+            size,
+          },
+          {
+            signal: derivedSignal,
+          },
+        );
+      } catch (error) {
+        const message = '[image_gen_oai] Problem generating the image:';
+        logAxiosError({ error, message });
+        return returnValue(`Something went wrong when trying to generate the image. The OpenAI API may be unavailable:
+Error Message: ${error.message}`);
+      }
+
+      if (!resp) {
+        return returnValue(
+          'Something went wrong when trying to generate the image. The OpenAI API may be unavailable',
+        );
+      }
+
+      // For gpt-image-1, the response contains base64-encoded images
+      // TODO: handle cost in `resp.usage`
+      const base64Image = resp.data[0].b64_json;
+
+      if (!base64Image) {
+        return returnValue(
+          'No image data returned from OpenAI API. There may be a problem with the API or your configuration.',
+        );
+      }
+
+      const content = [
+        {
+          type: ContentTypes.IMAGE_URL,
+          image_url: {
+            url: `data:image/${output_format};base64,${base64Image}`,
+          },
+        },
+      ];
+
+      const file_ids = [v4()];
+      const response = [
+        {
+          type: ContentTypes.TEXT,
+          text: displayMessage + `\n\ngenerated_image_id: "${file_ids[0]}"`,
+        },
+      ];
+      return [response, { content, file_ids }];
+    },
+    {
+      name: 'image_gen_oai',
+      description: getImageGenDescription(),
+      schema: z.object({
+        prompt: z.string().max(32000).describe(getImageGenPromptDescription()),
+        background: z
+          .enum(['transparent', 'opaque', 'auto'])
+          .optional()
+          .describe(
+            'Sets transparency for the background. Must be one of transparent, opaque or auto (default). When transparent, the output format should be png or webp.',
+          ),
+        /*
+        n: z
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .optional()
+          .describe('The number of images to generate. Must be between 1 and 10.'),
+        output_compression: z
+          .number()
+          .int()
+          .min(0)
+          .max(100)
+          .optional()
+          .describe('The compression level (0-100%) for webp or jpeg formats. Defaults to 100.'),
+           */
+        quality: z
+          .enum(['auto', 'high', 'medium', 'low'])
+          .optional()
+          .describe('The quality of the image. One of auto (default), high, medium, or low.'),
+        size: z
+          .enum(['auto', '1024x1024', '1536x1024', '1024x1536'])
+          .optional()
+          .describe(
+            'The size of the generated image. One of 1024x1024, 1536x1024 (landscape), 1024x1536 (portrait), or auto (default).',
+          ),
+      }),
+      responseFormat: 'content_and_artifact',
+    },
+  );
+
+  /**
+   * Image Editing Tool
+   */
+  const imageEditTool = tool(
+    async ({ prompt, image_ids, quality = 'auto', size = 'auto' }, runnableConfig) => {
+      if (!prompt) {
+        throw new Error('Missing required field: prompt');
+      }
+
+      const clientConfig = { ...closureConfig };
+      if (process.env.PROXY) {
+        clientConfig.httpAgent = new HttpsProxyAgent(process.env.PROXY);
+      }
+
+      const formData = new FormData();
+      formData.append('model', 'gpt-image-1');
+      formData.append('prompt', replaceUnwantedChars(prompt));
+      // TODO: `mask` support
+      // TODO: more than 1 image support
+      // formData.append('n', n.toString());
+      formData.append('quality', quality);
+      formData.append('size', size);
+
+      /** @type {Record<FileSources, undefined | NodeStreamDownloader<File>>} */
+      const streamMethods = {};
+
+      const requestFilesMap = Object.fromEntries(imageFiles.map((f) => [f.file_id, { ...f }]));
+
+      const orderedFiles = new Array(image_ids.length);
+      const idsToFetch = [];
+      const indexOfMissing = Object.create(null);
+
+      for (let i = 0; i < image_ids.length; i++) {
+        const id = image_ids[i];
+        const file = requestFilesMap[id];
+
+        if (file) {
+          orderedFiles[i] = file;
+        } else {
+          idsToFetch.push(id);
+          indexOfMissing[id] = i;
+        }
+      }
+
+      if (idsToFetch.length) {
+        const fetchedFiles = await getFiles(
+          {
+            user: req.user.id,
+            file_id: { $in: idsToFetch },
+            height: { $exists: true },
+            width: { $exists: true },
+          },
+          {},
+          {},
+        );
+
+        for (const file of fetchedFiles) {
+          requestFilesMap[file.file_id] = file;
+          orderedFiles[indexOfMissing[file.file_id]] = file;
+        }
+      }
+      for (const imageFile of orderedFiles) {
+        if (!imageFile) {
+          continue;
+        }
+        /** @type {NodeStream<File>} */
+        let stream;
+        /** @type {NodeStreamDownloader<File>} */
+        let getDownloadStream;
+        const source = imageFile.source || appFileStrategy;
+        if (!source) {
+          throw new Error('No source found for image file');
+        }
+        if (streamMethods[source]) {
+          getDownloadStream = streamMethods[source];
+        } else {
+          ({ getDownloadStream } = getStrategyFunctions(source));
+          streamMethods[source] = getDownloadStream;
+        }
+        if (!getDownloadStream) {
+          throw new Error(`No download stream method found for source: ${source}`);
+        }
+        stream = await getDownloadStream(req, imageFile.filepath);
+        if (!stream) {
+          throw new Error('Failed to get download stream for image file');
+        }
+        formData.append('image[]', stream, {
+          filename: imageFile.filename,
+          contentType: imageFile.type,
+        });
+      }
+
+      /** @type {import('axios').RawAxiosHeaders} */
+      let headers = {
+        ...formData.getHeaders(),
+      };
+
+      if (process.env.IMAGE_GEN_OAI_AZURE_API_VERSION && process.env.IMAGE_GEN_OAI_BASEURL) {
+        headers['api-key'] = apiKey;
+      } else {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+      }
+
+      try {
+        const derivedSignal = runnableConfig?.signal
+          ? AbortSignal.any([runnableConfig.signal])
+          : undefined;
+
+        /** @type {import('axios').AxiosRequestConfig} */
+        const axiosConfig = {
+          headers,
+          ...clientConfig,
+          signal: derivedSignal,
+          baseURL,
+        };
+
+        if (process.env.IMAGE_GEN_OAI_AZURE_API_VERSION && process.env.IMAGE_GEN_OAI_BASEURL) {
+          axiosConfig.params = {
+            'api-version': process.env.IMAGE_GEN_OAI_AZURE_API_VERSION,
+            ...axiosConfig.params,
+          };
+        }
+        const response = await axios.post('/images/edits', formData, axiosConfig);
+
+        if (!response.data || !response.data.data || !response.data.data.length) {
+          return returnValue(
+            'No image data returned from OpenAI API. There may be a problem with the API or your configuration.',
+          );
+        }
+
+        const base64Image = response.data.data[0].b64_json;
+        if (!base64Image) {
+          return returnValue(
+            'No image data returned from OpenAI API. There may be a problem with the API or your configuration.',
+          );
+        }
+
+        const content = [
+          {
+            type: ContentTypes.IMAGE_URL,
+            image_url: {
+              url: `data:image/${imageOutputType};base64,${base64Image}`,
+            },
+          },
+        ];
+
+        const file_ids = [v4()];
+        const textResponse = [
+          {
+            type: ContentTypes.TEXT,
+            text:
+              displayMessage +
+              `\n\ngenerated_image_id: "${file_ids[0]}"\nreferenced_image_ids: ["${image_ids.join('", "')}"]`,
+          },
+        ];
+        return [textResponse, { content, file_ids }];
+      } catch (error) {
+        const message = '[image_edit_oai] Problem editing the image:';
+        logAxiosError({ error, message });
+        return returnValue(`Something went wrong when trying to edit the image. The OpenAI API may be unavailable:
+Error Message: ${error.message || 'Unknown error'}`);
+      }
+    },
+    {
+      name: 'image_edit_oai',
+      description: getImageEditDescription(),
+      schema: z.object({
+        image_ids: z
+          .array(z.string())
+          .min(1)
+          .describe(
+            `
+IDs (image ID strings) of previously generated or uploaded images that should guide the edit.
+
+Guidelines:
+- If the user's request depends on any prior image(s), copy their image IDs into the \`image_ids\` array (in the same order the user refers to them).  
+- Never invent or hallucinate IDs; only use IDs that are still visible in the conversation context.
+- If no earlier image is relevant, omit the field entirely.
+`.trim(),
+          ),
+        prompt: z.string().max(32000).describe(getImageEditPromptDescription()),
+        /*
+        n: z
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .optional()
+          .describe('The number of images to generate. Must be between 1 and 10. Defaults to 1.'),
+        */
+        quality: z
+          .enum(['auto', 'high', 'medium', 'low'])
+          .optional()
+          .describe(
+            'The quality of the image. One of auto (default), high, medium, or low. High/medium/low only supported for gpt-image-1.',
+          ),
+        size: z
+          .enum(['auto', '1024x1024', '1536x1024', '1024x1536', '256x256', '512x512'])
+          .optional()
+          .describe(
+            'The size of the generated images. For gpt-image-1: auto (default), 1024x1024, 1536x1024, 1024x1536. For dall-e-2: 256x256, 512x512, 1024x1024.',
+          ),
+      }),
+      responseFormat: 'content_and_artifact',
+    },
+  );
+
+  return [imageGenTool, imageEditTool];
+}
+
+module.exports = createOpenAIImageTools;

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

@@ -1,7 +1,7 @@
-const { Tools, Constants } = require('librechat-data-provider');
 const { SerpAPI } = require('@langchain/community/tools/serpapi');
 const { Calculator } = require('@langchain/community/tools/calculator');
 const { createCodeExecutionTool, EnvVar } = require('@librechat/agents');
+const { Tools, Constants, EToolResources } = require('librechat-data-provider');
 const { getUserPluginAuthValue } = require('~/server/services/PluginService');
 const {
   availableTools,
@@ -18,6 +18,7 @@ const {
   StructuredWolfram,
   createYouTubeTools,
   TavilySearchResults,
+  createOpenAIImageTools,
 } = require('../');
 const { primeFiles: primeCodeFiles } = require('~/server/services/Files/Code/process');
 const { createFileSearchTool, primeFiles: primeSearchFiles } = require('./fileSearch');
@@ -123,7 +124,7 @@ const getAuthFields = (toolKey) => {
  *
  * @param {object} object
  * @param {string} object.user
- * @param {Agent} [object.agent]
+ * @param {Pick<Agent, 'id' | 'provider' | 'model'>} [object.agent]
  * @param {string} [object.model]
  * @param {EModelEndpoint} [object.endpoint]
  * @param {LoadToolOptions} [object.options]
@@ -157,7 +158,7 @@ const loadTools = async ({
   };
 
   const customConstructors = {
-    serpapi: async () => {
+    serpapi: async (_toolContextMap) => {
       const authFields = getAuthFields('serpapi');
       let envVar = authFields[0] ?? '';
       let apiKey = process.env[envVar];
@@ -170,11 +171,40 @@ const loadTools = async ({
         gl: 'us',
       });
     },
-    youtube: async () => {
+    youtube: async (_toolContextMap) => {
       const authFields = getAuthFields('youtube');
       const authValues = await loadAuthValues({ userId: user, authFields });
       return createYouTubeTools(authValues);
     },
+    image_gen_oai: async (toolContextMap) => {
+      const authFields = getAuthFields('image_gen_oai');
+      const authValues = await loadAuthValues({ userId: user, authFields });
+      const imageFiles = options.tool_resources?.[EToolResources.image_edit]?.files ?? [];
+      let toolContext = '';
+      for (let i = 0; i < imageFiles.length; i++) {
+        const file = imageFiles[i];
+        if (!file) {
+          continue;
+        }
+        if (i === 0) {
+          toolContext =
+            'Image files provided in this request (their image IDs listed in order of appearance) available for image editing:';
+        }
+        toolContext += `\n\t- ${file.file_id}`;
+        if (i === imageFiles.length - 1) {
+          toolContext += `\n\nInclude any you need in the \`image_ids\` array when calling \`${EToolResources.image_edit}_oai\`. You may also include previously referenced or generated image IDs.`;
+        }
+      }
+      if (toolContext) {
+        toolContextMap.image_edit_oai = toolContext;
+      }
+      return createOpenAIImageTools({
+        ...authValues,
+        isAgent: !!agent,
+        req: options.req,
+        imageFiles,
+      });
+    },
   };
 
   const requestedTools = {};
@@ -200,6 +230,7 @@ const loadTools = async ({
     serpapi: { location: 'Austin,Texas,United States', hl: 'en', gl: 'us' },
   };
 
+  /** @type {Record<string, string>} */
   const toolContextMap = {};
   const remainingTools = [];
   const appTools = options.req?.app?.locals?.availableTools ?? {};
@@ -246,7 +277,7 @@ const loadTools = async ({
     }
 
     if (customConstructors[tool]) {
-      requestedTools[tool] = customConstructors[tool];
+      requestedTools[tool] = async () => customConstructors[tool](toolContextMap);
       continue;
     }
 

api/cache/clearPendingReq.js

@@ -1,7 +1,8 @@
+const { Time, CacheKeys } = require('librechat-data-provider');
+const { isEnabled } = require('~/server/utils');
 const getLogStores = require('./getLogStores');
-const { isEnabled } = require('../server/utils');
+
 const { USE_REDIS, LIMIT_CONCURRENT_MESSAGES } = process.env ?? {};
-const ttl = 1000 * 60 * 1;
 
 /**
  * Clear or decrement pending requests from the cache.
@@ -28,7 +29,7 @@ const clearPendingReq = async ({ userId, cache: _cache }) => {
     return;
   }
 
-  const namespace = 'pending_req';
+  const namespace = CacheKeys.PENDING_REQ;
   const cache = _cache ?? getLogStores(namespace);
 
   if (!cache) {
@@ -39,7 +40,7 @@ const clearPendingReq = async ({ userId, cache: _cache }) => {
   const currentReq = +((await cache.get(key)) ?? 0);
 
   if (currentReq && currentReq >= 1) {
-    await cache.set(key, currentReq - 1, ttl);
+    await cache.set(key, currentReq - 1, Time.ONE_MINUTE);
   } else {
     await cache.delete(key);
   }

api/cache/getLogStores.js

@@ -1,4 +1,4 @@
-const Keyv = require('keyv');
+const { Keyv } = require('keyv');
 const { CacheKeys, ViolationTypes, Time } = require('librechat-data-provider');
 const { logFile, violationFile } = require('./keyvFiles');
 const { math, isEnabled } = require('~/server/utils');
@@ -19,7 +19,7 @@ const createViolationInstance = (namespace) => {
 // Serve cache from memory so no need to clear it on startup/exit
 const pending_req = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
-  : new Keyv({ namespace: 'pending_req' });
+  : new Keyv({ namespace: CacheKeys.PENDING_REQ });
 
 const config = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
@@ -64,7 +64,7 @@ const abortKeys = isRedisEnabled
 const namespaces = {
   [CacheKeys.ROLES]: roles,
   [CacheKeys.CONFIG_STORE]: config,
-  pending_req,
+  [CacheKeys.PENDING_REQ]: pending_req,
   [ViolationTypes.BAN]: new Keyv({ store: keyvMongo, namespace: CacheKeys.BANS, ttl: duration }),
   [CacheKeys.ENCODED_DOMAINS]: new Keyv({
     store: keyvMongo,

api/cache/ioredisClient.js

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const Redis = require('ioredis');
+const { isEnabled } = require('~/server/utils');
+const logger = require('~/config/winston');
+
+const { REDIS_URI, USE_REDIS, USE_REDIS_CLUSTER, REDIS_CA, REDIS_MAX_LISTENERS } = process.env;
+
+/** @type {import('ioredis').Redis | import('ioredis').Cluster} */
+let ioredisClient;
+const redis_max_listeners = Number(REDIS_MAX_LISTENERS) || 40;
+
+function mapURI(uri) {
+  const regex =
+    /^(?:(?<scheme>\w+):\/\/)?(?:(?<user>[^:@]+)(?::(?<password>[^@]+))?@)?(?<host>[\w.-]+)(?::(?<port>\d{1,5}))?$/;
+  const match = uri.match(regex);
+
+  if (match) {
+    const { scheme, user, password, host, port } = match.groups;
+
+    return {
+      scheme: scheme || 'none',
+      user: user || null,
+      password: password || null,
+      host: host || null,
+      port: port || null,
+    };
+  } else {
+    const parts = uri.split(':');
+    if (parts.length === 2) {
+      return {
+        scheme: 'none',
+        user: null,
+        password: null,
+        host: parts[0],
+        port: parts[1],
+      };
+    }
+
+    return {
+      scheme: 'none',
+      user: null,
+      password: null,
+      host: uri,
+      port: null,
+    };
+  }
+}
+
+if (REDIS_URI && isEnabled(USE_REDIS)) {
+  let redisOptions = null;
+
+  if (REDIS_CA) {
+    const ca = fs.readFileSync(REDIS_CA);
+    redisOptions = { tls: { ca } };
+  }
+
+  if (isEnabled(USE_REDIS_CLUSTER)) {
+    const hosts = REDIS_URI.split(',').map((item) => {
+      var value = mapURI(item);
+
+      return {
+        host: value.host,
+        port: value.port,
+      };
+    });
+    ioredisClient = new Redis.Cluster(hosts, { redisOptions });
+  } else {
+    ioredisClient = new Redis(REDIS_URI, redisOptions);
+  }
+
+  ioredisClient.on('ready', () => {
+    logger.info('IoRedis connection ready');
+  });
+  ioredisClient.on('reconnecting', () => {
+    logger.info('IoRedis connection reconnecting');
+  });
+  ioredisClient.on('end', () => {
+    logger.info('IoRedis connection ended');
+  });
+  ioredisClient.on('close', () => {
+    logger.info('IoRedis connection closed');
+  });
+  ioredisClient.on('error', (err) => logger.error('IoRedis connection error:', err));
+  ioredisClient.setMaxListeners(redis_max_listeners);
+  logger.info(
+    '[Optional] IoRedis initialized for rate limiters. If you have issues, disable Redis or restart the server.',
+  );
+} else {
+  logger.info('[Optional] IoRedis not initialized for rate limiters.');
+}
+
+module.exports = ioredisClient;

api/cache/keyvFiles.js

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

api/cache/keyvMongo.js

@@ -1,9 +1,272 @@
-const KeyvMongo = require('@keyv/mongo');
+// api/cache/keyvMongo.js
+const mongoose = require('mongoose');
+const EventEmitter = require('events');
+const { GridFSBucket } = require('mongodb');
 const { logger } = require('~/config');
 
-const { MONGO_URI } = process.env ?? {};
+const storeMap = new Map();
+
+class KeyvMongoCustom extends EventEmitter {
+  constructor(url, options = {}) {
+    super();
+
+    url = url || {};
+    if (typeof url === 'string') {
+      url = { url };
+    }
+    if (url.uri) {
+      url = { url: url.uri, ...url };
+    }
+
+    this.opts = {
+      url: 'mongodb://127.0.0.1:27017',
+      collection: 'keyv',
+      ...url,
+      ...options,
+    };
+
+    this.ttlSupport = false;
+
+    // Filter valid options
+    const keyvMongoKeys = new Set([
+      'url',
+      'collection',
+      'namespace',
+      'serialize',
+      'deserialize',
+      'uri',
+      'useGridFS',
+      'dialect',
+    ]);
+    this.opts = Object.fromEntries(Object.entries(this.opts).filter(([k]) => keyvMongoKeys.has(k)));
+  }
+
+  // Helper to access the store WITHOUT storing a promise on the instance
+  _getClient() {
+    const storeKey = `${this.opts.collection}:${this.opts.useGridFS ? 'gridfs' : 'collection'}`;
+
+    // If we already have the store initialized, return it directly
+    if (storeMap.has(storeKey)) {
+      return Promise.resolve(storeMap.get(storeKey));
+    }
+
+    // Check mongoose connection state
+    if (mongoose.connection.readyState !== 1) {
+      return Promise.reject(
+        new Error('Mongoose connection not ready. Ensure connectDb() is called first.'),
+      );
+    }
+
+    try {
+      const db = mongoose.connection.db;
+      let client;
+
+      if (this.opts.useGridFS) {
+        const bucket = new GridFSBucket(db, {
+          readPreference: this.opts.readPreference,
+          bucketName: this.opts.collection,
+        });
+        const store = db.collection(`${this.opts.collection}.files`);
+        client = { bucket, store, db };
+      } else {
+        const collection = this.opts.collection || 'keyv';
+        const store = db.collection(collection);
+        client = { store, db };
+      }
+
+      storeMap.set(storeKey, client);
+      return Promise.resolve(client);
+    } catch (error) {
+      this.emit('error', error);
+      return Promise.reject(error);
+    }
+  }
+
+  async get(key) {
+    const client = await this._getClient();
+
+    if (this.opts.useGridFS) {
+      await client.store.updateOne(
+        {
+          filename: key,
+        },
+        {
+          $set: {
+            'metadata.lastAccessed': new Date(),
+          },
+        },
+      );
+
+      const stream = client.bucket.openDownloadStreamByName(key);
+
+      return new Promise((resolve) => {
+        const resp = [];
+        stream.on('error', () => {
+          resolve(undefined);
+        });
+
+        stream.on('end', () => {
+          const data = Buffer.concat(resp).toString('utf8');
+          resolve(data);
+        });
+
+        stream.on('data', (chunk) => {
+          resp.push(chunk);
+        });
+      });
+    }
+
+    const document = await client.store.findOne({ key: { $eq: key } });
+
+    if (!document) {
+      return undefined;
+    }
+
+    return document.value;
+  }
+
+  async getMany(keys) {
+    const client = await this._getClient();
+
+    if (this.opts.useGridFS) {
+      const promises = [];
+      for (const key of keys) {
+        promises.push(this.get(key));
+      }
+
+      const values = await Promise.allSettled(promises);
+      const data = [];
+      for (const value of values) {
+        data.push(value.value);
+      }
+
+      return data;
+    }
+
+    const values = await client.store
+      .find({ key: { $in: keys } })
+      .project({ _id: 0, value: 1, key: 1 })
+      .toArray();
+
+    const results = [...keys];
+    let i = 0;
+    for (const key of keys) {
+      const rowIndex = values.findIndex((row) => row.key === key);
+      results[i] = rowIndex > -1 ? values[rowIndex].value : undefined;
+      i++;
+    }
+
+    return results;
+  }
+
+  async set(key, value, ttl) {
+    const client = await this._getClient();
+    const expiresAt = typeof ttl === 'number' ? new Date(Date.now() + ttl) : null;
+
+    if (this.opts.useGridFS) {
+      const stream = client.bucket.openUploadStream(key, {
+        metadata: {
+          expiresAt,
+          lastAccessed: new Date(),
+        },
+      });
+
+      return new Promise((resolve) => {
+        stream.on('finish', () => {
+          resolve(stream);
+        });
+        stream.end(value);
+      });
+    }
+
+    await client.store.updateOne(
+      { key: { $eq: key } },
+      { $set: { key, value, expiresAt } },
+      { upsert: true },
+    );
+  }
+
+  async delete(key) {
+    if (typeof key !== 'string') {
+      return false;
+    }
+
+    const client = await this._getClient();
+
+    if (this.opts.useGridFS) {
+      try {
+        const bucket = new GridFSBucket(client.db, {
+          bucketName: this.opts.collection,
+        });
+        const files = await bucket.find({ filename: key }).toArray();
+        await client.bucket.delete(files[0]._id);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    const object = await client.store.deleteOne({ key: { $eq: key } });
+    return object.deletedCount > 0;
+  }
+
+  async deleteMany(keys) {
+    const client = await this._getClient();
+
+    if (this.opts.useGridFS) {
+      const bucket = new GridFSBucket(client.db, {
+        bucketName: this.opts.collection,
+      });
+      const files = await bucket.find({ filename: { $in: keys } }).toArray();
+      if (files.length === 0) {
+        return false;
+      }
+
+      await Promise.all(files.map(async (file) => client.bucket.delete(file._id)));
+      return true;
+    }
+
+    const object = await client.store.deleteMany({ key: { $in: keys } });
+    return object.deletedCount > 0;
+  }
+
+  async clear() {
+    const client = await this._getClient();
+
+    if (this.opts.useGridFS) {
+      try {
+        await client.bucket.drop();
+      } catch (error) {
+        // Throw error if not "namespace not found" error
+        if (!(error.code === 26)) {
+          throw error;
+        }
+      }
+    }
+
+    await client.store.deleteMany({
+      key: { $regex: this.namespace ? `^${this.namespace}:*` : '' },
+    });
+  }
+
+  async has(key) {
+    const client = await this._getClient();
+    const filter = { [this.opts.useGridFS ? 'filename' : 'key']: { $eq: key } };
+    const document = await client.store.countDocuments(filter, { limit: 1 });
+    return document !== 0;
+  }
+
+  // No-op disconnect
+  async disconnect() {
+    // This is a no-op since we don't want to close the shared mongoose connection
+    return true;
+  }
+}
+
+const keyvMongo = new KeyvMongoCustom({
+  collection: 'logs',
+});
 
-const keyvMongo = new KeyvMongo(MONGO_URI, { collection: 'logs' });
 keyvMongo.on('error', (err) => logger.error('KeyvMongo connection error:', err));
 
 module.exports = keyvMongo;

api/cache/keyvRedis.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const ioredis = require('ioredis');
-const KeyvRedis = require('@keyv/redis');
+const KeyvRedis = require('@keyv/redis').default;
 const { isEnabled } = require('~/server/utils');
 const logger = require('~/config/winston');
 
@@ -50,6 +50,7 @@ function mapURI(uri) {
 
 if (REDIS_URI && isEnabled(USE_REDIS)) {
   let redisOptions = null;
+  /** @type {import('@keyv/redis').KeyvRedisOptions} */
   let keyvOpts = {
     useRedisSets: false,
     keyPrefix: redis_prefix,
@@ -74,6 +75,18 @@ if (REDIS_URI && isEnabled(USE_REDIS)) {
   } else {
     keyvRedis = new KeyvRedis(REDIS_URI, keyvOpts);
   }
+  keyvRedis.on('ready', () => {
+    logger.info('KeyvRedis connection ready');
+  });
+  keyvRedis.on('reconnecting', () => {
+    logger.info('KeyvRedis connection reconnecting');
+  });
+  keyvRedis.on('end', () => {
+    logger.info('KeyvRedis connection ended');
+  });
+  keyvRedis.on('close', () => {
+    logger.info('KeyvRedis connection closed');
+  });
   keyvRedis.on('error', (err) => logger.error('KeyvRedis connection error:', err));
   keyvRedis.setMaxListeners(redis_max_listeners);
   logger.info(

api/cache/redis.js

@@ -1,4 +0,0 @@
-const Redis = require('ioredis');
-const { REDIS_URI } = process.env ?? {};
-const redis = new Redis.Cluster(REDIS_URI);
-module.exports = redis;

api/config/index.js

@@ -1,32 +1,35 @@
 const axios = require('axios');
 const { EventSource } = require('eventsource');
 const { Time, CacheKeys } = require('librechat-data-provider');
+const { MCPManager, FlowStateManager } = require('librechat-mcp');
 const logger = require('./winston');
 
 global.EventSource = EventSource;
 
+/** @type {MCPManager} */
 let mcpManager = null;
 let flowManager = null;
 
 /**
- * @returns {Promise<MCPManager>}
+ * @param {string} [userId] - Optional user ID, to avoid disconnecting the current user.
+ * @returns {MCPManager}
  */
-async function getMCPManager() {
+function getMCPManager(userId) {
   if (!mcpManager) {
-    const { MCPManager } = await import('librechat-mcp');
     mcpManager = MCPManager.getInstance(logger);
+  } else {
+    mcpManager.checkIdleConnections(userId);
   }
   return mcpManager;
 }
 
 /**
- * @param {(key: string) => Keyv} getLogStores
- * @returns {Promise<FlowStateManager>}
+ * @param {Keyv} flowsCache
+ * @returns {FlowStateManager}
  */
-async function getFlowStateManager(getLogStores) {
+function getFlowStateManager(flowsCache) {
   if (!flowManager) {
-    const { FlowStateManager } = await import('librechat-mcp');
-    flowManager = new FlowStateManager(getLogStores(CacheKeys.FLOWS), {
+    flowManager = new FlowStateManager(flowsCache, {
       ttl: Time.ONE_MINUTE * 3,
       logger,
     });

api/jest.config.js

@@ -5,7 +5,6 @@ module.exports = {
   coverageDirectory: 'coverage',
   setupFiles: [
     './test/jestSetup.js',
-    './test/__mocks__/KeyvMongo.js',
     './test/__mocks__/logger.js',
     './test/__mocks__/fetchEventSource.js',
   ],

api/lib/utils/reduceHits.js

@@ -1,59 +0,0 @@
-const mergeSort = require('./mergeSort');
-const { cleanUpPrimaryKeyValue } = require('./misc');
-
-function reduceMessages(hits) {
-  const counts = {};
-
-  for (const hit of hits) {
-    if (!counts[hit.conversationId]) {
-      counts[hit.conversationId] = 1;
-    } else {
-      counts[hit.conversationId]++;
-    }
-  }
-
-  const result = [];
-
-  for (const [conversationId, count] of Object.entries(counts)) {
-    result.push({
-      conversationId,
-      count,
-    });
-  }
-
-  return mergeSort(result, (a, b) => b.count - a.count);
-}
-
-function reduceHits(hits, titles = []) {
-  const counts = {};
-  const titleMap = {};
-  const convos = [...hits, ...titles];
-
-  for (const convo of convos) {
-    const currentId = cleanUpPrimaryKeyValue(convo.conversationId);
-    if (!counts[currentId]) {
-      counts[currentId] = 1;
-    } else {
-      counts[currentId]++;
-    }
-
-    if (convo.title) {
-      // titleMap[currentId] = convo._formatted.title;
-      titleMap[currentId] = convo.title;
-    }
-  }
-
-  const result = [];
-
-  for (const [conversationId, count] of Object.entries(counts)) {
-    result.push({
-      conversationId,
-      count,
-      title: titleMap[conversationId] ? titleMap[conversationId] : null,
-    });
-  }
-
-  return mergeSort(result, (a, b) => b.count - a.count);
-}
-
-module.exports = { reduceMessages, reduceHits };

api/models/Agent.js

@@ -1,6 +1,8 @@
 const mongoose = require('mongoose');
-const { SystemRoles } = require('librechat-data-provider');
-const { GLOBAL_PROJECT_NAME } = require('librechat-data-provider').Constants;
+const { agentSchema } = require('@librechat/data-schemas');
+const { SystemRoles, Tools } = require('librechat-data-provider');
+const { GLOBAL_PROJECT_NAME, EPHEMERAL_AGENT_ID, mcp_delimiter } =
+  require('librechat-data-provider').Constants;
 const { CONFIG_STORE, STARTUP_CONFIG } = require('librechat-data-provider').CacheKeys;
 const {
   getProjectByName,
@@ -9,7 +11,6 @@ const {
   removeAgentFromAllProjects,
 } = require('./Project');
 const getLogStores = require('~/cache/getLogStores');
-const { agentSchema } = require('@librechat/data-schemas');
 
 const Agent = mongoose.model('agent', agentSchema);
 
@@ -39,9 +40,61 @@ const getAgent = async (searchParameter) => await Agent.findOne(searchParameter)
  * @param {Object} params
  * @param {ServerRequest} params.req
  * @param {string} params.agent_id
+ * @param {string} params.endpoint
+ * @param {import('@librechat/agents').ClientOptions} [params.model_parameters]
+ * @returns {Agent|null} The agent document as a plain object, or null if not found.
+ */
+const loadEphemeralAgent = ({ req, agent_id, endpoint, model_parameters: _m }) => {
+  const { model, ...model_parameters } = _m;
+  /** @type {Record<string, FunctionTool>} */
+  const availableTools = req.app.locals.availableTools;
+  const mcpServers = new Set(req.body.ephemeralAgent?.mcp);
+  /** @type {string[]} */
+  const tools = [];
+  if (req.body.ephemeralAgent?.execute_code === true) {
+    tools.push(Tools.execute_code);
+  }
+
+  if (mcpServers.size > 0) {
+    for (const toolName of Object.keys(availableTools)) {
+      if (!toolName.includes(mcp_delimiter)) {
+        continue;
+      }
+      const mcpServer = toolName.split(mcp_delimiter)?.[1];
+      if (mcpServer && mcpServers.has(mcpServer)) {
+        tools.push(toolName);
+      }
+    }
+  }
+
+  const instructions = req.body.promptPrefix;
+  return {
+    id: agent_id,
+    instructions,
+    provider: endpoint,
+    model_parameters,
+    model,
+    tools,
+  };
+};
+
+/**
+ * Load an agent based on the provided ID
+ *
+ * @param {Object} params
+ * @param {ServerRequest} params.req
+ * @param {string} params.agent_id
+ * @param {string} params.endpoint
+ * @param {import('@librechat/agents').ClientOptions} [params.model_parameters]
  * @returns {Promise<Agent|null>} The agent document as a plain object, or null if not found.
  */
-const loadAgent = async ({ req, agent_id }) => {
+const loadAgent = async ({ req, agent_id, endpoint, model_parameters }) => {
+  if (!agent_id) {
+    return null;
+  }
+  if (agent_id === EPHEMERAL_AGENT_ID) {
+    return loadEphemeralAgent({ req, agent_id, endpoint, model_parameters });
+  }
   const agent = await getAgent({
     id: agent_id,
   });
@@ -100,9 +153,11 @@ const updateAgent = async (searchParameter, updateData) => {
  */
 const addAgentResourceFile = async ({ agent_id, tool_resource, file_id }) => {
   const searchParameter = { id: agent_id };
-
+  let agent = await getAgent(searchParameter);
+  if (!agent) {
+    throw new Error('Agent not found for adding resource file');
+  }
   const fileIdsPath = `tool_resources.${tool_resource}.file_ids`;
-
   await Agent.updateOne(
     {
       id: agent_id,
@@ -115,7 +170,12 @@ const addAgentResourceFile = async ({ agent_id, tool_resource, file_id }) => {
     },
   );
 
-  const updateData = { $addToSet: { [fileIdsPath]: file_id } };
+  const updateData = {
+    $addToSet: {
+      tools: tool_resource,
+      [fileIdsPath]: file_id,
+    },
+  };
 
   const updatedAgent = await updateAgent(searchParameter, updateData);
   if (updatedAgent) {
@@ -126,16 +186,17 @@ const addAgentResourceFile = async ({ agent_id, tool_resource, file_id }) => {
 };
 
 /**
- * Removes multiple resource files from an agent in a single update.
+ * Removes multiple resource files from an agent using atomic operations.
  * @param {object} params
  * @param {string} params.agent_id
  * @param {Array<{tool_resource: string, file_id: string}>} params.files
  * @returns {Promise<Agent>} The updated agent.
+ * @throws {Error} If the agent is not found or update fails.
  */
 const removeAgentResourceFiles = async ({ agent_id, files }) => {
   const searchParameter = { id: agent_id };
 
-  // associate each tool resource with the respective file ids array
+  // Group files to remove by resource
   const filesByResource = files.reduce((acc, { tool_resource, file_id }) => {
     if (!acc[tool_resource]) {
       acc[tool_resource] = [];
@@ -144,42 +205,35 @@ const removeAgentResourceFiles = async ({ agent_id, files }) => {
     return acc;
   }, {});
 
-  // build the update aggregation pipeline wich removes file ids from tool resources array
-  // and eventually deletes empty tool resources
-  const updateData = [];
-  Object.entries(filesByResource).forEach(([resource, fileIds]) => {
-    const toolResourcePath = `tool_resources.${resource}`;
-    const fileIdsPath = `${toolResourcePath}.file_ids`;
-
-    // file ids removal stage
-    updateData.push({
-      $set: {
-        [fileIdsPath]: {
-          $filter: {
-            input: `$${fileIdsPath}`,
-            cond: { $not: [{ $in: ['$$this', fileIds] }] },
-          },
-        },
-      },
-    });
-
-    // empty tool resource deletion stage
-    updateData.push({
-      $set: {
-        [toolResourcePath]: {
-          $cond: [{ $eq: [`$${fileIdsPath}`, []] }, '$$REMOVE', `$${toolResourcePath}`],
-        },
-      },
-    });
-  });
-
-  // return the updated agent or throw if no agent matches
-  const updatedAgent = await updateAgent(searchParameter, updateData);
-  if (updatedAgent) {
-    return updatedAgent;
-  } else {
-    throw new Error('Agent not found for removing resource files');
+  // Step 1: Atomically remove file IDs using $pull
+  const pullOps = {};
+  const resourcesToCheck = new Set();
+  for (const [resource, fileIds] of Object.entries(filesByResource)) {
+    const fileIdsPath = `tool_resources.${resource}.file_ids`;
+    pullOps[fileIdsPath] = { $in: fileIds };
+    resourcesToCheck.add(resource);
   }
+
+  const updatePullData = { $pull: pullOps };
+  const agentAfterPull = await Agent.findOneAndUpdate(searchParameter, updatePullData, {
+    new: true,
+  }).lean();
+
+  if (!agentAfterPull) {
+    // Agent might have been deleted concurrently, or never existed.
+    // Check if it existed before trying to throw.
+    const agentExists = await getAgent(searchParameter);
+    if (!agentExists) {
+      throw new Error('Agent not found for removing resource files');
+    }
+    // If it existed but findOneAndUpdate returned null, something else went wrong.
+    throw new Error('Failed to update agent during file removal (pull step)');
+  }
+
+  // Return the agent state directly after the $pull operation.
+  // Skipping the $unset step for now to simplify and test core $pull atomicity.
+  // Empty arrays might remain, but the removal itself should be correct.
+  return agentAfterPull;
 };
 
 /**

api/models/Agent.spec.js

@@ -33,6 +33,50 @@ describe('Agent Resource File Operations', () => {
     return agent;
   };
 
+  test('should add tool_resource to tools if missing', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+    const toolResource = 'file_search';
+
+    const updatedAgent = await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: toolResource,
+      file_id: fileId,
+    });
+
+    expect(updatedAgent.tools).toContain(toolResource);
+    expect(Array.isArray(updatedAgent.tools)).toBe(true);
+    // Should not duplicate
+    const count = updatedAgent.tools.filter((t) => t === toolResource).length;
+    expect(count).toBe(1);
+  });
+
+  test('should not duplicate tool_resource in tools if already present', async () => {
+    const agent = await createBasicAgent();
+    const fileId1 = uuidv4();
+    const fileId2 = uuidv4();
+    const toolResource = 'file_search';
+
+    // First add
+    await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: toolResource,
+      file_id: fileId1,
+    });
+
+    // Second add (should not duplicate)
+    const updatedAgent = await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: toolResource,
+      file_id: fileId2,
+    });
+
+    expect(updatedAgent.tools).toContain(toolResource);
+    expect(Array.isArray(updatedAgent.tools)).toBe(true);
+    const count = updatedAgent.tools.filter((t) => t === toolResource).length;
+    expect(count).toBe(1);
+  });
+
   test('should handle concurrent file additions', async () => {
     const agent = await createBasicAgent();
     const fileIds = Array.from({ length: 10 }, () => uuidv4());
@@ -157,4 +201,134 @@ describe('Agent Resource File Operations', () => {
       expect(updatedAgent.tool_resources[tool].file_ids).toHaveLength(5);
     });
   });
+
+  test('should handle concurrent duplicate additions', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+
+    // Concurrent additions of the same file
+    const additionPromises = Array.from({ length: 5 }).map(() =>
+      addAgentResourceFile({
+        agent_id: agent.id,
+        tool_resource: 'test_tool',
+        file_id: fileId,
+      }),
+    );
+
+    await Promise.all(additionPromises);
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toBeDefined();
+    // Should only contain one instance of the fileId
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toHaveLength(1);
+    expect(updatedAgent.tool_resources.test_tool.file_ids[0]).toBe(fileId);
+  });
+
+  test('should handle concurrent add and remove of the same file', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+
+    // First, ensure the file exists (or test might be trivial if remove runs first)
+    await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: 'test_tool',
+      file_id: fileId,
+    });
+
+    // Concurrent add (which should be ignored) and remove
+    const operations = [
+      addAgentResourceFile({
+        agent_id: agent.id,
+        tool_resource: 'test_tool',
+        file_id: fileId,
+      }),
+      removeAgentResourceFiles({
+        agent_id: agent.id,
+        files: [{ tool_resource: 'test_tool', file_id: fileId }],
+      }),
+    ];
+
+    await Promise.all(operations);
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    // The final state should ideally be that the file is removed,
+    // but the key point is consistency (not duplicated or error state).
+    // Depending on execution order, the file might remain if the add operation's
+    // findOneAndUpdate runs after the remove operation completes.
+    // A more robust check might be that the length is <= 1.
+    // Given the remove uses an update pipeline, it might be more likely to win.
+    // The final state depends on race condition timing (add or remove might "win").
+    // The critical part is that the state is consistent (no duplicates, no errors).
+    // Assert that the fileId is either present exactly once or not present at all.
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toBeDefined();
+    const finalFileIds = updatedAgent.tool_resources.test_tool.file_ids;
+    const count = finalFileIds.filter((id) => id === fileId).length;
+    expect(count).toBeLessThanOrEqual(1); // Should be 0 or 1, never more
+    // Optional: Check overall length is consistent with the count
+    if (count === 0) {
+      expect(finalFileIds).toHaveLength(0);
+    } else {
+      expect(finalFileIds).toHaveLength(1);
+      expect(finalFileIds[0]).toBe(fileId);
+    }
+  });
+
+  test('should handle concurrent duplicate removals', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+
+    // Add the file first
+    await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: 'test_tool',
+      file_id: fileId,
+    });
+
+    // Concurrent removals of the same file
+    const removalPromises = Array.from({ length: 5 }).map(() =>
+      removeAgentResourceFiles({
+        agent_id: agent.id,
+        files: [{ tool_resource: 'test_tool', file_id: fileId }],
+      }),
+    );
+
+    await Promise.all(removalPromises);
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    // Check if the array is empty or the tool resource itself is removed
+    const fileIds = updatedAgent.tool_resources?.test_tool?.file_ids ?? [];
+    expect(fileIds).toHaveLength(0);
+    expect(fileIds).not.toContain(fileId);
+  });
+
+  test('should handle concurrent removals of different files', async () => {
+    const agent = await createBasicAgent();
+    const fileIds = Array.from({ length: 10 }, () => uuidv4());
+
+    // Add all files first
+    await Promise.all(
+      fileIds.map((fileId) =>
+        addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: 'test_tool',
+          file_id: fileId,
+        }),
+      ),
+    );
+
+    // Concurrently remove all files
+    const removalPromises = fileIds.map((fileId) =>
+      removeAgentResourceFiles({
+        agent_id: agent.id,
+        files: [{ tool_resource: 'test_tool', file_id: fileId }],
+      }),
+    );
+
+    await Promise.all(removalPromises);
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    // Check if the array is empty or the tool resource itself is removed
+    const finalFileIds = updatedAgent.tool_resources?.test_tool?.file_ids ?? [];
+    expect(finalFileIds).toHaveLength(0);
+  });
 });

api/models/Conversation.js

@@ -88,11 +88,13 @@ module.exports = {
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
     try {
-      if (metadata && metadata?.context) {
+      if (metadata?.context) {
         logger.debug(`[saveConvo] ${metadata.context}`);
       }
+
       const messages = await getMessages({ conversationId }, '_id');
       const update = { ...convo, messages, user: req.user.id };
+
       if (newConversationId) {
         update.conversationId = newConversationId;
       }
@@ -148,75 +150,102 @@ module.exports = {
       throw new Error('Failed to save conversations in bulk.');
     }
   },
-  getConvosByPage: async (user, pageNumber = 1, pageSize = 25, isArchived = false, tags) => {
-    const query = { user };
+  getConvosByCursor: async (
+    user,
+    { cursor, limit = 25, isArchived = false, tags, search, order = 'desc' } = {},
+  ) => {
+    const filters = [{ user }];
+
     if (isArchived) {
-      query.isArchived = true;
+      filters.push({ isArchived: true });
     } else {
-      query.$or = [{ isArchived: false }, { isArchived: { $exists: false } }];
-    }
-    if (Array.isArray(tags) && tags.length > 0) {
-      query.tags = { $in: tags };
+      filters.push({ $or: [{ isArchived: false }, { isArchived: { $exists: false } }] });
     }
 
-    query.$and = [{ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] }];
+    if (Array.isArray(tags) && tags.length > 0) {
+      filters.push({ tags: { $in: tags } });
+    }
+
+    filters.push({ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] });
+
+    if (search) {
+      try {
+        const meiliResults = await Conversation.meiliSearch(search);
+        const matchingIds = Array.isArray(meiliResults.hits)
+          ? meiliResults.hits.map((result) => result.conversationId)
+          : [];
+        if (!matchingIds.length) {
+          return { conversations: [], nextCursor: null };
+        }
+        filters.push({ conversationId: { $in: matchingIds } });
+      } catch (error) {
+        logger.error('[getConvosByCursor] Error during meiliSearch', error);
+        return { message: 'Error during meiliSearch' };
+      }
+    }
+
+    if (cursor) {
+      filters.push({ updatedAt: { $lt: new Date(cursor) } });
+    }
+
+    const query = filters.length === 1 ? filters[0] : { $and: filters };
 
     try {
-      const totalConvos = (await Conversation.countDocuments(query)) || 1;
-      const totalPages = Math.ceil(totalConvos / pageSize);
       const convos = await Conversation.find(query)
-        .sort({ updatedAt: -1 })
-        .skip((pageNumber - 1) * pageSize)
-        .limit(pageSize)
+        .select(
+          'conversationId endpoint title createdAt updatedAt user model agent_id assistant_id spec iconURL',
+        )
+        .sort({ updatedAt: order === 'asc' ? 1 : -1 })
+        .limit(limit + 1)
         .lean();
-      return { conversations: convos, pages: totalPages, pageNumber, pageSize };
+
+      let nextCursor = null;
+      if (convos.length > limit) {
+        const lastConvo = convos.pop();
+        nextCursor = lastConvo.updatedAt.toISOString();
+      }
+
+      return { conversations: convos, nextCursor };
     } catch (error) {
-      logger.error('[getConvosByPage] Error getting conversations', error);
+      logger.error('[getConvosByCursor] Error getting conversations', error);
       return { message: 'Error getting conversations' };
     }
   },
-  getConvosQueried: async (user, convoIds, pageNumber = 1, pageSize = 25) => {
+  getConvosQueried: async (user, convoIds, cursor = null, limit = 25) => {
     try {
-      if (!convoIds || convoIds.length === 0) {
-        return { conversations: [], pages: 1, pageNumber, pageSize };
+      if (!convoIds?.length) {
+        return { conversations: [], nextCursor: null, convoMap: {} };
+      }
+
+      const conversationIds = convoIds.map((convo) => convo.conversationId);
+
+      const results = await Conversation.find({
+        user,
+        conversationId: { $in: conversationIds },
+        $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
+      }).lean();
+
+      results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+      let filtered = results;
+      if (cursor && cursor !== 'start') {
+        const cursorDate = new Date(cursor);
+        filtered = results.filter((convo) => new Date(convo.updatedAt) < cursorDate);
+      }
+
+      const limited = filtered.slice(0, limit + 1);
+      let nextCursor = null;
+      if (limited.length > limit) {
+        const lastConvo = limited.pop();
+        nextCursor = lastConvo.updatedAt.toISOString();
       }
 
-      const cache = {};
       const convoMap = {};
-      const promises = [];
-
-      convoIds.forEach((convo) =>
-        promises.push(
-          Conversation.findOne({
-            user,
-            conversationId: convo.conversationId,
-            $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
-          }).lean(),
-        ),
-      );
-
-      const results = (await Promise.all(promises)).filter(Boolean);
-
-      results.forEach((convo, i) => {
-        const page = Math.floor(i / pageSize) + 1;
-        if (!cache[page]) {
-          cache[page] = [];
-        }
-        cache[page].push(convo);
+      limited.forEach((convo) => {
         convoMap[convo.conversationId] = convo;
       });
 
-      const totalPages = Math.ceil(results.length / pageSize);
-      cache.pages = totalPages;
-      cache.pageSize = pageSize;
-      return {
-        cache,
-        conversations: cache[pageNumber] || [],
-        pages: totalPages || 1,
-        pageNumber,
-        pageSize,
-        convoMap,
-      };
+      return { conversations: limited, nextCursor, convoMap };
     } catch (error) {
       logger.error('[getConvosQueried] Error getting conversations', error);
       return { message: 'Error fetching conversations' };
@@ -257,10 +286,26 @@ module.exports = {
    * logger.error(result); // { n: 5, ok: 1, deletedCount: 5, messages: { n: 10, ok: 1, deletedCount: 10 } }
    */
   deleteConvos: async (user, filter) => {
-    let toRemove = await Conversation.find({ ...filter, user }).select('conversationId');
-    const ids = toRemove.map((instance) => instance.conversationId);
-    let deleteCount = await Conversation.deleteMany({ ...filter, user });
-    deleteCount.messages = await deleteMessages({ conversationId: { $in: ids } });
-    return deleteCount;
+    try {
+      const userFilter = { ...filter, user };
+
+      const conversations = await Conversation.find(userFilter).select('conversationId');
+      const conversationIds = conversations.map((c) => c.conversationId);
+
+      if (!conversationIds.length) {
+        throw new Error('Conversation not found or already deleted.');
+      }
+
+      const deleteConvoResult = await Conversation.deleteMany(userFilter);
+
+      const deleteMessagesResult = await deleteMessages({
+        conversationId: { $in: conversationIds },
+      });
+
+      return { ...deleteConvoResult, messages: deleteMessagesResult };
+    } catch (error) {
+      logger.error('[deleteConvos] Error deleting conversations and messages', error);
+      throw error;
+    }
   },
 };

api/models/File.js

@@ -1,4 +1,5 @@
 const mongoose = require('mongoose');
+const { EToolResources } = require('librechat-data-provider');
 const { fileSchema } = require('@librechat/data-schemas');
 const { logger } = require('~/config');
 
@@ -8,7 +9,7 @@ const File = mongoose.model('File', fileSchema);
  * Finds a file by its file_id with additional query options.
  * @param {string} file_id - The unique identifier of the file.
  * @param {object} options - Query options for filtering, projection, etc.
- * @returns {Promise<IMongoFile>} A promise that resolves to the file document or null.
+ * @returns {Promise<MongoFile>} A promise that resolves to the file document or null.
  */
 const findFileById = async (file_id, options = {}) => {
   return await File.findOne({ file_id, ...options }).lean();
@@ -20,7 +21,7 @@ const findFileById = async (file_id, options = {}) => {
  * @param {Object} [_sortOptions] - Optional sort parameters.
  * @param {Object|String} [selectFields={ text: 0 }] - Fields to include/exclude in the query results.
  *                                                   Default excludes the 'text' field.
- * @returns {Promise<Array<IMongoFile>>} A promise that resolves to an array of file documents.
+ * @returns {Promise<Array<MongoFile>>} A promise that resolves to an array of file documents.
  */
 const getFiles = async (filter, _sortOptions, selectFields = { text: 0 }) => {
   const sortOptions = { updatedAt: -1, ..._sortOptions };
@@ -30,9 +31,10 @@ const getFiles = async (filter, _sortOptions, selectFields = { text: 0 }) => {
 /**
  * Retrieves tool files (files that are embedded or have a fileIdentifier) from an array of file IDs
  * @param {string[]} fileIds - Array of file_id strings to search for
- * @returns {Promise<Array<IMongoFile>>} Files that match the criteria
+ * @param {Set<EToolResources>} toolResourceSet - Optional filter for tool resources
+ * @returns {Promise<Array<MongoFile>>} Files that match the criteria
  */
-const getToolFilesByIds = async (fileIds) => {
+const getToolFilesByIds = async (fileIds, toolResourceSet) => {
   if (!fileIds || !fileIds.length) {
     return [];
   }
@@ -40,9 +42,19 @@ const getToolFilesByIds = async (fileIds) => {
   try {
     const filter = {
       file_id: { $in: fileIds },
-      $or: [{ embedded: true }, { 'metadata.fileIdentifier': { $exists: true } }],
     };
 
+    if (toolResourceSet.size) {
+      filter.$or = [];
+    }
+
+    if (toolResourceSet.has(EToolResources.file_search)) {
+      filter.$or.push({ embedded: true });
+    }
+    if (toolResourceSet.has(EToolResources.execute_code)) {
+      filter.$or.push({ 'metadata.fileIdentifier': { $exists: true } });
+    }
+
     const selectFields = { text: 0 };
     const sortOptions = { updatedAt: -1 };
 
@@ -55,9 +67,9 @@ const getToolFilesByIds = async (fileIds) => {
 
 /**
  * Creates a new file with a TTL of 1 hour.
- * @param {IMongoFile} data - The file data to be created, must contain file_id.
+ * @param {MongoFile} data - The file data to be created, must contain file_id.
  * @param {boolean} disableTTL - Whether to disable the TTL.
- * @returns {Promise<IMongoFile>} A promise that resolves to the created file document.
+ * @returns {Promise<MongoFile>} A promise that resolves to the created file document.
  */
 const createFile = async (data, disableTTL) => {
   const fileData = {
@@ -77,8 +89,8 @@ const createFile = async (data, disableTTL) => {
 
 /**
  * Updates a file identified by file_id with new data and removes the TTL.
- * @param {IMongoFile} data - The data to update, must contain file_id.
- * @returns {Promise<IMongoFile>} A promise that resolves to the updated file document.
+ * @param {MongoFile} data - The data to update, must contain file_id.
+ * @returns {Promise<MongoFile>} A promise that resolves to the updated file document.
  */
 const updateFile = async (data) => {
   const { file_id, ...update } = data;
@@ -91,8 +103,8 @@ const updateFile = async (data) => {
 
 /**
  * Increments the usage of a file identified by file_id.
- * @param {IMongoFile} data - The data to update, must contain file_id and the increment value for usage.
- * @returns {Promise<IMongoFile>} A promise that resolves to the updated file document.
+ * @param {MongoFile} data - The data to update, must contain file_id and the increment value for usage.
+ * @returns {Promise<MongoFile>} A promise that resolves to the updated file document.
  */
 const updateFileUsage = async (data) => {
   const { file_id, inc = 1 } = data;
@@ -106,7 +118,7 @@ const updateFileUsage = async (data) => {
 /**
  * Deletes a file identified by file_id.
  * @param {string} file_id - The unique identifier of the file to delete.
- * @returns {Promise<IMongoFile>} A promise that resolves to the deleted file document or null.
+ * @returns {Promise<MongoFile>} A promise that resolves to the deleted file document or null.
  */
 const deleteFile = async (file_id) => {
   return await File.findOneAndDelete({ file_id }).lean();
@@ -115,7 +127,7 @@ const deleteFile = async (file_id) => {
 /**
  * Deletes a file identified by a filter.
  * @param {object} filter - The filter criteria to apply.
- * @returns {Promise<IMongoFile>} A promise that resolves to the deleted file document or null.
+ * @returns {Promise<MongoFile>} A promise that resolves to the deleted file document or null.
  */
 const deleteFileByFilter = async (filter) => {
   return await File.findOneAndDelete(filter).lean();

api/models/Message.js

@@ -61,6 +61,14 @@ async function saveMessage(req, params, metadata) {
       update.expiredAt = null;
     }
 
+    if (update.tokenCount != null && isNaN(update.tokenCount)) {
+      logger.warn(
+        `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${update.tokenCount}`,
+      );
+      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+      update.tokenCount = 0;
+    }
+
     const message = await Message.findOneAndUpdate(
       { messageId: params.messageId, user: req.user.id },
       update,
@@ -97,7 +105,9 @@ async function saveMessage(req, params, metadata) {
         };
       } catch (findError) {
         // If the findOne also fails, log it but don't crash
-        logger.warn(`Could not retrieve existing message with ID ${params.messageId}: ${findError.message}`);
+        logger.warn(
+          `Could not retrieve existing message with ID ${params.messageId}: ${findError.message}`,
+        );
         return {
           ...params,
           messageId: params.messageId,

api/models/Role.js

@@ -4,13 +4,8 @@ const {
   SystemRoles,
   roleDefaults,
   PermissionTypes,
+  permissionsSchema,
   removeNullishValues,
-  agentPermissionsSchema,
-  promptPermissionsSchema,
-  runCodePermissionsSchema,
-  bookmarkPermissionsSchema,
-  multiConvoPermissionsSchema,
-  temporaryChatPermissionsSchema,
 } = require('librechat-data-provider');
 const getLogStores = require('~/cache/getLogStores');
 const { roleSchema } = require('@librechat/data-schemas');
@@ -20,15 +15,16 @@ const Role = mongoose.model('Role', roleSchema);
 
 /**
  * Retrieve a role by name and convert the found role document to a plain object.
- * If the role with the given name doesn't exist and the name is a system defined role, create it and return the lean version.
+ * If the role with the given name doesn't exist and the name is a system defined role,
+ * create it and return the lean version.
  *
  * @param {string} roleName - The name of the role to find or create.
  * @param {string|string[]} [fieldsToSelect] - The fields to include or exclude in the returned document.
  * @returns {Promise<Object>} A plain object representing the role document.
  */
 const getRoleByName = async function (roleName, fieldsToSelect = null) {
+  const cache = getLogStores(CacheKeys.ROLES);
   try {
-    const cache = getLogStores(CacheKeys.ROLES);
     const cachedRole = await cache.get(roleName);
     if (cachedRole) {
       return cachedRole;
@@ -40,8 +36,7 @@ const getRoleByName = async function (roleName, fieldsToSelect = null) {
     let role = await query.lean().exec();
 
     if (!role && SystemRoles[roleName]) {
-      role = roleDefaults[roleName];
-      role = await new Role(role).save();
+      role = await new Role(roleDefaults[roleName]).save();
       await cache.set(roleName, role);
       return role.toObject();
     }
@@ -60,8 +55,8 @@ const getRoleByName = async function (roleName, fieldsToSelect = null) {
  * @returns {Promise<TRole>} Updated role document.
  */
 const updateRoleByName = async function (roleName, updates) {
+  const cache = getLogStores(CacheKeys.ROLES);
   try {
-    const cache = getLogStores(CacheKeys.ROLES);
     const role = await Role.findOneAndUpdate(
       { name: roleName },
       { $set: updates },
@@ -77,29 +72,20 @@ const updateRoleByName = async function (roleName, updates) {
   }
 };
 
-const permissionSchemas = {
-  [PermissionTypes.AGENTS]: agentPermissionsSchema,
-  [PermissionTypes.PROMPTS]: promptPermissionsSchema,
-  [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
-  [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
-  [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
-  [PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
-};
-
 /**
  * Updates access permissions for a specific role and multiple permission types.
- * @param {SystemRoles} roleName - The role to update.
+ * @param {string} roleName - The role to update.
  * @param {Object.<PermissionTypes, Object.<Permissions, boolean>>} permissionsUpdate - Permissions to update and their values.
  */
 async function updateAccessPermissions(roleName, permissionsUpdate) {
+  // Filter and clean the permission updates based on our schema definition.
   const updates = {};
   for (const [permissionType, permissions] of Object.entries(permissionsUpdate)) {
-    if (permissionSchemas[permissionType]) {
+    if (permissionsSchema.shape && permissionsSchema.shape[permissionType]) {
       updates[permissionType] = removeNullishValues(permissions);
     }
   }
-
-  if (Object.keys(updates).length === 0) {
+  if (!Object.keys(updates).length) {
     return;
   }
 
@@ -109,26 +95,75 @@ async function updateAccessPermissions(roleName, permissionsUpdate) {
       return;
     }
 
-    const updatedPermissions = {};
+    const currentPermissions = role.permissions || {};
+    const updatedPermissions = { ...currentPermissions };
     let hasChanges = false;
 
+    const unsetFields = {};
+    const permissionTypes = Object.keys(permissionsSchema.shape || {});
+    for (const permType of permissionTypes) {
+      if (role[permType] && typeof role[permType] === 'object') {
+        logger.info(
+          `Migrating '${roleName}' role from old schema: found '${permType}' at top level`,
+        );
+
+        updatedPermissions[permType] = {
+          ...updatedPermissions[permType],
+          ...role[permType],
+        };
+
+        unsetFields[permType] = 1;
+        hasChanges = true;
+      }
+    }
+
+    // Process the current updates
     for (const [permissionType, permissions] of Object.entries(updates)) {
-      const currentPermissions = role[permissionType] || {};
-      updatedPermissions[permissionType] = { ...currentPermissions };
+      const currentTypePermissions = currentPermissions[permissionType] || {};
+      updatedPermissions[permissionType] = { ...currentTypePermissions };
 
       for (const [permission, value] of Object.entries(permissions)) {
-        if (currentPermissions[permission] !== value) {
+        if (currentTypePermissions[permission] !== value) {
           updatedPermissions[permissionType][permission] = value;
           hasChanges = true;
           logger.info(
-            `Updating '${roleName}' role ${permissionType} '${permission}' permission from ${currentPermissions[permission]} to: ${value}`,
+            `Updating '${roleName}' role permission '${permissionType}' '${permission}' from ${currentTypePermissions[permission]} to: ${value}`,
           );
         }
       }
     }
 
     if (hasChanges) {
-      await updateRoleByName(roleName, updatedPermissions);
+      const updateObj = { permissions: updatedPermissions };
+
+      if (Object.keys(unsetFields).length > 0) {
+        logger.info(
+          `Unsetting old schema fields for '${roleName}' role: ${Object.keys(unsetFields).join(', ')}`,
+        );
+
+        try {
+          await Role.updateOne(
+            { name: roleName },
+            {
+              $set: updateObj,
+              $unset: unsetFields,
+            },
+          );
+
+          const cache = getLogStores(CacheKeys.ROLES);
+          const updatedRole = await Role.findOne({ name: roleName }).select('-__v').lean().exec();
+          await cache.set(roleName, updatedRole);
+
+          logger.info(`Updated role '${roleName}' and removed old schema fields`);
+        } catch (updateError) {
+          logger.error(`Error during role migration update: ${updateError.message}`);
+          throw updateError;
+        }
+      } else {
+        // Standard update if no migration needed
+        await updateRoleByName(roleName, updateObj);
+      }
+
       logger.info(`Updated '${roleName}' role permissions`);
     } else {
       logger.info(`No changes needed for '${roleName}' role permissions`);
@@ -146,34 +181,111 @@ async function updateAccessPermissions(roleName, permissionsUpdate) {
  * @returns {Promise<void>}
  */
 const initializeRoles = async function () {
-  const defaultRoles = [SystemRoles.ADMIN, SystemRoles.USER];
-
-  for (const roleName of defaultRoles) {
+  for (const roleName of [SystemRoles.ADMIN, SystemRoles.USER]) {
     let role = await Role.findOne({ name: roleName });
+    const defaultPerms = roleDefaults[roleName].permissions;
 
     if (!role) {
-      // Create new role if it doesn't exist
+      // Create new role if it doesn't exist.
       role = new Role(roleDefaults[roleName]);
     } else {
-      // Add missing permission types
-      let isUpdated = false;
-      for (const permType of Object.values(PermissionTypes)) {
-        if (!role[permType]) {
-          role[permType] = roleDefaults[roleName][permType];
-          isUpdated = true;
+      // Ensure role.permissions is defined.
+      role.permissions = role.permissions || {};
+      // For each permission type in defaults, add it if missing.
+      for (const permType of Object.keys(defaultPerms)) {
+        if (role.permissions[permType] == null) {
+          role.permissions[permType] = defaultPerms[permType];
         }
       }
-      if (isUpdated) {
-        await role.save();
-      }
     }
     await role.save();
   }
 };
+
+/**
+ * Migrates roles from old schema to new schema structure.
+ * This can be called directly to fix existing roles.
+ *
+ * @param {string} [roleName] - Optional specific role to migrate. If not provided, migrates all roles.
+ * @returns {Promise<number>} Number of roles migrated.
+ */
+const migrateRoleSchema = async function (roleName) {
+  try {
+    // Get roles to migrate
+    let roles;
+    if (roleName) {
+      const role = await Role.findOne({ name: roleName });
+      roles = role ? [role] : [];
+    } else {
+      roles = await Role.find({});
+    }
+
+    logger.info(`Migrating ${roles.length} roles to new schema structure`);
+    let migratedCount = 0;
+
+    for (const role of roles) {
+      const permissionTypes = Object.keys(permissionsSchema.shape || {});
+      const unsetFields = {};
+      let hasOldSchema = false;
+
+      // Check for old schema fields
+      for (const permType of permissionTypes) {
+        if (role[permType] && typeof role[permType] === 'object') {
+          hasOldSchema = true;
+
+          // Ensure permissions object exists
+          role.permissions = role.permissions || {};
+
+          // Migrate permissions from old location to new
+          role.permissions[permType] = {
+            ...role.permissions[permType],
+            ...role[permType],
+          };
+
+          // Mark field for removal
+          unsetFields[permType] = 1;
+        }
+      }
+
+      if (hasOldSchema) {
+        try {
+          logger.info(`Migrating role '${role.name}' from old schema structure`);
+
+          // Simple update operation
+          await Role.updateOne(
+            { _id: role._id },
+            {
+              $set: { permissions: role.permissions },
+              $unset: unsetFields,
+            },
+          );
+
+          // Refresh cache
+          const cache = getLogStores(CacheKeys.ROLES);
+          const updatedRole = await Role.findById(role._id).lean().exec();
+          await cache.set(role.name, updatedRole);
+
+          migratedCount++;
+          logger.info(`Migrated role '${role.name}'`);
+        } catch (error) {
+          logger.error(`Failed to migrate role '${role.name}': ${error.message}`);
+        }
+      }
+    }
+
+    logger.info(`Migration complete: ${migratedCount} roles migrated`);
+    return migratedCount;
+  } catch (error) {
+    logger.error(`Role schema migration failed: ${error.message}`);
+    throw error;
+  }
+};
+
 module.exports = {
   Role,
   getRoleByName,
   initializeRoles,
   updateRoleByName,
   updateAccessPermissions,
+  migrateRoleSchema,
 };

api/models/Role.spec.js

@@ -2,22 +2,21 @@ const mongoose = require('mongoose');
 const { MongoMemoryServer } = require('mongodb-memory-server');
 const {
   SystemRoles,
-  PermissionTypes,
-  roleDefaults,
   Permissions,
+  roleDefaults,
+  PermissionTypes,
 } = require('librechat-data-provider');
-const { updateAccessPermissions, initializeRoles } = require('~/models/Role');
+const { Role, getRoleByName, updateAccessPermissions, initializeRoles } = require('~/models/Role');
 const getLogStores = require('~/cache/getLogStores');
-const { Role } = require('~/models/Role');
 
 // Mock the cache
-jest.mock('~/cache/getLogStores', () => {
-  return jest.fn().mockReturnValue({
+jest.mock('~/cache/getLogStores', () =>
+  jest.fn().mockReturnValue({
     get: jest.fn(),
     set: jest.fn(),
     del: jest.fn(),
-  });
-});
+  }),
+);
 
 let mongoServer;
 
@@ -41,10 +40,12 @@ describe('updateAccessPermissions', () => {
   it('should update permissions when changes are needed', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          CREATE: true,
+          USE: true,
+          SHARED_GLOBAL: false,
+        },
       },
     }).save();
 
@@ -56,8 +57,8 @@ describe('updateAccessPermissions', () => {
       },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: true,
       SHARED_GLOBAL: true,
@@ -67,10 +68,12 @@ describe('updateAccessPermissions', () => {
   it('should not update permissions when no changes are needed', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          CREATE: true,
+          USE: true,
+          SHARED_GLOBAL: false,
+        },
       },
     }).save();
 
@@ -82,8 +85,8 @@ describe('updateAccessPermissions', () => {
       },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: true,
       SHARED_GLOBAL: false,
@@ -92,11 +95,8 @@ describe('updateAccessPermissions', () => {
 
   it('should handle non-existent roles', async () => {
     await updateAccessPermissions('NON_EXISTENT_ROLE', {
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-      },
+      [PermissionTypes.PROMPTS]: { CREATE: true },
     });
-
     const role = await Role.findOne({ name: 'NON_EXISTENT_ROLE' });
     expect(role).toBeNull();
   });
@@ -104,21 +104,21 @@ describe('updateAccessPermissions', () => {
   it('should update only specified permissions', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          CREATE: true,
+          USE: true,
+          SHARED_GLOBAL: false,
+        },
       },
     }).save();
 
     await updateAccessPermissions(SystemRoles.USER, {
-      [PermissionTypes.PROMPTS]: {
-        SHARED_GLOBAL: true,
-      },
+      [PermissionTypes.PROMPTS]: { SHARED_GLOBAL: true },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: true,
       SHARED_GLOBAL: true,
@@ -128,21 +128,21 @@ describe('updateAccessPermissions', () => {
   it('should handle partial updates', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          CREATE: true,
+          USE: true,
+          SHARED_GLOBAL: false,
+        },
       },
     }).save();
 
     await updateAccessPermissions(SystemRoles.USER, {
-      [PermissionTypes.PROMPTS]: {
-        USE: false,
-      },
+      [PermissionTypes.PROMPTS]: { USE: false },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: false,
       SHARED_GLOBAL: false,
@@ -152,13 +152,9 @@ describe('updateAccessPermissions', () => {
   it('should update multiple permission types at once', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
-      },
-      [PermissionTypes.BOOKMARKS]: {
-        USE: true,
+      permissions: {
+        [PermissionTypes.PROMPTS]: { CREATE: true, USE: true, SHARED_GLOBAL: false },
+        [PermissionTypes.BOOKMARKS]: { USE: true },
       },
     }).save();
 
@@ -167,24 +163,20 @@ describe('updateAccessPermissions', () => {
       [PermissionTypes.BOOKMARKS]: { USE: false },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: false,
       SHARED_GLOBAL: true,
     });
-    expect(updatedRole[PermissionTypes.BOOKMARKS]).toEqual({
-      USE: false,
-    });
+    expect(updatedRole.permissions[PermissionTypes.BOOKMARKS]).toEqual({ USE: false });
   });
 
   it('should handle updates for a single permission type', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: { CREATE: true, USE: true, SHARED_GLOBAL: false },
       },
     }).save();
 
@@ -192,8 +184,8 @@ describe('updateAccessPermissions', () => {
       [PermissionTypes.PROMPTS]: { USE: false, SHARED_GLOBAL: true },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: false,
       SHARED_GLOBAL: true,
@@ -203,33 +195,25 @@ describe('updateAccessPermissions', () => {
   it('should update MULTI_CONVO permissions', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.MULTI_CONVO]: {
-        USE: false,
+      permissions: {
+        [PermissionTypes.MULTI_CONVO]: { USE: false },
       },
     }).save();
 
     await updateAccessPermissions(SystemRoles.USER, {
-      [PermissionTypes.MULTI_CONVO]: {
-        USE: true,
-      },
+      [PermissionTypes.MULTI_CONVO]: { USE: true },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.MULTI_CONVO]).toEqual({
-      USE: true,
-    });
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.MULTI_CONVO]).toEqual({ USE: true });
   });
 
   it('should update MULTI_CONVO permissions along with other permission types', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        CREATE: true,
-        USE: true,
-        SHARED_GLOBAL: false,
-      },
-      [PermissionTypes.MULTI_CONVO]: {
-        USE: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: { CREATE: true, USE: true, SHARED_GLOBAL: false },
+        [PermissionTypes.MULTI_CONVO]: { USE: false },
       },
     }).save();
 
@@ -238,35 +222,29 @@ describe('updateAccessPermissions', () => {
       [PermissionTypes.MULTI_CONVO]: { USE: true },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.PROMPTS]).toEqual({
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.PROMPTS]).toEqual({
       CREATE: true,
       USE: true,
       SHARED_GLOBAL: true,
     });
-    expect(updatedRole[PermissionTypes.MULTI_CONVO]).toEqual({
-      USE: true,
-    });
+    expect(updatedRole.permissions[PermissionTypes.MULTI_CONVO]).toEqual({ USE: true });
   });
 
   it('should not update MULTI_CONVO permissions when no changes are needed', async () => {
     await new Role({
       name: SystemRoles.USER,
-      [PermissionTypes.MULTI_CONVO]: {
-        USE: true,
+      permissions: {
+        [PermissionTypes.MULTI_CONVO]: { USE: true },
       },
     }).save();
 
     await updateAccessPermissions(SystemRoles.USER, {
-      [PermissionTypes.MULTI_CONVO]: {
-        USE: true,
-      },
+      [PermissionTypes.MULTI_CONVO]: { USE: true },
     });
 
-    const updatedRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-    expect(updatedRole[PermissionTypes.MULTI_CONVO]).toEqual({
-      USE: true,
-    });
+    const updatedRole = await getRoleByName(SystemRoles.USER);
+    expect(updatedRole.permissions[PermissionTypes.MULTI_CONVO]).toEqual({ USE: true });
   });
 });
 
@@ -278,65 +256,69 @@ describe('initializeRoles', () => {
   it('should create default roles if they do not exist', async () => {
     await initializeRoles();
 
-    const adminRole = await Role.findOne({ name: SystemRoles.ADMIN }).lean();
-    const userRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    const adminRole = await getRoleByName(SystemRoles.ADMIN);
+    const userRole = await getRoleByName(SystemRoles.USER);
 
     expect(adminRole).toBeTruthy();
     expect(userRole).toBeTruthy();
 
-    // Check if all permission types exist
+    // Check if all permission types exist in the permissions field
     Object.values(PermissionTypes).forEach((permType) => {
-      expect(adminRole[permType]).toBeDefined();
-      expect(userRole[permType]).toBeDefined();
+      expect(adminRole.permissions[permType]).toBeDefined();
+      expect(userRole.permissions[permType]).toBeDefined();
     });
 
-    // Check if permissions match defaults (example for ADMIN role)
-    expect(adminRole[PermissionTypes.PROMPTS].SHARED_GLOBAL).toBe(true);
-    expect(adminRole[PermissionTypes.BOOKMARKS].USE).toBe(true);
-    expect(adminRole[PermissionTypes.AGENTS].CREATE).toBe(true);
+    // Example: Check default values for ADMIN role
+    expect(adminRole.permissions[PermissionTypes.PROMPTS].SHARED_GLOBAL).toBe(true);
+    expect(adminRole.permissions[PermissionTypes.BOOKMARKS].USE).toBe(true);
+    expect(adminRole.permissions[PermissionTypes.AGENTS].CREATE).toBe(true);
   });
 
   it('should not modify existing permissions for existing roles', async () => {
     const customUserRole = {
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: {
-        [Permissions.USE]: false,
-        [Permissions.CREATE]: true,
-        [Permissions.SHARED_GLOBAL]: true,
-      },
-      [PermissionTypes.BOOKMARKS]: {
-        [Permissions.USE]: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          [Permissions.USE]: false,
+          [Permissions.CREATE]: true,
+          [Permissions.SHARED_GLOBAL]: true,
+        },
+        [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: false },
       },
     };
 
     await new Role(customUserRole).save();
-
     await initializeRoles();
 
-    const userRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-
-    expect(userRole[PermissionTypes.PROMPTS]).toEqual(customUserRole[PermissionTypes.PROMPTS]);
-    expect(userRole[PermissionTypes.BOOKMARKS]).toEqual(customUserRole[PermissionTypes.BOOKMARKS]);
-    expect(userRole[PermissionTypes.AGENTS]).toBeDefined();
+    const userRole = await getRoleByName(SystemRoles.USER);
+    expect(userRole.permissions[PermissionTypes.PROMPTS]).toEqual(
+      customUserRole.permissions[PermissionTypes.PROMPTS],
+    );
+    expect(userRole.permissions[PermissionTypes.BOOKMARKS]).toEqual(
+      customUserRole.permissions[PermissionTypes.BOOKMARKS],
+    );
+    expect(userRole.permissions[PermissionTypes.AGENTS]).toBeDefined();
   });
 
   it('should add new permission types to existing roles', async () => {
     const partialUserRole = {
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: roleDefaults[SystemRoles.USER][PermissionTypes.PROMPTS],
-      [PermissionTypes.BOOKMARKS]: roleDefaults[SystemRoles.USER][PermissionTypes.BOOKMARKS],
+      permissions: {
+        [PermissionTypes.PROMPTS]:
+          roleDefaults[SystemRoles.USER].permissions[PermissionTypes.PROMPTS],
+        [PermissionTypes.BOOKMARKS]:
+          roleDefaults[SystemRoles.USER].permissions[PermissionTypes.BOOKMARKS],
+      },
     };
 
     await new Role(partialUserRole).save();
-
     await initializeRoles();
 
-    const userRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-
-    expect(userRole[PermissionTypes.AGENTS]).toBeDefined();
-    expect(userRole[PermissionTypes.AGENTS].CREATE).toBeDefined();
-    expect(userRole[PermissionTypes.AGENTS].USE).toBeDefined();
-    expect(userRole[PermissionTypes.AGENTS].SHARED_GLOBAL).toBeDefined();
+    const userRole = await getRoleByName(SystemRoles.USER);
+    expect(userRole.permissions[PermissionTypes.AGENTS]).toBeDefined();
+    expect(userRole.permissions[PermissionTypes.AGENTS].CREATE).toBeDefined();
+    expect(userRole.permissions[PermissionTypes.AGENTS].USE).toBeDefined();
+    expect(userRole.permissions[PermissionTypes.AGENTS].SHARED_GLOBAL).toBeDefined();
   });
 
   it('should handle multiple runs without duplicating or modifying data', async () => {
@@ -349,72 +331,73 @@ describe('initializeRoles', () => {
     expect(adminRoles).toHaveLength(1);
     expect(userRoles).toHaveLength(1);
 
-    const adminRole = adminRoles[0].toObject();
-    const userRole = userRoles[0].toObject();
-
-    // Check if all permission types exist
+    const adminPerms = adminRoles[0].toObject().permissions;
+    const userPerms = userRoles[0].toObject().permissions;
     Object.values(PermissionTypes).forEach((permType) => {
-      expect(adminRole[permType]).toBeDefined();
-      expect(userRole[permType]).toBeDefined();
+      expect(adminPerms[permType]).toBeDefined();
+      expect(userPerms[permType]).toBeDefined();
     });
   });
 
   it('should update roles with missing permission types from roleDefaults', async () => {
     const partialAdminRole = {
       name: SystemRoles.ADMIN,
-      [PermissionTypes.PROMPTS]: {
-        [Permissions.USE]: false,
-        [Permissions.CREATE]: false,
-        [Permissions.SHARED_GLOBAL]: false,
+      permissions: {
+        [PermissionTypes.PROMPTS]: {
+          [Permissions.USE]: false,
+          [Permissions.CREATE]: false,
+          [Permissions.SHARED_GLOBAL]: false,
+        },
+        [PermissionTypes.BOOKMARKS]:
+          roleDefaults[SystemRoles.ADMIN].permissions[PermissionTypes.BOOKMARKS],
       },
-      [PermissionTypes.BOOKMARKS]: roleDefaults[SystemRoles.ADMIN][PermissionTypes.BOOKMARKS],
     };
 
     await new Role(partialAdminRole).save();
-
     await initializeRoles();
 
-    const adminRole = await Role.findOne({ name: SystemRoles.ADMIN }).lean();
-
-    expect(adminRole[PermissionTypes.PROMPTS]).toEqual(partialAdminRole[PermissionTypes.PROMPTS]);
-    expect(adminRole[PermissionTypes.AGENTS]).toBeDefined();
-    expect(adminRole[PermissionTypes.AGENTS].CREATE).toBeDefined();
-    expect(adminRole[PermissionTypes.AGENTS].USE).toBeDefined();
-    expect(adminRole[PermissionTypes.AGENTS].SHARED_GLOBAL).toBeDefined();
+    const adminRole = await getRoleByName(SystemRoles.ADMIN);
+    expect(adminRole.permissions[PermissionTypes.PROMPTS]).toEqual(
+      partialAdminRole.permissions[PermissionTypes.PROMPTS],
+    );
+    expect(adminRole.permissions[PermissionTypes.AGENTS]).toBeDefined();
+    expect(adminRole.permissions[PermissionTypes.AGENTS].CREATE).toBeDefined();
+    expect(adminRole.permissions[PermissionTypes.AGENTS].USE).toBeDefined();
+    expect(adminRole.permissions[PermissionTypes.AGENTS].SHARED_GLOBAL).toBeDefined();
   });
 
   it('should include MULTI_CONVO permissions when creating default roles', async () => {
     await initializeRoles();
 
-    const adminRole = await Role.findOne({ name: SystemRoles.ADMIN }).lean();
-    const userRole = await Role.findOne({ name: SystemRoles.USER }).lean();
+    const adminRole = await getRoleByName(SystemRoles.ADMIN);
+    const userRole = await getRoleByName(SystemRoles.USER);
 
-    expect(adminRole[PermissionTypes.MULTI_CONVO]).toBeDefined();
-    expect(userRole[PermissionTypes.MULTI_CONVO]).toBeDefined();
-
-    // Check if MULTI_CONVO permissions match defaults
-    expect(adminRole[PermissionTypes.MULTI_CONVO].USE).toBe(
-      roleDefaults[SystemRoles.ADMIN][PermissionTypes.MULTI_CONVO].USE,
+    expect(adminRole.permissions[PermissionTypes.MULTI_CONVO]).toBeDefined();
+    expect(userRole.permissions[PermissionTypes.MULTI_CONVO]).toBeDefined();
+    expect(adminRole.permissions[PermissionTypes.MULTI_CONVO].USE).toBe(
+      roleDefaults[SystemRoles.ADMIN].permissions[PermissionTypes.MULTI_CONVO].USE,
     );
-    expect(userRole[PermissionTypes.MULTI_CONVO].USE).toBe(
-      roleDefaults[SystemRoles.USER][PermissionTypes.MULTI_CONVO].USE,
+    expect(userRole.permissions[PermissionTypes.MULTI_CONVO].USE).toBe(
+      roleDefaults[SystemRoles.USER].permissions[PermissionTypes.MULTI_CONVO].USE,
     );
   });
 
   it('should add MULTI_CONVO permissions to existing roles without them', async () => {
     const partialUserRole = {
       name: SystemRoles.USER,
-      [PermissionTypes.PROMPTS]: roleDefaults[SystemRoles.USER][PermissionTypes.PROMPTS],
-      [PermissionTypes.BOOKMARKS]: roleDefaults[SystemRoles.USER][PermissionTypes.BOOKMARKS],
+      permissions: {
+        [PermissionTypes.PROMPTS]:
+          roleDefaults[SystemRoles.USER].permissions[PermissionTypes.PROMPTS],
+        [PermissionTypes.BOOKMARKS]:
+          roleDefaults[SystemRoles.USER].permissions[PermissionTypes.BOOKMARKS],
+      },
     };
 
     await new Role(partialUserRole).save();
-
     await initializeRoles();
 
-    const userRole = await Role.findOne({ name: SystemRoles.USER }).lean();
-
-    expect(userRole[PermissionTypes.MULTI_CONVO]).toBeDefined();
-    expect(userRole[PermissionTypes.MULTI_CONVO].USE).toBeDefined();
+    const userRole = await getRoleByName(SystemRoles.USER);
+    expect(userRole.permissions[PermissionTypes.MULTI_CONVO]).toBeDefined();
+    expect(userRole.permissions[PermissionTypes.MULTI_CONVO].USE).toBeDefined();
   });
 });

api/models/Share.js

@@ -52,6 +52,14 @@ function anonymizeMessages(messages, newConvoId) {
     const newMessageId = anonymizeMessageId(message.messageId);
     idMap.set(message.messageId, newMessageId);
 
+    const anonymizedAttachments = message.attachments?.map((attachment) => {
+      return {
+        ...attachment,
+        messageId: newMessageId,
+        conversationId: newConvoId,
+      };
+    });
+
     return {
       ...message,
       messageId: newMessageId,
@@ -61,6 +69,7 @@ function anonymizeMessages(messages, newConvoId) {
       model: message.model?.startsWith('asst_')
         ? anonymizeAssistantId(message.model)
         : message.model,
+      attachments: anonymizedAttachments,
     };
   });
 }

api/models/tx.js

@@ -76,10 +76,15 @@ const tokenValues = Object.assign(
     '4k': { prompt: 1.5, completion: 2 },
     '16k': { prompt: 3, completion: 4 },
     'gpt-3.5-turbo-1106': { prompt: 1, completion: 2 },
+    'o4-mini': { prompt: 1.1, completion: 4.4 },
     'o3-mini': { prompt: 1.1, completion: 4.4 },
+    o3: { prompt: 10, completion: 40 },
     'o1-mini': { prompt: 1.1, completion: 4.4 },
     'o1-preview': { prompt: 15, completion: 60 },
     o1: { prompt: 15, completion: 60 },
+    'gpt-4.1-nano': { prompt: 0.1, completion: 0.4 },
+    'gpt-4.1-mini': { prompt: 0.4, completion: 1.6 },
+    'gpt-4.1': { prompt: 2, completion: 8 },
     'gpt-4.5': { prompt: 75, completion: 150 },
     'gpt-4o-mini': { prompt: 0.15, completion: 0.6 },
     'gpt-4o': { prompt: 2.5, completion: 10 },
@@ -107,8 +112,9 @@ const tokenValues = Object.assign(
   so this was from https://artificialanalysis.ai/models/command-light/providers */
     command: { prompt: 0.38, completion: 0.38 },
     'gemini-2.0-flash-lite': { prompt: 0.075, completion: 0.3 },
-    'gemini-2.0-flash': { prompt: 0.1, completion: 0.7 },
+    'gemini-2.0-flash': { prompt: 0.1, completion: 0.4 },
     'gemini-2.0': { prompt: 0, completion: 0 }, // https://ai.google.dev/pricing
+    'gemini-2.5-pro-preview-03-25': { prompt: 1.25, completion: 10 },
     'gemini-2.5': { prompt: 0, completion: 0 }, // Free for a period of time
     'gemini-1.5-flash-8b': { prompt: 0.075, completion: 0.3 },
     'gemini-1.5-flash': { prompt: 0.15, completion: 0.6 },
@@ -122,6 +128,10 @@ const tokenValues = Object.assign(
     'grok-2-1212': { prompt: 2.0, completion: 10.0 },
     'grok-2-latest': { prompt: 2.0, completion: 10.0 },
     'grok-2': { prompt: 2.0, completion: 10.0 },
+    'grok-3-mini-fast': { prompt: 0.4, completion: 4 },
+    'grok-3-mini': { prompt: 0.3, completion: 0.5 },
+    'grok-3-fast': { prompt: 5.0, completion: 25.0 },
+    'grok-3': { prompt: 3.0, completion: 15.0 },
     'grok-beta': { prompt: 5.0, completion: 15.0 },
     'mistral-large': { prompt: 2.0, completion: 6.0 },
     'pixtral-large': { prompt: 2.0, completion: 6.0 },
@@ -170,6 +180,14 @@ const getValueKey = (model, endpoint) => {
     return 'gpt-3.5-turbo-1106';
   } else if (modelName.includes('gpt-3.5')) {
     return '4k';
+  } else if (modelName.includes('o4-mini')) {
+    return 'o4-mini';
+  } else if (modelName.includes('o4')) {
+    return 'o4';
+  } else if (modelName.includes('o3-mini')) {
+    return 'o3-mini';
+  } else if (modelName.includes('o3')) {
+    return 'o3';
   } else if (modelName.includes('o1-preview')) {
     return 'o1-preview';
   } else if (modelName.includes('o1-mini')) {
@@ -178,6 +196,12 @@ const getValueKey = (model, endpoint) => {
     return 'o1';
   } else if (modelName.includes('gpt-4.5')) {
     return 'gpt-4.5';
+  } else if (modelName.includes('gpt-4.1-nano')) {
+    return 'gpt-4.1-nano';
+  } else if (modelName.includes('gpt-4.1-mini')) {
+    return 'gpt-4.1-mini';
+  } else if (modelName.includes('gpt-4.1')) {
+    return 'gpt-4.1';
   } else if (modelName.includes('gpt-4o-2024-05-13')) {
     return 'gpt-4o-2024-05-13';
   } else if (modelName.includes('gpt-4o-mini')) {

api/models/tx.spec.js

@@ -60,6 +60,30 @@ describe('getValueKey', () => {
     expect(getValueKey('gpt-4.5-0125')).toBe('gpt-4.5');
   });
 
+  it('should return "gpt-4.1" for model type of "gpt-4.1"', () => {
+    expect(getValueKey('gpt-4.1-preview')).toBe('gpt-4.1');
+    expect(getValueKey('gpt-4.1-2024-08-06')).toBe('gpt-4.1');
+    expect(getValueKey('gpt-4.1-2024-08-06-0718')).toBe('gpt-4.1');
+    expect(getValueKey('openai/gpt-4.1')).toBe('gpt-4.1');
+    expect(getValueKey('openai/gpt-4.1-2024-08-06')).toBe('gpt-4.1');
+    expect(getValueKey('gpt-4.1-turbo')).toBe('gpt-4.1');
+    expect(getValueKey('gpt-4.1-0125')).toBe('gpt-4.1');
+  });
+
+  it('should return "gpt-4.1-mini" for model type of "gpt-4.1-mini"', () => {
+    expect(getValueKey('gpt-4.1-mini-preview')).toBe('gpt-4.1-mini');
+    expect(getValueKey('gpt-4.1-mini-2024-08-06')).toBe('gpt-4.1-mini');
+    expect(getValueKey('openai/gpt-4.1-mini')).toBe('gpt-4.1-mini');
+    expect(getValueKey('gpt-4.1-mini-0125')).toBe('gpt-4.1-mini');
+  });
+
+  it('should return "gpt-4.1-nano" for model type of "gpt-4.1-nano"', () => {
+    expect(getValueKey('gpt-4.1-nano-preview')).toBe('gpt-4.1-nano');
+    expect(getValueKey('gpt-4.1-nano-2024-08-06')).toBe('gpt-4.1-nano');
+    expect(getValueKey('openai/gpt-4.1-nano')).toBe('gpt-4.1-nano');
+    expect(getValueKey('gpt-4.1-nano-0125')).toBe('gpt-4.1-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');
@@ -141,6 +165,15 @@ describe('getMultiplier', () => {
     );
   });
 
+  it('should return correct multipliers for o4-mini and o3', () => {
+    ['o4-mini', 'o3'].forEach((model) => {
+      const prompt = getMultiplier({ model, tokenType: 'prompt' });
+      const completion = getMultiplier({ model, tokenType: 'completion' });
+      expect(prompt).toBe(tokenValues[model].prompt);
+      expect(completion).toBe(tokenValues[model].completion);
+    });
+  });
+
   it('should return defaultRate if tokenType is provided but not found in tokenValues', () => {
     expect(getMultiplier({ valueKey: '8k', tokenType: 'unknownType' })).toBe(defaultRate);
   });
@@ -185,6 +218,52 @@ describe('getMultiplier', () => {
     );
   });
 
+  it('should return the correct multiplier for gpt-4.1', () => {
+    const valueKey = getValueKey('gpt-4.1-2024-08-06');
+    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(tokenValues['gpt-4.1'].prompt);
+    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1'].completion,
+    );
+    expect(getMultiplier({ model: 'gpt-4.1-preview', tokenType: 'prompt' })).toBe(
+      tokenValues['gpt-4.1'].prompt,
+    );
+    expect(getMultiplier({ model: 'openai/gpt-4.1', tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1'].completion,
+    );
+  });
+
+  it('should return the correct multiplier for gpt-4.1-mini', () => {
+    const valueKey = getValueKey('gpt-4.1-mini-2024-08-06');
+    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(
+      tokenValues['gpt-4.1-mini'].prompt,
+    );
+    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1-mini'].completion,
+    );
+    expect(getMultiplier({ model: 'gpt-4.1-mini-preview', tokenType: 'prompt' })).toBe(
+      tokenValues['gpt-4.1-mini'].prompt,
+    );
+    expect(getMultiplier({ model: 'openai/gpt-4.1-mini', tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1-mini'].completion,
+    );
+  });
+
+  it('should return the correct multiplier for gpt-4.1-nano', () => {
+    const valueKey = getValueKey('gpt-4.1-nano-2024-08-06');
+    expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(
+      tokenValues['gpt-4.1-nano'].prompt,
+    );
+    expect(getMultiplier({ valueKey, tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1-nano'].completion,
+    );
+    expect(getMultiplier({ model: 'gpt-4.1-nano-preview', tokenType: 'prompt' })).toBe(
+      tokenValues['gpt-4.1-nano'].prompt,
+    );
+    expect(getMultiplier({ model: 'openai/gpt-4.1-nano', tokenType: 'completion' })).toBe(
+      tokenValues['gpt-4.1-nano'].completion,
+    );
+  });
+
   it('should return the correct multiplier for gpt-4o-mini', () => {
     const valueKey = getValueKey('gpt-4o-mini-2024-07-18');
     expect(getMultiplier({ valueKey, tokenType: 'prompt' })).toBe(
@@ -348,9 +427,11 @@ describe('getCacheMultiplier', () => {
 
   it('should derive the valueKey from the model if not provided', () => {
     expect(getCacheMultiplier({ cacheType: 'write', model: 'claude-3-5-sonnet-20240620' })).toBe(
-      3.75,
+      cacheTokenValues['claude-3-5-sonnet'].write,
+    );
+    expect(getCacheMultiplier({ cacheType: 'read', model: 'claude-3-haiku-20240307' })).toBe(
+      cacheTokenValues['claude-3-haiku'].read,
     );
-    expect(getCacheMultiplier({ cacheType: 'read', model: 'claude-3-haiku-20240307' })).toBe(0.03);
   });
 
   it('should return null if only model or cacheType is missing', () => {
@@ -371,10 +452,10 @@ describe('getCacheMultiplier', () => {
     };
     expect(
       getCacheMultiplier({ model: 'custom-model', cacheType: 'write', endpointTokenConfig }),
-    ).toBe(5);
+    ).toBe(endpointTokenConfig['custom-model'].write);
     expect(
       getCacheMultiplier({ model: 'custom-model', cacheType: 'read', endpointTokenConfig }),
-    ).toBe(1);
+    ).toBe(endpointTokenConfig['custom-model'].read);
   });
 
   it('should return null if model is not found in endpointTokenConfig', () => {
@@ -395,13 +476,13 @@ describe('getCacheMultiplier', () => {
         model: 'bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0',
         cacheType: 'write',
       }),
-    ).toBe(3.75);
+    ).toBe(cacheTokenValues['claude-3-5-sonnet'].write);
     expect(
       getCacheMultiplier({
         model: 'bedrock/anthropic.claude-3-haiku-20240307-v1:0',
         cacheType: 'read',
       }),
-    ).toBe(0.03);
+    ).toBe(cacheTokenValues['claude-3-haiku'].read);
   });
 });
 
@@ -488,24 +569,92 @@ describe('Grok Model Tests - Pricing', () => {
     test('should return correct prompt and completion rates for Grok vision models', () => {
       const models = ['grok-2-vision-1212', 'grok-2-vision', 'grok-2-vision-latest'];
       models.forEach((model) => {
-        expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(2.0);
-        expect(getMultiplier({ model, tokenType: 'completion' })).toBe(10.0);
+        expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(
+          tokenValues['grok-2-vision'].prompt,
+        );
+        expect(getMultiplier({ model, tokenType: 'completion' })).toBe(
+          tokenValues['grok-2-vision'].completion,
+        );
       });
     });
 
     test('should return correct prompt and completion rates for Grok text models', () => {
       const models = ['grok-2-1212', 'grok-2', 'grok-2-latest'];
       models.forEach((model) => {
-        expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(2.0);
-        expect(getMultiplier({ model, tokenType: 'completion' })).toBe(10.0);
+        expect(getMultiplier({ model, tokenType: 'prompt' })).toBe(tokenValues['grok-2'].prompt);
+        expect(getMultiplier({ model, tokenType: 'completion' })).toBe(
+          tokenValues['grok-2'].completion,
+        );
       });
     });
 
     test('should return correct prompt and completion rates for Grok beta models', () => {
-      expect(getMultiplier({ model: 'grok-vision-beta', tokenType: 'prompt' })).toBe(5.0);
-      expect(getMultiplier({ model: 'grok-vision-beta', tokenType: 'completion' })).toBe(15.0);
-      expect(getMultiplier({ model: 'grok-beta', tokenType: 'prompt' })).toBe(5.0);
-      expect(getMultiplier({ model: 'grok-beta', tokenType: 'completion' })).toBe(15.0);
+      expect(getMultiplier({ model: 'grok-vision-beta', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-vision-beta'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-vision-beta', tokenType: 'completion' })).toBe(
+        tokenValues['grok-vision-beta'].completion,
+      );
+      expect(getMultiplier({ model: 'grok-beta', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-beta'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-beta', tokenType: 'completion' })).toBe(
+        tokenValues['grok-beta'].completion,
+      );
+    });
+
+    test('should return correct prompt and completion rates for Grok 3 models', () => {
+      expect(getMultiplier({ model: 'grok-3', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-3', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3'].completion,
+      );
+      expect(getMultiplier({ model: 'grok-3-fast', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-fast'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-3-fast', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-fast'].completion,
+      );
+      expect(getMultiplier({ model: 'grok-3-mini', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-mini'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-3-mini', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-mini'].completion,
+      );
+      expect(getMultiplier({ model: 'grok-3-mini-fast', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-mini-fast'].prompt,
+      );
+      expect(getMultiplier({ model: 'grok-3-mini-fast', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-mini-fast'].completion,
+      );
+    });
+
+    test('should return correct prompt and completion rates for Grok 3 models with prefixes', () => {
+      expect(getMultiplier({ model: 'xai/grok-3', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3'].prompt,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3'].completion,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-fast', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-fast'].prompt,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-fast', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-fast'].completion,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-mini', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-mini'].prompt,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-mini', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-mini'].completion,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-mini-fast', tokenType: 'prompt' })).toBe(
+        tokenValues['grok-3-mini-fast'].prompt,
+      );
+      expect(getMultiplier({ model: 'xai/grok-3-mini-fast', tokenType: 'completion' })).toBe(
+        tokenValues['grok-3-mini-fast'].completion,
+      );
     });
   });
 });

api/package.json

@@ -39,17 +39,16 @@
     "@aws-sdk/s3-request-presigner": "^3.758.0",
     "@azure/identity": "^4.7.0",
     "@azure/search-documents": "^12.0.0",
-    "@azure/storage-blob": "^12.26.0",
+    "@azure/storage-blob": "^12.27.0",
     "@google/generative-ai": "^0.23.0",
     "@googleapis/youtube": "^20.0.0",
-    "@keyv/mongo": "^2.1.8",
-    "@keyv/redis": "^2.8.1",
-    "@langchain/community": "^0.3.34",
-    "@langchain/core": "^0.3.40",
-    "@langchain/google-genai": "^0.1.11",
-    "@langchain/google-vertexai": "^0.2.2",
+    "@keyv/redis": "^4.3.3",
+    "@langchain/community": "^0.3.39",
+    "@langchain/core": "^0.3.43",
+    "@langchain/google-genai": "^0.2.2",
+    "@langchain/google-vertexai": "^0.2.3",
     "@langchain/textsplitters": "^0.1.0",
-    "@librechat/agents": "^2.3.95",
+    "@librechat/agents": "^2.4.22",
     "@librechat/data-schemas": "*",
     "@waylaidwanderer/fetch-event-source": "^3.0.1",
     "axios": "^1.8.2",
@@ -76,8 +75,8 @@
     "ioredis": "^5.3.2",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.0",
-    "keyv": "^4.5.4",
-    "keyv-file": "^0.2.0",
+    "keyv": "^5.3.2",
+    "keyv-file": "^5.1.2",
     "klona": "^2.0.6",
     "librechat-data-provider": "*",
     "librechat-mcp": "*",

api/server/cleanup.js

@@ -0,0 +1,387 @@
+const { logger } = require('~/config');
+
+// WeakMap to hold temporary data associated with requests
+const requestDataMap = new WeakMap();
+
+const FinalizationRegistry = global.FinalizationRegistry || null;
+
+/**
+ * FinalizationRegistry to clean up client objects when they are garbage collected.
+ * This is used to prevent memory leaks and ensure that client objects are
+ * properly disposed of when they are no longer needed.
+ * The registry holds a weak reference to the client object and a cleanup
+ * callback that is called when the client object is garbage collected.
+ * The callback can be used to perform any necessary cleanup operations,
+ * such as removing event listeners or freeing up resources.
+ */
+const clientRegistry = FinalizationRegistry
+  ? new FinalizationRegistry((heldValue) => {
+    try {
+      // This will run when the client is garbage collected
+      if (heldValue && heldValue.userId) {
+        logger.debug(`[FinalizationRegistry] Cleaning up client for user ${heldValue.userId}`);
+      } else {
+        logger.debug('[FinalizationRegistry] Cleaning up client');
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+  })
+  : null;
+
+/**
+ * Cleans up the client object by removing references to its properties.
+ * This is useful for preventing memory leaks and ensuring that the client
+ * and its properties can be garbage collected when it is no longer needed.
+ */
+function disposeClient(client) {
+  if (!client) {
+    return;
+  }
+
+  try {
+    if (client.user) {
+      client.user = null;
+    }
+    if (client.apiKey) {
+      client.apiKey = null;
+    }
+    if (client.azure) {
+      client.azure = null;
+    }
+    if (client.conversationId) {
+      client.conversationId = null;
+    }
+    if (client.responseMessageId) {
+      client.responseMessageId = null;
+    }
+    if (client.message_file_map) {
+      client.message_file_map = null;
+    }
+    if (client.clientName) {
+      client.clientName = null;
+    }
+    if (client.sender) {
+      client.sender = null;
+    }
+    if (client.model) {
+      client.model = null;
+    }
+    if (client.maxContextTokens) {
+      client.maxContextTokens = null;
+    }
+    if (client.contextStrategy) {
+      client.contextStrategy = null;
+    }
+    if (client.currentDateString) {
+      client.currentDateString = null;
+    }
+    if (client.inputTokensKey) {
+      client.inputTokensKey = null;
+    }
+    if (client.outputTokensKey) {
+      client.outputTokensKey = null;
+    }
+    if (client.skipSaveUserMessage !== undefined) {
+      client.skipSaveUserMessage = null;
+    }
+    if (client.visionMode) {
+      client.visionMode = null;
+    }
+    if (client.continued !== undefined) {
+      client.continued = null;
+    }
+    if (client.fetchedConvo !== undefined) {
+      client.fetchedConvo = null;
+    }
+    if (client.previous_summary) {
+      client.previous_summary = null;
+    }
+    if (client.metadata) {
+      client.metadata = null;
+    }
+    if (client.isVisionModel) {
+      client.isVisionModel = null;
+    }
+    if (client.isChatCompletion !== undefined) {
+      client.isChatCompletion = null;
+    }
+    if (client.contextHandlers) {
+      client.contextHandlers = null;
+    }
+    if (client.augmentedPrompt) {
+      client.augmentedPrompt = null;
+    }
+    if (client.systemMessage) {
+      client.systemMessage = null;
+    }
+    if (client.azureEndpoint) {
+      client.azureEndpoint = null;
+    }
+    if (client.langchainProxy) {
+      client.langchainProxy = null;
+    }
+    if (client.isOmni !== undefined) {
+      client.isOmni = null;
+    }
+    if (client.runManager) {
+      client.runManager = null;
+    }
+    // Properties specific to AnthropicClient
+    if (client.message_start) {
+      client.message_start = null;
+    }
+    if (client.message_delta) {
+      client.message_delta = null;
+    }
+    if (client.isClaude3 !== undefined) {
+      client.isClaude3 = null;
+    }
+    if (client.useMessages !== undefined) {
+      client.useMessages = null;
+    }
+    if (client.isLegacyOutput !== undefined) {
+      client.isLegacyOutput = null;
+    }
+    if (client.supportsCacheControl !== undefined) {
+      client.supportsCacheControl = null;
+    }
+    // Properties specific to GoogleClient
+    if (client.serviceKey) {
+      client.serviceKey = null;
+    }
+    if (client.project_id) {
+      client.project_id = null;
+    }
+    if (client.client_email) {
+      client.client_email = null;
+    }
+    if (client.private_key) {
+      client.private_key = null;
+    }
+    if (client.access_token) {
+      client.access_token = null;
+    }
+    if (client.reverseProxyUrl) {
+      client.reverseProxyUrl = null;
+    }
+    if (client.authHeader) {
+      client.authHeader = null;
+    }
+    if (client.isGenerativeModel !== undefined) {
+      client.isGenerativeModel = null;
+    }
+    // Properties specific to OpenAIClient
+    if (client.ChatGPTClient) {
+      client.ChatGPTClient = null;
+    }
+    if (client.completionsUrl) {
+      client.completionsUrl = null;
+    }
+    if (client.shouldSummarize !== undefined) {
+      client.shouldSummarize = null;
+    }
+    if (client.isOllama !== undefined) {
+      client.isOllama = null;
+    }
+    if (client.FORCE_PROMPT !== undefined) {
+      client.FORCE_PROMPT = null;
+    }
+    if (client.isChatGptModel !== undefined) {
+      client.isChatGptModel = null;
+    }
+    if (client.isUnofficialChatGptModel !== undefined) {
+      client.isUnofficialChatGptModel = null;
+    }
+    if (client.useOpenRouter !== undefined) {
+      client.useOpenRouter = null;
+    }
+    if (client.startToken) {
+      client.startToken = null;
+    }
+    if (client.endToken) {
+      client.endToken = null;
+    }
+    if (client.userLabel) {
+      client.userLabel = null;
+    }
+    if (client.chatGptLabel) {
+      client.chatGptLabel = null;
+    }
+    if (client.modelLabel) {
+      client.modelLabel = null;
+    }
+    if (client.modelOptions) {
+      client.modelOptions = null;
+    }
+    if (client.defaultVisionModel) {
+      client.defaultVisionModel = null;
+    }
+    if (client.maxPromptTokens) {
+      client.maxPromptTokens = null;
+    }
+    if (client.maxResponseTokens) {
+      client.maxResponseTokens = null;
+    }
+    if (client.run) {
+      // Break circular references in run
+      if (client.run.Graph) {
+        client.run.Graph.resetValues();
+        client.run.Graph.handlerRegistry = null;
+        client.run.Graph.runId = null;
+        client.run.Graph.tools = null;
+        client.run.Graph.signal = null;
+        client.run.Graph.config = null;
+        client.run.Graph.toolEnd = null;
+        client.run.Graph.toolMap = null;
+        client.run.Graph.provider = null;
+        client.run.Graph.streamBuffer = null;
+        client.run.Graph.clientOptions = null;
+        client.run.Graph.graphState = null;
+        if (client.run.Graph.boundModel?.client) {
+          client.run.Graph.boundModel.client = null;
+        }
+        client.run.Graph.boundModel = null;
+        client.run.Graph.systemMessage = null;
+        client.run.Graph.reasoningKey = null;
+        client.run.Graph.messages = null;
+        client.run.Graph.contentData = null;
+        client.run.Graph.stepKeyIds = null;
+        client.run.Graph.contentIndexMap = null;
+        client.run.Graph.toolCallStepIds = null;
+        client.run.Graph.messageIdsByStepKey = null;
+        client.run.Graph.messageStepHasToolCalls = null;
+        client.run.Graph.prelimMessageIdsByStepKey = null;
+        client.run.Graph.currentTokenType = null;
+        client.run.Graph.lastToken = null;
+        client.run.Graph.tokenTypeSwitch = null;
+        client.run.Graph.indexTokenCountMap = null;
+        client.run.Graph.currentUsage = null;
+        client.run.Graph.tokenCounter = null;
+        client.run.Graph.maxContextTokens = null;
+        client.run.Graph.pruneMessages = null;
+        client.run.Graph.lastStreamCall = null;
+        client.run.Graph.startIndex = null;
+        client.run.Graph = null;
+      }
+      if (client.run.handlerRegistry) {
+        client.run.handlerRegistry = null;
+      }
+      if (client.run.graphRunnable) {
+        if (client.run.graphRunnable.channels) {
+          client.run.graphRunnable.channels = null;
+        }
+        if (client.run.graphRunnable.nodes) {
+          client.run.graphRunnable.nodes = null;
+        }
+        if (client.run.graphRunnable.lc_kwargs) {
+          client.run.graphRunnable.lc_kwargs = null;
+        }
+        if (client.run.graphRunnable.builder?.nodes) {
+          client.run.graphRunnable.builder.nodes = null;
+          client.run.graphRunnable.builder = null;
+        }
+        client.run.graphRunnable = null;
+      }
+      client.run = null;
+    }
+    if (client.sendMessage) {
+      client.sendMessage = null;
+    }
+    if (client.savedMessageIds) {
+      client.savedMessageIds.clear();
+      client.savedMessageIds = null;
+    }
+    if (client.currentMessages) {
+      client.currentMessages = null;
+    }
+    if (client.streamHandler) {
+      client.streamHandler = null;
+    }
+    if (client.contentParts) {
+      client.contentParts = null;
+    }
+    if (client.abortController) {
+      client.abortController = null;
+    }
+    if (client.collectedUsage) {
+      client.collectedUsage = null;
+    }
+    if (client.indexTokenCountMap) {
+      client.indexTokenCountMap = null;
+    }
+    if (client.agentConfigs) {
+      client.agentConfigs = null;
+    }
+    if (client.artifactPromises) {
+      client.artifactPromises = null;
+    }
+    if (client.usage) {
+      client.usage = null;
+    }
+    if (typeof client.dispose === 'function') {
+      client.dispose();
+    }
+    if (client.options) {
+      if (client.options.req) {
+        client.options.req = null;
+      }
+      if (client.options.res) {
+        client.options.res = null;
+      }
+      if (client.options.attachments) {
+        client.options.attachments = null;
+      }
+      if (client.options.agent) {
+        client.options.agent = null;
+      }
+    }
+    client.options = null;
+  } catch (e) {
+    // Ignore errors during disposal
+  }
+}
+
+function processReqData(data = {}, context) {
+  let {
+    abortKey,
+    userMessage,
+    userMessagePromise,
+    responseMessageId,
+    promptTokens,
+    conversationId,
+    userMessageId,
+  } = context;
+  for (const key in data) {
+    if (key === 'userMessage') {
+      userMessage = data[key];
+      userMessageId = data[key].messageId;
+    } else if (key === 'userMessagePromise') {
+      userMessagePromise = data[key];
+    } else if (key === 'responseMessageId') {
+      responseMessageId = data[key];
+    } else if (key === 'promptTokens') {
+      promptTokens = data[key];
+    } else if (key === 'abortKey') {
+      abortKey = data[key];
+    } else if (!conversationId && key === 'conversationId') {
+      conversationId = data[key];
+    }
+  }
+  return {
+    abortKey,
+    userMessage,
+    userMessagePromise,
+    responseMessageId,
+    promptTokens,
+    conversationId,
+    userMessageId,
+  };
+}
+
+module.exports = {
+  disposeClient,
+  requestDataMap,
+  clientRegistry,
+  processReqData,
+};

api/server/controllers/AskController.js

@@ -1,5 +1,15 @@
 const { getResponseSender, Constants } = require('librechat-data-provider');
-const { createAbortController, handleAbortError } = require('~/server/middleware');
+const {
+  handleAbortError,
+  createAbortController,
+  cleanupAbortController,
+} = require('~/server/middleware');
+const {
+  disposeClient,
+  processReqData,
+  clientRegistry,
+  requestDataMap,
+} = require('~/server/cleanup');
 const { sendMessage, createOnProgress } = require('~/server/utils');
 const { saveMessage } = require('~/models');
 const { logger } = require('~/config');
@@ -14,90 +24,162 @@ const AskController = async (req, res, next, initializeClient, addTitle) => {
     overrideParentMessageId = null,
   } = req.body;
 
+  let client = null;
+  let abortKey = null;
+  let cleanupHandlers = [];
+  let clientRef = null;
+
   logger.debug('[AskController]', {
     text,
     conversationId,
     ...endpointOption,
-    modelsConfig: endpointOption.modelsConfig ? 'exists' : '',
+    modelsConfig: endpointOption?.modelsConfig ? 'exists' : '',
   });
 
-  let userMessage;
-  let userMessagePromise;
-  let promptTokens;
-  let userMessageId;
-  let responseMessageId;
+  let userMessage = null;
+  let userMessagePromise = null;
+  let promptTokens = null;
+  let userMessageId = null;
+  let responseMessageId = null;
+  let getAbortData = null;
+
   const sender = getResponseSender({
     ...endpointOption,
     model: endpointOption.modelOptions.model,
     modelDisplayLabel,
   });
-  const newConvo = !conversationId;
-  const user = req.user.id;
+  const initialConversationId = conversationId;
+  const newConvo = !initialConversationId;
+  const userId = req.user.id;
 
-  const getReqData = (data = {}) => {
-    for (let key in data) {
-      if (key === 'userMessage') {
-        userMessage = data[key];
-        userMessageId = data[key].messageId;
-      } else if (key === 'userMessagePromise') {
-        userMessagePromise = data[key];
-      } else if (key === 'responseMessageId') {
-        responseMessageId = data[key];
-      } else if (key === 'promptTokens') {
-        promptTokens = data[key];
-      } else if (!conversationId && key === 'conversationId') {
-        conversationId = data[key];
-      }
-    }
+  let reqDataContext = {
+    userMessage,
+    userMessagePromise,
+    responseMessageId,
+    promptTokens,
+    conversationId,
+    userMessageId,
   };
 
-  let getText;
+  const updateReqData = (data = {}) => {
+    reqDataContext = processReqData(data, reqDataContext);
+    abortKey = reqDataContext.abortKey;
+    userMessage = reqDataContext.userMessage;
+    userMessagePromise = reqDataContext.userMessagePromise;
+    responseMessageId = reqDataContext.responseMessageId;
+    promptTokens = reqDataContext.promptTokens;
+    conversationId = reqDataContext.conversationId;
+    userMessageId = reqDataContext.userMessageId;
+  };
+
+  let { onProgress: progressCallback, getPartialText } = createOnProgress();
+
+  const performCleanup = () => {
+    logger.debug('[AskController] Performing cleanup');
+    if (Array.isArray(cleanupHandlers)) {
+      for (const handler of cleanupHandlers) {
+        try {
+          if (typeof handler === 'function') {
+            handler();
+          }
+        } catch (e) {
+          // Ignore
+        }
+      }
+    }
+
+    if (abortKey) {
+      logger.debug('[AskController] Cleaning up abort controller');
+      cleanupAbortController(abortKey);
+      abortKey = null;
+    }
+
+    if (client) {
+      disposeClient(client);
+      client = null;
+    }
+
+    reqDataContext = null;
+    userMessage = null;
+    userMessagePromise = null;
+    promptTokens = null;
+    getAbortData = null;
+    progressCallback = null;
+    endpointOption = null;
+    cleanupHandlers = null;
+    addTitle = null;
+
+    if (requestDataMap.has(req)) {
+      requestDataMap.delete(req);
+    }
+    logger.debug('[AskController] Cleanup completed');
+  };
 
   try {
-    const { client } = await initializeClient({ req, res, endpointOption });
-    const { onProgress: progressCallback, getPartialText } = createOnProgress();
+    ({ client } = await initializeClient({ req, res, endpointOption }));
+    if (clientRegistry && client) {
+      clientRegistry.register(client, { userId }, client);
+    }
 
-    getText = client.getStreamText != null ? client.getStreamText.bind(client) : getPartialText;
+    if (client) {
+      requestDataMap.set(req, { client });
+    }
 
-    const getAbortData = () => ({
-      sender,
-      conversationId,
-      userMessagePromise,
-      messageId: responseMessageId,
-      parentMessageId: overrideParentMessageId ?? userMessageId,
-      text: getText(),
-      userMessage,
-      promptTokens,
-    });
+    clientRef = new WeakRef(client);
 
-    const { abortController, onStart } = createAbortController(req, res, getAbortData, getReqData);
+    getAbortData = () => {
+      const currentClient = clientRef.deref();
+      const currentText =
+        currentClient?.getStreamText != null ? currentClient.getStreamText() : getPartialText();
 
-    res.on('close', () => {
+      return {
+        sender,
+        conversationId,
+        messageId: reqDataContext.responseMessageId,
+        parentMessageId: overrideParentMessageId ?? userMessageId,
+        text: currentText,
+        userMessage: userMessage,
+        userMessagePromise: userMessagePromise,
+        promptTokens: reqDataContext.promptTokens,
+      };
+    };
+
+    const { onStart, abortController } = createAbortController(
+      req,
+      res,
+      getAbortData,
+      updateReqData,
+    );
+
+    const closeHandler = () => {
       logger.debug('[AskController] Request closed');
-      if (!abortController) {
-        return;
-      } else if (abortController.signal.aborted) {
-        return;
-      } else if (abortController.requestCompleted) {
+      if (!abortController || abortController.signal.aborted || abortController.requestCompleted) {
         return;
       }
-
       abortController.abort();
       logger.debug('[AskController] Request aborted on close');
+    };
+
+    res.on('close', closeHandler);
+    cleanupHandlers.push(() => {
+      try {
+        res.removeListener('close', closeHandler);
+      } catch (e) {
+        // Ignore
+      }
     });
 
     const messageOptions = {
-      user,
+      user: userId,
       parentMessageId,
-      conversationId,
+      conversationId: reqDataContext.conversationId,
       overrideParentMessageId,
-      getReqData,
+      getReqData: updateReqData,
       onStart,
       abortController,
       progressCallback,
       progressOptions: {
         res,
-        // parentMessageId: overrideParentMessageId || userMessageId,
       },
     };
 
@@ -105,59 +187,94 @@ const AskController = async (req, res, next, initializeClient, addTitle) => {
     let response = await client.sendMessage(text, messageOptions);
     response.endpoint = endpointOption.endpoint;
 
-    const { conversation = {} } = await client.responsePromise;
+    const databasePromise = response.databasePromise;
+    delete response.databasePromise;
+
+    const { conversation: convoData = {} } = await databasePromise;
+    const conversation = { ...convoData };
     conversation.title =
       conversation && !conversation.title ? null : conversation?.title || 'New Chat';
 
-    if (client.options.attachments) {
-      userMessage.files = client.options.attachments;
-      conversation.model = endpointOption.modelOptions.model;
-      delete userMessage.image_urls;
+    const latestUserMessage = reqDataContext.userMessage;
+
+    if (client?.options?.attachments && latestUserMessage) {
+      latestUserMessage.files = client.options.attachments;
+      if (endpointOption?.modelOptions?.model) {
+        conversation.model = endpointOption.modelOptions.model;
+      }
+      delete latestUserMessage.image_urls;
     }
 
     if (!abortController.signal.aborted) {
+      const finalResponseMessage = { ...response };
+
       sendMessage(res, {
         final: true,
         conversation,
         title: conversation.title,
-        requestMessage: userMessage,
-        responseMessage: response,
+        requestMessage: latestUserMessage,
+        responseMessage: finalResponseMessage,
       });
       res.end();
 
-      if (!client.savedMessageIds.has(response.messageId)) {
+      if (client?.savedMessageIds && !client.savedMessageIds.has(response.messageId)) {
         await saveMessage(
           req,
-          { ...response, user },
+          { ...finalResponseMessage, user: userId },
           { context: 'api/server/controllers/AskController.js - response end' },
         );
       }
     }
 
-    if (!client.skipSaveUserMessage) {
-      await saveMessage(req, userMessage, {
+    if (!client?.skipSaveUserMessage && latestUserMessage) {
+      await saveMessage(req, latestUserMessage, {
         context: 'api/server/controllers/AskController.js - don\'t skip saving user message',
       });
     }
 
-    if (addTitle && parentMessageId === Constants.NO_PARENT && newConvo) {
+    if (typeof addTitle === 'function' && parentMessageId === Constants.NO_PARENT && newConvo) {
       addTitle(req, {
         text,
-        response,
+        response: { ...response },
         client,
-      });
+      })
+        .then(() => {
+          logger.debug('[AskController] Title generation started');
+        })
+        .catch((err) => {
+          logger.error('[AskController] Error in title generation', err);
+        })
+        .finally(() => {
+          logger.debug('[AskController] Title generation completed');
+          performCleanup();
+        });
+    } else {
+      performCleanup();
     }
   } catch (error) {
-    const partialText = getText && getText();
+    logger.error('[AskController] Error handling request', error);
+    let partialText = '';
+    try {
+      const currentClient = clientRef.deref();
+      partialText =
+        currentClient?.getStreamText != null ? currentClient.getStreamText() : getPartialText();
+    } catch (getTextError) {
+      logger.error('[AskController] Error calling getText() during error handling', getTextError);
+    }
+
     handleAbortError(res, req, error, {
       sender,
       partialText,
-      conversationId,
-      messageId: responseMessageId,
-      parentMessageId: overrideParentMessageId ?? userMessageId ?? parentMessageId,
-    }).catch((err) => {
-      logger.error('[AskController] Error in `handleAbortError`', err);
-    });
+      conversationId: reqDataContext.conversationId,
+      messageId: reqDataContext.responseMessageId,
+      parentMessageId: overrideParentMessageId ?? reqDataContext.userMessageId ?? parentMessageId,
+    })
+      .catch((err) => {
+        logger.error('[AskController] Error in `handleAbortError` during catch block', err);
+      })
+      .finally(() => {
+        performCleanup();
+      });
   }
 };
 

api/server/controllers/EditController.js

@@ -1,5 +1,15 @@
 const { getResponseSender } = require('librechat-data-provider');
-const { createAbortController, handleAbortError } = require('~/server/middleware');
+const {
+  handleAbortError,
+  createAbortController,
+  cleanupAbortController,
+} = require('~/server/middleware');
+const {
+  disposeClient,
+  processReqData,
+  clientRegistry,
+  requestDataMap,
+} = require('~/server/cleanup');
 const { sendMessage, createOnProgress } = require('~/server/utils');
 const { saveMessage } = require('~/models');
 const { logger } = require('~/config');
@@ -17,6 +27,11 @@ const EditController = async (req, res, next, initializeClient) => {
     overrideParentMessageId = null,
   } = req.body;
 
+  let client = null;
+  let abortKey = null;
+  let cleanupHandlers = [];
+  let clientRef = null; // Declare clientRef here
+
   logger.debug('[EditController]', {
     text,
     generation,
@@ -26,123 +41,204 @@ const EditController = async (req, res, next, initializeClient) => {
     modelsConfig: endpointOption.modelsConfig ? 'exists' : '',
   });
 
-  let userMessage;
-  let userMessagePromise;
-  let promptTokens;
+  let userMessage = null;
+  let userMessagePromise = null;
+  let promptTokens = null;
+  let getAbortData = null;
+
   const sender = getResponseSender({
     ...endpointOption,
     model: endpointOption.modelOptions.model,
     modelDisplayLabel,
   });
   const userMessageId = parentMessageId;
-  const user = req.user.id;
+  const userId = req.user.id;
 
-  const getReqData = (data = {}) => {
-    for (let key in data) {
-      if (key === 'userMessage') {
-        userMessage = data[key];
-      } else if (key === 'userMessagePromise') {
-        userMessagePromise = data[key];
-      } else if (key === 'responseMessageId') {
-        responseMessageId = data[key];
-      } else if (key === 'promptTokens') {
-        promptTokens = data[key];
-      }
-    }
+  let reqDataContext = { userMessage, userMessagePromise, responseMessageId, promptTokens };
+
+  const updateReqData = (data = {}) => {
+    reqDataContext = processReqData(data, reqDataContext);
+    abortKey = reqDataContext.abortKey;
+    userMessage = reqDataContext.userMessage;
+    userMessagePromise = reqDataContext.userMessagePromise;
+    responseMessageId = reqDataContext.responseMessageId;
+    promptTokens = reqDataContext.promptTokens;
   };
 
-  const { onProgress: progressCallback, getPartialText } = createOnProgress({
+  let { onProgress: progressCallback, getPartialText } = createOnProgress({
     generation,
   });
 
-  let getText;
+  const performCleanup = () => {
+    logger.debug('[EditController] Performing cleanup');
+    if (Array.isArray(cleanupHandlers)) {
+      for (const handler of cleanupHandlers) {
+        try {
+          if (typeof handler === 'function') {
+            handler();
+          }
+        } catch (e) {
+          // Ignore
+        }
+      }
+    }
+
+    if (abortKey) {
+      logger.debug('[AskController] Cleaning up abort controller');
+      cleanupAbortController(abortKey);
+      abortKey = null;
+    }
+
+    if (client) {
+      disposeClient(client);
+      client = null;
+    }
+
+    reqDataContext = null;
+    userMessage = null;
+    userMessagePromise = null;
+    promptTokens = null;
+    getAbortData = null;
+    progressCallback = null;
+    endpointOption = null;
+    cleanupHandlers = null;
+
+    if (requestDataMap.has(req)) {
+      requestDataMap.delete(req);
+    }
+    logger.debug('[EditController] Cleanup completed');
+  };
 
   try {
-    const { client } = await initializeClient({ req, res, endpointOption });
+    ({ client } = await initializeClient({ req, res, endpointOption }));
 
-    getText = client.getStreamText != null ? client.getStreamText.bind(client) : getPartialText;
+    if (clientRegistry && client) {
+      clientRegistry.register(client, { userId }, client);
+    }
 
-    const getAbortData = () => ({
-      conversationId,
-      userMessagePromise,
-      messageId: responseMessageId,
-      sender,
-      parentMessageId: overrideParentMessageId ?? userMessageId,
-      text: getText(),
-      userMessage,
-      promptTokens,
-    });
+    if (client) {
+      requestDataMap.set(req, { client });
+    }
 
-    const { abortController, onStart } = createAbortController(req, res, getAbortData, getReqData);
+    clientRef = new WeakRef(client);
 
-    res.on('close', () => {
+    getAbortData = () => {
+      const currentClient = clientRef.deref();
+      const currentText =
+        currentClient?.getStreamText != null ? currentClient.getStreamText() : getPartialText();
+
+      return {
+        sender,
+        conversationId,
+        messageId: reqDataContext.responseMessageId,
+        parentMessageId: overrideParentMessageId ?? userMessageId,
+        text: currentText,
+        userMessage: userMessage,
+        userMessagePromise: userMessagePromise,
+        promptTokens: reqDataContext.promptTokens,
+      };
+    };
+
+    const { onStart, abortController } = createAbortController(
+      req,
+      res,
+      getAbortData,
+      updateReqData,
+    );
+
+    const closeHandler = () => {
       logger.debug('[EditController] Request closed');
-      if (!abortController) {
-        return;
-      } else if (abortController.signal.aborted) {
-        return;
-      } else if (abortController.requestCompleted) {
+      if (!abortController || abortController.signal.aborted || abortController.requestCompleted) {
         return;
       }
-
       abortController.abort();
       logger.debug('[EditController] Request aborted on close');
+    };
+
+    res.on('close', closeHandler);
+    cleanupHandlers.push(() => {
+      try {
+        res.removeListener('close', closeHandler);
+      } catch (e) {
+        // Ignore
+      }
     });
 
     let response = await client.sendMessage(text, {
-      user,
+      user: userId,
       generation,
       isContinued,
       isEdited: true,
       conversationId,
       parentMessageId,
-      responseMessageId,
+      responseMessageId: reqDataContext.responseMessageId,
       overrideParentMessageId,
-      getReqData,
+      getReqData: updateReqData,
       onStart,
       abortController,
       progressCallback,
       progressOptions: {
         res,
-        // parentMessageId: overrideParentMessageId || userMessageId,
       },
     });
 
-    const { conversation = {} } = await client.responsePromise;
+    const databasePromise = response.databasePromise;
+    delete response.databasePromise;
+
+    const { conversation: convoData = {} } = await databasePromise;
+    const conversation = { ...convoData };
     conversation.title =
       conversation && !conversation.title ? null : conversation?.title || 'New Chat';
 
-    if (client.options.attachments) {
+    if (client?.options?.attachments && endpointOption?.modelOptions?.model) {
       conversation.model = endpointOption.modelOptions.model;
     }
 
     if (!abortController.signal.aborted) {
+      const finalUserMessage = reqDataContext.userMessage;
+      const finalResponseMessage = { ...response };
+
       sendMessage(res, {
         final: true,
         conversation,
         title: conversation.title,
-        requestMessage: userMessage,
-        responseMessage: response,
+        requestMessage: finalUserMessage,
+        responseMessage: finalResponseMessage,
       });
       res.end();
 
       await saveMessage(
         req,
-        { ...response, user },
+        { ...finalResponseMessage, user: userId },
         { context: 'api/server/controllers/EditController.js - response end' },
       );
     }
+
+    performCleanup();
   } catch (error) {
-    const partialText = getText();
+    logger.error('[EditController] Error handling request', error);
+    let partialText = '';
+    try {
+      const currentClient = clientRef.deref();
+      partialText =
+        currentClient?.getStreamText != null ? currentClient.getStreamText() : getPartialText();
+    } catch (getTextError) {
+      logger.error('[EditController] Error calling getText() during error handling', getTextError);
+    }
+
     handleAbortError(res, req, error, {
       sender,
       partialText,
       conversationId,
-      messageId: responseMessageId,
+      messageId: reqDataContext.responseMessageId,
       parentMessageId: overrideParentMessageId ?? userMessageId ?? parentMessageId,
-    }).catch((err) => {
-      logger.error('[EditController] Error in `handleAbortError`', err);
-    });
+    })
+      .catch((err) => {
+        logger.error('[EditController] Error in `handleAbortError` during catch block', err);
+      })
+      .finally(() => {
+        performCleanup();
+      });
   }
 };
 

api/server/controllers/PluginController.js

@@ -108,7 +108,7 @@ const getAvailableTools = async (req, res) => {
     const pluginManifest = availableTools;
     const customConfig = await getCustomConfig();
     if (customConfig?.mcpServers != null) {
-      const mcpManager = await getMCPManager();
+      const mcpManager = getMCPManager();
       await mcpManager.loadManifestTools(pluginManifest);
     }
 

api/server/controllers/agents/callbacks.js

@@ -246,7 +246,11 @@ function createToolEndCallback({ req, res, artifactPromises }) {
     if (output.artifact.content) {
       /** @type {FormattedContent[]} */
       const content = output.artifact.content;
-      for (const part of content) {
+      for (let i = 0; i < content.length; i++) {
+        const part = content[i];
+        if (!part) {
+          continue;
+        }
         if (part.type !== 'image_url') {
           continue;
         }
@@ -254,8 +258,10 @@ function createToolEndCallback({ req, res, artifactPromises }) {
         artifactPromises.push(
           (async () => {
             const filename = `${output.name}_${output.tool_call_id}_img_${nanoid()}`;
+            const file_id = output.artifact.file_ids?.[i];
             const file = await saveBase64Image(url, {
               req,
+              file_id,
               filename,
               endpoint: metadata.provider,
               context: FileContext.image_generation,

api/server/controllers/agents/client.js

@@ -20,11 +20,9 @@ const {
 const {
   Constants,
   VisionModes,
-  openAISchema,
   ContentTypes,
   EModelEndpoint,
   KnownEndpoints,
-  anthropicSchema,
   isAgentsEndpoint,
   AgentCapabilities,
   bedrockInputSchema,
@@ -35,6 +33,7 @@ const { addCacheControl, createContextHandlers } = require('~/app/clients/prompt
 const { spendTokens, spendStructuredTokens } = require('~/models/spendTokens');
 const { getBufferString, HumanMessage } = require('@langchain/core/messages');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const initOpenAI = require('~/server/services/Endpoints/openAI/initialize');
 const Tokenizer = require('~/server/services/Tokenizer');
 const BaseClient = require('~/app/clients/BaseClient');
 const { logger, sendEvent } = require('~/config');
@@ -43,21 +42,43 @@ const { createRun } = require('./run');
 /** @typedef {import('@librechat/agents').MessageContentComplex} MessageContentComplex */
 /** @typedef {import('@langchain/core/runnables').RunnableConfig} RunnableConfig */
 
-const providerParsers = {
-  [EModelEndpoint.openAI]: openAISchema.parse,
-  [EModelEndpoint.azureOpenAI]: openAISchema.parse,
-  [EModelEndpoint.anthropic]: anthropicSchema.parse,
-  [EModelEndpoint.bedrock]: bedrockInputSchema.parse,
+/**
+ * @param {ServerRequest} req
+ * @param {Agent} agent
+ * @param {string} endpoint
+ */
+const payloadParser = ({ req, agent, endpoint }) => {
+  if (isAgentsEndpoint(endpoint)) {
+    return { model: undefined };
+  } else if (endpoint === EModelEndpoint.bedrock) {
+    return bedrockInputSchema.parse(agent.model_parameters);
+  }
+  return req.body.endpointOption.model_parameters;
 };
 
 const legacyContentEndpoints = new Set([KnownEndpoints.groq, KnownEndpoints.deepseek]);
 
-const noSystemModelRegex = [/\bo1\b/gi];
+const noSystemModelRegex = [/\b(o\d)\b/gi];
 
 // const { processMemory, memoryInstructions } = require('~/server/services/Endpoints/agents/memory');
 // const { getFormattedMemories } = require('~/models/Memory');
 // const { getCurrentDateTime } = require('~/utils');
 
+function createTokenCounter(encoding) {
+  return (message) => {
+    const countTokens = (text) => Tokenizer.getTokenCount(text, encoding);
+    return getTokenCountForMessage(message, countTokens);
+  };
+}
+
+function logToolError(graph, error, toolId) {
+  logger.error(
+    '[api/server/controllers/agents/client.js #chatCompletion] Tool Error',
+    error,
+    toolId,
+  );
+}
+
 class AgentClient extends BaseClient {
   constructor(options = {}) {
     super(null, options);
@@ -180,28 +201,19 @@ class AgentClient extends BaseClient {
   }
 
   getSaveOptions() {
-    const parseOptions = providerParsers[this.options.endpoint];
-    let runOptions =
-      this.options.endpoint === EModelEndpoint.agents
-        ? {
-          model: undefined,
-          // TODO:
-          // would need to be override settings; otherwise, model needs to be undefined
-          // model: this.override.model,
-          // instructions: this.override.instructions,
-          // additional_instructions: this.override.additional_instructions,
-        }
-        : {};
-
-    if (parseOptions) {
-      try {
-        runOptions = parseOptions(this.options.agent.model_parameters);
-      } catch (error) {
-        logger.error(
-          '[api/server/controllers/agents/client.js #getSaveOptions] Error parsing options',
-          error,
-        );
-      }
+    // TODO:
+    // would need to be override settings; otherwise, model needs to be undefined
+    // model: this.override.model,
+    // instructions: this.override.instructions,
+    // additional_instructions: this.override.additional_instructions,
+    let runOptions = {};
+    try {
+      runOptions = payloadParser(this.options);
+    } catch (error) {
+      logger.error(
+        '[api/server/controllers/agents/client.js #getSaveOptions] Error parsing options',
+        error,
+      );
     }
 
     return removeNullishValues(
@@ -352,7 +364,9 @@ class AgentClient extends BaseClient {
             this.contextHandlers?.processFile(file);
             continue;
           }
-
+          if (file.metadata?.fileIdentifier) {
+            continue;
+          }
           // orderedMessages[i].tokenCount += this.calculateImageTokenCost({
           //   width: file.width,
           //   height: file.height,
@@ -539,6 +553,10 @@ class AgentClient extends BaseClient {
   }
 
   async chatCompletion({ payload, abortController = null }) {
+    /** @type {Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string; streamMode: string }} */
+    let config;
+    /** @type {ReturnType<createRun>} */
+    let run;
     try {
       if (!abortController) {
         abortController = new AbortController();
@@ -636,11 +654,11 @@ class AgentClient extends BaseClient {
       /** @type {TCustomConfig['endpoints']['agents']} */
       const agentsEConfig = this.options.req.app.locals[EModelEndpoint.agents];
 
-      /** @type {Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string; streamMode: string }} */
-      const config = {
+      config = {
         configurable: {
           thread_id: this.conversationId,
           last_agent_index: this.agentConfigs?.size ?? 0,
+          user_id: this.user ?? this.options.req.user?.id,
           hide_sequential_outputs: this.options.agent.hide_sequential_outputs,
         },
         recursionLimit: agentsEConfig?.recursionLimit,
@@ -659,15 +677,6 @@ class AgentClient extends BaseClient {
         initialMessages = formatContentStrings(initialMessages);
       }
 
-      /** @type {ReturnType<createRun>} */
-      let run;
-      const countTokens = ((text) => this.getTokenCount(text)).bind(this);
-
-      /** @type {(message: BaseMessage) => number} */
-      const tokenCounter = (message) => {
-        return getTokenCountForMessage(message, countTokens);
-      };
-
       /**
        *
        * @param {Agent} agent
@@ -771,21 +780,18 @@ class AgentClient extends BaseClient {
           run.Graph.contentData = contentData;
         }
 
+        const encoding = this.getEncoding();
         await run.processStream({ messages }, config, {
           keepContent: i !== 0,
-          tokenCounter,
+          tokenCounter: createTokenCounter(encoding),
           indexTokenCountMap: currentIndexCountMap,
           maxContextTokens: agent.maxContextTokens,
           callbacks: {
-            [Callback.TOOL_ERROR]: (graph, error, toolId) => {
-              logger.error(
-                '[api/server/controllers/agents/client.js #chatCompletion] Tool Error',
-                error,
-                toolId,
-              );
-            },
+            [Callback.TOOL_ERROR]: logToolError,
           },
         });
+
+        config.signal = null;
       };
 
       await runAgent(this.options.agent, initialMessages);
@@ -813,6 +819,8 @@ class AgentClient extends BaseClient {
             break;
           }
         }
+        const encoding = this.getEncoding();
+        const tokenCounter = createTokenCounter(encoding);
         for (const [agentId, agent] of this.agentConfigs) {
           if (abortController.signal.aborted === true) {
             break;
@@ -921,19 +929,21 @@ class AgentClient extends BaseClient {
    * @param {string} params.text
    * @param {string} params.conversationId
    */
-  async titleConvo({ text }) {
+  async titleConvo({ text, abortController }) {
     if (!this.run) {
       throw new Error('Run not initialized');
     }
     const { handleLLMEnd, collected: collectedMetadata } = createMetadataAggregator();
+    const endpoint = this.options.agent.endpoint;
+    const { req, res } = this.options;
     /** @type {import('@librechat/agents').ClientOptions} */
-    const clientOptions = {
+    let clientOptions = {
       maxTokens: 75,
     };
-    let endpointConfig = this.options.req.app.locals[this.options.agent.endpoint];
+    let endpointConfig = req.app.locals[endpoint];
     if (!endpointConfig) {
       try {
-        endpointConfig = await getCustomEndpointConfig(this.options.agent.endpoint);
+        endpointConfig = await getCustomEndpointConfig(endpoint);
       } catch (err) {
         logger.error(
           '[api/server/controllers/agents/client.js #titleConvo] Error getting custom endpoint config',
@@ -948,12 +958,35 @@ class AgentClient extends BaseClient {
     ) {
       clientOptions.model = endpointConfig.titleModel;
     }
+    if (
+      endpoint === EModelEndpoint.azureOpenAI &&
+      clientOptions.model &&
+      this.options.agent.model_parameters.model !== clientOptions.model
+    ) {
+      clientOptions =
+        (
+          await initOpenAI({
+            req,
+            res,
+            optionsOnly: true,
+            overrideModel: clientOptions.model,
+            overrideEndpoint: endpoint,
+            endpointOption: {
+              model_parameters: clientOptions,
+            },
+          })
+        )?.llmConfig ?? clientOptions;
+    }
+    if (/\b(o\d)\b/i.test(clientOptions.model) && clientOptions.maxTokens != null) {
+      delete clientOptions.maxTokens;
+    }
     try {
       const titleResult = await this.run.generateTitle({
         inputText: text,
         contentParts: this.contentParts,
         clientOptions,
         chainOptions: {
+          signal: abortController.signal,
           callbacks: [
             {
               handleLLMEnd,
@@ -979,7 +1012,7 @@ class AgentClient extends BaseClient {
         };
       });
 
-      this.recordCollectedUsage({
+      await this.recordCollectedUsage({
         model: clientOptions.model,
         context: 'title',
         collectedUsage,

api/server/controllers/agents/request.js

@@ -1,5 +1,10 @@
 const { Constants } = require('librechat-data-provider');
-const { createAbortController, handleAbortError } = require('~/server/middleware');
+const {
+  handleAbortError,
+  createAbortController,
+  cleanupAbortController,
+} = require('~/server/middleware');
+const { disposeClient, clientRegistry, requestDataMap } = require('~/server/cleanup');
 const { sendMessage } = require('~/server/utils');
 const { saveMessage } = require('~/models');
 const { logger } = require('~/config');
@@ -14,16 +19,22 @@ const AgentController = async (req, res, next, initializeClient, addTitle) => {
   } = req.body;
 
   let sender;
+  let abortKey;
   let userMessage;
   let promptTokens;
   let userMessageId;
   let responseMessageId;
   let userMessagePromise;
+  let getAbortData;
+  let client = null;
+  // Initialize as an array
+  let cleanupHandlers = [];
 
   const newConvo = !conversationId;
-  const user = req.user.id;
+  const userId = req.user.id;
 
-  const getReqData = (data = {}) => {
+  // Create handler to avoid capturing the entire parent scope
+  let getReqData = (data = {}) => {
     for (let key in data) {
       if (key === 'userMessage') {
         userMessage = data[key];
@@ -36,30 +47,96 @@ const AgentController = async (req, res, next, initializeClient, addTitle) => {
         promptTokens = data[key];
       } else if (key === 'sender') {
         sender = data[key];
+      } else if (key === 'abortKey') {
+        abortKey = data[key];
       } else if (!conversationId && key === 'conversationId') {
         conversationId = data[key];
       }
     }
   };
 
+  // Create a function to handle final cleanup
+  const performCleanup = () => {
+    logger.debug('[AgentController] Performing cleanup');
+    // Make sure cleanupHandlers is an array before iterating
+    if (Array.isArray(cleanupHandlers)) {
+      // Execute all cleanup handlers
+      for (const handler of cleanupHandlers) {
+        try {
+          if (typeof handler === 'function') {
+            handler();
+          }
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      }
+    }
+
+    // Clean up abort controller
+    if (abortKey) {
+      logger.debug('[AgentController] Cleaning up abort controller');
+      cleanupAbortController(abortKey);
+    }
+
+    // Dispose client properly
+    if (client) {
+      disposeClient(client);
+    }
+
+    // Clear all references
+    client = null;
+    getReqData = null;
+    userMessage = null;
+    getAbortData = null;
+    endpointOption.agent = null;
+    endpointOption = null;
+    cleanupHandlers = null;
+    userMessagePromise = null;
+
+    // Clear request data map
+    if (requestDataMap.has(req)) {
+      requestDataMap.delete(req);
+    }
+    logger.debug('[AgentController] Cleanup completed');
+  };
+
   try {
     /** @type {{ client: TAgentClient }} */
-    const { client } = await initializeClient({ req, res, endpointOption });
+    const result = await initializeClient({ req, res, endpointOption });
+    client = result.client;
 
-    const getAbortData = () => ({
-      sender,
-      userMessage,
-      promptTokens,
-      conversationId,
-      userMessagePromise,
-      messageId: responseMessageId,
-      content: client.getContentParts(),
-      parentMessageId: overrideParentMessageId ?? userMessageId,
-    });
+    // Register client with finalization registry if available
+    if (clientRegistry) {
+      clientRegistry.register(client, { userId }, client);
+    }
+
+    // Store request data in WeakMap keyed by req object
+    requestDataMap.set(req, { client });
+
+    // Use WeakRef to allow GC but still access content if it exists
+    const contentRef = new WeakRef(client.contentParts || []);
+
+    // Minimize closure scope - only capture small primitives and WeakRef
+    getAbortData = () => {
+      // Dereference WeakRef each time
+      const content = contentRef.deref();
+
+      return {
+        sender,
+        content: content || [],
+        userMessage,
+        promptTokens,
+        conversationId,
+        userMessagePromise,
+        messageId: responseMessageId,
+        parentMessageId: overrideParentMessageId ?? userMessageId,
+      };
+    };
 
     const { abortController, onStart } = createAbortController(req, res, getAbortData, getReqData);
 
-    res.on('close', () => {
+    // Simple handler to avoid capturing scope
+    const closeHandler = () => {
       logger.debug('[AgentController] Request closed');
       if (!abortController) {
         return;
@@ -71,10 +148,19 @@ const AgentController = async (req, res, next, initializeClient, addTitle) => {
 
       abortController.abort();
       logger.debug('[AgentController] Request aborted on close');
+    };
+
+    res.on('close', closeHandler);
+    cleanupHandlers.push(() => {
+      try {
+        res.removeListener('close', closeHandler);
+      } catch (e) {
+        // Ignore
+      }
     });
 
     const messageOptions = {
-      user,
+      user: userId,
       onStart,
       getReqData,
       conversationId,
@@ -83,69 +169,103 @@ const AgentController = async (req, res, next, initializeClient, addTitle) => {
       overrideParentMessageId,
       progressOptions: {
         res,
-        // parentMessageId: overrideParentMessageId || userMessageId,
       },
     };
 
     let response = await client.sendMessage(text, messageOptions);
-    response.endpoint = endpointOption.endpoint;
 
-    const { conversation = {} } = await client.responsePromise;
+    // Extract what we need and immediately break reference
+    const messageId = response.messageId;
+    const endpoint = endpointOption.endpoint;
+    response.endpoint = endpoint;
+
+    // Store database promise locally
+    const databasePromise = response.databasePromise;
+    delete response.databasePromise;
+
+    // Resolve database-related data
+    const { conversation: convoData = {} } = await databasePromise;
+    const conversation = { ...convoData };
     conversation.title =
       conversation && !conversation.title ? null : conversation?.title || 'New Chat';
 
-    if (req.body.files && client.options.attachments) {
+    // Process files if needed
+    if (req.body.files && client.options?.attachments) {
       userMessage.files = [];
       const messageFiles = new Set(req.body.files.map((file) => file.file_id));
       for (let attachment of client.options.attachments) {
         if (messageFiles.has(attachment.file_id)) {
-          userMessage.files.push(attachment);
+          userMessage.files.push({ ...attachment });
         }
       }
       delete userMessage.image_urls;
     }
 
+    // Only send if not aborted
     if (!abortController.signal.aborted) {
+      // Create a new response object with minimal copies
+      const finalResponse = { ...response };
+
       sendMessage(res, {
         final: true,
         conversation,
         title: conversation.title,
         requestMessage: userMessage,
-        responseMessage: response,
+        responseMessage: finalResponse,
       });
       res.end();
 
-      if (!client.savedMessageIds.has(response.messageId)) {
+      // Save the message if needed
+      if (client.savedMessageIds && !client.savedMessageIds.has(messageId)) {
         await saveMessage(
           req,
-          { ...response, user },
+          { ...finalResponse, user: userId },
           { context: 'api/server/controllers/agents/request.js - response end' },
         );
       }
     }
 
+    // Save user message if needed
     if (!client.skipSaveUserMessage) {
       await saveMessage(req, userMessage, {
         context: 'api/server/controllers/agents/request.js - don\'t skip saving user message',
       });
     }
 
+    // Add title if needed - extract minimal data
     if (addTitle && parentMessageId === Constants.NO_PARENT && newConvo) {
       addTitle(req, {
         text,
-        response,
+        response: { ...response },
         client,
-      });
+      })
+        .then(() => {
+          logger.debug('[AgentController] Title generation started');
+        })
+        .catch((err) => {
+          logger.error('[AgentController] Error in title generation', err);
+        })
+        .finally(() => {
+          logger.debug('[AgentController] Title generation completed');
+          performCleanup();
+        });
+    } else {
+      performCleanup();
     }
   } catch (error) {
+    // Handle error without capturing much scope
     handleAbortError(res, req, error, {
       conversationId,
       sender,
       messageId: responseMessageId,
       parentMessageId: overrideParentMessageId ?? userMessageId ?? parentMessageId,
-    }).catch((err) => {
-      logger.error('[api/server/controllers/agents/request] Error in `handleAbortError`', err);
-    });
+    })
+      .catch((err) => {
+        logger.error('[api/server/controllers/agents/request] Error in `handleAbortError`', err);
+      })
+      .finally(() => {
+        performCleanup();
+      });
   }
 };
 

api/server/controllers/agents/run.js

@@ -11,6 +11,13 @@ const { providerEndpointMap, KnownEndpoints } = require('librechat-data-provider
  * @typedef {import('@librechat/agents').IState} IState
  */
 
+const customProviders = new Set([
+  Providers.XAI,
+  Providers.OLLAMA,
+  Providers.DEEPSEEK,
+  Providers.OPENROUTER,
+]);
+
 /**
  * Creates a new Run instance with custom handlers and configuration.
  *
@@ -43,8 +50,11 @@ async function createRun({
     agent.model_parameters,
   );
 
-  /** Resolves Mistral type strictness due to new OpenAI usage field */
-  if (agent.endpoint?.toLowerCase().includes(KnownEndpoints.mistral)) {
+  /** Resolves issues with new OpenAI usage field */
+  if (
+    customProviders.has(agent.provider) ||
+    (agent.provider === Providers.OPENAI && agent.endpoint !== agent.provider)
+  ) {
     llmConfig.streamUsage = false;
     llmConfig.usage = true;
   }

api/server/index.js

@@ -88,8 +88,8 @@ const startServer = async () => {
   app.use('/api/actions', routes.actions);
   app.use('/api/keys', routes.keys);
   app.use('/api/user', routes.user);
-  app.use('/api/search', routes.search);
   app.use('/api/ask', routes.ask);
+  app.use('/api/search', routes.search);
   app.use('/api/edit', routes.edit);
   app.use('/api/messages', routes.messages);
   app.use('/api/convos', routes.convos);

api/server/middleware/abortMiddleware.js

@@ -1,3 +1,4 @@
+// abortMiddleware.js
 const { isAssistantsEndpoint, ErrorTypes } = require('librechat-data-provider');
 const { sendMessage, sendError, countTokens, isEnabled } = require('~/server/utils');
 const { truncateText, smartTruncateText } = require('~/app/clients/prompts');
@@ -8,6 +9,68 @@ const { saveMessage, getConvo } = require('~/models');
 const { abortRun } = require('./abortRun');
 const { logger } = require('~/config');
 
+const abortDataMap = new WeakMap();
+
+function cleanupAbortController(abortKey) {
+  if (!abortControllers.has(abortKey)) {
+    return false;
+  }
+
+  const { abortController } = abortControllers.get(abortKey);
+
+  if (!abortController) {
+    abortControllers.delete(abortKey);
+    return true;
+  }
+
+  // 1. Check if this controller has any composed signals and clean them up
+  try {
+    // This creates a temporary composed signal to use for cleanup
+    const composedSignal = AbortSignal.any([abortController.signal]);
+
+    // Get all event types - in practice, AbortSignal typically only uses 'abort'
+    const eventTypes = ['abort'];
+
+    // First, execute a dummy listener removal to handle potential composed signals
+    for (const eventType of eventTypes) {
+      const dummyHandler = () => {};
+      composedSignal.addEventListener(eventType, dummyHandler);
+      composedSignal.removeEventListener(eventType, dummyHandler);
+
+      const listeners = composedSignal.listeners?.(eventType) || [];
+      for (const listener of listeners) {
+        composedSignal.removeEventListener(eventType, listener);
+      }
+    }
+  } catch (e) {
+    logger.debug(`Error cleaning up composed signals: ${e}`);
+  }
+
+  // 2. Abort the controller if not already aborted
+  if (!abortController.signal.aborted) {
+    abortController.abort();
+  }
+
+  // 3. Remove from registry
+  abortControllers.delete(abortKey);
+
+  // 4. Clean up any data stored in the WeakMap
+  if (abortDataMap.has(abortController)) {
+    abortDataMap.delete(abortController);
+  }
+
+  // 5. Clean up function references on the controller
+  if (abortController.getAbortData) {
+    abortController.getAbortData = null;
+  }
+
+  if (abortController.abortCompletion) {
+    abortController.abortCompletion = null;
+  }
+
+  return true;
+}
+
 async function abortMessage(req, res) {
   let { abortKey, endpoint } = req.body;
 
@@ -29,24 +92,24 @@ async function abortMessage(req, res) {
   if (!abortController) {
     return res.status(204).send({ message: 'Request not found' });
   }
-  const finalEvent = await abortController.abortCompletion();
+
+  const finalEvent = await abortController.abortCompletion?.();
   logger.debug(
     `[abortMessage] ID: ${req.user.id} | ${req.user.email} | Aborted request: ` +
       JSON.stringify({ abortKey }),
   );
-  abortControllers.delete(abortKey);
+  cleanupAbortController(abortKey);
 
   if (res.headersSent && finalEvent) {
     return sendMessage(res, finalEvent);
   }
 
   res.setHeader('Content-Type', 'application/json');
-
   res.send(JSON.stringify(finalEvent));
 }
 
-const handleAbort = () => {
-  return async (req, res) => {
+const handleAbort = function () {
+  return async function (req, res) {
     try {
       if (isEnabled(process.env.LIMIT_CONCURRENT_MESSAGES)) {
         await clearPendingReq({ userId: req.user.id });
@@ -62,8 +125,48 @@ const createAbortController = (req, res, getAbortData, getReqData) => {
   const abortController = new AbortController();
   const { endpointOption } = req.body;
 
+  // Store minimal data in WeakMap to avoid circular references
+  abortDataMap.set(abortController, {
+    getAbortDataFn: getAbortData,
+    userId: req.user.id,
+    endpoint: endpointOption.endpoint,
+    iconURL: endpointOption.iconURL,
+    model: endpointOption.modelOptions?.model || endpointOption.model_parameters?.model,
+  });
+
+  // Replace the direct function reference with a wrapper that uses WeakMap
   abortController.getAbortData = function () {
-    return getAbortData();
+    const data = abortDataMap.get(this);
+    if (!data || typeof data.getAbortDataFn !== 'function') {
+      return {};
+    }
+
+    try {
+      const result = data.getAbortDataFn();
+
+      // Create a copy without circular references
+      const cleanResult = { ...result };
+
+      // If userMessagePromise exists, break its reference to client
+      if (
+        cleanResult.userMessagePromise &&
+        typeof cleanResult.userMessagePromise.then === 'function'
+      ) {
+        // Create a new promise that fulfills with the same result but doesn't reference the original
+        const originalPromise = cleanResult.userMessagePromise;
+        cleanResult.userMessagePromise = new Promise((resolve, reject) => {
+          originalPromise.then(
+            (result) => resolve({ ...result }),
+            (error) => reject(error),
+          );
+        });
+      }
+
+      return cleanResult;
+    } catch (err) {
+      logger.error('[abortController.getAbortData] Error:', err);
+      return {};
+    }
   };
 
   /**
@@ -74,6 +177,7 @@ const createAbortController = (req, res, getAbortData, getReqData) => {
     sendMessage(res, { message: userMessage, created: true });
 
     const abortKey = userMessage?.conversationId ?? req.user.id;
+    getReqData({ abortKey });
     const prevRequest = abortControllers.get(abortKey);
     const { overrideUserMessageId } = req?.body ?? {};
 
@@ -81,34 +185,74 @@ const createAbortController = (req, res, getAbortData, getReqData) => {
       const data = prevRequest.abortController.getAbortData();
       getReqData({ userMessage: data?.userMessage });
       const addedAbortKey = `${abortKey}:${responseMessageId}`;
-      abortControllers.set(addedAbortKey, { abortController, ...endpointOption });
-      res.on('finish', function () {
-        abortControllers.delete(addedAbortKey);
-      });
+
+      // Store minimal options
+      const minimalOptions = {
+        endpoint: endpointOption.endpoint,
+        iconURL: endpointOption.iconURL,
+        model: endpointOption.modelOptions?.model || endpointOption.model_parameters?.model,
+      };
+
+      abortControllers.set(addedAbortKey, { abortController, ...minimalOptions });
+
+      // Use a simple function for cleanup to avoid capturing context
+      const cleanupHandler = () => {
+        try {
+          cleanupAbortController(addedAbortKey);
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      };
+
+      res.on('finish', cleanupHandler);
       return;
     }
 
-    abortControllers.set(abortKey, { abortController, ...endpointOption });
+    // Store minimal options
+    const minimalOptions = {
+      endpoint: endpointOption.endpoint,
+      iconURL: endpointOption.iconURL,
+      model: endpointOption.modelOptions?.model || endpointOption.model_parameters?.model,
+    };
 
-    res.on('finish', function () {
-      abortControllers.delete(abortKey);
-    });
+    abortControllers.set(abortKey, { abortController, ...minimalOptions });
+
+    // Use a simple function for cleanup to avoid capturing context
+    const cleanupHandler = () => {
+      try {
+        cleanupAbortController(abortKey);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    };
+
+    res.on('finish', cleanupHandler);
   };
 
+  // Define abortCompletion without capturing the entire parent scope
   abortController.abortCompletion = async function () {
-    abortController.abort();
+    this.abort();
+
+    // Get data from WeakMap
+    const ctrlData = abortDataMap.get(this);
+    if (!ctrlData || !ctrlData.getAbortDataFn) {
+      return { final: true, conversation: {}, title: 'New Chat' };
+    }
+
+    // Get abort data using stored function
     const { conversationId, userMessage, userMessagePromise, promptTokens, ...responseData } =
-      getAbortData();
+      ctrlData.getAbortDataFn();
+
     const completionTokens = await countTokens(responseData?.text ?? '');
-    const user = req.user.id;
+    const user = ctrlData.userId;
 
     const responseMessage = {
       ...responseData,
       conversationId,
       finish_reason: 'incomplete',
-      endpoint: endpointOption.endpoint,
-      iconURL: endpointOption.iconURL,
-      model: endpointOption.modelOptions?.model ?? endpointOption.model_parameters?.model,
+      endpoint: ctrlData.endpoint,
+      iconURL: ctrlData.iconURL,
+      model: ctrlData.modelOptions?.model ?? ctrlData.model_parameters?.model,
       unfinished: false,
       error: false,
       isCreatedByUser: false,
@@ -130,10 +274,12 @@ const createAbortController = (req, res, getAbortData, getReqData) => {
     if (userMessagePromise) {
       const resolved = await userMessagePromise;
       conversation = resolved?.conversation;
+      // Break reference to promise
+      resolved.conversation = null;
     }
 
     if (!conversation) {
-      conversation = await getConvo(req.user.id, conversationId);
+      conversation = await getConvo(user, conversationId);
     }
 
     return {
@@ -218,11 +364,12 @@ const handleAbortError = async (res, req, error, data) => {
       };
     }
 
+    // Create a simple callback without capturing parent scope
     const callback = async () => {
-      if (abortControllers.has(conversationId)) {
-        const { abortController } = abortControllers.get(conversationId);
-        abortController.abort();
-        abortControllers.delete(conversationId);
+      try {
+        cleanupAbortController(conversationId);
+      } catch (e) {
+        // Ignore cleanup errors
       }
     };
 
@@ -243,6 +390,7 @@ const handleAbortError = async (res, req, error, data) => {
 
 module.exports = {
   handleAbort,
-  createAbortController,
   handleAbortError,
+  createAbortController,
+  cleanupAbortController,
 };

api/server/middleware/buildEndpointOption.js

@@ -1,6 +1,11 @@
-const { parseCompactConvo, EModelEndpoint, isAgentsEndpoint } = require('librechat-data-provider');
-const { getModelsConfig } = require('~/server/controllers/ModelController');
+const {
+  parseCompactConvo,
+  EModelEndpoint,
+  isAgentsEndpoint,
+  EndpointURLs,
+} = require('librechat-data-provider');
 const azureAssistants = require('~/server/services/Endpoints/azureAssistants');
+const { getModelsConfig } = require('~/server/controllers/ModelController');
 const assistants = require('~/server/services/Endpoints/assistants');
 const gptPlugins = require('~/server/services/Endpoints/gptPlugins');
 const { processFiles } = require('~/server/services/Files/process');
@@ -77,8 +82,9 @@ async function buildEndpointOption(req, res, next) {
   }
 
   try {
-    const isAgents = isAgentsEndpoint(endpoint);
-    const endpointFn = buildFunction[endpointType ?? endpoint];
+    const isAgents =
+      isAgentsEndpoint(endpoint) || req.baseUrl.startsWith(EndpointURLs[EModelEndpoint.agents]);
+    const endpointFn = buildFunction[isAgents ? EModelEndpoint.agents : (endpointType ?? endpoint)];
     const builder = isAgents ? (...args) => endpointFn(req, ...args) : endpointFn;
 
     // TODO: use object params

api/server/middleware/checkBan.js

@@ -1,4 +1,4 @@
-const Keyv = require('keyv');
+const { Keyv } = require('keyv');
 const uap = require('ua-parser-js');
 const { ViolationTypes } = require('librechat-data-provider');
 const { isEnabled, removePorts } = require('~/server/utils');

api/server/middleware/concurrentLimiter.js

@@ -1,4 +1,4 @@
-const { Time } = require('librechat-data-provider');
+const { Time, CacheKeys } = require('librechat-data-provider');
 const clearPendingReq = require('~/cache/clearPendingReq');
 const { logViolation, getLogStores } = require('~/cache');
 const { isEnabled } = require('~/server/utils');
@@ -25,7 +25,7 @@ const {
  * @throws {Error} Throws an error if the user exceeds the concurrent request limit.
  */
 const concurrentLimiter = async (req, res, next) => {
-  const namespace = 'pending_req';
+  const namespace = CacheKeys.PENDING_REQ;
   const cache = getLogStores(namespace);
   if (!cache) {
     return next();

api/server/middleware/limiters/importLimiters.js

@@ -1,10 +1,9 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
+const ioredisClient = require('~/cache/ioredisClient');
 const logViolation = require('~/cache/logViolation');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logger } = require('~/config');
 
 const getEnvironmentVariables = () => {
@@ -67,11 +66,9 @@ const createImportLimiters = () => {
     },
   };
 
-  if (isEnabled(process.env.USE_REDIS)) {
+  if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
     logger.debug('Using Redis for import rate limiters.');
-    const keyv = new Keyv({ store: keyvRedis });
-    const client = keyv.opts.store.redis;
-    const sendCommand = (...args) => client.call(...args);
+    const sendCommand = (...args) => ioredisClient.call(...args);
     const ipStore = new RedisStore({
       sendCommand,
       prefix: 'import_ip_limiter:',

api/server/middleware/limiters/loginLimiter.js

@@ -1,8 +1,7 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { removePorts, isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
+const ioredisClient = require('~/cache/ioredisClient');
 const { logViolation } = require('~/cache');
 const { logger } = require('~/config');
 
@@ -31,13 +30,10 @@ const limiterOptions = {
   keyGenerator: removePorts,
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for login rate limiter.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
   const store = new RedisStore({
-    sendCommand,
+    sendCommand: (...args) => ioredisClient.call(...args),
     prefix: 'login_limiter:',
   });
   limiterOptions.store = store;

api/server/middleware/limiters/messageLimiters.js

@@ -1,9 +1,8 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const denyRequest = require('~/server/middleware/denyRequest');
+const ioredisClient = require('~/cache/ioredisClient');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logViolation } = require('~/cache');
 const { logger } = require('~/config');
 
@@ -63,11 +62,9 @@ const userLimiterOptions = {
   },
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for message rate limiters.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
+  const sendCommand = (...args) => ioredisClient.call(...args);
   const ipStore = new RedisStore({
     sendCommand,
     prefix: 'message_ip_limiter:',

api/server/middleware/limiters/registerLimiter.js

@@ -1,8 +1,7 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { removePorts, isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
+const ioredisClient = require('~/cache/ioredisClient');
 const { logViolation } = require('~/cache');
 const { logger } = require('~/config');
 
@@ -31,13 +30,10 @@ const limiterOptions = {
   keyGenerator: removePorts,
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for register rate limiter.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
   const store = new RedisStore({
-    sendCommand,
+    sendCommand: (...args) => ioredisClient.call(...args),
     prefix: 'register_limiter:',
   });
   limiterOptions.store = store;

api/server/middleware/limiters/resetPasswordLimiter.js

@@ -1,9 +1,8 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts, isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
+const ioredisClient = require('~/cache/ioredisClient');
 const { logViolation } = require('~/cache');
 const { logger } = require('~/config');
 
@@ -36,13 +35,10 @@ const limiterOptions = {
   keyGenerator: removePorts,
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for reset password rate limiter.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
   const store = new RedisStore({
-    sendCommand,
+    sendCommand: (...args) => ioredisClient.call(...args),
     prefix: 'reset_password_limiter:',
   });
   limiterOptions.store = store;

api/server/middleware/limiters/sttLimiters.js

@@ -1,10 +1,9 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
+const ioredisClient = require('~/cache/ioredisClient');
 const logViolation = require('~/cache/logViolation');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logger } = require('~/config');
 
 const getEnvironmentVariables = () => {
@@ -67,11 +66,9 @@ const createSTTLimiters = () => {
     },
   };
 
-  if (isEnabled(process.env.USE_REDIS)) {
+  if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
     logger.debug('Using Redis for STT rate limiters.');
-    const keyv = new Keyv({ store: keyvRedis });
-    const client = keyv.opts.store.redis;
-    const sendCommand = (...args) => client.call(...args);
+    const sendCommand = (...args) => ioredisClient.call(...args);
     const ipStore = new RedisStore({
       sendCommand,
       prefix: 'stt_ip_limiter:',

api/server/middleware/limiters/toolCallLimiter.js

@@ -1,10 +1,9 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
+const ioredisClient = require('~/cache/ioredisClient');
 const logViolation = require('~/cache/logViolation');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logger } = require('~/config');
 
 const handler = async (req, res) => {
@@ -29,13 +28,10 @@ const limiterOptions = {
   },
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for tool call rate limiter.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
   const store = new RedisStore({
-    sendCommand,
+    sendCommand: (...args) => ioredisClient.call(...args),
     prefix: 'tool_call_limiter:',
   });
   limiterOptions.store = store;

api/server/middleware/limiters/ttsLimiters.js

@@ -1,10 +1,9 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
+const ioredisClient = require('~/cache/ioredisClient');
 const logViolation = require('~/cache/logViolation');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logger } = require('~/config');
 
 const getEnvironmentVariables = () => {
@@ -67,11 +66,9 @@ const createTTSLimiters = () => {
     },
   };
 
-  if (isEnabled(process.env.USE_REDIS)) {
+  if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
     logger.debug('Using Redis for TTS rate limiters.');
-    const keyv = new Keyv({ store: keyvRedis });
-    const client = keyv.opts.store.redis;
-    const sendCommand = (...args) => client.call(...args);
+    const sendCommand = (...args) => ioredisClient.call(...args);
     const ipStore = new RedisStore({
       sendCommand,
       prefix: 'tts_ip_limiter:',

api/server/middleware/limiters/uploadLimiters.js

@@ -1,10 +1,9 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
+const ioredisClient = require('~/cache/ioredisClient');
 const logViolation = require('~/cache/logViolation');
 const { isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
 const { logger } = require('~/config');
 
 const getEnvironmentVariables = () => {
@@ -72,11 +71,9 @@ const createFileLimiters = () => {
     },
   };
 
-  if (isEnabled(process.env.USE_REDIS)) {
+  if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
     logger.debug('Using Redis for file upload rate limiters.');
-    const keyv = new Keyv({ store: keyvRedis });
-    const client = keyv.opts.store.redis;
-    const sendCommand = (...args) => client.call(...args);
+    const sendCommand = (...args) => ioredisClient.call(...args);
     const ipStore = new RedisStore({
       sendCommand,
       prefix: 'file_upload_ip_limiter:',

api/server/middleware/limiters/verifyEmailLimiter.js

@@ -1,9 +1,8 @@
-const Keyv = require('keyv');
 const rateLimit = require('express-rate-limit');
 const { RedisStore } = require('rate-limit-redis');
 const { ViolationTypes } = require('librechat-data-provider');
 const { removePorts, isEnabled } = require('~/server/utils');
-const keyvRedis = require('~/cache/keyvRedis');
+const ioredisClient = require('~/cache/ioredisClient');
 const { logViolation } = require('~/cache');
 const { logger } = require('~/config');
 
@@ -36,13 +35,10 @@ const limiterOptions = {
   keyGenerator: removePorts,
 };
 
-if (isEnabled(process.env.USE_REDIS)) {
+if (isEnabled(process.env.USE_REDIS) && ioredisClient) {
   logger.debug('Using Redis for verify email rate limiter.');
-  const keyv = new Keyv({ store: keyvRedis });
-  const client = keyv.opts.store.redis;
-  const sendCommand = (...args) => client.call(...args);
   const store = new RedisStore({
-    sendCommand,
+    sendCommand: (...args) => ioredisClient.call(...args),
     prefix: 'verify_email_limiter:',
   });
   limiterOptions.store = store;

api/server/middleware/roles/generateCheckAccess.js

@@ -17,9 +17,9 @@ const checkAccess = async (user, permissionType, permissions, bodyProps = {}, ch
   }
 
   const role = await getRoleByName(user.role);
-  if (role && role[permissionType]) {
+  if (role && role.permissions && role.permissions[permissionType]) {
     const hasAnyPermission = permissions.some((permission) => {
-      if (role[permissionType][permission]) {
+      if (role.permissions[permissionType][permission]) {
         return true;
       }
 

api/server/routes/actions.js

@@ -1,5 +1,6 @@
 const express = require('express');
 const jwt = require('jsonwebtoken');
+const { CacheKeys } = require('librechat-data-provider');
 const { getAccessToken } = require('~/server/services/TokenService');
 const { logger, getFlowStateManager } = require('~/config');
 const { getLogStores } = require('~/cache');
@@ -19,8 +20,8 @@ const JWT_SECRET = process.env.JWT_SECRET;
 router.get('/:action_id/oauth/callback', async (req, res) => {
   const { action_id } = req.params;
   const { code, state } = req.query;
-
-  const flowManager = await getFlowStateManager(getLogStores);
+  const flowsCache = getLogStores(CacheKeys.FLOWS);
+  const flowManager = getFlowStateManager(flowsCache);
   let identifier = action_id;
   try {
     let decodedState;

api/server/routes/agents/actions.js

@@ -58,7 +58,7 @@ router.post('/:agent_id', async (req, res) => {
     }
 
     let { domain } = metadata;
-    domain = await domainParser(req, domain, true);
+    domain = await domainParser(domain, true);
 
     if (!domain) {
       return res.status(400).json({ message: 'No domain provided' });
@@ -164,7 +164,7 @@ router.delete('/:agent_id/:action_id', async (req, res) => {
       return true;
     });
 
-    domain = await domainParser(req, domain, true);
+    domain = await domainParser(domain, true);
 
     if (!domain) {
       return res.status(400).json({ message: 'No domain provided' });

api/server/routes/agents/chat.js

@@ -2,7 +2,6 @@ const express = require('express');
 const { PermissionTypes, Permissions } = require('librechat-data-provider');
 const {
   setHeaders,
-  handleAbort,
   moderateText,
   // validateModel,
   generateCheckAccess,
@@ -16,28 +15,36 @@ const addTitle = require('~/server/services/Endpoints/agents/title');
 const router = express.Router();
 
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 const checkAgentAccess = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
 
+router.use(checkAgentAccess);
+router.use(validateConvoAccess);
+router.use(buildEndpointOption);
+router.use(setHeaders);
+
+const controller = async (req, res, next) => {
+  await AgentController(req, res, next, initializeClient, addTitle);
+};
+
 /**
- * @route POST /
+ * @route POST / (regular endpoint)
  * @desc Chat with an assistant
  * @access Public
  * @param {express.Request} req - The request object, containing the request data.
  * @param {express.Response} res - The response object, used to send back a response.
  * @returns {void}
  */
-router.post(
-  '/',
-  // validateModel,
-  checkAgentAccess,
-  validateConvoAccess,
-  buildEndpointOption,
-  setHeaders,
-  async (req, res, next) => {
-    await AgentController(req, res, next, initializeClient, addTitle);
-  },
-);
+router.post('/', controller);
+
+/**
+ * @route POST /:endpoint (ephemeral agents)
+ * @desc Chat with an assistant
+ * @access Public
+ * @param {express.Request} req - The request object, containing the request data.
+ * @param {express.Response} res - The response object, used to send back a response.
+ * @returns {void}
+ */
+router.post('/:endpoint', controller);
 
 module.exports = router;

api/server/routes/ask/addToCache.js

@@ -1,4 +1,4 @@
-const Keyv = require('keyv');
+const { Keyv } = require('keyv');
 const { KeyvFile } = require('keyv-file');
 const { logger } = require('~/config');
 

api/server/routes/ask/anthropic.js

@@ -11,8 +11,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/ask/custom.js

@@ -3,7 +3,6 @@ const AskController = require('~/server/controllers/AskController');
 const { initializeClient } = require('~/server/services/Endpoints/custom');
 const { addTitle } = require('~/server/services/Endpoints/openAI');
 const {
-  handleAbort,
   setHeaders,
   validateModel,
   validateEndpoint,
@@ -12,8 +11,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/ask/google.js

@@ -3,7 +3,6 @@ const AskController = require('~/server/controllers/AskController');
 const { initializeClient, addTitle } = require('~/server/services/Endpoints/google');
 const {
   setHeaders,
-  handleAbort,
   validateModel,
   validateEndpoint,
   buildEndpointOption,
@@ -11,8 +10,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/ask/gptPlugins.js

@@ -20,7 +20,6 @@ const { logger } = require('~/config');
 const router = express.Router();
 
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 router.post(
   '/',
@@ -196,7 +195,8 @@ router.post(
 
       logger.debug('[/ask/gptPlugins]', response);
 
-      const { conversation = {} } = await client.responsePromise;
+      const { conversation = {} } = await response.databasePromise;
+      delete response.databasePromise;
       conversation.title =
         conversation && !conversation.title ? null : conversation?.title || 'New Chat';
 

api/server/routes/ask/openAI.js

@@ -12,7 +12,6 @@ const {
 
 const router = express.Router();
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 router.post(
   '/',

api/server/routes/assistants/actions.js

@@ -36,7 +36,7 @@ router.post('/:assistant_id', async (req, res) => {
     }
 
     let { domain } = metadata;
-    domain = await domainParser(req, domain, true);
+    domain = await domainParser(domain, true);
 
     if (!domain) {
       return res.status(400).json({ message: 'No domain provided' });
@@ -172,7 +172,7 @@ router.delete('/:assistant_id/:action_id/:model', async (req, res) => {
       return true;
     });
 
-    domain = await domainParser(req, domain, true);
+    domain = await domainParser(domain, true);
 
     if (!domain) {
       return res.status(400).json({ message: 'No domain provided' });

api/server/routes/bedrock/chat.js

@@ -14,7 +14,6 @@ const AgentController = require('~/server/controllers/agents/request');
 const addTitle = require('~/server/services/Endpoints/agents/title');
 
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 /**
  * @route POST /

api/server/routes/config.js

@@ -82,6 +82,7 @@ router.get('/', async function (req, res) {
       analyticsGtmId: process.env.ANALYTICS_GTM_ID,
       instanceProjectId: instanceProject._id.toString(),
       bundlerURL: process.env.SANDPACK_BUNDLER_URL,
+      staticBundlerURL: process.env.SANDPACK_STATIC_BUNDLER_URL,
     };
 
     if (ldap) {

api/server/routes/convos.js

@@ -1,16 +1,17 @@
 const multer = require('multer');
 const express = require('express');
 const { CacheKeys, EModelEndpoint } = require('librechat-data-provider');
-const { getConvosByPage, deleteConvos, getConvo, saveConvo } = require('~/models/Conversation');
+const { getConvosByCursor, deleteConvos, getConvo, saveConvo } = require('~/models/Conversation');
 const { forkConversation, duplicateConversation } = require('~/server/utils/import/fork');
 const { storage, importFileFilter } = require('~/server/routes/files/multer');
 const requireJwtAuth = require('~/server/middleware/requireJwtAuth');
 const { importConversations } = require('~/server/utils/import');
 const { createImportLimiters } = require('~/server/middleware');
 const { deleteToolCalls } = require('~/models/ToolCall');
+const { isEnabled, sleep } = require('~/server/utils');
 const getLogStores = require('~/cache/getLogStores');
-const { sleep } = require('~/server/utils');
 const { logger } = require('~/config');
+
 const assistantClients = {
   [EModelEndpoint.azureAssistants]: require('~/server/services/Endpoints/azureAssistants'),
   [EModelEndpoint.assistants]: require('~/server/services/Endpoints/assistants'),
@@ -20,28 +21,30 @@ const router = express.Router();
 router.use(requireJwtAuth);
 
 router.get('/', async (req, res) => {
-  let pageNumber = req.query.pageNumber || 1;
-  pageNumber = parseInt(pageNumber, 10);
+  const limit = parseInt(req.query.limit, 10) || 25;
+  const cursor = req.query.cursor;
+  const isArchived = isEnabled(req.query.isArchived);
+  const search = req.query.search ? decodeURIComponent(req.query.search) : undefined;
+  const order = req.query.order || 'desc';
 
-  if (isNaN(pageNumber) || pageNumber < 1) {
-    return res.status(400).json({ error: 'Invalid page number' });
-  }
-
-  let pageSize = req.query.pageSize || 25;
-  pageSize = parseInt(pageSize, 10);
-
-  if (isNaN(pageSize) || pageSize < 1) {
-    return res.status(400).json({ error: 'Invalid page size' });
-  }
-  const isArchived = req.query.isArchived === 'true';
   let tags;
   if (req.query.tags) {
     tags = Array.isArray(req.query.tags) ? req.query.tags : [req.query.tags];
-  } else {
-    tags = undefined;
   }
 
-  res.status(200).send(await getConvosByPage(req.user.id, pageNumber, pageSize, isArchived, tags));
+  try {
+    const result = await getConvosByCursor(req.user.id, {
+      cursor,
+      limit,
+      isArchived,
+      tags,
+      search,
+      order,
+    });
+    res.status(200).json(result);
+  } catch (error) {
+    res.status(500).json({ error: 'Error fetching conversations' });
+  }
 });
 
 router.get('/:conversationId', async (req, res) => {
@@ -76,22 +79,28 @@ router.post('/gen_title', async (req, res) => {
   }
 });
 
-router.post('/clear', async (req, res) => {
+router.delete('/', async (req, res) => {
   let filter = {};
   const { conversationId, source, thread_id, endpoint } = req.body.arg;
-  if (conversationId) {
-    filter = { conversationId };
+
+  // Prevent deletion of all conversations
+  if (!conversationId && !source && !thread_id && !endpoint) {
+    return res.status(400).json({
+      error: 'no parameters provided',
+    });
   }
 
-  if (source === 'button' && !conversationId) {
+  if (conversationId) {
+    filter = { conversationId };
+  } else if (source === 'button') {
     return res.status(200).send('No conversationId provided');
   }
 
   if (
-    typeof endpoint != 'undefined' &&
+    typeof endpoint !== 'undefined' &&
     Object.prototype.propertyIsEnumerable.call(assistantClients, endpoint)
   ) {
-    /** @type {{ openai: OpenAI}} */
+    /** @type {{ openai: OpenAI }} */
     const { openai } = await assistantClients[endpoint].initializeClient({ req, res });
     try {
       const response = await openai.beta.threads.del(thread_id);
@@ -101,9 +110,6 @@ router.post('/clear', async (req, res) => {
     }
   }
 
-  // for debugging deletion source
-  // logger.debug('source:', source);
-
   try {
     const dbResponse = await deleteConvos(req.user.id, filter);
     await deleteToolCalls(req.user.id, filter.conversationId);
@@ -114,6 +120,17 @@ router.post('/clear', async (req, res) => {
   }
 });
 
+router.delete('/all', async (req, res) => {
+  try {
+    const dbResponse = await deleteConvos(req.user.id, {});
+    await deleteToolCalls(req.user.id);
+    res.status(201).json(dbResponse);
+  } catch (error) {
+    logger.error('Error clearing conversations', error);
+    res.status(500).send('Error clearing conversations');
+  }
+});
+
 router.post('/update', async (req, res) => {
   const update = req.body.arg;
 

api/server/routes/edit/anthropic.js

@@ -3,7 +3,6 @@ const EditController = require('~/server/controllers/EditController');
 const { initializeClient } = require('~/server/services/Endpoints/anthropic');
 const {
   setHeaders,
-  handleAbort,
   validateModel,
   validateEndpoint,
   buildEndpointOption,
@@ -11,8 +10,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/edit/custom.js

@@ -12,8 +12,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/edit/google.js

@@ -3,7 +3,6 @@ const EditController = require('~/server/controllers/EditController');
 const { initializeClient } = require('~/server/services/Endpoints/google');
 const {
   setHeaders,
-  handleAbort,
   validateModel,
   validateEndpoint,
   buildEndpointOption,
@@ -11,8 +10,6 @@ const {
 
 const router = express.Router();
 
-router.post('/abort', handleAbort());
-
 router.post(
   '/',
   validateEndpoint,

api/server/routes/edit/gptPlugins.js

@@ -2,7 +2,6 @@ const express = require('express');
 const { getResponseSender } = require('librechat-data-provider');
 const {
   setHeaders,
-  handleAbort,
   moderateText,
   validateModel,
   handleAbortError,
@@ -19,7 +18,6 @@ const { logger } = require('~/config');
 const router = express.Router();
 
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 router.post(
   '/',
@@ -173,7 +171,8 @@ router.post(
 
       logger.debug('[/edit/gptPlugins] CLIENT RESPONSE', response);
 
-      const { conversation = {} } = await client.responsePromise;
+      const { conversation = {} } = await response.databasePromise;
+      delete response.databasePromise;
       conversation.title =
         conversation && !conversation.title ? null : conversation?.title || 'New Chat';
 

api/server/routes/edit/openAI.js

@@ -2,7 +2,6 @@ const express = require('express');
 const EditController = require('~/server/controllers/EditController');
 const { initializeClient } = require('~/server/services/Endpoints/openAI');
 const {
-  handleAbort,
   setHeaders,
   validateModel,
   validateEndpoint,
@@ -12,7 +11,6 @@ const {
 
 const router = express.Router();
 router.use(moderateText);
-router.post('/abort', handleAbort());
 
 router.post(
   '/',

api/server/routes/index.js

@@ -10,6 +10,7 @@ const balance = require('./balance');
 const plugins = require('./plugins');
 const bedrock = require('./bedrock');
 const actions = require('./actions');
+const banner = require('./banner');
 const search = require('./search');
 const models = require('./models');
 const convos = require('./convos');
@@ -25,7 +26,6 @@ const edit = require('./edit');
 const keys = require('./keys');
 const user = require('./user');
 const ask = require('./ask');
-const banner = require('./banner');
 
 module.exports = {
   ask,
@@ -38,13 +38,14 @@ module.exports = {
   oauth,
   files,
   share,
+  banner,
   agents,
-  bedrock,
   convos,
   search,
-  prompts,
   config,
   models,
+  bedrock,
+  prompts,
   plugins,
   actions,
   presets,
@@ -55,5 +56,4 @@ module.exports = {
   assistants,
   categories,
   staticRoute,
-  banner,
 };

api/server/routes/messages.js

@@ -10,12 +10,90 @@ const {
 } = require('~/models');
 const { findAllArtifacts, replaceArtifactContent } = require('~/server/services/Artifacts/update');
 const { requireJwtAuth, validateMessageReq } = require('~/server/middleware');
+const { cleanUpPrimaryKeyValue } = require('~/lib/utils/misc');
+const { getConvosQueried } = require('~/models/Conversation');
 const { countTokens } = require('~/server/utils');
+const { Message } = require('~/models/Message');
 const { logger } = require('~/config');
 
 const router = express.Router();
 router.use(requireJwtAuth);
 
+router.get('/', async (req, res) => {
+  try {
+    const user = req.user.id ?? '';
+    const {
+      cursor = null,
+      sortBy = 'createdAt',
+      sortDirection = 'desc',
+      pageSize: pageSizeRaw,
+      conversationId,
+      messageId,
+      search,
+    } = req.query;
+    const pageSize = parseInt(pageSizeRaw, 10) || 25;
+
+    let response;
+    const sortField = ['endpoint', 'createdAt', 'updatedAt'].includes(sortBy)
+      ? sortBy
+      : 'createdAt';
+    const sortOrder = sortDirection === 'asc' ? 1 : -1;
+
+    if (conversationId && messageId) {
+      const message = await Message.findOne({ conversationId, messageId, user: user }).lean();
+      response = { messages: message ? [message] : [], nextCursor: null };
+    } else if (conversationId) {
+      const filter = { conversationId, user: user };
+      if (cursor) {
+        filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
+      }
+      const messages = await Message.find(filter)
+        .sort({ [sortField]: sortOrder })
+        .limit(pageSize + 1)
+        .lean();
+      const nextCursor = messages.length > pageSize ? messages.pop()[sortField] : null;
+      response = { messages, nextCursor };
+    } else if (search) {
+      const searchResults = await Message.meiliSearch(search, undefined, true);
+
+      const messages = searchResults.hits || [];
+
+      const result = await getConvosQueried(req.user.id, messages, cursor);
+
+      const activeMessages = [];
+      for (let i = 0; i < messages.length; i++) {
+        let message = messages[i];
+        if (message.conversationId.includes('--')) {
+          message.conversationId = cleanUpPrimaryKeyValue(message.conversationId);
+        }
+        if (result.convoMap[message.conversationId]) {
+          const convo = result.convoMap[message.conversationId];
+
+          const dbMessage = await getMessage({ user, messageId: message.messageId });
+          activeMessages.push({
+            ...message,
+            title: convo.title,
+            conversationId: message.conversationId,
+            model: convo.model,
+            isCreatedByUser: dbMessage?.isCreatedByUser,
+            endpoint: dbMessage?.endpoint,
+            iconURL: dbMessage?.iconURL,
+          });
+        }
+      }
+
+      response = { messages: activeMessages, nextCursor: null };
+    } else {
+      response = { messages: [], nextCursor: null };
+    }
+
+    res.status(200).json(response);
+  } catch (error) {
+    logger.error('Error fetching messages:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
 router.post('/artifact/:messageId', async (req, res) => {
   try {
     const { messageId } = req.params;

api/server/routes/roles.js

@@ -48,7 +48,7 @@ router.put('/:roleName/prompts', checkAdmin, async (req, res) => {
   const { roleName: _r } = req.params;
   // TODO: TEMP, use a better parsing for roleName
   const roleName = _r.toUpperCase();
-  /** @type {TRole['PROMPTS']} */
+  /** @type {TRole['permissions']['PROMPTS']} */
   const updates = req.body;
 
   try {
@@ -59,10 +59,16 @@ router.put('/:roleName/prompts', checkAdmin, async (req, res) => {
       return res.status(404).send({ message: 'Role not found' });
     }
 
+    const currentPermissions =
+      role.permissions?.[PermissionTypes.PROMPTS] || role[PermissionTypes.PROMPTS] || {};
+
     const mergedUpdates = {
-      [PermissionTypes.PROMPTS]: {
-        ...role[PermissionTypes.PROMPTS],
-        ...parsedUpdates,
+      permissions: {
+        ...role.permissions,
+        [PermissionTypes.PROMPTS]: {
+          ...currentPermissions,
+          ...parsedUpdates,
+        },
       },
     };
 
@@ -81,7 +87,7 @@ router.put('/:roleName/agents', checkAdmin, async (req, res) => {
   const { roleName: _r } = req.params;
   // TODO: TEMP, use a better parsing for roleName
   const roleName = _r.toUpperCase();
-  /** @type {TRole['AGENTS']} */
+  /** @type {TRole['permissions']['AGENTS']} */
   const updates = req.body;
 
   try {
@@ -92,17 +98,23 @@ router.put('/:roleName/agents', checkAdmin, async (req, res) => {
       return res.status(404).send({ message: 'Role not found' });
     }
 
+    const currentPermissions =
+      role.permissions?.[PermissionTypes.AGENTS] || role[PermissionTypes.AGENTS] || {};
+
     const mergedUpdates = {
-      [PermissionTypes.AGENTS]: {
-        ...role[PermissionTypes.AGENTS],
-        ...parsedUpdates,
+      permissions: {
+        ...role.permissions,
+        [PermissionTypes.AGENTS]: {
+          ...currentPermissions,
+          ...parsedUpdates,
+        },
       },
     };
 
     const updatedRole = await updateRoleByName(roleName, mergedUpdates);
     res.status(200).send(updatedRole);
   } catch (error) {
-    return res.status(400).send({ message: 'Invalid prompt permissions.', error: error.errors });
+    return res.status(400).send({ message: 'Invalid agent permissions.', error: error.errors });
   }
 });
 

api/server/routes/search.js

@@ -1,14 +1,11 @@
-const Keyv = require('keyv');
+const { Keyv } = require('keyv');
 const express = require('express');
 const { MeiliSearch } = require('meilisearch');
-const { Conversation, getConvosQueried } = require('~/models/Conversation');
+const { Conversation } = require('~/models/Conversation');
 const requireJwtAuth = require('~/server/middleware/requireJwtAuth');
-const { cleanUpPrimaryKeyValue } = require('~/lib/utils/misc');
-const { reduceHits } = require('~/lib/utils/reduceHits');
-const { isEnabled } = require('~/server/utils');
 const { Message } = require('~/models/Message');
+const { isEnabled } = require('~/server/utils');
 const keyvRedis = require('~/cache/keyvRedis');
-const { logger } = require('~/config');
 
 const router = express.Router();
 
@@ -25,56 +22,6 @@ router.get('/sync', async function (req, res) {
   res.send('synced');
 });
 
-router.get('/', async function (req, res) {
-  try {
-    let user = req.user.id ?? '';
-    const { q } = req.query;
-    const pageNumber = req.query.pageNumber || 1;
-    const key = `${user}:search:${q}`;
-    const cached = await cache.get(key);
-    if (cached) {
-      logger.debug('[/search] cache hit: ' + key);
-      const { pages, pageSize, messages } = cached;
-      res
-        .status(200)
-        .send({ conversations: cached[pageNumber], pages, pageNumber, pageSize, messages });
-      return;
-    }
-
-    const messages = (await Message.meiliSearch(q, undefined, true)).hits;
-    const titles = (await Conversation.meiliSearch(q)).hits;
-
-    const sortedHits = reduceHits(messages, titles);
-    const result = await getConvosQueried(user, sortedHits, pageNumber);
-
-    const activeMessages = [];
-    for (let i = 0; i < messages.length; i++) {
-      let message = messages[i];
-      if (message.conversationId.includes('--')) {
-        message.conversationId = cleanUpPrimaryKeyValue(message.conversationId);
-      }
-      if (result.convoMap[message.conversationId]) {
-        const convo = result.convoMap[message.conversationId];
-        const { title, chatGptLabel, model } = convo;
-        message = { ...message, ...{ title, chatGptLabel, model } };
-        activeMessages.push(message);
-      }
-    }
-    result.messages = activeMessages;
-    if (result.cache) {
-      result.cache.messages = activeMessages;
-      cache.set(key, result.cache, expiration);
-      delete result.cache;
-    }
-    delete result.convoMap;
-
-    res.status(200).send(result);
-  } catch (error) {
-    logger.error('[/search] Error while searching messages & conversations', error);
-    res.status(500).send({ message: 'Error searching' });
-  }
-});
-
 router.get('/test', async function (req, res) {
   const { q } = req.query;
   const messages = (

api/server/services/ActionService.js

@@ -50,7 +50,7 @@ const validateAndUpdateTool = async ({ req, tool, assistant_id }) => {
       return null;
     }
 
-    const parsedDomain = await domainParser(req, domain, true);
+    const parsedDomain = await domainParser(domain, true);
 
     if (!parsedDomain) {
       return null;
@@ -66,16 +66,14 @@ const validateAndUpdateTool = async ({ req, tool, assistant_id }) => {
  *
  * Necessary due to `[a-zA-Z0-9_-]*` Regex Validation, limited to a 64-character maximum.
  *
- * @param {Express.Request} req - The Express Request object.
  * @param {string} domain - The domain name to encode/decode.
  * @param {boolean} inverse - False to decode from base64, true to encode to base64.
  * @returns {Promise<string>} Encoded or decoded domain string.
  */
-async function domainParser(req, domain, inverse = false) {
+async function domainParser(domain, inverse = false) {
   if (!domain) {
     return;
   }
-
   const domainsCache = getLogStores(CacheKeys.ENCODED_DOMAINS);
   const cachedDomain = await domainsCache.get(domain);
   if (inverse && cachedDomain) {
@@ -122,7 +120,7 @@ async function loadActionSets(searchParams) {
  * Creates a general tool for an entire action set.
  *
  * @param {Object} params - The parameters for loading action sets.
- * @param {ServerRequest} params.req
+ * @param {string} params.userId
  * @param {ServerResponse} params.res
  * @param {Action} params.action - The action set. Necessary for decrypting authentication values.
  * @param {ActionRequest} params.requestBuilder - The ActionRequest builder class to execute the API call.
@@ -133,7 +131,7 @@ async function loadActionSets(searchParams) {
  * @returns { Promise<typeof tool | { _call: (toolInput: Object | string) => unknown}> } An object with `_call` method to execute the tool input.
  */
 async function createActionTool({
-  req,
+  userId,
   res,
   action,
   requestBuilder,
@@ -154,7 +152,7 @@ async function createActionTool({
         try {
           if (metadata.auth.type === AuthTypeEnum.OAuth && metadata.auth.authorization_url) {
             const action_id = action.action_id;
-            const identifier = `${req.user.id}:${action.action_id}`;
+            const identifier = `${userId}:${action.action_id}`;
             const requestLogin = async () => {
               const { args: _args, stepId, ...toolCall } = config.toolCall ?? {};
               if (!stepId) {
@@ -162,7 +160,7 @@ async function createActionTool({
               }
               const statePayload = {
                 nonce: nanoid(),
-                user: req.user.id,
+                user: userId,
                 action_id,
               };
 
@@ -189,26 +187,33 @@ async function createActionTool({
                     expires_at: Date.now() + Time.TWO_MINUTES,
                   },
                 };
-                const flowManager = await getFlowStateManager(getLogStores);
+                const flowsCache = getLogStores(CacheKeys.FLOWS);
+                const flowManager = getFlowStateManager(flowsCache);
                 await flowManager.createFlowWithHandler(
-                  `${identifier}:login`,
+                  `${identifier}:oauth_login:${config.metadata.thread_id}:${config.metadata.run_id}`,
                   'oauth_login',
                   async () => {
                     sendEvent(res, { event: GraphEvents.ON_RUN_STEP_DELTA, data });
                     logger.debug('Sent OAuth login request to client', { action_id, identifier });
                     return true;
                   },
+                  config?.signal,
                 );
                 logger.debug('Waiting for OAuth Authorization response', { action_id, identifier });
-                const result = await flowManager.createFlow(identifier, 'oauth', {
-                  state: stateToken,
-                  userId: req.user.id,
-                  client_url: metadata.auth.client_url,
-                  redirect_uri: `${process.env.DOMAIN_CLIENT}/api/actions/${action_id}/oauth/callback`,
-                  /** Encrypted values */
-                  encrypted_oauth_client_id: encrypted.oauth_client_id,
-                  encrypted_oauth_client_secret: encrypted.oauth_client_secret,
-                });
+                const result = await flowManager.createFlow(
+                  identifier,
+                  'oauth',
+                  {
+                    state: stateToken,
+                    userId: userId,
+                    client_url: metadata.auth.client_url,
+                    redirect_uri: `${process.env.DOMAIN_CLIENT}/api/actions/${action_id}/oauth/callback`,
+                    /** Encrypted values */
+                    encrypted_oauth_client_id: encrypted.oauth_client_id,
+                    encrypted_oauth_client_secret: encrypted.oauth_client_secret,
+                  },
+                  config?.signal,
+                );
                 logger.debug('Received OAuth Authorization response', { action_id, identifier });
                 data.delta.auth = undefined;
                 data.delta.expires_at = undefined;
@@ -226,10 +231,10 @@ async function createActionTool({
             };
 
             const tokenPromises = [];
-            tokenPromises.push(findToken({ userId: req.user.id, type: 'oauth', identifier }));
+            tokenPromises.push(findToken({ userId, type: 'oauth', identifier }));
             tokenPromises.push(
               findToken({
-                userId: req.user.id,
+                userId,
                 type: 'oauth_refresh',
                 identifier: `${identifier}:refresh`,
               }),
@@ -252,18 +257,20 @@ async function createActionTool({
                 const refresh_token = await decryptV2(refreshTokenData.token);
                 const refreshTokens = async () =>
                   await refreshAccessToken({
+                    userId,
                     identifier,
                     refresh_token,
-                    userId: req.user.id,
                     client_url: metadata.auth.client_url,
                     encrypted_oauth_client_id: encrypted.oauth_client_id,
                     encrypted_oauth_client_secret: encrypted.oauth_client_secret,
                   });
-                const flowManager = await getFlowStateManager(getLogStores);
+                const flowsCache = getLogStores(CacheKeys.FLOWS);
+                const flowManager = getFlowStateManager(flowsCache);
                 const refreshData = await flowManager.createFlowWithHandler(
                   `${identifier}:refresh`,
                   'oauth_refresh',
                   refreshTokens,
+                  config?.signal,
                 );
                 metadata.oauth_access_token = refreshData.access_token;
                 if (refreshData.refresh_token) {

api/server/services/ActionService.spec.js

@@ -78,20 +78,20 @@ describe('domainParser', () => {
   // Non-azure request
   it('does not return domain as is if not azure', async () => {
     const domain = `example.com${actionDomainSeparator}test${actionDomainSeparator}`;
-    const result1 = await domainParser(reqNoAzure, domain, false);
-    const result2 = await domainParser(reqNoAzure, domain, true);
+    const result1 = await domainParser(domain, false);
+    const result2 = await domainParser(domain, true);
     expect(result1).not.toEqual(domain);
     expect(result2).not.toEqual(domain);
   });
 
   // Test for Empty or Null Inputs
   it('returns undefined for null domain input', async () => {
-    const result = await domainParser(req, null, true);
+    const result = await domainParser(null, true);
     expect(result).toBeUndefined();
   });
 
   it('returns undefined for empty domain input', async () => {
-    const result = await domainParser(req, '', true);
+    const result = await domainParser('', true);
     expect(result).toBeUndefined();
   });
 
@@ -102,7 +102,7 @@ describe('domainParser', () => {
       .toString('base64')
       .substring(0, Constants.ENCODED_DOMAIN_LENGTH);
 
-    await domainParser(req, domain, true);
+    await domainParser(domain, true);
 
     const cachedValue = await globalCache[encodedDomain];
     expect(cachedValue).toEqual(Buffer.from(domain).toString('base64'));
@@ -112,14 +112,14 @@ describe('domainParser', () => {
   it('encodes domain exactly at threshold without modification', async () => {
     const domain = 'a'.repeat(Constants.ENCODED_DOMAIN_LENGTH - TLD.length) + TLD;
     const expected = domain.replace(/\./g, actionDomainSeparator);
-    const result = await domainParser(req, domain, true);
+    const result = await domainParser(domain, true);
     expect(result).toEqual(expected);
   });
 
   it('encodes domain just below threshold without modification', async () => {
     const domain = 'a'.repeat(Constants.ENCODED_DOMAIN_LENGTH - 1 - TLD.length) + TLD;
     const expected = domain.replace(/\./g, actionDomainSeparator);
-    const result = await domainParser(req, domain, true);
+    const result = await domainParser(domain, true);
     expect(result).toEqual(expected);
   });
 
@@ -129,7 +129,7 @@ describe('domainParser', () => {
     const encodedDomain = Buffer.from(unicodeDomain)
       .toString('base64')
       .substring(0, Constants.ENCODED_DOMAIN_LENGTH);
-    const result = await domainParser(req, unicodeDomain, true);
+    const result = await domainParser(unicodeDomain, true);
     expect(result).toEqual(encodedDomain);
   });
 
@@ -139,7 +139,6 @@ describe('domainParser', () => {
     globalCache[encodedDomain.substring(0, Constants.ENCODED_DOMAIN_LENGTH)] = encodedDomain; // Simulate caching
 
     const result = await domainParser(
-      req,
       encodedDomain.substring(0, Constants.ENCODED_DOMAIN_LENGTH),
       false,
     );
@@ -150,27 +149,27 @@ describe('domainParser', () => {
   it('returns domain with replaced separators if no cached domain exists', async () => {
     const domain = 'example.com';
     const withSeparator = domain.replace(/\./g, actionDomainSeparator);
-    const result = await domainParser(req, withSeparator, false);
+    const result = await domainParser(withSeparator, false);
     expect(result).toEqual(domain);
   });
 
   it('returns domain with replaced separators when inverse is false and under encoding length', async () => {
     const domain = 'examp.com';
     const withSeparator = domain.replace(/\./g, actionDomainSeparator);
-    const result = await domainParser(req, withSeparator, false);
+    const result = await domainParser(withSeparator, false);
     expect(result).toEqual(domain);
   });
 
   it('replaces periods with actionDomainSeparator when inverse is true and under encoding length', async () => {
     const domain = 'examp.com';
     const expected = domain.replace(/\./g, actionDomainSeparator);
-    const result = await domainParser(req, domain, true);
+    const result = await domainParser(domain, true);
     expect(result).toEqual(expected);
   });
 
   it('encodes domain when length is above threshold and inverse is true', async () => {
     const domain = 'a'.repeat(Constants.ENCODED_DOMAIN_LENGTH + 1).concat('.com');
-    const result = await domainParser(req, domain, true);
+    const result = await domainParser(domain, true);
     expect(result).not.toEqual(domain);
     expect(result.length).toBeLessThanOrEqual(Constants.ENCODED_DOMAIN_LENGTH);
   });
@@ -180,20 +179,20 @@ describe('domainParser', () => {
     const encodedDomain = Buffer.from(
       originalDomain.replace(/\./g, actionDomainSeparator),
     ).toString('base64');
-    const result = await domainParser(req, encodedDomain, false);
+    const result = await domainParser(encodedDomain, false);
     expect(result).toEqual(encodedDomain);
   });
 
   it('decodes encoded value if cached and encoded value is provided, and inverse is false', async () => {
     const originalDomain = 'example.com';
-    const encodedDomain = await domainParser(req, originalDomain, true);
-    const result = await domainParser(req, encodedDomain, false);
+    const encodedDomain = await domainParser(originalDomain, true);
+    const result = await domainParser(encodedDomain, false);
     expect(result).toEqual(originalDomain);
   });
 
   it('handles invalid base64 encoded values gracefully', async () => {
     const invalidBase64Domain = 'not_base64_encoded';
-    const result = await domainParser(req, invalidBase64Domain, false);
+    const result = await domainParser(invalidBase64Domain, false);
     expect(result).toEqual(invalidBase64Domain);
   });
 });

api/server/services/AppService.js

@@ -66,7 +66,7 @@ const AppService = async (app) => {
   });
 
   if (config.mcpServers != null) {
-    const mcpManager = await getMCPManager();
+    const mcpManager = getMCPManager();
     await mcpManager.initializeMCP(config.mcpServers, processMCPEnv);
     await mcpManager.mapAvailableTools(availableTools);
   }

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

@@ -1,12 +1,15 @@
+const { isAgentsEndpoint, Constants } = require('librechat-data-provider');
 const { loadAgent } = require('~/models/Agent');
 const { logger } = require('~/config');
 
-const buildOptions = (req, endpoint, parsedBody) => {
+const buildOptions = (req, endpoint, parsedBody, endpointType) => {
   const { spec, iconURL, agent_id, instructions, maxContextTokens, ...model_parameters } =
     parsedBody;
   const agentPromise = loadAgent({
     req,
-    agent_id,
+    agent_id: isAgentsEndpoint(endpoint) ? agent_id : Constants.EPHEMERAL_AGENT_ID,
+    endpoint,
+    model_parameters,
   }).catch((error) => {
     logger.error(`[/agents/:${agent_id}] Error retrieving agent during build options step`, error);
     return undefined;
@@ -17,6 +20,7 @@ const buildOptions = (req, endpoint, parsedBody) => {
     iconURL,
     endpoint,
     agent_id,
+    endpointType,
     instructions,
     maxContextTokens,
     model_parameters,

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

@@ -1,7 +1,9 @@
 const { createContentAggregator, Providers } = require('@librechat/agents');
 const {
+  Constants,
   ErrorTypes,
   EModelEndpoint,
+  EToolResources,
   getResponseSender,
   AgentCapabilities,
   providerEndpointMap,
@@ -40,12 +42,19 @@ const providerConfigMap = {
 };
 
 /**
- * @param {ServerRequest} req
- * @param {Promise<Array<MongoFile | null>> | undefined} _attachments
- * @param {AgentToolResources | undefined} _tool_resources
+ * @param {Object} params
+ * @param {ServerRequest} params.req
+ * @param {Promise<Array<MongoFile | null>> | undefined} [params.attachments]
+ * @param {Set<string>} params.requestFileSet
+ * @param {AgentToolResources | undefined} [params.tool_resources]
  * @returns {Promise<{ attachments: Array<MongoFile | undefined> | undefined, tool_resources: AgentToolResources | undefined }>}
  */
-const primeResources = async (req, _attachments, _tool_resources) => {
+const primeResources = async ({
+  req,
+  attachments: _attachments,
+  tool_resources: _tool_resources,
+  requestFileSet,
+}) => {
   try {
     /** @type {Array<MongoFile | undefined> | undefined} */
     let attachments;
@@ -53,7 +62,7 @@ const primeResources = async (req, _attachments, _tool_resources) => {
     const isOCREnabled = (req.app.locals?.[EModelEndpoint.agents]?.capabilities ?? []).includes(
       AgentCapabilities.ocr,
     );
-    if (tool_resources.ocr?.file_ids && isOCREnabled) {
+    if (tool_resources[EToolResources.ocr]?.file_ids && isOCREnabled) {
       const context = await getFiles(
         {
           file_id: { $in: tool_resources.ocr.file_ids },
@@ -78,17 +87,28 @@ const primeResources = async (req, _attachments, _tool_resources) => {
         continue;
       }
       if (file.metadata?.fileIdentifier) {
-        const execute_code = tool_resources.execute_code ?? {};
+        const execute_code = tool_resources[EToolResources.execute_code] ?? {};
         if (!execute_code.files) {
-          tool_resources.execute_code = { ...execute_code, files: [] };
+          tool_resources[EToolResources.execute_code] = { ...execute_code, files: [] };
         }
-        tool_resources.execute_code.files.push(file);
+        tool_resources[EToolResources.execute_code].files.push(file);
       } else if (file.embedded === true) {
-        const file_search = tool_resources.file_search ?? {};
+        const file_search = tool_resources[EToolResources.file_search] ?? {};
         if (!file_search.files) {
-          tool_resources.file_search = { ...file_search, files: [] };
+          tool_resources[EToolResources.file_search] = { ...file_search, files: [] };
         }
-        tool_resources.file_search.files.push(file);
+        tool_resources[EToolResources.file_search].files.push(file);
+      } else if (
+        requestFileSet.has(file.file_id) &&
+        file.type.startsWith('image') &&
+        file.height &&
+        file.width
+      ) {
+        const image_edit = tool_resources[EToolResources.image_edit] ?? {};
+        if (!image_edit.files) {
+          tool_resources[EToolResources.image_edit] = { ...image_edit, files: [] };
+        }
+        tool_resources[EToolResources.image_edit].files.push(file);
       }
 
       attachments.push(file);
@@ -145,7 +165,14 @@ const initializeAgentOptions = async ({
     (agent.model_parameters?.resendFiles ?? true) === true
   ) {
     const fileIds = (await getConvoFiles(req.body.conversationId)) ?? [];
-    const toolFiles = await getToolFilesByIds(fileIds);
+    /** @type {Set<EToolResources>} */
+    const toolResourceSet = new Set();
+    for (const tool of agent.tools) {
+      if (EToolResources[tool]) {
+        toolResourceSet.add(EToolResources[tool]);
+      }
+    }
+    const toolFiles = await getToolFilesByIds(fileIds, toolResourceSet);
     if (requestFiles.length || toolFiles.length) {
       currentFiles = await processFiles(requestFiles.concat(toolFiles));
     }
@@ -153,19 +180,26 @@ const initializeAgentOptions = async ({
     currentFiles = await processFiles(requestFiles);
   }
 
-  const { attachments, tool_resources } = await primeResources(
+  const { attachments, tool_resources } = await primeResources({
     req,
-    currentFiles,
-    agent.tool_resources,
-  );
-  const { tools, toolContextMap } = await loadAgentTools({
-    req,
-    res,
-    agent,
-    tool_resources,
+    attachments: currentFiles,
+    tool_resources: agent.tool_resources,
+    requestFileSet: new Set(requestFiles.map((file) => file.file_id)),
   });
 
   const provider = agent.provider;
+  const { tools, toolContextMap } = await loadAgentTools({
+    req,
+    res,
+    agent: {
+      id: agent.id,
+      tools: agent.tools,
+      provider,
+      model: agent.model,
+    },
+    tool_resources,
+  });
+
   agent.endpoint = provider;
   let getOptions = providerConfigMap[provider];
   if (!getOptions && providerConfigMap[provider.toLowerCase()] != null) {
@@ -322,10 +356,14 @@ const initializeClient = async ({ req, res, endpointOption }) => {
     agent: primaryConfig,
     spec: endpointOption.spec,
     iconURL: endpointOption.iconURL,
-    endpoint: EModelEndpoint.agents,
     attachments: primaryConfig.attachments,
+    endpointType: endpointOption.endpointType,
     maxContextTokens: primaryConfig.maxContextTokens,
     resendFiles: primaryConfig.model_parameters?.resendFiles ?? true,
+    endpoint:
+      primaryConfig.id === Constants.EPHEMERAL_AGENT_ID
+        ? primaryConfig.endpoint
+        : EModelEndpoint.agents,
   });
 
   return { client };

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

@@ -2,7 +2,11 @@ const { CacheKeys } = require('librechat-data-provider');
 const getLogStores = require('~/cache/getLogStores');
 const { isEnabled } = require('~/server/utils');
 const { saveConvo } = require('~/models');
+const { logger } = require('~/config');
 
+/**
+ * Add title to conversation in a way that avoids memory retention
+ */
 const addTitle = async (req, { text, response, client }) => {
   const { TITLE_CONVO = true } = process.env ?? {};
   if (!isEnabled(TITLE_CONVO)) {
@@ -13,37 +17,55 @@ const addTitle = async (req, { text, response, client }) => {
     return;
   }
 
-  // If the request was aborted, don't generate the title.
-  if (client.abortController.signal.aborted) {
-    return;
-  }
-
   const titleCache = getLogStores(CacheKeys.GEN_TITLE);
   const key = `${req.user.id}-${response.conversationId}`;
-  const responseText =
-    response?.content && Array.isArray(response?.content)
-      ? response.content.reduce((acc, block) => {
-        if (block?.type === 'text') {
-          return acc + block.text;
-        }
-        return acc;
-      }, '')
-      : (response?.content ?? response?.text ?? '');
+  /** @type {NodeJS.Timeout} */
+  let timeoutId;
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => reject(new Error('Title generation timeout')), 25000);
+    }).catch((error) => {
+      logger.error('Title error:', error);
+    });
 
-  const title = await client.titleConvo({
-    text,
-    responseText,
-    conversationId: response.conversationId,
-  });
-  await titleCache.set(key, title, 120000);
-  await saveConvo(
-    req,
-    {
-      conversationId: response.conversationId,
-      title,
-    },
-    { context: 'api/server/services/Endpoints/agents/title.js' },
-  );
+    let titlePromise;
+    let abortController = new AbortController();
+    if (client && typeof client.titleConvo === 'function') {
+      titlePromise = Promise.race([
+        client
+          .titleConvo({
+            text,
+            abortController,
+          })
+          .catch((error) => {
+            logger.error('Client title error:', error);
+          }),
+        timeoutPromise,
+      ]);
+    } else {
+      return;
+    }
+
+    const title = await titlePromise;
+    if (!abortController.signal.aborted) {
+      abortController.abort();
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    await titleCache.set(key, title, 120000);
+    await saveConvo(
+      req,
+      {
+        conversationId: response.conversationId,
+        title,
+      },
+      { context: 'api/server/services/Endpoints/agents/title.js' },
+    );
+  } catch (error) {
+    logger.error('Error generating title:', error);
+  }
 };
 
 module.exports = addTitle;

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

@@ -1,7 +1,7 @@
 const { EModelEndpoint } = require('librechat-data-provider');
 const { getUserKey, checkUserKeyExpiry } = require('~/server/services/UserService');
 const { getLLMConfig } = require('~/server/services/Endpoints/anthropic/llm');
-const { AnthropicClient } = require('~/app');
+const AnthropicClient = require('~/app/clients/AnthropicClient');
 
 const initializeClient = async ({ req, res, endpointOption, overrideModel, optionsOnly }) => {
   const { ANTHROPIC_API_KEY, ANTHROPIC_REVERSE_PROXY, PROXY } = process.env;

api/server/services/Endpoints/anthropic/title.js

@@ -13,11 +13,6 @@ const addTitle = async (req, { text, response, client }) => {
     return;
   }
 
-  // If the request was aborted, don't generate the title.
-  if (client.abortController.signal.aborted) {
-    return;
-  }
-
   const titleCache = getLogStores(CacheKeys.GEN_TITLE);
   const key = `${req.user.id}-${response.conversationId}`;
 

api/server/services/Endpoints/bedrock/options.js

@@ -8,7 +8,7 @@ const {
   removeNullishValues,
 } = require('librechat-data-provider');
 const { getUserKey, checkUserKeyExpiry } = require('~/server/services/UserService');
-const { sleep } = require('~/server/utils');
+const { createHandleLLMNewToken } = require('~/app/clients/generators');
 
 const getOptions = async ({ req, overrideModel, endpointOption }) => {
   const {
@@ -90,12 +90,7 @@ const getOptions = async ({ req, overrideModel, endpointOption }) => {
 
   llmConfig.callbacks = [
     {
-      handleLLMNewToken: async () => {
-        if (!streamRate) {
-          return;
-        }
-        await sleep(streamRate);
-      },
+      handleLLMNewToken: createHandleLLMNewToken(streamRate),
     },
   ];
 

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

@@ -9,10 +9,11 @@ const { Providers } = require('@librechat/agents');
 const { getUserKeyValues, checkUserKeyExpiry } = require('~/server/services/UserService');
 const { getLLMConfig } = require('~/server/services/Endpoints/openAI/llm');
 const { getCustomEndpointConfig } = require('~/server/services/Config');
+const { createHandleLLMNewToken } = require('~/app/clients/generators');
 const { fetchModels } = require('~/server/services/ModelService');
-const { isUserProvided, sleep } = require('~/server/utils');
+const OpenAIClient = require('~/app/clients/OpenAIClient');
+const { isUserProvided } = require('~/server/utils');
 const getLogStores = require('~/cache/getLogStores');
-const { OpenAIClient } = require('~/app');
 
 const { PROXY } = process.env;
 
@@ -148,9 +149,7 @@ const initializeClient = async ({ req, res, endpointOption, optionsOnly, overrid
       }
       options.llmConfig.callbacks = [
         {
-          handleLLMNewToken: async () => {
-            await sleep(customOptions.streamRate);
-          },
+          handleLLMNewToken: createHandleLLMNewToken(clientOptions.streamRate),
         },
       ];
       return options;

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

@@ -6,9 +6,10 @@ const {
 } = require('librechat-data-provider');
 const { getUserKeyValues, checkUserKeyExpiry } = require('~/server/services/UserService');
 const { getLLMConfig } = require('~/server/services/Endpoints/openAI/llm');
-const { isEnabled, isUserProvided, sleep } = require('~/server/utils');
+const { createHandleLLMNewToken } = require('~/app/clients/generators');
+const { isEnabled, isUserProvided } = require('~/server/utils');
+const OpenAIClient = require('~/app/clients/OpenAIClient');
 const { getAzureCredentials } = require('~/utils');
-const { OpenAIClient } = require('~/app');
 
 const initializeClient = async ({
   req,
@@ -140,14 +141,13 @@ const initializeClient = async ({
     clientOptions = Object.assign({ modelOptions }, clientOptions);
     clientOptions.modelOptions.user = req.user.id;
     const options = getLLMConfig(apiKey, clientOptions);
-    if (!clientOptions.streamRate) {
+    const streamRate = clientOptions.streamRate;
+    if (!streamRate) {
       return options;
     }
     options.llmConfig.callbacks = [
       {
-        handleLLMNewToken: async () => {
-          await sleep(clientOptions.streamRate);
-        },
+        handleLLMNewToken: createHandleLLMNewToken(streamRate),
       },
     ];
     return options;

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

@@ -153,6 +153,12 @@ function getLLMConfig(apiKey, options = {}, endpoint = null) {
     delete llmConfig.reasoning_effort;
   }
 
+  if (llmConfig?.['max_tokens'] != null) {
+    /** @type {number} */
+    llmConfig.maxTokens = llmConfig['max_tokens'];
+    delete llmConfig['max_tokens'];
+  }
+
   return {
     /** @type {OpenAIClientOptions} */
     llmConfig,