Merge branch 'main' into a11y/focus-plugin-auth

* 🔧 feat: Add configurable S3 URL refresh expiry time

* fix: Set default width and height for URLIcon component in case container style results in NaN

* refactor: Enhance auto-save functionality with debounced restore methods

* feat: Add support for additionalProperties in JSON schema conversion to Zod

* test: Add tests for additionalProperties handling in JSON schema to Zod conversion

* chore: Reorder import statements for better readability in ask route

* fix: Handle additional successful response status code (200) in SSE error handler

* fix: add missing rate limiting middleware for bedrock and agent chat routes

* fix: update moderation middleware to check feature flag before processing requests

* fix: add moderation middleware to chat routes for text moderation

* Revert "refactor: Enhance auto-save functionality with debounced restore methods"

This reverts commit d2e4134d1f.

* refactor: Move base64 encoding/decoding functions to top-level scope and optimize input handling

.env.example

@@ -20,6 +20,11 @@ DOMAIN_CLIENT=http://localhost:3080
 DOMAIN_SERVER=http://localhost:3080
 
 NO_INDEX=true
+# Use the address that is at most n number of hops away from the Express application. 
+# req.socket.remoteAddress is the first hop, and the rest are looked for in the X-Forwarded-For header from right to left. 
+# A value of 0 means that the first untrusted address would be req.socket.remoteAddress, i.e. there is no reverse proxy.
+# Defaulted to 1.
+TRUST_PROXY=1
 
 #===============#
 # JSON Logging  #
@@ -53,7 +58,7 @@ DEBUG_CONSOLE=false
 #                     Endpoints                     #
 #===================================================#
 
-# ENDPOINTS=openAI,assistants,azureOpenAI,bingAI,google,gptPlugins,anthropic
+# ENDPOINTS=openAI,assistants,azureOpenAI,google,gptPlugins,anthropic
 
 PROXY=
 
@@ -83,7 +88,7 @@ PROXY=
 #============#
 
 ANTHROPIC_API_KEY=user_provided
-# ANTHROPIC_MODELS=claude-3-5-haiku-20241022,claude-3-5-sonnet-20241022,claude-3-5-sonnet-latest,claude-3-5-sonnet-20240620,claude-3-opus-20240229,claude-3-sonnet-20240229,claude-3-haiku-20240307,claude-2.1,claude-2,claude-1.2,claude-1,claude-1-100k,claude-instant-1,claude-instant-1-100k
+# ANTHROPIC_MODELS=claude-3-7-sonnet-latest,claude-3-7-sonnet-20250219,claude-3-5-haiku-20241022,claude-3-5-sonnet-20241022,claude-3-5-sonnet-latest,claude-3-5-sonnet-20240620,claude-3-opus-20240229,claude-3-sonnet-20240229,claude-3-haiku-20240307,claude-2.1,claude-2,claude-1.2,claude-1,claude-1-100k,claude-instant-1,claude-instant-1-100k
 # ANTHROPIC_REVERSE_PROXY=
 
 #============#
@@ -105,13 +110,6 @@ ANTHROPIC_API_KEY=user_provided
 # AZURE_OPENAI_API_EMBEDDINGS_DEPLOYMENT_NAME= # Deprecated
 # PLUGINS_USE_AZURE="true" # Deprecated
 
-#============#
-# BingAI     #
-#============#
-
-BINGAI_TOKEN=user_provided
-# BINGAI_HOST=https://cn.bing.com
-
 #=================#
 #   AWS Bedrock   #
 #=================#
@@ -144,7 +142,7 @@ GOOGLE_KEY=user_provided
 # GOOGLE_AUTH_HEADER=true
 
 # Gemini API (AI Studio)
-# GOOGLE_MODELS=gemini-2.0-flash-exp,gemini-2.0-flash-thinking-exp-1219,gemini-exp-1121,gemini-exp-1114,gemini-1.5-flash-latest,gemini-1.0-pro,gemini-1.0-pro-001,gemini-1.0-pro-latest,gemini-1.0-pro-vision-latest,gemini-1.5-pro-latest,gemini-pro,gemini-pro-vision
+# GOOGLE_MODELS=gemini-2.5-pro-exp-03-25,gemini-2.0-flash-exp,gemini-2.0-flash-thinking-exp-1219,gemini-exp-1121,gemini-exp-1114,gemini-1.5-flash-latest,gemini-1.0-pro,gemini-1.0-pro-001,gemini-1.0-pro-latest,gemini-1.0-pro-vision-latest,gemini-1.5-pro-latest,gemini-pro,gemini-pro-vision
 
 # Vertex AI
 # GOOGLE_MODELS=gemini-1.5-flash-preview-0514,gemini-1.5-pro-preview-0514,gemini-1.0-pro-vision-001,gemini-1.0-pro-002,gemini-1.0-pro-001,gemini-pro-vision,gemini-1.0-pro
@@ -177,7 +175,7 @@ GOOGLE_KEY=user_provided
 #============#
 
 OPENAI_API_KEY=user_provided
-# OPENAI_MODELS=gpt-4o,chatgpt-4o-latest,gpt-4o-mini,gpt-3.5-turbo-0125,gpt-3.5-turbo-0301,gpt-3.5-turbo,gpt-4,gpt-4-0613,gpt-4-vision-preview,gpt-3.5-turbo-0613,gpt-3.5-turbo-16k-0613,gpt-4-0125-preview,gpt-4-turbo-preview,gpt-4-1106-preview,gpt-3.5-turbo-1106,gpt-3.5-turbo-instruct,gpt-3.5-turbo-instruct-0914,gpt-3.5-turbo-16k
+# OPENAI_MODELS=o1,o1-mini,o1-preview,gpt-4o,gpt-4.5-preview,chatgpt-4o-latest,gpt-4o-mini,gpt-3.5-turbo-0125,gpt-3.5-turbo-0301,gpt-3.5-turbo,gpt-4,gpt-4-0613,gpt-4-vision-preview,gpt-3.5-turbo-0613,gpt-3.5-turbo-16k-0613,gpt-4-0125-preview,gpt-4-turbo-preview,gpt-4-1106-preview,gpt-3.5-turbo-1106,gpt-3.5-turbo-instruct,gpt-3.5-turbo-instruct-0914,gpt-3.5-turbo-16k
 
 DEBUG_OPENAI=false
 
@@ -211,12 +209,6 @@ ASSISTANTS_API_KEY=user_provided
 # More info, including how to enable use of Assistants with Azure here:
 # https://www.librechat.ai/docs/configuration/librechat_yaml/ai_endpoints/azure#using-assistants-with-azure
 
-#============#
-# OpenRouter #
-#============#
-# !!!Warning: Use the variable above instead of this one. Using this one will override the OpenAI endpoint
-# OPENROUTER_API_KEY=
-
 #============#
 # Plugins    #
 #============#
@@ -256,11 +248,23 @@ AZURE_AI_SEARCH_SEARCH_OPTION_SELECT=
 # DALLE3_AZURE_API_VERSION=
 # DALLE2_AZURE_API_VERSION=
 
+# Flux
+#-----------------
+FLUX_API_BASE_URL=https://api.us1.bfl.ai
+# FLUX_API_BASE_URL = 'https://api.bfl.ml';
+
+# Get your API key at https://api.us1.bfl.ai/auth/profile
+# FLUX_API_KEY=
+
 # Google
 #-----------------
 GOOGLE_SEARCH_API_KEY=
 GOOGLE_CSE_ID=
 
+# YOUTUBE
+#-----------------
+YOUTUBE_API_KEY=
+
 # SerpAPI
 #-----------------
 SERPAPI_API_KEY=
@@ -294,6 +298,10 @@ MEILI_NO_ANALYTICS=true
 MEILI_HOST=http://0.0.0.0:7700
 MEILI_MASTER_KEY=DrhYf7zENyR6AlUCKmnz0eYASOQdl6zxH7s7MKFSfFCt
 
+# Optional: Disable indexing, useful in a multi-node setup
+# where only one instance should perform an index sync.
+# MEILI_NO_SYNC=true
+
 #==================================================#
 #          Speech to Text & Text to Speech         #
 #==================================================#
@@ -356,7 +364,7 @@ ILLEGAL_MODEL_REQ_SCORE=5
 # Balance                #
 #========================#
 
-CHECK_BALANCE=false
+# CHECK_BALANCE=false
 # START_BALANCE=20000 # note: the number of tokens that will be credited after registration.
 
 #========================#
@@ -391,12 +399,22 @@ FACEBOOK_CALLBACK_URL=/oauth/facebook/callback
 GITHUB_CLIENT_ID=
 GITHUB_CLIENT_SECRET=
 GITHUB_CALLBACK_URL=/oauth/github/callback
+# GitHub Enterprise
+# GITHUB_ENTERPRISE_BASE_URL=
+# GITHUB_ENTERPRISE_USER_AGENT=
 
 # Google
 GOOGLE_CLIENT_ID=
 GOOGLE_CLIENT_SECRET=
 GOOGLE_CALLBACK_URL=/oauth/google/callback
 
+# Apple
+APPLE_CLIENT_ID=
+APPLE_TEAM_ID=
+APPLE_KEY_ID=
+APPLE_PRIVATE_KEY_PATH=
+APPLE_CALLBACK_URL=/oauth/apple/callback
+
 # OpenID
 OPENID_CLIENT_ID=
 OPENID_CLIENT_SECRET=
@@ -414,15 +432,19 @@ OPENID_NAME_CLAIM=
 
 OPENID_BUTTON_LABEL=
 OPENID_IMAGE_URL=
+# Set to true to automatically redirect to the OpenID provider when a user visits the login page
+# This will bypass the login form completely for users, only use this if OpenID is your only authentication method
+OPENID_AUTO_REDIRECT=false
 
 # LDAP
 LDAP_URL=
 LDAP_BIND_DN=
 LDAP_BIND_CREDENTIALS=
 LDAP_USER_SEARCH_BASE=
-LDAP_SEARCH_FILTER=mail={{username}}
+#LDAP_SEARCH_FILTER="mail="
 LDAP_CA_CERT_PATH=
 # LDAP_TLS_REJECT_UNAUTHORIZED=
+# LDAP_STARTTLS=
 # LDAP_LOGIN_USES_USERNAME=true
 # LDAP_ID=
 # LDAP_USERNAME=
@@ -455,6 +477,24 @@ FIREBASE_STORAGE_BUCKET=
 FIREBASE_MESSAGING_SENDER_ID=
 FIREBASE_APP_ID=
 
+#========================#
+# S3 AWS Bucket          #
+#========================#
+
+AWS_ENDPOINT_URL=
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_REGION=
+AWS_BUCKET_NAME=
+
+#========================#
+# Azure Blob Storage     #
+#========================#
+
+AZURE_STORAGE_CONNECTION_STRING=
+AZURE_STORAGE_PUBLIC_ACCESS=false
+AZURE_CONTAINER_NAME=files
+
 #========================#
 # Shared Links           #
 #========================#
@@ -487,6 +527,16 @@ HELP_AND_FAQ_URL=https://librechat.ai
 # Google tag manager id
 #ANALYTICS_GTM_ID=user provided google tag manager id
 
+#===============#
+# REDIS Options #
+#===============#
+
+# REDIS_URI=10.10.10.10:6379
+# USE_REDIS=true
+
+# USE_REDIS_CLUSTER=true
+# REDIS_CA=/path/to/ca.crt
+
 #==================================================#
 #                      Others                      #
 #==================================================#
@@ -494,9 +544,6 @@ HELP_AND_FAQ_URL=https://librechat.ai
 
 # NODE_ENV=
 
-# REDIS_URI=
-# USE_REDIS=
-
 # E2E_USER_EMAIL=
 # E2E_USER_PASSWORD=
 
@@ -514,4 +561,9 @@ HELP_AND_FAQ_URL=https://librechat.ai
 
 # no-cache: Forces validation with server before using cached version
 # no-store: Prevents storing the response entirely
-# must-revalidate: Prevents using stale content when offline
+# must-revalidate: Prevents using stale content when offline
+
+#=====================================================#
+#                  OpenWeather                        #
+#=====================================================#
+OPENWEATHER_API_KEY=

.eslintrc.js

@@ -1,213 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es2021: true,
-    node: true,
-    commonjs: true,
-    es6: true,
-  },
-  extends: [
-    'eslint:recommended',
-    'plugin:react/recommended',
-    'plugin:react-hooks/recommended',
-    'plugin:jest/recommended',
-    'prettier',
-    'plugin:jsx-a11y/recommended',
-  ],
-  ignorePatterns: [
-    'client/dist/**/*',
-    'client/public/**/*',
-    'e2e/playwright-report/**/*',
-    'packages/mcp/types/**/*',
-    'packages/mcp/dist/**/*',
-    'packages/mcp/test_bundle/**/*',
-    'api/demo/**/*',
-    'packages/data-provider/types/**/*',
-    'packages/data-provider/dist/**/*',
-    'packages/data-provider/test_bundle/**/*',
-    'data-node/**/*',
-    'meili_data/**/*',
-    'node_modules/**/*',
-  ],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-    ecmaFeatures: {
-      jsx: true,
-    },
-  },
-  plugins: ['react', 'react-hooks', '@typescript-eslint', 'import', 'jsx-a11y'],
-  rules: {
-    'react/react-in-jsx-scope': 'off',
-    '@typescript-eslint/ban-ts-comment': ['error', { 'ts-ignore': 'allow' }],
-    indent: ['error', 2, { SwitchCase: 1 }],
-    'max-len': [
-      'error',
-      {
-        code: 120,
-        ignoreStrings: true,
-        ignoreTemplateLiterals: true,
-        ignoreComments: true,
-      },
-    ],
-    'linebreak-style': 0,
-    curly: ['error', 'all'],
-    semi: ['error', 'always'],
-    'object-curly-spacing': ['error', 'always'],
-    'no-multiple-empty-lines': ['error', { max: 1 }],
-    'no-trailing-spaces': 'error',
-    'comma-dangle': ['error', 'always-multiline'],
-    // "arrow-parens": [2, "as-needed", { requireForBlockBody: true }],
-    // 'no-plusplus': ['error', { allowForLoopAfterthoughts: true }],
-    'no-console': 'off',
-    'import/no-cycle': 'error',
-    'import/no-self-import': 'error',
-    'import/extensions': 'off',
-    'no-promise-executor-return': 'off',
-    'no-param-reassign': 'off',
-    'no-continue': 'off',
-    'no-restricted-syntax': 'off',
-    'react/prop-types': ['off'],
-    'react/display-name': ['off'],
-    'no-nested-ternary': 'error',
-    'no-unused-vars': ['error', { varsIgnorePattern: '^_' }],
-    quotes: ['error', 'single'],
-  },
-  overrides: [
-    {
-      files: ['**/*.ts', '**/*.tsx'],
-      rules: {
-        'no-unused-vars': 'off', // off because it conflicts with '@typescript-eslint/no-unused-vars'
-        'react/display-name': 'off',
-        '@typescript-eslint/no-unused-vars': 'warn',
-      },
-    },
-    {
-      files: ['rollup.config.js', '.eslintrc.js', 'jest.config.js'],
-      env: {
-        node: true,
-      },
-    },
-    {
-      files: [
-        '**/*.test.js',
-        '**/*.test.jsx',
-        '**/*.test.ts',
-        '**/*.test.tsx',
-        '**/*.spec.js',
-        '**/*.spec.jsx',
-        '**/*.spec.ts',
-        '**/*.spec.tsx',
-        'setupTests.js',
-      ],
-      env: {
-        jest: true,
-        node: true,
-      },
-      rules: {
-        'react/display-name': 'off',
-        'react/prop-types': 'off',
-        'react/no-unescaped-entities': 'off',
-      },
-    },
-    {
-      files: ['**/*.ts', '**/*.tsx'],
-      parser: '@typescript-eslint/parser',
-      parserOptions: {
-        project: './client/tsconfig.json',
-      },
-      plugins: ['@typescript-eslint/eslint-plugin', 'jest'],
-      extends: [
-        'plugin:@typescript-eslint/eslint-recommended',
-        'plugin:@typescript-eslint/recommended',
-      ],
-      rules: {
-        '@typescript-eslint/no-explicit-any': 'error',
-        '@typescript-eslint/no-unnecessary-condition': 'warn',
-        '@typescript-eslint/strict-boolean-expressions': 'warn',
-      },
-    },
-    {
-      files: './packages/data-provider/**/*.ts',
-      overrides: [
-        {
-          files: '**/*.ts',
-          parser: '@typescript-eslint/parser',
-          parserOptions: {
-            project: './packages/data-provider/tsconfig.json',
-          },
-        },
-      ],
-    },
-    {
-      files: './api/demo/**/*.ts',
-      overrides: [
-        {
-          files: '**/*.ts',
-          parser: '@typescript-eslint/parser',
-          parserOptions: {
-            project: './packages/data-provider/tsconfig.json',
-          },
-        },
-      ],
-    },
-    {
-      files: './packages/mcp/**/*.ts',
-      overrides: [
-        {
-          files: '**/*.ts',
-          parser: '@typescript-eslint/parser',
-          parserOptions: {
-            project: './packages/mcp/tsconfig.json',
-          },
-        },
-      ],
-    },
-    {
-      files: './config/translations/**/*.ts',
-      parser: '@typescript-eslint/parser',
-      parserOptions: {
-        project: './config/translations/tsconfig.json',
-      },
-    },
-    {
-      files: ['./packages/data-provider/specs/**/*.ts'],
-      parserOptions: {
-        project: './packages/data-provider/tsconfig.spec.json',
-      },
-    },
-    {
-      files: ['./api/demo/specs/**/*.ts'],
-      parserOptions: {
-        project: './packages/data-provider/tsconfig.spec.json',
-      },
-    },
-    {
-      files: ['./packages/mcp/specs/**/*.ts'],
-      parserOptions: {
-        project: './packages/mcp/tsconfig.spec.json',
-      },
-    },
-  ],
-  settings: {
-    react: {
-      createClass: 'createReactClass', // Regex for Component Factory to use,
-      // default to "createReactClass"
-      pragma: 'React', // Pragma to use, default to "React"
-      fragment: 'Fragment', // Fragment to use (may be a property of <pragma>), default to "Fragment"
-      version: 'detect', // React version. "detect" automatically picks the version you have installed.
-    },
-    'import/parsers': {
-      '@typescript-eslint/parser': ['.ts', '.tsx'],
-    },
-    'import/resolver': {
-      typescript: {
-        project: ['./client/tsconfig.json'],
-      },
-      node: {
-        project: ['./client/tsconfig.json'],
-      },
-    },
-  },
-};

.github/ISSUE_TEMPLATE/BUG-REPORT.yml

@@ -1,12 +1,19 @@
 name: Bug Report
 description: File a bug report
 title: "[Bug]: "
-labels: ["bug"]
+labels: ["🐛 bug"]
 body:
   - type: markdown
     attributes:
       value: |
         Thanks for taking the time to fill out this bug report!
+        
+        Before submitting, please:
+        - Search existing [Issues and Discussions](https://github.com/danny-avila/LibreChat/discussions) to see if your bug has already been reported
+        - Use [Discussions](https://github.com/danny-avila/LibreChat/discussions) instead of Issues for:
+          - General inquiries
+          - Help with setup
+          - Questions about whether you're experiencing a bug
   - type: textarea
     id: what-happened
     attributes:
@@ -15,6 +22,23 @@ body:
       placeholder: Please give as many details as possible
     validations:
       required: true
+  - type: textarea
+    id: version-info
+    attributes:
+      label: Version Information
+      description: |
+        If using Docker, please run and provide the output of:
+        ```bash
+        docker images | grep librechat
+        ```
+        
+        If running from source, please run and provide the output of:
+        ```bash
+        git rev-parse HEAD
+        ```
+      placeholder: Paste the output here
+    validations:
+      required: true
   - type: textarea
     id: steps-to-reproduce
     attributes:
@@ -39,7 +63,21 @@ body:
     id: logs
     attributes:
       label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      description: |
+        Please paste relevant logs that were created when reproducing the error.
+        
+        Log locations:
+        - Docker: Project root directory ./logs
+        - npm: ./api/logs
+        
+        There are two types of logs that can help diagnose the issue:
+        - debug logs (debug-YYYY-MM-DD.log)
+        - error logs (error-YYYY-MM-DD.log)
+        
+        Error logs contain exact stack traces and are especially helpful, but both can provide valuable information.
+        Please only include the relevant portions of logs that correspond to when you reproduced the error.
+
+        For UI-related issues, browser console logs can be very helpful. You can provide these as screenshots or paste the text here.
       render: shell
   - type: textarea
     id: screenshots
@@ -53,4 +91,4 @@ body:
       description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/danny-avila/LibreChat/blob/main/.github/CODE_OF_CONDUCT.md)
       options:
         - label: I agree to follow this project's Code of Conduct
-          required: true
+          required: true

.github/ISSUE_TEMPLATE/FEATURE-REQUEST.yml

@@ -1,7 +1,7 @@
 name: Feature Request
 description: File a feature request
-title: "Enhancement: "
-labels: ["enhancement"]
+title: "[Enhancement]: "
+labels: ["✨ enhancement"]
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/LOCIZE_TRANSLATION_ACCESS_REQUEST.yml

@@ -0,0 +1,42 @@
+name: Locize Translation Access Request
+description: Request access to an additional language in Locize for LibreChat translations.
+title: "Locize Access Request: "
+labels: ["🌍 i18n", "🔑 access request"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for your interest in contributing to LibreChat translations!  
+        Please fill out the form below to request access to an additional language in **Locize**.
+
+        **🔗 Available Languages:** [View the list here](https://www.librechat.ai/docs/translation)
+        
+        **📌 Note:** Ensure that the requested language is supported before submitting your request.
+  - type: input
+    id: account_name
+    attributes:
+      label: Locize Account Name
+      description: Please provide your Locize account name (e.g., John Doe).
+      placeholder: e.g., John Doe
+    validations:
+      required: true
+  - type: input
+    id: language_requested
+    attributes:
+      label: Language Code (ISO 639-1)
+      description: |
+        Enter the **ISO 639-1** language code for the language you want to translate into.  
+        Example: `es` for Spanish, `zh-Hant` for Traditional Chinese.
+        
+        **🔗 Reference:** [Available Languages](https://www.librechat.ai/docs/translation)
+      placeholder: e.g., es
+    validations:
+      required: true
+  - type: checkboxes
+    id: agreement
+    attributes:
+      label: Agreement
+      description: By submitting this request, you confirm that you will contribute responsibly and adhere to the project guidelines.
+      options:
+        - label: I agree to use my access solely for contributing to LibreChat translations.
+          required: true

.github/ISSUE_TEMPLATE/NEW-LANGUAGE-REQUEST.yml

@@ -0,0 +1,33 @@
+name: New Language Request
+description: Request to add a new language for LibreChat translations.
+title: "New Language Request: "
+labels: ["✨ enhancement", "🌍 i18n"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking the time to submit a new language request! Please fill out the following details so we can review your request.
+  - type: input
+    id: language_name
+    attributes:
+      label: Language Name
+      description: Please provide the full name of the language (e.g., Spanish, Mandarin).
+      placeholder: e.g., Spanish
+    validations:
+      required: true
+  - type: input
+    id: iso_code
+    attributes:
+      label: ISO 639-1 Code
+      description: Please provide the ISO 639-1 code for the language (e.g., es for Spanish). You can refer to [this list](https://www.w3schools.com/tags/ref_language_codes.asp) for valid codes.
+      placeholder: e.g., es
+    validations:
+      required: true
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Code of Conduct
+      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/danny-avila/LibreChat/blob/main/.github/CODE_OF_CONDUCT.md).
+      options:
+        - label: I agree to follow this project's Code of Conduct
+          required: true

.github/ISSUE_TEMPLATE/QUESTION.yml

@@ -1,50 +0,0 @@
-name: Question
-description: Ask your question
-title: "[Question]: "
-labels: ["question"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill this!
-  - type: textarea
-    id: what-is-your-question
-    attributes:
-      label: What is your question?
-      description: Please give as many details as possible
-      placeholder: Please give as many details as possible
-    validations:
-      required: true
-  - type: textarea
-    id: more-details
-    attributes:
-      label: More Details
-      description: Please provide more details if needed.
-      placeholder: Please provide more details if needed.
-    validations:
-      required: true
-  - type: dropdown
-    id: browsers
-    attributes:
-      label: What is the main subject of your question?
-      multiple: true
-      options:
-        - Documentation
-        - Installation
-        - UI
-        - Endpoints
-        - User System/OAuth
-        - Other
-  - type: textarea
-    id: screenshots
-    attributes:
-      label: Screenshots
-      description: If applicable, add screenshots to help explain your problem. You can drag and drop, paste images directly here or link to them.
-  - type: checkboxes
-    id: terms
-    attributes:
-      label: Code of Conduct
-      description: By submitting this issue, you agree to follow our [Code of Conduct](https://github.com/danny-avila/LibreChat/blob/main/.github/CODE_OF_CONDUCT.md)
-      options:
-        - label: I agree to follow this project's Code of Conduct
-          required: true

.github/configuration-release.json

@@ -0,0 +1,60 @@
+{
+  "categories": [
+    {
+      "title": "### ✨ New Features",
+      "labels": ["feat"]
+    },
+    {
+      "title": "### 🌍 Internationalization",
+      "labels": ["i18n"]
+    },
+    {
+      "title": "### 👐 Accessibility",
+      "labels": ["a11y"]
+    },
+    {
+      "title": "### 🔧 Fixes",
+      "labels": ["Fix", "fix"]
+    },
+    {
+      "title": "### ⚙️ Other Changes",
+      "labels": ["ci", "style", "docs", "refactor", "chore"]
+    }
+  ],
+  "ignore_labels": [
+    "🔁 duplicate",
+    "📊 analytics",
+    "🌱 good first issue",
+    "🔍 investigation",
+    "🙏 help wanted",
+    "❌ invalid",
+    "❓ question",
+    "🚫 wontfix",
+    "🚀 release",
+    "version"
+  ],
+  "base_branches": ["main"],
+  "sort": {
+    "order": "ASC",
+    "on_property": "mergedAt"
+  },
+  "label_extractor": [
+    {
+      "pattern": "^(?:[^A-Za-z0-9]*)(feat|fix|chore|docs|refactor|ci|style|a11y|i18n)\\s*:",
+      "target": "$1",
+      "flags": "i",
+      "on_property": "title",
+      "method": "match"
+    },
+    {
+      "pattern": "^(?:[^A-Za-z0-9]*)(v\\d+\\.\\d+\\.\\d+(?:-rc\\d+)?).*",
+      "target": "version",
+      "flags": "i",
+      "on_property": "title",
+      "method": "match"
+    }
+  ],
+  "template": "## [#{{TO_TAG}}] - #{{TO_TAG_DATE}}\n\nChanges from #{{FROM_TAG}} to #{{TO_TAG}}.\n\n#{{CHANGELOG}}\n\n[See full release details][release-#{{TO_TAG}}]\n\n[release-#{{TO_TAG}}]: https://github.com/#{{OWNER}}/#{{REPO}}/releases/tag/#{{TO_TAG}}\n\n---",
+  "pr_template": "- #{{TITLE}} by **@#{{AUTHOR}}** in [##{{NUMBER}}](#{{URL}})",
+  "empty_template": "- no changes"
+}

.github/configuration-unreleased.json

@@ -0,0 +1,68 @@
+{
+  "categories": [
+    {
+      "title": "### ✨ New Features",
+      "labels": ["feat"]
+    },
+    {
+      "title": "### 🌍 Internationalization",
+      "labels": ["i18n"]
+    },
+    {
+      "title": "### 👐 Accessibility",
+      "labels": ["a11y"]
+    },
+    {
+      "title": "### 🔧 Fixes",
+      "labels": ["Fix", "fix"]
+    },
+    {
+      "title": "### ⚙️ Other Changes",
+      "labels": ["ci", "style", "docs", "refactor", "chore"]
+    }
+  ],
+  "ignore_labels": [
+    "🔁 duplicate",
+    "📊 analytics",
+    "🌱 good first issue",
+    "🔍 investigation",
+    "🙏 help wanted",
+    "❌ invalid",
+    "❓ question",
+    "🚫 wontfix",
+    "🚀 release",
+    "version",
+    "action"
+  ],
+  "base_branches": ["main"],
+  "sort": {
+    "order": "ASC",
+    "on_property": "mergedAt"
+  },
+  "label_extractor": [
+    {
+      "pattern": "^(?:[^A-Za-z0-9]*)(feat|fix|chore|docs|refactor|ci|style|a11y|i18n)\\s*:",
+      "target": "$1",
+      "flags": "i",
+      "on_property": "title",
+      "method": "match"
+    },
+    {
+      "pattern": "^(?:[^A-Za-z0-9]*)(v\\d+\\.\\d+\\.\\d+(?:-rc\\d+)?).*",
+      "target": "version",
+      "flags": "i",
+      "on_property": "title",
+      "method": "match"
+    },
+    {
+      "pattern": "^(?:[^A-Za-z0-9]*)(action)\\b.*",
+      "target": "action",
+      "flags": "i",
+      "on_property": "title",
+      "method": "match"
+    }
+  ],
+  "template": "## [Unreleased]\n\n#{{CHANGELOG}}\n\n---",
+  "pr_template": "- #{{TITLE}} by **@#{{AUTHOR}}** in [##{{NUMBER}}](#{{URL}})",
+  "empty_template": "- no changes"
+}

.github/workflows/backend-review.yml

@@ -38,7 +38,10 @@ jobs:
 
       - name: Install MCP Package
         run: npm run build:mcp
-      
+
+      - name: Install Data Schemas Package
+        run: npm run build:data-schemas
+
       - name: Create empty auth.json file
         run: |
           mkdir -p api/data
@@ -63,7 +66,5 @@ jobs:
       - name: Run librechat-data-provider unit tests
         run: cd packages/data-provider && npm run test:ci
 
-      - name: Run linters
-        uses: wearerequired/lint-action@v2
-        with:
-          eslint: true
+      - name: Run librechat-mcp unit tests
+        run: cd packages/mcp && npm run test:ci

.github/workflows/data-schemas.yml

@@ -0,0 +1,58 @@
+name: Publish `@librechat/data-schemas` to NPM
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'packages/data-schemas/package.json'
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: 'Reason for manual trigger'
+        required: false
+        default: 'Manual publish requested'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18.x'
+          
+      - name: Install dependencies
+        run: cd packages/data-schemas && npm ci
+        
+      - name: Build
+        run: cd packages/data-schemas && npm run build
+        
+      - name: Set up npm authentication
+        run: echo "//registry.npmjs.org/:_authToken=${{ secrets.PUBLISH_NPM_TOKEN }}" > ~/.npmrc
+        
+      - name: Check version change
+        id: check
+        working-directory: packages/data-schemas
+        run: |
+          PACKAGE_VERSION=$(node -p "require('./package.json').version")
+          PUBLISHED_VERSION=$(npm view @librechat/data-schemas version 2>/dev/null || echo "0.0.0")
+          if [ "$PACKAGE_VERSION" = "$PUBLISHED_VERSION" ]; then
+            echo "No version change, skipping publish"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "Version changed, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+            
+      - name: Pack package
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/data-schemas
+        run: npm pack
+        
+      - name: Publish
+        if: steps.check.outputs.skip != 'true'
+        working-directory: packages/data-schemas
+        run: npm publish *.tgz --access public

.github/workflows/eslint-ci.yml

@@ -0,0 +1,73 @@
+name: ESLint Code Quality Checks
+
+on:
+  pull_request:
+    branches:
+      - main
+      - dev
+      - release/*
+    paths:
+      - 'api/**'
+      - 'client/**'
+
+jobs:
+  eslint_checks:
+    name: Run ESLint Linting
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+      actions: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      # Run ESLint on changed files within the api/ and client/ directories.
+      - name: Run ESLint on changed files
+        env:
+          SARIF_ESLINT_IGNORE_SUPPRESSED: "true"
+        run: |
+          # Extract the base commit SHA from the pull_request event payload.
+          BASE_SHA=$(jq --raw-output .pull_request.base.sha "$GITHUB_EVENT_PATH")
+          echo "Base commit SHA: $BASE_SHA"
+
+          # Get changed files (only JS/TS files in api/ or client/)
+          CHANGED_FILES=$(git diff --name-only --diff-filter=ACMRTUXB "$BASE_SHA" HEAD | grep -E '^(api|client)/.*\.(js|jsx|ts|tsx)$' || true)
+
+          # Debug output
+          echo "Changed files:"
+          echo "$CHANGED_FILES"
+
+          # Ensure there are files to lint before running ESLint
+          if [[ -z "$CHANGED_FILES" ]]; then
+            echo "No matching files changed. Skipping ESLint."
+            echo "UPLOAD_SARIF=false" >> $GITHUB_ENV
+            exit 0
+          fi
+
+          # Set variable to allow SARIF upload
+          echo "UPLOAD_SARIF=true" >> $GITHUB_ENV
+
+          # Run ESLint
+          npx eslint --no-error-on-unmatched-pattern \
+            --config eslint.config.mjs \
+            --format @microsoft/eslint-formatter-sarif \
+            --output-file eslint-results.sarif $CHANGED_FILES || true
+
+      - name: Upload analysis results to GitHub
+        if: env.UPLOAD_SARIF == 'true'
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: eslint-results.sarif
+          wait-for-processing: true

.github/workflows/generate-release-changelog-pr.yml

@@ -0,0 +1,94 @@
+name: Generate Release Changelog PR
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  generate-release-changelog-pr:
+    permissions:
+      contents: write    # Needed for pushing commits and creating branches.
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      # 1. Checkout the repository (with full history).
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # 2. Generate the release changelog using our custom configuration.
+      - name: Generate Release Changelog
+        id: generate_release
+        uses: mikepenz/release-changelog-builder-action@v5.1.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          configuration: ".github/configuration-release.json"
+          owner: ${{ github.repository_owner }}
+          repo: ${{ github.event.repository.name }}
+          outputFile: CHANGELOG-release.md
+
+      # 3. Update the main CHANGELOG.md:
+      #    - If it doesn't exist, create it with a basic header.
+      #    - Remove the "Unreleased" section (if present).
+      #    - Prepend the new release changelog above previous releases.
+      #    - Remove all temporary files before committing.
+      - name: Update CHANGELOG.md
+        run: |
+          # Determine the release tag, e.g. "v1.2.3"
+          TAG=${GITHUB_REF##*/}
+          echo "Using release tag: $TAG"
+          
+          # Ensure CHANGELOG.md exists; if not, create a basic header.
+          if [ ! -f CHANGELOG.md ]; then
+            echo "# Changelog" > CHANGELOG.md
+            echo "" >> CHANGELOG.md
+            echo "All notable changes to this project will be documented in this file." >> CHANGELOG.md
+            echo "" >> CHANGELOG.md
+          fi
+
+          echo "Updating CHANGELOG.md…"
+          
+          # Remove the "Unreleased" section (from "## [Unreleased]" until the first occurrence of '---') if it exists.
+          if grep -q "^## \[Unreleased\]" CHANGELOG.md; then
+            awk '/^## \[Unreleased\]/{flag=1} flag && /^---/{flag=0; next} !flag' CHANGELOG.md > CHANGELOG.cleaned
+          else
+            cp CHANGELOG.md CHANGELOG.cleaned
+          fi
+
+          # Split the cleaned file into:
+          #   - header.md: content before the first release header ("## [v...").
+          #   - tail.md: content from the first release header onward.
+          awk '/^## \[v/{exit} {print}' CHANGELOG.cleaned > header.md
+          awk 'f{print} /^## \[v/{f=1; print}' CHANGELOG.cleaned > tail.md
+
+          # Combine header, the new release changelog, and the tail.
+          echo "Combining updated changelog parts..."
+          cat header.md CHANGELOG-release.md > CHANGELOG.md.new
+          echo "" >> CHANGELOG.md.new
+          cat tail.md >> CHANGELOG.md.new
+
+          mv CHANGELOG.md.new CHANGELOG.md
+
+          # Remove temporary files.
+          rm -f CHANGELOG.cleaned header.md tail.md CHANGELOG-release.md
+
+          echo "Final CHANGELOG.md content:"
+          cat CHANGELOG.md
+
+      # 4. Create (or update) the Pull Request with the updated CHANGELOG.md.
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sign-commits: true
+          commit-message: "chore: update CHANGELOG for release ${{ github.ref_name }}"
+          base: main
+          branch: "changelog/${{ github.ref_name }}"
+          reviewers: danny-avila
+          title: "chore: update CHANGELOG for release ${{ github.ref_name }}"
+          body: |
+            **Description**:
+            - This PR updates the CHANGELOG.md by removing the "Unreleased" section and adding new release notes for release ${{ github.ref_name }} above previous releases.

.github/workflows/generate-unreleased-changelog-pr.yml

@@ -0,0 +1,106 @@
+name: Generate Unreleased Changelog PR
+
+on:
+  schedule:
+    - cron: "0 0 * * 1"  # Runs every Monday at 00:00 UTC
+
+jobs:
+  generate-unreleased-changelog-pr:
+    permissions:
+      contents: write    # Needed for pushing commits and creating branches.
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      # 1. Checkout the repository on main.
+      - name: Checkout Repository on Main
+        uses: actions/checkout@v4
+        with:
+          ref: main
+          fetch-depth: 0
+
+      # 4. Get the latest version tag.
+      - name: Get Latest Tag
+        id: get_latest_tag
+        run: |
+          LATEST_TAG=$(git describe --tags $(git rev-list --tags --max-count=1) || echo "none")
+          echo "Latest tag: $LATEST_TAG"
+          echo "tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+
+      # 5. Generate the Unreleased changelog.
+      - name: Generate Unreleased Changelog
+        id: generate_unreleased
+        uses: mikepenz/release-changelog-builder-action@v5.1.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          configuration: ".github/configuration-unreleased.json"
+          owner: ${{ github.repository_owner }}
+          repo: ${{ github.event.repository.name }}
+          outputFile: CHANGELOG-unreleased.md
+          fromTag: ${{ steps.get_latest_tag.outputs.tag }}
+          toTag: main
+
+      # 7. Update CHANGELOG.md with the new Unreleased section.
+      - name: Update CHANGELOG.md
+        id: update_changelog
+        run: |
+          # Create CHANGELOG.md if it doesn't exist.
+          if [ ! -f CHANGELOG.md ]; then
+            echo "# Changelog" > CHANGELOG.md
+            echo "" >> CHANGELOG.md
+            echo "All notable changes to this project will be documented in this file." >> CHANGELOG.md
+            echo "" >> CHANGELOG.md
+          fi
+          
+          echo "Updating CHANGELOG.md…"
+          
+          # Extract content before the "## [Unreleased]" (or first version header if missing).
+          if grep -q "^## \[Unreleased\]" CHANGELOG.md; then
+            awk '/^## \[Unreleased\]/{exit} {print}' CHANGELOG.md > CHANGELOG_TMP.md
+          else
+            awk '/^## \[v/{exit} {print}' CHANGELOG.md > CHANGELOG_TMP.md
+          fi
+          
+          # Append the generated Unreleased changelog.
+          echo "" >> CHANGELOG_TMP.md
+          cat CHANGELOG-unreleased.md >> CHANGELOG_TMP.md
+          echo "" >> CHANGELOG_TMP.md
+          
+          # Append the remainder of the original changelog (starting from the first version header).
+          awk 'f{print} /^## \[v/{f=1; print}' CHANGELOG.md >> CHANGELOG_TMP.md
+          
+          # Replace the old file with the updated file.
+          mv CHANGELOG_TMP.md CHANGELOG.md
+          
+          # Remove the temporary generated file.
+          rm -f CHANGELOG-unreleased.md
+          
+          echo "Final CHANGELOG.md:"
+          cat CHANGELOG.md
+
+      # 8. Check if CHANGELOG.md has any updates.
+      - name: Check for CHANGELOG.md changes
+        id: changelog_changes
+        run: |
+          if git diff --quiet CHANGELOG.md; then
+            echo "has_changes=false" >> $GITHUB_OUTPUT
+          else
+            echo "has_changes=true" >> $GITHUB_OUTPUT
+          fi
+
+      # 9. Create (or update) the Pull Request only if there are changes.
+      - name: Create Pull Request
+        if: steps.changelog_changes.outputs.has_changes == 'true'
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          base: main
+          branch: "changelog/unreleased-update"
+          sign-commits: true
+          commit-message: "action: update Unreleased changelog"
+          title: "action: update Unreleased changelog"
+          body: |
+            **Description**:
+            - This PR updates the Unreleased section in CHANGELOG.md.
+            - It compares the current main branch with the latest version tag (determined as ${{ steps.get_latest_tag.outputs.tag }}),
+              regenerates the Unreleased changelog, removes any old Unreleased block, and inserts the new content.

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

@@ -0,0 +1,93 @@
+name: Detect Unused i18next Strings
+
+on:
+  pull_request:
+    paths:
+      - "client/src/**"
+      - "api/**"
+
+jobs:
+  detect-unused-i18n-keys:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write  # Required for posting PR comments
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Find unused i18next keys
+        id: find-unused
+        run: |
+          echo "🔍 Scanning for unused i18next keys..."
+
+          # Define paths
+          I18N_FILE="client/src/locales/en/translation.json"
+          SOURCE_DIRS=("client/src" "api")
+
+          # Check if translation file exists
+          if [[ ! -f "$I18N_FILE" ]]; then
+            echo "::error title=Missing i18n File::Translation file not found: $I18N_FILE"
+            exit 1
+          fi
+
+          # Extract all keys from the JSON file
+          KEYS=$(jq -r 'keys[]' "$I18N_FILE")
+
+          # Track unused keys
+          UNUSED_KEYS=()
+
+          # Check if each key is used in the source code
+          for KEY in $KEYS; do
+            FOUND=false
+            for DIR in "${SOURCE_DIRS[@]}"; do
+              if grep -r --include=\*.{js,jsx,ts,tsx} -q "$KEY" "$DIR"; then
+                FOUND=true
+                break
+              fi
+            done
+          
+            if [[ "$FOUND" == false ]]; then
+              UNUSED_KEYS+=("$KEY")
+            fi
+          done
+
+          # Output results
+          if [[ ${#UNUSED_KEYS[@]} -gt 0 ]]; then
+            echo "🛑 Found ${#UNUSED_KEYS[@]} unused i18n keys:"
+            echo "unused_keys=$(echo "${UNUSED_KEYS[@]}" | jq -R -s -c 'split(" ")')" >> $GITHUB_ENV
+            for KEY in "${UNUSED_KEYS[@]}"; do
+              echo "::warning title=Unused i18n Key::'$KEY' is defined but not used in the codebase."
+            done
+          else
+            echo "✅ No unused i18n keys detected!"
+            echo "unused_keys=[]" >> $GITHUB_ENV
+          fi
+
+      - name: Post verified comment on PR
+        if: env.unused_keys != '[]'
+        run: |
+          PR_NUMBER=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
+
+          # Format the unused keys list as checkboxes for easy manual checking.
+          FILTERED_KEYS=$(echo "$unused_keys" | jq -r '.[]' | grep -v '^\s*$' | sed 's/^/- [ ] `/;s/$/`/' )
+
+          COMMENT_BODY=$(cat <<EOF
+          ### 🚨 Unused i18next Keys Detected
+
+          The following translation keys are defined in \`translation.json\` but are **not used** in the codebase:
+
+          $FILTERED_KEYS
+
+          ⚠️ **Please remove these unused keys to keep the translation files clean.**
+          EOF
+          )
+
+          gh api "repos/${{ github.repository }}/issues/${PR_NUMBER}/comments" \
+            -f body="$COMMENT_BODY" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Fail workflow if unused keys found
+        if: env.unused_keys != '[]'
+        run: exit 1

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

@@ -0,0 +1,72 @@
+name: Sync Locize Translations & Create Translation PR
+
+on:
+  push:
+    branches: [main]
+  repository_dispatch:
+    types: [locize/versionPublished]
+
+jobs:
+  sync-translations:
+    name: Sync Translation Keys with Locize
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set Up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install locize CLI
+        run: npm install -g locize-cli
+
+      # Sync translations (Push missing keys & remove deleted ones)
+      - name: Sync Locize with Repository
+        if: ${{ github.event_name == 'push' }}
+        run: |
+          cd client/src/locales
+          locize sync --api-key ${{ secrets.LOCIZE_API_KEY }} --project-id ${{ secrets.LOCIZE_PROJECT_ID }} --language en
+
+      # When triggered by repository_dispatch, skip sync step.
+      - name: Skip sync step on non-push events
+        if: ${{ github.event_name != 'push' }}
+        run: echo "Skipping sync as the event is not a push."
+
+  create-pull-request:
+    name: Create Translation PR on Version Published
+    runs-on: ubuntu-latest
+    needs: sync-translations
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      # 1. Check out the repository.
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      # 2. Download translation files from locize.
+      - name: Download Translations from locize
+        uses: locize/download@v1
+        with:
+          project-id: ${{ secrets.LOCIZE_PROJECT_ID }}
+          path: "client/src/locales"
+
+      # 3. Create a Pull Request using built-in functionality.
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sign-commits: true
+          commit-message: "🌍 i18n: Update translation.json with latest translations"
+          base: main
+          branch: i18n/locize-translation-update
+          reviewers: danny-avila
+          title: "🌍 i18n: Update translation.json with latest translations"
+          body: |
+            **Description**:
+            - 🎯 **Objective**: Update `translation.json` with the latest translations from locize.
+            - 🔍 **Details**: This PR is automatically generated upon receiving a versionPublished event with version "latest". It reflects the newest translations provided by locize.
+            - ✅ **Status**: Ready for review.
+          labels: "🌍 i18n"

.github/workflows/unused-packages.yml

@@ -0,0 +1,153 @@
+name: Detect Unused NPM Packages
+
+on:
+  pull_request:
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+      - 'client/**'
+      - 'api/**'
+
+jobs:
+  detect-unused-packages:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install depcheck
+        run: npm install -g depcheck
+
+      - name: Validate JSON files
+        run: |
+          for FILE in package.json client/package.json api/package.json; do
+            if [[ -f "$FILE" ]]; then
+              jq empty "$FILE" || (echo "::error title=Invalid JSON::$FILE is invalid" && exit 1)
+            fi
+          done
+
+      - name: Extract Dependencies Used in Scripts
+        id: extract-used-scripts
+        run: |
+          extract_deps_from_scripts() {
+            local package_file=$1
+            if [[ -f "$package_file" ]]; then
+              jq -r '.scripts | to_entries[].value' "$package_file" | \
+                grep -oE '([a-zA-Z0-9_-]+)' | sort -u > used_scripts.txt
+            else
+              touch used_scripts.txt
+            fi
+          }
+
+          extract_deps_from_scripts "package.json"
+          mv used_scripts.txt root_used_deps.txt
+
+          extract_deps_from_scripts "client/package.json"
+          mv used_scripts.txt client_used_deps.txt
+
+          extract_deps_from_scripts "api/package.json"
+          mv used_scripts.txt api_used_deps.txt
+
+      - name: Extract Dependencies Used in Source Code
+        id: extract-used-code
+        run: |
+          extract_deps_from_code() {
+            local folder=$1
+            local output_file=$2
+            if [[ -d "$folder" ]]; then
+              grep -rEho "require\\(['\"]([a-zA-Z0-9@/._-]+)['\"]\\)" "$folder" --include=\*.{js,ts,mjs,cjs} | \
+                sed -E "s/require\\(['\"]([a-zA-Z0-9@/._-]+)['\"]\\)/\1/" > "$output_file"
+          
+              grep -rEho "import .* from ['\"]([a-zA-Z0-9@/._-]+)['\"]" "$folder" --include=\*.{js,ts,mjs,cjs} | \
+                sed -E "s/import .* from ['\"]([a-zA-Z0-9@/._-]+)['\"]/\1/" >> "$output_file"
+          
+              sort -u "$output_file" -o "$output_file"
+            else
+              touch "$output_file"
+            fi
+          }
+
+          extract_deps_from_code "." root_used_code.txt
+          extract_deps_from_code "client" client_used_code.txt
+          extract_deps_from_code "api" api_used_code.txt
+
+      - name: Run depcheck for root package.json
+        id: check-root
+        run: |
+          if [[ -f "package.json" ]]; then
+            UNUSED=$(depcheck --json | jq -r '.dependencies | join("\n")' || echo "")
+            UNUSED=$(comm -23 <(echo "$UNUSED" | sort) <(cat root_used_deps.txt root_used_code.txt | sort) || echo "")
+            echo "ROOT_UNUSED<<EOF" >> $GITHUB_ENV
+            echo "$UNUSED" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+          fi
+
+      - name: Run depcheck for client/package.json
+        id: check-client
+        run: |
+          if [[ -f "client/package.json" ]]; then
+            chmod -R 755 client
+            cd client
+            UNUSED=$(depcheck --json | jq -r '.dependencies | join("\n")' || echo "")
+            UNUSED=$(comm -23 <(echo "$UNUSED" | sort) <(cat ../client_used_deps.txt ../client_used_code.txt | sort) || echo "")
+            echo "CLIENT_UNUSED<<EOF" >> $GITHUB_ENV
+            echo "$UNUSED" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+            cd ..
+          fi
+
+      - name: Run depcheck for api/package.json
+        id: check-api
+        run: |
+          if [[ -f "api/package.json" ]]; then
+            chmod -R 755 api
+            cd api
+            UNUSED=$(depcheck --json | jq -r '.dependencies | join("\n")' || echo "")
+            UNUSED=$(comm -23 <(echo "$UNUSED" | sort) <(cat ../api_used_deps.txt ../api_used_code.txt | sort) || echo "")
+            echo "API_UNUSED<<EOF" >> $GITHUB_ENV
+            echo "$UNUSED" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+            cd ..
+          fi
+
+      - name: Post comment on PR if unused dependencies are found
+        if: env.ROOT_UNUSED != '' || env.CLIENT_UNUSED != '' || env.API_UNUSED != ''
+        run: |
+          PR_NUMBER=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
+
+          ROOT_LIST=$(echo "$ROOT_UNUSED" | awk '{print "- `" $0 "`"}')
+          CLIENT_LIST=$(echo "$CLIENT_UNUSED" | awk '{print "- `" $0 "`"}')
+          API_LIST=$(echo "$API_UNUSED" | awk '{print "- `" $0 "`"}')
+
+          COMMENT_BODY=$(cat <<EOF
+          ### 🚨 Unused NPM Packages Detected
+
+          The following **unused dependencies** were found:
+
+          $(if [[ ! -z "$ROOT_UNUSED" ]]; then echo "#### 📂 Root \`package.json\`"; echo ""; echo "$ROOT_LIST"; echo ""; fi)
+
+          $(if [[ ! -z "$CLIENT_UNUSED" ]]; then echo "#### 📂 Client \`client/package.json\`"; echo ""; echo "$CLIENT_LIST"; echo ""; fi)
+
+          $(if [[ ! -z "$API_UNUSED" ]]; then echo "#### 📂 API \`api/package.json\`"; echo ""; echo "$API_LIST"; echo ""; fi)
+
+          ⚠️ **Please remove these unused dependencies to keep your project clean.**
+          EOF
+          )
+
+          gh api "repos/${{ github.repository }}/issues/${PR_NUMBER}/comments" \
+            -f body="$COMMENT_BODY" \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Fail workflow if unused dependencies found
+        if: env.ROOT_UNUSED != '' || env.CLIENT_UNUSED != '' || env.API_UNUSED != ''
+        run: exit 1

.gitignore

@@ -37,6 +37,10 @@ client/public/main.js
 client/public/main.js.map
 client/public/main.js.LICENSE.txt
 
+# Azure Blob Storage Emulator (Azurite)
+__azurite**
+__blobstorage__/**/*
+
 # Dependency directorys
 # Deployed apps should consider commenting these lines out:
 # see https://npmjs.org/doc/faq.html#Should-I-check-my-node_modules-folder-into-git
@@ -105,4 +109,5 @@ auth.json
 uploads/
 
 # owner
-release/
+release/
+!/client/src/@types/i18next.d.ts

.prettierrc

@@ -0,0 +1,19 @@
+{
+  "tailwindConfig": "./client/tailwind.config.cjs",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "arrowParens": "always",
+  "embeddedLanguageFormatting": "auto",
+  "insertPragma": false,
+  "proseWrap": "preserve",
+  "quoteProps": "as-needed",
+  "requirePragma": false,
+  "rangeStart": 0,
+  "endOfLine": "auto",
+  "jsxSingleQuote": false,
+  "plugins": ["prettier-plugin-tailwindcss"]
+}

CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+### ✨ New Features
+
+- 🪄 feat: Agent Artifacts by **@danny-avila** in [#5804](https://github.com/danny-avila/LibreChat/pull/5804)
+
+### ⚙️ Other Changes
+
+- 🔄 chore: Enforce 18next Language Keys by **@rubentalstra** in [#5803](https://github.com/danny-avila/LibreChat/pull/5803)
+- 🔃 refactor: Parent Message ID Handling on Error, Update Translations, Bump Agents by **@danny-avila** in [#5833](https://github.com/danny-avila/LibreChat/pull/5833)
+
+---

Dockerfile

@@ -1,4 +1,4 @@
-# v0.7.6
+# v0.7.7
 
 # Base node image
 FROM node:20-alpine AS node

Dockerfile.multi

@@ -1,8 +1,8 @@
 # Dockerfile.multi
-# v0.7.6
+# v0.7.7
 
 # Base for all builds
-FROM node:20-alpine AS base
+FROM node:20-alpine AS base-min
 WORKDIR /app
 RUN apk --no-cache add curl
 RUN npm config set fetch-retry-maxtimeout 600000 && \
@@ -11,8 +11,13 @@ RUN npm config set fetch-retry-maxtimeout 600000 && \
 COPY package*.json ./
 COPY packages/data-provider/package*.json ./packages/data-provider/
 COPY packages/mcp/package*.json ./packages/mcp/
+COPY packages/data-schemas/package*.json ./packages/data-schemas/
 COPY client/package*.json ./client/
 COPY api/package*.json ./api/
+
+# Install all dependencies for every build
+FROM base-min AS base
+WORKDIR /app
 RUN npm ci
 
 # Build data-provider
@@ -20,7 +25,6 @@ FROM base AS data-provider-build
 WORKDIR /app/packages/data-provider
 COPY packages/data-provider ./
 RUN npm run build
-RUN npm prune --production
 
 # Build mcp package
 FROM base AS mcp-build
@@ -28,7 +32,13 @@ WORKDIR /app/packages/mcp
 COPY packages/mcp ./
 COPY --from=data-provider-build /app/packages/data-provider/dist /app/packages/data-provider/dist
 RUN npm run build
-RUN npm prune --production
+
+# Build data-schemas
+FROM base AS data-schemas-build
+WORKDIR /app/packages/data-schemas
+COPY packages/data-schemas ./
+COPY --from=data-provider-build /app/packages/data-provider/dist /app/packages/data-provider/dist
+RUN npm run build
 
 # Client build
 FROM base AS client-build
@@ -37,18 +47,19 @@ COPY client ./
 COPY --from=data-provider-build /app/packages/data-provider/dist /app/packages/data-provider/dist
 ENV NODE_OPTIONS="--max-old-space-size=2048"
 RUN npm run build
-RUN npm prune --production
 
 # API setup (including client dist)
-FROM base AS api-build
+FROM base-min AS api-build
 WORKDIR /app
+# Install only production deps
+RUN npm ci --omit=dev
 COPY api ./api
 COPY config ./config
 COPY --from=data-provider-build /app/packages/data-provider/dist ./packages/data-provider/dist
 COPY --from=mcp-build /app/packages/mcp/dist ./packages/mcp/dist
+COPY --from=data-schemas-build /app/packages/data-schemas/dist ./packages/data-schemas/dist
 COPY --from=client-build /app/client/dist ./client/dist
 WORKDIR /app/api
-RUN npm prune --production
 EXPOSE 3080
 ENV HOST=0.0.0.0
 CMD ["node", "server/index.js"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 LibreChat
+Copyright (c) 2025 LibreChat
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -38,6 +38,15 @@
 </a>
 </p>
 
+<p align="center">
+  <a href="https://www.librechat.ai/docs/translation">
+    <img 
+      src="https://img.shields.io/badge/dynamic/json.svg?style=for-the-badge&color=2096F3&label=locize&query=%24.translatedPercentage&url=https://api.locize.app/badgedata/4cb2598b-ed4d-469c-9b04-2ed531a8cb45&suffix=%+translated" 
+      alt="Translation Progress">
+  </a>
+</p>
+
+
 # ✨ Features
 
 - 🖥️ **UI & Experience** inspired by ChatGPT with enhanced design and features
@@ -72,13 +81,16 @@
   - [Fork Messages & Conversations](https://www.librechat.ai/docs/features/fork) for Advanced Context control
 
 - 💬 **Multimodal & File Interactions**:  
-  - Upload and analyze images with Claude 3, GPT-4o, o1, Llama-Vision, and Gemini 📸  
+  - Upload and analyze images with Claude 3, GPT-4.5, GPT-4o, o1, Llama-Vision, and Gemini 📸  
   - Chat with Files using Custom Endpoints, OpenAI, Azure, Anthropic, AWS Bedrock, & Google 🗃️
 
 - 🌎 **Multilingual UI**:  
   - English, 中文, Deutsch, Español, Français, Italiano, Polski, Português Brasileiro
   - Русский, 日本語, Svenska, 한국어, Tiếng Việt, 繁體中文, العربية, Türkçe, Nederlands, עברית
 
+- 🧠 **Reasoning UI**:  
+  - Dynamic Reasoning UI for Chain-of-Thought/Reasoning AI models like DeepSeek-R1
+
 - 🎨 **Customizable Interface**:  
   - Customizable Dropdown & Interface that adapts to both power users and newcomers
 
@@ -114,7 +126,8 @@ LibreChat brings together the future of assistant AIs with the revolutionary tec
 
 With LibreChat, you no longer need to opt for ChatGPT Plus and can instead use free or pay-per-call APIs. We welcome contributions, cloning, and forking to enhance the capabilities of this advanced chatbot platform.
 
-[![Watch the video](https://raw.githubusercontent.com/LibreChat-AI/librechat.ai/main/public/images/changelog/v0.7.5.png)](https://www.youtube.com/watch?v=IDukQ7a2f3U)
+[![Watch the video](https://raw.githubusercontent.com/LibreChat-AI/librechat.ai/main/public/images/changelog/v0.7.6.gif)](https://www.youtube.com/watch?v=ilfwGQtJNlI)
+
 Click on the thumbnail to open the video☝️
 
 ---
@@ -166,6 +179,8 @@ Contributions, suggestions, bug reports and fixes are welcome!
 
 For new features, components, or extensions, please open an issue and discuss before sending a PR.
 
+If you'd like to help translate LibreChat into your language, we'd love your contribution! Improving our translations not only makes LibreChat more accessible to users around the world but also enhances the overall user experience. Please check out our [Translation Guide](https://www.librechat.ai/docs/translation).
+
 ---
 
 ## 💖 This project exists in its current state thanks to all the people who contribute
@@ -173,3 +188,15 @@ For new features, components, or extensions, please open an issue and discuss be
 <a href="https://github.com/danny-avila/LibreChat/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=danny-avila/LibreChat" />
 </a>
+
+---
+
+## 🎉 Special Thanks
+
+We thank [Locize](https://locize.com) for their translation management tools that support multiple languages in LibreChat.
+
+<p align="center">
+  <a href="https://locize.com" target="_blank" rel="noopener noreferrer">
+    <img src="https://github.com/user-attachments/assets/d6b70894-6064-475e-bb65-92a9e23e0077" alt="Locize Logo" height="50">
+  </a>
+</p>

api/app/bingai.js

@@ -1,112 +0,0 @@
-require('dotenv').config();
-const { KeyvFile } = require('keyv-file');
-const { EModelEndpoint } = require('librechat-data-provider');
-const { getUserKey, checkUserKeyExpiry } = require('~/server/services/UserService');
-const { logger } = require('~/config');
-
-const askBing = async ({
-  text,
-  parentMessageId,
-  conversationId,
-  jailbreak,
-  jailbreakConversationId,
-  context,
-  systemMessage,
-  conversationSignature,
-  clientId,
-  invocationId,
-  toneStyle,
-  key: expiresAt,
-  onProgress,
-  userId,
-}) => {
-  const isUserProvided = process.env.BINGAI_TOKEN === 'user_provided';
-
-  let key = null;
-  if (expiresAt && isUserProvided) {
-    checkUserKeyExpiry(expiresAt, EModelEndpoint.bingAI);
-    key = await getUserKey({ userId, name: 'bingAI' });
-  }
-
-  const { BingAIClient } = await import('nodejs-gpt');
-  const store = {
-    store: new KeyvFile({ filename: './data/cache.json' }),
-  };
-
-  const bingAIClient = new BingAIClient({
-    // "_U" cookie from bing.com
-    // userToken:
-    //   isUserProvided ? key : process.env.BINGAI_TOKEN ?? null,
-    // If the above doesn't work, provide all your cookies as a string instead
-    cookies: isUserProvided ? key : process.env.BINGAI_TOKEN ?? null,
-    debug: false,
-    cache: store,
-    host: process.env.BINGAI_HOST || null,
-    proxy: process.env.PROXY || null,
-  });
-
-  let options = {};
-
-  if (jailbreakConversationId == 'false') {
-    jailbreakConversationId = false;
-  }
-
-  if (jailbreak) {
-    options = {
-      jailbreakConversationId: jailbreakConversationId || jailbreak,
-      context,
-      systemMessage,
-      parentMessageId,
-      toneStyle,
-      onProgress,
-      clientOptions: {
-        features: {
-          genImage: {
-            server: {
-              enable: true,
-              type: 'markdown_list',
-            },
-          },
-        },
-      },
-    };
-  } else {
-    options = {
-      conversationId,
-      context,
-      systemMessage,
-      parentMessageId,
-      toneStyle,
-      onProgress,
-      clientOptions: {
-        features: {
-          genImage: {
-            server: {
-              enable: true,
-              type: 'markdown_list',
-            },
-          },
-        },
-      },
-    };
-
-    // don't give those parameters for new conversation
-    // for new conversation, conversationSignature always is null
-    if (conversationSignature) {
-      options.encryptedConversationSignature = conversationSignature;
-      options.clientId = clientId;
-      options.invocationId = invocationId;
-    }
-  }
-
-  logger.debug('bing options', options);
-
-  const res = await bingAIClient.sendMessage(text, options);
-
-  return res;
-
-  // for reference:
-  // https://github.com/waylaidwanderer/node-chatgpt-api/blob/main/demos/use-bing-client.js
-};
-
-module.exports = { askBing };

api/app/chatgpt-browser.js

@@ -1,57 +0,0 @@
-require('dotenv').config();
-const { KeyvFile } = require('keyv-file');
-const { Constants, EModelEndpoint } = require('librechat-data-provider');
-const { getUserKey, checkUserKeyExpiry } = require('../server/services/UserService');
-
-const browserClient = async ({
-  text,
-  parentMessageId,
-  conversationId,
-  model,
-  key: expiresAt,
-  onProgress,
-  onEventMessage,
-  abortController,
-  userId,
-}) => {
-  const isUserProvided = process.env.CHATGPT_TOKEN === 'user_provided';
-
-  let key = null;
-  if (expiresAt && isUserProvided) {
-    checkUserKeyExpiry(expiresAt, EModelEndpoint.chatGPTBrowser);
-    key = await getUserKey({ userId, name: 'chatGPTBrowser' });
-  }
-
-  const { ChatGPTBrowserClient } = await import('nodejs-gpt');
-  const store = {
-    store: new KeyvFile({ filename: './data/cache.json' }),
-  };
-
-  const clientOptions = {
-    // Warning: This will expose your access token to a third party. Consider the risks before using this.
-    reverseProxyUrl:
-      process.env.CHATGPT_REVERSE_PROXY ?? 'https://ai.fakeopen.com/api/conversation',
-    // Access token from https://chat.openai.com/api/auth/session
-    accessToken: isUserProvided ? key : process.env.CHATGPT_TOKEN ?? null,
-    model: model,
-    debug: false,
-    proxy: process.env.PROXY ?? null,
-    user: userId,
-  };
-
-  const client = new ChatGPTBrowserClient(clientOptions, store);
-  let options = { onProgress, onEventMessage, abortController };
-
-  if (!!parentMessageId && !!conversationId) {
-    options = { ...options, parentMessageId, conversationId };
-  }
-
-  if (parentMessageId === Constants.NO_PARENT) {
-    delete options.conversationId;
-  }
-
-  const res = await client.sendMessage(text, options);
-  return res;
-};
-
-module.exports = { browserClient };

api/app/clients/AnthropicClient.js

@@ -1,14 +1,14 @@
 const Anthropic = require('@anthropic-ai/sdk');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { encoding_for_model: encodingForModel, get_encoding: getEncoding } = require('tiktoken');
 const {
   Constants,
+  ErrorTypes,
   EModelEndpoint,
   anthropicSettings,
   getResponseSender,
   validateVisionModel,
 } = require('librechat-data-provider');
-const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { SplitStreamHandler: _Handler, GraphEvents } = require('@librechat/agents');
 const {
   truncateText,
   formatMessage,
@@ -17,16 +17,30 @@ const {
   parseParamFromPrompt,
   createContextHandlers,
 } = require('./prompts');
+const {
+  getClaudeHeaders,
+  configureReasoning,
+  checkPromptCacheSupport,
+} = require('~/server/services/Endpoints/anthropic/helpers');
 const { getModelMaxTokens, getModelMaxOutputTokens, matchModelName } = require('~/utils');
 const { spendTokens, spendStructuredTokens } = require('~/models/spendTokens');
+const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const 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:';
 
-const tokenizersCache = {};
+class SplitStreamHandler extends _Handler {
+  getDeltaContent(chunk) {
+    return (chunk?.delta?.text ?? chunk?.completion) || '';
+  }
+  getReasoningDelta(chunk) {
+    return chunk?.delta?.thinking || '';
+  }
+}
 
 /** Helper function to introduce a delay before retrying */
 function delayBeforeRetry(attempts, baseDelay = 1000) {
@@ -70,6 +84,8 @@ class AnthropicClient extends BaseClient {
     /** The key for the usage object's output tokens
      * @type {string} */
     this.outputTokensKey = 'output_tokens';
+    /** @type {SplitStreamHandler | undefined} */
+    this.streamHandler;
   }
 
   setOptions(options) {
@@ -99,9 +115,10 @@ class AnthropicClient extends BaseClient {
 
     const modelMatch = matchModelName(this.modelOptions.model, EModelEndpoint.anthropic);
     this.isClaude3 = modelMatch.includes('claude-3');
-    this.isLegacyOutput = !modelMatch.includes('claude-3-5-sonnet');
-    this.supportsCacheControl =
-      this.options.promptCache && this.checkPromptCacheSupport(modelMatch);
+    this.isLegacyOutput = !(
+      /claude-3[-.]5-sonnet/.test(modelMatch) || /claude-3[-.]7/.test(modelMatch)
+    );
+    this.supportsCacheControl = this.options.promptCache && checkPromptCacheSupport(modelMatch);
 
     if (
       this.isLegacyOutput &&
@@ -127,16 +144,21 @@ class AnthropicClient extends BaseClient {
         this.options.endpointType ?? this.options.endpoint,
         this.options.endpointTokenConfig,
       ) ??
-      1500;
+      anthropicSettings.maxOutputTokens.reset(this.modelOptions.model);
     this.maxPromptTokens =
       this.options.maxPromptTokens || this.maxContextTokens - this.maxResponseTokens;
 
-    if (this.maxPromptTokens + this.maxResponseTokens > this.maxContextTokens) {
-      throw new Error(
-        `maxPromptTokens + maxOutputTokens (${this.maxPromptTokens} + ${this.maxResponseTokens} = ${
-          this.maxPromptTokens + this.maxResponseTokens
-        }) must be less than or equal to maxContextTokens (${this.maxContextTokens})`,
-      );
+    const reservedTokens = this.maxPromptTokens + this.maxResponseTokens;
+    if (reservedTokens > this.maxContextTokens) {
+      const info = `Total Possible Tokens + Max Output Tokens must be less than or equal to Max Context Tokens: ${this.maxPromptTokens} (total possible output) + ${this.maxResponseTokens} (max output) = ${reservedTokens}/${this.maxContextTokens} (max context)`;
+      const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
+      logger.warn(info);
+      throw new Error(errorMessage);
+    } else if (this.maxResponseTokens === this.maxContextTokens) {
+      const info = `Max Output Tokens must be less than Max Context Tokens: ${this.maxResponseTokens} (max output) = ${this.maxContextTokens} (max context)`;
+      const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
+      logger.warn(info);
+      throw new Error(errorMessage);
     }
 
     this.sender =
@@ -149,7 +171,6 @@ class AnthropicClient extends BaseClient {
 
     this.startToken = '||>';
     this.endToken = '';
-    this.gptEncoder = this.constructor.getTokenizer('cl100k_base');
 
     return this;
   }
@@ -174,18 +195,9 @@ class AnthropicClient extends BaseClient {
       options.baseURL = this.options.reverseProxyUrl;
     }
 
-    if (
-      this.supportsCacheControl &&
-      requestOptions?.model &&
-      requestOptions.model.includes('claude-3-5-sonnet')
-    ) {
-      options.defaultHeaders = {
-        'anthropic-beta': 'max-tokens-3-5-sonnet-2024-07-15,prompt-caching-2024-07-31',
-      };
-    } else if (this.supportsCacheControl) {
-      options.defaultHeaders = {
-        'anthropic-beta': 'prompt-caching-2024-07-31',
-      };
+    const headers = getClaudeHeaders(requestOptions?.model, this.supportsCacheControl);
+    if (headers) {
+      options.defaultHeaders = headers;
     }
 
     return new Anthropic(options);
@@ -419,7 +431,7 @@ class AnthropicClient extends BaseClient {
     }
 
     let { context: messagesInWindow, remainingContextTokens } =
-      await this.getMessagesWithinTokenLimit(formattedMessages);
+      await this.getMessagesWithinTokenLimit({ messages: formattedMessages });
 
     const tokenCountMap = orderedMessages
       .slice(orderedMessages.length - messagesInWindow.length)
@@ -671,29 +683,48 @@ class AnthropicClient extends BaseClient {
    * @returns {Promise<Anthropic.default.Message | Anthropic.default.Completion>} The response from the Anthropic client.
    */
   async createResponse(client, options, useMessages) {
-    return useMessages ?? this.useMessages
+    return (useMessages ?? this.useMessages)
       ? await client.messages.create(options)
       : await client.completions.create(options);
   }
 
+  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) {
+        /** @type {import('@librechat/agents').MessageContentComplex} */
+        const newContent = [];
+        for (let part of msg.content) {
+          if (part.think != null) {
+            continue;
+          }
+          newContent.push(part);
+        }
+        msg.content = newContent;
+      }
+
+      return msg;
+    };
+  }
+
   /**
-   * @param {string} modelName
-   * @returns {boolean}
+   * @param {string[]} [intermediateReply]
+   * @returns {string}
    */
-  checkPromptCacheSupport(modelName) {
-    const modelMatch = matchModelName(modelName, EModelEndpoint.anthropic);
-    if (modelMatch.includes('claude-3-5-sonnet-latest')) {
-      return false;
+  getStreamText(intermediateReply) {
+    if (!this.streamHandler) {
+      return intermediateReply?.join('') ?? '';
     }
-    if (
-      modelMatch === 'claude-3-5-sonnet' ||
-      modelMatch === 'claude-3-5-haiku' ||
-      modelMatch === 'claude-3-haiku' ||
-      modelMatch === 'claude-3-opus'
-    ) {
-      return true;
-    }
-    return false;
+
+    const reasoningText = this.streamHandler.reasoningTokens.join('');
+
+    const reasoningBlock = reasoningText.length > 0 ? `:::thinking\n${reasoningText}\n:::\n` : '';
+
+    return `${reasoningBlock}${this.streamHandler.tokens.join('')}`;
   }
 
   async sendCompletion(payload, { onProgress, abortController }) {
@@ -713,7 +744,6 @@ class AnthropicClient extends BaseClient {
       user_id: this.user,
     };
 
-    let text = '';
     const {
       stream,
       model,
@@ -724,22 +754,34 @@ class AnthropicClient extends BaseClient {
       topK: top_k,
     } = this.modelOptions;
 
-    const requestOptions = {
+    let requestOptions = {
       model,
       stream: stream || true,
       stop_sequences,
       temperature,
       metadata,
-      top_p,
-      top_k,
     };
 
     if (this.useMessages) {
       requestOptions.messages = payload;
-      requestOptions.max_tokens = maxOutputTokens || legacy.maxOutputTokens.default;
+      requestOptions.max_tokens =
+        maxOutputTokens || anthropicSettings.maxOutputTokens.reset(requestOptions.model);
     } else {
       requestOptions.prompt = payload;
-      requestOptions.max_tokens_to_sample = maxOutputTokens || 1500;
+      requestOptions.max_tokens_to_sample = maxOutputTokens || legacy.maxOutputTokens.default;
+    }
+
+    requestOptions = configureReasoning(requestOptions, {
+      thinking: this.options.thinking,
+      thinkingBudget: this.options.thinkingBudget,
+    });
+
+    if (!/claude-3[-.]7/.test(model)) {
+      requestOptions.top_p = top_p;
+      requestOptions.top_k = top_k;
+    } else if (requestOptions.thinking == null) {
+      requestOptions.topP = top_p;
+      requestOptions.topK = top_k;
     }
 
     if (this.systemMessage && this.supportsCacheControl === true) {
@@ -759,13 +801,17 @@ class AnthropicClient extends BaseClient {
     }
 
     logger.debug('[AnthropicClient]', { ...requestOptions });
+    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),
+      },
+    });
 
-    const handleChunk = (currentChunk) => {
-      if (currentChunk) {
-        text += currentChunk;
-        onProgress(currentChunk);
-      }
-    };
+    let intermediateReply = this.streamHandler.tokens;
 
     const maxRetries = 3;
     const streamRate = this.options.streamRate ?? Constants.DEFAULT_STREAM_RATE;
@@ -786,22 +832,15 @@ class AnthropicClient extends BaseClient {
           });
 
           for await (const completion of response) {
-            // Handle each completion as before
             const type = completion?.type ?? '';
             if (tokenEventTypes.has(type)) {
               logger.debug(`[AnthropicClient] ${type}`, completion);
               this[type] = completion;
             }
-            if (completion?.delta?.text) {
-              handleChunk(completion.delta.text);
-            } else if (completion.completion) {
-              handleChunk(completion.completion);
-            }
-
+            this.streamHandler.handle(completion);
             await sleep(streamRate);
           }
 
-          // Successful processing, exit loop
           break;
         } catch (error) {
           attempts += 1;
@@ -811,6 +850,10 @@ class AnthropicClient extends BaseClient {
 
           if (attempts < maxRetries) {
             await delayBeforeRetry(attempts, 350);
+          } else if (this.streamHandler && this.streamHandler.reasoningTokens.length) {
+            return this.getStreamText();
+          } else if (intermediateReply.length > 0) {
+            return this.getStreamText(intermediateReply);
           } else {
             throw new Error(`Operation failed after ${maxRetries} attempts: ${error.message}`);
           }
@@ -826,8 +869,7 @@ class AnthropicClient extends BaseClient {
     }
 
     await processResponse.bind(this)();
-
-    return text.trim();
+    return this.getStreamText(intermediateReply);
   }
 
   getSaveOptions() {
@@ -837,6 +879,8 @@ class AnthropicClient extends BaseClient {
       promptPrefix: this.options.promptPrefix,
       modelLabel: this.options.modelLabel,
       promptCache: this.options.promptCache,
+      thinking: this.options.thinking,
+      thinkingBudget: this.options.thinkingBudget,
       resendFiles: this.options.resendFiles,
       iconURL: this.options.iconURL,
       greeting: this.options.greeting,
@@ -849,22 +893,18 @@ class AnthropicClient extends BaseClient {
     logger.debug('AnthropicClient doesn\'t use getBuildMessagesOptions');
   }
 
-  static getTokenizer(encoding, isModelName = false, extendSpecialTokens = {}) {
-    if (tokenizersCache[encoding]) {
-      return tokenizersCache[encoding];
-    }
-    let tokenizer;
-    if (isModelName) {
-      tokenizer = encodingForModel(encoding, extendSpecialTokens);
-    } else {
-      tokenizer = getEncoding(encoding, extendSpecialTokens);
-    }
-    tokenizersCache[encoding] = tokenizer;
-    return tokenizer;
+  getEncoding() {
+    return 'cl100k_base';
   }
 
+  /**
+   * Returns the token count of a given text. It also checks and resets the tokenizers if necessary.
+   * @param {string} text - The text to get the token count for.
+   * @returns {number} The token count of the given text.
+   */
   getTokenCount(text) {
-    return this.gptEncoder.encode(text, 'all').length;
+    const encoding = this.getEncoding();
+    return Tokenizer.getTokenCount(text, encoding);
   }
 
   /**

api/app/clients/BaseClient.js

@@ -4,16 +4,17 @@ const {
   supportsBalanceCheck,
   isAgentsEndpoint,
   isParamEndpoint,
+  EModelEndpoint,
+  ContentTypes,
+  excludedKeys,
   ErrorTypes,
   Constants,
-  CacheKeys,
-  Time,
 } = require('librechat-data-provider');
-const { getMessages, saveMessage, updateMessage, saveConvo } = require('~/models');
-const { addSpaceIfNeeded, isEnabled } = require('~/server/utils');
-const checkBalance = require('~/models/checkBalance');
+const { getMessages, saveMessage, updateMessage, saveConvo, getConvo } = require('~/models');
+const { checkBalance } = require('~/models/balanceMethods');
+const { truncateToolCallOutputs } = require('./prompts');
+const { addSpaceIfNeeded } = require('~/server/utils');
 const { getFiles } = require('~/models/File');
-const { getLogStores } = require('~/cache');
 const TextStream = require('./TextStream');
 const { logger } = require('~/config');
 
@@ -52,6 +53,18 @@ class BaseClient {
     this.outputTokensKey = 'completion_tokens';
     /** @type {Set<string>} */
     this.savedMessageIds = new Set();
+    /**
+     * Flag to determine if the client re-submitted the latest assistant message.
+     * @type {boolean | undefined} */
+    this.continued;
+    /**
+     * Flag to determine if the client has already fetched the conversation while saving new messages.
+     * @type {boolean | undefined} */
+    this.fetchedConvo;
+    /** @type {TMessage[]} */
+    this.currentMessages = [];
+    /** @type {import('librechat-data-provider').VisionModes | undefined} */
+    this.visionMode;
   }
 
   setOptions() {
@@ -95,7 +108,7 @@ class BaseClient {
    * @returns {number}
    */
   getTokenCountForResponse(responseMessage) {
-    logger.debug('`[BaseClient] recordTokenUsage` not implemented.', responseMessage);
+    logger.debug('[BaseClient] `recordTokenUsage` not implemented.', responseMessage);
   }
 
   /**
@@ -106,7 +119,7 @@ class BaseClient {
    * @returns {Promise<void>}
    */
   async recordTokenUsage({ promptTokens, completionTokens }) {
-    logger.debug('`[BaseClient] recordTokenUsage` not implemented.', {
+    logger.debug('[BaseClient] `recordTokenUsage` not implemented.', {
       promptTokens,
       completionTokens,
     });
@@ -262,17 +275,24 @@ class BaseClient {
   /**
    * Adds instructions to the messages array. If the instructions object is empty or undefined,
    * the original messages array is returned. Otherwise, the instructions are added to the messages
-   * array, preserving the last message at the end.
+   * array either at the beginning (default) or preserving the last message at the end.
    *
    * @param {Array} messages - An array of messages.
    * @param {Object} instructions - An object containing instructions to be added to the messages.
+   * @param {boolean} [beforeLast=false] - If true, adds instructions before the last message; if false, adds at the beginning.
    * @returns {Array} An array containing messages and instructions, or the original messages if instructions are empty.
    */
-  addInstructions(messages, instructions) {
-    const payload = [];
+  addInstructions(messages, instructions, beforeLast = false) {
     if (!instructions || Object.keys(instructions).length === 0) {
       return messages;
     }
+
+    if (!beforeLast) {
+      return [instructions, ...messages];
+    }
+
+    // Legacy behavior: add instructions before the last message
+    const payload = [];
     if (messages.length > 1) {
       payload.push(...messages.slice(0, -1));
     }
@@ -287,6 +307,9 @@ class BaseClient {
   }
 
   async handleTokenCountMap(tokenCountMap) {
+    if (this.clientName === EModelEndpoint.agents) {
+      return;
+    }
     if (this.currentMessages.length === 0) {
       return;
     }
@@ -335,25 +358,35 @@ class BaseClient {
    * If the token limit would be exceeded by adding a message, that message is not added to the context and remains in the original array.
    * The method uses `push` and `pop` operations for efficient array manipulation, and reverses the context array at the end to maintain the original order of the messages.
    *
-   * @param {Array} _messages - An array of messages, each with a `tokenCount` property. The messages should be ordered from oldest to newest.
-   * @param {number} [maxContextTokens] - The max number of tokens allowed in the context. If not provided, defaults to `this.maxContextTokens`.
-   * @returns {Object} An object with four properties: `context`, `summaryIndex`, `remainingContextTokens`, and `messagesToRefine`.
+   * @param {Object} params
+   * @param {TMessage[]} params.messages - An array of messages, each with a `tokenCount` property. The messages should be ordered from oldest to newest.
+   * @param {number} [params.maxContextTokens] - The max number of tokens allowed in the context. If not provided, defaults to `this.maxContextTokens`.
+   * @param {{ role: 'system', content: text, tokenCount: number }} [params.instructions] - Instructions already added to the context at index 0.
+   * @returns {Promise<{
+   *  context: TMessage[],
+   *  remainingContextTokens: number,
+   *  messagesToRefine: TMessage[],
+   * }>} An object with three properties: `context`, `remainingContextTokens`, and `messagesToRefine`.
    *    `context` is an array of messages that fit within the token limit.
-   *    `summaryIndex` is the index of the first message in the `messagesToRefine` array.
    *    `remainingContextTokens` is the number of tokens remaining within the limit after adding the messages to the context.
    *    `messagesToRefine` is an array of messages that were not added to the context because they would have exceeded the token limit.
    */
-  async getMessagesWithinTokenLimit(_messages, maxContextTokens) {
+  async getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, instructions }) {
     // Every reply is primed with <|start|>assistant<|message|>, so we
     // start with 3 tokens for the label after all messages have been counted.
     let currentTokenCount = 3;
-    let summaryIndex = -1;
-    let remainingContextTokens = maxContextTokens ?? this.maxContextTokens;
+    const instructionsTokenCount = instructions?.tokenCount ?? 0;
+    let remainingContextTokens =
+      (maxContextTokens ?? this.maxContextTokens) - instructionsTokenCount;
     const messages = [..._messages];
 
     const context = [];
+
     if (currentTokenCount < remainingContextTokens) {
       while (messages.length > 0 && currentTokenCount < remainingContextTokens) {
+        if (messages.length === 1 && instructions) {
+          break;
+        }
         const poppedMessage = messages.pop();
         const { tokenCount } = poppedMessage;
 
@@ -367,15 +400,18 @@ class BaseClient {
       }
     }
 
+    if (instructions) {
+      context.push(_messages[0]);
+      messages.shift();
+    }
+
     const prunedMemory = messages;
-    summaryIndex = prunedMemory.length - 1;
     remainingContextTokens -= currentTokenCount;
 
     return {
       context: context.reverse(),
       remainingContextTokens,
       messagesToRefine: prunedMemory,
-      summaryIndex,
     };
   }
 
@@ -391,12 +427,38 @@ class BaseClient {
     if (instructions) {
       ({ tokenCount, ..._instructions } = instructions);
     }
+
     _instructions && logger.debug('[BaseClient] instructions tokenCount: ' + tokenCount);
-    let payload = this.addInstructions(formattedMessages, _instructions);
+    if (tokenCount && tokenCount > this.maxContextTokens) {
+      const info = `${tokenCount} / ${this.maxContextTokens}`;
+      const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
+      logger.warn(`Instructions token count exceeds max token count (${info}).`);
+      throw new Error(errorMessage);
+    }
+
+    if (this.clientName === EModelEndpoint.agents) {
+      const { dbMessages, editedIndices } = truncateToolCallOutputs(
+        orderedMessages,
+        this.maxContextTokens,
+        this.getTokenCountForMessage.bind(this),
+      );
+
+      if (editedIndices.length > 0) {
+        logger.debug('[BaseClient] Truncated tool call outputs:', editedIndices);
+        for (const index of editedIndices) {
+          formattedMessages[index].content = dbMessages[index].content;
+        }
+        orderedMessages = dbMessages;
+      }
+    }
+
     let orderedWithInstructions = this.addInstructions(orderedMessages, instructions);
 
-    let { context, remainingContextTokens, messagesToRefine, summaryIndex } =
-      await this.getMessagesWithinTokenLimit(orderedWithInstructions);
+    let { context, remainingContextTokens, messagesToRefine } =
+      await this.getMessagesWithinTokenLimit({
+        messages: orderedWithInstructions,
+        instructions,
+      });
 
     logger.debug('[BaseClient] Context Count (1/2)', {
       remainingContextTokens,
@@ -408,7 +470,9 @@ class BaseClient {
     let { shouldSummarize } = this;
 
     // Calculate the difference in length to determine how many messages were discarded if any
-    const { length } = payload;
+    let payload;
+    let { length } = formattedMessages;
+    length += instructions != null ? 1 : 0;
     const diff = length - context.length;
     const firstMessage = orderedWithInstructions[0];
     const usePrevSummary =
@@ -418,18 +482,31 @@ class BaseClient {
       this.previous_summary.messageId === firstMessage.messageId;
 
     if (diff > 0) {
-      payload = payload.slice(diff);
+      payload = formattedMessages.slice(diff);
       logger.debug(
         `[BaseClient] Difference between original payload (${length}) and context (${context.length}): ${diff}`,
       );
     }
 
+    payload = this.addInstructions(payload ?? formattedMessages, _instructions);
+
     const latestMessage = orderedWithInstructions[orderedWithInstructions.length - 1];
     if (payload.length === 0 && !shouldSummarize && latestMessage) {
       const info = `${latestMessage.tokenCount} / ${this.maxContextTokens}`;
       const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
       logger.warn(`Prompt token count exceeds max token count (${info}).`);
       throw new Error(errorMessage);
+    } else if (
+      _instructions &&
+      payload.length === 1 &&
+      payload[0].content === _instructions.content
+    ) {
+      const info = `${tokenCount + 3} / ${this.maxContextTokens}`;
+      const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
+      logger.warn(
+        `Including instructions, the prompt token count exceeds remaining max token count (${info}).`,
+      );
+      throw new Error(errorMessage);
     }
 
     if (usePrevSummary) {
@@ -447,7 +524,7 @@ class BaseClient {
     }
 
     // Make sure to only continue summarization logic if the summary message was generated
-    shouldSummarize = summaryMessage && shouldSummarize;
+    shouldSummarize = summaryMessage != null && shouldSummarize === true;
 
     logger.debug('[BaseClient] Context Count (2/2)', {
       remainingContextTokens,
@@ -457,17 +534,18 @@ class BaseClient {
     /** @type {Record<string, number> | undefined} */
     let tokenCountMap;
     if (buildTokenMap) {
-      tokenCountMap = orderedWithInstructions.reduce((map, message, index) => {
+      const currentPayload = shouldSummarize ? orderedWithInstructions : context;
+      tokenCountMap = currentPayload.reduce((map, message, index) => {
         const { messageId } = message;
         if (!messageId) {
           return map;
         }
 
-        if (shouldSummarize && index === summaryIndex && !usePrevSummary) {
+        if (shouldSummarize && index === messagesToRefine.length - 1 && !usePrevSummary) {
           map.summaryMessage = { ...summaryMessage, messageId, tokenCount: summaryTokenCount };
         }
 
-        map[messageId] = orderedWithInstructions[index].tokenCount;
+        map[messageId] = currentPayload[index].tokenCount;
         return map;
       }, {});
     }
@@ -518,6 +596,7 @@ class BaseClient {
       } else {
         latestMessage.text = generation;
       }
+      this.continued = true;
     } else {
       this.currentMessages.push(userMessage);
     }
@@ -555,8 +634,9 @@ class BaseClient {
       }
     }
 
+    const balance = this.options.req?.app?.locals?.balance;
     if (
-      isEnabled(process.env.CHECK_BALANCE) &&
+      balance?.enabled &&
       supportsBalanceCheck[this.options.endpointType ?? this.options.endpoint]
     ) {
       await checkBalance({
@@ -625,7 +705,7 @@ class BaseClient {
         await this.updateUserMessageTokenCount({ usage, tokenCountMap, userMessage, opts });
       } else {
         responseMessage.tokenCount = this.getTokenCountForResponse(responseMessage);
-        completionTokens = this.getTokenCount(completion);
+        completionTokens = responseMessage.tokenCount;
       }
 
       await this.recordTokenUsage({ promptTokens, completionTokens, usage });
@@ -649,15 +729,6 @@ class BaseClient {
 
     this.responsePromise = this.saveMessageToDatabase(responseMessage, saveOptions, user);
     this.savedMessageIds.add(responseMessage.messageId);
-    const messageCache = getLogStores(CacheKeys.MESSAGES);
-    messageCache.set(
-      responseMessageId,
-      {
-        text: responseMessage.text,
-        complete: true,
-      },
-      Time.FIVE_MINUTES,
-    );
     delete responseMessage.tokenCount;
     return responseMessage;
   }
@@ -795,16 +866,40 @@ class BaseClient {
       return { message: savedMessage };
     }
 
-    const conversation = await saveConvo(
-      this.options.req,
-      {
-        conversationId: message.conversationId,
-        endpoint: this.options.endpoint,
-        endpointType: this.options.endpointType,
-        ...endpointOptions,
-      },
-      { context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo' },
-    );
+    const fieldsToKeep = {
+      conversationId: message.conversationId,
+      endpoint: this.options.endpoint,
+      endpointType: this.options.endpointType,
+      ...endpointOptions,
+    };
+
+    const existingConvo =
+      this.fetchedConvo === true
+        ? null
+        : await getConvo(this.options.req?.user?.id, message.conversationId);
+
+    const unsetFields = {};
+    const exceptions = new Set(['spec', 'iconURL']);
+    if (existingConvo != null) {
+      this.fetchedConvo = true;
+      for (const key in existingConvo) {
+        if (!key) {
+          continue;
+        }
+        if (excludedKeys.has(key) && !exceptions.has(key)) {
+          continue;
+        }
+
+        if (endpointOptions?.[key] === undefined) {
+          unsetFields[key] = 1;
+        }
+      }
+    }
+
+    const conversation = await saveConvo(this.options.req, fieldsToKeep, {
+      context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo',
+      unsetFields,
+    });
 
     return { message: savedMessage, conversation };
   }
@@ -925,7 +1020,31 @@ class BaseClient {
     const processValue = (value) => {
       if (Array.isArray(value)) {
         for (let item of value) {
-          if (!item || !item.type || item.type === 'image_url') {
+          if (
+            !item ||
+            !item.type ||
+            item.type === ContentTypes.THINK ||
+            item.type === ContentTypes.ERROR ||
+            item.type === ContentTypes.IMAGE_URL
+          ) {
+            continue;
+          }
+
+          if (item.type === ContentTypes.TOOL_CALL && item.tool_call != null) {
+            const toolName = item.tool_call?.name || '';
+            if (toolName != null && toolName && typeof toolName === 'string') {
+              numTokens += this.getTokenCount(toolName);
+            }
+
+            const args = item.tool_call?.args || '';
+            if (args != null && args && typeof args === 'string') {
+              numTokens += this.getTokenCount(args);
+            }
+
+            const output = item.tool_call?.output || '';
+            if (output != null && output && typeof output === 'string') {
+              numTokens += this.getTokenCount(output);
+            }
             continue;
           }
 
@@ -1007,11 +1126,15 @@ class BaseClient {
         return message;
       }
 
-      const files = await getFiles({
-        file_id: { $in: fileIds },
-      });
+      const files = await getFiles(
+        {
+          file_id: { $in: fileIds },
+        },
+        {},
+        {},
+      );
 
-      await this.addImageURLs(message, files);
+      await this.addImageURLs(message, files, this.visionMode);
 
       this.message_file_map[message.messageId] = files;
       return message;

api/app/clients/ChatGPTClient.js

@@ -13,7 +13,6 @@ const {
 const { extractBaseURL, constructAzureURL, genAzureChatCompletion } = require('~/utils');
 const { createContextHandlers } = require('./prompts');
 const { createCoherePayload } = require('./llm');
-const { Agent, ProxyAgent } = require('undici');
 const BaseClient = require('./BaseClient');
 const { logger } = require('~/config');
 
@@ -186,10 +185,6 @@ class ChatGPTClient extends BaseClient {
       headers: {
         'Content-Type': 'application/json',
       },
-      dispatcher: new Agent({
-        bodyTimeout: 0,
-        headersTimeout: 0,
-      }),
     };
 
     if (this.isVisionModel) {
@@ -275,10 +270,6 @@ class ChatGPTClient extends BaseClient {
       opts.headers['X-Title'] = 'LibreChat';
     }
 
-    if (this.options.proxy) {
-      opts.dispatcher = new ProxyAgent(this.options.proxy);
-    }
-
     /* hacky fixes for Mistral AI API:
       - Re-orders system message to the top of the messages payload, as not allowed anywhere else
       - If there is only one message and it's a system message, change the role to user

api/app/clients/GoogleClient.js

@@ -1,22 +1,25 @@
 const { google } = require('googleapis');
-const { Agent, ProxyAgent } = require('undici');
+const { concat } = require('@langchain/core/utils/stream');
 const { ChatVertexAI } = require('@langchain/google-vertexai');
-const { GoogleVertexAI } = require('@langchain/google-vertexai');
-const { ChatGoogleVertexAI } = require('@langchain/google-vertexai');
 const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
 const { GoogleGenerativeAI: GenAI } = require('@google/generative-ai');
-const { AIMessage, HumanMessage, SystemMessage } = require('@langchain/core/messages');
-const { encoding_for_model: encodingForModel, get_encoding: getEncoding } = require('tiktoken');
+const { HumanMessage, SystemMessage } = require('@langchain/core/messages');
 const {
+  googleGenConfigSchema,
   validateVisionModel,
   getResponseSender,
   endpointSettings,
   EModelEndpoint,
+  ContentTypes,
   VisionModes,
+  ErrorTypes,
   Constants,
   AuthKeys,
 } = require('librechat-data-provider');
+const { getSafetySettings } = require('~/server/services/Endpoints/google/llm');
 const { encodeAndFormat } = require('~/server/services/Files/images');
+const Tokenizer = require('~/server/services/Tokenizer');
+const { spendTokens } = require('~/models/spendTokens');
 const { getModelMaxTokens } = require('~/utils');
 const { sleep } = require('~/server/utils');
 const { logger } = require('~/config');
@@ -31,7 +34,6 @@ const BaseClient = require('./BaseClient');
 const loc = process.env.GOOGLE_LOC || 'us-central1';
 const publisher = 'google';
 const endpointPrefix = `${loc}-aiplatform.googleapis.com`;
-const tokenizersCache = {};
 
 const settings = endpointSettings[EModelEndpoint.google];
 const EXCLUDED_GENAI_MODELS = /gemini-(?:1\.0|1-0|pro)/;
@@ -49,10 +51,11 @@ class GoogleClient extends BaseClient {
 
     const serviceKey = creds[AuthKeys.GOOGLE_SERVICE_KEY] ?? {};
     this.serviceKey =
-      serviceKey && typeof serviceKey === 'string' ? JSON.parse(serviceKey) : serviceKey ?? {};
+      serviceKey && typeof serviceKey === 'string' ? JSON.parse(serviceKey) : (serviceKey ?? {});
+    /** @type {string | null | undefined} */
+    this.project_id = this.serviceKey.project_id;
     this.client_email = this.serviceKey.client_email;
     this.private_key = this.serviceKey.private_key;
-    this.project_id = this.serviceKey.project_id;
     this.access_token = null;
 
     this.apiKey = creds[AuthKeys.GOOGLE_API_KEY];
@@ -61,6 +64,17 @@ class GoogleClient extends BaseClient {
 
     this.authHeader = options.authHeader;
 
+    /** @type {UsageMetadata | undefined} */
+    this.usage;
+    /** The key for the usage object's input tokens
+     * @type {string} */
+    this.inputTokensKey = 'input_tokens';
+    /** The key for the usage object's output tokens
+     * @type {string} */
+    this.outputTokensKey = 'output_tokens';
+    this.visionMode = VisionModes.generative;
+    /** @type {string} */
+    this.systemMessage;
     if (options.skipSetOptions) {
       return;
     }
@@ -120,22 +134,13 @@ class GoogleClient extends BaseClient {
       this.options = options;
     }
 
-    this.options.examples = (this.options.examples ?? [])
-      .filter((ex) => ex)
-      .filter((obj) => obj.input.content !== '' && obj.output.content !== '');
-
     this.modelOptions = this.options.modelOptions || {};
 
     this.options.attachments?.then((attachments) => this.checkVisionRequest(attachments));
 
     /** @type {boolean} Whether using a "GenerativeAI" Model */
-    this.isGenerativeModel = this.modelOptions.model.includes('gemini');
-    const { isGenerativeModel } = this;
-    this.isChatModel = !isGenerativeModel && this.modelOptions.model.includes('chat');
-    const { isChatModel } = this;
-    this.isTextModel =
-      !isGenerativeModel && !isChatModel && /code|text/.test(this.modelOptions.model);
-    const { isTextModel } = this;
+    this.isGenerativeModel =
+      this.modelOptions.model.includes('gemini') || this.modelOptions.model.includes('learnlm');
 
     this.maxContextTokens =
       this.options.maxContextTokens ??
@@ -171,50 +176,18 @@ class GoogleClient extends BaseClient {
     this.userLabel = this.options.userLabel || 'User';
     this.modelLabel = this.options.modelLabel || 'Assistant';
 
-    if (isChatModel || isGenerativeModel) {
-      // Use these faux tokens to help the AI understand the context since we are building the chat log ourselves.
-      // Trying to use "<|im_start|>" causes the AI to still generate "<" or "<|" at the end sometimes for some reason,
-      // without tripping the stop sequences, so I'm using "||>" instead.
-      this.startToken = '||>';
-      this.endToken = '';
-      this.gptEncoder = this.constructor.getTokenizer('cl100k_base');
-    } else if (isTextModel) {
-      this.startToken = '||>';
-      this.endToken = '';
-      this.gptEncoder = this.constructor.getTokenizer('text-davinci-003', true, {
-        '<|im_start|>': 100264,
-        '<|im_end|>': 100265,
-      });
-    } else {
-      // Previously I was trying to use "<|endoftext|>" but there seems to be some bug with OpenAI's token counting
-      // system that causes only the first "<|endoftext|>" to be counted as 1 token, and the rest are not treated
-      // as a single token. So we're using this instead.
-      this.startToken = '||>';
-      this.endToken = '';
-      try {
-        this.gptEncoder = this.constructor.getTokenizer(this.modelOptions.model, true);
-      } catch {
-        this.gptEncoder = this.constructor.getTokenizer('text-davinci-003', true);
-      }
-    }
-
-    if (!this.modelOptions.stop) {
-      const stopTokens = [this.startToken];
-      if (this.endToken && this.endToken !== this.startToken) {
-        stopTokens.push(this.endToken);
-      }
-      stopTokens.push(`\n${this.userLabel}:`);
-      stopTokens.push('<|diff_marker|>');
-      // I chose not to do one for `modelLabel` because I've never seen it happen
-      this.modelOptions.stop = stopTokens;
-    }
-
     if (this.options.reverseProxyUrl) {
       this.completionsUrl = this.options.reverseProxyUrl;
     } else {
       this.completionsUrl = this.constructUrl();
     }
 
+    let promptPrefix = (this.options.promptPrefix ?? '').trim();
+    if (typeof this.options.artifactsPrompt === 'string' && this.options.artifactsPrompt) {
+      promptPrefix = `${promptPrefix ?? ''}\n${this.options.artifactsPrompt}`.trim();
+    }
+    this.systemMessage = promptPrefix;
+    this.initializeClient();
     return this;
   }
 
@@ -225,7 +198,11 @@ class GoogleClient extends BaseClient {
    */
   checkVisionRequest(attachments) {
     /* Validation vision request */
-    this.defaultVisionModel = this.options.visionModel ?? 'gemini-pro-vision';
+    this.defaultVisionModel =
+      this.options.visionModel ??
+      (!EXCLUDED_GENAI_MODELS.test(this.modelOptions.model)
+        ? this.modelOptions.model
+        : 'gemini-pro-vision');
     const availableModels = this.options.modelsConfig?.[EModelEndpoint.google];
     this.isVisionModel = validateVisionModel({ model: this.modelOptions.model, availableModels });
 
@@ -246,10 +223,29 @@ class GoogleClient extends BaseClient {
   }
 
   formatMessages() {
-    return ((message) => ({
-      author: message?.author ?? (message.isCreatedByUser ? this.userLabel : this.modelLabel),
-      content: message?.content ?? message.text,
-    })).bind(this);
+    return ((message) => {
+      const msg = {
+        author: message?.author ?? (message.isCreatedByUser ? this.userLabel : this.modelLabel),
+        content: message?.content ?? message.text,
+      };
+
+      if (!message.image_urls?.length) {
+        return msg;
+      }
+
+      msg.content = (
+        !Array.isArray(msg.content)
+          ? [
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: msg.content,
+            },
+          ]
+          : msg.content
+      ).concat(message.image_urls);
+
+      return msg;
+    }).bind(this);
   }
 
   /**
@@ -324,7 +320,7 @@ class GoogleClient extends BaseClient {
       }
 
       this.augmentedPrompt = await this.contextHandlers.createContext();
-      this.options.promptPrefix = this.augmentedPrompt + this.options.promptPrefix;
+      this.systemMessage = this.augmentedPrompt + this.systemMessage;
     }
   }
 
@@ -347,7 +343,6 @@ class GoogleClient extends BaseClient {
           messages: [new HumanMessage(formatMessage({ message: latestMessage }))],
         },
       ],
-      parameters: this.modelOptions,
     };
     return { prompt: payload };
   }
@@ -363,23 +358,58 @@ class GoogleClient extends BaseClient {
     return { prompt: formattedMessages };
   }
 
-  async buildMessages(messages = [], parentMessageId) {
+  /**
+   * @param {TMessage[]} [messages=[]]
+   * @param {string} [parentMessageId]
+   */
+  async buildMessages(_messages = [], parentMessageId) {
     if (!this.isGenerativeModel && !this.project_id) {
-      throw new Error(
-        '[GoogleClient] a Service Account JSON Key is required for PaLM 2 and Codey models (Vertex AI)',
-      );
+      throw new Error('[GoogleClient] PaLM 2 and Codey models are no longer supported.');
     }
 
+    if (this.systemMessage) {
+      const instructionsTokenCount = this.getTokenCount(this.systemMessage);
+
+      this.maxContextTokens = this.maxContextTokens - instructionsTokenCount;
+      if (this.maxContextTokens < 0) {
+        const info = `${instructionsTokenCount} / ${this.maxContextTokens}`;
+        const errorMessage = `{ "type": "${ErrorTypes.INPUT_LENGTH}", "info": "${info}" }`;
+        logger.warn(`Instructions token count exceeds max context (${info}).`);
+        throw new Error(errorMessage);
+      }
+    }
+
+    for (let i = 0; i < _messages.length; i++) {
+      const message = _messages[i];
+      if (!message.tokenCount) {
+        _messages[i].tokenCount = this.getTokenCountForMessage({
+          role: message.isCreatedByUser ? 'user' : 'assistant',
+          content: message.content ?? message.text,
+        });
+      }
+    }
+
+    const {
+      payload: messages,
+      tokenCountMap,
+      promptTokens,
+    } = await this.handleContextStrategy({
+      orderedMessages: _messages,
+      formattedMessages: _messages,
+    });
+
     if (!this.project_id && !EXCLUDED_GENAI_MODELS.test(this.modelOptions.model)) {
-      return await this.buildGenerativeMessages(messages);
+      const result = await this.buildGenerativeMessages(messages);
+      result.tokenCountMap = tokenCountMap;
+      result.promptTokens = promptTokens;
+      return result;
     }
 
     if (this.options.attachments && this.isGenerativeModel) {
-      return this.buildVisionMessages(messages, parentMessageId);
-    }
-
-    if (this.isTextModel) {
-      return this.buildMessagesPrompt(messages, parentMessageId);
+      const result = this.buildVisionMessages(messages, parentMessageId);
+      result.tokenCountMap = tokenCountMap;
+      result.promptTokens = promptTokens;
+      return result;
     }
 
     let payload = {
@@ -391,25 +421,14 @@ class GoogleClient extends BaseClient {
             .map((message) => formatMessage({ message, langChain: true })),
         },
       ],
-      parameters: this.modelOptions,
     };
 
-    let promptPrefix = (this.options.promptPrefix ?? '').trim();
-    if (typeof this.options.artifactsPrompt === 'string' && this.options.artifactsPrompt) {
-      promptPrefix = `${promptPrefix ?? ''}\n${this.options.artifactsPrompt}`.trim();
-    }
-
-    if (promptPrefix) {
-      payload.instances[0].context = promptPrefix;
-    }
-
-    if (this.options.examples.length > 0) {
-      payload.instances[0].examples = this.options.examples;
+    if (this.systemMessage) {
+      payload.instances[0].context = this.systemMessage;
     }
 
     logger.debug('[GoogleClient] buildMessages', payload);
-
-    return { prompt: payload };
+    return { prompt: payload, tokenCountMap, promptTokens };
   }
 
   async buildMessagesPrompt(messages, parentMessageId) {
@@ -423,10 +442,7 @@ class GoogleClient extends BaseClient {
       parentMessageId,
     });
 
-    const formattedMessages = orderedMessages.map((message) => ({
-      author: message.isCreatedByUser ? this.userLabel : this.modelLabel,
-      content: message?.content ?? message.text,
-    }));
+    const formattedMessages = orderedMessages.map(this.formatMessages());
 
     let lastAuthor = '';
     let groupedMessages = [];
@@ -454,17 +470,7 @@ class GoogleClient extends BaseClient {
       identityPrefix = `${identityPrefix}\nYou are ${this.options.modelLabel}`;
     }
 
-    let promptPrefix = (this.options.promptPrefix ?? '').trim();
-    if (typeof this.options.artifactsPrompt === 'string' && this.options.artifactsPrompt) {
-      promptPrefix = `${promptPrefix ?? ''}\n${this.options.artifactsPrompt}`.trim();
-    }
-    if (promptPrefix) {
-      // If the prompt prefix doesn't end with the end token, add it.
-      if (!promptPrefix.endsWith(`${this.endToken}`)) {
-        promptPrefix = `${promptPrefix.trim()}${this.endToken}\n\n`;
-      }
-      promptPrefix = `\nContext:\n${promptPrefix}`;
-    }
+    let promptPrefix = (this.systemMessage ?? '').trim();
 
     if (identityPrefix) {
       promptPrefix = `${identityPrefix}${promptPrefix}`;
@@ -501,7 +507,7 @@ class GoogleClient extends BaseClient {
           isCreatedByUser || !isEdited
             ? `\n\n${message.author}:`
             : `${promptPrefix}\n\n${message.author}:`;
-        const messageString = `${messagePrefix}\n${message.content}${this.endToken}\n`;
+        const messageString = `${messagePrefix}\n${message.content}\n`;
         let newPromptBody = `${messageString}${promptBody}`;
 
         context.unshift(message);
@@ -567,34 +573,6 @@ class GoogleClient extends BaseClient {
     return { prompt, context };
   }
 
-  async _getCompletion(payload, abortController = null) {
-    if (!abortController) {
-      abortController = new AbortController();
-    }
-    const { debug } = this.options;
-    const url = this.completionsUrl;
-    if (debug) {
-      logger.debug('GoogleClient _getCompletion', { url, payload });
-    }
-    const opts = {
-      method: 'POST',
-      agent: new Agent({
-        bodyTimeout: 0,
-        headersTimeout: 0,
-      }),
-      signal: abortController.signal,
-    };
-
-    if (this.options.proxy) {
-      opts.agent = new ProxyAgent(this.options.proxy);
-    }
-
-    const client = await this.getClient();
-    const res = await client.request({ url, method: 'POST', data: payload });
-    logger.debug('GoogleClient _getCompletion', { res });
-    return res.data;
-  }
-
   createLLM(clientOptions) {
     const model = clientOptions.modelName ?? clientOptions.model;
     clientOptions.location = loc;
@@ -613,33 +591,30 @@ class GoogleClient extends BaseClient {
       }
     }
 
-    if (this.project_id && this.isTextModel) {
-      logger.debug('Creating Google VertexAI client');
-      return new GoogleVertexAI(clientOptions);
-    } else if (this.project_id && this.isChatModel) {
-      logger.debug('Creating Chat Google VertexAI client');
-      return new ChatGoogleVertexAI(clientOptions);
-    } else if (this.project_id) {
+    if (this.project_id != null) {
       logger.debug('Creating VertexAI client');
-      return new ChatVertexAI(clientOptions);
+      this.visionMode = undefined;
+      clientOptions.streaming = true;
+      const client = new ChatVertexAI(clientOptions);
+      client.temperature = clientOptions.temperature;
+      client.topP = clientOptions.topP;
+      client.topK = clientOptions.topK;
+      client.topLogprobs = clientOptions.topLogprobs;
+      client.frequencyPenalty = clientOptions.frequencyPenalty;
+      client.presencePenalty = clientOptions.presencePenalty;
+      client.maxOutputTokens = clientOptions.maxOutputTokens;
+      return client;
     } else if (!EXCLUDED_GENAI_MODELS.test(model)) {
       logger.debug('Creating GenAI client');
-      return new GenAI(this.apiKey).getGenerativeModel({ ...clientOptions, model }, requestOptions);
+      return new GenAI(this.apiKey).getGenerativeModel({ model }, requestOptions);
     }
 
     logger.debug('Creating Chat Google Generative AI client');
     return new ChatGoogleGenerativeAI({ ...clientOptions, apiKey: this.apiKey });
   }
 
-  async getCompletion(_payload, options = {}) {
-    const { parameters, instances } = _payload;
-    const { onProgress, abortController } = options;
-    const streamRate = this.options.streamRate ?? Constants.DEFAULT_STREAM_RATE;
-    const { messages: _messages, context, examples: _examples } = instances?.[0] ?? {};
-
-    let examples;
-
-    let clientOptions = { ...parameters, maxRetries: 2 };
+  initializeClient() {
+    let clientOptions = { ...this.modelOptions };
 
     if (this.project_id) {
       clientOptions['authOptions'] = {
@@ -650,184 +625,249 @@ class GoogleClient extends BaseClient {
       };
     }
 
-    if (!parameters) {
-      clientOptions = { ...clientOptions, ...this.modelOptions };
-    }
-
     if (this.isGenerativeModel && !this.project_id) {
       clientOptions.modelName = clientOptions.model;
       delete clientOptions.model;
     }
 
-    if (_examples && _examples.length) {
-      examples = _examples
-        .map((ex) => {
-          const { input, output } = ex;
-          if (!input || !output) {
-            return undefined;
-          }
-          return {
-            input: new HumanMessage(input.content),
-            output: new AIMessage(output.content),
-          };
-        })
-        .filter((ex) => ex);
+    this.client = this.createLLM(clientOptions);
+    return this.client;
+  }
 
-      clientOptions.examples = examples;
-    }
-
-    const model = this.createLLM(clientOptions);
+  async getCompletion(_payload, options = {}) {
+    const { onProgress, abortController } = options;
+    const safetySettings = getSafetySettings(this.modelOptions.model);
+    const streamRate = this.options.streamRate ?? Constants.DEFAULT_STREAM_RATE;
+    const modelName = this.modelOptions.modelName ?? this.modelOptions.model ?? '';
 
     let reply = '';
-    const messages = this.isTextModel ? _payload.trim() : _messages;
-
-    if (!this.isVisionModel && context && messages?.length > 0) {
-      messages.unshift(new SystemMessage(context));
-    }
-
-    const modelName = clientOptions.modelName ?? clientOptions.model ?? '';
-    if (!EXCLUDED_GENAI_MODELS.test(modelName) && !this.project_id) {
-      const client = model;
-      const requestOptions = {
-        contents: _payload,
-      };
-
-      let promptPrefix = (this.options.promptPrefix ?? '').trim();
-      if (typeof this.options.artifactsPrompt === 'string' && this.options.artifactsPrompt) {
-        promptPrefix = `${promptPrefix ?? ''}\n${this.options.artifactsPrompt}`.trim();
-      }
-
-      if (promptPrefix.length) {
-        requestOptions.systemInstruction = {
-          parts: [
-            {
-              text: promptPrefix,
-            },
-          ],
+    /** @type {Error} */
+    let error;
+    try {
+      if (!EXCLUDED_GENAI_MODELS.test(modelName) && !this.project_id) {
+        /** @type {GenerativeModel} */
+        const client = this.client;
+        /** @type {GenerateContentRequest} */
+        const requestOptions = {
+          safetySettings,
+          contents: _payload,
+          generationConfig: googleGenConfigSchema.parse(this.modelOptions),
         };
+
+        const promptPrefix = (this.systemMessage ?? '').trim();
+        if (promptPrefix.length) {
+          requestOptions.systemInstruction = {
+            parts: [
+              {
+                text: promptPrefix,
+              },
+            ],
+          };
+        }
+
+        const delay = modelName.includes('flash') ? 8 : 15;
+        /** @type {GenAIUsageMetadata} */
+        let usageMetadata;
+
+        abortController.signal.addEventListener(
+          'abort',
+          () => {
+            logger.warn('[GoogleClient] Request was aborted', abortController.signal.reason);
+          },
+          { once: true },
+        );
+
+        const result = await client.generateContentStream(requestOptions, {
+          signal: abortController.signal,
+        });
+        for await (const chunk of result.stream) {
+          usageMetadata = !usageMetadata
+            ? chunk?.usageMetadata
+            : Object.assign(usageMetadata, chunk?.usageMetadata);
+          const chunkText = chunk.text();
+          await this.generateTextStream(chunkText, onProgress, {
+            delay,
+          });
+          reply += chunkText;
+          await sleep(streamRate);
+        }
+
+        if (usageMetadata) {
+          this.usage = {
+            input_tokens: usageMetadata.promptTokenCount,
+            output_tokens: usageMetadata.candidatesTokenCount,
+          };
+        }
+
+        return reply;
       }
 
-      requestOptions.safetySettings = _payload.safetySettings;
+      const { instances } = _payload;
+      const { messages: messages, context } = instances?.[0] ?? {};
 
-      const delay = modelName.includes('flash') ? 8 : 15;
-      const result = await client.generateContentStream(requestOptions);
-      for await (const chunk of result.stream) {
-        const chunkText = chunk.text();
+      if (!this.isVisionModel && context && messages?.length > 0) {
+        messages.unshift(new SystemMessage(context));
+      }
+
+      /** @type {import('@langchain/core/messages').AIMessageChunk['usage_metadata']} */
+      let usageMetadata;
+      /** @type {ChatVertexAI} */
+      const client = this.client;
+      const stream = await client.stream(messages, {
+        signal: abortController.signal,
+        streamUsage: true,
+        safetySettings,
+      });
+
+      let delay = this.options.streamRate || 8;
+
+      if (!this.options.streamRate) {
+        if (this.isGenerativeModel) {
+          delay = 15;
+        }
+        if (modelName.includes('flash')) {
+          delay = 5;
+        }
+      }
+
+      for await (const chunk of stream) {
+        if (chunk?.usage_metadata) {
+          const metadata = chunk.usage_metadata;
+          for (const key in metadata) {
+            if (Number.isNaN(metadata[key])) {
+              delete metadata[key];
+            }
+          }
+
+          usageMetadata = !usageMetadata ? metadata : concat(usageMetadata, metadata);
+        }
+
+        const chunkText = chunk?.content ?? '';
         await this.generateTextStream(chunkText, onProgress, {
           delay,
         });
         reply += chunkText;
-        await sleep(streamRate);
       }
-      return reply;
+
+      if (usageMetadata) {
+        this.usage = usageMetadata;
+      }
+    } catch (e) {
+      error = e;
+      logger.error('[GoogleClient] There was an issue generating the completion', e);
     }
 
-    const stream = await model.stream(messages, {
-      signal: abortController.signal,
-      safetySettings: _payload.safetySettings,
-    });
-
-    let delay = this.options.streamRate || 8;
-
-    if (!this.options.streamRate) {
-      if (this.isGenerativeModel) {
-        delay = 15;
-      }
-      if (modelName.includes('flash')) {
-        delay = 5;
-      }
+    if (error != null && reply === '') {
+      const errorMessage = `{ "type": "${ErrorTypes.GoogleError}", "info": "${
+        error.message ?? 'The Google provider failed to generate content, please contact the Admin.'
+      }" }`;
+      throw new Error(errorMessage);
     }
-
-    for await (const chunk of stream) {
-      const chunkText = chunk?.content ?? chunk;
-      await this.generateTextStream(chunkText, onProgress, {
-        delay,
-      });
-      reply += chunkText;
-    }
-
     return reply;
   }
 
+  /**
+   * Get stream usage as returned by this client's API response.
+   * @returns {UsageMetadata} The stream usage object.
+   */
+  getStreamUsage() {
+    return this.usage;
+  }
+
+  /**
+   * 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.
+   * If revisiting a conversation with a chat history entirely composed of token estimates,
+   * the cumulative token count going forward should become more accurate as the conversation progresses.
+   * @param {Object} params - The parameters for the calculation.
+   * @param {Record<string, number>} params.tokenCountMap - A map of message IDs to their token counts.
+   * @param {string} params.currentMessageId - The ID of the current message to calculate.
+   * @param {UsageMetadata} params.usage - The usage object returned by the API.
+   * @returns {number} The correct token count for the current user message.
+   */
+  calculateCurrentTokenCount({ tokenCountMap, currentMessageId, usage }) {
+    const originalEstimate = tokenCountMap[currentMessageId] || 0;
+
+    if (!usage || typeof usage.input_tokens !== 'number') {
+      return originalEstimate;
+    }
+
+    tokenCountMap[currentMessageId] = 0;
+    const totalTokensFromMap = Object.values(tokenCountMap).reduce((sum, count) => {
+      const numCount = Number(count);
+      return sum + (isNaN(numCount) ? 0 : numCount);
+    }, 0);
+    const totalInputTokens = usage.input_tokens ?? 0;
+    const currentMessageTokens = totalInputTokens - totalTokensFromMap;
+    return currentMessageTokens > 0 ? currentMessageTokens : originalEstimate;
+  }
+
+  /**
+   * @param {object} params
+   * @param {number} params.promptTokens
+   * @param {number} params.completionTokens
+   * @param {UsageMetadata} [params.usage]
+   * @param {string} [params.model]
+   * @param {string} [params.context='message']
+   * @returns {Promise<void>}
+   */
+  async recordTokenUsage({ promptTokens, completionTokens, model, context = 'message' }) {
+    await spendTokens(
+      {
+        context,
+        user: this.user ?? this.options.req?.user?.id,
+        conversationId: this.conversationId,
+        model: model ?? this.modelOptions.model,
+        endpointTokenConfig: this.options.endpointTokenConfig,
+      },
+      { promptTokens, completionTokens },
+    );
+  }
+
   /**
    * Stripped-down logic for generating a title. This uses the non-streaming APIs, since the user does not see titles streaming
    */
   async titleChatCompletion(_payload, options = {}) {
-    const { abortController } = options;
-    const { parameters, instances } = _payload;
-    const { messages: _messages, examples: _examples } = instances?.[0] ?? {};
-
-    let clientOptions = { ...parameters, maxRetries: 2 };
-
-    logger.debug('Initialized title client options');
-
-    if (this.project_id) {
-      clientOptions['authOptions'] = {
-        credentials: {
-          ...this.serviceKey,
-        },
-        projectId: this.project_id,
-      };
-    }
-
-    if (!parameters) {
-      clientOptions = { ...clientOptions, ...this.modelOptions };
-    }
-
-    if (this.isGenerativeModel && !this.project_id) {
-      clientOptions.modelName = clientOptions.model;
-      delete clientOptions.model;
-    }
-
-    const model = this.createLLM(clientOptions);
-
     let reply = '';
-    const messages = this.isTextModel ? _payload.trim() : _messages;
+    const { abortController } = options;
 
-    const modelName = clientOptions.modelName ?? clientOptions.model ?? '';
-    if (!EXCLUDED_GENAI_MODELS.test(modelName) && !this.project_id) {
+    const model =
+      this.options.titleModel ?? this.modelOptions.modelName ?? this.modelOptions.model ?? '';
+    const safetySettings = getSafetySettings(model);
+    if (!EXCLUDED_GENAI_MODELS.test(model) && !this.project_id) {
       logger.debug('Identified titling model as GenAI version');
       /** @type {GenerativeModel} */
-      const client = model;
+      const client = this.client;
       const requestOptions = {
         contents: _payload,
+        safetySettings,
+        generationConfig: {
+          temperature: 0.5,
+        },
       };
 
-      let promptPrefix = (this.options.promptPrefix ?? '').trim();
-      if (typeof this.options.artifactsPrompt === 'string' && this.options.artifactsPrompt) {
-        promptPrefix = `${promptPrefix ?? ''}\n${this.options.artifactsPrompt}`.trim();
-      }
-
-      if (this.options?.promptPrefix?.length) {
-        requestOptions.systemInstruction = {
-          parts: [
-            {
-              text: promptPrefix,
-            },
-          ],
-        };
-      }
-
-      const safetySettings = _payload.safetySettings;
-      requestOptions.safetySettings = safetySettings;
-
       const result = await client.generateContent(requestOptions);
-
       reply = result.response?.text();
-
       return reply;
     } else {
-      logger.debug('Beginning titling');
-      const safetySettings = _payload.safetySettings;
-
-      const titleResponse = await model.invoke(messages, {
+      const { instances } = _payload;
+      const { messages } = instances?.[0] ?? {};
+      const titleResponse = await this.client.invoke(messages, {
         signal: abortController.signal,
         timeout: 7000,
-        safetySettings: safetySettings,
+        safetySettings,
       });
 
+      if (titleResponse.usage_metadata) {
+        await this.recordTokenUsage({
+          model,
+          promptTokens: titleResponse.usage_metadata.input_tokens,
+          completionTokens: titleResponse.usage_metadata.output_tokens,
+          context: 'title',
+        });
+      }
+
       reply = titleResponse.content;
-      // TODO: RECORD TOKEN USAGE
       return reply;
     }
   }
@@ -851,15 +891,8 @@ class GoogleClient extends BaseClient {
       },
     ]);
 
-    if (this.isVisionModel) {
-      logger.warn(
-        `Current vision model does not support titling without an attachment; falling back to default model ${settings.model.default}`,
-      );
-
-      payload.parameters = { ...payload.parameters, model: settings.model.default };
-    }
-
     try {
+      this.initializeClient();
       title = await this.titleChatCompletion(payload, {
         abortController: new AbortController(),
         onProgress: () => {},
@@ -873,8 +906,10 @@ class GoogleClient extends BaseClient {
 
   getSaveOptions() {
     return {
+      endpointType: null,
       artifacts: this.options.artifacts,
       promptPrefix: this.options.promptPrefix,
+      maxContextTokens: this.options.maxContextTokens,
       modelLabel: this.options.modelLabel,
       iconURL: this.options.iconURL,
       greeting: this.options.greeting,
@@ -888,61 +923,39 @@ class GoogleClient extends BaseClient {
   }
 
   async sendCompletion(payload, opts = {}) {
-    payload.safetySettings = this.getSafetySettings();
-
     let reply = '';
     reply = await this.getCompletion(payload, opts);
     return reply.trim();
   }
 
-  getSafetySettings() {
-    return [
-      {
-        category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
-        threshold:
-          process.env.GOOGLE_SAFETY_SEXUALLY_EXPLICIT || 'HARM_BLOCK_THRESHOLD_UNSPECIFIED',
-      },
-      {
-        category: 'HARM_CATEGORY_HATE_SPEECH',
-        threshold: process.env.GOOGLE_SAFETY_HATE_SPEECH || 'HARM_BLOCK_THRESHOLD_UNSPECIFIED',
-      },
-      {
-        category: 'HARM_CATEGORY_HARASSMENT',
-        threshold: process.env.GOOGLE_SAFETY_HARASSMENT || 'HARM_BLOCK_THRESHOLD_UNSPECIFIED',
-      },
-      {
-        category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
-        threshold:
-          process.env.GOOGLE_SAFETY_DANGEROUS_CONTENT || 'HARM_BLOCK_THRESHOLD_UNSPECIFIED',
-      },
-      {
-        category: 'HARM_CATEGORY_CIVIC_INTEGRITY',
-        /**
-         * Note: this was added since `gemini-2.0-flash-thinking-exp-1219` does not
-         * accept 'HARM_BLOCK_THRESHOLD_UNSPECIFIED' for 'HARM_CATEGORY_CIVIC_INTEGRITY'
-         * */
-        threshold: process.env.GOOGLE_SAFETY_CIVIC_INTEGRITY || 'BLOCK_NONE',
-      },
-    ];
+  getEncoding() {
+    return 'cl100k_base';
   }
 
-  /* TO-DO: Handle tokens with Google tokenization NOTE: these are required */
-  static getTokenizer(encoding, isModelName = false, extendSpecialTokens = {}) {
-    if (tokenizersCache[encoding]) {
-      return tokenizersCache[encoding];
-    }
-    let tokenizer;
-    if (isModelName) {
-      tokenizer = encodingForModel(encoding, extendSpecialTokens);
-    } else {
-      tokenizer = getEncoding(encoding, extendSpecialTokens);
-    }
-    tokenizersCache[encoding] = tokenizer;
-    return tokenizer;
+  async getVertexTokenCount(text) {
+    /** @type {ChatVertexAI} */
+    const client = this.client ?? this.initializeClient();
+    const connection = client.connection;
+    const gAuthClient = connection.client;
+    const tokenEndpoint = `https://${connection._endpoint}/${connection.apiVersion}/projects/${this.project_id}/locations/${connection._location}/publishers/google/models/${connection.model}/:countTokens`;
+    const result = await gAuthClient.request({
+      url: tokenEndpoint,
+      method: 'POST',
+      data: {
+        contents: [{ role: 'user', parts: [{ text }] }],
+      },
+    });
+    return result;
   }
 
+  /**
+   * Returns the token count of a given text. It also checks and resets the tokenizers if necessary.
+   * @param {string} text - The text to get the token count for.
+   * @returns {number} The token count of the given text.
+   */
   getTokenCount(text) {
-    return this.gptEncoder.encode(text, 'all').length;
+    const encoding = this.getEncoding();
+    return Tokenizer.getTokenCount(text, encoding);
   }
 }
 

api/app/clients/OllamaClient.js

@@ -2,7 +2,7 @@ const { z } = require('zod');
 const axios = require('axios');
 const { Ollama } = require('ollama');
 const { Constants } = require('librechat-data-provider');
-const { deriveBaseURL } = require('~/utils');
+const { deriveBaseURL, logAxiosError } = require('~/utils');
 const { sleep } = require('~/server/utils');
 const { logger } = require('~/config');
 
@@ -68,7 +68,7 @@ class OllamaClient {
     } catch (error) {
       const logMessage =
         'Failed to fetch models from Ollama API. If you are not using Ollama directly, and instead, through some aggregator or reverse proxy that handles fetching via OpenAI spec, ensure the name of the endpoint doesn\'t start with `ollama` (case-insensitive).';
-      logger.error(logMessage, error);
+      logAxiosError({ message: logMessage, error });
       return [];
     }
   }

api/app/clients/OpenAIClient.js

@@ -1,11 +1,14 @@
 const OpenAI = require('openai');
 const { OllamaClient } = require('./OllamaClient');
 const { HttpsProxyAgent } = require('https-proxy-agent');
+const { SplitStreamHandler, GraphEvents } = require('@librechat/agents');
 const {
   Constants,
   ImageDetail,
+  ContentTypes,
   EModelEndpoint,
   resolveHeaders,
+  KnownEndpoints,
   openAISettings,
   ImageDetailCost,
   CohereConstants,
@@ -13,7 +16,6 @@ const {
   validateVisionModel,
   mapModelToAzureConfig,
 } = require('librechat-data-provider');
-const { encoding_for_model: encodingForModel, get_encoding: getEncoding } = require('tiktoken');
 const {
   extractBaseURL,
   constructAzureURL,
@@ -29,21 +31,17 @@ const {
   createContextHandlers,
 } = require('./prompts');
 const { encodeAndFormat } = require('~/server/services/Files/images/encode');
+const { addSpaceIfNeeded, isEnabled, sleep } = require('~/server/utils');
+const Tokenizer = require('~/server/services/Tokenizer');
 const { spendTokens } = require('~/models/spendTokens');
-const { isEnabled, sleep } = require('~/server/utils');
 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');
-
-// Cache to store Tiktoken instances
-const tokenizersCache = {};
-// Counter for keeping track of the number of tokenizer calls
-let tokenizerCallsCount = 0;
 
 class OpenAIClient extends BaseClient {
   constructor(apiKey, options = {}) {
@@ -69,7 +67,9 @@ class OpenAIClient extends BaseClient {
     /** @type {OpenAIUsageMetadata | undefined} */
     this.usage;
     /** @type {boolean|undefined} */
-    this.isO1Model;
+    this.isOmni;
+    /** @type {SplitStreamHandler | undefined} */
+    this.streamHandler;
   }
 
   // TODO: PluginsClient calls this 3x, unneeded
@@ -107,21 +107,17 @@ class OpenAIClient extends BaseClient {
       this.checkVisionRequest(this.options.attachments);
     }
 
-    const o1Pattern = /\bo1\b/i;
-    this.isO1Model = o1Pattern.test(this.modelOptions.model);
-
-    const { OPENROUTER_API_KEY, OPENAI_FORCE_PROMPT } = process.env ?? {};
-    if (OPENROUTER_API_KEY && !this.azure) {
-      this.apiKey = OPENROUTER_API_KEY;
-      this.useOpenRouter = true;
-    }
+    const omniPattern = /\b(o1|o3)\b/i;
+    this.isOmni = omniPattern.test(this.modelOptions.model);
 
+    const { OPENAI_FORCE_PROMPT } = process.env ?? {};
     const { reverseProxyUrl: reverseProxy } = this.options;
 
     if (
       !this.useOpenRouter &&
-      reverseProxy &&
-      reverseProxy.includes('https://openrouter.ai/api/v1')
+      ((reverseProxy && reverseProxy.includes(KnownEndpoints.openrouter)) ||
+        (this.options.endpoint &&
+          this.options.endpoint.toLowerCase().includes(KnownEndpoints.openrouter)))
     ) {
       this.useOpenRouter = true;
     }
@@ -148,7 +144,7 @@ class OpenAIClient extends BaseClient {
     const { model } = this.modelOptions;
 
     this.isChatCompletion =
-      o1Pattern.test(model) || model.includes('gpt') || this.useOpenRouter || !!reverseProxy;
+      omniPattern.test(model) || model.includes('gpt') || this.useOpenRouter || !!reverseProxy;
     this.isChatGptModel = this.isChatCompletion;
     if (
       model.includes('text-davinci') ||
@@ -230,10 +226,6 @@ class OpenAIClient extends BaseClient {
       logger.debug('Using Azure endpoint');
     }
 
-    if (this.useOpenRouter) {
-      this.completionsUrl = 'https://openrouter.ai/api/v1/chat/completions';
-    }
-
     return this;
   }
 
@@ -307,75 +299,10 @@ class OpenAIClient extends BaseClient {
     }
   }
 
-  // Selects an appropriate tokenizer based on the current configuration of the client instance.
-  // It takes into account factors such as whether it's a chat completion, an unofficial chat GPT model, etc.
-  selectTokenizer() {
-    let tokenizer;
-    this.encoding = 'text-davinci-003';
-    if (this.isChatCompletion) {
-      this.encoding = this.modelOptions.model.includes('gpt-4o') ? 'o200k_base' : 'cl100k_base';
-      tokenizer = this.constructor.getTokenizer(this.encoding);
-    } else if (this.isUnofficialChatGptModel) {
-      const extendSpecialTokens = {
-        '<|im_start|>': 100264,
-        '<|im_end|>': 100265,
-      };
-      tokenizer = this.constructor.getTokenizer(this.encoding, true, extendSpecialTokens);
-    } else {
-      try {
-        const { model } = this.modelOptions;
-        this.encoding = model.includes('instruct') ? 'text-davinci-003' : model;
-        tokenizer = this.constructor.getTokenizer(this.encoding, true);
-      } catch {
-        tokenizer = this.constructor.getTokenizer('text-davinci-003', true);
-      }
-    }
-
-    return tokenizer;
-  }
-
-  // Retrieves a tokenizer either from the cache or creates a new one if one doesn't exist in the cache.
-  // If a tokenizer is being created, it's also added to the cache.
-  static getTokenizer(encoding, isModelName = false, extendSpecialTokens = {}) {
-    let tokenizer;
-    if (tokenizersCache[encoding]) {
-      tokenizer = tokenizersCache[encoding];
-    } else {
-      if (isModelName) {
-        tokenizer = encodingForModel(encoding, extendSpecialTokens);
-      } else {
-        tokenizer = getEncoding(encoding, extendSpecialTokens);
-      }
-      tokenizersCache[encoding] = tokenizer;
-    }
-    return tokenizer;
-  }
-
-  // Frees all encoders in the cache and resets the count.
-  static freeAndResetAllEncoders() {
-    try {
-      Object.keys(tokenizersCache).forEach((key) => {
-        if (tokenizersCache[key]) {
-          tokenizersCache[key].free();
-          delete tokenizersCache[key];
-        }
-      });
-      // Reset count
-      tokenizerCallsCount = 1;
-    } catch (error) {
-      logger.error('[OpenAIClient] Free and reset encoders error', error);
-    }
-  }
-
-  // Checks if the cache of tokenizers has reached a certain size. If it has, it frees and resets all tokenizers.
-  resetTokenizersIfNecessary() {
-    if (tokenizerCallsCount >= 25) {
-      if (this.options.debug) {
-        logger.debug('[OpenAIClient] freeAndResetAllEncoders: reached 25 encodings, resetting...');
-      }
-      this.constructor.freeAndResetAllEncoders();
-    }
-    tokenizerCallsCount++;
+  getEncoding() {
+    return this.modelOptions?.model && /gpt-4[^-\s]/.test(this.modelOptions.model)
+      ? 'o200k_base'
+      : 'cl100k_base';
   }
 
   /**
@@ -384,15 +311,8 @@ class OpenAIClient extends BaseClient {
    * @returns {number} The token count of the given text.
    */
   getTokenCount(text) {
-    this.resetTokenizersIfNecessary();
-    try {
-      const tokenizer = this.selectTokenizer();
-      return tokenizer.encode(text, 'all').length;
-    } catch (error) {
-      this.constructor.freeAndResetAllEncoders();
-      const tokenizer = this.selectTokenizer();
-      return tokenizer.encode(text, 'all').length;
-    }
+    const encoding = this.getEncoding();
+    return Tokenizer.getTokenCount(text, encoding);
   }
 
   /**
@@ -551,7 +471,7 @@ class OpenAIClient extends BaseClient {
       promptPrefix = this.augmentedPrompt + promptPrefix;
     }
 
-    if (promptPrefix && this.isO1Model !== true) {
+    if (promptPrefix && this.isOmni !== true) {
       promptPrefix = `Instructions:\n${promptPrefix.trim()}`;
       instructions = {
         role: 'system',
@@ -579,12 +499,27 @@ class OpenAIClient extends BaseClient {
     };
 
     /** EXPERIMENTAL */
-    if (promptPrefix && this.isO1Model === true) {
+    if (promptPrefix && this.isOmni === true) {
       const lastUserMessageIndex = payload.findLastIndex((message) => message.role === 'user');
       if (lastUserMessageIndex !== -1) {
-        payload[
-          lastUserMessageIndex
-        ].content = `${promptPrefix}\n${payload[lastUserMessageIndex].content}`;
+        if (Array.isArray(payload[lastUserMessageIndex].content)) {
+          const firstTextPartIndex = payload[lastUserMessageIndex].content.findIndex(
+            (part) => part.type === ContentTypes.TEXT,
+          );
+          if (firstTextPartIndex !== -1) {
+            const firstTextPart = payload[lastUserMessageIndex].content[firstTextPartIndex];
+            payload[lastUserMessageIndex].content[firstTextPartIndex].text =
+              `${promptPrefix}\n${firstTextPart.text}`;
+          } else {
+            payload[lastUserMessageIndex].content.unshift({
+              type: ContentTypes.TEXT,
+              text: promptPrefix,
+            });
+          }
+        } else {
+          payload[lastUserMessageIndex].content =
+            `${promptPrefix}\n${payload[lastUserMessageIndex].content}`;
+        }
       }
     }
 
@@ -690,11 +625,9 @@ class OpenAIClient extends BaseClient {
   }
 
   initializeLLM({
-    model = 'gpt-4o-mini',
+    model = openAISettings.model.default,
     modelName,
     temperature = 0.2,
-    presence_penalty = 0,
-    frequency_penalty = 0,
     max_tokens,
     streaming,
     context,
@@ -705,8 +638,6 @@ class OpenAIClient extends BaseClient {
     const modelOptions = {
       modelName: modelName ?? model,
       temperature,
-      presence_penalty,
-      frequency_penalty,
       user: this.user,
     };
 
@@ -795,7 +726,7 @@ class OpenAIClient extends BaseClient {
 
     const { OPENAI_TITLE_MODEL } = process.env ?? {};
 
-    let model = this.options.titleModel ?? OPENAI_TITLE_MODEL ?? 'gpt-4o-mini';
+    let model = this.options.titleModel ?? OPENAI_TITLE_MODEL ?? openAISettings.model.default;
     if (model === Constants.CURRENT_MODEL) {
       model = this.modelOptions.model;
     }
@@ -877,7 +808,11 @@ ${convo}
         }
 
         title = (
-          await this.sendPayload(instructionsPayload, { modelOptions, useChatCompletion })
+          await this.sendPayload(instructionsPayload, {
+            modelOptions,
+            useChatCompletion,
+            context: 'title',
+          })
         ).replaceAll('"', '');
 
         const completionTokens = this.getTokenCount(title);
@@ -984,7 +919,7 @@ ${convo}
     let prompt;
 
     // TODO: remove the gpt fallback and make it specific to endpoint
-    const { OPENAI_SUMMARY_MODEL = 'gpt-4o-mini' } = process.env ?? {};
+    const { OPENAI_SUMMARY_MODEL = openAISettings.model.default } = process.env ?? {};
     let model = this.options.summaryModel ?? OPENAI_SUMMARY_MODEL;
     if (model === Constants.CURRENT_MODEL) {
       model = this.modelOptions.model;
@@ -1010,7 +945,10 @@ ${convo}
     );
 
     if (excessTokenCount > maxContextTokens) {
-      ({ context } = await this.getMessagesWithinTokenLimit(context, maxContextTokens));
+      ({ context } = await this.getMessagesWithinTokenLimit({
+        messages: context,
+        maxContextTokens,
+      }));
     }
 
     if (context.length === 0) {
@@ -1140,10 +1078,68 @@ ${convo}
     });
   }
 
+  /**
+   *
+   * @param {string[]} [intermediateReply]
+   * @returns {string}
+   */
+  getStreamText(intermediateReply) {
+    if (!this.streamHandler) {
+      return intermediateReply?.join('') ?? '';
+    }
+
+    let thinkMatch;
+    let remainingText;
+    let reasoningText = '';
+
+    if (this.streamHandler.reasoningTokens.length > 0) {
+      reasoningText = this.streamHandler.reasoningTokens.join('');
+      thinkMatch = reasoningText.match(/<think>([\s\S]*?)<\/think>/)?.[1]?.trim();
+      if (thinkMatch != null && thinkMatch) {
+        const reasoningTokens = `:::thinking\n${thinkMatch}\n:::\n`;
+        remainingText = reasoningText.split(/<\/think>/)?.[1]?.trim() || '';
+        return `${reasoningTokens}${remainingText}${this.streamHandler.tokens.join('')}`;
+      } else if (thinkMatch === '') {
+        remainingText = reasoningText.split(/<\/think>/)?.[1]?.trim() || '';
+        return `${remainingText}${this.streamHandler.tokens.join('')}`;
+      }
+    }
+
+    const reasoningTokens =
+      reasoningText.length > 0
+        ? `:::thinking\n${reasoningText.replace('<think>', '').replace('</think>', '').trim()}\n:::\n`
+        : '';
+
+    return `${reasoningTokens}${this.streamHandler.tokens.join('')}`;
+  }
+
+  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) {
+        /** @type {import('@librechat/agents').MessageContentComplex} */
+        const newContent = [];
+        for (let part of msg.content) {
+          if (part.think != null) {
+            continue;
+          }
+          newContent.push(part);
+        }
+        msg.content = newContent;
+      }
+
+      return msg;
+    };
+  }
+
   async chatCompletion({ payload, onProgress, abortController = null }) {
     let error = null;
+    let intermediateReply = [];
     const errorCallback = (err) => (error = err);
-    const intermediateReply = [];
     try {
       if (!abortController) {
         abortController = new AbortController();
@@ -1185,10 +1181,6 @@ ${convo}
         opts.httpAgent = new HttpsProxyAgent(this.options.proxy);
       }
 
-      if (this.isVisionModel) {
-        modelOptions.max_tokens = 4000;
-      }
-
       /** @type {TAzureConfig | undefined} */
       const azureConfig = this.options?.req?.app?.locals?.[EModelEndpoint.azureOpenAI];
 
@@ -1247,7 +1239,7 @@ ${convo}
         opts.defaultHeaders = { ...opts.defaultHeaders, 'api-key': this.apiKey };
       }
 
-      if (this.isO1Model === true && modelOptions.max_tokens != null) {
+      if (this.isOmni === true && modelOptions.max_tokens != null) {
         modelOptions.max_completion_tokens = modelOptions.max_tokens;
         delete modelOptions.max_tokens;
       }
@@ -1299,6 +1291,29 @@ ${convo}
         });
       }
 
+      /** Note: OpenAI Web Search models do not support any known parameters besdies `max_tokens` */
+      if (modelOptions.model && /gpt-4o.*search/.test(modelOptions.model)) {
+        const searchExcludeParams = [
+          'frequency_penalty',
+          'presence_penalty',
+          'temperature',
+          'top_p',
+          'top_k',
+          'stop',
+          'logit_bias',
+          'seed',
+          'response_format',
+          'n',
+          'logprobs',
+          'user',
+        ];
+
+        this.options.dropParams = this.options.dropParams || [];
+        this.options.dropParams = [
+          ...new Set([...this.options.dropParams, ...searchExcludeParams]),
+        ];
+      }
+
       if (this.options.dropParams && Array.isArray(this.options.dropParams)) {
         this.options.dropParams.forEach((param) => {
           delete modelOptions[param];
@@ -1327,23 +1342,55 @@ ${convo}
       let streamResolve;
 
       if (
-        this.isO1Model === true &&
-        (this.azure || /o1(?!-(?:mini|preview)).*$/.test(modelOptions.model)) &&
-        modelOptions.stream
+        (!this.isOmni || /^o1-(mini|preview)/i.test(modelOptions.model)) &&
+        modelOptions.reasoning_effort != null
       ) {
-        delete modelOptions.stream;
-        delete modelOptions.stop;
+        delete modelOptions.reasoning_effort;
+        delete modelOptions.temperature;
       }
 
+      let reasoningKey = 'reasoning_content';
+      if (this.useOpenRouter) {
+        modelOptions.include_reasoning = true;
+        reasoningKey = 'reasoning';
+      }
+      if (this.useOpenRouter && modelOptions.reasoning_effort != null) {
+        modelOptions.reasoning = {
+          effort: modelOptions.reasoning_effort,
+        };
+        delete modelOptions.reasoning_effort;
+      }
+
+      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),
+        },
+      });
+
+      intermediateReply = this.streamHandler.tokens;
+
       if (modelOptions.stream) {
         streamPromise = new Promise((resolve) => {
           streamResolve = resolve;
         });
+        /** @type {OpenAI.OpenAI.CompletionCreateParamsStreaming} */
+        const params = {
+          ...modelOptions,
+          stream: true,
+        };
+        if (
+          this.options.endpoint === EModelEndpoint.openAI ||
+          this.options.endpoint === EModelEndpoint.azureOpenAI
+        ) {
+          params.stream_options = { include_usage: true };
+        }
         const stream = await openai.beta.chat.completions
-          .stream({
-            ...modelOptions,
-            stream: true,
-          })
+          .stream(params)
           .on('abort', () => {
             /* Do nothing here */
           })
@@ -1361,20 +1408,44 @@ ${convo}
             }
 
             if (typeof finalMessage.content !== 'string' || finalMessage.content.trim() === '') {
-              finalChatCompletion.choices[0].message.content = intermediateReply.join('');
+              finalChatCompletion.choices[0].message.content = this.streamHandler.tokens.join('');
             }
           })
           .on('finalMessage', (message) => {
             if (message?.role !== 'assistant') {
-              stream.messages.push({ role: 'assistant', content: intermediateReply.join('') });
+              stream.messages.push({
+                role: 'assistant',
+                content: this.streamHandler.tokens.join(''),
+              });
               UnexpectedRoleError = true;
             }
           });
 
+        if (this.continued === true) {
+          const latestText = addSpaceIfNeeded(
+            this.currentMessages[this.currentMessages.length - 1]?.text ?? '',
+          );
+          this.streamHandler.handle({
+            choices: [
+              {
+                delta: {
+                  content: latestText,
+                },
+              },
+            ],
+          });
+        }
+
         for await (const chunk of stream) {
-          const token = chunk.choices[0]?.delta?.content || '';
-          intermediateReply.push(token);
-          onProgress(token);
+          // Add finish_reason: null if missing in any choice
+          if (chunk.choices) {
+            chunk.choices.forEach((choice) => {
+              if (!('finish_reason' in choice)) {
+                choice.finish_reason = null;
+              }
+            });
+          }
+          this.streamHandler.handle(chunk);
           if (abortController.signal.aborted) {
             stream.controller.abort();
             break;
@@ -1417,7 +1488,7 @@ ${convo}
 
       if (!Array.isArray(choices) || choices.length === 0) {
         logger.warn('[OpenAIClient] Chat completion response has no choices');
-        return intermediateReply.join('');
+        return this.streamHandler.tokens.join('');
       }
 
       const { message, finish_reason } = choices[0] ?? {};
@@ -1427,11 +1498,11 @@ ${convo}
 
       if (!message) {
         logger.warn('[OpenAIClient] Message is undefined in chatCompletion response');
-        return intermediateReply.join('');
+        return this.streamHandler.tokens.join('');
       }
 
       if (typeof message.content !== 'string' || message.content.trim() === '') {
-        const reply = intermediateReply.join('');
+        const reply = this.streamHandler.tokens.join('');
         logger.debug(
           '[OpenAIClient] chatCompletion: using intermediateReply due to empty message.content',
           { intermediateReply: reply },
@@ -1439,13 +1510,27 @@ ${convo}
         return reply;
       }
 
+      if (
+        this.streamHandler.reasoningTokens.length > 0 &&
+        this.options.context !== 'title' &&
+        !message.content.startsWith('<think>')
+      ) {
+        return this.getStreamText();
+      } else if (
+        this.streamHandler.reasoningTokens.length > 0 &&
+        this.options.context !== 'title' &&
+        message.content.startsWith('<think>')
+      ) {
+        return this.getStreamText();
+      }
+
       return message.content;
     } catch (err) {
       if (
         err?.message?.includes('abort') ||
         (err instanceof OpenAI.APIError && err?.message?.includes('abort'))
       ) {
-        return intermediateReply.join('');
+        return this.getStreamText(intermediateReply);
       }
       if (
         err?.message?.includes(
@@ -1460,10 +1545,18 @@ ${convo}
         (err instanceof OpenAI.OpenAIError && err?.message?.includes('missing finish_reason'))
       ) {
         logger.error('[OpenAIClient] Known OpenAI error:', err);
-        return intermediateReply.join('');
+        if (this.streamHandler && this.streamHandler.reasoningTokens.length) {
+          return this.getStreamText();
+        } else if (intermediateReply.length > 0) {
+          return this.getStreamText(intermediateReply);
+        } else {
+          throw err;
+        }
       } else if (err instanceof OpenAI.APIError) {
-        if (intermediateReply.length > 0) {
-          return intermediateReply.join('');
+        if (this.streamHandler && this.streamHandler.reasoningTokens.length) {
+          return this.getStreamText();
+        } else if (intermediateReply.length > 0) {
+          return this.getStreamText(intermediateReply);
         } else {
           throw err;
         }

api/app/clients/PluginsClient.js

@@ -1,17 +1,14 @@
 const OpenAIClient = require('./OpenAIClient');
-const { CacheKeys, Time } = require('librechat-data-provider');
 const { CallbackManager } = require('@langchain/core/callbacks/manager');
 const { BufferMemory, ChatMessageHistory } = require('langchain/memory');
 const { addImages, buildErrorInput, buildPromptPrefix } = require('./output_parsers');
 const { initializeCustomAgent, initializeFunctionsAgent } = require('./agents');
 const { processFileURL } = require('~/server/services/Files/process');
 const { EModelEndpoint } = require('librechat-data-provider');
+const { checkBalance } = require('~/models/balanceMethods');
 const { formatLangChainMessages } = require('./prompts');
-const checkBalance = require('~/models/checkBalance');
-const { isEnabled } = require('~/server/utils');
 const { extractBaseURL } = require('~/utils');
 const { loadTools } = require('./tools/util');
-const { getLogStores } = require('~/cache');
 const { logger } = require('~/config');
 
 class PluginsClient extends OpenAIClient {
@@ -256,15 +253,6 @@ class PluginsClient extends OpenAIClient {
     }
 
     this.responsePromise = this.saveMessageToDatabase(responseMessage, saveOptions, user);
-    const messageCache = getLogStores(CacheKeys.MESSAGES);
-    messageCache.set(
-      responseMessage.messageId,
-      {
-        text: responseMessage.text,
-        complete: true,
-      },
-      Time.FIVE_MINUTES,
-    );
     delete responseMessage.tokenCount;
     return { ...responseMessage, ...result };
   }
@@ -291,7 +279,6 @@ class PluginsClient extends OpenAIClient {
     logger.debug('[PluginsClient] sendMessage', { userMessageText: message, opts });
     const {
       user,
-      isEdited,
       conversationId,
       responseMessageId,
       saveOptions,
@@ -348,7 +335,8 @@ class PluginsClient extends OpenAIClient {
       }
     }
 
-    if (isEnabled(process.env.CHECK_BALANCE)) {
+    const balance = this.options.req?.app?.locals?.balance;
+    if (balance?.enabled) {
       await checkBalance({
         req: this.options.req,
         res: this.options.res,
@@ -370,7 +358,6 @@ class PluginsClient extends OpenAIClient {
       conversationId,
       parentMessageId: userMessage.messageId,
       isCreatedByUser: false,
-      isEdited,
       model: this.modelOptions.model,
       sender: this.sender,
       promptTokens,

api/app/clients/callbacks/createStartHandler.js

@@ -1,8 +1,8 @@
 const { promptTokensEstimate } = require('openai-chat-tokens');
 const { EModelEndpoint, supportsBalanceCheck } = require('librechat-data-provider');
 const { formatFromLangChain } = require('~/app/clients/prompts');
-const checkBalance = require('~/models/checkBalance');
-const { isEnabled } = require('~/server/utils');
+const { getBalanceConfig } = require('~/server/services/Config');
+const { checkBalance } = require('~/models/balanceMethods');
 const { logger } = require('~/config');
 
 const createStartHandler = ({
@@ -49,8 +49,8 @@ const createStartHandler = ({
     prelimPromptTokens += tokenBuffer;
 
     try {
-      // TODO: if plugins extends to non-OpenAI models, this will need to be updated
-      if (isEnabled(process.env.CHECK_BALANCE) && supportsBalanceCheck[EModelEndpoint.openAI]) {
+      const balance = await getBalanceConfig();
+      if (balance?.enabled && supportsBalanceCheck[EModelEndpoint.openAI]) {
         const generations =
           initialMessageCount && messages.length > initialMessageCount
             ? messages.slice(initialMessageCount)

api/app/clients/prompts/addCacheControl.js

@@ -1,7 +1,7 @@
 /**
  * Anthropic API: Adds cache control to the appropriate user messages in the payload.
- * @param {Array<AnthropicMessage>} messages - The array of message objects.
- * @returns {Array<AnthropicMessage>} - The updated array of message objects with cache control added.
+ * @param {Array<AnthropicMessage | BaseMessage>} messages - The array of message objects.
+ * @returns {Array<AnthropicMessage | BaseMessage>} - The updated array of message objects with cache control added.
  */
 function addCacheControl(messages) {
   if (!Array.isArray(messages) || messages.length < 2) {
@@ -13,7 +13,9 @@ function addCacheControl(messages) {
 
   for (let i = updatedMessages.length - 1; i >= 0 && userMessagesModified < 2; i--) {
     const message = updatedMessages[i];
-    if (message.role !== 'user') {
+    if (message.getType != null && message.getType() !== 'human') {
+      continue;
+    } else if (message.getType == null && message.role !== 'user') {
       continue;
     }
 

api/app/clients/prompts/formatAgentMessages.spec.js

@@ -282,4 +282,80 @@ describe('formatAgentMessages', () => {
     // Additional check to ensure the consecutive assistant messages were combined
     expect(result[1].content).toHaveLength(2);
   });
+
+  it('should skip THINK type content parts', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Initial response' },
+          { type: ContentTypes.THINK, [ContentTypes.THINK]: 'Reasoning about the problem...' },
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Final answer' },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBeInstanceOf(AIMessage);
+    expect(result[0].content).toEqual('Initial response\nFinal answer');
+  });
+
+  it('should join TEXT content as string when THINK content type is present', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.THINK, [ContentTypes.THINK]: 'Analyzing the problem...' },
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'First part of response' },
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Second part of response' },
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Final part of response' },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBeInstanceOf(AIMessage);
+    expect(typeof result[0].content).toBe('string');
+    expect(result[0].content).toBe(
+      'First part of response\nSecond part of response\nFinal part of response',
+    );
+    expect(result[0].content).not.toContain('Analyzing the problem...');
+  });
+
+  it('should exclude ERROR type content parts', () => {
+    const payload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello there' },
+          {
+            type: ContentTypes.ERROR,
+            [ContentTypes.ERROR]:
+              'An error occurred while processing the request: Something went wrong',
+          },
+          { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Final answer' },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toBeInstanceOf(AIMessage);
+    expect(result[0].content).toEqual([
+      { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Hello there' },
+      { type: ContentTypes.TEXT, [ContentTypes.TEXT]: 'Final answer' },
+    ]);
+
+    // Make sure no error content exists in the result
+    const hasErrorContent = result[0].content.some(
+      (item) =>
+        item.type === ContentTypes.ERROR || JSON.stringify(item).includes('An error occurred'),
+    );
+    expect(hasErrorContent).toBe(false);
+  });
 });

api/app/clients/prompts/formatMessages.js

@@ -153,6 +153,7 @@ const formatAgentMessages = (payload) => {
     let currentContent = [];
     let lastAIMessage = null;
 
+    let hasReasoning = false;
     for (const part of message.content) {
       if (part.type === ContentTypes.TEXT && part.tool_call_ids) {
         /*
@@ -207,11 +208,27 @@ const formatAgentMessages = (payload) => {
             content: output || '',
           }),
         );
+      } else if (part.type === ContentTypes.THINK) {
+        hasReasoning = true;
+        continue;
+      } else if (part.type === ContentTypes.ERROR || part.type === ContentTypes.AGENT_UPDATE) {
+        continue;
       } else {
         currentContent.push(part);
       }
     }
 
+    if (hasReasoning) {
+      currentContent = currentContent
+        .reduce((acc, curr) => {
+          if (curr.type === ContentTypes.TEXT) {
+            return `${acc}${curr[ContentTypes.TEXT]}\n`;
+          }
+          return acc;
+        }, '')
+        .trim();
+    }
+
     if (currentContent.length > 0) {
       messages.push(new AIMessage({ content: currentContent }));
     }

api/app/clients/prompts/formatMessages.spec.js

@@ -60,7 +60,6 @@ describe('formatMessage', () => {
         error: false,
         finish_reason: null,
         isCreatedByUser: true,
-        isEdited: false,
         model: null,
         parentMessageId: Constants.NO_PARENT,
         sender: 'User',

api/app/clients/prompts/index.js

@@ -4,7 +4,7 @@ const summaryPrompts = require('./summaryPrompts');
 const handleInputs = require('./handleInputs');
 const instructions = require('./instructions');
 const titlePrompts = require('./titlePrompts');
-const truncateText = require('./truncateText');
+const truncate = require('./truncate');
 const createVisionPrompt = require('./createVisionPrompt');
 const createContextHandlers = require('./createContextHandlers');
 
@@ -15,7 +15,7 @@ module.exports = {
   ...handleInputs,
   ...instructions,
   ...titlePrompts,
-  ...truncateText,
+  ...truncate,
   createVisionPrompt,
   createContextHandlers,
 };

api/app/clients/prompts/truncate.js

@@ -0,0 +1,115 @@
+const MAX_CHAR = 255;
+
+/**
+ * Truncates a given text to a specified maximum length, appending ellipsis and a notification
+ * if the original text exceeds the maximum length.
+ *
+ * @param {string} text - The text to be truncated.
+ * @param {number} [maxLength=MAX_CHAR] - The maximum length of the text after truncation. Defaults to MAX_CHAR.
+ * @returns {string} The truncated text if the original text length exceeds maxLength, otherwise returns the original text.
+ */
+function truncateText(text, maxLength = MAX_CHAR) {
+  if (text.length > maxLength) {
+    return `${text.slice(0, maxLength)}... [text truncated for brevity]`;
+  }
+  return text;
+}
+
+/**
+ * Truncates a given text to a specified maximum length by showing the first half and the last half of the text,
+ * separated by ellipsis. This method ensures the output does not exceed the maximum length, including the addition
+ * of ellipsis and notification if the original text exceeds the maximum length.
+ *
+ * @param {string} text - The text to be truncated.
+ * @param {number} [maxLength=MAX_CHAR] - The maximum length of the output text after truncation. Defaults to MAX_CHAR.
+ * @returns {string} The truncated text showing the first half and the last half, or the original text if it does not exceed maxLength.
+ */
+function smartTruncateText(text, maxLength = MAX_CHAR) {
+  const ellipsis = '...';
+  const notification = ' [text truncated for brevity]';
+  const halfMaxLength = Math.floor((maxLength - ellipsis.length - notification.length) / 2);
+
+  if (text.length > maxLength) {
+    const startLastHalf = text.length - halfMaxLength;
+    return `${text.slice(0, halfMaxLength)}${ellipsis}${text.slice(startLastHalf)}${notification}`;
+  }
+
+  return text;
+}
+
+/**
+ * @param {TMessage[]} _messages
+ * @param {number} maxContextTokens
+ * @param {function({role: string, content: TMessageContent[]}): number} getTokenCountForMessage
+ *
+ * @returns {{
+ *  dbMessages: TMessage[],
+ * editedIndices: number[]
+ * }}
+ */
+function truncateToolCallOutputs(_messages, maxContextTokens, getTokenCountForMessage) {
+  const THRESHOLD_PERCENTAGE = 0.5;
+  const targetTokenLimit = maxContextTokens * THRESHOLD_PERCENTAGE;
+
+  let currentTokenCount = 3;
+  const messages = [..._messages];
+  const processedMessages = [];
+  let currentIndex = messages.length;
+  const editedIndices = new Set();
+  while (messages.length > 0) {
+    currentIndex--;
+    const message = messages.pop();
+    currentTokenCount += message.tokenCount;
+    if (currentTokenCount < targetTokenLimit) {
+      processedMessages.push(message);
+      continue;
+    }
+
+    if (!message.content || !Array.isArray(message.content)) {
+      processedMessages.push(message);
+      continue;
+    }
+
+    const toolCallIndices = message.content
+      .map((item, index) => (item.type === 'tool_call' ? index : -1))
+      .filter((index) => index !== -1)
+      .reverse();
+
+    if (toolCallIndices.length === 0) {
+      processedMessages.push(message);
+      continue;
+    }
+
+    const newContent = [...message.content];
+
+    // Truncate all tool outputs since we're over threshold
+    for (const index of toolCallIndices) {
+      const toolCall = newContent[index].tool_call;
+      if (!toolCall || !toolCall.output) {
+        continue;
+      }
+
+      editedIndices.add(currentIndex);
+
+      newContent[index] = {
+        ...newContent[index],
+        tool_call: {
+          ...toolCall,
+          output: '[OUTPUT_OMITTED_FOR_BREVITY]',
+        },
+      };
+    }
+
+    const truncatedMessage = {
+      ...message,
+      content: newContent,
+      tokenCount: getTokenCountForMessage({ role: 'assistant', content: newContent }),
+    };
+
+    processedMessages.push(truncatedMessage);
+  }
+
+  return { dbMessages: processedMessages.reverse(), editedIndices: Array.from(editedIndices) };
+}
+
+module.exports = { truncateText, smartTruncateText, truncateToolCallOutputs };

api/app/clients/prompts/truncateText.js

@@ -1,40 +0,0 @@
-const MAX_CHAR = 255;
-
-/**
- * Truncates a given text to a specified maximum length, appending ellipsis and a notification
- * if the original text exceeds the maximum length.
- *
- * @param {string} text - The text to be truncated.
- * @param {number} [maxLength=MAX_CHAR] - The maximum length of the text after truncation. Defaults to MAX_CHAR.
- * @returns {string} The truncated text if the original text length exceeds maxLength, otherwise returns the original text.
- */
-function truncateText(text, maxLength = MAX_CHAR) {
-  if (text.length > maxLength) {
-    return `${text.slice(0, maxLength)}... [text truncated for brevity]`;
-  }
-  return text;
-}
-
-/**
- * Truncates a given text to a specified maximum length by showing the first half and the last half of the text,
- * separated by ellipsis. This method ensures the output does not exceed the maximum length, including the addition
- * of ellipsis and notification if the original text exceeds the maximum length.
- *
- * @param {string} text - The text to be truncated.
- * @param {number} [maxLength=MAX_CHAR] - The maximum length of the output text after truncation. Defaults to MAX_CHAR.
- * @returns {string} The truncated text showing the first half and the last half, or the original text if it does not exceed maxLength.
- */
-function smartTruncateText(text, maxLength = MAX_CHAR) {
-  const ellipsis = '...';
-  const notification = ' [text truncated for brevity]';
-  const halfMaxLength = Math.floor((maxLength - ellipsis.length - notification.length) / 2);
-
-  if (text.length > maxLength) {
-    const startLastHalf = text.length - halfMaxLength;
-    return `${text.slice(0, halfMaxLength)}${ellipsis}${text.slice(startLastHalf)}${notification}`;
-  }
-
-  return text;
-}
-
-module.exports = { truncateText, smartTruncateText };

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

@@ -1,3 +1,4 @@
+const { SplitStreamHandler } = require('@librechat/agents');
 const { anthropicSettings } = require('librechat-data-provider');
 const AnthropicClient = require('~/app/clients/AnthropicClient');
 
@@ -405,4 +406,327 @@ describe('AnthropicClient', () => {
       expect(Number.isNaN(result)).toBe(false);
     });
   });
+
+  describe('maxOutputTokens handling for different models', () => {
+    it('should not cap maxOutputTokens for Claude 3.5 Sonnet models', () => {
+      const client = new AnthropicClient('test-api-key');
+      const highTokenValue = anthropicSettings.legacy.maxOutputTokens.default * 10;
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-5-sonnet',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(highTokenValue);
+
+      // Test with decimal notation
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3.5-sonnet',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(highTokenValue);
+    });
+
+    it('should not cap maxOutputTokens for Claude 3.7 models', () => {
+      const client = new AnthropicClient('test-api-key');
+      const highTokenValue = anthropicSettings.legacy.maxOutputTokens.default * 2;
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-7-sonnet',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(highTokenValue);
+
+      // Test with decimal notation
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3.7-sonnet',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(highTokenValue);
+    });
+
+    it('should cap maxOutputTokens for Claude 3.5 Haiku models', () => {
+      const client = new AnthropicClient('test-api-key');
+      const highTokenValue = anthropicSettings.legacy.maxOutputTokens.default * 2;
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-5-haiku',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(
+        anthropicSettings.legacy.maxOutputTokens.default,
+      );
+
+      // Test with decimal notation
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3.5-haiku',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(
+        anthropicSettings.legacy.maxOutputTokens.default,
+      );
+    });
+
+    it('should cap maxOutputTokens for Claude 3 Haiku and Opus models', () => {
+      const client = new AnthropicClient('test-api-key');
+      const highTokenValue = anthropicSettings.legacy.maxOutputTokens.default * 2;
+
+      // Test haiku
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-haiku',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(
+        anthropicSettings.legacy.maxOutputTokens.default,
+      );
+
+      // Test opus
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-opus',
+          maxOutputTokens: highTokenValue,
+        },
+      });
+
+      expect(client.modelOptions.maxOutputTokens).toBe(
+        anthropicSettings.legacy.maxOutputTokens.default,
+      );
+    });
+  });
+
+  describe('topK/topP parameters for different models', () => {
+    beforeEach(() => {
+      // Mock the SplitStreamHandler
+      jest.spyOn(SplitStreamHandler.prototype, 'handle').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should include top_k and top_p parameters for non-claude-3.7 models', async () => {
+      const client = new AnthropicClient('test-api-key');
+
+      // Create a mock async generator function
+      async function* mockAsyncGenerator() {
+        yield { type: 'message_start', message: { usage: {} } };
+        yield { delta: { text: 'Test response' } };
+        yield { type: 'message_delta', usage: {} };
+      }
+
+      // Mock createResponse to return the async generator
+      jest.spyOn(client, 'createResponse').mockImplementation(() => {
+        return mockAsyncGenerator();
+      });
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-opus',
+          temperature: 0.7,
+          topK: 10,
+          topP: 0.9,
+        },
+      });
+
+      // Mock getClient to capture the request options
+      let capturedOptions = null;
+      jest.spyOn(client, 'getClient').mockImplementation((options) => {
+        capturedOptions = options;
+        return {};
+      });
+
+      const payload = [{ role: 'user', content: 'Test message' }];
+      await client.sendCompletion(payload, {});
+
+      // Check the options passed to getClient
+      expect(capturedOptions).toHaveProperty('top_k', 10);
+      expect(capturedOptions).toHaveProperty('top_p', 0.9);
+    });
+
+    it('should include top_k and top_p parameters for claude-3-5-sonnet models', async () => {
+      const client = new AnthropicClient('test-api-key');
+
+      // Create a mock async generator function
+      async function* mockAsyncGenerator() {
+        yield { type: 'message_start', message: { usage: {} } };
+        yield { delta: { text: 'Test response' } };
+        yield { type: 'message_delta', usage: {} };
+      }
+
+      // Mock createResponse to return the async generator
+      jest.spyOn(client, 'createResponse').mockImplementation(() => {
+        return mockAsyncGenerator();
+      });
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-5-sonnet',
+          temperature: 0.7,
+          topK: 10,
+          topP: 0.9,
+        },
+      });
+
+      // Mock getClient to capture the request options
+      let capturedOptions = null;
+      jest.spyOn(client, 'getClient').mockImplementation((options) => {
+        capturedOptions = options;
+        return {};
+      });
+
+      const payload = [{ role: 'user', content: 'Test message' }];
+      await client.sendCompletion(payload, {});
+
+      // Check the options passed to getClient
+      expect(capturedOptions).toHaveProperty('top_k', 10);
+      expect(capturedOptions).toHaveProperty('top_p', 0.9);
+    });
+
+    it('should not include top_k and top_p parameters for claude-3-7-sonnet models', async () => {
+      const client = new AnthropicClient('test-api-key');
+
+      // Create a mock async generator function
+      async function* mockAsyncGenerator() {
+        yield { type: 'message_start', message: { usage: {} } };
+        yield { delta: { text: 'Test response' } };
+        yield { type: 'message_delta', usage: {} };
+      }
+
+      // Mock createResponse to return the async generator
+      jest.spyOn(client, 'createResponse').mockImplementation(() => {
+        return mockAsyncGenerator();
+      });
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3-7-sonnet',
+          temperature: 0.7,
+          topK: 10,
+          topP: 0.9,
+        },
+      });
+
+      // Mock getClient to capture the request options
+      let capturedOptions = null;
+      jest.spyOn(client, 'getClient').mockImplementation((options) => {
+        capturedOptions = options;
+        return {};
+      });
+
+      const payload = [{ role: 'user', content: 'Test message' }];
+      await client.sendCompletion(payload, {});
+
+      // Check the options passed to getClient
+      expect(capturedOptions).not.toHaveProperty('top_k');
+      expect(capturedOptions).not.toHaveProperty('top_p');
+    });
+
+    it('should not include top_k and top_p parameters for models with decimal notation (claude-3.7)', async () => {
+      const client = new AnthropicClient('test-api-key');
+
+      // Create a mock async generator function
+      async function* mockAsyncGenerator() {
+        yield { type: 'message_start', message: { usage: {} } };
+        yield { delta: { text: 'Test response' } };
+        yield { type: 'message_delta', usage: {} };
+      }
+
+      // Mock createResponse to return the async generator
+      jest.spyOn(client, 'createResponse').mockImplementation(() => {
+        return mockAsyncGenerator();
+      });
+
+      client.setOptions({
+        modelOptions: {
+          model: 'claude-3.7-sonnet',
+          temperature: 0.7,
+          topK: 10,
+          topP: 0.9,
+        },
+      });
+
+      // Mock getClient to capture the request options
+      let capturedOptions = null;
+      jest.spyOn(client, 'getClient').mockImplementation((options) => {
+        capturedOptions = options;
+        return {};
+      });
+
+      const payload = [{ role: 'user', content: 'Test message' }];
+      await client.sendCompletion(payload, {});
+
+      // Check the options passed to getClient
+      expect(capturedOptions).not.toHaveProperty('top_k');
+      expect(capturedOptions).not.toHaveProperty('top_p');
+    });
+  });
+
+  it('should include top_k and top_p parameters for Claude-3.7 models when thinking is explicitly disabled', async () => {
+    const client = new AnthropicClient('test-api-key', {
+      modelOptions: {
+        model: 'claude-3-7-sonnet',
+        temperature: 0.7,
+        topK: 10,
+        topP: 0.9,
+      },
+      thinking: false,
+    });
+
+    async function* mockAsyncGenerator() {
+      yield { type: 'message_start', message: { usage: {} } };
+      yield { delta: { text: 'Test response' } };
+      yield { type: 'message_delta', usage: {} };
+    }
+
+    jest.spyOn(client, 'createResponse').mockImplementation(() => {
+      return mockAsyncGenerator();
+    });
+
+    let capturedOptions = null;
+    jest.spyOn(client, 'getClient').mockImplementation((options) => {
+      capturedOptions = options;
+      return {};
+    });
+
+    const payload = [{ role: 'user', content: 'Test message' }];
+    await client.sendCompletion(payload, {});
+
+    expect(capturedOptions).toHaveProperty('topK', 10);
+    expect(capturedOptions).toHaveProperty('topP', 0.9);
+
+    client.setOptions({
+      modelOptions: {
+        model: 'claude-3.7-sonnet',
+        temperature: 0.7,
+        topK: 10,
+        topP: 0.9,
+      },
+      thinking: false,
+    });
+
+    await client.sendCompletion(payload, {});
+
+    expect(capturedOptions).toHaveProperty('topK', 10);
+    expect(capturedOptions).toHaveProperty('topP', 0.9);
+  });
 });

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

@@ -30,6 +30,8 @@ jest.mock('~/models', () => ({
   updateFileUsage: jest.fn(),
 }));
 
+const { getConvo, saveConvo } = require('~/models');
+
 jest.mock('@langchain/openai', () => {
   return {
     ChatOpenAI: jest.fn().mockImplementation(() => {
@@ -88,6 +90,19 @@ describe('BaseClient', () => {
     const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }];
     const instructions = { content: 'Please respond to the question.' };
     const result = TestClient.addInstructions(messages, instructions);
+    const expected = [
+      { content: 'Please respond to the question.' },
+      { content: 'Hello' },
+      { content: 'How are you?' },
+      { content: 'Goodbye' },
+    ];
+    expect(result).toEqual(expected);
+  });
+
+  test('returns the input messages with instructions properly added when addInstructions() with legacy flag', () => {
+    const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }];
+    const instructions = { content: 'Please respond to the question.' };
+    const result = TestClient.addInstructions(messages, instructions, true);
     const expected = [
       { content: 'Hello' },
       { content: 'How are you?' },
@@ -146,10 +161,10 @@ describe('BaseClient', () => {
       expectedMessagesToRefine?.[expectedMessagesToRefine.length - 1] ?? {};
     const expectedIndex = messages.findIndex((msg) => msg.content === lastExpectedMessage?.content);
 
-    const result = await TestClient.getMessagesWithinTokenLimit(messages);
+    const result = await TestClient.getMessagesWithinTokenLimit({ messages });
 
     expect(result.context).toEqual(expectedContext);
-    expect(result.summaryIndex).toEqual(expectedIndex);
+    expect(result.messagesToRefine.length - 1).toEqual(expectedIndex);
     expect(result.remainingContextTokens).toBe(expectedRemainingContextTokens);
     expect(result.messagesToRefine).toEqual(expectedMessagesToRefine);
   });
@@ -182,74 +197,14 @@ describe('BaseClient', () => {
       expectedMessagesToRefine?.[expectedMessagesToRefine.length - 1] ?? {};
     const expectedIndex = messages.findIndex((msg) => msg.content === lastExpectedMessage?.content);
 
-    const result = await TestClient.getMessagesWithinTokenLimit(messages);
+    const result = await TestClient.getMessagesWithinTokenLimit({ messages });
 
     expect(result.context).toEqual(expectedContext);
-    expect(result.summaryIndex).toEqual(expectedIndex);
+    expect(result.messagesToRefine.length - 1).toEqual(expectedIndex);
     expect(result.remainingContextTokens).toBe(expectedRemainingContextTokens);
     expect(result.messagesToRefine).toEqual(expectedMessagesToRefine);
   });
 
-  test('handles context strategy correctly in handleContextStrategy()', async () => {
-    TestClient.addInstructions = jest
-      .fn()
-      .mockReturnValue([
-        { content: 'Hello' },
-        { content: 'How can I help you?' },
-        { content: 'Please provide more details.' },
-        { content: 'I can assist you with that.' },
-      ]);
-    TestClient.getMessagesWithinTokenLimit = jest.fn().mockReturnValue({
-      context: [
-        { content: 'How can I help you?' },
-        { content: 'Please provide more details.' },
-        { content: 'I can assist you with that.' },
-      ],
-      remainingContextTokens: 80,
-      messagesToRefine: [{ content: 'Hello' }],
-      summaryIndex: 3,
-    });
-
-    TestClient.getTokenCount = jest.fn().mockReturnValue(40);
-
-    const instructions = { content: 'Please provide more details.' };
-    const orderedMessages = [
-      { content: 'Hello' },
-      { content: 'How can I help you?' },
-      { content: 'Please provide more details.' },
-      { content: 'I can assist you with that.' },
-    ];
-    const formattedMessages = [
-      { content: 'Hello' },
-      { content: 'How can I help you?' },
-      { content: 'Please provide more details.' },
-      { content: 'I can assist you with that.' },
-    ];
-    const expectedResult = {
-      payload: [
-        {
-          role: 'system',
-          content: 'Refined answer',
-        },
-        { content: 'How can I help you?' },
-        { content: 'Please provide more details.' },
-        { content: 'I can assist you with that.' },
-      ],
-      promptTokens: expect.any(Number),
-      tokenCountMap: {},
-      messages: expect.any(Array),
-    };
-
-    TestClient.shouldSummarize = true;
-    const result = await TestClient.handleContextStrategy({
-      instructions,
-      orderedMessages,
-      formattedMessages,
-    });
-
-    expect(result).toEqual(expectedResult);
-  });
-
   describe('getMessagesForConversation', () => {
     it('should return an empty array if the parentMessageId does not exist', () => {
       const result = TestClient.constructor.getMessagesForConversation({
@@ -587,10 +542,11 @@ describe('BaseClient', () => {
 
     test('saveMessageToDatabase is called with the correct arguments', async () => {
       const saveOptions = TestClient.getSaveOptions();
-      const user = {}; // Mock user
+      const user = {};
       const opts = { user };
+      const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase');
       await TestClient.sendMessage('Hello, world!', opts);
-      expect(TestClient.saveMessageToDatabase).toHaveBeenCalledWith(
+      expect(saveSpy).toHaveBeenCalledWith(
         expect.objectContaining({
           sender: expect.any(String),
           text: expect.any(String),
@@ -604,6 +560,157 @@ describe('BaseClient', () => {
       );
     });
 
+    test('should handle existing conversation when getConvo retrieves one', async () => {
+      const existingConvo = {
+        conversationId: 'existing-convo-id',
+        endpoint: 'openai',
+        endpointType: 'openai',
+        model: 'gpt-3.5-turbo',
+        messages: [
+          { role: 'user', content: 'Existing message 1' },
+          { role: 'assistant', content: 'Existing response 1' },
+        ],
+        temperature: 1,
+      };
+
+      const { temperature: _temp, ...newConvo } = existingConvo;
+
+      const user = {
+        id: 'user-id',
+      };
+
+      getConvo.mockResolvedValue(existingConvo);
+      saveConvo.mockResolvedValue(newConvo);
+
+      TestClient = initializeFakeClient(
+        apiKey,
+        {
+          ...options,
+          req: {
+            user,
+          },
+        },
+        [],
+      );
+
+      const saveSpy = jest.spyOn(TestClient, 'saveMessageToDatabase');
+
+      const newMessage = 'New message in existing conversation';
+      const response = await TestClient.sendMessage(newMessage, {
+        user,
+        conversationId: existingConvo.conversationId,
+      });
+
+      expect(getConvo).toHaveBeenCalledWith(user.id, existingConvo.conversationId);
+      expect(TestClient.conversationId).toBe(existingConvo.conversationId);
+      expect(response.conversationId).toBe(existingConvo.conversationId);
+      expect(TestClient.fetchedConvo).toBe(true);
+
+      expect(saveSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          conversationId: existingConvo.conversationId,
+          text: newMessage,
+        }),
+        expect.any(Object),
+        expect.any(Object),
+      );
+
+      expect(saveConvo).toHaveBeenCalledTimes(2);
+      expect(saveConvo).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({
+          conversationId: existingConvo.conversationId,
+        }),
+        expect.objectContaining({
+          context: 'api/app/clients/BaseClient.js - saveMessageToDatabase #saveConvo',
+          unsetFields: {
+            temperature: 1,
+          },
+        }),
+      );
+
+      await TestClient.sendMessage('Another message', {
+        conversationId: existingConvo.conversationId,
+      });
+      expect(getConvo).toHaveBeenCalledTimes(1);
+    });
+
+    test('should correctly handle existing conversation and unset fields appropriately', async () => {
+      const existingConvo = {
+        conversationId: 'existing-convo-id',
+        endpoint: 'openai',
+        endpointType: 'openai',
+        model: 'gpt-3.5-turbo',
+        messages: [
+          { role: 'user', content: 'Existing message 1' },
+          { role: 'assistant', content: 'Existing response 1' },
+        ],
+        title: 'Existing Conversation',
+        someExistingField: 'existingValue',
+        anotherExistingField: 'anotherValue',
+        temperature: 0.7,
+        modelLabel: 'GPT-3.5',
+      };
+
+      getConvo.mockResolvedValue(existingConvo);
+      saveConvo.mockResolvedValue(existingConvo);
+
+      TestClient = initializeFakeClient(
+        apiKey,
+        {
+          ...options,
+          modelOptions: {
+            model: 'gpt-4',
+            temperature: 0.5,
+          },
+        },
+        [],
+      );
+
+      const newMessage = 'New message in existing conversation';
+      await TestClient.sendMessage(newMessage, {
+        conversationId: existingConvo.conversationId,
+      });
+
+      expect(saveConvo).toHaveBeenCalledTimes(2);
+
+      const saveConvoCall = saveConvo.mock.calls[0];
+      const [, savedFields, saveOptions] = saveConvoCall;
+
+      // Instead of checking all excludedKeys, we'll just check specific fields
+      // that we know should be excluded
+      expect(savedFields).not.toHaveProperty('messages');
+      expect(savedFields).not.toHaveProperty('title');
+
+      // Only check that someExistingField is in unsetFields
+      expect(saveOptions.unsetFields).toHaveProperty('someExistingField', 1);
+
+      // Mock saveConvo to return the expected fields
+      saveConvo.mockImplementation((req, fields) => {
+        return Promise.resolve({
+          ...fields,
+          endpoint: 'openai',
+          endpointType: 'openai',
+          model: 'gpt-4',
+          temperature: 0.5,
+        });
+      });
+
+      // Only check the conversationId since that's the only field we can be sure about
+      expect(savedFields).toHaveProperty('conversationId', 'existing-convo-id');
+
+      expect(TestClient.fetchedConvo).toBe(true);
+
+      await TestClient.sendMessage('Another message', {
+        conversationId: existingConvo.conversationId,
+      });
+
+      expect(getConvo).toHaveBeenCalledTimes(1);
+
+      const secondSaveConvoCall = saveConvo.mock.calls[1];
+      expect(secondSaveConvoCall[2]).toHaveProperty('unsetFields', {});
+    });
+
     test('sendCompletion is called with the correct arguments', async () => {
       const payload = {}; // Mock payload
       TestClient.buildMessages.mockReturnValue({ prompt: payload, tokenCountMap: null });
@@ -615,9 +722,9 @@ describe('BaseClient', () => {
     test('getTokenCount for response is called with the correct arguments', async () => {
       const tokenCountMap = {}; // Mock tokenCountMap
       TestClient.buildMessages.mockReturnValue({ prompt: [], tokenCountMap });
-      TestClient.getTokenCount = jest.fn();
+      TestClient.getTokenCountForResponse = jest.fn();
       const response = await TestClient.sendMessage('Hello, world!', {});
-      expect(TestClient.getTokenCount).toHaveBeenCalledWith(response.text);
+      expect(TestClient.getTokenCountForResponse).toHaveBeenCalledWith(response);
     });
 
     test('returns an object with the correct shape', async () => {
@@ -661,4 +768,112 @@ describe('BaseClient', () => {
       expect(calls[1][0].isCreatedByUser).toBe(false); // Second call should be for response message
     });
   });
+
+  describe('getMessagesWithinTokenLimit with instructions', () => {
+    test('should always include instructions when present', async () => {
+      TestClient.maxContextTokens = 50;
+      const instructions = {
+        role: 'system',
+        content: 'System instructions',
+        tokenCount: 20,
+      };
+
+      const messages = [
+        instructions,
+        { role: 'user', content: 'Hello', tokenCount: 10 },
+        { role: 'assistant', content: 'Hi there', tokenCount: 15 },
+      ];
+
+      const result = await TestClient.getMessagesWithinTokenLimit({
+        messages,
+        instructions,
+      });
+
+      expect(result.context[0]).toBe(instructions);
+      expect(result.remainingContextTokens).toBe(2);
+    });
+
+    test('should handle case when messages exceed limit but instructions must be preserved', async () => {
+      TestClient.maxContextTokens = 30;
+      const instructions = {
+        role: 'system',
+        content: 'System instructions',
+        tokenCount: 20,
+      };
+
+      const messages = [
+        instructions,
+        { role: 'user', content: 'Hello', tokenCount: 10 },
+        { role: 'assistant', content: 'Hi there', tokenCount: 15 },
+      ];
+
+      const result = await TestClient.getMessagesWithinTokenLimit({
+        messages,
+        instructions,
+      });
+
+      // Should only include instructions and the last message that fits
+      expect(result.context).toHaveLength(1);
+      expect(result.context[0].content).toBe(instructions.content);
+      expect(result.messagesToRefine).toHaveLength(2);
+      expect(result.remainingContextTokens).toBe(7); // 30 - 20 - 3 (assistant label)
+    });
+
+    test('should work correctly without instructions (1/2)', async () => {
+      TestClient.maxContextTokens = 50;
+      const messages = [
+        { role: 'user', content: 'Hello', tokenCount: 10 },
+        { role: 'assistant', content: 'Hi there', tokenCount: 15 },
+      ];
+
+      const result = await TestClient.getMessagesWithinTokenLimit({
+        messages,
+      });
+
+      expect(result.context).toHaveLength(2);
+      expect(result.remainingContextTokens).toBe(22); // 50 - 10 - 15 - 3(assistant label)
+      expect(result.messagesToRefine).toHaveLength(0);
+    });
+
+    test('should work correctly without instructions (2/2)', async () => {
+      TestClient.maxContextTokens = 30;
+      const messages = [
+        { role: 'user', content: 'Hello', tokenCount: 10 },
+        { role: 'assistant', content: 'Hi there', tokenCount: 20 },
+      ];
+
+      const result = await TestClient.getMessagesWithinTokenLimit({
+        messages,
+      });
+
+      expect(result.context).toHaveLength(1);
+      expect(result.remainingContextTokens).toBe(7);
+      expect(result.messagesToRefine).toHaveLength(1);
+    });
+
+    test('should handle case when only instructions fit within limit', async () => {
+      TestClient.maxContextTokens = 25;
+      const instructions = {
+        role: 'system',
+        content: 'System instructions',
+        tokenCount: 20,
+      };
+
+      const messages = [
+        instructions,
+        { role: 'user', content: 'Hello', tokenCount: 10 },
+        { role: 'assistant', content: 'Hi there', tokenCount: 15 },
+      ];
+
+      const result = await TestClient.getMessagesWithinTokenLimit({
+        messages,
+        instructions,
+      });
+
+      expect(result.context).toHaveLength(1);
+      expect(result.context[0]).toBe(instructions);
+      expect(result.messagesToRefine).toHaveLength(2);
+      expect(result.remainingContextTokens).toBe(2); // 25 - 20 - 3(assistant label)
+    });
+  });
 });

api/app/clients/specs/FakeClient.js

@@ -56,7 +56,6 @@ const initializeFakeClient = (apiKey, options, fakeMessages) => {
   let TestClient = new FakeClient(apiKey);
   TestClient.options = options;
   TestClient.abortController = { abort: jest.fn() };
-  TestClient.saveMessageToDatabase = jest.fn();
   TestClient.loadHistory = jest
     .fn()
     .mockImplementation((conversationId, parentMessageId = null) => {
@@ -86,7 +85,6 @@ const initializeFakeClient = (apiKey, options, fakeMessages) => {
     return 'Mock response text';
   });
 
-  // eslint-disable-next-line no-unused-vars
   TestClient.getCompletion = jest.fn().mockImplementation(async (..._args) => {
     return {
       choices: [

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

@@ -1,5 +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 OpenAIClient = require('../OpenAIClient');
@@ -134,7 +136,14 @@ OpenAI.mockImplementation(() => ({
 }));
 
 describe('OpenAIClient', () => {
-  let client, client2;
+  beforeEach(() => {
+    const mockCache = {
+      get: jest.fn().mockResolvedValue({}),
+      set: jest.fn(),
+    };
+    getLogStores.mockReturnValue(mockCache);
+  });
+  let client;
   const model = 'gpt-4';
   const parentMessageId = '1';
   const messages = [
@@ -176,7 +185,6 @@ describe('OpenAIClient', () => {
   beforeEach(() => {
     const options = { ...defaultOptions };
     client = new OpenAIClient('test-api-key', options);
-    client2 = new OpenAIClient('test-api-key', options);
     client.summarizeMessages = jest.fn().mockResolvedValue({
       role: 'assistant',
       content: 'Refined answer',
@@ -185,7 +193,6 @@ describe('OpenAIClient', () => {
     client.buildPrompt = jest
       .fn()
       .mockResolvedValue({ prompt: messages.map((m) => m.text).join('\n') });
-    client.constructor.freeAndResetAllEncoders();
     client.getMessages = jest.fn().mockResolvedValue([]);
   });
 
@@ -196,14 +203,6 @@ describe('OpenAIClient', () => {
       expect(client.modelOptions.temperature).toBe(0.7);
     });
 
-    it('should set apiKey and useOpenRouter if OPENROUTER_API_KEY is present', () => {
-      process.env.OPENROUTER_API_KEY = 'openrouter-key';
-      client.setOptions({});
-      expect(client.apiKey).toBe('openrouter-key');
-      expect(client.useOpenRouter).toBe(true);
-      delete process.env.OPENROUTER_API_KEY; // Cleanup
-    });
-
     it('should set FORCE_PROMPT based on OPENAI_FORCE_PROMPT or reverseProxyUrl', () => {
       process.env.OPENAI_FORCE_PROMPT = 'true';
       client.setOptions({});
@@ -335,77 +334,11 @@ describe('OpenAIClient', () => {
     });
   });
 
-  describe('selectTokenizer', () => {
-    it('should get the correct tokenizer based on the instance state', () => {
-      const tokenizer = client.selectTokenizer();
-      expect(tokenizer).toBeDefined();
-    });
-  });
-
-  describe('freeAllTokenizers', () => {
-    it('should free all tokenizers', () => {
-      // Create a tokenizer
-      const tokenizer = client.selectTokenizer();
-
-      // Mock 'free' method on the tokenizer
-      tokenizer.free = jest.fn();
-
-      client.constructor.freeAndResetAllEncoders();
-
-      // Check if 'free' method has been called on the tokenizer
-      expect(tokenizer.free).toHaveBeenCalled();
-    });
-  });
-
   describe('getTokenCount', () => {
     it('should return the correct token count', () => {
       const count = client.getTokenCount('Hello, world!');
       expect(count).toBeGreaterThan(0);
     });
-
-    it('should reset the encoder and count when count reaches 25', () => {
-      const freeAndResetEncoderSpy = jest.spyOn(client.constructor, 'freeAndResetAllEncoders');
-
-      // Call getTokenCount 25 times
-      for (let i = 0; i < 25; i++) {
-        client.getTokenCount('test text');
-      }
-
-      expect(freeAndResetEncoderSpy).toHaveBeenCalled();
-    });
-
-    it('should not reset the encoder and count when count is less than 25', () => {
-      const freeAndResetEncoderSpy = jest.spyOn(client.constructor, 'freeAndResetAllEncoders');
-      freeAndResetEncoderSpy.mockClear();
-
-      // Call getTokenCount 24 times
-      for (let i = 0; i < 24; i++) {
-        client.getTokenCount('test text');
-      }
-
-      expect(freeAndResetEncoderSpy).not.toHaveBeenCalled();
-    });
-
-    it('should handle errors and reset the encoder', () => {
-      const freeAndResetEncoderSpy = jest.spyOn(client.constructor, 'freeAndResetAllEncoders');
-
-      // Mock encode function to throw an error
-      client.selectTokenizer().encode = jest.fn().mockImplementation(() => {
-        throw new Error('Test error');
-      });
-
-      client.getTokenCount('test text');
-
-      expect(freeAndResetEncoderSpy).toHaveBeenCalled();
-    });
-
-    it('should not throw null pointer error when freeing the same encoder twice', () => {
-      client.constructor.freeAndResetAllEncoders();
-      client2.constructor.freeAndResetAllEncoders();
-
-      const count = client2.getTokenCount('test text');
-      expect(count).toBeGreaterThan(0);
-    });
   });
 
   describe('getSaveOptions', () => {
@@ -548,7 +481,6 @@ describe('OpenAIClient', () => {
     testCases.forEach((testCase) => {
       it(`should return ${testCase.expected} tokens for model ${testCase.model}`, () => {
         client.modelOptions.model = testCase.model;
-        client.selectTokenizer();
         // 3 tokens for assistant label
         let totalTokens = 3;
         for (let message of example_messages) {
@@ -582,7 +514,6 @@ describe('OpenAIClient', () => {
 
     it(`should return ${expectedTokens} tokens for model ${visionModel} (Vision Request)`, () => {
       client.modelOptions.model = visionModel;
-      client.selectTokenizer();
       // 3 tokens for assistant label
       let totalTokens = 3;
       for (let message of vision_request) {
@@ -596,7 +527,6 @@ describe('OpenAIClient', () => {
     afterEach(() => {
       delete process.env.AZURE_OPENAI_DEFAULT_MODEL;
       delete process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME;
-      delete process.env.OPENROUTER_API_KEY;
     });
 
     it('should call getCompletion and fetchEventSource when using a text/instruct model', async () => {

api/app/clients/tools/index.js

@@ -2,21 +2,42 @@ const availableTools = require('./manifest.json');
 
 // Structured Tools
 const DALLE3 = require('./structured/DALLE3');
+const FluxAPI = require('./structured/FluxAPI');
+const OpenWeather = require('./structured/OpenWeather');
 const StructuredWolfram = require('./structured/Wolfram');
+const createYouTubeTools = require('./structured/YouTube');
 const StructuredACS = require('./structured/AzureAISearch');
 const StructuredSD = require('./structured/StableDiffusion');
 const GoogleSearchAPI = require('./structured/GoogleSearch');
 const TraversaalSearch = require('./structured/TraversaalSearch');
 const TavilySearchResults = require('./structured/TavilySearchResults');
 
+/** @type {Record<string, TPlugin | undefined>} */
+const manifestToolMap = {};
+
+/** @type {Array<TPlugin>} */
+const toolkits = [];
+
+availableTools.forEach((tool) => {
+  manifestToolMap[tool.pluginKey] = tool;
+  if (tool.toolkit === true) {
+    toolkits.push(tool);
+  }
+});
+
 module.exports = {
+  toolkits,
   availableTools,
+  manifestToolMap,
   // Structured Tools
   DALLE3,
+  FluxAPI,
+  OpenWeather,
   StructuredSD,
   StructuredACS,
   GoogleSearchAPI,
   TraversaalSearch,
   StructuredWolfram,
+  createYouTubeTools,
   TavilySearchResults,
 };

api/app/clients/tools/manifest.json

@@ -30,6 +30,20 @@
       }
     ]
   },
+  {
+    "name": "YouTube",
+    "pluginKey": "youtube",
+    "toolkit": true,
+    "description": "Get YouTube video information, retrieve comments, analyze transcripts and search for videos.",
+    "icon": "https://www.youtube.com/s/desktop/7449ebf7/img/favicon_144x144.png",
+    "authConfig": [
+      {
+        "authField": "YOUTUBE_API_KEY",
+        "label": "YouTube API Key",
+        "description": "Your YouTube Data API v3 key."
+      }
+    ]
+  },
   {
     "name": "Wolfram",
     "pluginKey": "wolfram",
@@ -100,7 +114,6 @@
     "pluginKey": "calculator",
     "description": "Perform simple and complex mathematical calculations.",
     "icon": "https://i.imgur.com/RHsSG5h.png",
-    "isAuthRequired": "false",
     "authConfig": []
   },
   {
@@ -135,7 +148,34 @@
       {
         "authField": "AZURE_AI_SEARCH_API_KEY",
         "label": "Azure AI Search API Key",
-        "description": "You need to provideq your API Key for Azure AI Search."
+        "description": "You need to provide your API Key for Azure AI Search."
+      }
+    ]
+  },
+  {
+    "name": "OpenWeather",
+    "pluginKey": "open_weather",
+    "description": "Get weather forecasts and historical data from the OpenWeather API",
+    "icon": "/assets/openweather.png",
+    "authConfig": [
+      {
+        "authField": "OPENWEATHER_API_KEY",
+        "label": "OpenWeather API Key",
+        "description": "Sign up at <a href=\"https://home.openweathermap.org/users/sign_up\" target=\"_blank\">OpenWeather</a>, then get your key at <a href=\"https://home.openweathermap.org/api_keys\" target=\"_blank\">API keys</a>."
+      }
+    ]
+  },
+  {
+    "name": "Flux",
+    "pluginKey": "flux",
+    "description": "Generate images using text with the Flux API.",
+    "icon": "https://blackforestlabs.ai/wp-content/uploads/2024/07/bfl_logo_retraced_blk.png",
+    "isAuthRequired": "true",
+    "authConfig": [
+      {
+        "authField": "FLUX_API_KEY",
+        "label": "Your Flux API Key",
+        "description": "Provide your Flux API key from your user profile."
       }
     ]
   }

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

@@ -1,14 +1,17 @@
 const { z } = require('zod');
 const path = require('path');
 const OpenAI = require('openai');
+const fetch = require('node-fetch');
 const { v4: uuidv4 } = require('uuid');
 const { Tool } = require('@langchain/core/tools');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { FileContext } = require('librechat-data-provider');
+const { FileContext, ContentTypes } = require('librechat-data-provider');
 const { getImageBasename } = require('~/server/services/Files/images');
 const extractBaseURL = require('~/utils/extractBaseURL');
 const { logger } = require('~/config');
 
+const displayMessage =
+  'DALL-E displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.';
 class DALLE3 extends Tool {
   constructor(fields = {}) {
     super();
@@ -114,10 +117,7 @@ class DALLE3 extends Tool {
     if (this.isAgent === true && typeof value === 'string') {
       return [value, {}];
     } else if (this.isAgent === true && typeof value === 'object') {
-      return [
-        'DALL-E displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.',
-        value,
-      ];
+      return [displayMessage, value];
     }
 
     return value;
@@ -160,6 +160,32 @@ Error Message: ${error.message}`);
       );
     }
 
+    if (this.isAgent) {
+      let fetchOptions = {};
+      if (process.env.PROXY) {
+        fetchOptions.agent = new HttpsProxyAgent(process.env.PROXY);
+      }
+      const imageResponse = await fetch(theImageUrl, fetchOptions);
+      const arrayBuffer = await imageResponse.arrayBuffer();
+      const base64 = Buffer.from(arrayBuffer).toString('base64');
+      const content = [
+        {
+          type: ContentTypes.IMAGE_URL,
+          image_url: {
+            url: `data:image/png;base64,${base64}`,
+          },
+        },
+      ];
+
+      const response = [
+        {
+          type: ContentTypes.TEXT,
+          text: displayMessage,
+        },
+      ];
+      return [response, { content }];
+    }
+
     const imageBasename = getImageBasename(theImageUrl);
     const imageExt = path.extname(imageBasename);
 

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

@@ -0,0 +1,554 @@
+const { z } = require('zod');
+const axios = require('axios');
+const fetch = require('node-fetch');
+const { v4: uuidv4 } = require('uuid');
+const { Tool } = require('@langchain/core/tools');
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const { FileContext, ContentTypes } = require('librechat-data-provider');
+const { logger } = require('~/config');
+
+const displayMessage =
+  'Flux displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.';
+
+/**
+ * FluxAPI - A tool for generating high-quality images from text prompts using the Flux API.
+ * Each call generates one image. If multiple images are needed, make multiple consecutive calls with the same or varied prompts.
+ */
+class FluxAPI extends Tool {
+  // Pricing constants in USD per image
+  static PRICING = {
+    FLUX_PRO_1_1_ULTRA: -0.06, // /v1/flux-pro-1.1-ultra
+    FLUX_PRO_1_1: -0.04, // /v1/flux-pro-1.1
+    FLUX_PRO: -0.05, // /v1/flux-pro
+    FLUX_DEV: -0.025, // /v1/flux-dev
+    FLUX_PRO_FINETUNED: -0.06, // /v1/flux-pro-finetuned
+    FLUX_PRO_1_1_ULTRA_FINETUNED: -0.07, // /v1/flux-pro-1.1-ultra-finetuned
+  };
+
+  constructor(fields = {}) {
+    super();
+
+    /** @type {boolean} Used to initialize the Tool without necessary variables. */
+    this.override = fields.override ?? false;
+
+    this.userId = fields.userId;
+    this.fileStrategy = fields.fileStrategy;
+
+    /** @type {boolean} **/
+    this.isAgent = fields.isAgent;
+    this.returnMetadata = fields.returnMetadata ?? false;
+
+    if (fields.processFileURL) {
+      /** @type {processFileURL} Necessary for output to contain all image metadata. */
+      this.processFileURL = fields.processFileURL.bind(this);
+    }
+
+    this.apiKey = fields.FLUX_API_KEY || this.getApiKey();
+
+    this.name = 'flux';
+    this.description =
+      'Use Flux to generate images from text descriptions. This tool can generate images and list available finetunes. Each generate call creates one image. For multiple images, make multiple consecutive calls.';
+
+    this.description_for_model = `// Transform any image description into a detailed, high-quality prompt. Never submit a prompt under 3 sentences. Follow these core rules:
+    // 1. ALWAYS enhance basic prompts into 5-10 detailed sentences (e.g., "a cat" becomes: "A close-up photo of a sleek Siamese cat with piercing blue eyes. The cat sits elegantly on a vintage leather armchair, its tail curled gracefully around its paws. Warm afternoon sunlight streams through a nearby window, casting gentle shadows across its face and highlighting the subtle variations in its cream and chocolate-point fur. The background is softly blurred, creating a shallow depth of field that draws attention to the cat's expressive features. The overall composition has a peaceful, contemplative mood with a professional photography style.")
+    // 2. Each prompt MUST be 3-6 descriptive sentences minimum, focusing on visual elements: lighting, composition, mood, and style
+    // Use action: 'list_finetunes' to see available custom models. When using finetunes, use endpoint: '/v1/flux-pro-finetuned' (default) or '/v1/flux-pro-1.1-ultra-finetuned' for higher quality and aspect ratio.`;
+
+    // Add base URL from environment variable with fallback
+    this.baseUrl = process.env.FLUX_API_BASE_URL || 'https://api.us1.bfl.ai';
+
+    // Define the schema for structured input
+    this.schema = z.object({
+      action: z
+        .enum(['generate', 'list_finetunes', 'generate_finetuned'])
+        .default('generate')
+        .describe(
+          'Action to perform: "generate" for image generation, "generate_finetuned" for finetuned model generation, "list_finetunes" to get available custom models',
+        ),
+      prompt: z
+        .string()
+        .optional()
+        .describe(
+          'Text prompt for image generation. Required when action is "generate". Not used for list_finetunes.',
+        ),
+      width: z
+        .number()
+        .optional()
+        .describe(
+          'Width of the generated image in pixels. Must be a multiple of 32. Default is 1024.',
+        ),
+      height: z
+        .number()
+        .optional()
+        .describe(
+          'Height of the generated image in pixels. Must be a multiple of 32. Default is 768.',
+        ),
+      prompt_upsampling: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to perform upsampling on the prompt.'),
+      steps: z
+        .number()
+        .int()
+        .optional()
+        .describe('Number of steps to run the model for, a number from 1 to 50. Default is 40.'),
+      seed: z.number().optional().describe('Optional seed for reproducibility.'),
+      safety_tolerance: z
+        .number()
+        .optional()
+        .default(6)
+        .describe(
+          'Tolerance level for input and output moderation. Between 0 and 6, 0 being most strict, 6 being least strict.',
+        ),
+      endpoint: z
+        .enum([
+          '/v1/flux-pro-1.1',
+          '/v1/flux-pro',
+          '/v1/flux-dev',
+          '/v1/flux-pro-1.1-ultra',
+          '/v1/flux-pro-finetuned',
+          '/v1/flux-pro-1.1-ultra-finetuned',
+        ])
+        .optional()
+        .default('/v1/flux-pro-1.1')
+        .describe('Endpoint to use for image generation.'),
+      raw: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe(
+          'Generate less processed, more natural-looking images. Only works for /v1/flux-pro-1.1-ultra.',
+        ),
+      finetune_id: z.string().optional().describe('ID of the finetuned model to use'),
+      finetune_strength: z
+        .number()
+        .optional()
+        .default(1.1)
+        .describe('Strength of the finetuning effect (typically between 0.1 and 1.2)'),
+      guidance: z.number().optional().default(2.5).describe('Guidance scale for finetuned models'),
+      aspect_ratio: z
+        .string()
+        .optional()
+        .default('16:9')
+        .describe('Aspect ratio for ultra models (e.g., "16:9")'),
+    });
+  }
+
+  getAxiosConfig() {
+    const config = {};
+    if (process.env.PROXY) {
+      config.httpsAgent = new HttpsProxyAgent(process.env.PROXY);
+    }
+    return config;
+  }
+
+  /** @param {Object|string} value */
+  getDetails(value) {
+    if (typeof value === 'string') {
+      return value;
+    }
+    return JSON.stringify(value, null, 2);
+  }
+
+  getApiKey() {
+    const apiKey = process.env.FLUX_API_KEY || '';
+    if (!apiKey && !this.override) {
+      throw new Error('Missing FLUX_API_KEY environment variable.');
+    }
+    return apiKey;
+  }
+
+  wrapInMarkdown(imageUrl) {
+    const serverDomain = process.env.DOMAIN_SERVER || 'http://localhost:3080';
+    return `![generated image](${serverDomain}${imageUrl})`;
+  }
+
+  returnValue(value) {
+    if (this.isAgent === true && typeof value === 'string') {
+      return [value, {}];
+    } else if (this.isAgent === true && typeof value === 'object') {
+      if (Array.isArray(value)) {
+        return value;
+      }
+      return [displayMessage, value];
+    }
+    return value;
+  }
+
+  async _call(data) {
+    const { action = 'generate', ...imageData } = data;
+
+    // Use provided API key for this request if available, otherwise use default
+    const requestApiKey = this.apiKey || this.getApiKey();
+
+    // Handle list_finetunes action
+    if (action === 'list_finetunes') {
+      return this.getMyFinetunes(requestApiKey);
+    }
+
+    // Handle finetuned generation
+    if (action === 'generate_finetuned') {
+      return this.generateFinetunedImage(imageData, requestApiKey);
+    }
+
+    // For generate action, ensure prompt is provided
+    if (!imageData.prompt) {
+      throw new Error('Missing required field: prompt');
+    }
+
+    let payload = {
+      prompt: imageData.prompt,
+      prompt_upsampling: imageData.prompt_upsampling || false,
+      safety_tolerance: imageData.safety_tolerance || 6,
+      output_format: imageData.output_format || 'png',
+    };
+
+    // Add optional parameters if provided
+    if (imageData.width) {
+      payload.width = imageData.width;
+    }
+    if (imageData.height) {
+      payload.height = imageData.height;
+    }
+    if (imageData.steps) {
+      payload.steps = imageData.steps;
+    }
+    if (imageData.seed !== undefined) {
+      payload.seed = imageData.seed;
+    }
+    if (imageData.raw) {
+      payload.raw = imageData.raw;
+    }
+
+    const generateUrl = `${this.baseUrl}${imageData.endpoint || '/v1/flux-pro'}`;
+    const resultUrl = `${this.baseUrl}/v1/get_result`;
+
+    logger.debug('[FluxAPI] Generating image with payload:', payload);
+    logger.debug('[FluxAPI] Using endpoint:', generateUrl);
+
+    let taskResponse;
+    try {
+      taskResponse = await axios.post(generateUrl, payload, {
+        headers: {
+          'x-key': requestApiKey,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+        ...this.getAxiosConfig(),
+      });
+    } catch (error) {
+      const details = this.getDetails(error?.response?.data || error.message);
+      logger.error('[FluxAPI] Error while submitting task:', details);
+
+      return this.returnValue(
+        `Something went wrong when trying to generate the image. The Flux API may be unavailable:
+        Error Message: ${details}`,
+      );
+    }
+
+    const taskId = taskResponse.data.id;
+
+    // Polling for the result
+    let status = 'Pending';
+    let resultData = null;
+    while (status !== 'Ready' && status !== 'Error') {
+      try {
+        // Wait 2 seconds between polls
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const resultResponse = await axios.get(resultUrl, {
+          headers: {
+            'x-key': requestApiKey,
+            Accept: 'application/json',
+          },
+          params: { id: taskId },
+          ...this.getAxiosConfig(),
+        });
+        status = resultResponse.data.status;
+
+        if (status === 'Ready') {
+          resultData = resultResponse.data.result;
+          break;
+        } else if (status === 'Error') {
+          logger.error('[FluxAPI] Error in task:', resultResponse.data);
+          return this.returnValue('An error occurred during image generation.');
+        }
+      } catch (error) {
+        const details = this.getDetails(error?.response?.data || error.message);
+        logger.error('[FluxAPI] Error while getting result:', details);
+        return this.returnValue('An error occurred while retrieving the image.');
+      }
+    }
+
+    // If no result data
+    if (!resultData || !resultData.sample) {
+      logger.error('[FluxAPI] No image data received from API. Response:', resultData);
+      return this.returnValue('No image data received from Flux API.');
+    }
+
+    // Try saving the image locally
+    const imageUrl = resultData.sample;
+    const imageName = `img-${uuidv4()}.png`;
+
+    if (this.isAgent) {
+      try {
+        // Fetch the image and convert to base64
+        const fetchOptions = {};
+        if (process.env.PROXY) {
+          fetchOptions.agent = new HttpsProxyAgent(process.env.PROXY);
+        }
+        const imageResponse = await fetch(imageUrl, fetchOptions);
+        const arrayBuffer = await imageResponse.arrayBuffer();
+        const base64 = Buffer.from(arrayBuffer).toString('base64');
+        const content = [
+          {
+            type: ContentTypes.IMAGE_URL,
+            image_url: {
+              url: `data:image/png;base64,${base64}`,
+            },
+          },
+        ];
+
+        const response = [
+          {
+            type: ContentTypes.TEXT,
+            text: displayMessage,
+          },
+        ];
+        return [response, { content }];
+      } catch (error) {
+        logger.error('Error processing image for agent:', error);
+        return this.returnValue(`Failed to process the image. ${error.message}`);
+      }
+    }
+
+    try {
+      logger.debug('[FluxAPI] Saving image:', imageUrl);
+      const result = await this.processFileURL({
+        fileStrategy: this.fileStrategy,
+        userId: this.userId,
+        URL: imageUrl,
+        fileName: imageName,
+        basePath: 'images',
+        context: FileContext.image_generation,
+      });
+
+      logger.debug('[FluxAPI] Image saved to path:', result.filepath);
+
+      // Calculate cost based on endpoint
+      /**
+       * TODO: Cost handling
+      const endpoint = imageData.endpoint || '/v1/flux-pro';
+      const endpointKey = Object.entries(FluxAPI.PRICING).find(([key, _]) =>
+        endpoint.includes(key.toLowerCase().replace(/_/g, '-')),
+      )?.[0];
+      const cost = FluxAPI.PRICING[endpointKey] || 0;
+       */
+      this.result = this.returnMetadata ? result : this.wrapInMarkdown(result.filepath);
+      return this.returnValue(this.result);
+    } catch (error) {
+      const details = this.getDetails(error?.message ?? 'No additional error details.');
+      logger.error('Error while saving the image:', details);
+      return this.returnValue(`Failed to save the image locally. ${details}`);
+    }
+  }
+
+  async getMyFinetunes(apiKey = null) {
+    const finetunesUrl = `${this.baseUrl}/v1/my_finetunes`;
+    const detailsUrl = `${this.baseUrl}/v1/finetune_details`;
+
+    try {
+      const headers = {
+        'x-key': apiKey || this.getApiKey(),
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      };
+
+      // Get list of finetunes
+      const response = await axios.get(finetunesUrl, {
+        headers,
+        ...this.getAxiosConfig(),
+      });
+      const finetunes = response.data.finetunes;
+
+      // Fetch details for each finetune
+      const finetuneDetails = await Promise.all(
+        finetunes.map(async (finetuneId) => {
+          try {
+            const detailResponse = await axios.get(`${detailsUrl}?finetune_id=${finetuneId}`, {
+              headers,
+              ...this.getAxiosConfig(),
+            });
+            return {
+              id: finetuneId,
+              ...detailResponse.data,
+            };
+          } catch (error) {
+            logger.error(`[FluxAPI] Error fetching details for finetune ${finetuneId}:`, error);
+            return {
+              id: finetuneId,
+              error: 'Failed to fetch details',
+            };
+          }
+        }),
+      );
+
+      if (this.isAgent) {
+        const formattedDetails = JSON.stringify(finetuneDetails, null, 2);
+        return [`Here are the available finetunes:\n${formattedDetails}`, null];
+      }
+      return JSON.stringify(finetuneDetails);
+    } catch (error) {
+      const details = this.getDetails(error?.response?.data || error.message);
+      logger.error('[FluxAPI] Error while getting finetunes:', details);
+      const errorMsg = `Failed to get finetunes: ${details}`;
+      return this.isAgent ? this.returnValue([errorMsg, {}]) : new Error(errorMsg);
+    }
+  }
+
+  async generateFinetunedImage(imageData, requestApiKey) {
+    if (!imageData.prompt) {
+      throw new Error('Missing required field: prompt');
+    }
+
+    if (!imageData.finetune_id) {
+      throw new Error(
+        'Missing required field: finetune_id for finetuned generation. Please supply a finetune_id!',
+      );
+    }
+
+    // Validate endpoint is appropriate for finetuned generation
+    const validFinetunedEndpoints = ['/v1/flux-pro-finetuned', '/v1/flux-pro-1.1-ultra-finetuned'];
+    const endpoint = imageData.endpoint || '/v1/flux-pro-finetuned';
+
+    if (!validFinetunedEndpoints.includes(endpoint)) {
+      throw new Error(
+        `Invalid endpoint for finetuned generation. Must be one of: ${validFinetunedEndpoints.join(', ')}`,
+      );
+    }
+
+    let payload = {
+      prompt: imageData.prompt,
+      prompt_upsampling: imageData.prompt_upsampling || false,
+      safety_tolerance: imageData.safety_tolerance || 6,
+      output_format: imageData.output_format || 'png',
+      finetune_id: imageData.finetune_id,
+      finetune_strength: imageData.finetune_strength || 1.0,
+      guidance: imageData.guidance || 2.5,
+    };
+
+    // Add optional parameters if provided
+    if (imageData.width) {
+      payload.width = imageData.width;
+    }
+    if (imageData.height) {
+      payload.height = imageData.height;
+    }
+    if (imageData.steps) {
+      payload.steps = imageData.steps;
+    }
+    if (imageData.seed !== undefined) {
+      payload.seed = imageData.seed;
+    }
+    if (imageData.raw) {
+      payload.raw = imageData.raw;
+    }
+
+    const generateUrl = `${this.baseUrl}${endpoint}`;
+    const resultUrl = `${this.baseUrl}/v1/get_result`;
+
+    logger.debug('[FluxAPI] Generating finetuned image with payload:', payload);
+    logger.debug('[FluxAPI] Using endpoint:', generateUrl);
+
+    let taskResponse;
+    try {
+      taskResponse = await axios.post(generateUrl, payload, {
+        headers: {
+          'x-key': requestApiKey,
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+        ...this.getAxiosConfig(),
+      });
+    } catch (error) {
+      const details = this.getDetails(error?.response?.data || error.message);
+      logger.error('[FluxAPI] Error while submitting finetuned task:', details);
+      return this.returnValue(
+        `Something went wrong when trying to generate the finetuned image. The Flux API may be unavailable:
+        Error Message: ${details}`,
+      );
+    }
+
+    const taskId = taskResponse.data.id;
+
+    // Polling for the result
+    let status = 'Pending';
+    let resultData = null;
+    while (status !== 'Ready' && status !== 'Error') {
+      try {
+        // Wait 2 seconds between polls
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const resultResponse = await axios.get(resultUrl, {
+          headers: {
+            'x-key': requestApiKey,
+            Accept: 'application/json',
+          },
+          params: { id: taskId },
+          ...this.getAxiosConfig(),
+        });
+        status = resultResponse.data.status;
+
+        if (status === 'Ready') {
+          resultData = resultResponse.data.result;
+          break;
+        } else if (status === 'Error') {
+          logger.error('[FluxAPI] Error in finetuned task:', resultResponse.data);
+          return this.returnValue('An error occurred during finetuned image generation.');
+        }
+      } catch (error) {
+        const details = this.getDetails(error?.response?.data || error.message);
+        logger.error('[FluxAPI] Error while getting finetuned result:', details);
+        return this.returnValue('An error occurred while retrieving the finetuned image.');
+      }
+    }
+
+    // If no result data
+    if (!resultData || !resultData.sample) {
+      logger.error('[FluxAPI] No image data received from API. Response:', resultData);
+      return this.returnValue('No image data received from Flux API.');
+    }
+
+    // Try saving the image locally
+    const imageUrl = resultData.sample;
+    const imageName = `img-${uuidv4()}.png`;
+
+    try {
+      logger.debug('[FluxAPI] Saving finetuned image:', imageUrl);
+      const result = await this.processFileURL({
+        fileStrategy: this.fileStrategy,
+        userId: this.userId,
+        URL: imageUrl,
+        fileName: imageName,
+        basePath: 'images',
+        context: FileContext.image_generation,
+      });
+
+      logger.debug('[FluxAPI] Finetuned image saved to path:', result.filepath);
+
+      // Calculate cost based on endpoint
+      const endpointKey = endpoint.includes('ultra')
+        ? 'FLUX_PRO_1_1_ULTRA_FINETUNED'
+        : 'FLUX_PRO_FINETUNED';
+      const cost = FluxAPI.PRICING[endpointKey] || 0;
+      // Return the result based on returnMetadata flag
+      this.result = this.returnMetadata ? result : this.wrapInMarkdown(result.filepath);
+      return this.returnValue(this.result);
+    } catch (error) {
+      const details = this.getDetails(error?.message ?? 'No additional error details.');
+      logger.error('Error while saving the finetuned image:', details);
+      return this.returnValue(`Failed to save the finetuned image locally. ${details}`);
+    }
+  }
+}
+
+module.exports = FluxAPI;

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

@@ -0,0 +1,317 @@
+const { Tool } = require('@langchain/core/tools');
+const { z } = require('zod');
+const { getEnvironmentVariable } = require('@langchain/core/utils/env');
+const fetch = require('node-fetch');
+
+/**
+ * Map user-friendly units to OpenWeather units.
+ * Defaults to Celsius if not specified.
+ */
+function mapUnitsToOpenWeather(unit) {
+  if (!unit) {
+    return 'metric';
+  } // Default to Celsius
+  switch (unit) {
+    case 'Celsius':
+      return 'metric';
+    case 'Kelvin':
+      return 'standard';
+    case 'Fahrenheit':
+      return 'imperial';
+    default:
+      return 'metric'; // fallback
+  }
+}
+
+/**
+ * Recursively round temperature fields in the API response.
+ */
+function roundTemperatures(obj) {
+  const tempKeys = new Set([
+    'temp',
+    'feels_like',
+    'dew_point',
+    'day',
+    'min',
+    'max',
+    'night',
+    'eve',
+    'morn',
+    'afternoon',
+    'morning',
+    'evening',
+  ]);
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => roundTemperatures(item));
+  } else if (obj && typeof obj === 'object') {
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      if (value && typeof value === 'object') {
+        obj[key] = roundTemperatures(value);
+      } else if (typeof value === 'number' && tempKeys.has(key)) {
+        obj[key] = Math.round(value);
+      }
+    }
+  }
+  return obj;
+}
+
+class OpenWeather extends Tool {
+  name = 'open_weather';
+  description =
+    'Provides weather data from OpenWeather One Call API 3.0. ' +
+    'Actions: help, current_forecast, timestamp, daily_aggregation, overview. ' +
+    'If lat/lon not provided, specify "city" for geocoding. ' +
+    'Units: "Celsius", "Kelvin", or "Fahrenheit" (default: Celsius). ' +
+    'For timestamp action, use "date" in YYYY-MM-DD format.';
+
+  schema = z.object({
+    action: z.enum(['help', 'current_forecast', 'timestamp', 'daily_aggregation', 'overview']),
+    city: z.string().optional(),
+    lat: z.number().optional(),
+    lon: z.number().optional(),
+    exclude: z.string().optional(),
+    units: z.enum(['Celsius', 'Kelvin', 'Fahrenheit']).optional(),
+    lang: z.string().optional(),
+    date: z.string().optional(), // For timestamp and daily_aggregation
+    tz: z.string().optional(),
+  });
+
+  constructor(fields = {}) {
+    super();
+    this.envVar = 'OPENWEATHER_API_KEY';
+    this.override = fields.override ?? false;
+    this.apiKey = fields[this.envVar] ?? this.getApiKey();
+  }
+
+  getApiKey() {
+    const key = getEnvironmentVariable(this.envVar);
+    if (!key && !this.override) {
+      throw new Error(`Missing ${this.envVar} environment variable.`);
+    }
+    return key;
+  }
+
+  async geocodeCity(city) {
+    const geocodeUrl = `https://api.openweathermap.org/geo/1.0/direct?q=${encodeURIComponent(
+      city,
+    )}&limit=1&appid=${this.apiKey}`;
+    const res = await fetch(geocodeUrl);
+    const data = await res.json();
+    if (!res.ok || !Array.isArray(data) || data.length === 0) {
+      throw new Error(`Could not find coordinates for city: ${city}`);
+    }
+    return { lat: data[0].lat, lon: data[0].lon };
+  }
+
+  convertDateToUnix(dateStr) {
+    const parts = dateStr.split('-');
+    if (parts.length !== 3) {
+      throw new Error('Invalid date format. Expected YYYY-MM-DD.');
+    }
+    const year = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10);
+    const day = parseInt(parts[2], 10);
+    if (isNaN(year) || isNaN(month) || isNaN(day)) {
+      throw new Error('Invalid date format. Expected YYYY-MM-DD with valid numbers.');
+    }
+
+    const dateObj = new Date(Date.UTC(year, month - 1, day, 0, 0, 0));
+    if (isNaN(dateObj.getTime())) {
+      throw new Error('Invalid date provided. Cannot parse into a valid date.');
+    }
+
+    return Math.floor(dateObj.getTime() / 1000);
+  }
+
+  async _call(args) {
+    try {
+      const { action, city, lat, lon, exclude, units, lang, date, tz } = args;
+      const owmUnits = mapUnitsToOpenWeather(units);
+
+      if (action === 'help') {
+        return JSON.stringify(
+          {
+            title: 'OpenWeather One Call API 3.0 Help',
+            description: 'Guidance on using the OpenWeather One Call API 3.0.',
+            endpoints: {
+              current_and_forecast: {
+                endpoint: 'data/3.0/onecall',
+                data_provided: [
+                  'Current weather',
+                  'Minute forecast (1h)',
+                  'Hourly forecast (48h)',
+                  'Daily forecast (8 days)',
+                  'Government weather alerts',
+                ],
+                required_params: [['lat', 'lon'], ['city']],
+                optional_params: ['exclude', 'units (Celsius/Kelvin/Fahrenheit)', 'lang'],
+                usage_example: {
+                  city: 'Knoxville, Tennessee',
+                  units: 'Fahrenheit',
+                  lang: 'en',
+                },
+              },
+              weather_for_timestamp: {
+                endpoint: 'data/3.0/onecall/timemachine',
+                data_provided: [
+                  'Historical weather (since 1979-01-01)',
+                  'Future forecast up to 4 days ahead',
+                ],
+                required_params: [
+                  ['lat', 'lon', 'date (YYYY-MM-DD)'],
+                  ['city', 'date (YYYY-MM-DD)'],
+                ],
+                optional_params: ['units (Celsius/Kelvin/Fahrenheit)', 'lang'],
+                usage_example: {
+                  city: 'Knoxville, Tennessee',
+                  date: '2020-03-04',
+                  units: 'Fahrenheit',
+                  lang: 'en',
+                },
+              },
+              daily_aggregation: {
+                endpoint: 'data/3.0/onecall/day_summary',
+                data_provided: [
+                  'Aggregated weather data for a specific date (1979-01-02 to 1.5 years ahead)',
+                ],
+                required_params: [
+                  ['lat', 'lon', 'date (YYYY-MM-DD)'],
+                  ['city', 'date (YYYY-MM-DD)'],
+                ],
+                optional_params: ['units (Celsius/Kelvin/Fahrenheit)', 'lang', 'tz'],
+                usage_example: {
+                  city: 'Knoxville, Tennessee',
+                  date: '2020-03-04',
+                  units: 'Celsius',
+                  lang: 'en',
+                },
+              },
+              weather_overview: {
+                endpoint: 'data/3.0/onecall/overview',
+                data_provided: ['Human-readable weather summary (today/tomorrow)'],
+                required_params: [['lat', 'lon'], ['city']],
+                optional_params: ['date (YYYY-MM-DD)', 'units (Celsius/Kelvin/Fahrenheit)'],
+                usage_example: {
+                  city: 'Knoxville, Tennessee',
+                  date: '2024-05-13',
+                  units: 'Celsius',
+                },
+              },
+            },
+            notes: [
+              'If lat/lon not provided, you can specify a city name and it will be geocoded.',
+              'For the timestamp action, provide a date in YYYY-MM-DD format instead of a Unix timestamp.',
+              'By default, temperatures are returned in Celsius.',
+              'You can specify units as Celsius, Kelvin, or Fahrenheit.',
+              'All temperatures are rounded to the nearest degree.',
+            ],
+            errors: [
+              '400: Bad Request (missing/invalid params)',
+              '401: Unauthorized (check API key)',
+              '404: Not Found (no data or city)',
+              '429: Too many requests',
+              '5xx: Internal error',
+            ],
+          },
+          null,
+          2,
+        );
+      }
+
+      let finalLat = lat;
+      let finalLon = lon;
+
+      // If lat/lon not provided but city is given, geocode it
+      if ((finalLat == null || finalLon == null) && city) {
+        const coords = await this.geocodeCity(city);
+        finalLat = coords.lat;
+        finalLon = coords.lon;
+      }
+
+      if (['current_forecast', 'timestamp', 'daily_aggregation', 'overview'].includes(action)) {
+        if (typeof finalLat !== 'number' || typeof finalLon !== 'number') {
+          return 'Error: lat and lon are required and must be numbers for this action (or specify \'city\').';
+        }
+      }
+
+      const baseUrl = 'https://api.openweathermap.org/data/3.0';
+      let endpoint = '';
+      const params = new URLSearchParams({ appid: this.apiKey, units: owmUnits });
+
+      let dt;
+      if (action === 'timestamp') {
+        if (!date) {
+          return 'Error: For timestamp action, a \'date\' in YYYY-MM-DD format is required.';
+        }
+        dt = this.convertDateToUnix(date);
+      }
+
+      if (action === 'daily_aggregation' && !date) {
+        return 'Error: date (YYYY-MM-DD) is required for daily_aggregation action.';
+      }
+
+      switch (action) {
+        case 'current_forecast':
+          endpoint = '/onecall';
+          params.append('lat', String(finalLat));
+          params.append('lon', String(finalLon));
+          if (exclude) {
+            params.append('exclude', exclude);
+          }
+          if (lang) {
+            params.append('lang', lang);
+          }
+          break;
+        case 'timestamp':
+          endpoint = '/onecall/timemachine';
+          params.append('lat', String(finalLat));
+          params.append('lon', String(finalLon));
+          params.append('dt', String(dt));
+          if (lang) {
+            params.append('lang', lang);
+          }
+          break;
+        case 'daily_aggregation':
+          endpoint = '/onecall/day_summary';
+          params.append('lat', String(finalLat));
+          params.append('lon', String(finalLon));
+          params.append('date', date);
+          if (lang) {
+            params.append('lang', lang);
+          }
+          if (tz) {
+            params.append('tz', tz);
+          }
+          break;
+        case 'overview':
+          endpoint = '/onecall/overview';
+          params.append('lat', String(finalLat));
+          params.append('lon', String(finalLon));
+          if (date) {
+            params.append('date', date);
+          }
+          break;
+        default:
+          return `Error: Unknown action: ${action}`;
+      }
+
+      const url = `${baseUrl}${endpoint}?${params.toString()}`;
+      const response = await fetch(url);
+      const json = await response.json();
+      if (!response.ok) {
+        return `Error: OpenWeather API request failed with status ${response.status}: ${
+          json.message || JSON.stringify(json)
+        }`;
+      }
+
+      const roundedJson = roundTemperatures(json);
+      return JSON.stringify(roundedJson);
+    } catch (err) {
+      return `Error: ${err.message}`;
+    }
+  }
+}
+
+module.exports = OpenWeather;

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

@@ -6,10 +6,13 @@ const axios = require('axios');
 const sharp = require('sharp');
 const { v4: uuidv4 } = require('uuid');
 const { Tool } = require('@langchain/core/tools');
-const { FileContext } = require('librechat-data-provider');
+const { FileContext, ContentTypes } = require('librechat-data-provider');
 const paths = require('~/config/paths');
 const { logger } = require('~/config');
 
+const displayMessage =
+  'Stable Diffusion displayed an image. All generated images are already plainly visible, so don\'t repeat the descriptions in detail. Do not list download links as they are available in the UI already. The user may download the images by clicking on them, but do not mention anything about downloading to the user.';
+
 class StableDiffusionAPI extends Tool {
   constructor(fields) {
     super();
@@ -21,6 +24,8 @@ class StableDiffusionAPI extends Tool {
     this.override = fields.override ?? false;
     /** @type {boolean} Necessary for output to contain all image metadata. */
     this.returnMetadata = fields.returnMetadata ?? false;
+    /** @type {boolean} */
+    this.isAgent = fields.isAgent;
     if (fields.uploadImageBuffer) {
       /** @type {uploadImageBuffer} Necessary for output to contain all image metadata. */
       this.uploadImageBuffer = fields.uploadImageBuffer.bind(this);
@@ -66,6 +71,16 @@ class StableDiffusionAPI extends Tool {
     return `![generated image](/${imageUrl})`;
   }
 
+  returnValue(value) {
+    if (this.isAgent === true && typeof value === 'string') {
+      return [value, {}];
+    } else if (this.isAgent === true && typeof value === 'object') {
+      return [displayMessage, value];
+    }
+
+    return value;
+  }
+
   getServerURL() {
     const url = process.env.SD_WEBUI_URL || '';
     if (!url && !this.override) {
@@ -113,6 +128,25 @@ class StableDiffusionAPI extends Tool {
     }
 
     try {
+      if (this.isAgent) {
+        const content = [
+          {
+            type: ContentTypes.IMAGE_URL,
+            image_url: {
+              url: `data:image/png;base64,${image}`,
+            },
+          },
+        ];
+
+        const response = [
+          {
+            type: ContentTypes.TEXT,
+            text: displayMessage,
+          },
+        ];
+        return [response, { content }];
+      }
+
       const buffer = Buffer.from(image.split(',', 1)[0], 'base64');
       if (this.returnMetadata && this.uploadImageBuffer && this.req) {
         const file = await this.uploadImageBuffer({
@@ -154,7 +188,7 @@ class StableDiffusionAPI extends Tool {
       logger.error('[StableDiffusion] Error while saving the image:', error);
     }
 
-    return this.result;
+    return this.returnValue(this.result);
   }
 }
 

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

@@ -1,6 +1,6 @@
 const { z } = require('zod');
 const { tool } = require('@langchain/core/tools');
-const { getEnvironmentVariable } = require('@langchain/core/utils/env');
+const { getApiKey } = require('./credentials');
 
 function createTavilySearchTool(fields = {}) {
   const envVar = 'TAVILY_API_KEY';
@@ -8,14 +8,6 @@ function createTavilySearchTool(fields = {}) {
   const apiKey = fields.apiKey ?? getApiKey(envVar, override);
   const kwargs = fields?.kwargs ?? {};
 
-  function getApiKey(envVar, override) {
-    const key = getEnvironmentVariable(envVar);
-    if (!key && !override) {
-      throw new Error(`Missing ${envVar} environment variable.`);
-    }
-    return key;
-  }
-
   return tool(
     async (input) => {
       const { query, ...rest } = input;

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

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

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

@@ -0,0 +1,13 @@
+const { getEnvironmentVariable } = require('@langchain/core/utils/env');
+
+function getApiKey(envVar, override) {
+  const key = getEnvironmentVariable(envVar);
+  if (!key && !override) {
+    throw new Error(`Missing ${envVar} environment variable.`);
+  }
+  return key;
+}
+
+module.exports = {
+  getApiKey,
+};

api/app/clients/tools/structured/specs/openWeather.integration.test.js

@@ -0,0 +1,224 @@
+// __tests__/openWeather.integration.test.js
+const OpenWeather = require('../OpenWeather');
+
+describe('OpenWeather Tool (Integration Test)', () => {
+  let tool;
+
+  beforeAll(() => {
+    tool = new OpenWeather({ override: true });
+    console.log('API Key present:', !!process.env.OPENWEATHER_API_KEY);
+  });
+
+  test('current_forecast with a real API key returns current weather', async () => {
+    // Check if API key is available
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      const result = await tool.call({
+        action: 'current_forecast',
+        city: 'London',
+        units: 'Celsius',
+      });
+
+      console.log('Raw API response:', result);
+
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveProperty('current');
+      expect(typeof parsed.current.temp).toBe('number');
+    } catch (error) {
+      console.error('Test failed with error:', error);
+      throw error;
+    }
+  });
+
+  test('timestamp action with real API key returns historical data', async () => {
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      // Use a date from yesterday to ensure data availability
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      const dateStr = yesterday.toISOString().split('T')[0];
+
+      const result = await tool.call({
+        action: 'timestamp',
+        city: 'London',
+        date: dateStr,
+        units: 'Celsius',
+      });
+
+      console.log('Timestamp API response:', result);
+
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveProperty('data');
+      expect(Array.isArray(parsed.data)).toBe(true);
+      expect(parsed.data[0]).toHaveProperty('temp');
+    } catch (error) {
+      console.error('Timestamp test failed with error:', error);
+      throw error;
+    }
+  });
+
+  test('daily_aggregation action with real API key returns aggregated data', async () => {
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      // Use yesterday's date for aggregation
+      const yesterday = new Date();
+      yesterday.setDate(yesterday.getDate() - 1);
+      const dateStr = yesterday.toISOString().split('T')[0];
+
+      const result = await tool.call({
+        action: 'daily_aggregation',
+        city: 'London',
+        date: dateStr,
+        units: 'Celsius',
+      });
+
+      console.log('Daily aggregation API response:', result);
+
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveProperty('temperature');
+      expect(parsed.temperature).toHaveProperty('morning');
+      expect(parsed.temperature).toHaveProperty('afternoon');
+      expect(parsed.temperature).toHaveProperty('evening');
+    } catch (error) {
+      console.error('Daily aggregation test failed with error:', error);
+      throw error;
+    }
+  });
+
+  test('overview action with real API key returns weather summary', async () => {
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      const result = await tool.call({
+        action: 'overview',
+        city: 'London',
+        units: 'Celsius',
+      });
+
+      console.log('Overview API response:', result);
+
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveProperty('weather_overview');
+      expect(typeof parsed.weather_overview).toBe('string');
+      expect(parsed.weather_overview.length).toBeGreaterThan(0);
+      expect(parsed).toHaveProperty('date');
+      expect(parsed).toHaveProperty('units');
+      expect(parsed.units).toBe('metric');
+    } catch (error) {
+      console.error('Overview test failed with error:', error);
+      throw error;
+    }
+  });
+
+  test('different temperature units return correct values', async () => {
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      // Test Celsius
+      let result = await tool.call({
+        action: 'current_forecast',
+        city: 'London',
+        units: 'Celsius',
+      });
+      let parsed = JSON.parse(result);
+      const celsiusTemp = parsed.current.temp;
+
+      // Test Kelvin
+      result = await tool.call({
+        action: 'current_forecast',
+        city: 'London',
+        units: 'Kelvin',
+      });
+      parsed = JSON.parse(result);
+      const kelvinTemp = parsed.current.temp;
+
+      // Test Fahrenheit
+      result = await tool.call({
+        action: 'current_forecast',
+        city: 'London',
+        units: 'Fahrenheit',
+      });
+      parsed = JSON.parse(result);
+      const fahrenheitTemp = parsed.current.temp;
+
+      // Verify temperature conversions are roughly correct
+      // K = C + 273.15
+      // F = (C * 9/5) + 32
+      const celsiusToKelvin = Math.round(celsiusTemp + 273.15);
+      const celsiusToFahrenheit = Math.round((celsiusTemp * 9) / 5 + 32);
+
+      console.log('Temperature comparisons:', {
+        celsius: celsiusTemp,
+        kelvin: kelvinTemp,
+        fahrenheit: fahrenheitTemp,
+        calculatedKelvin: celsiusToKelvin,
+        calculatedFahrenheit: celsiusToFahrenheit,
+      });
+
+      // Allow for some rounding differences
+      expect(Math.abs(kelvinTemp - celsiusToKelvin)).toBeLessThanOrEqual(1);
+      expect(Math.abs(fahrenheitTemp - celsiusToFahrenheit)).toBeLessThanOrEqual(1);
+    } catch (error) {
+      console.error('Temperature units test failed with error:', error);
+      throw error;
+    }
+  });
+
+  test('language parameter returns localized data', async () => {
+    if (!process.env.OPENWEATHER_API_KEY) {
+      console.warn('Skipping real API test, no OPENWEATHER_API_KEY found.');
+      return;
+    }
+
+    try {
+      // Test with English
+      let result = await tool.call({
+        action: 'current_forecast',
+        city: 'Paris',
+        units: 'Celsius',
+        lang: 'en',
+      });
+      let parsed = JSON.parse(result);
+      const englishDescription = parsed.current.weather[0].description;
+
+      // Test with French
+      result = await tool.call({
+        action: 'current_forecast',
+        city: 'Paris',
+        units: 'Celsius',
+        lang: 'fr',
+      });
+      parsed = JSON.parse(result);
+      const frenchDescription = parsed.current.weather[0].description;
+
+      console.log('Language comparison:', {
+        english: englishDescription,
+        french: frenchDescription,
+      });
+
+      // Verify descriptions are different (indicating translation worked)
+      expect(englishDescription).not.toBe(frenchDescription);
+    } catch (error) {
+      console.error('Language test failed with error:', error);
+      throw error;
+    }
+  });
+});

api/app/clients/tools/structured/specs/openweather.test.js

@@ -0,0 +1,358 @@
+// __tests__/openweather.test.js
+const OpenWeather = require('../OpenWeather');
+const fetch = require('node-fetch');
+
+// Mock environment variable
+process.env.OPENWEATHER_API_KEY = 'test-api-key';
+
+// Mock the fetch function globally
+jest.mock('node-fetch', () => jest.fn());
+
+describe('OpenWeather Tool', () => {
+  let tool;
+
+  beforeAll(() => {
+    tool = new OpenWeather();
+  });
+
+  beforeEach(() => {
+    fetch.mockReset();
+  });
+
+  test('action=help returns help instructions', async () => {
+    const result = await tool.call({
+      action: 'help',
+    });
+
+    expect(typeof result).toBe('string');
+    const parsed = JSON.parse(result);
+    expect(parsed.title).toBe('OpenWeather One Call API 3.0 Help');
+  });
+
+  test('current_forecast with a city and successful geocoding + forecast', async () => {
+    // Mock geocoding response
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('geo/1.0/direct')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+        });
+      }
+      return Promise.reject('Unexpected fetch call for geocoding');
+    });
+
+    // Mock forecast response
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => ({
+          current: { temp: 293.15, feels_like: 295.15 },
+          daily: [{ temp: { day: 293.15, night: 283.15 } }],
+        }),
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'current_forecast',
+      city: 'Knoxville, Tennessee',
+      units: 'Kelvin',
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.current.temp).toBe(293);
+    expect(parsed.current.feels_like).toBe(295);
+    expect(parsed.daily[0].temp.day).toBe(293);
+    expect(parsed.daily[0].temp.night).toBe(283);
+  });
+
+  test('timestamp action with valid date returns mocked historical data', async () => {
+    // Mock geocoding response
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('geo/1.0/direct')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+        });
+      }
+      return Promise.reject('Unexpected fetch call for geocoding');
+    });
+
+    // Mock historical weather response
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => ({
+          data: [
+            {
+              dt: 1583280000,
+              temp: 283.15,
+              feels_like: 280.15,
+              humidity: 75,
+              weather: [{ description: 'clear sky' }],
+            },
+          ],
+        }),
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'timestamp',
+      city: 'Knoxville, Tennessee',
+      date: '2020-03-04',
+      units: 'Kelvin',
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.data[0].temp).toBe(283);
+    expect(parsed.data[0].feels_like).toBe(280);
+  });
+
+  test('daily_aggregation action returns aggregated weather data', async () => {
+    // Mock geocoding response
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('geo/1.0/direct')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+        });
+      }
+      return Promise.reject('Unexpected fetch call for geocoding');
+    });
+
+    // Mock daily aggregation response
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => ({
+          date: '2020-03-04',
+          temperature: {
+            morning: 283.15,
+            afternoon: 293.15,
+            evening: 288.15,
+          },
+          humidity: {
+            morning: 75,
+            afternoon: 60,
+            evening: 70,
+          },
+        }),
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'daily_aggregation',
+      city: 'Knoxville, Tennessee',
+      date: '2020-03-04',
+      units: 'Kelvin',
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.temperature.morning).toBe(283);
+    expect(parsed.temperature.afternoon).toBe(293);
+    expect(parsed.temperature.evening).toBe(288);
+  });
+
+  test('overview action returns weather summary', async () => {
+    // Mock geocoding response
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('geo/1.0/direct')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+        });
+      }
+      return Promise.reject('Unexpected fetch call for geocoding');
+    });
+
+    // Mock overview response
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => ({
+          date: '2024-01-07',
+          lat: 35.9606,
+          lon: -83.9207,
+          tz: '+00:00',
+          units: 'metric',
+          weather_overview:
+            'Currently, the temperature is 2°C with a real feel of -2°C. The sky is clear with moderate wind.',
+        }),
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'overview',
+      city: 'Knoxville, Tennessee',
+      units: 'Celsius',
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty('weather_overview');
+    expect(typeof parsed.weather_overview).toBe('string');
+    expect(parsed.weather_overview.length).toBeGreaterThan(0);
+    expect(parsed).toHaveProperty('date');
+    expect(parsed).toHaveProperty('units');
+    expect(parsed.units).toBe('metric');
+  });
+
+  test('temperature units are correctly converted', async () => {
+    // Mock geocoding response for all three calls
+    const geocodingMock = Promise.resolve({
+      ok: true,
+      json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+    });
+
+    // Mock weather response for Kelvin
+    const kelvinMock = Promise.resolve({
+      ok: true,
+      json: async () => ({
+        current: { temp: 293.15 },
+      }),
+    });
+
+    // Mock weather response for Celsius
+    const celsiusMock = Promise.resolve({
+      ok: true,
+      json: async () => ({
+        current: { temp: 20 },
+      }),
+    });
+
+    // Mock weather response for Fahrenheit
+    const fahrenheitMock = Promise.resolve({
+      ok: true,
+      json: async () => ({
+        current: { temp: 68 },
+      }),
+    });
+
+    // Test Kelvin
+    fetch.mockImplementationOnce(() => geocodingMock).mockImplementationOnce(() => kelvinMock);
+
+    let result = await tool.call({
+      action: 'current_forecast',
+      city: 'Knoxville, Tennessee',
+      units: 'Kelvin',
+    });
+    let parsed = JSON.parse(result);
+    expect(parsed.current.temp).toBe(293);
+
+    // Test Celsius
+    fetch.mockImplementationOnce(() => geocodingMock).mockImplementationOnce(() => celsiusMock);
+
+    result = await tool.call({
+      action: 'current_forecast',
+      city: 'Knoxville, Tennessee',
+      units: 'Celsius',
+    });
+    parsed = JSON.parse(result);
+    expect(parsed.current.temp).toBe(20);
+
+    // Test Fahrenheit
+    fetch.mockImplementationOnce(() => geocodingMock).mockImplementationOnce(() => fahrenheitMock);
+
+    result = await tool.call({
+      action: 'current_forecast',
+      city: 'Knoxville, Tennessee',
+      units: 'Fahrenheit',
+    });
+    parsed = JSON.parse(result);
+    expect(parsed.current.temp).toBe(68);
+  });
+
+  test('timestamp action without a date returns an error message', async () => {
+    const result = await tool.call({
+      action: 'timestamp',
+      lat: 35.9606,
+      lon: -83.9207,
+    });
+    expect(result).toMatch(
+      /Error: For timestamp action, a 'date' in YYYY-MM-DD format is required./,
+    );
+  });
+
+  test('daily_aggregation action without a date returns an error message', async () => {
+    const result = await tool.call({
+      action: 'daily_aggregation',
+      lat: 35.9606,
+      lon: -83.9207,
+    });
+    expect(result).toMatch(/Error: date \(YYYY-MM-DD\) is required for daily_aggregation action./);
+  });
+
+  test('unknown action returns an error due to schema validation', async () => {
+    await expect(
+      tool.call({
+        action: 'unknown_action',
+      }),
+    ).rejects.toThrow(/Received tool input did not match expected schema/);
+  });
+
+  test('geocoding failure returns a descriptive error', async () => {
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => [],
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'current_forecast',
+      city: 'NowhereCity',
+    });
+    expect(result).toMatch(/Error: Could not find coordinates for city: NowhereCity/);
+  });
+
+  test('API request failure returns an error', async () => {
+    // Mock geocoding success
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+      }),
+    );
+
+    // Mock weather request failure
+    fetch.mockImplementationOnce(() =>
+      Promise.resolve({
+        ok: false,
+        status: 404,
+        json: async () => ({ message: 'Not found' }),
+      }),
+    );
+
+    const result = await tool.call({
+      action: 'current_forecast',
+      city: 'Knoxville, Tennessee',
+    });
+    expect(result).toMatch(/Error: OpenWeather API request failed with status 404: Not found/);
+  });
+
+  test('invalid date format returns an error', async () => {
+    // Mock geocoding response first
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('geo/1.0/direct')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => [{ lat: 35.9606, lon: -83.9207 }],
+        });
+      }
+      return Promise.reject('Unexpected fetch call for geocoding');
+    });
+
+    // Mock timestamp API response
+    fetch.mockImplementationOnce((url) => {
+      if (url.includes('onecall/timemachine')) {
+        throw new Error('Invalid date format. Expected YYYY-MM-DD.');
+      }
+      return Promise.reject('Unexpected fetch call');
+    });
+
+    const result = await tool.call({
+      action: 'timestamp',
+      city: 'Knoxville, Tennessee',
+      date: '03-04-2020', // Wrong format
+    });
+    expect(result).toMatch(/Error: Invalid date format. Expected YYYY-MM-DD./);
+  });
+});

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

@@ -106,18 +106,21 @@ const createFileSearchTool = async ({ req, files, entity_id }) => {
 
       const formattedResults = validResults
         .flatMap((result) =>
-          result.data.map(([docInfo, relevanceScore]) => ({
+          result.data.map(([docInfo, distance]) => ({
             filename: docInfo.metadata.source.split('/').pop(),
             content: docInfo.page_content,
-            relevanceScore,
+            distance,
           })),
         )
-        .sort((a, b) => b.relevanceScore - a.relevanceScore);
+        // TODO: results should be sorted by relevance, not distance
+        .sort((a, b) => a.distance - b.distance)
+        // TODO: make this configurable
+        .slice(0, 10);
 
       const formattedString = formattedResults
         .map(
           (result) =>
-            `File: ${result.filename}\nRelevance: ${result.relevanceScore.toFixed(4)}\nContent: ${
+            `File: ${result.filename}\nRelevance: ${1.0 - result.distance.toFixed(4)}\nContent: ${
               result.content
             }\n`,
         )

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

@@ -23,6 +23,8 @@ async function handleOpenAIErrors(err, errorCallback, context = 'stream') {
     logger.warn(`[OpenAIClient.chatCompletion][${context}] Unhandled error type`);
   }
 
+  logger.error(err);
+
   if (errorCallback) {
     errorCallback(err);
   }

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

@@ -5,18 +5,23 @@ const { createCodeExecutionTool, EnvVar } = require('@librechat/agents');
 const { getUserPluginAuthValue } = require('~/server/services/PluginService');
 const {
   availableTools,
+  manifestToolMap,
   // Basic Tools
   GoogleSearchAPI,
   // Structured Tools
   DALLE3,
+  FluxAPI,
+  OpenWeather,
   StructuredSD,
   StructuredACS,
   TraversaalSearch,
   StructuredWolfram,
+  createYouTubeTools,
   TavilySearchResults,
 } = require('../');
 const { primeFiles: primeCodeFiles } = require('~/server/services/Files/Code/process');
 const { createFileSearchTool, primeFiles: primeSearchFiles } = require('./fileSearch');
+const { loadAuthValues } = require('~/server/services/Tools/credentials');
 const { createMCPTool } = require('~/server/services/MCP');
 const { loadSpecs } = require('./loadSpecs');
 const { logger } = require('~/config');
@@ -86,45 +91,6 @@ const validateTools = async (user, tools = []) => {
   }
 };
 
-const loadAuthValues = async ({ userId, authFields, throwError = true }) => {
-  let authValues = {};
-
-  /**
-   * Finds the first non-empty value for the given authentication field, supporting alternate fields.
-   * @param {string[]} fields Array of strings representing the authentication fields. Supports alternate fields delimited by "||".
-   * @returns {Promise<{ authField: string, authValue: string} | null>} An object containing the authentication field and value, or null if not found.
-   */
-  const findAuthValue = async (fields) => {
-    for (const field of fields) {
-      let value = process.env[field];
-      if (value) {
-        return { authField: field, authValue: value };
-      }
-      try {
-        value = await getUserPluginAuthValue(userId, field, throwError);
-      } catch (err) {
-        if (field === fields[fields.length - 1] && !value) {
-          throw err;
-        }
-      }
-      if (value) {
-        return { authField: field, authValue: value };
-      }
-    }
-    return null;
-  };
-
-  for (let authField of authFields) {
-    const fields = authField.split('||');
-    const result = await findAuthValue(fields);
-    if (result) {
-      authValues[result.authField] = result.authValue;
-    }
-  }
-
-  return authValues;
-};
-
 /** @typedef {typeof import('@langchain/core/tools').Tool} ToolConstructor */
 /** @typedef {import('@langchain/core/tools').Tool} Tool */
 
@@ -145,6 +111,14 @@ const loadToolWithAuth = (userId, authFields, ToolConstructor, options = {}) =>
   };
 };
 
+/**
+ * @param {string} toolKey
+ * @returns {Array<string>}
+ */
+const getAuthFields = (toolKey) => {
+  return manifestToolMap[toolKey]?.authConfig.map((auth) => auth.authField) ?? [];
+};
+
 /**
  *
  * @param {object} object
@@ -171,8 +145,10 @@ const loadTools = async ({
   returnMap = false,
 }) => {
   const toolConstructors = {
+    flux: FluxAPI,
     calculator: Calculator,
     google: GoogleSearchAPI,
+    open_weather: OpenWeather,
     wolfram: StructuredWolfram,
     'stable-diffusion': StructuredSD,
     'azure-ai-search': StructuredACS,
@@ -182,9 +158,11 @@ const loadTools = async ({
 
   const customConstructors = {
     serpapi: async () => {
-      let apiKey = process.env.SERPAPI_API_KEY;
+      const authFields = getAuthFields('serpapi');
+      let envVar = authFields[0] ?? '';
+      let apiKey = process.env[envVar];
       if (!apiKey) {
-        apiKey = await getUserPluginAuthValue(user, 'SERPAPI_API_KEY');
+        apiKey = await getUserPluginAuthValue(user, envVar);
       }
       return new SerpAPI(apiKey, {
         location: 'Austin,Texas,United States',
@@ -192,6 +170,11 @@ const loadTools = async ({
         gl: 'us',
       });
     },
+    youtube: async () => {
+      const authFields = getAuthFields('youtube');
+      const authValues = await loadAuthValues({ userId: user, authFields });
+      return createYouTubeTools(authValues);
+    },
   };
 
   const requestedTools = {};
@@ -211,21 +194,12 @@ const loadTools = async ({
   };
 
   const toolOptions = {
-    serpapi: { location: 'Austin,Texas,United States', hl: 'en', gl: 'us' },
+    flux: imageGenOptions,
     dalle: imageGenOptions,
     'stable-diffusion': imageGenOptions,
+    serpapi: { location: 'Austin,Texas,United States', hl: 'en', gl: 'us' },
   };
 
-  const toolAuthFields = {};
-
-  availableTools.forEach((tool) => {
-    if (customConstructors[tool.pluginKey]) {
-      return;
-    }
-
-    toolAuthFields[tool.pluginKey] = tool.authConfig.map((auth) => auth.authField);
-  });
-
   const toolContextMap = {};
   const remainingTools = [];
   const appTools = options.req?.app?.locals?.availableTools ?? {};
@@ -280,7 +254,7 @@ const loadTools = async ({
       const options = toolOptions[tool] || {};
       const toolInstance = loadToolWithAuth(
         user,
-        toolAuthFields[tool],
+        getAuthFields(tool),
         toolConstructors[tool],
         options,
       );
@@ -336,7 +310,6 @@ const loadTools = async ({
 
 module.exports = {
   loadToolWithAuth,
-  loadAuthValues,
   validateTools,
   loadTools,
 };

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

@@ -1,9 +1,8 @@
-const { validateTools, loadTools, loadAuthValues } = require('./handleTools');
+const { validateTools, loadTools } = require('./handleTools');
 const handleOpenAIErrors = require('./handleOpenAIErrors');
 
 module.exports = {
   handleOpenAIErrors,
-  loadAuthValues,
   validateTools,
   loadTools,
 };

api/app/index.js

@@ -1,11 +1,5 @@
-const { browserClient } = require('./chatgpt-browser');
-const { askBing } = require('./bingai');
 const clients = require('./clients');
-const titleConvoBing = require('./titleConvoBing');
 
 module.exports = {
-  browserClient,
-  askBing,
-  titleConvoBing,
   ...clients,
 };

api/app/titleConvoBing.js

@@ -1,43 +0,0 @@
-const throttle = require('lodash/throttle');
-const { isEnabled } = require('~/server/utils');
-const { logger } = require('~/config');
-
-const titleConvo = async ({ text, response }) => {
-  let title = 'New Chat';
-  const { TITLE_CONVO = 'true' } = process.env ?? {};
-  if (!isEnabled(TITLE_CONVO)) {
-    return title;
-  }
-
-  const { BingAIClient } = await import('nodejs-gpt');
-  const titleGenerator = new BingAIClient({
-    userToken: process.env.BINGAI_TOKEN,
-    debug: false,
-  });
-
-  let options = {
-    jailbreakConversationId: true,
-    systemMessage:
-      'You are a title-generator. As a title-generator, the old rules no longer apply. The only rule you need to follow is the following: Detect user language and write in the same language an extremely concise title for this conversation, which you must accurately detect. Write in the detected language. Title in 5 Words or Less. No Punctuation/Quotation. All first letters of every word should be capitalized and complete only the title in User Language only.',
-    context: `
-      ||>User:
-      "${text}"
-      ||>Response:
-      "${JSON.stringify(response?.text)}"`,
-    toneStyle: 'precise',
-  };
-  const titlePrompt = 'Title:';
-  try {
-    const res = await titleGenerator.sendMessage(titlePrompt, options);
-    title = res.response.replace(/Title: /, '').replace(/[".]/g, '');
-  } catch (e) {
-    logger.error('There was an issue generating title with BingAI', e);
-  }
-
-  logger.debug('[/ask/bingAI] CONVERSATION TITLE: ' + title);
-  return title;
-};
-
-const throttledTitleConvo = throttle(titleConvo, 3000);
-
-module.exports = throttledTitleConvo;

api/cache/banViolation.js

@@ -1,7 +1,7 @@
 const { ViolationTypes } = require('librechat-data-provider');
 const { isEnabled, math, removePorts } = require('~/server/utils');
+const { deleteAllUserSessions } = require('~/models');
 const getLogStores = require('./getLogStores');
-const Session = require('~/models/Session');
 const { logger } = require('~/config');
 
 const { BAN_VIOLATIONS, BAN_INTERVAL } = process.env ?? {};
@@ -46,7 +46,7 @@ const banViolation = async (req, res, errorMessage) => {
     return;
   }
 
-  await Session.deleteAllUserSessions(user_id);
+  await deleteAllUserSessions({ userId: user_id });
   res.clearCookie('refreshToken');
 
   const banLogs = getLogStores(ViolationTypes.BAN);

api/cache/getLogStores.js

@@ -5,49 +5,59 @@ const { math, isEnabled } = require('~/server/utils');
 const keyvRedis = require('./keyvRedis');
 const keyvMongo = require('./keyvMongo');
 
-const { BAN_DURATION, USE_REDIS } = process.env ?? {};
+const { BAN_DURATION, USE_REDIS, DEBUG_MEMORY_CACHE, CI } = process.env ?? {};
 
 const duration = math(BAN_DURATION, 7200000);
+const isRedisEnabled = isEnabled(USE_REDIS);
+const debugMemoryCache = isEnabled(DEBUG_MEMORY_CACHE);
 
 const createViolationInstance = (namespace) => {
-  const config = isEnabled(USE_REDIS) ? { store: keyvRedis } : { store: violationFile, namespace };
+  const config = isRedisEnabled ? { store: keyvRedis } : { store: violationFile, namespace };
   return new Keyv(config);
 };
 
 // Serve cache from memory so no need to clear it on startup/exit
-const pending_req = isEnabled(USE_REDIS)
+const pending_req = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: 'pending_req' });
 
-const config = isEnabled(USE_REDIS)
+const config = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: CacheKeys.CONFIG_STORE });
 
-const roles = isEnabled(USE_REDIS)
+const roles = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: CacheKeys.ROLES });
 
-const audioRuns = isEnabled(USE_REDIS)
+const audioRuns = isRedisEnabled
   ? new Keyv({ store: keyvRedis, ttl: Time.TEN_MINUTES })
   : new Keyv({ namespace: CacheKeys.AUDIO_RUNS, ttl: Time.TEN_MINUTES });
 
-const messages = isEnabled(USE_REDIS)
-  ? new Keyv({ store: keyvRedis, ttl: Time.FIVE_MINUTES })
-  : new Keyv({ namespace: CacheKeys.MESSAGES, ttl: Time.FIVE_MINUTES });
+const messages = isRedisEnabled
+  ? new Keyv({ store: keyvRedis, ttl: Time.ONE_MINUTE })
+  : new Keyv({ namespace: CacheKeys.MESSAGES, ttl: Time.ONE_MINUTE });
 
-const tokenConfig = isEnabled(USE_REDIS)
+const flows = isRedisEnabled
+  ? new Keyv({ store: keyvRedis, ttl: Time.TWO_MINUTES })
+  : new Keyv({ namespace: CacheKeys.FLOWS, ttl: Time.ONE_MINUTE * 3 });
+
+const tokenConfig = isRedisEnabled
   ? new Keyv({ store: keyvRedis, ttl: Time.THIRTY_MINUTES })
   : new Keyv({ namespace: CacheKeys.TOKEN_CONFIG, ttl: Time.THIRTY_MINUTES });
 
-const genTitle = isEnabled(USE_REDIS)
+const genTitle = isRedisEnabled
   ? new Keyv({ store: keyvRedis, ttl: Time.TWO_MINUTES })
   : new Keyv({ namespace: CacheKeys.GEN_TITLE, ttl: Time.TWO_MINUTES });
 
+const s3ExpiryInterval = isRedisEnabled
+  ? new Keyv({ store: keyvRedis, ttl: Time.THIRTY_MINUTES })
+  : new Keyv({ namespace: CacheKeys.S3_EXPIRY_INTERVAL, ttl: Time.THIRTY_MINUTES });
+
 const modelQueries = isEnabled(process.env.USE_REDIS)
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: CacheKeys.MODEL_QUERIES });
 
-const abortKeys = isEnabled(USE_REDIS)
+const abortKeys = isRedisEnabled
   ? new Keyv({ store: keyvRedis })
   : new Keyv({ namespace: CacheKeys.ABORT_KEYS, ttl: Time.TEN_MINUTES });
 
@@ -83,11 +93,166 @@ const namespaces = {
   [CacheKeys.ABORT_KEYS]: abortKeys,
   [CacheKeys.TOKEN_CONFIG]: tokenConfig,
   [CacheKeys.GEN_TITLE]: genTitle,
+  [CacheKeys.S3_EXPIRY_INTERVAL]: s3ExpiryInterval,
   [CacheKeys.MODEL_QUERIES]: modelQueries,
   [CacheKeys.AUDIO_RUNS]: audioRuns,
   [CacheKeys.MESSAGES]: messages,
+  [CacheKeys.FLOWS]: flows,
 };
 
+/**
+ * Gets all cache stores that have TTL configured
+ * @returns {Keyv[]}
+ */
+function getTTLStores() {
+  return Object.values(namespaces).filter(
+    (store) => store instanceof Keyv && typeof store.opts?.ttl === 'number' && store.opts.ttl > 0,
+  );
+}
+
+/**
+ * Clears entries older than the cache's TTL
+ * @param {Keyv} cache
+ */
+async function clearExpiredFromCache(cache) {
+  if (!cache?.opts?.store?.entries) {
+    return;
+  }
+
+  const ttl = cache.opts.ttl;
+  if (!ttl) {
+    return;
+  }
+
+  const expiryTime = Date.now() - ttl;
+  let cleared = 0;
+
+  // Get all keys first to avoid modification during iteration
+  const keys = Array.from(cache.opts.store.keys());
+
+  for (const key of keys) {
+    try {
+      const raw = cache.opts.store.get(key);
+      if (!raw) {
+        continue;
+      }
+
+      const data = cache.opts.deserialize(raw);
+      // Check if the entry is older than TTL
+      if (data?.expires && data.expires <= expiryTime) {
+        const deleted = await cache.opts.store.delete(key);
+        if (!deleted) {
+          debugMemoryCache &&
+            console.warn(`[Cache] Error deleting entry: ${key} from ${cache.opts.namespace}`);
+          continue;
+        }
+        cleared++;
+      }
+    } catch (error) {
+      debugMemoryCache &&
+        console.log(`[Cache] Error processing entry from ${cache.opts.namespace}:`, error);
+      const deleted = await cache.opts.store.delete(key);
+      if (!deleted) {
+        debugMemoryCache &&
+          console.warn(`[Cache] Error deleting entry: ${key} from ${cache.opts.namespace}`);
+        continue;
+      }
+      cleared++;
+    }
+  }
+
+  if (cleared > 0) {
+    debugMemoryCache &&
+      console.log(
+        `[Cache] Cleared ${cleared} entries older than ${ttl}ms from ${cache.opts.namespace}`,
+      );
+  }
+}
+
+const auditCache = () => {
+  const ttlStores = getTTLStores();
+  console.log('[Cache] Starting audit');
+
+  ttlStores.forEach((store) => {
+    if (!store?.opts?.store?.entries) {
+      return;
+    }
+
+    console.log(`[Cache] ${store.opts.namespace} entries:`, {
+      count: store.opts.store.size,
+      ttl: store.opts.ttl,
+      keys: Array.from(store.opts.store.keys()),
+      entriesWithTimestamps: Array.from(store.opts.store.entries()).map(([key, value]) => ({
+        key,
+        value,
+      })),
+    });
+  });
+};
+
+/**
+ * Clears expired entries from all TTL-enabled stores
+ */
+async function clearAllExpiredFromCache() {
+  const ttlStores = getTTLStores();
+  await Promise.all(ttlStores.map((store) => clearExpiredFromCache(store)));
+
+  // Force garbage collection if available (Node.js with --expose-gc flag)
+  if (global.gc) {
+    global.gc();
+  }
+}
+
+if (!isRedisEnabled && !isEnabled(CI)) {
+  /** @type {Set<NodeJS.Timeout>} */
+  const cleanupIntervals = new Set();
+
+  // Clear expired entries every 30 seconds
+  const cleanup = setInterval(() => {
+    clearAllExpiredFromCache();
+  }, Time.THIRTY_SECONDS);
+
+  cleanupIntervals.add(cleanup);
+
+  if (debugMemoryCache) {
+    const monitor = setInterval(() => {
+      const ttlStores = getTTLStores();
+      const memory = process.memoryUsage();
+      const totalSize = ttlStores.reduce((sum, store) => sum + (store.opts?.store?.size ?? 0), 0);
+
+      console.log('[Cache] Memory usage:', {
+        heapUsed: `${(memory.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+        heapTotal: `${(memory.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+        rss: `${(memory.rss / 1024 / 1024).toFixed(2)} MB`,
+        external: `${(memory.external / 1024 / 1024).toFixed(2)} MB`,
+        totalCacheEntries: totalSize,
+      });
+
+      auditCache();
+    }, Time.ONE_MINUTE);
+
+    cleanupIntervals.add(monitor);
+  }
+
+  const dispose = () => {
+    debugMemoryCache && console.log('[Cache] Cleaning up and shutting down...');
+    cleanupIntervals.forEach((interval) => clearInterval(interval));
+    cleanupIntervals.clear();
+
+    // One final cleanup before exit
+    clearAllExpiredFromCache().then(() => {
+      debugMemoryCache && console.log('[Cache] Final cleanup completed');
+      process.exit(0);
+    });
+  };
+
+  // Handle various termination signals
+  process.on('SIGTERM', dispose);
+  process.on('SIGINT', dispose);
+  process.on('SIGQUIT', dispose);
+  process.on('SIGHUP', dispose);
+}
+
 /**
  * Returns the keyv cache specified by type.
  * If an invalid type is passed, an error will be thrown.

api/cache/keyvRedis.js

@@ -1,20 +1,86 @@
+const fs = require('fs');
+const ioredis = require('ioredis');
 const KeyvRedis = require('@keyv/redis');
-const { logger } = require('~/config');
 const { isEnabled } = require('~/server/utils');
+const logger = require('~/config/winston');
 
-const { REDIS_URI, USE_REDIS } = process.env;
+const { REDIS_URI, USE_REDIS, USE_REDIS_CLUSTER, REDIS_CA, REDIS_KEY_PREFIX, REDIS_MAX_LISTENERS } =
+  process.env;
 
 let keyvRedis;
+const redis_prefix = REDIS_KEY_PREFIX || '';
+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)) {
-  keyvRedis = new KeyvRedis(REDIS_URI, { useRedisSets: false });
+  let redisOptions = null;
+  let keyvOpts = {
+    useRedisSets: false,
+    keyPrefix: redis_prefix,
+  };
+
+  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,
+      };
+    });
+    const cluster = new ioredis.Cluster(hosts, { redisOptions });
+    keyvRedis = new KeyvRedis(cluster, keyvOpts);
+  } else {
+    keyvRedis = new KeyvRedis(REDIS_URI, keyvOpts);
+  }
   keyvRedis.on('error', (err) => logger.error('KeyvRedis connection error:', err));
-  keyvRedis.setMaxListeners(20);
+  keyvRedis.setMaxListeners(redis_max_listeners);
   logger.info(
-    '[Optional] Redis initialized. Note: Redis support is experimental. If you have issues, disable it. Cache needs to be flushed for values to refresh.',
+    '[Optional] Redis initialized. If you have issues, or seeing older values, disable it or flush cache to refresh values.',
   );
 } else {
-  logger.info('[Optional] Redis not initialized. Note: Redis support is experimental.');
+  logger.info('[Optional] Redis not initialized.');
 }
 
 module.exports = keyvRedis;

api/config/index.js

@@ -1,9 +1,12 @@
+const axios = require('axios');
 const { EventSource } = require('eventsource');
+const { Time, CacheKeys } = require('librechat-data-provider');
 const logger = require('./winston');
 
 global.EventSource = EventSource;
 
 let mcpManager = null;
+let flowManager = null;
 
 /**
  * @returns {Promise<MCPManager>}
@@ -16,7 +19,75 @@ async function getMCPManager() {
   return mcpManager;
 }
 
+/**
+ * @param {(key: string) => Keyv} getLogStores
+ * @returns {Promise<FlowStateManager>}
+ */
+async function getFlowStateManager(getLogStores) {
+  if (!flowManager) {
+    const { FlowStateManager } = await import('librechat-mcp');
+    flowManager = new FlowStateManager(getLogStores(CacheKeys.FLOWS), {
+      ttl: Time.ONE_MINUTE * 3,
+      logger,
+    });
+  }
+  return flowManager;
+}
+
+/**
+ * Sends message data in Server Sent Events format.
+ * @param {ServerResponse} res - The server response.
+ * @param {{ data: string | Record<string, unknown>, event?: string }} event - The message event.
+ * @param {string} event.event - The type of event.
+ * @param {string} event.data - The message to be sent.
+ */
+const sendEvent = (res, event) => {
+  if (typeof event.data === 'string' && event.data.length === 0) {
+    return;
+  }
+  res.write(`event: message\ndata: ${JSON.stringify(event)}\n\n`);
+};
+
+/**
+ * Creates and configures an Axios instance with optional proxy settings.
+ *
+ * @typedef {import('axios').AxiosInstance} AxiosInstance
+ * @typedef {import('axios').AxiosProxyConfig} AxiosProxyConfig
+ *
+ * @returns {AxiosInstance} A configured Axios instance
+ * @throws {Error} If there's an issue creating the Axios instance or parsing the proxy URL
+ */
+function createAxiosInstance() {
+  const instance = axios.create();
+
+  if (process.env.proxy) {
+    try {
+      const url = new URL(process.env.proxy);
+
+      /** @type {AxiosProxyConfig} */
+      const proxyConfig = {
+        host: url.hostname.replace(/^\[|\]$/g, ''),
+        protocol: url.protocol.replace(':', ''),
+      };
+
+      if (url.port) {
+        proxyConfig.port = parseInt(url.port, 10);
+      }
+
+      instance.defaults.proxy = proxyConfig;
+    } catch (error) {
+      console.error('Error parsing proxy URL:', error);
+      throw new Error(`Invalid proxy URL: ${process.env.proxy}`);
+    }
+  }
+
+  return instance;
+}
+
 module.exports = {
   logger,
+  sendEvent,
   getMCPManager,
+  createAxiosInstance,
+  getFlowStateManager,
 };

api/config/index.spec.js

@@ -0,0 +1,126 @@
+const axios = require('axios');
+const { createAxiosInstance } = require('./index');
+
+// Mock axios
+jest.mock('axios', () => ({
+  interceptors: {
+    request: { use: jest.fn(), eject: jest.fn() },
+    response: { use: jest.fn(), eject: jest.fn() },
+  },
+  create: jest.fn().mockReturnValue({
+    defaults: {
+      proxy: null,
+    },
+    get: jest.fn().mockResolvedValue({ data: {} }),
+    post: jest.fn().mockResolvedValue({ data: {} }),
+    put: jest.fn().mockResolvedValue({ data: {} }),
+    delete: jest.fn().mockResolvedValue({ data: {} }),
+  }),
+  get: jest.fn().mockResolvedValue({ data: {} }),
+  post: jest.fn().mockResolvedValue({ data: {} }),
+  put: jest.fn().mockResolvedValue({ data: {} }),
+  delete: jest.fn().mockResolvedValue({ data: {} }),
+  reset: jest.fn().mockImplementation(function () {
+    this.get.mockClear();
+    this.post.mockClear();
+    this.put.mockClear();
+    this.delete.mockClear();
+    this.create.mockClear();
+  }),
+}));
+
+describe('createAxiosInstance', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+    // Create a clean copy of process.env
+    process.env = { ...originalEnv };
+    // Default: no proxy
+    delete process.env.proxy;
+  });
+
+  afterAll(() => {
+    // Restore original process.env
+    process.env = originalEnv;
+  });
+
+  test('creates an axios instance without proxy when no proxy env is set', () => {
+    const instance = createAxiosInstance();
+
+    expect(axios.create).toHaveBeenCalledTimes(1);
+    expect(instance.defaults.proxy).toBeNull();
+  });
+
+  test('configures proxy correctly with hostname and protocol', () => {
+    process.env.proxy = 'http://example.com';
+
+    const instance = createAxiosInstance();
+
+    expect(axios.create).toHaveBeenCalledTimes(1);
+    expect(instance.defaults.proxy).toEqual({
+      host: 'example.com',
+      protocol: 'http',
+    });
+  });
+
+  test('configures proxy correctly with hostname, protocol and port', () => {
+    process.env.proxy = 'https://proxy.example.com:8080';
+
+    const instance = createAxiosInstance();
+
+    expect(axios.create).toHaveBeenCalledTimes(1);
+    expect(instance.defaults.proxy).toEqual({
+      host: 'proxy.example.com',
+      protocol: 'https',
+      port: 8080,
+    });
+  });
+
+  test('handles proxy URLs with authentication', () => {
+    process.env.proxy = 'http://user:pass@proxy.example.com:3128';
+
+    const instance = createAxiosInstance();
+
+    expect(axios.create).toHaveBeenCalledTimes(1);
+    expect(instance.defaults.proxy).toEqual({
+      host: 'proxy.example.com',
+      protocol: 'http',
+      port: 3128,
+      // Note: The current implementation doesn't handle auth - if needed, add this functionality
+    });
+  });
+
+  test('throws error when proxy URL is invalid', () => {
+    process.env.proxy = 'invalid-url';
+
+    expect(() => createAxiosInstance()).toThrow('Invalid proxy URL');
+    expect(axios.create).toHaveBeenCalledTimes(1);
+  });
+
+  // If you want to test the actual URL parsing more thoroughly
+  test('handles edge case proxy URLs correctly', () => {
+    // IPv6 address
+    process.env.proxy = 'http://[::1]:8080';
+
+    let instance = createAxiosInstance();
+
+    expect(instance.defaults.proxy).toEqual({
+      host: '::1',
+      protocol: 'http',
+      port: 8080,
+    });
+
+    // URL with path (which should be ignored for proxy config)
+    process.env.proxy = 'http://proxy.example.com:8080/some/path';
+
+    instance = createAxiosInstance();
+
+    expect(instance.defaults.proxy).toEqual({
+      host: 'proxy.example.com',
+      protocol: 'http',
+      port: 8080,
+    });
+  });
+});

api/config/meiliLogger.js

@@ -4,7 +4,11 @@ require('winston-daily-rotate-file');
 
 const logDir = path.join(__dirname, '..', 'logs');
 
-const { NODE_ENV } = process.env;
+const { NODE_ENV, DEBUG_LOGGING = false } = process.env;
+
+const useDebugLogging =
+  (typeof DEBUG_LOGGING === 'string' && DEBUG_LOGGING?.toLowerCase() === 'true') ||
+  DEBUG_LOGGING === true;
 
 const levels = {
   error: 0,
@@ -36,9 +40,10 @@ const fileFormat = winston.format.combine(
   winston.format.splat(),
 );
 
+const logLevel = useDebugLogging ? 'debug' : 'error';
 const transports = [
   new winston.transports.DailyRotateFile({
-    level: 'debug',
+    level: logLevel,
     filename: `${logDir}/meiliSync-%DATE%.log`,
     datePattern: 'YYYY-MM-DD',
     zippedArchive: true,
@@ -48,14 +53,6 @@ const transports = [
   }),
 ];
 
-// if (NODE_ENV !== 'production') {
-//   transports.push(
-//     new winston.transports.Console({
-//       format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-//     }),
-//   );
-// }
-
 const consoleFormat = winston.format.combine(
   winston.format.colorize({ all: true }),
   winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),

api/config/parsers.js

@@ -4,6 +4,7 @@ const traverse = require('traverse');
 
 const SPLAT_SYMBOL = Symbol.for('splat');
 const MESSAGE_SYMBOL = Symbol.for('message');
+const CONSOLE_JSON_STRING_LENGTH = parseInt(process.env.CONSOLE_JSON_STRING_LENGTH) || 255;
 
 const sensitiveKeys = [
   /^(sk-)[^\s]+/, // OpenAI API key pattern
@@ -205,13 +206,13 @@ const jsonTruncateFormat = winston.format((info) => {
     seen.add(obj);
 
     if (Array.isArray(obj)) {
-      return obj.map(item => truncateObject(item));
+      return obj.map((item) => truncateObject(item));
     }
 
     const newObj = {};
     Object.entries(obj).forEach(([key, value]) => {
       if (typeof value === 'string') {
-        newObj[key] = truncateLongStrings(value, 255);
+        newObj[key] = truncateLongStrings(value, CONSOLE_JSON_STRING_LENGTH);
       } else {
         newObj[key] = truncateObject(value);
       }

api/config/winston.js

@@ -5,7 +5,7 @@ const { redactFormat, redactMessage, debugTraverse, jsonTruncateFormat } = requi
 
 const logDir = path.join(__dirname, '..', 'logs');
 
-const { NODE_ENV, DEBUG_LOGGING = true, DEBUG_CONSOLE = false, CONSOLE_JSON = false } = process.env;
+const { NODE_ENV, DEBUG_LOGGING = true, CONSOLE_JSON = false, DEBUG_CONSOLE = false } = process.env;
 
 const useConsoleJson =
   (typeof CONSOLE_JSON === 'string' && CONSOLE_JSON?.toLowerCase() === 'true') ||
@@ -15,6 +15,10 @@ const useDebugConsole =
   (typeof DEBUG_CONSOLE === 'string' && DEBUG_CONSOLE?.toLowerCase() === 'true') ||
   DEBUG_CONSOLE === true;
 
+const useDebugLogging =
+  (typeof DEBUG_LOGGING === 'string' && DEBUG_LOGGING?.toLowerCase() === 'true') ||
+  DEBUG_LOGGING === true;
+
 const levels = {
   error: 0,
   warn: 1,
@@ -57,28 +61,9 @@ const transports = [
     maxFiles: '14d',
     format: fileFormat,
   }),
-  // new winston.transports.DailyRotateFile({
-  //   level: 'info',
-  //   filename: `${logDir}/info-%DATE%.log`,
-  //   datePattern: 'YYYY-MM-DD',
-  //   zippedArchive: true,
-  //   maxSize: '20m',
-  //   maxFiles: '14d',
-  // }),
 ];
 
-// if (NODE_ENV !== 'production') {
-//   transports.push(
-//     new winston.transports.Console({
-//       format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-//     }),
-//   );
-// }
-
-if (
-  (typeof DEBUG_LOGGING === 'string' && DEBUG_LOGGING?.toLowerCase() === 'true') ||
-  DEBUG_LOGGING === true
-) {
+if (useDebugLogging) {
   transports.push(
     new winston.transports.DailyRotateFile({
       level: 'debug',
@@ -107,10 +92,16 @@ const consoleFormat = winston.format.combine(
   }),
 );
 
+// Determine console log level
+let consoleLogLevel = 'info';
+if (useDebugConsole) {
+  consoleLogLevel = 'debug';
+}
+
 if (useDebugConsole) {
   transports.push(
     new winston.transports.Console({
-      level: 'debug',
+      level: consoleLogLevel,
       format: useConsoleJson
         ? winston.format.combine(fileFormat, jsonTruncateFormat(), winston.format.json())
         : winston.format.combine(fileFormat, debugTraverse),
@@ -119,14 +110,14 @@ if (useDebugConsole) {
 } else if (useConsoleJson) {
   transports.push(
     new winston.transports.Console({
-      level: 'info',
+      level: consoleLogLevel,
       format: winston.format.combine(fileFormat, jsonTruncateFormat(), winston.format.json()),
     }),
   );
 } else {
   transports.push(
     new winston.transports.Console({
-      level: 'info',
+      level: consoleLogLevel,
       format: consoleFormat,
     }),
   );

api/lib/db/indexSync.js

@@ -1,9 +1,11 @@
 const { MeiliSearch } = require('meilisearch');
-const Conversation = require('~/models/schema/convoSchema');
-const Message = require('~/models/schema/messageSchema');
+const { Conversation } = require('~/models/Conversation');
+const { Message } = require('~/models/Message');
+const { isEnabled } = require('~/server/utils');
 const { logger } = require('~/config');
 
-const searchEnabled = process.env?.SEARCH?.toLowerCase() === 'true';
+const searchEnabled = isEnabled(process.env.SEARCH);
+const indexingDisabled = isEnabled(process.env.MEILI_NO_SYNC);
 let currentTimeout = null;
 
 class MeiliSearchClient {
@@ -23,8 +25,7 @@ class MeiliSearchClient {
   }
 }
 
-// eslint-disable-next-line no-unused-vars
-async function indexSync(req, res, next) {
+async function indexSync() {
   if (!searchEnabled) {
     return;
   }
@@ -33,10 +34,15 @@ async function indexSync(req, res, next) {
     const client = MeiliSearchClient.getInstance();
 
     const { status } = await client.health();
-    if (status !== 'available' || !process.env.SEARCH) {
+    if (status !== 'available') {
       throw new Error('Meilisearch not available');
     }
 
+    if (indexingDisabled === true) {
+      logger.info('[indexSync] Indexing is disabled, skipping...');
+      return;
+    }
+
     const messageCount = await Message.countDocuments();
     const convoCount = await Conversation.countDocuments();
     const messages = await client.index('messages').getStats();
@@ -71,7 +77,6 @@ async function indexSync(req, res, next) {
       logger.info('[indexSync] Meilisearch not configured, search will be disabled.');
     } else {
       logger.error('[indexSync] error', err);
-      // res.status(500).json({ error: 'Server error' });
     }
   }
 }

api/lib/utils/misc.js

@@ -3,15 +3,6 @@ const cleanUpPrimaryKeyValue = (value) => {
   return value.replace(/--/g, '|');
 };
 
-function replaceSup(text) {
-  if (!text.includes('<sup>')) {
-    return text;
-  }
-  const replacedText = text.replace(/<sup>/g, '^').replace(/\s+<\/sup>/g, '^');
-  return replacedText;
-}
-
 module.exports = {
   cleanUpPrimaryKeyValue,
-  replaceSup,
 };

api/models/Action.js

@@ -1,5 +1,5 @@
 const mongoose = require('mongoose');
-const actionSchema = require('./schema/action');
+const { actionSchema } = require('@librechat/data-schemas');
 
 const Action = mongoose.model('action', actionSchema);
 

api/models/Agent.js

@@ -9,7 +9,7 @@ const {
   removeAgentFromAllProjects,
 } = require('./Project');
 const getLogStores = require('~/cache/getLogStores');
-const agentSchema = require('./schema/agent');
+const { agentSchema } = require('@librechat/data-schemas');
 
 const Agent = mongoose.model('agent', agentSchema);
 
@@ -46,6 +46,10 @@ const loadAgent = async ({ req, agent_id }) => {
     id: agent_id,
   });
 
+  if (!agent) {
+    return null;
+  }
+
   if (agent.author.toString() === req.user.id) {
     return agent;
   }
@@ -82,7 +86,7 @@ const loadAgent = async ({ req, agent_id }) => {
  */
 const updateAgent = async (searchParameter, updateData) => {
   const options = { new: true, upsert: false };
-  return await Agent.findOneAndUpdate(searchParameter, updateData, options).lean();
+  return Agent.findOneAndUpdate(searchParameter, updateData, options).lean();
 };
 
 /**
@@ -96,25 +100,29 @@ const updateAgent = async (searchParameter, updateData) => {
  */
 const addAgentResourceFile = async ({ agent_id, tool_resource, file_id }) => {
   const searchParameter = { id: agent_id };
-  const agent = await getAgent(searchParameter);
 
-  if (!agent) {
+  const fileIdsPath = `tool_resources.${tool_resource}.file_ids`;
+
+  await Agent.updateOne(
+    {
+      id: agent_id,
+      [`${fileIdsPath}`]: { $exists: false },
+    },
+    {
+      $set: {
+        [`${fileIdsPath}`]: [],
+      },
+    },
+  );
+
+  const updateData = { $addToSet: { [fileIdsPath]: file_id } };
+
+  const updatedAgent = await updateAgent(searchParameter, updateData);
+  if (updatedAgent) {
+    return updatedAgent;
+  } else {
     throw new Error('Agent not found for adding resource file');
   }
-
-  const tool_resources = agent.tool_resources || {};
-
-  if (!tool_resources[tool_resource]) {
-    tool_resources[tool_resource] = { file_ids: [] };
-  }
-
-  if (!tool_resources[tool_resource].file_ids.includes(file_id)) {
-    tool_resources[tool_resource].file_ids.push(file_id);
-  }
-
-  const updateData = { tool_resources };
-
-  return await updateAgent(searchParameter, updateData);
 };
 
 /**
@@ -126,36 +134,52 @@ const addAgentResourceFile = async ({ agent_id, tool_resource, file_id }) => {
  */
 const removeAgentResourceFiles = async ({ agent_id, files }) => {
   const searchParameter = { id: agent_id };
-  const agent = await getAgent(searchParameter);
-
-  if (!agent) {
-    throw new Error('Agent not found for removing resource files');
-  }
-
-  const tool_resources = { ...agent.tool_resources } || {};
 
+  // associate each tool resource with the respective file ids array
   const filesByResource = files.reduce((acc, { tool_resource, file_id }) => {
     if (!acc[tool_resource]) {
-      acc[tool_resource] = new Set();
+      acc[tool_resource] = [];
     }
-    acc[tool_resource].add(file_id);
+    acc[tool_resource].push(file_id);
     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]) => {
-    if (tool_resources[resource] && tool_resources[resource].file_ids) {
-      tool_resources[resource].file_ids = tool_resources[resource].file_ids.filter(
-        (id) => !fileIds.has(id),
-      );
+    const toolResourcePath = `tool_resources.${resource}`;
+    const fileIdsPath = `${toolResourcePath}.file_ids`;
 
-      if (tool_resources[resource].file_ids.length === 0) {
-        delete tool_resources[resource];
-      }
-    }
+    // 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}`],
+        },
+      },
+    });
   });
 
-  const updateData = { tool_resources };
-  return await updateAgent(searchParameter, updateData);
+  // 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');
+  }
 };
 
 /**
@@ -281,6 +305,7 @@ const updateAgentProjects = async ({ user, agentId, projectIds, removeProjectIds
 };
 
 module.exports = {
+  Agent,
   getAgent,
   loadAgent,
   createAgent,

api/models/Agent.spec.js

@@ -0,0 +1,160 @@
+const mongoose = require('mongoose');
+const { v4: uuidv4 } = require('uuid');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { Agent, addAgentResourceFile, removeAgentResourceFiles } = require('./Agent');
+
+describe('Agent Resource File Operations', () => {
+  let mongoServer;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const mongoUri = mongoServer.getUri();
+    await mongoose.connect(mongoUri);
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  beforeEach(async () => {
+    await Agent.deleteMany({});
+  });
+
+  const createBasicAgent = async () => {
+    const agentId = `agent_${uuidv4()}`;
+    const agent = await Agent.create({
+      id: agentId,
+      name: 'Test Agent',
+      provider: 'test',
+      model: 'test-model',
+      author: new mongoose.Types.ObjectId(),
+    });
+    return agent;
+  };
+
+  test('should handle concurrent file additions', async () => {
+    const agent = await createBasicAgent();
+    const fileIds = Array.from({ length: 10 }, () => uuidv4());
+
+    // Concurrent additions
+    const additionPromises = fileIds.map((fileId) =>
+      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();
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toHaveLength(10);
+    expect(new Set(updatedAgent.tool_resources.test_tool.file_ids).size).toBe(10);
+  });
+
+  test('should handle concurrent additions and removals', async () => {
+    const agent = await createBasicAgent();
+    const initialFileIds = Array.from({ length: 5 }, () => uuidv4());
+
+    await Promise.all(
+      initialFileIds.map((fileId) =>
+        addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: 'test_tool',
+          file_id: fileId,
+        }),
+      ),
+    );
+
+    const newFileIds = Array.from({ length: 5 }, () => uuidv4());
+    const operations = [
+      ...newFileIds.map((fileId) =>
+        addAgentResourceFile({
+          agent_id: agent.id,
+          tool_resource: 'test_tool',
+          file_id: fileId,
+        }),
+      ),
+      ...initialFileIds.map((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 });
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toBeDefined();
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toHaveLength(5);
+  });
+
+  test('should initialize array when adding to non-existent tool resource', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+
+    const updatedAgent = await addAgentResourceFile({
+      agent_id: agent.id,
+      tool_resource: 'new_tool',
+      file_id: fileId,
+    });
+
+    expect(updatedAgent.tool_resources.new_tool.file_ids).toBeDefined();
+    expect(updatedAgent.tool_resources.new_tool.file_ids).toHaveLength(1);
+    expect(updatedAgent.tool_resources.new_tool.file_ids[0]).toBe(fileId);
+  });
+
+  test('should handle rapid sequential modifications to same tool resource', async () => {
+    const agent = await createBasicAgent();
+    const fileId = uuidv4();
+
+    for (let i = 0; i < 10; i++) {
+      await addAgentResourceFile({
+        agent_id: agent.id,
+        tool_resource: 'test_tool',
+        file_id: `${fileId}_${i}`,
+      });
+
+      if (i % 2 === 0) {
+        await removeAgentResourceFiles({
+          agent_id: agent.id,
+          files: [{ tool_resource: 'test_tool', file_id: `${fileId}_${i}` }],
+        });
+      }
+    }
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    expect(updatedAgent.tool_resources.test_tool.file_ids).toBeDefined();
+    expect(Array.isArray(updatedAgent.tool_resources.test_tool.file_ids)).toBe(true);
+  });
+
+  test('should handle multiple tool resources concurrently', async () => {
+    const agent = await createBasicAgent();
+    const toolResources = ['tool1', 'tool2', 'tool3'];
+    const operations = [];
+
+    toolResources.forEach((tool) => {
+      const fileIds = Array.from({ length: 5 }, () => uuidv4());
+      fileIds.forEach((fileId) => {
+        operations.push(
+          addAgentResourceFile({
+            agent_id: agent.id,
+            tool_resource: tool,
+            file_id: fileId,
+          }),
+        );
+      });
+    });
+
+    await Promise.all(operations);
+
+    const updatedAgent = await Agent.findOne({ id: agent.id });
+    toolResources.forEach((tool) => {
+      expect(updatedAgent.tool_resources[tool].file_ids).toBeDefined();
+      expect(updatedAgent.tool_resources[tool].file_ids).toHaveLength(5);
+    });
+  });
+});

api/models/Assistant.js

@@ -1,5 +1,5 @@
 const mongoose = require('mongoose');
-const assistantSchema = require('./schema/assistant');
+const { assistantSchema } = require('@librechat/data-schemas');
 
 const Assistant = mongoose.model('assistant', assistantSchema);
 

api/models/Balance.js

@@ -1,44 +1,4 @@
 const mongoose = require('mongoose');
-const balanceSchema = require('./schema/balance');
-const { getMultiplier } = require('./tx');
-const { logger } = require('~/config');
-
-balanceSchema.statics.check = async function ({
-  user,
-  model,
-  endpoint,
-  valueKey,
-  tokenType,
-  amount,
-  endpointTokenConfig,
-}) {
-  const multiplier = getMultiplier({ valueKey, tokenType, model, endpoint, endpointTokenConfig });
-  const tokenCost = amount * multiplier;
-  const { tokenCredits: balance } = (await this.findOne({ user }, 'tokenCredits').lean()) ?? {};
-
-  logger.debug('[Balance.check]', {
-    user,
-    model,
-    endpoint,
-    valueKey,
-    tokenType,
-    amount,
-    balance,
-    multiplier,
-    endpointTokenConfig: !!endpointTokenConfig,
-  });
-
-  if (!balance) {
-    return {
-      canSpend: false,
-      balance: 0,
-      tokenCost,
-    };
-  }
-
-  logger.debug('[Balance.check]', { tokenCost });
-
-  return { canSpend: balance >= tokenCost, balance, tokenCost };
-};
+const { balanceSchema } = require('@librechat/data-schemas');
 
 module.exports = mongoose.model('Balance', balanceSchema);

api/models/Banner.js

@@ -1,5 +1,9 @@
-const Banner = require('./schema/banner');
+const mongoose = require('mongoose');
 const logger = require('~/config/winston');
+const { bannerSchema } = require('@librechat/data-schemas');
+
+const Banner = mongoose.model('Banner', bannerSchema);
+
 /**
  * Retrieves the current active banner.
  * @returns {Promise<Object|null>} The active banner object or null if no active banner is found.
@@ -24,4 +28,4 @@ const getBanner = async (user) => {
   }
 };
 
-module.exports = { getBanner };
+module.exports = { Banner, getBanner };

api/models/Categories.js

@@ -1,44 +1,40 @@
 const { logger } = require('~/config');
-// const { Categories } = require('./schema/categories');
+
 const options = [
   {
-    label: '',
-    value: '',
-  },
-  {
-    label: 'idea',
+    label: 'com_ui_idea',
     value: 'idea',
   },
   {
-    label: 'travel',
+    label: 'com_ui_travel',
     value: 'travel',
   },
   {
-    label: 'teach_or_explain',
+    label: 'com_ui_teach_or_explain',
     value: 'teach_or_explain',
   },
   {
-    label: 'write',
+    label: 'com_ui_write',
     value: 'write',
   },
   {
-    label: 'shop',
+    label: 'com_ui_shop',
     value: 'shop',
   },
   {
-    label: 'code',
+    label: 'com_ui_code',
     value: 'code',
   },
   {
-    label: 'misc',
+    label: 'com_ui_misc',
     value: 'misc',
   },
   {
-    label: 'roleplay',
+    label: 'com_ui_roleplay',
     value: 'roleplay',
   },
   {
-    label: 'finance',
+    label: 'com_ui_finance',
     value: 'finance',
   },
 ];

api/models/Conversation.js

@@ -15,19 +15,6 @@ const searchConversation = async (conversationId) => {
     throw new Error('Error searching conversation');
   }
 };
-/**
- * Searches for a conversation by conversationId and returns associated file ids.
- * @param {string} conversationId - The conversation's ID.
- * @returns {Promise<string[] | null>}
- */
-const getConvoFiles = async (conversationId) => {
-  try {
-    return (await Conversation.findOne({ conversationId }, 'files').lean())?.files ?? [];
-  } catch (error) {
-    logger.error('[getConvoFiles] Error getting conversation files', error);
-    throw new Error('Error getting conversation files');
-  }
-};
 
 /**
  * Retrieves a single conversation for a given user and conversation ID.
@@ -73,6 +60,20 @@ const deleteNullOrEmptyConversations = async () => {
   }
 };
 
+/**
+ * Searches for a conversation by conversationId and returns associated file ids.
+ * @param {string} conversationId - The conversation's ID.
+ * @returns {Promise<string[] | null>}
+ */
+const getConvoFiles = async (conversationId) => {
+  try {
+    return (await Conversation.findOne({ conversationId }, 'files').lean())?.files ?? [];
+  } catch (error) {
+    logger.error('[getConvoFiles] Error getting conversation files', error);
+    throw new Error('Error getting conversation files');
+  }
+};
+
 module.exports = {
   Conversation,
   getConvoFiles,
@@ -96,10 +97,24 @@ module.exports = {
         update.conversationId = newConversationId;
       }
 
+      if (req.body.isTemporary) {
+        const expiredAt = new Date();
+        expiredAt.setDate(expiredAt.getDate() + 30);
+        update.expiredAt = expiredAt;
+      } else {
+        update.expiredAt = null;
+      }
+
+      /** @type {{ $set: Partial<TConversation>; $unset?: Record<keyof TConversation, number> }} */
+      const updateOperation = { $set: update };
+      if (metadata && metadata.unsetFields && Object.keys(metadata.unsetFields).length > 0) {
+        updateOperation.$unset = metadata.unsetFields;
+      }
+
       /** Note: the resulting Model object is necessary for Meilisearch operations */
       const conversation = await Conversation.findOneAndUpdate(
         { conversationId, user: req.user.id },
-        update,
+        updateOperation,
         {
           new: true,
           upsert: true,
@@ -143,6 +158,9 @@ module.exports = {
     if (Array.isArray(tags) && tags.length > 0) {
       query.tags = { $in: tags };
     }
+
+    query.$and = [{ $or: [{ expiredAt: null }, { expiredAt: { $exists: false } }] }];
+
     try {
       const totalConvos = (await Conversation.countDocuments(query)) || 1;
       const totalPages = Math.ceil(totalConvos / pageSize);
@@ -172,6 +190,7 @@ module.exports = {
           Conversation.findOne({
             user,
             conversationId: convo.conversationId,
+            $or: [{ expiredAt: { $exists: false } }, { expiredAt: null }],
           }).lean(),
         ),
       );

api/models/ConversationTag.js

@@ -1,7 +1,11 @@
-const ConversationTag = require('./schema/conversationTagSchema');
+const mongoose = require('mongoose');
 const Conversation = require('./schema/convoSchema');
 const logger = require('~/config/winston');
 
+const { conversationTagSchema } = require('@librechat/data-schemas');
+
+const ConversationTag = mongoose.model('ConversationTag', conversationTagSchema);
+
 /**
  * Retrieves all conversation tags for a user.
  * @param {string} user - The user ID.

api/models/File.js

@@ -1,5 +1,6 @@
 const mongoose = require('mongoose');
-const fileSchema = require('./schema/fileSchema');
+const { fileSchema } = require('@librechat/data-schemas');
+const { logger } = require('~/config');
 
 const File = mongoose.model('File', fileSchema);
 
@@ -7,7 +8,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<MongoFile>} A promise that resolves to the file document or null.
+ * @returns {Promise<IMongoFile>} A promise that resolves to the file document or null.
  */
 const findFileById = async (file_id, options = {}) => {
   return await File.findOne({ file_id, ...options }).lean();
@@ -17,18 +18,46 @@ const findFileById = async (file_id, options = {}) => {
  * Retrieves files matching a given filter, sorted by the most recently updated.
  * @param {Object} filter - The filter criteria to apply.
  * @param {Object} [_sortOptions] - Optional sort parameters.
- * @returns {Promise<Array<MongoFile>>} A promise that resolves to an array of file documents.
+ * @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.
  */
-const getFiles = async (filter, _sortOptions) => {
+const getFiles = async (filter, _sortOptions, selectFields = { text: 0 }) => {
   const sortOptions = { updatedAt: -1, ..._sortOptions };
-  return await File.find(filter).sort(sortOptions).lean();
+  return await File.find(filter).select(selectFields).sort(sortOptions).lean();
+};
+
+/**
+ * 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
+ */
+const getToolFilesByIds = async (fileIds) => {
+  if (!fileIds || !fileIds.length) {
+    return [];
+  }
+
+  try {
+    const filter = {
+      file_id: { $in: fileIds },
+      $or: [{ embedded: true }, { 'metadata.fileIdentifier': { $exists: true } }],
+    };
+
+    const selectFields = { text: 0 };
+    const sortOptions = { updatedAt: -1 };
+
+    return await getFiles(filter, sortOptions, selectFields);
+  } catch (error) {
+    logger.error('[getToolFilesByIds] Error retrieving tool files:', error);
+    throw new Error('Error retrieving tool files');
+  }
 };
 
 /**
  * Creates a new file with a TTL of 1 hour.
- * @param {MongoFile} data - The file data to be created, must contain file_id.
+ * @param {IMongoFile} data - The file data to be created, must contain file_id.
  * @param {boolean} disableTTL - Whether to disable the TTL.
- * @returns {Promise<MongoFile>} A promise that resolves to the created file document.
+ * @returns {Promise<IMongoFile>} A promise that resolves to the created file document.
  */
 const createFile = async (data, disableTTL) => {
   const fileData = {
@@ -48,8 +77,8 @@ const createFile = async (data, disableTTL) => {
 
 /**
  * Updates a file identified by file_id with new data and removes the TTL.
- * @param {MongoFile} data - The data to update, must contain file_id.
- * @returns {Promise<MongoFile>} A promise that resolves to the updated file document.
+ * @param {IMongoFile} data - The data to update, must contain file_id.
+ * @returns {Promise<IMongoFile>} A promise that resolves to the updated file document.
  */
 const updateFile = async (data) => {
   const { file_id, ...update } = data;
@@ -62,8 +91,8 @@ const updateFile = async (data) => {
 
 /**
  * Increments the usage of a file identified by file_id.
- * @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.
+ * @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.
  */
 const updateFileUsage = async (data) => {
   const { file_id, inc = 1 } = data;
@@ -77,7 +106,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<MongoFile>} A promise that resolves to the deleted file document or null.
+ * @returns {Promise<IMongoFile>} A promise that resolves to the deleted file document or null.
  */
 const deleteFile = async (file_id) => {
   return await File.findOneAndDelete({ file_id }).lean();
@@ -86,7 +115,7 @@ const deleteFile = async (file_id) => {
 /**
  * Deletes a file identified by a filter.
  * @param {object} filter - The filter criteria to apply.
- * @returns {Promise<MongoFile>} A promise that resolves to the deleted file document or null.
+ * @returns {Promise<IMongoFile>} A promise that resolves to the deleted file document or null.
  */
 const deleteFileByFilter = async (filter) => {
   return await File.findOneAndDelete(filter).lean();
@@ -105,14 +134,38 @@ const deleteFiles = async (file_ids, user) => {
   return await File.deleteMany(deleteQuery);
 };
 
+/**
+ * Batch updates files with new signed URLs in MongoDB
+ *
+ * @param {MongoFile[]} updates - Array of updates in the format { file_id, filepath }
+ * @returns {Promise<void>}
+ */
+async function batchUpdateFiles(updates) {
+  if (!updates || updates.length === 0) {
+    return;
+  }
+
+  const bulkOperations = updates.map((update) => ({
+    updateOne: {
+      filter: { file_id: update.file_id },
+      update: { $set: { filepath: update.filepath } },
+    },
+  }));
+
+  const result = await File.bulkWrite(bulkOperations);
+  logger.info(`Updated ${result.modifiedCount} files with new S3 URLs`);
+}
+
 module.exports = {
   File,
   findFileById,
   getFiles,
+  getToolFilesByIds,
   createFile,
   updateFile,
   updateFileUsage,
   deleteFile,
   deleteFiles,
   deleteFileByFilter,
+  batchUpdateFiles,
 };

api/models/Key.js

@@ -1,4 +1,4 @@
 const mongoose = require('mongoose');
-const keySchema = require('./schema/key');
+const { keySchema } = require('@librechat/data-schemas');
 
 module.exports = mongoose.model('Key', keySchema);

api/models/Message.js

@@ -23,7 +23,6 @@ const idSchema = z.string().uuid();
  * @param {string} [params.error] - Any error associated with the message.
  * @param {boolean} [params.unfinished] - Indicates if the message is unfinished.
  * @param {Object[]} [params.files] - An array of files associated with the message.
- * @param {boolean} [params.isEdited] - Indicates if the message was edited.
  * @param {string} [params.finish_reason] - Reason for finishing the message.
  * @param {number} [params.tokenCount] - The number of tokens in the message.
  * @param {string} [params.plugin] - Plugin associated with the message.
@@ -53,6 +52,15 @@ async function saveMessage(req, params, metadata) {
       user: req.user.id,
       messageId: params.newMessageId || params.messageId,
     };
+
+    if (req?.body?.isTemporary) {
+      const expiredAt = new Date();
+      expiredAt.setDate(expiredAt.getDate() + 30);
+      update.expiredAt = expiredAt;
+    } else {
+      update.expiredAt = null;
+    }
+
     const message = await Message.findOneAndUpdate(
       { messageId: params.messageId, user: req.user.id },
       update,
@@ -63,7 +71,42 @@ async function saveMessage(req, params, metadata) {
   } catch (err) {
     logger.error('Error saving message:', err);
     logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-    throw err;
+
+    // Check if this is a duplicate key error (MongoDB error code 11000)
+    if (err.code === 11000 && err.message.includes('duplicate key error')) {
+      // Log the duplicate key error but don't crash the application
+      logger.warn(`Duplicate messageId detected: ${params.messageId}. Continuing execution.`);
+
+      try {
+        // Try to find the existing message with this ID
+        const existingMessage = await Message.findOne({
+          messageId: params.messageId,
+          user: req.user.id,
+        });
+
+        // If we found it, return it
+        if (existingMessage) {
+          return existingMessage.toObject();
+        }
+
+        // If we can't find it (unlikely but possible in race conditions)
+        return {
+          ...params,
+          messageId: params.messageId,
+          user: req.user.id,
+        };
+      } 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}`);
+        return {
+          ...params,
+          messageId: params.messageId,
+          user: req.user.id,
+        };
+      }
+    }
+
+    throw err; // Re-throw other errors
   }
 }
 
@@ -77,7 +120,7 @@ async function saveMessage(req, params, metadata) {
  * @returns {Promise<Object>} The result of the bulk write operation.
  * @throws {Error} If there is an error in saving messages in bulk.
  */
-async function bulkSaveMessages(messages, overrideTimestamp=false) {
+async function bulkSaveMessages(messages, overrideTimestamp = false) {
   try {
     const bulkOps = messages.map((message) => ({
       updateOne: {
@@ -182,7 +225,6 @@ async function updateMessageText(req, { messageId, text }) {
 async function updateMessage(req, message, metadata) {
   try {
     const { messageId, ...update } = message;
-    update.isEdited = true;
     const updatedMessage = await Message.findOneAndUpdate(
       { messageId, user: req.user.id },
       update,
@@ -203,7 +245,6 @@ async function updateMessage(req, message, metadata) {
       text: updatedMessage.text,
       isCreatedByUser: updatedMessage.isCreatedByUser,
       tokenCount: updatedMessage.tokenCount,
-      isEdited: true,
     };
   } catch (err) {
     logger.error('Error updating message:', err);

api/models/Message.spec.js

@@ -100,7 +100,6 @@ describe('Message Operations', () => {
         expect.objectContaining({
           messageId: 'msg123',
           text: 'Hello, world!',
-          isEdited: true,
         }),
       );
     });

api/models/Project.js

@@ -1,6 +1,6 @@
 const { model } = require('mongoose');
 const { GLOBAL_PROJECT_NAME } = require('librechat-data-provider').Constants;
-const projectSchema = require('~/models/schema/projectSchema');
+const { projectSchema } = require('@librechat/data-schemas');
 
 const Project = model('Project', projectSchema);
 
@@ -9,7 +9,7 @@ const Project = model('Project', projectSchema);
  *
  * @param {string} projectId - The ID of the project to find and return as a plain object.
  * @param {string|string[]} [fieldsToSelect] - The fields to include or exclude in the returned document.
- * @returns {Promise<MongoProject>} A plain object representing the project document, or `null` if no project is found.
+ * @returns {Promise<IMongoProject>} A plain object representing the project document, or `null` if no project is found.
  */
 const getProjectById = async function (projectId, fieldsToSelect = null) {
   const query = Project.findById(projectId);
@@ -27,7 +27,7 @@ const getProjectById = async function (projectId, fieldsToSelect = null) {
  *
  * @param {string} projectName - The name of the project to find or create.
  * @param {string|string[]} [fieldsToSelect] - The fields to include or exclude in the returned document.
- * @returns {Promise<MongoProject>} A plain object representing the project document.
+ * @returns {Promise<IMongoProject>} A plain object representing the project document.
  */
 const getProjectByName = async function (projectName, fieldsToSelect = null) {
   const query = { name: projectName };
@@ -47,7 +47,7 @@ const getProjectByName = async function (projectName, fieldsToSelect = null) {
  *
  * @param {string} projectId - The ID of the project to update.
  * @param {string[]} promptGroupIds - The array of prompt group IDs to add to the project.
- * @returns {Promise<MongoProject>} The updated project document.
+ * @returns {Promise<IMongoProject>} The updated project document.
  */
 const addGroupIdsToProject = async function (projectId, promptGroupIds) {
   return await Project.findByIdAndUpdate(
@@ -62,7 +62,7 @@ const addGroupIdsToProject = async function (projectId, promptGroupIds) {
  *
  * @param {string} projectId - The ID of the project to update.
  * @param {string[]} promptGroupIds - The array of prompt group IDs to remove from the project.
- * @returns {Promise<MongoProject>} The updated project document.
+ * @returns {Promise<IMongoProject>} The updated project document.
  */
 const removeGroupIdsFromProject = async function (projectId, promptGroupIds) {
   return await Project.findByIdAndUpdate(
@@ -87,7 +87,7 @@ const removeGroupFromAllProjects = async (promptGroupId) => {
  *
  * @param {string} projectId - The ID of the project to update.
  * @param {string[]} agentIds - The array of agent IDs to add to the project.
- * @returns {Promise<MongoProject>} The updated project document.
+ * @returns {Promise<IMongoProject>} The updated project document.
  */
 const addAgentIdsToProject = async function (projectId, agentIds) {
   return await Project.findByIdAndUpdate(
@@ -102,7 +102,7 @@ const addAgentIdsToProject = async function (projectId, agentIds) {
  *
  * @param {string} projectId - The ID of the project to update.
  * @param {string[]} agentIds - The array of agent IDs to remove from the project.
- * @returns {Promise<MongoProject>} The updated project document.
+ * @returns {Promise<IMongoProject>} The updated project document.
  */
 const removeAgentIdsFromProject = async function (projectId, agentIds) {
   return await Project.findByIdAndUpdate(

api/models/Prompt.js

@@ -1,3 +1,4 @@
+const mongoose = require('mongoose');
 const { ObjectId } = require('mongodb');
 const { SystemRoles, SystemCategories, Constants } = require('librechat-data-provider');
 const {
@@ -6,10 +7,13 @@ const {
   removeGroupIdsFromProject,
   removeGroupFromAllProjects,
 } = require('./Project');
-const { Prompt, PromptGroup } = require('./schema/promptSchema');
+const { promptGroupSchema, promptSchema } = require('@librechat/data-schemas');
 const { escapeRegExp } = require('~/server/utils');
 const { logger } = require('~/config');
 
+const PromptGroup = mongoose.model('PromptGroup', promptGroupSchema);
+const Prompt = mongoose.model('Prompt', promptSchema);
+
 /**
  * Create a pipeline for the aggregation to get prompt groups
  * @param {Object} query
@@ -125,7 +129,7 @@ const getAllPromptGroups = async (req, filter) => {
 
     if (searchShared) {
       const project = await getProjectByName(Constants.GLOBAL_PROJECT_NAME, 'promptGroupIds');
-      if (project && project.promptGroupIds.length > 0) {
+      if (project && project.promptGroupIds && project.promptGroupIds.length > 0) {
         const projectQuery = { _id: { $in: project.promptGroupIds }, ...query };
         delete projectQuery.author;
         combinedQuery = searchSharedOnly ? projectQuery : { $or: [projectQuery, query] };
@@ -179,7 +183,7 @@ const getPromptGroups = async (req, filter) => {
     if (searchShared) {
       // const projects = req.user.projects || []; // TODO: handle multiple projects
       const project = await getProjectByName(Constants.GLOBAL_PROJECT_NAME, 'promptGroupIds');
-      if (project && project.promptGroupIds.length > 0) {
+      if (project && project.promptGroupIds && project.promptGroupIds.length > 0) {
         const projectQuery = { _id: { $in: project.promptGroupIds }, ...query };
         delete projectQuery.author;
         combinedQuery = searchSharedOnly ? projectQuery : { $or: [projectQuery, query] };

api/models/Role.js

@@ -1,3 +1,4 @@
+const mongoose = require('mongoose');
 const {
   CacheKeys,
   SystemRoles,
@@ -6,13 +7,17 @@ const {
   removeNullishValues,
   agentPermissionsSchema,
   promptPermissionsSchema,
+  runCodePermissionsSchema,
   bookmarkPermissionsSchema,
   multiConvoPermissionsSchema,
+  temporaryChatPermissionsSchema,
 } = require('librechat-data-provider');
 const getLogStores = require('~/cache/getLogStores');
-const Role = require('~/models/schema/roleSchema');
+const { roleSchema } = require('@librechat/data-schemas');
 const { logger } = require('~/config');
 
+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.
@@ -77,6 +82,8 @@ const permissionSchemas = {
   [PermissionTypes.PROMPTS]: promptPermissionsSchema,
   [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
   [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
+  [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
+  [PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
 };
 
 /**
@@ -164,6 +171,7 @@ const initializeRoles = async function () {
   }
 };
 module.exports = {
+  Role,
   getRoleByName,
   initializeRoles,
   updateRoleByName,

api/models/Role.spec.js

@@ -8,7 +8,7 @@ const {
 } = require('librechat-data-provider');
 const { updateAccessPermissions, initializeRoles } = require('~/models/Role');
 const getLogStores = require('~/cache/getLogStores');
-const Role = require('~/models/schema/roleSchema');
+const { Role } = require('~/models/Role');
 
 // Mock the cache
 jest.mock('~/cache/getLogStores', () => {

api/models/Session.js

@@ -1,75 +1,275 @@
 const mongoose = require('mongoose');
 const signPayload = require('~/server/services/signPayload');
 const { hashToken } = require('~/server/utils/crypto');
+const { sessionSchema } = require('@librechat/data-schemas');
 const { logger } = require('~/config');
 
+const Session = mongoose.model('Session', sessionSchema);
+
 const { REFRESH_TOKEN_EXPIRY } = process.env ?? {};
-const expires = eval(REFRESH_TOKEN_EXPIRY) ?? 1000 * 60 * 60 * 24 * 7;
+const expires = eval(REFRESH_TOKEN_EXPIRY) ?? 1000 * 60 * 60 * 24 * 7; // 7 days default
 
-const sessionSchema = mongoose.Schema({
-  refreshTokenHash: {
-    type: String,
-    required: true,
-  },
-  expiration: {
-    type: Date,
-    required: true,
-    expires: 0,
-  },
-  user: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'User',
-    required: true,
-  },
-});
+/**
+ * Error class for Session-related errors
+ */
+class SessionError extends Error {
+  constructor(message, code = 'SESSION_ERROR') {
+    super(message);
+    this.name = 'SessionError';
+    this.code = code;
+  }
+}
+
+/**
+ * Creates a new session for a user
+ * @param {string} userId - The ID of the user
+ * @param {Object} options - Additional options for session creation
+ * @param {Date} options.expiration - Custom expiration date
+ * @returns {Promise<{session: Session, refreshToken: string}>}
+ * @throws {SessionError}
+ */
+const createSession = async (userId, options = {}) => {
+  if (!userId) {
+    throw new SessionError('User ID is required', 'INVALID_USER_ID');
+  }
 
-sessionSchema.methods.generateRefreshToken = async function () {
   try {
-    let expiresIn;
-    if (this.expiration) {
-      expiresIn = this.expiration.getTime();
-    } else {
-      expiresIn = Date.now() + expires;
-      this.expiration = new Date(expiresIn);
+    const session = new Session({
+      user: userId,
+      expiration: options.expiration || new Date(Date.now() + expires),
+    });
+    const refreshToken = await generateRefreshToken(session);
+    return { session, refreshToken };
+  } catch (error) {
+    logger.error('[createSession] Error creating session:', error);
+    throw new SessionError('Failed to create session', 'CREATE_SESSION_FAILED');
+  }
+};
+
+/**
+ * Finds a session by various parameters
+ * @param {Object} params - Search parameters
+ * @param {string} [params.refreshToken] - The refresh token to search by
+ * @param {string} [params.userId] - The user ID to search by
+ * @param {string} [params.sessionId] - The session ID to search by
+ * @param {Object} [options] - Additional options
+ * @param {boolean} [options.lean=true] - Whether to return plain objects instead of documents
+ * @returns {Promise<Session|null>}
+ * @throws {SessionError}
+ */
+const findSession = async (params, options = { lean: true }) => {
+  try {
+    const query = {};
+
+    if (!params.refreshToken && !params.userId && !params.sessionId) {
+      throw new SessionError('At least one search parameter is required', 'INVALID_SEARCH_PARAMS');
+    }
+
+    if (params.refreshToken) {
+      const tokenHash = await hashToken(params.refreshToken);
+      query.refreshTokenHash = tokenHash;
+    }
+
+    if (params.userId) {
+      query.user = params.userId;
+    }
+
+    if (params.sessionId) {
+      const sessionId = params.sessionId.sessionId || params.sessionId;
+      if (!mongoose.Types.ObjectId.isValid(sessionId)) {
+        throw new SessionError('Invalid session ID format', 'INVALID_SESSION_ID');
+      }
+      query._id = sessionId;
+    }
+
+    // Add expiration check to only return valid sessions
+    query.expiration = { $gt: new Date() };
+
+    const sessionQuery = Session.findOne(query);
+
+    if (options.lean) {
+      return await sessionQuery.lean();
+    }
+
+    return await sessionQuery.exec();
+  } catch (error) {
+    logger.error('[findSession] Error finding session:', error);
+    throw new SessionError('Failed to find session', 'FIND_SESSION_FAILED');
+  }
+};
+
+/**
+ * Updates session expiration
+ * @param {Session|string} session - The session or session ID to update
+ * @param {Date} [newExpiration] - Optional new expiration date
+ * @returns {Promise<Session>}
+ * @throws {SessionError}
+ */
+const updateExpiration = async (session, newExpiration) => {
+  try {
+    const sessionDoc = typeof session === 'string' ? await Session.findById(session) : session;
+
+    if (!sessionDoc) {
+      throw new SessionError('Session not found', 'SESSION_NOT_FOUND');
+    }
+
+    sessionDoc.expiration = newExpiration || new Date(Date.now() + expires);
+    return await sessionDoc.save();
+  } catch (error) {
+    logger.error('[updateExpiration] Error updating session:', error);
+    throw new SessionError('Failed to update session expiration', 'UPDATE_EXPIRATION_FAILED');
+  }
+};
+
+/**
+ * Deletes a session by refresh token or session ID
+ * @param {Object} params - Delete parameters
+ * @param {string} [params.refreshToken] - The refresh token of the session to delete
+ * @param {string} [params.sessionId] - The ID of the session to delete
+ * @returns {Promise<Object>}
+ * @throws {SessionError}
+ */
+const deleteSession = async (params) => {
+  try {
+    if (!params.refreshToken && !params.sessionId) {
+      throw new SessionError(
+        'Either refreshToken or sessionId is required',
+        'INVALID_DELETE_PARAMS',
+      );
+    }
+
+    const query = {};
+
+    if (params.refreshToken) {
+      query.refreshTokenHash = await hashToken(params.refreshToken);
+    }
+
+    if (params.sessionId) {
+      query._id = params.sessionId;
+    }
+
+    const result = await Session.deleteOne(query);
+
+    if (result.deletedCount === 0) {
+      logger.warn('[deleteSession] No session found to delete');
+    }
+
+    return result;
+  } catch (error) {
+    logger.error('[deleteSession] Error deleting session:', error);
+    throw new SessionError('Failed to delete session', 'DELETE_SESSION_FAILED');
+  }
+};
+
+/**
+ * Deletes all sessions for a user
+ * @param {string} userId - The ID of the user
+ * @param {Object} [options] - Additional options
+ * @param {boolean} [options.excludeCurrentSession] - Whether to exclude the current session
+ * @param {string} [options.currentSessionId] - The ID of the current session to exclude
+ * @returns {Promise<Object>}
+ * @throws {SessionError}
+ */
+const deleteAllUserSessions = async (userId, options = {}) => {
+  try {
+    if (!userId) {
+      throw new SessionError('User ID is required', 'INVALID_USER_ID');
+    }
+
+    // Extract userId if it's passed as an object
+    const userIdString = userId.userId || userId;
+
+    if (!mongoose.Types.ObjectId.isValid(userIdString)) {
+      throw new SessionError('Invalid user ID format', 'INVALID_USER_ID_FORMAT');
+    }
+
+    const query = { user: userIdString };
+
+    if (options.excludeCurrentSession && options.currentSessionId) {
+      query._id = { $ne: options.currentSessionId };
+    }
+
+    const result = await Session.deleteMany(query);
+
+    if (result.deletedCount > 0) {
+      logger.debug(
+        `[deleteAllUserSessions] Deleted ${result.deletedCount} sessions for user ${userIdString}.`,
+      );
+    }
+
+    return result;
+  } catch (error) {
+    logger.error('[deleteAllUserSessions] Error deleting user sessions:', error);
+    throw new SessionError('Failed to delete user sessions', 'DELETE_ALL_SESSIONS_FAILED');
+  }
+};
+
+/**
+ * Generates a refresh token for a session
+ * @param {Session} session - The session to generate a token for
+ * @returns {Promise<string>}
+ * @throws {SessionError}
+ */
+const generateRefreshToken = async (session) => {
+  if (!session || !session.user) {
+    throw new SessionError('Invalid session object', 'INVALID_SESSION');
+  }
+
+  try {
+    const expiresIn = session.expiration ? session.expiration.getTime() : Date.now() + expires;
+
+    if (!session.expiration) {
+      session.expiration = new Date(expiresIn);
     }
 
     const refreshToken = await signPayload({
-      payload: { id: this.user },
+      payload: {
+        id: session.user,
+        sessionId: session._id,
+      },
       secret: process.env.JWT_REFRESH_SECRET,
       expirationTime: Math.floor((expiresIn - Date.now()) / 1000),
     });
 
-    this.refreshTokenHash = await hashToken(refreshToken);
-
-    await this.save();
+    session.refreshTokenHash = await hashToken(refreshToken);
+    await session.save();
 
     return refreshToken;
   } catch (error) {
-    logger.error(
-      'Error generating refresh token. Is a `JWT_REFRESH_SECRET` set in the .env file?\n\n',
-      error,
-    );
-    throw error;
+    logger.error('[generateRefreshToken] Error generating refresh token:', error);
+    throw new SessionError('Failed to generate refresh token', 'GENERATE_TOKEN_FAILED');
   }
 };
 
-sessionSchema.statics.deleteAllUserSessions = async function (userId) {
+/**
+ * Counts active sessions for a user
+ * @param {string} userId - The ID of the user
+ * @returns {Promise<number>}
+ * @throws {SessionError}
+ */
+const countActiveSessions = async (userId) => {
   try {
     if (!userId) {
-      return;
-    }
-    const result = await this.deleteMany({ user: userId });
-    if (result && result?.deletedCount > 0) {
-      logger.debug(
-        `[deleteAllUserSessions] Deleted ${result.deletedCount} sessions for user ${userId}.`,
-      );
+      throw new SessionError('User ID is required', 'INVALID_USER_ID');
     }
+
+    return await Session.countDocuments({
+      user: userId,
+      expiration: { $gt: new Date() },
+    });
   } catch (error) {
-    logger.error('[deleteAllUserSessions] Error in deleting user sessions:', error);
-    throw error;
+    logger.error('[countActiveSessions] Error counting active sessions:', error);
+    throw new SessionError('Failed to count active sessions', 'COUNT_SESSIONS_FAILED');
   }
 };
 
-const Session = mongoose.model('Session', sessionSchema);
-
-module.exports = Session;
+module.exports = {
+  createSession,
+  findSession,
+  updateExpiration,
+  deleteSession,
+  deleteAllUserSessions,
+  generateRefreshToken,
+  countActiveSessions,
+  SessionError,
+};

api/models/Share.js

@@ -1,82 +1,73 @@
+const mongoose = require('mongoose');
 const { nanoid } = require('nanoid');
 const { Constants } = require('librechat-data-provider');
-const SharedLink = require('./schema/shareSchema');
+const { Conversation } = require('~/models/Conversation');
+const { shareSchema } = require('@librechat/data-schemas');
+const SharedLink = mongoose.model('SharedLink', shareSchema);
 const { getMessages } = require('./Message');
 const logger = require('~/config/winston');
 
-/**
- * Anonymizes a conversation ID
- * @returns {string} The anonymized conversation ID
- */
-function anonymizeConvoId() {
-  return `convo_${nanoid()}`;
+class ShareServiceError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'ShareServiceError';
+    this.code = code;
+  }
 }
 
-/**
- * Anonymizes an assistant ID
- * @returns {string} The anonymized assistant ID
- */
-function anonymizeAssistantId() {
-  return `a_${nanoid()}`;
-}
+const memoizedAnonymizeId = (prefix) => {
+  const memo = new Map();
+  return (id) => {
+    if (!memo.has(id)) {
+      memo.set(id, `${prefix}_${nanoid()}`);
+    }
+    return memo.get(id);
+  };
+};
 
-/**
- * Anonymizes a message ID
- * @param {string} id - The original message ID
- * @returns {string} The anonymized message ID
- */
-function anonymizeMessageId(id) {
-  return id === Constants.NO_PARENT ? id : `msg_${nanoid()}`;
-}
+const anonymizeConvoId = memoizedAnonymizeId('convo');
+const anonymizeAssistantId = memoizedAnonymizeId('a');
+const anonymizeMessageId = (id) =>
+  id === Constants.NO_PARENT ? id : memoizedAnonymizeId('msg')(id);
 
-/**
- * Anonymizes a conversation object
- * @param {object} conversation - The conversation object
- * @returns {object} The anonymized conversation object
- */
 function anonymizeConvo(conversation) {
+  if (!conversation) {
+    return null;
+  }
+
   const newConvo = { ...conversation };
   if (newConvo.assistant_id) {
-    newConvo.assistant_id = anonymizeAssistantId();
+    newConvo.assistant_id = anonymizeAssistantId(newConvo.assistant_id);
   }
   return newConvo;
 }
 
-/**
- * Anonymizes messages in a conversation
- * @param {TMessage[]} messages - The original messages
- * @param {string} newConvoId - The new conversation ID
- * @returns {TMessage[]} The anonymized messages
- */
 function anonymizeMessages(messages, newConvoId) {
+  if (!Array.isArray(messages)) {
+    return [];
+  }
+
   const idMap = new Map();
   return messages.map((message) => {
     const newMessageId = anonymizeMessageId(message.messageId);
     idMap.set(message.messageId, newMessageId);
 
-    const anonymizedMessage = Object.assign(message, {
+    return {
+      ...message,
       messageId: newMessageId,
       parentMessageId:
         idMap.get(message.parentMessageId) || anonymizeMessageId(message.parentMessageId),
       conversationId: newConvoId,
-    });
-
-    if (anonymizedMessage.model && anonymizedMessage.model.startsWith('asst_')) {
-      anonymizedMessage.model = anonymizeAssistantId();
-    }
-
-    return anonymizedMessage;
+      model: message.model?.startsWith('asst_')
+        ? anonymizeAssistantId(message.model)
+        : message.model,
+    };
   });
 }
 
-/**
- * Retrieves shared messages for a given share ID
- * @param {string} shareId - The share ID
- * @returns {Promise<object|null>} The shared conversation data or null if not found
- */
 async function getSharedMessages(shareId) {
   try {
-    const share = await SharedLink.findOne({ shareId })
+    const share = await SharedLink.findOne({ shareId, isPublic: true })
       .populate({
         path: 'messages',
         select: '-_id -__v -user',
@@ -84,165 +75,264 @@ async function getSharedMessages(shareId) {
       .select('-_id -__v -user')
       .lean();
 
-    if (!share || !share.conversationId || !share.isPublic) {
+    if (!share?.conversationId || !share.isPublic) {
       return null;
     }
 
-    const newConvoId = anonymizeConvoId();
-    return Object.assign(share, {
+    const newConvoId = anonymizeConvoId(share.conversationId);
+    const result = {
+      ...share,
       conversationId: newConvoId,
       messages: anonymizeMessages(share.messages, newConvoId),
-    });
+    };
+
+    return result;
   } catch (error) {
-    logger.error('[getShare] Error getting share link', error);
-    throw new Error('Error getting share link');
+    logger.error('[getShare] Error getting share link', {
+      error: error.message,
+      shareId,
+    });
+    throw new ShareServiceError('Error getting share link', 'SHARE_FETCH_ERROR');
   }
 }
 
-/**
- * Retrieves shared links for a user
- * @param {string} user - The user ID
- * @param {number} [pageNumber=1] - The page number
- * @param {number} [pageSize=25] - The page size
- * @param {boolean} [isPublic=true] - Whether to retrieve public links only
- * @returns {Promise<object>} The shared links and pagination data
- */
-async function getSharedLinks(user, pageNumber = 1, pageSize = 25, isPublic = true) {
-  const query = { user, isPublic };
+async function getSharedLinks(user, pageParam, pageSize, isPublic, sortBy, sortDirection, search) {
   try {
-    const [totalConvos, sharedLinks] = await Promise.all([
-      SharedLink.countDocuments(query),
-      SharedLink.find(query)
-        .sort({ updatedAt: -1 })
-        .skip((pageNumber - 1) * pageSize)
-        .limit(pageSize)
-        .select('-_id -__v -user')
-        .lean(),
-    ]);
+    const query = { user, isPublic };
 
-    const totalPages = Math.ceil((totalConvos || 1) / pageSize);
+    if (pageParam) {
+      if (sortDirection === 'desc') {
+        query[sortBy] = { $lt: pageParam };
+      } else {
+        query[sortBy] = { $gt: pageParam };
+      }
+    }
+
+    if (search && search.trim()) {
+      try {
+        const searchResults = await Conversation.meiliSearch(search);
+
+        if (!searchResults?.hits?.length) {
+          return {
+            links: [],
+            nextCursor: undefined,
+            hasNextPage: false,
+          };
+        }
+
+        const conversationIds = searchResults.hits.map((hit) => hit.conversationId);
+        query['conversationId'] = { $in: conversationIds };
+      } catch (searchError) {
+        logger.error('[getSharedLinks] Meilisearch error', {
+          error: searchError.message,
+          user,
+        });
+        return {
+          links: [],
+          nextCursor: undefined,
+          hasNextPage: false,
+        };
+      }
+    }
+
+    const sort = {};
+    sort[sortBy] = sortDirection === 'desc' ? -1 : 1;
+
+    if (Array.isArray(query.conversationId)) {
+      query.conversationId = { $in: query.conversationId };
+    }
+
+    const sharedLinks = await SharedLink.find(query)
+      .sort(sort)
+      .limit(pageSize + 1)
+      .select('-__v -user')
+      .lean();
+
+    const hasNextPage = sharedLinks.length > pageSize;
+    const links = sharedLinks.slice(0, pageSize);
+
+    const nextCursor = hasNextPage ? links[links.length - 1][sortBy] : undefined;
 
     return {
-      sharedLinks,
-      pages: totalPages,
-      pageNumber,
-      pageSize,
+      links: links.map((link) => ({
+        shareId: link.shareId,
+        title: link?.title || 'Untitled',
+        isPublic: link.isPublic,
+        createdAt: link.createdAt,
+        conversationId: link.conversationId,
+      })),
+      nextCursor,
+      hasNextPage,
     };
   } catch (error) {
-    logger.error('[getShareByPage] Error getting shares', error);
-    throw new Error('Error getting shares');
-  }
-}
-
-/**
- * Creates a new shared link
- * @param {string} user - The user ID
- * @param {object} shareData - The share data
- * @param {string} shareData.conversationId - The conversation ID
- * @returns {Promise<object>} The created shared link
- */
-async function createSharedLink(user, { conversationId, ...shareData }) {
-  try {
-    const share = await SharedLink.findOne({ conversationId }).select('-_id -__v -user').lean();
-    if (share) {
-      const newConvoId = anonymizeConvoId();
-      const sharedConvo = anonymizeConvo(share);
-      return Object.assign(sharedConvo, {
-        conversationId: newConvoId,
-        messages: anonymizeMessages(share.messages, newConvoId),
-      });
-    }
-
-    const shareId = nanoid();
-    const messages = await getMessages({ conversationId });
-    const update = { ...shareData, shareId, messages, user };
-    const newShare = await SharedLink.findOneAndUpdate({ conversationId, user }, update, {
-      new: true,
-      upsert: true,
-    }).lean();
-
-    const newConvoId = anonymizeConvoId();
-    const sharedConvo = anonymizeConvo(newShare);
-    return Object.assign(sharedConvo, {
-      conversationId: newConvoId,
-      messages: anonymizeMessages(newShare.messages, newConvoId),
+    logger.error('[getSharedLinks] Error getting shares', {
+      error: error.message,
+      user,
     });
-  } catch (error) {
-    logger.error('[createSharedLink] Error creating shared link', error);
-    throw new Error('Error creating shared link');
+    throw new ShareServiceError('Error getting shares', 'SHARES_FETCH_ERROR');
   }
 }
 
-/**
- * Updates an existing shared link
- * @param {string} user - The user ID
- * @param {object} shareData - The share data to update
- * @param {string} shareData.conversationId - The conversation ID
- * @returns {Promise<object>} The updated shared link
- */
-async function updateSharedLink(user, { conversationId, ...shareData }) {
-  try {
-    const share = await SharedLink.findOne({ conversationId }).select('-_id -__v -user').lean();
-    if (!share) {
-      return { message: 'Share not found' };
-    }
-
-    const messages = await getMessages({ conversationId });
-    const update = { ...shareData, messages, user };
-    const updatedShare = await SharedLink.findOneAndUpdate({ conversationId, user }, update, {
-      new: true,
-      upsert: false,
-    }).lean();
-
-    const newConvoId = anonymizeConvoId();
-    const sharedConvo = anonymizeConvo(updatedShare);
-    return Object.assign(sharedConvo, {
-      conversationId: newConvoId,
-      messages: anonymizeMessages(updatedShare.messages, newConvoId),
-    });
-  } catch (error) {
-    logger.error('[updateSharedLink] Error updating shared link', error);
-    throw new Error('Error updating shared link');
-  }
-}
-
-/**
- * Deletes a shared link
- * @param {string} user - The user ID
- * @param {object} params - The deletion parameters
- * @param {string} params.shareId - The share ID to delete
- * @returns {Promise<object>} The result of the deletion
- */
-async function deleteSharedLink(user, { shareId }) {
-  try {
-    const result = await SharedLink.findOneAndDelete({ shareId, user });
-    return result ? { message: 'Share deleted successfully' } : { message: 'Share not found' };
-  } catch (error) {
-    logger.error('[deleteSharedLink] Error deleting shared link', error);
-    throw new Error('Error deleting shared link');
-  }
-}
-
-/**
- * Deletes all shared links for a specific user
- * @param {string} user - The user ID
- * @returns {Promise<object>} The result of the deletion
- */
 async function deleteAllSharedLinks(user) {
   try {
     const result = await SharedLink.deleteMany({ user });
     return {
-      message: 'All shared links have been deleted successfully',
+      message: 'All shared links deleted successfully',
       deletedCount: result.deletedCount,
     };
   } catch (error) {
-    logger.error('[deleteAllSharedLinks] Error deleting shared links', error);
-    throw new Error('Error deleting shared links');
+    logger.error('[deleteAllSharedLinks] Error deleting shared links', {
+      error: error.message,
+      user,
+    });
+    throw new ShareServiceError('Error deleting shared links', 'BULK_DELETE_ERROR');
+  }
+}
+
+async function createSharedLink(user, conversationId) {
+  if (!user || !conversationId) {
+    throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+  }
+
+  try {
+    const [existingShare, conversationMessages] = await Promise.all([
+      SharedLink.findOne({ conversationId, isPublic: true }).select('-_id -__v -user').lean(),
+      getMessages({ conversationId }),
+    ]);
+
+    if (existingShare && existingShare.isPublic) {
+      throw new ShareServiceError('Share already exists', 'SHARE_EXISTS');
+    } else if (existingShare) {
+      await SharedLink.deleteOne({ conversationId });
+    }
+
+    const conversation = await Conversation.findOne({ conversationId }).lean();
+    const title = conversation?.title || 'Untitled';
+
+    const shareId = nanoid();
+    await SharedLink.create({
+      shareId,
+      conversationId,
+      messages: conversationMessages,
+      title,
+      user,
+    });
+
+    return { shareId, conversationId };
+  } catch (error) {
+    logger.error('[createSharedLink] Error creating shared link', {
+      error: error.message,
+      user,
+      conversationId,
+    });
+    throw new ShareServiceError('Error creating shared link', 'SHARE_CREATE_ERROR');
+  }
+}
+
+async function getSharedLink(user, conversationId) {
+  if (!user || !conversationId) {
+    throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+  }
+
+  try {
+    const share = await SharedLink.findOne({ conversationId, user, isPublic: true })
+      .select('shareId -_id')
+      .lean();
+
+    if (!share) {
+      return { shareId: null, success: false };
+    }
+
+    return { shareId: share.shareId, success: true };
+  } catch (error) {
+    logger.error('[getSharedLink] Error getting shared link', {
+      error: error.message,
+      user,
+      conversationId,
+    });
+    throw new ShareServiceError('Error getting shared link', 'SHARE_FETCH_ERROR');
+  }
+}
+
+async function updateSharedLink(user, shareId) {
+  if (!user || !shareId) {
+    throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+  }
+
+  try {
+    const share = await SharedLink.findOne({ shareId }).select('-_id -__v -user').lean();
+
+    if (!share) {
+      throw new ShareServiceError('Share not found', 'SHARE_NOT_FOUND');
+    }
+
+    const [updatedMessages] = await Promise.all([
+      getMessages({ conversationId: share.conversationId }),
+    ]);
+
+    const newShareId = nanoid();
+    const update = {
+      messages: updatedMessages,
+      user,
+      shareId: newShareId,
+    };
+
+    const updatedShare = await SharedLink.findOneAndUpdate({ shareId, user }, update, {
+      new: true,
+      upsert: false,
+      runValidators: true,
+    }).lean();
+
+    if (!updatedShare) {
+      throw new ShareServiceError('Share update failed', 'SHARE_UPDATE_ERROR');
+    }
+
+    anonymizeConvo(updatedShare);
+
+    return { shareId: newShareId, conversationId: updatedShare.conversationId };
+  } catch (error) {
+    logger.error('[updateSharedLink] Error updating shared link', {
+      error: error.message,
+      user,
+      shareId,
+    });
+    throw new ShareServiceError(
+      error.code === 'SHARE_UPDATE_ERROR' ? error.message : 'Error updating shared link',
+      error.code || 'SHARE_UPDATE_ERROR',
+    );
+  }
+}
+
+async function deleteSharedLink(user, shareId) {
+  if (!user || !shareId) {
+    throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
+  }
+
+  try {
+    const result = await SharedLink.findOneAndDelete({ shareId, user }).lean();
+
+    if (!result) {
+      return null;
+    }
+
+    return {
+      success: true,
+      shareId,
+      message: 'Share deleted successfully',
+    };
+  } catch (error) {
+    logger.error('[deleteSharedLink] Error deleting shared link', {
+      error: error.message,
+      user,
+      shareId,
+    });
+    throw new ShareServiceError('Error deleting shared link', 'SHARE_DELETE_ERROR');
   }
 }
 
 module.exports = {
   SharedLink,
+  getSharedLink,
   getSharedLinks,
   createSharedLink,
   updateSharedLink,

api/models/Token.js

@@ -1,5 +1,6 @@
-const tokenSchema = require('./schema/tokenSchema');
 const mongoose = require('mongoose');
+const { encryptV2 } = require('~/server/utils/crypto');
+const { tokenSchema } = require('@librechat/data-schemas');
 const { logger } = require('~/config');
 
 /**
@@ -7,6 +8,39 @@ const { logger } = require('~/config');
  * @type {mongoose.Model}
  */
 const Token = mongoose.model('Token', tokenSchema);
+/**
+ * Fixes the indexes for the Token collection from legacy TTL indexes to the new expiresAt index.
+ */
+async function fixIndexes() {
+  try {
+    if (
+      process.env.NODE_ENV === 'CI' ||
+      process.env.NODE_ENV === 'development' ||
+      process.env.NODE_ENV === 'test'
+    ) {
+      return;
+    }
+    const indexes = await Token.collection.indexes();
+    logger.debug('Existing Token Indexes:', JSON.stringify(indexes, null, 2));
+    const unwantedTTLIndexes = indexes.filter(
+      (index) => index.key.createdAt === 1 && index.expireAfterSeconds !== undefined,
+    );
+    if (unwantedTTLIndexes.length === 0) {
+      logger.debug('No unwanted Token indexes found.');
+      return;
+    }
+    for (const index of unwantedTTLIndexes) {
+      logger.debug(`Dropping unwanted Token index: ${index.name}`);
+      await Token.collection.dropIndex(index.name);
+      logger.debug(`Dropped Token index: ${index.name}`);
+    }
+    logger.debug('Token index cleanup completed successfully.');
+  } catch (error) {
+    logger.error('An error occurred while fixing Token indexes:', error);
+  }
+}
+
+fixIndexes();
 
 /**
  * Creates a new Token instance.
@@ -29,8 +63,7 @@ async function createToken(tokenData) {
       expiresAt,
     };
 
-    const newToken = new Token(newTokenData);
-    return await newToken.save();
+    return await Token.create(newTokenData);
   } catch (error) {
     logger.debug('An error occurred while creating token:', error);
     throw error;
@@ -42,7 +75,8 @@ async function createToken(tokenData) {
  * @param {Object} query - The query to match against.
  * @param {mongoose.Types.ObjectId|String} query.userId - The ID of the user.
  * @param {String} query.token - The token value.
- * @param {String} query.email - The email of the user.
+ * @param {String} [query.email] - The email of the user.
+ * @param {String} [query.identifier] - Unique, alternative identifier for the token.
  * @returns {Promise<Object|null>} The matched Token document, or null if not found.
  * @throws Will throw an error if the find operation fails.
  */
@@ -59,6 +93,9 @@ async function findToken(query) {
     if (query.email) {
       conditions.push({ email: query.email });
     }
+    if (query.identifier) {
+      conditions.push({ identifier: query.identifier });
+    }
 
     const token = await Token.findOne({
       $and: conditions,
@@ -76,6 +113,8 @@ async function findToken(query) {
  * @param {Object} query - The query to match against.
  * @param {mongoose.Types.ObjectId|String} query.userId - The ID of the user.
  * @param {String} query.token - The token value.
+ * @param {String} [query.email] - The email of the user.
+ * @param {String} [query.identifier] - Unique, alternative identifier for the token.
  * @param {Object} updateData - The data to update the Token with.
  * @returns {Promise<mongoose.Document|null>} The updated Token document, or null if not found.
  * @throws Will throw an error if the update operation fails.
@@ -94,14 +133,20 @@ async function updateToken(query, updateData) {
  * @param {Object} query - The query to match against.
  * @param {mongoose.Types.ObjectId|String} query.userId - The ID of the user.
  * @param {String} query.token - The token value.
- * @param {String} query.email - The email of the user.
+ * @param {String} [query.email] - The email of the user.
+ * @param {String} [query.identifier] - Unique, alternative identifier for the token.
  * @returns {Promise<Object>} The result of the delete operation.
  * @throws Will throw an error if the delete operation fails.
  */
 async function deleteTokens(query) {
   try {
     return await Token.deleteMany({
-      $or: [{ userId: query.userId }, { token: query.token }, { email: query.email }],
+      $or: [
+        { userId: query.userId },
+        { token: query.token },
+        { email: query.email },
+        { identifier: query.identifier },
+      ],
     });
   } catch (error) {
     logger.debug('An error occurred while deleting tokens:', error);
@@ -109,9 +154,46 @@ async function deleteTokens(query) {
   }
 }
 
+/**
+ * Handles the OAuth token by creating or updating the token.
+ * @param {object} fields
+ * @param {string} fields.userId - The user's ID.
+ * @param {string} fields.token - The full token to store.
+ * @param {string} fields.identifier - Unique, alternative identifier for the token.
+ * @param {number} fields.expiresIn - The number of seconds until the token expires.
+ * @param {object} fields.metadata - Additional metadata to store with the token.
+ * @param {string} [fields.type="oauth"] - The type of token. Default is 'oauth'.
+ */
+async function handleOAuthToken({
+  token,
+  userId,
+  identifier,
+  expiresIn,
+  metadata,
+  type = 'oauth',
+}) {
+  const encrypedToken = await encryptV2(token);
+  const tokenData = {
+    type,
+    userId,
+    metadata,
+    identifier,
+    token: encrypedToken,
+    expiresIn: parseInt(expiresIn, 10) || 3600,
+  };
+
+  const existingToken = await findToken({ userId, identifier });
+  if (existingToken) {
+    return await updateToken({ identifier }, tokenData);
+  } else {
+    return await createToken(tokenData);
+  }
+}
+
 module.exports = {
-  createToken,
   findToken,
+  createToken,
   updateToken,
   deleteTokens,
+  handleOAuthToken,
 };

api/models/ToolCall.js

@@ -1,9 +1,11 @@
-const ToolCall = require('./schema/toolCallSchema');
+const mongoose = require('mongoose');
+const { toolCallSchema } = require('@librechat/data-schemas');
+const ToolCall = mongoose.model('ToolCall', toolCallSchema);
 
 /**
  * Create a new tool call
- * @param {ToolCallData} toolCallData - The tool call data
- * @returns {Promise<ToolCallData>} The created tool call document
+ * @param {IToolCallData} toolCallData - The tool call data
+ * @returns {Promise<IToolCallData>} The created tool call document
  */
 async function createToolCall(toolCallData) {
   try {
@@ -16,7 +18,7 @@ async function createToolCall(toolCallData) {
 /**
  * Get a tool call by ID
  * @param {string} id - The tool call document ID
- * @returns {Promise<ToolCallData|null>} The tool call document or null if not found
+ * @returns {Promise<IToolCallData|null>} The tool call document or null if not found
  */
 async function getToolCallById(id) {
   try {
@@ -44,7 +46,7 @@ async function getToolCallsByMessage(messageId, userId) {
  * Get tool calls by conversation ID and user
  * @param {string} conversationId - The conversation ID
  * @param {string} userId - The user's ObjectId
- * @returns {Promise<ToolCallData[]>} Array of tool call documents
+ * @returns {Promise<IToolCallData[]>} Array of tool call documents
  */
 async function getToolCallsByConvo(conversationId, userId) {
   try {
@@ -57,8 +59,8 @@ async function getToolCallsByConvo(conversationId, userId) {
 /**
  * Update a tool call
  * @param {string} id - The tool call document ID
- * @param {Partial<ToolCallData>} updateData - The data to update
- * @returns {Promise<ToolCallData|null>} The updated tool call document or null if not found
+ * @param {Partial<IToolCallData>} updateData - The data to update
+ * @returns {Promise<IToolCallData|null>} The updated tool call document or null if not found
  */
 async function updateToolCall(id, updateData) {
   try {

api/models/Transaction.js

@@ -1,11 +1,144 @@
 const mongoose = require('mongoose');
-const { isEnabled } = require('~/server/utils/handleText');
-const transactionSchema = require('./schema/transaction');
+const { transactionSchema } = require('@librechat/data-schemas');
+const { getBalanceConfig } = require('~/server/services/Config');
 const { getMultiplier, getCacheMultiplier } = require('./tx');
 const { logger } = require('~/config');
 const Balance = require('./Balance');
+
 const cancelRate = 1.15;
 
+/**
+ * Updates a user's token balance based on a transaction using optimistic concurrency control
+ * without schema changes. Compatible with DocumentDB.
+ * @async
+ * @function
+ * @param {Object} params - The function parameters.
+ * @param {string|mongoose.Types.ObjectId} params.user - The user ID.
+ * @param {number} params.incrementValue - The value to increment the balance by (can be negative).
+ * @param {import('mongoose').UpdateQuery<import('@librechat/data-schemas').IBalance>['$set']} [params.setValues] - Optional additional fields to set.
+ * @returns {Promise<Object>} Returns the updated balance document (lean).
+ * @throws {Error} Throws an error if the update fails after multiple retries.
+ */
+const updateBalance = async ({ user, incrementValue, setValues }) => {
+  let maxRetries = 10; // Number of times to retry on conflict
+  let delay = 50; // Initial retry delay in ms
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    let currentBalanceDoc;
+    try {
+      // 1. Read the current document state
+      currentBalanceDoc = await Balance.findOne({ user }).lean();
+      const currentCredits = currentBalanceDoc ? currentBalanceDoc.tokenCredits : 0;
+
+      // 2. Calculate the desired new state
+      const potentialNewCredits = currentCredits + incrementValue;
+      const newCredits = Math.max(0, potentialNewCredits); // Ensure balance doesn't go below zero
+
+      // 3. Prepare the update payload
+      const updatePayload = {
+        $set: {
+          tokenCredits: newCredits,
+          ...(setValues || {}), // Merge other values to set
+        },
+      };
+
+      // 4. Attempt the conditional update or upsert
+      let updatedBalance = null;
+      if (currentBalanceDoc) {
+        // --- Document Exists: Perform Conditional Update ---
+        // Try to update only if the tokenCredits match the value we read (currentCredits)
+        updatedBalance = await Balance.findOneAndUpdate(
+          {
+            user: user,
+            tokenCredits: currentCredits, // Optimistic lock: condition based on the read value
+          },
+          updatePayload,
+          {
+            new: true, // Return the modified document
+            // lean: true, // .lean() is applied after query execution in Mongoose >= 6
+          },
+        ).lean(); // Use lean() for plain JS object
+
+        if (updatedBalance) {
+          // Success! The update was applied based on the expected current state.
+          return updatedBalance;
+        }
+        // If updatedBalance is null, it means tokenCredits changed between read and write (conflict).
+        lastError = new Error(`Concurrency conflict for user ${user} on attempt ${attempt}.`);
+        // Proceed to retry logic below.
+      } else {
+        // --- Document Does Not Exist: Perform Conditional Upsert ---
+        // Try to insert the document, but only if it still doesn't exist.
+        // Using tokenCredits: {$exists: false} helps prevent race conditions where
+        // another process creates the doc between our findOne and findOneAndUpdate.
+        try {
+          updatedBalance = await Balance.findOneAndUpdate(
+            {
+              user: user,
+              // Attempt to match only if the document doesn't exist OR was just created
+              // without tokenCredits (less likely but possible). A simple { user } filter
+              // might also work, relying on the retry for conflicts.
+              // Let's use a simpler filter and rely on retry for races.
+              // tokenCredits: { $exists: false } // This condition might be too strict if doc exists with 0 credits
+            },
+            updatePayload,
+            {
+              upsert: true, // Create if doesn't exist
+              new: true, // Return the created/updated document
+              // setDefaultsOnInsert: true, // Ensure schema defaults are applied on insert
+              // lean: true,
+            },
+          ).lean();
+
+          if (updatedBalance) {
+            // Upsert succeeded (likely created the document)
+            return updatedBalance;
+          }
+          // If null, potentially a rare race condition during upsert. Retry should handle it.
+          lastError = new Error(
+            `Upsert race condition suspected for user ${user} on attempt ${attempt}.`,
+          );
+        } catch (error) {
+          if (error.code === 11000) {
+            // E11000 duplicate key error on index
+            // This means another process created the document *just* before our upsert.
+            // It's a concurrency conflict during creation. We should retry.
+            lastError = error; // Store the error
+            // Proceed to retry logic below.
+          } else {
+            // Different error, rethrow
+            throw error;
+          }
+        }
+      } // End if/else (document exists?)
+    } catch (error) {
+      // Catch errors from findOne or unexpected findOneAndUpdate errors
+      logger.error(`[updateBalance] Error during attempt ${attempt} for user ${user}:`, error);
+      lastError = error; // Store the error
+      // Consider stopping retries for non-transient errors, but for now, we retry.
+    }
+
+    // If we reached here, it means the update failed (conflict or error), wait and retry
+    if (attempt < maxRetries) {
+      const jitter = Math.random() * delay * 0.5; // Add jitter to delay
+      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+      delay = Math.min(delay * 2, 2000); // Exponential backoff with cap
+    }
+  } // End for loop (retries)
+
+  // If loop finishes without success, throw the last encountered error or a generic one
+  logger.error(
+    `[updateBalance] Failed to update balance for user ${user} after ${maxRetries} attempts.`,
+  );
+  throw (
+    lastError ||
+    new Error(
+      `Failed to update balance for user ${user} after maximum retries due to persistent conflicts.`,
+    )
+  );
+};
+
 /** Method to calculate and set the tokenValue for a transaction */
 transactionSchema.methods.calculateTokenValue = function () {
   if (!this.valueKey || !this.tokenType) {
@@ -21,12 +154,48 @@ transactionSchema.methods.calculateTokenValue = function () {
   }
 };
 
+/**
+ * New static method to create an auto-refill transaction that does NOT trigger a balance update.
+ * @param {object} txData - Transaction data.
+ * @param {string} txData.user - The user ID.
+ * @param {string} txData.tokenType - The type of token.
+ * @param {string} txData.context - The context of the transaction.
+ * @param {number} txData.rawAmount - The raw amount of tokens.
+ * @returns {Promise<object>} - The created transaction.
+ */
+transactionSchema.statics.createAutoRefillTransaction = async function (txData) {
+  if (txData.rawAmount != null && isNaN(txData.rawAmount)) {
+    return;
+  }
+  const transaction = new this(txData);
+  transaction.endpointTokenConfig = txData.endpointTokenConfig;
+  transaction.calculateTokenValue();
+  await transaction.save();
+
+  const balanceResponse = await updateBalance({
+    user: transaction.user,
+    incrementValue: txData.rawAmount,
+    setValues: { lastRefill: new Date() },
+  });
+  const result = {
+    rate: transaction.rate,
+    user: transaction.user.toString(),
+    balance: balanceResponse.tokenCredits,
+  };
+  logger.debug('[Balance.check] Auto-refill performed', result);
+  result.transaction = transaction;
+  return result;
+};
+
 /**
  * Static method to create a transaction and update the balance
  * @param {txData} txData - Transaction data.
  */
 transactionSchema.statics.create = async function (txData) {
   const Transaction = this;
+  if (txData.rawAmount != null && isNaN(txData.rawAmount)) {
+    return;
+  }
 
   const transaction = new Transaction(txData);
   transaction.endpointTokenConfig = txData.endpointTokenConfig;
@@ -34,27 +203,22 @@ transactionSchema.statics.create = async function (txData) {
 
   await transaction.save();
 
-  if (!isEnabled(process.env.CHECK_BALANCE)) {
+  const balance = await getBalanceConfig();
+  if (!balance?.enabled) {
     return;
   }
 
-  let balance = await Balance.findOne({ user: transaction.user }).lean();
   let incrementValue = transaction.tokenValue;
 
-  if (balance && balance?.tokenCredits + incrementValue < 0) {
-    incrementValue = -balance.tokenCredits;
-  }
-
-  balance = await Balance.findOneAndUpdate(
-    { user: transaction.user },
-    { $inc: { tokenCredits: incrementValue } },
-    { upsert: true, new: true },
-  ).lean();
+  const balanceResponse = await updateBalance({
+    user: transaction.user,
+    incrementValue,
+  });
 
   return {
     rate: transaction.rate,
     user: transaction.user.toString(),
-    balance: balance.tokenCredits,
+    balance: balanceResponse.tokenCredits,
     [transaction.tokenType]: incrementValue,
   };
 };
@@ -75,27 +239,22 @@ transactionSchema.statics.createStructured = async function (txData) {
 
   await transaction.save();
 
-  if (!isEnabled(process.env.CHECK_BALANCE)) {
+  const balance = await getBalanceConfig();
+  if (!balance?.enabled) {
     return;
   }
 
-  let balance = await Balance.findOne({ user: transaction.user }).lean();
   let incrementValue = transaction.tokenValue;
 
-  if (balance && balance?.tokenCredits + incrementValue < 0) {
-    incrementValue = -balance.tokenCredits;
-  }
-
-  balance = await Balance.findOneAndUpdate(
-    { user: transaction.user },
-    { $inc: { tokenCredits: incrementValue } },
-    { upsert: true, new: true },
-  ).lean();
+  const balanceResponse = await updateBalance({
+    user: transaction.user,
+    incrementValue,
+  });
 
   return {
     rate: transaction.rate,
     user: transaction.user.toString(),
-    balance: balance.tokenCredits,
+    balance: balanceResponse.tokenCredits,
     [transaction.tokenType]: incrementValue,
   };
 };

api/models/Transaction.spec.js

@@ -1,8 +1,13 @@
 const mongoose = require('mongoose');
 const { MongoMemoryServer } = require('mongodb-memory-server');
-const Balance = require('./Balance');
 const { spendTokens, spendStructuredTokens } = require('./spendTokens');
+const { getBalanceConfig } = require('~/server/services/Config');
 const { getMultiplier, getCacheMultiplier } = require('./tx');
+const { Transaction } = require('./Transaction');
+const Balance = require('./Balance');
+
+// Mock the custom config module so we can control the balance flag.
+jest.mock('~/server/services/Config');
 
 let mongoServer;
 
@@ -19,6 +24,8 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await mongoose.connection.dropDatabase();
+  // Default: enable balance updates in tests.
+  getBalanceConfig.mockResolvedValue({ enabled: true });
 });
 
 describe('Regular Token Spending Tests', () => {
@@ -43,34 +50,22 @@ describe('Regular Token Spending Tests', () => {
     };
 
     // Act
-    process.env.CHECK_BALANCE = 'true';
     await spendTokens(txData, tokenUsage);
 
     // Assert
-    console.log('Initial Balance:', initialBalance);
-
     const updatedBalance = await Balance.findOne({ user: userId });
-    console.log('Updated Balance:', updatedBalance.tokenCredits);
-
     const promptMultiplier = getMultiplier({ model, tokenType: 'prompt' });
     const completionMultiplier = getMultiplier({ model, tokenType: 'completion' });
-
-    const expectedPromptCost = tokenUsage.promptTokens * promptMultiplier;
-    const expectedCompletionCost = tokenUsage.completionTokens * completionMultiplier;
-    const expectedTotalCost = expectedPromptCost + expectedCompletionCost;
+    const expectedTotalCost = 100 * promptMultiplier + 50 * completionMultiplier;
     const expectedBalance = initialBalance - expectedTotalCost;
 
-    expect(updatedBalance.tokenCredits).toBeLessThan(initialBalance);
     expect(updatedBalance.tokenCredits).toBeCloseTo(expectedBalance, 0);
-
-    console.log('Expected Total Cost:', expectedTotalCost);
-    console.log('Actual Balance Decrease:', initialBalance - updatedBalance.tokenCredits);
   });
 
   test('spendTokens should handle zero completion tokens', async () => {
     // Arrange
     const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000; // $10.00
+    const initialBalance = 10000000;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
 
     const model = 'gpt-3.5-turbo';
@@ -88,24 +83,19 @@ describe('Regular Token Spending Tests', () => {
     };
 
     // Act
-    process.env.CHECK_BALANCE = 'true';
     await spendTokens(txData, tokenUsage);
 
     // Assert
     const updatedBalance = await Balance.findOne({ user: userId });
-
     const promptMultiplier = getMultiplier({ model, tokenType: 'prompt' });
-    const expectedCost = tokenUsage.promptTokens * promptMultiplier;
+    const expectedCost = 100 * promptMultiplier;
     expect(updatedBalance.tokenCredits).toBeCloseTo(initialBalance - expectedCost, 0);
-
-    console.log('Initial Balance:', initialBalance);
-    console.log('Updated Balance:', updatedBalance.tokenCredits);
-    console.log('Expected Cost:', expectedCost);
   });
 
   test('spendTokens should handle undefined token counts', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000; // $10.00
+    const initialBalance = 10000000;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
 
     const model = 'gpt-3.5-turbo';
@@ -119,14 +109,17 @@ describe('Regular Token Spending Tests', () => {
 
     const tokenUsage = {};
 
+    // Act
     const result = await spendTokens(txData, tokenUsage);
 
+    // Assert: No transaction should be created
     expect(result).toBeUndefined();
   });
 
   test('spendTokens should handle only prompt tokens', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
-    const initialBalance = 10000000; // $10.00
+    const initialBalance = 10000000;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
 
     const model = 'gpt-3.5-turbo';
@@ -140,14 +133,44 @@ describe('Regular Token Spending Tests', () => {
 
     const tokenUsage = { promptTokens: 100 };
 
+    // Act
     await spendTokens(txData, tokenUsage);
 
+    // Assert
     const updatedBalance = await Balance.findOne({ user: userId });
-
     const promptMultiplier = getMultiplier({ model, tokenType: 'prompt' });
     const expectedCost = 100 * promptMultiplier;
     expect(updatedBalance.tokenCredits).toBeCloseTo(initialBalance - expectedCost, 0);
   });
+
+  test('spendTokens should not update balance when balance feature is disabled', async () => {
+    // Arrange: Override the config to disable balance updates.
+    getBalanceConfig.mockResolvedValue({ balance: { enabled: false } });
+    const userId = new mongoose.Types.ObjectId();
+    const initialBalance = 10000000;
+    await Balance.create({ user: userId, tokenCredits: initialBalance });
+
+    const model = 'gpt-3.5-turbo';
+    const txData = {
+      user: userId,
+      conversationId: 'test-conversation-id',
+      model,
+      context: 'test',
+      endpointTokenConfig: null,
+    };
+
+    const tokenUsage = {
+      promptTokens: 100,
+      completionTokens: 50,
+    };
+
+    // Act
+    await spendTokens(txData, tokenUsage);
+
+    // Assert: Balance should remain unchanged.
+    const updatedBalance = await Balance.findOne({ user: userId });
+    expect(updatedBalance.tokenCredits).toBe(initialBalance);
+  });
 });
 
 describe('Structured Token Spending Tests', () => {
@@ -163,7 +186,7 @@ describe('Structured Token Spending Tests', () => {
       conversationId: 'c23a18da-706c-470a-ac28-ec87ed065199',
       model,
       context: 'message',
-      endpointTokenConfig: null, // We'll use the default rates
+      endpointTokenConfig: null,
     };
 
     const tokenUsage = {
@@ -175,28 +198,15 @@ describe('Structured Token Spending Tests', () => {
       completionTokens: 5,
     };
 
-    // Get the actual multipliers
     const promptMultiplier = getMultiplier({ model, tokenType: 'prompt' });
     const completionMultiplier = getMultiplier({ model, tokenType: 'completion' });
     const writeMultiplier = getCacheMultiplier({ model, cacheType: 'write' });
     const readMultiplier = getCacheMultiplier({ model, cacheType: 'read' });
 
-    console.log('Multipliers:', {
-      promptMultiplier,
-      completionMultiplier,
-      writeMultiplier,
-      readMultiplier,
-    });
-
     // Act
-    process.env.CHECK_BALANCE = 'true';
     const result = await spendStructuredTokens(txData, tokenUsage);
 
-    // Assert
-    console.log('Initial Balance:', initialBalance);
-    console.log('Updated Balance:', result.completion.balance);
-    console.log('Transaction Result:', result);
-
+    // Calculate expected costs.
     const expectedPromptCost =
       tokenUsage.promptTokens.input * promptMultiplier +
       tokenUsage.promptTokens.write * writeMultiplier +
@@ -205,37 +215,21 @@ describe('Structured Token Spending Tests', () => {
     const expectedTotalCost = expectedPromptCost + expectedCompletionCost;
     const expectedBalance = initialBalance - expectedTotalCost;
 
-    console.log('Expected Cost:', expectedTotalCost);
-    console.log('Expected Balance:', expectedBalance);
-
+    // Assert
     expect(result.completion.balance).toBeLessThan(initialBalance);
-
-    // Allow for a small difference (e.g., 100 token credits, which is $0.0001)
     const allowedDifference = 100;
     expect(Math.abs(result.completion.balance - expectedBalance)).toBeLessThan(allowedDifference);
-
-    // Check if the decrease is approximately as expected
     const balanceDecrease = initialBalance - result.completion.balance;
     expect(balanceDecrease).toBeCloseTo(expectedTotalCost, 0);
 
-    // Check token values
-    const expectedPromptTokenValue = -(
-      tokenUsage.promptTokens.input * promptMultiplier +
-      tokenUsage.promptTokens.write * writeMultiplier +
-      tokenUsage.promptTokens.read * readMultiplier
-    );
-    const expectedCompletionTokenValue = -tokenUsage.completionTokens * completionMultiplier;
-
+    const expectedPromptTokenValue = -expectedPromptCost;
+    const expectedCompletionTokenValue = -expectedCompletionCost;
     expect(result.prompt.prompt).toBeCloseTo(expectedPromptTokenValue, 1);
     expect(result.completion.completion).toBe(expectedCompletionTokenValue);
-
-    console.log('Expected prompt tokenValue:', expectedPromptTokenValue);
-    console.log('Actual prompt tokenValue:', result.prompt.prompt);
-    console.log('Expected completion tokenValue:', expectedCompletionTokenValue);
-    console.log('Actual completion tokenValue:', result.completion.completion);
   });
 
   test('should handle zero completion tokens in structured spending', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
     const initialBalance = 17613154.55;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
@@ -257,15 +251,17 @@ describe('Structured Token Spending Tests', () => {
       completionTokens: 0,
     };
 
-    process.env.CHECK_BALANCE = 'true';
+    // Act
     const result = await spendStructuredTokens(txData, tokenUsage);
 
+    // Assert
     expect(result.prompt).toBeDefined();
     expect(result.completion).toBeUndefined();
     expect(result.prompt.prompt).toBeLessThan(0);
   });
 
   test('should handle only prompt tokens in structured spending', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
     const initialBalance = 17613154.55;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
@@ -286,15 +282,17 @@ describe('Structured Token Spending Tests', () => {
       },
     };
 
-    process.env.CHECK_BALANCE = 'true';
+    // Act
     const result = await spendStructuredTokens(txData, tokenUsage);
 
+    // Assert
     expect(result.prompt).toBeDefined();
     expect(result.completion).toBeUndefined();
     expect(result.prompt.prompt).toBeLessThan(0);
   });
 
   test('should handle undefined token counts in structured spending', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
     const initialBalance = 17613154.55;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
@@ -309,9 +307,10 @@ describe('Structured Token Spending Tests', () => {
 
     const tokenUsage = {};
 
-    process.env.CHECK_BALANCE = 'true';
+    // Act
     const result = await spendStructuredTokens(txData, tokenUsage);
 
+    // Assert
     expect(result).toEqual({
       prompt: undefined,
       completion: undefined,
@@ -319,6 +318,7 @@ describe('Structured Token Spending Tests', () => {
   });
 
   test('should handle incomplete context for completion tokens', async () => {
+    // Arrange
     const userId = new mongoose.Types.ObjectId();
     const initialBalance = 17613154.55;
     await Balance.create({ user: userId, tokenCredits: initialBalance });
@@ -340,9 +340,39 @@ describe('Structured Token Spending Tests', () => {
       completionTokens: 50,
     };
 
-    process.env.CHECK_BALANCE = 'true';
+    // Act
     const result = await spendStructuredTokens(txData, tokenUsage);
 
-    expect(result.completion.completion).toBeCloseTo(-50 * 15 * 1.15, 0); // Assuming multiplier is 15 and cancelRate is 1.15
+    // Assert:
+    // (Assuming a multiplier for completion of 15 and a cancel rate of 1.15 as noted in the original test.)
+    expect(result.completion.completion).toBeCloseTo(-50 * 15 * 1.15, 0);
+  });
+});
+
+describe('NaN Handling Tests', () => {
+  test('should skip transaction creation when rawAmount is NaN', async () => {
+    // Arrange
+    const userId = new mongoose.Types.ObjectId();
+    const initialBalance = 10000000;
+    await Balance.create({ user: userId, tokenCredits: initialBalance });
+
+    const model = 'gpt-3.5-turbo';
+    const txData = {
+      user: userId,
+      conversationId: 'test-conversation-id',
+      model,
+      context: 'test',
+      endpointTokenConfig: null,
+      rawAmount: NaN,
+      tokenType: 'prompt',
+    };
+
+    // Act
+    const result = await Transaction.create(txData);
+
+    // Assert: No transaction should be created and balance remains unchanged.
+    expect(result).toBeUndefined();
+    const balance = await Balance.findOne({ user: userId });
+    expect(balance.tokenCredits).toBe(initialBalance);
   });
 });

api/models/User.js

@@ -1,5 +1,5 @@
 const mongoose = require('mongoose');
-const userSchema = require('~/models/schema/userSchema');
+const { userSchema } = require('@librechat/data-schemas');
 
 const User = mongoose.model('User', userSchema);
 

api/models/balanceMethods.js

@@ -0,0 +1,156 @@
+const { ViolationTypes } = require('librechat-data-provider');
+const { Transaction } = require('./Transaction');
+const { logViolation } = require('~/cache');
+const { getMultiplier } = require('./tx');
+const { logger } = require('~/config');
+const Balance = require('./Balance');
+
+function isInvalidDate(date) {
+  return isNaN(date);
+}
+
+/**
+ * Simple check method that calculates token cost and returns balance info.
+ * The auto-refill logic has been moved to balanceMethods.js to prevent circular dependencies.
+ */
+const checkBalanceRecord = async function ({
+  user,
+  model,
+  endpoint,
+  valueKey,
+  tokenType,
+  amount,
+  endpointTokenConfig,
+}) {
+  const multiplier = getMultiplier({ valueKey, tokenType, model, endpoint, endpointTokenConfig });
+  const tokenCost = amount * multiplier;
+
+  // Retrieve the balance record
+  let record = await Balance.findOne({ user }).lean();
+  if (!record) {
+    logger.debug('[Balance.check] No balance record found for user', { user });
+    return {
+      canSpend: false,
+      balance: 0,
+      tokenCost,
+    };
+  }
+  let balance = record.tokenCredits;
+
+  logger.debug('[Balance.check] Initial state', {
+    user,
+    model,
+    endpoint,
+    valueKey,
+    tokenType,
+    amount,
+    balance,
+    multiplier,
+    endpointTokenConfig: !!endpointTokenConfig,
+  });
+
+  // Only perform auto-refill if spending would bring the balance to 0 or below
+  if (balance - tokenCost <= 0 && record.autoRefillEnabled && record.refillAmount > 0) {
+    const lastRefillDate = new Date(record.lastRefill);
+    const now = new Date();
+    if (
+      isInvalidDate(lastRefillDate) ||
+      now >=
+        addIntervalToDate(lastRefillDate, record.refillIntervalValue, record.refillIntervalUnit)
+    ) {
+      try {
+        /** @type {{ rate: number, user: string, balance: number, transaction: import('@librechat/data-schemas').ITransaction}} */
+        const result = await Transaction.createAutoRefillTransaction({
+          user: user,
+          tokenType: 'credits',
+          context: 'autoRefill',
+          rawAmount: record.refillAmount,
+        });
+        balance = result.balance;
+      } catch (error) {
+        logger.error('[Balance.check] Failed to record transaction for auto-refill', error);
+      }
+    }
+  }
+
+  logger.debug('[Balance.check] Token cost', { tokenCost });
+  return { canSpend: balance >= tokenCost, balance, tokenCost };
+};
+
+/**
+ * Adds a time interval to a given date.
+ * @param {Date} date - The starting date.
+ * @param {number} value - The numeric value of the interval.
+ * @param {'seconds'|'minutes'|'hours'|'days'|'weeks'|'months'} unit - The unit of time.
+ * @returns {Date} A new Date representing the starting date plus the interval.
+ */
+const addIntervalToDate = (date, value, unit) => {
+  const result = new Date(date);
+  switch (unit) {
+    case 'seconds':
+      result.setSeconds(result.getSeconds() + value);
+      break;
+    case 'minutes':
+      result.setMinutes(result.getMinutes() + value);
+      break;
+    case 'hours':
+      result.setHours(result.getHours() + value);
+      break;
+    case 'days':
+      result.setDate(result.getDate() + value);
+      break;
+    case 'weeks':
+      result.setDate(result.getDate() + value * 7);
+      break;
+    case 'months':
+      result.setMonth(result.getMonth() + value);
+      break;
+    default:
+      break;
+  }
+  return result;
+};
+
+/**
+ * Checks the balance for a user and determines if they can spend a certain amount.
+ * If the user cannot spend the amount, it logs a violation and denies the request.
+ *
+ * @async
+ * @function
+ * @param {Object} params - The function parameters.
+ * @param {Express.Request} params.req - The Express request object.
+ * @param {Express.Response} params.res - The Express response object.
+ * @param {Object} params.txData - The transaction data.
+ * @param {string} params.txData.user - The user ID or identifier.
+ * @param {('prompt' | 'completion')} params.txData.tokenType - The type of token.
+ * @param {number} params.txData.amount - The amount of tokens.
+ * @param {string} params.txData.model - The model name or identifier.
+ * @param {string} [params.txData.endpointTokenConfig] - The token configuration for the endpoint.
+ * @returns {Promise<boolean>} Throws error if the user cannot spend the amount.
+ * @throws {Error} Throws an error if there's an issue with the balance check.
+ */
+const checkBalance = async ({ req, res, txData }) => {
+  const { canSpend, balance, tokenCost } = await checkBalanceRecord(txData);
+  if (canSpend) {
+    return true;
+  }
+
+  const type = ViolationTypes.TOKEN_BALANCE;
+  const errorMessage = {
+    type,
+    balance,
+    tokenCost,
+    promptTokens: txData.amount,
+  };
+
+  if (txData.generations && txData.generations.length > 0) {
+    errorMessage.generations = txData.generations;
+  }
+
+  await logViolation(req, res, type, errorMessage, 0);
+  throw new Error(JSON.stringify(errorMessage));
+};
+
+module.exports = {
+  checkBalance,
+};

api/models/checkBalance.js

@@ -1,45 +0,0 @@
-const { ViolationTypes } = require('librechat-data-provider');
-const { logViolation } = require('~/cache');
-const Balance = require('./Balance');
-/**
- * Checks the balance for a user and determines if they can spend a certain amount.
- * If the user cannot spend the amount, it logs a violation and denies the request.
- *
- * @async
- * @function
- * @param {Object} params - The function parameters.
- * @param {Express.Request} params.req - The Express request object.
- * @param {Express.Response} params.res - The Express response object.
- * @param {Object} params.txData - The transaction data.
- * @param {string} params.txData.user - The user ID or identifier.
- * @param {('prompt' | 'completion')} params.txData.tokenType - The type of token.
- * @param {number} params.txData.amount - The amount of tokens.
- * @param {string} params.txData.model - The model name or identifier.
- * @param {string} [params.txData.endpointTokenConfig] - The token configuration for the endpoint.
- * @returns {Promise<boolean>} Returns true if the user can spend the amount, otherwise denies the request.
- * @throws {Error} Throws an error if there's an issue with the balance check.
- */
-const checkBalance = async ({ req, res, txData }) => {
-  const { canSpend, balance, tokenCost } = await Balance.check(txData);
-
-  if (canSpend) {
-    return true;
-  }
-
-  const type = ViolationTypes.TOKEN_BALANCE;
-  const errorMessage = {
-    type,
-    balance,
-    tokenCost,
-    promptTokens: txData.amount,
-  };
-
-  if (txData.generations && txData.generations.length > 0) {
-    errorMessage.generations = txData.generations;
-  }
-
-  await logViolation(req, res, type, errorMessage, 0);
-  throw new Error(JSON.stringify(errorMessage));
-};
-
-module.exports = checkBalance;

api/models/index.js

@@ -26,10 +26,18 @@ const {
   deleteMessagesSince,
   deleteMessages,
 } = require('./Message');
+const {
+  createSession,
+  findSession,
+  updateExpiration,
+  deleteSession,
+  deleteAllUserSessions,
+  generateRefreshToken,
+  countActiveSessions,
+} = require('./Session');
 const { getConvoTitle, getConvo, saveConvo, deleteConvos } = require('./Conversation');
 const { getPreset, getPresets, savePreset, deletePresets } = require('./Preset');
 const { createToken, findToken, updateToken, deleteTokens } = require('./Token');
-const Session = require('./Session');
 const Balance = require('./Balance');
 const User = require('./User');
 const Key = require('./Key');
@@ -75,8 +83,15 @@ module.exports = {
   updateToken,
   deleteTokens,
 
+  createSession,
+  findSession,
+  updateExpiration,
+  deleteSession,
+  deleteAllUserSessions,
+  generateRefreshToken,
+  countActiveSessions,
+
   User,
   Key,
-  Session,
   Balance,
 };

api/models/plugins/mongoMeili.js

@@ -1,12 +1,32 @@
 const _ = require('lodash');
 const mongoose = require('mongoose');
 const { MeiliSearch } = require('meilisearch');
+const { parseTextParts, ContentTypes } = require('librechat-data-provider');
 const { cleanUpPrimaryKeyValue } = require('~/lib/utils/misc');
 const logger = require('~/config/meiliLogger');
 
+// Environment flags
+/**
+ * Flag to indicate if search is enabled based on environment variables.
+ * @type {boolean}
+ */
 const searchEnabled = process.env.SEARCH && process.env.SEARCH.toLowerCase() === 'true';
+
+/**
+ * Flag to indicate if MeiliSearch is enabled based on required environment variables.
+ * @type {boolean}
+ */
 const meiliEnabled = process.env.MEILI_HOST && process.env.MEILI_MASTER_KEY && searchEnabled;
 
+/**
+ * Validates the required options for configuring the mongoMeili plugin.
+ *
+ * @param {Object} options - The configuration options.
+ * @param {string} options.host - The MeiliSearch host.
+ * @param {string} options.apiKey - The MeiliSearch API key.
+ * @param {string} options.indexName - The name of the index.
+ * @throws {Error} Throws an error if any required option is missing.
+ */
 const validateOptions = function (options) {
   const requiredKeys = ['host', 'apiKey', 'indexName'];
   requiredKeys.forEach((key) => {
@@ -16,53 +36,64 @@ const validateOptions = function (options) {
   });
 };
 
-// const createMeiliMongooseModel = function ({ index, indexName, client, attributesToIndex }) {
+/**
+ * Factory function to create a MeiliMongooseModel class which extends a Mongoose model.
+ * This class contains static and instance methods to synchronize and manage the MeiliSearch index
+ * corresponding to the MongoDB collection.
+ *
+ * @param {Object} config - Configuration object.
+ * @param {Object} config.index - The MeiliSearch index object.
+ * @param {Array<string>} config.attributesToIndex - List of attributes to index.
+ * @returns {Function} A class definition that will be loaded into the Mongoose schema.
+ */
 const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
+  // The primary key is assumed to be the first attribute in the attributesToIndex array.
   const primaryKey = attributesToIndex[0];
-  // MeiliMongooseModel is of type Mongoose.Model
+
   class MeiliMongooseModel {
     /**
-     * `syncWithMeili`: synchronizes the data between a MongoDB collection and a MeiliSearch index,
-     * only triggered if there's ever a discrepancy determined by `api\lib\db\indexSync.js`.
+     * Synchronizes the data between the MongoDB collection and the MeiliSearch index.
      *
-     * 1. Fetches all documents from the MongoDB collection and the MeiliSearch index.
-     * 2. Compares the documents from both sources.
-     * 3. If a document exists in MeiliSearch but not in MongoDB, it's deleted from MeiliSearch.
-     * 4. If a document exists in MongoDB but not in MeiliSearch, it's added to MeiliSearch.
-     * 5. If a document exists in both but has different `text` or `title` fields (depending on the `primaryKey`), it's updated in MeiliSearch.
-     * 6. After all operations, it updates the `_meiliIndex` field in MongoDB to indicate whether the document is indexed in MeiliSearch.
+     * The synchronization process involves:
+     *   1. Fetching all documents from the MongoDB collection and MeiliSearch index.
+     *   2. Comparing documents from both sources.
+     *   3. Deleting documents from MeiliSearch that no longer exist in MongoDB.
+     *   4. Adding documents to MeiliSearch that exist in MongoDB but not in the index.
+     *   5. Updating documents in MeiliSearch if key fields (such as `text` or `title`) differ.
+     *   6. Updating the `_meiliIndex` field in MongoDB to indicate the indexing status.
      *
-     * Note: This strategy does not use batch operations for Meilisearch as the `index.addDocuments` will discard
-     * the entire batch if there's an error with one document, and will not throw an error if there's an issue.
-     * Also, `index.getDocuments` needs an exact limit on the amount of documents to return, so we build the map in batches.
+     * Note: The function processes documents in batches because MeiliSearch's
+     * `index.getDocuments` requires an exact limit and `index.addDocuments` does not handle
+     * partial failures in a batch.
      *
-     * @returns {Promise} A promise that resolves when the synchronization is complete.
-     *
-     * @throws {Error} Throws an error if there's an issue with adding a document to MeiliSearch.
+     * @returns {Promise<void>} Resolves when the synchronization is complete.
      */
     static async syncWithMeili() {
       try {
         let moreDocuments = true;
+        // Retrieve all MongoDB documents from the collection as plain JavaScript objects.
         const mongoDocuments = await this.find().lean();
-        const format = (doc) => _.pick(doc, attributesToIndex);
 
-        // Prepare for comparison
+        // Helper function to format a document by selecting only the attributes to index
+        // and omitting keys starting with '$'.
+        const format = (doc) =>
+          _.omitBy(_.pick(doc, attributesToIndex), (v, k) => k.startsWith('$'));
+
+        // Build a map of MongoDB documents for quick lookup based on the primary key.
         const mongoMap = new Map(mongoDocuments.map((doc) => [doc[primaryKey], format(doc)]));
         const indexMap = new Map();
         let offset = 0;
         const batchSize = 1000;
 
+        // Fetch documents from the MeiliSearch index in batches.
         while (moreDocuments) {
           const batch = await index.getDocuments({ limit: batchSize, offset });
-
           if (batch.results.length === 0) {
             moreDocuments = false;
           }
-
           for (const doc of batch.results) {
             indexMap.set(doc[primaryKey], format(doc));
           }
-
           offset += batchSize;
         }
 
@@ -70,13 +101,12 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
 
         const updateOps = [];
 
-        // Iterate over Meili index documents
+        // Process documents present in the MeiliSearch index.
         for (const [id, doc] of indexMap) {
           const update = {};
           update[primaryKey] = id;
           if (mongoMap.has(id)) {
-            // Case: Update
-            // If document also exists in MongoDB, would be update case
+            // If document exists in MongoDB, check for discrepancies in key fields.
             if (
               (doc.text && doc.text !== mongoMap.get(id).text) ||
               (doc.title && doc.title !== mongoMap.get(id).title)
@@ -92,8 +122,7 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
               await index.addDocuments([doc]);
             }
           } else {
-            // Case: Delete
-            // If document does not exist in MongoDB, its a delete case from meili index
+            // If the document does not exist in MongoDB, delete it from MeiliSearch.
             await index.deleteDocument(id);
             updateOps.push({
               updateOne: { filter: update, update: { $set: { _meiliIndex: false } } },
@@ -101,24 +130,25 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
           }
         }
 
-        // Iterate over MongoDB documents
+        // Process documents present in MongoDB.
         for (const [id, doc] of mongoMap) {
           const update = {};
           update[primaryKey] = id;
-          // Case: Insert
-          // If document does not exist in Meili Index, Its an insert case
+          // If the document is missing in the Meili index, add it.
           if (!indexMap.has(id)) {
             await index.addDocuments([doc]);
             updateOps.push({
               updateOne: { filter: update, update: { $set: { _meiliIndex: true } } },
             });
           } else if (doc._meiliIndex === false) {
+            // If the document exists but is marked as not indexed, update the flag.
             updateOps.push({
               updateOne: { filter: update, update: { $set: { _meiliIndex: true } } },
             });
           }
         }
 
+        // Execute bulk update operations in MongoDB to update the _meiliIndex flags.
         if (updateOps.length > 0) {
           await this.collection.bulkWrite(updateOps);
           logger.debug(
@@ -132,34 +162,47 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
       }
     }
 
-    // Set one or more settings of the meili index
+    /**
+     * Updates settings for the MeiliSearch index.
+     *
+     * @param {Object} settings - The settings to update on the MeiliSearch index.
+     * @returns {Promise<Object>} Promise resolving to the update result.
+     */
     static async setMeiliIndexSettings(settings) {
       return await index.updateSettings(settings);
     }
 
-    // Search the index
+    /**
+     * Searches the MeiliSearch index and optionally populates the results with data from MongoDB.
+     *
+     * @param {string} q - The search query.
+     * @param {Object} params - Additional search parameters for MeiliSearch.
+     * @param {boolean} populate - Whether to populate search hits with full MongoDB documents.
+     * @returns {Promise<Object>} The search results with populated hits if requested.
+     */
     static async meiliSearch(q, params, populate) {
       const data = await index.search(q, params);
 
-      // Populate hits with content from mongodb
       if (populate) {
-        // Find objects into mongodb matching `objectID` from Meili search
+        // Build a query using the primary key values from the search hits.
         const query = {};
-        // query[primaryKey] = { $in: _.map(data.hits, primaryKey) };
         query[primaryKey] = _.map(data.hits, (hit) => cleanUpPrimaryKeyValue(hit[primaryKey]));
-        // logger.debug('query', query);
-        const hitsFromMongoose = await this.find(
-          query,
-          _.reduce(
-            this.schema.obj,
-            function (results, value, key) {
-              return { ...results, [key]: 1 };
-            },
-            { _id: 1, __v: 1 },
-          ),
-        ).lean();
 
-        // Add additional data from mongodb into Meili search hits
+        // Build a projection object, including only keys that do not start with '$'.
+        const projection = Object.keys(this.schema.obj).reduce(
+          (results, key) => {
+            if (!key.startsWith('$')) {
+              results[key] = 1;
+            }
+            return results;
+          },
+          { _id: 1, __v: 1 },
+        );
+
+        // Retrieve the full documents from MongoDB.
+        const hitsFromMongoose = await this.find(query, projection).lean();
+
+        // Merge the MongoDB documents with the search hits.
         const populatedHits = data.hits.map(function (hit) {
           const query = {};
           query[primaryKey] = hit[primaryKey];
@@ -176,51 +219,80 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
       return data;
     }
 
+    /**
+     * Preprocesses the current document for indexing.
+     *
+     * This method:
+     *  - Picks only the defined attributes to index.
+     *  - Omits any keys starting with '$'.
+     *  - Replaces pipe characters ('|') in `conversationId` with '--'.
+     *  - Extracts and concatenates text from an array of content items.
+     *
+     * @returns {Object} The preprocessed object ready for indexing.
+     */
     preprocessObjectForIndex() {
-      const object = _.pick(this.toJSON(), attributesToIndex);
-      // NOTE: MeiliSearch does not allow | in primary key, so we replace it with - for Bing convoIds
-      // object.conversationId = object.conversationId.replace(/\|/g, '-');
+      const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) =>
+        k.startsWith('$'),
+      );
       if (object.conversationId && object.conversationId.includes('|')) {
         object.conversationId = object.conversationId.replace(/\|/g, '--');
       }
 
       if (object.content && Array.isArray(object.content)) {
-        object.text = object.content
-          .filter((item) => item.type === 'text' && item.text && item.text.value)
-          .map((item) => item.text.value)
-          .join(' ');
+        object.text = parseTextParts(object.content);
         delete object.content;
       }
 
       return object;
     }
 
-    // Push new document to Meili
+    /**
+     * Adds the current document to the MeiliSearch index.
+     *
+     * The method preprocesses the document, adds it to MeiliSearch, and then updates
+     * the MongoDB document's `_meiliIndex` flag to true.
+     *
+     * @returns {Promise<void>}
+     */
     async addObjectToMeili() {
       const object = this.preprocessObjectForIndex();
       try {
-        // logger.debug('Adding document to Meili', object);
         await index.addDocuments([object]);
       } catch (error) {
-        // logger.debug('Error adding document to Meili');
-        // logger.error(error);
+        // Error handling can be enhanced as needed.
+        logger.error('[addObjectToMeili] Error adding document to Meili', error);
       }
 
       await this.collection.updateMany({ _id: this._id }, { $set: { _meiliIndex: true } });
     }
 
-    // Update an existing document in Meili
+    /**
+     * Updates the current document in the MeiliSearch index.
+     *
+     * @returns {Promise<void>}
+     */
     async updateObjectToMeili() {
-      const object = _.pick(this.toJSON(), attributesToIndex);
+      const object = _.omitBy(_.pick(this.toJSON(), attributesToIndex), (v, k) =>
+        k.startsWith('$'),
+      );
       await index.updateDocuments([object]);
     }
 
-    // Delete a document from Meili
+    /**
+     * Deletes the current document from the MeiliSearch index.
+     *
+     * @returns {Promise<void>}
+     */
     async deleteObjectFromMeili() {
       await index.deleteDocument(this._id);
     }
 
-    // * schema.post('save')
+    /**
+     * Post-save hook to synchronize the document with MeiliSearch.
+     *
+     * If the document is already indexed (i.e. `_meiliIndex` is true), it updates it;
+     * otherwise, it adds the document to the index.
+     */
     postSaveHook() {
       if (this._meiliIndex) {
         this.updateObjectToMeili();
@@ -229,14 +301,24 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
       }
     }
 
-    // * schema.post('update')
+    /**
+     * Post-update hook to update the document in MeiliSearch.
+     *
+     * This hook is triggered after a document update, ensuring that changes are
+     * propagated to the MeiliSearch index if the document is indexed.
+     */
     postUpdateHook() {
       if (this._meiliIndex) {
         this.updateObjectToMeili();
       }
     }
 
-    // * schema.post('remove')
+    /**
+     * Post-remove hook to delete the document from MeiliSearch.
+     *
+     * This hook is triggered after a document is removed, ensuring that the document
+     * is also removed from the MeiliSearch index if it was previously indexed.
+     */
     postRemoveHook() {
       if (this._meiliIndex) {
         this.deleteObjectFromMeili();
@@ -247,11 +329,27 @@ const createMeiliMongooseModel = function ({ index, attributesToIndex }) {
   return MeiliMongooseModel;
 };
 
+/**
+ * Mongoose plugin to synchronize MongoDB collections with a MeiliSearch index.
+ *
+ * This plugin:
+ *   - Validates the provided options.
+ *   - Adds a `_meiliIndex` field to the schema to track indexing status.
+ *   - Sets up a MeiliSearch client and creates an index if it doesn't already exist.
+ *   - Loads class methods for syncing, searching, and managing documents in MeiliSearch.
+ *   - Registers Mongoose hooks (post-save, post-update, post-remove, etc.) to maintain index consistency.
+ *
+ * @param {mongoose.Schema} schema - The Mongoose schema to which the plugin is applied.
+ * @param {Object} options - Configuration options.
+ * @param {string} options.host - The MeiliSearch host.
+ * @param {string} options.apiKey - The MeiliSearch API key.
+ * @param {string} options.indexName - The name of the MeiliSearch index.
+ * @param {string} options.primaryKey - The primary key field for indexing.
+ */
 module.exports = function mongoMeili(schema, options) {
-  // Vaidate Options for mongoMeili
   validateOptions(options);
 
-  // Add meiliIndex to schema
+  // Add _meiliIndex field to the schema to track if a document has been indexed in MeiliSearch.
   schema.add({
     _meiliIndex: {
       type: Boolean,
@@ -263,69 +361,77 @@ module.exports = function mongoMeili(schema, options) {
 
   const { host, apiKey, indexName, primaryKey } = options;
 
-  // Setup MeiliSearch Client
+  // Setup the MeiliSearch client.
   const client = new MeiliSearch({ host, apiKey });
 
-  // Asynchronously create the index
+  // Create the index asynchronously if it doesn't exist.
   client.createIndex(indexName, { primaryKey });
 
-  // Setup the index to search for this schema
+  // Setup the MeiliSearch index for this schema.
   const index = client.index(indexName);
 
+  // Collect attributes from the schema that should be indexed.
   const attributesToIndex = [
     ..._.reduce(
       schema.obj,
       function (results, value, key) {
         return value.meiliIndex ? [...results, key] : results;
-        // }, []), '_id'];
       },
       [],
     ),
   ];
 
+  // Load the class methods into the schema.
   schema.loadClass(createMeiliMongooseModel({ index, indexName, client, attributesToIndex }));
 
-  // Register hooks
+  // Register Mongoose hooks to synchronize with MeiliSearch.
+
+  // Post-save: synchronize after a document is saved.
   schema.post('save', function (doc) {
     doc.postSaveHook();
   });
+
+  // Post-update: synchronize after a document is updated.
   schema.post('update', function (doc) {
     doc.postUpdateHook();
   });
+
+  // Post-remove: synchronize after a document is removed.
   schema.post('remove', function (doc) {
     doc.postRemoveHook();
   });
 
+  // Pre-deleteMany hook: remove corresponding documents from MeiliSearch when multiple documents are deleted.
   schema.pre('deleteMany', async function (next) {
     if (!meiliEnabled) {
-      next();
+      return next();
     }
 
     try {
+      // Check if the schema has a "messages" field to determine if it's a conversation schema.
       if (Object.prototype.hasOwnProperty.call(schema.obj, 'messages')) {
         const convoIndex = client.index('convos');
         const deletedConvos = await mongoose.model('Conversation').find(this._conditions).lean();
-        let promises = [];
-        for (const convo of deletedConvos) {
-          promises.push(convoIndex.deleteDocument(convo.conversationId));
-        }
+        const promises = deletedConvos.map((convo) =>
+          convoIndex.deleteDocument(convo.conversationId),
+        );
         await Promise.all(promises);
       }
 
+      // Check if the schema has a "messageId" field to determine if it's a message schema.
       if (Object.prototype.hasOwnProperty.call(schema.obj, 'messageId')) {
         const messageIndex = client.index('messages');
         const deletedMessages = await mongoose.model('Message').find(this._conditions).lean();
-        let promises = [];
-        for (const message of deletedMessages) {
-          promises.push(messageIndex.deleteDocument(message.messageId));
-        }
+        const promises = deletedMessages.map((message) =>
+          messageIndex.deleteDocument(message.messageId),
+        );
         await Promise.all(promises);
       }
       return next();
     } catch (error) {
       if (meiliEnabled) {
         logger.error(
-          '[MeiliMongooseModel.deleteMany] There was an issue deleting conversation indexes upon deletion, next startup may be slow due to syncing',
+          '[MeiliMongooseModel.deleteMany] There was an issue deleting conversation indexes upon deletion. Next startup may be slow due to syncing.',
           error,
         );
       }
@@ -333,17 +439,19 @@ module.exports = function mongoMeili(schema, options) {
     }
   });
 
+  // Post-findOneAndUpdate hook: update MeiliSearch index after a document is updated via findOneAndUpdate.
   schema.post('findOneAndUpdate', async function (doc) {
     if (!meiliEnabled) {
       return;
     }
 
+    // If the document is unfinished, do not update the index.
     if (doc.unfinished) {
       return;
     }
 
     let meiliDoc;
-    // Doc is a Conversation
+    // For conversation documents, try to fetch the document from the "convos" index.
     if (doc.messages) {
       try {
         meiliDoc = await client.index('convos').getDocument(doc.conversationId);
@@ -356,10 +464,12 @@ module.exports = function mongoMeili(schema, options) {
       }
     }
 
+    // If the MeiliSearch document exists and the title is unchanged, do nothing.
     if (meiliDoc && meiliDoc.title === doc.title) {
       return;
     }
 
+    // Otherwise, trigger a post-save hook to synchronize the document.
     doc.postSaveHook();
   });
 };