From 34fd2a802fcd63b4bdf0717734126ad2c91c116a Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 12:38:51 +0000
Subject: [PATCH 01/94] Duplicate OpenID strategy to enable Solid login

---
 api/server/socialLogins.js         |   4 +-
 api/strategies/MyopenidStrategy.js | 589 +++++++++++++++++++++++++++++
 2 files changed, 591 insertions(+), 2 deletions(-)
 create mode 100644 api/strategies/MyopenidStrategy.js

diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index a84c33bd52de..14c9e6f15446 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -7,7 +7,7 @@ const {
   openIdJwtLogin,
   facebookLogin,
   discordLogin,
-  setupOpenId,
+  MysetupOpenId,
   googleLogin,
   githubLogin,
   appleLogin,
@@ -36,7 +36,7 @@ async function configureOpenId(app) {
   app.use(session(sessionOptions));
   app.use(passport.session());
 
-  const config = await setupOpenId();
+  const config = await MysetupOpenId();
   if (!config) {
     logger.error('OpenID Connect configuration failed - strategy not registered.');
     return;
diff --git a/api/strategies/MyopenidStrategy.js b/api/strategies/MyopenidStrategy.js
new file mode 100644
index 000000000000..2ebd1e780a8c
--- /dev/null
+++ b/api/strategies/MyopenidStrategy.js
@@ -0,0 +1,589 @@
+const undici = require('undici');
+const { get } = require('lodash');
+const fetch = require('node-fetch');
+const passport = require('passport');
+const client = require('openid-client');
+const jwtDecode = require('jsonwebtoken/decode');
+const { HttpsProxyAgent } = require('https-proxy-agent');
+const { hashToken, logger } = require('@librechat/data-schemas');
+const { CacheKeys, ErrorTypes } = require('librechat-data-provider');
+const { Strategy: OpenIDStrategy } = require('openid-client/passport');
+const {
+  isEnabled,
+  logHeaders,
+  safeStringify,
+  findOpenIDUser,
+  getBalanceConfig,
+  isEmailDomainAllowed,
+} = require('@librechat/api');
+const { getStrategyFunctions } = require('~/server/services/Files/strategies');
+const { findUser, createUser, updateUser } = require('~/models');
+const { getAppConfig } = require('~/server/services/Config');
+const getLogStores = require('~/cache/getLogStores');
+
+/**
+ * @typedef {import('openid-client').ClientMetadata} ClientMetadata
+ * @typedef {import('openid-client').Configuration} Configuration
+ **/
+
+/**
+ * @param {string} url
+ * @param {client.CustomFetchOptions} options
+ */
+async function customFetch(url, options) {
+  const urlStr = url.toString();
+  logger.debug(`[MyopenidStrategy] Request to: ${urlStr}`);
+  const debugOpenId = isEnabled(process.env.DEBUG_OPENID_REQUESTS);
+  if (debugOpenId) {
+    logger.debug(`[MyopenidStrategy] Request method: ${options.method || 'GET'}`);
+    logger.debug(`[MyopenidStrategy] Request headers: ${logHeaders(options.headers)}`);
+    if (options.body) {
+      let bodyForLogging = '';
+      if (options.body instanceof URLSearchParams) {
+        bodyForLogging = options.body.toString();
+      } else if (typeof options.body === 'string') {
+        bodyForLogging = options.body;
+      } else {
+        bodyForLogging = safeStringify(options.body);
+      }
+      logger.debug(`[MyopenidStrategy] Request body: ${bodyForLogging}`);
+    }
+  }
+
+  try {
+    /** @type {undici.RequestInit} */
+    let fetchOptions = options;
+    if (process.env.PROXY) {
+      logger.info(`[MyopenidStrategy] proxy agent configured: ${process.env.PROXY}`);
+      fetchOptions = {
+        ...options,
+        dispatcher: new undici.ProxyAgent(process.env.PROXY),
+      };
+    }
+
+    const response = await undici.fetch(url, fetchOptions);
+
+    if (debugOpenId) {
+      logger.debug(`[MyopenidStrategy] Response status: ${response.status} ${response.statusText}`);
+      logger.debug(`[MyopenidStrategy] Response headers: ${logHeaders(response.headers)}`);
+    }
+
+    if (response.status === 200 && response.headers.has('www-authenticate')) {
+      const wwwAuth = response.headers.get('www-authenticate');
+      logger.warn(`[MyopenidStrategy] Non-standard WWW-Authenticate header found in successful response (200 OK): ${wwwAuth}.
+This violates RFC 7235 and may cause issues with strict OAuth clients. Removing header for compatibility.`);
+
+      /** Cloned response without the WWW-Authenticate header */
+      const responseBody = await response.arrayBuffer();
+      const newHeaders = new Headers();
+      for (const [key, value] of response.headers.entries()) {
+        if (key.toLowerCase() !== 'www-authenticate') {
+          newHeaders.append(key, value);
+        }
+      }
+
+      return new Response(responseBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders,
+      });
+    }
+
+    return response;
+  } catch (error) {
+    logger.error(`[MyopenidStrategy] Fetch error: ${error.message}`);
+    throw error;
+  }
+}
+
+/** @typedef {Configuration | null}  */
+let openidConfig = null;
+
+/**
+ * Custom OpenID Strategy
+ *
+ * Note: Originally overrode currentUrl() to work around Express 4's req.host not including port.
+ * With Express 5, req.host now includes the port by default, but we continue to use DOMAIN_SERVER
+ * for consistency and explicit configuration control.
+ * More info: https://github.com/panva/openid-client/pull/713
+ */
+class CustomOpenIDStrategy extends OpenIDStrategy {
+  currentUrl(req) {
+    const hostAndProtocol = process.env.DOMAIN_SERVER;
+    return new URL(`${hostAndProtocol}${req.originalUrl ?? req.url}`);
+  }
+
+  authorizationRequestParams(req, options) {
+    const params = super.authorizationRequestParams(req, options);
+    if (options?.state && !params.has('state')) {
+      params.set('state', options.state);
+    }
+
+    if (process.env.OPENID_AUDIENCE) {
+      params.set('audience', process.env.OPENID_AUDIENCE);
+      logger.debug(
+        `[MyopenidStrategy] Adding audience to authorization request: ${process.env.OPENID_AUDIENCE}`,
+      );
+    }
+
+    /** Generate nonce for federated providers that require it */
+    const shouldGenerateNonce = isEnabled(process.env.OPENID_GENERATE_NONCE);
+    if (shouldGenerateNonce && !params.has('nonce') && this._sessionKey) {
+      const crypto = require('crypto');
+      const nonce = crypto.randomBytes(16).toString('hex');
+      params.set('nonce', nonce);
+      logger.debug('[MyopenidStrategy] Generated nonce for federated provider:', nonce);
+    }
+
+    return params;
+  }
+}
+
+/**
+ * Exchange the access token for a new access token using the on-behalf-of flow if required.
+ * @param {Configuration} config
+ * @param {string} accessToken access token to be exchanged if necessary
+ * @param {string} sub - The subject identifier of the user. usually found as "sub" in the claims of the token
+ * @param {boolean} fromCache - Indicates whether to use cached tokens.
+ * @returns {Promise<string>} The new access token if exchanged, otherwise the original access token.
+ */
+const exchangeAccessTokenIfNeeded = async (config, accessToken, sub, fromCache = false) => {
+  const tokensCache = getLogStores(CacheKeys.OPENID_EXCHANGED_TOKENS);
+  const onBehalfFlowRequired = isEnabled(process.env.OPENID_ON_BEHALF_FLOW_FOR_USERINFO_REQUIRED);
+  if (onBehalfFlowRequired) {
+    if (fromCache) {
+      const cachedToken = await tokensCache.get(sub);
+      if (cachedToken) {
+        return cachedToken.access_token;
+      }
+    }
+    const grantResponse = await client.genericGrantRequest(
+      config,
+      'urn:ietf:params:oauth:grant-type:jwt-bearer',
+      {
+        scope: process.env.OPENID_ON_BEHALF_FLOW_USERINFO_SCOPE || 'user.read',
+        assertion: accessToken,
+        requested_token_use: 'on_behalf_of',
+      },
+    );
+    await tokensCache.set(
+      sub,
+      {
+        access_token: grantResponse.access_token,
+      },
+      grantResponse.expires_in * 1000,
+    );
+    return grantResponse.access_token;
+  }
+  return accessToken;
+};
+
+/**
+ * get user info from openid provider
+ * @param {Configuration} config
+ * @param {string} accessToken access token
+ * @param {string} sub - The subject identifier of the user. usually found as "sub" in the claims of the token
+ * @returns {Promise<Object|null>}
+ */
+const getUserInfo = async (config, accessToken, sub) => {
+  try {
+    const exchangedAccessToken = await exchangeAccessTokenIfNeeded(config, accessToken, sub);
+    return await client.fetchUserInfo(config, exchangedAccessToken, sub);
+  } catch (error) {
+    logger.error('[MyopenidStrategy] getUserInfo: Error fetching user info:', error);
+    return null;
+  }
+};
+
+/**
+ * Downloads an image from a URL using an access token.
+ * @param {string} url
+ * @param {Configuration} config
+ * @param {string} accessToken access token
+ * @param {string} sub - The subject identifier of the user. usually found as "sub" in the claims of the token
+ * @returns {Promise<Buffer | string>} The image buffer or an empty string if the download fails.
+ */
+const downloadImage = async (url, config, accessToken, sub) => {
+  const exchangedAccessToken = await exchangeAccessTokenIfNeeded(config, accessToken, sub, true);
+  if (!url) {
+    return '';
+  }
+
+  try {
+    const options = {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${exchangedAccessToken}`,
+      },
+    };
+
+    if (process.env.PROXY) {
+      options.agent = new HttpsProxyAgent(process.env.PROXY);
+    }
+
+    const response = await fetch(url, options);
+
+    if (response.ok) {
+      const buffer = await response.buffer();
+      return buffer;
+    } else {
+      throw new Error(`${response.statusText} (HTTP ${response.status})`);
+    }
+  } catch (error) {
+    logger.error(
+      `[MyopenidStrategy] downloadImage: Error downloading image at URL "${url}": ${error}`,
+    );
+    return '';
+  }
+};
+
+/**
+ * Determines the full name of a user based on OpenID userinfo and environment configuration.
+ *
+ * @param {Object} userinfo - The user information object from OpenID Connect
+ * @param {string} [userinfo.given_name] - The user's first name
+ * @param {string} [userinfo.family_name] - The user's last name
+ * @param {string} [userinfo.username] - The user's username
+ * @param {string} [userinfo.email] - The user's email address
+ * @returns {string} The determined full name of the user
+ */
+function getFullName(userinfo) {
+  if (process.env.OPENID_NAME_CLAIM) {
+    return userinfo[process.env.OPENID_NAME_CLAIM];
+  }
+
+  if (userinfo.given_name && userinfo.family_name) {
+    return `${userinfo.given_name} ${userinfo.family_name}`;
+  }
+
+  if (userinfo.given_name) {
+    return userinfo.given_name;
+  }
+
+  if (userinfo.family_name) {
+    return userinfo.family_name;
+  }
+
+  return userinfo.username || userinfo.email;
+}
+
+/**
+ * Converts an input into a string suitable for a username.
+ * If the input is a string, it will be returned as is.
+ * If the input is an array, elements will be joined with underscores.
+ * In case of undefined or other falsy values, a default value will be returned.
+ *
+ * @param {string | string[] | undefined} input - The input value to be converted into a username.
+ * @param {string} [defaultValue=''] - The default value to return if the input is falsy.
+ * @returns {string} The processed input as a string suitable for a username.
+ */
+function convertToUsername(input, defaultValue = '') {
+  if (typeof input === 'string') {
+    return input;
+  } else if (Array.isArray(input)) {
+    return input.join('_');
+  }
+
+  return defaultValue;
+}
+
+/**
+ * Sets up the OpenID strategy for authentication.
+ * This function configures the OpenID client, handles proxy settings,
+ * and defines the OpenID strategy for Passport.js.
+ *
+ * @async
+ * @function setupOpenId
+ * @returns {Promise<Configuration | null>} A promise that resolves when the OpenID strategy is set up and returns the openid client config object.
+ * @throws {Error} If an error occurs during the setup process.
+ */
+async function MysetupOpenId() {
+  try {
+    const shouldGenerateNonce = isEnabled(process.env.OPENID_GENERATE_NONCE);
+
+    /** @type {ClientMetadata} */
+    const clientMetadata = {
+      client_id: process.env.OPENID_CLIENT_ID,
+      client_secret: process.env.OPENID_CLIENT_SECRET,
+    };
+
+    if (shouldGenerateNonce) {
+      clientMetadata.response_types = ['code'];
+      clientMetadata.grant_types = ['authorization_code'];
+      clientMetadata.token_endpoint_auth_method = 'client_secret_post';
+    }
+
+    /** @type {Configuration} */
+    openidConfig = await client.discovery(
+      new URL(process.env.OPENID_ISSUER),
+      process.env.OPENID_CLIENT_ID,
+      clientMetadata,
+      undefined,
+      {
+        [client.customFetch]: customFetch,
+      },
+    );
+
+    const requiredRole = process.env.OPENID_REQUIRED_ROLE;
+    const requiredRoleParameterPath = process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH;
+    const requiredRoleTokenKind = process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND;
+    const usePKCE = isEnabled(process.env.OPENID_USE_PKCE);
+    logger.info(`[MyopenidStrategy] OpenID authentication configuration`, {
+      generateNonce: shouldGenerateNonce,
+      reason: shouldGenerateNonce
+        ? 'OPENID_GENERATE_NONCE=true - Will generate nonce and use explicit metadata for federated providers'
+        : 'OPENID_GENERATE_NONCE=false - Standard flow without explicit nonce or metadata',
+    });
+
+    // Set of env variables that specify how to set if a user is an admin
+    // If not set, all users will be treated as regular users
+    const adminRole = process.env.OPENID_ADMIN_ROLE;
+    const adminRoleParameterPath = process.env.OPENID_ADMIN_ROLE_PARAMETER_PATH;
+    const adminRoleTokenKind = process.env.OPENID_ADMIN_ROLE_TOKEN_KIND;
+
+    const openidLogin = new CustomOpenIDStrategy(
+      {
+        config: openidConfig,
+        scope: process.env.OPENID_SCOPE,
+        callbackURL: process.env.DOMAIN_SERVER + process.env.OPENID_CALLBACK_URL,
+        clockTolerance: process.env.OPENID_CLOCK_TOLERANCE || 300,
+        usePKCE,
+      },
+      /**
+       * @param {import('openid-client').TokenEndpointResponseHelpers} tokenset
+       * @param {import('passport-jwt').VerifyCallback} done
+       */
+      async (tokenset, done) => {
+        try {
+          const claims = tokenset.claims();
+          const userinfo = {
+            ...claims,
+            ...(await getUserInfo(openidConfig, tokenset.access_token, claims.sub)),
+          };
+
+          const appConfig = await getAppConfig();
+          /** Azure AD sometimes doesn't return email, use preferred_username as fallback */
+          const email = userinfo.email || userinfo.preferred_username || userinfo.upn || `${userinfo.webid}@FAKEDOMAIN.TLD`;
+          if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
+            logger.error(
+              `[My OpenID Strategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
+            );
+            return done(null, false, { message: 'Email domain not allowed' });
+          }
+
+          const result = await findOpenIDUser({
+            findUser,
+            email: email,
+            openidId: claims.sub,
+            idOnTheSource: claims.oid,
+            strategyName: 'MyopenidStrategy',
+          });
+          let user = result.user;
+          const error = result.error;
+
+          if (error) {
+            return done(null, false, {
+              message: ErrorTypes.AUTH_FAILED,
+            });
+          }
+
+          const fullName = getFullName(userinfo);
+
+          if (requiredRole) {
+            const requiredRoles = requiredRole
+              .split(',')
+              .map((role) => role.trim())
+              .filter(Boolean);
+            let decodedToken = '';
+            if (requiredRoleTokenKind === 'access') {
+              decodedToken = jwtDecode(tokenset.access_token);
+            } else if (requiredRoleTokenKind === 'id') {
+              decodedToken = jwtDecode(tokenset.id_token);
+            }
+
+            let roles = get(decodedToken, requiredRoleParameterPath);
+            if (!roles || (!Array.isArray(roles) && typeof roles !== 'string')) {
+              logger.error(
+                `[MyopenidStrategy] Key '${requiredRoleParameterPath}' not found or invalid type in ${requiredRoleTokenKind} token!`,
+              );
+              const rolesList =
+                requiredRoles.length === 1
+                  ? `"${requiredRoles[0]}"`
+                  : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
+              return done(null, false, {
+                message: `You must have ${rolesList} role to log in.`,
+              });
+            }
+
+            if (!requiredRoles.some((role) => roles.includes(role))) {
+              const rolesList =
+                requiredRoles.length === 1
+                  ? `"${requiredRoles[0]}"`
+                  : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
+              return done(null, false, {
+                message: `You must have ${rolesList} role to log in.`,
+              });
+            }
+          }
+
+          let username = '';
+          if (process.env.OPENID_USERNAME_CLAIM) {
+            username = userinfo[process.env.OPENID_USERNAME_CLAIM];
+          } else {
+            username = convertToUsername(
+              userinfo.preferred_username || userinfo.username || userinfo.email,
+            );
+          }
+
+          if (!user) {
+            user = {
+              provider: 'openid',
+              openidId: userinfo.sub,
+              username,
+              email: email || '',
+              emailVerified: userinfo.email_verified || false,
+              name: fullName,
+              idOnTheSource: userinfo.oid,
+            };
+
+            const balanceConfig = getBalanceConfig(appConfig);
+            user = await createUser(user, balanceConfig, true, true);
+          } else {
+            user.provider = 'openid';
+            user.openidId = userinfo.sub;
+            user.username = username;
+            user.name = fullName;
+            user.idOnTheSource = userinfo.oid;
+            if (email && email !== user.email) {
+              user.email = email;
+              user.emailVerified = userinfo.email_verified || false;
+            }
+          }
+
+          if (adminRole && adminRoleParameterPath && adminRoleTokenKind) {
+            let adminRoleObject;
+            switch (adminRoleTokenKind) {
+              case 'access':
+                adminRoleObject = jwtDecode(tokenset.access_token);
+                break;
+              case 'id':
+                adminRoleObject = jwtDecode(tokenset.id_token);
+                break;
+              case 'userinfo':
+                adminRoleObject = userinfo;
+                break;
+              default:
+                logger.error(
+                  `[MyopenidStrategy] Invalid admin role token kind: ${adminRoleTokenKind}. Must be one of 'access', 'id', or 'userinfo'.`,
+                );
+                return done(new Error('Invalid admin role token kind'));
+            }
+
+            const adminRoles = get(adminRoleObject, adminRoleParameterPath);
+
+            // Accept 3 types of values for the object extracted from adminRoleParameterPath:
+            // 1. A boolean value indicating if the user is an admin
+            // 2. A string with a single role name
+            // 3. An array of role names
+
+            if (
+              adminRoles &&
+              (adminRoles === true ||
+                adminRoles === adminRole ||
+                (Array.isArray(adminRoles) && adminRoles.includes(adminRole)))
+            ) {
+              user.role = 'ADMIN';
+              logger.info(
+                `[MyopenidStrategy] User ${username} is an admin based on role: ${adminRole}`,
+              );
+            } else if (user.role === 'ADMIN') {
+              user.role = 'USER';
+              logger.info(
+                `[MyopenidStrategy] User ${username} demoted from admin - role no longer present in token`,
+              );
+            }
+          }
+
+          if (!!userinfo && userinfo.picture && !user.avatar?.includes('manual=true')) {
+            /** @type {string | undefined} */
+            const imageUrl = userinfo.picture;
+
+            let fileName;
+            if (crypto) {
+              fileName = (await hashToken(userinfo.sub)) + '.png';
+            } else {
+              fileName = userinfo.sub + '.png';
+            }
+
+            const imageBuffer = await downloadImage(
+              imageUrl,
+              openidConfig,
+              tokenset.access_token,
+              userinfo.sub,
+            );
+            if (imageBuffer) {
+              const { saveBuffer } = getStrategyFunctions(
+                appConfig?.fileStrategy ?? process.env.CDN_PROVIDER,
+              );
+              const imagePath = await saveBuffer({
+                fileName,
+                userId: user._id.toString(),
+                buffer: imageBuffer,
+              });
+              user.avatar = imagePath ?? '';
+            }
+          }
+
+          user = await updateUser(user._id, user);
+
+          logger.info(
+            `[MyopenidStrategy] login success openidId: ${user.openidId} | email: ${user.email} | username: ${user.username} `,
+            {
+              user: {
+                openidId: user.openidId,
+                username: user.username,
+                email: user.email,
+                name: user.name,
+              },
+            },
+          );
+
+          done(null, {
+            ...user,
+            tokenset,
+            federatedTokens: {
+              access_token: tokenset.access_token,
+              refresh_token: tokenset.refresh_token,
+              expires_at: tokenset.expires_at,
+            },
+          });
+        } catch (err) {
+          logger.error('[MyopenidStrategy] login failed', err);
+          done(err);
+        }
+      },
+    );
+    passport.use('openid', openidLogin);
+    return openidConfig;
+  } catch (err) {
+    logger.error('[MyopenidStrategy]', err);
+    return null;
+  }
+}
+/**
+ * @function getOpenIdConfig
+ * @description Returns the OpenID client instance.
+ * @throws {Error} If the OpenID client is not initialized.
+ * @returns {Configuration}
+ */
+function MygetOpenIdConfig() {
+  if (!openidConfig) {
+    throw new Error('OpenID client is not initialized. Please call setupOpenId first.');
+  }
+  return openidConfig;
+}
+
+module.exports = {
+  MysetupOpenId,
+  MygetOpenIdConfig,
+};

From d61dfb0f40f641780703d489982584f5e9609b98 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 12:44:00 +0000
Subject: [PATCH 02/94] Proper naming for Solid-OIDC strategy

---
 api/server/socialLogins.js                    |  4 +-
 ...enidStrategy.js => SolidOpenidStrategy.js} | 54 +++++++++----------
 api/strategies/index.js                       |  5 ++
 3 files changed, 34 insertions(+), 29 deletions(-)
 rename api/strategies/{MyopenidStrategy.js => SolidOpenidStrategy.js} (89%)

diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index 14c9e6f15446..57978197531e 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -7,7 +7,7 @@ const {
   openIdJwtLogin,
   facebookLogin,
   discordLogin,
-  MysetupOpenId,
+  setupSolidOpenId,
   googleLogin,
   githubLogin,
   appleLogin,
@@ -36,7 +36,7 @@ async function configureOpenId(app) {
   app.use(session(sessionOptions));
   app.use(passport.session());
 
-  const config = await MysetupOpenId();
+  const config = await setupSolidOpenId();
   if (!config) {
     logger.error('OpenID Connect configuration failed - strategy not registered.');
     return;
diff --git a/api/strategies/MyopenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
similarity index 89%
rename from api/strategies/MyopenidStrategy.js
rename to api/strategies/SolidOpenidStrategy.js
index 2ebd1e780a8c..3c4221b0717f 100644
--- a/api/strategies/MyopenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -32,11 +32,11 @@ const getLogStores = require('~/cache/getLogStores');
  */
 async function customFetch(url, options) {
   const urlStr = url.toString();
-  logger.debug(`[MyopenidStrategy] Request to: ${urlStr}`);
+  logger.debug(`[SolidOpenidStrategy] Request to: ${urlStr}`);
   const debugOpenId = isEnabled(process.env.DEBUG_OPENID_REQUESTS);
   if (debugOpenId) {
-    logger.debug(`[MyopenidStrategy] Request method: ${options.method || 'GET'}`);
-    logger.debug(`[MyopenidStrategy] Request headers: ${logHeaders(options.headers)}`);
+    logger.debug(`[SolidOpenidStrategy] Request method: ${options.method || 'GET'}`);
+    logger.debug(`[SolidOpenidStrategy] Request headers: ${logHeaders(options.headers)}`);
     if (options.body) {
       let bodyForLogging = '';
       if (options.body instanceof URLSearchParams) {
@@ -46,7 +46,7 @@ async function customFetch(url, options) {
       } else {
         bodyForLogging = safeStringify(options.body);
       }
-      logger.debug(`[MyopenidStrategy] Request body: ${bodyForLogging}`);
+      logger.debug(`[SolidOpenidStrategy] Request body: ${bodyForLogging}`);
     }
   }
 
@@ -54,7 +54,7 @@ async function customFetch(url, options) {
     /** @type {undici.RequestInit} */
     let fetchOptions = options;
     if (process.env.PROXY) {
-      logger.info(`[MyopenidStrategy] proxy agent configured: ${process.env.PROXY}`);
+      logger.info(`[SolidOpenidStrategy] proxy agent configured: ${process.env.PROXY}`);
       fetchOptions = {
         ...options,
         dispatcher: new undici.ProxyAgent(process.env.PROXY),
@@ -64,13 +64,13 @@ async function customFetch(url, options) {
     const response = await undici.fetch(url, fetchOptions);
 
     if (debugOpenId) {
-      logger.debug(`[MyopenidStrategy] Response status: ${response.status} ${response.statusText}`);
-      logger.debug(`[MyopenidStrategy] Response headers: ${logHeaders(response.headers)}`);
+      logger.debug(`[SolidOpenidStrategy] Response status: ${response.status} ${response.statusText}`);
+      logger.debug(`[SolidOpenidStrategy] Response headers: ${logHeaders(response.headers)}`);
     }
 
     if (response.status === 200 && response.headers.has('www-authenticate')) {
       const wwwAuth = response.headers.get('www-authenticate');
-      logger.warn(`[MyopenidStrategy] Non-standard WWW-Authenticate header found in successful response (200 OK): ${wwwAuth}.
+      logger.warn(`[SolidOpenidStrategy] Non-standard WWW-Authenticate header found in successful response (200 OK): ${wwwAuth}.
 This violates RFC 7235 and may cause issues with strict OAuth clients. Removing header for compatibility.`);
 
       /** Cloned response without the WWW-Authenticate header */
@@ -91,7 +91,7 @@ This violates RFC 7235 and may cause issues with strict OAuth clients. Removing
 
     return response;
   } catch (error) {
-    logger.error(`[MyopenidStrategy] Fetch error: ${error.message}`);
+    logger.error(`[SolidOpenidStrategy] Fetch error: ${error.message}`);
     throw error;
   }
 }
@@ -122,7 +122,7 @@ class CustomOpenIDStrategy extends OpenIDStrategy {
     if (process.env.OPENID_AUDIENCE) {
       params.set('audience', process.env.OPENID_AUDIENCE);
       logger.debug(
-        `[MyopenidStrategy] Adding audience to authorization request: ${process.env.OPENID_AUDIENCE}`,
+        `[SolidOpenidStrategy] Adding audience to authorization request: ${process.env.OPENID_AUDIENCE}`,
       );
     }
 
@@ -132,7 +132,7 @@ class CustomOpenIDStrategy extends OpenIDStrategy {
       const crypto = require('crypto');
       const nonce = crypto.randomBytes(16).toString('hex');
       params.set('nonce', nonce);
-      logger.debug('[MyopenidStrategy] Generated nonce for federated provider:', nonce);
+      logger.debug('[SolidOpenidStrategy] Generated nonce for federated provider:', nonce);
     }
 
     return params;
@@ -190,7 +190,7 @@ const getUserInfo = async (config, accessToken, sub) => {
     const exchangedAccessToken = await exchangeAccessTokenIfNeeded(config, accessToken, sub);
     return await client.fetchUserInfo(config, exchangedAccessToken, sub);
   } catch (error) {
-    logger.error('[MyopenidStrategy] getUserInfo: Error fetching user info:', error);
+    logger.error('[SolidOpenidStrategy] getUserInfo: Error fetching user info:', error);
     return null;
   }
 };
@@ -231,7 +231,7 @@ const downloadImage = async (url, config, accessToken, sub) => {
     }
   } catch (error) {
     logger.error(
-      `[MyopenidStrategy] downloadImage: Error downloading image at URL "${url}": ${error}`,
+      `[SolidOpenidStrategy] downloadImage: Error downloading image at URL "${url}": ${error}`,
     );
     return '';
   }
@@ -297,7 +297,7 @@ function convertToUsername(input, defaultValue = '') {
  * @returns {Promise<Configuration | null>} A promise that resolves when the OpenID strategy is set up and returns the openid client config object.
  * @throws {Error} If an error occurs during the setup process.
  */
-async function MysetupOpenId() {
+async function setupSolidOpenId() {
   try {
     const shouldGenerateNonce = isEnabled(process.env.OPENID_GENERATE_NONCE);
 
@@ -328,7 +328,7 @@ async function MysetupOpenId() {
     const requiredRoleParameterPath = process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH;
     const requiredRoleTokenKind = process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND;
     const usePKCE = isEnabled(process.env.OPENID_USE_PKCE);
-    logger.info(`[MyopenidStrategy] OpenID authentication configuration`, {
+    logger.info(`[SolidOpenidStrategy] OpenID authentication configuration`, {
       generateNonce: shouldGenerateNonce,
       reason: shouldGenerateNonce
         ? 'OPENID_GENERATE_NONCE=true - Will generate nonce and use explicit metadata for federated providers'
@@ -366,7 +366,7 @@ async function MysetupOpenId() {
           const email = userinfo.email || userinfo.preferred_username || userinfo.upn || `${userinfo.webid}@FAKEDOMAIN.TLD`;
           if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
             logger.error(
-              `[My OpenID Strategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
+              `[SolidOpenidStrategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
             );
             return done(null, false, { message: 'Email domain not allowed' });
           }
@@ -376,7 +376,7 @@ async function MysetupOpenId() {
             email: email,
             openidId: claims.sub,
             idOnTheSource: claims.oid,
-            strategyName: 'MyopenidStrategy',
+            strategyName: 'SolidOpenidStrategy',
           });
           let user = result.user;
           const error = result.error;
@@ -404,7 +404,7 @@ async function MysetupOpenId() {
             let roles = get(decodedToken, requiredRoleParameterPath);
             if (!roles || (!Array.isArray(roles) && typeof roles !== 'string')) {
               logger.error(
-                `[MyopenidStrategy] Key '${requiredRoleParameterPath}' not found or invalid type in ${requiredRoleTokenKind} token!`,
+                `[SolidOpenidStrategy] Key '${requiredRoleParameterPath}' not found or invalid type in ${requiredRoleTokenKind} token!`,
               );
               const rolesList =
                 requiredRoles.length === 1
@@ -474,7 +474,7 @@ async function MysetupOpenId() {
                 break;
               default:
                 logger.error(
-                  `[MyopenidStrategy] Invalid admin role token kind: ${adminRoleTokenKind}. Must be one of 'access', 'id', or 'userinfo'.`,
+                  `[SolidOpenidStrategy] Invalid admin role token kind: ${adminRoleTokenKind}. Must be one of 'access', 'id', or 'userinfo'.`,
                 );
                 return done(new Error('Invalid admin role token kind'));
             }
@@ -494,12 +494,12 @@ async function MysetupOpenId() {
             ) {
               user.role = 'ADMIN';
               logger.info(
-                `[MyopenidStrategy] User ${username} is an admin based on role: ${adminRole}`,
+                `[SolidOpenidStrategy] User ${username} is an admin based on role: ${adminRole}`,
               );
             } else if (user.role === 'ADMIN') {
               user.role = 'USER';
               logger.info(
-                `[MyopenidStrategy] User ${username} demoted from admin - role no longer present in token`,
+                `[SolidOpenidStrategy] User ${username} demoted from admin - role no longer present in token`,
               );
             }
           }
@@ -537,7 +537,7 @@ async function MysetupOpenId() {
           user = await updateUser(user._id, user);
 
           logger.info(
-            `[MyopenidStrategy] login success openidId: ${user.openidId} | email: ${user.email} | username: ${user.username} `,
+            `[SolidOpenidStrategy] login success openidId: ${user.openidId} | email: ${user.email} | username: ${user.username} `,
             {
               user: {
                 openidId: user.openidId,
@@ -558,7 +558,7 @@ async function MysetupOpenId() {
             },
           });
         } catch (err) {
-          logger.error('[MyopenidStrategy] login failed', err);
+          logger.error('[SolidOpenidStrategy] login failed', err);
           done(err);
         }
       },
@@ -566,7 +566,7 @@ async function MysetupOpenId() {
     passport.use('openid', openidLogin);
     return openidConfig;
   } catch (err) {
-    logger.error('[MyopenidStrategy]', err);
+    logger.error('[SolidOpenidStrategy]', err);
     return null;
   }
 }
@@ -576,7 +576,7 @@ async function MysetupOpenId() {
  * @throws {Error} If the OpenID client is not initialized.
  * @returns {Configuration}
  */
-function MygetOpenIdConfig() {
+function getSolidOpenIdConfig() {
   if (!openidConfig) {
     throw new Error('OpenID client is not initialized. Please call setupOpenId first.');
   }
@@ -584,6 +584,6 @@ function MygetOpenIdConfig() {
 }
 
 module.exports = {
-  MysetupOpenId,
-  MygetOpenIdConfig,
+  setupSolidOpenId,
+  getSolidOpenIdConfig,
 };
diff --git a/api/strategies/index.js b/api/strategies/index.js
index 9a1c58ad38c6..67c105ca1d78 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -5,6 +5,11 @@ const discordLogin = require('./discordStrategy');
 const passportLogin = require('./localStrategy');
 const googleLogin = require('./googleStrategy');
 const githubLogin = require('./githubStrategy');
+const discordLogin = require('./discordStrategy');
+const facebookLogin = require('./facebookStrategy');
+const { setupSolidOpenId, getSolidOpenIdConfig } = require('./SolidOpenidStrategy');
+const jwtLogin = require('./jwtStrategy');
+const ldapLogin = require('./ldapStrategy');
 const { setupSaml } = require('./samlStrategy');
 const appleLogin = require('./appleStrategy');
 const ldapLogin = require('./ldapStrategy');

From 67e3081aad2c258119e0911bcbed96f6ea05e182 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 13:35:23 +0000
Subject: [PATCH 03/94] Add task reminders about email in Solid login

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/strategies/SolidOpenidStrategy.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 3c4221b0717f..0b91bdb98682 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -363,6 +363,9 @@ async function setupSolidOpenId() {
 
           const appConfig = await getAppConfig();
           /** Azure AD sometimes doesn't return email, use preferred_username as fallback */
+          // TODO: jeswr - Potentially fetch an email from the user's WebID if they have a `foaf:mbox`
+          // TODO: jeswr - Can codebase support email or WebID rather than requiring email?
+          // TODO: jeswr - Suggest opening issues for these once we PR the changes upstream
           const email = userinfo.email || userinfo.preferred_username || userinfo.upn || `${userinfo.webid}@FAKEDOMAIN.TLD`;
           if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
             logger.error(

From 13c1038b6313ac2ae21da49fc1d0fcf4889eef56 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 14:09:01 +0000
Subject: [PATCH 04/94] Add Solid-OIDC Client ID Document route

---
 api/server/index.js | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/api/server/index.js b/api/server/index.js
index f034f102367f..b26a1ea1d114 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -164,7 +164,23 @@ const startServer = async () => {
   app.use('/api/tags', routes.tags);
   app.use('/api/mcp', routes.mcp);
 
-  /** 404 for unmatched API routes */
+  // Solid-OIDC Client ID Document route, see spec https://solidproject.org/TR/oidc#clientids-document
+  // TODO: Expose this route only if adequate according to config, i.e. when Solid-OIDC is in use
+  // TODO: Follow 'app.use' pattern instead of inlining route here
+  // TODO: Make path configurable instead of hardcoding here
+  app.get('/solid-client-id', (_, res) => {
+    // TODO: Use constants/enums for header name and value if available from framework
+    res.set('Content-Type', 'application/ld+json');
+
+    res.send({
+      '@context': ['https://www.w3.org/ns/solid/oidc-context.jsonld'],
+
+      // TODO: Take host & port from config or API instead of hardcoding
+      // TODO: Take callback path from config or API instead of hardcoding
+      redirect_uris: ['http://localhost:3080/oauth/openid/callback'],
+    });
+  });
+
   app.use('/api', apiNotFound);
 
   /** SPA fallback - serve index.html for all unmatched routes */

From ddbb221cd5ff005f114df220267066a6fd6ce650 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 14:20:54 +0000
Subject: [PATCH 05/94] Take Solid-OIDC redirect URI from config

---
 api/server/index.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/api/server/index.js b/api/server/index.js
index b26a1ea1d114..6fb9035468c2 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -174,10 +174,7 @@ const startServer = async () => {
 
     res.send({
       '@context': ['https://www.w3.org/ns/solid/oidc-context.jsonld'],
-
-      // TODO: Take host & port from config or API instead of hardcoding
-      // TODO: Take callback path from config or API instead of hardcoding
-      redirect_uris: ['http://localhost:3080/oauth/openid/callback'],
+      redirect_uris: [process.env.DOMAIN_SERVER + process.env.OPENID_CALLBACK_URL],
     });
   });
 

From 8b514482e1bfe2a9d08dd64a3d6891e6e8cba481 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 16:37:01 +0000
Subject: [PATCH 06/94] Temporarily allow insecure OIDC AS for local
 development

---
 api/strategies/SolidOpenidStrategy.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 0b91bdb98682..d5ea0a0e4705 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -321,6 +321,7 @@ async function setupSolidOpenId() {
       undefined,
       {
         [client.customFetch]: customFetch,
+        execute: [client.allowInsecureRequests], // TODO: Insecure! Remove deprecated hack used for local HTTP only.
       },
     );
 

From a9dfe59678994559ebeefef3bad52ab62cb712dc Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Thu, 22 Jan 2026 17:29:13 +0000
Subject: [PATCH 07/94] Add `client_id` to Solid-OIDC Client ID Document

---
 api/server/index.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/api/server/index.js b/api/server/index.js
index 6fb9035468c2..5ca3ad3db0dd 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -175,6 +175,9 @@ const startServer = async () => {
     res.send({
       '@context': ['https://www.w3.org/ns/solid/oidc-context.jsonld'],
       redirect_uris: [process.env.DOMAIN_SERVER + process.env.OPENID_CALLBACK_URL],
+
+      // TODO: Don't hardcode path
+      client_id: process.env.DOMAIN_SERVER + '/solid-client-id',
     });
   });
 

From c53cf67d7f37514fe87905630e1725a1507306f9 Mon Sep 17 00:00:00 2001
From: Samu Lang <langsamu@hotmail.com>
Date: Fri, 23 Jan 2026 09:44:50 +0000
Subject: [PATCH 08/94] Don't require client secret for Solid-OIDC

---
 api/server/routes/config.js | 1 -
 api/server/socialLogins.js  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index a2dc5b79d27f..ccbbaf8a0114 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -46,7 +46,6 @@ router.get('/', async function (req, res) {
 
     const isOpenIdEnabled =
       !!process.env.OPENID_CLIENT_ID &&
-      !!process.env.OPENID_CLIENT_SECRET &&
       !!process.env.OPENID_ISSUER &&
       !!process.env.OPENID_SESSION_SECRET;
 
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index 57978197531e..a65e996be15a 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -73,7 +73,6 @@ const configureSocialLogins = async (app) => {
   }
   if (
     process.env.OPENID_CLIENT_ID &&
-    process.env.OPENID_CLIENT_SECRET &&
     process.env.OPENID_ISSUER &&
     process.env.OPENID_SCOPE &&
     process.env.OPENID_SESSION_SECRET

From f954750eae698530cca6c72d64faf4be6d6dcf35 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 29 Jan 2026 10:33:10 +0000
Subject: [PATCH 09/94] Added Middleware to log authorization code from
 received from Solid/OpenID provider.

---
 api/server/routes/oauth.js |  34 ++
 docker-compose.yml         |   2 +
 package-lock.json          | 628 +++++++++++++++++++++++++++++++++++--
 3 files changed, 630 insertions(+), 34 deletions(-)

diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index f4bb5b6026e6..ecc4749255f4 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -97,8 +97,42 @@ router.get('/openid', (req, res, next) => {
   })(req, res, next);
 });
 
+/**
+ * Middleware to log authorization code from Solid/OpenID provider
+ */
+const logAuthorizationCode = (req, res, next) => {
+  const { code, state, error } = req.query;
+  
+  if (code) {
+    logger.info('[OpenID Callback] Authorization code received from Solid provider', {
+      authorizationCode: code,
+      state: state || 'not provided',
+      hasError: !!error,
+      error: error || null,
+      queryParams: {
+        code: code ? 'present' : 'missing',
+        state: state || 'missing',
+        error: error || 'none',
+      },
+    });
+    logger.info(`[OpenID Callback] Full authorization code: ${code}`);
+  } else if (error) {
+    logger.warn('[OpenID Callback] OAuth error received (no authorization code)', {
+      error,
+      state: state || 'not provided',
+    });
+  } else {
+    logger.warn('[OpenID Callback] No authorization code or error in callback', {
+      queryParams: req.query,
+    });
+  }
+  
+  next();
+};
+
 router.get(
   '/openid/callback',
+  logAuthorizationCode,
   passport.authenticate('openid', {
     failureRedirect: `${domains.client}/oauth/error`,
     failureMessage: true,
diff --git a/docker-compose.yml b/docker-compose.yml
index 079cdb74b6de..61f214f34773 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -28,6 +28,8 @@ services:
       - ./uploads:/app/uploads
       - ./logs:/app/logs
   mongodb:
+    ports:
+      - "27017:27017"
     container_name: chat-mongodb
     image: mongo:8.0.17
     restart: always
diff --git a/package-lock.json b/package-lock.json
index 1126527dd051..10864619ef0d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2369,6 +2369,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001688",
         "electron-to-chromium": "^1.5.73",
@@ -2755,6 +2756,7 @@
       "resolved": "https://registry.npmjs.org/@anthropic-ai/vertex-sdk/-/vertex-sdk-0.14.3.tgz",
       "integrity": "sha512-GJZTkkvN66gM3Epqm9laKEjC3orQqzmQt8JAgTN9+zlb+I+1/oEd3Z7rj2tkEKCTeOUVScdhcXPudN8GdpuGqA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@anthropic-ai/sdk": ">=0.50.3 <1",
         "google-auth-library": "^9.4.2"
@@ -2789,6 +2791,7 @@
       "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.17.tgz",
       "integrity": "sha512-HQaIboE2axtlncJz1hRTaiQfJ1GGjhdtNcAnPwdjvl2RybfmlHowIB+HTVBp36LzroKPs/M4hPCxk7XTaqRZGg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@ariakit/react-core": "0.4.17"
       },
@@ -2806,6 +2809,7 @@
       "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.17.tgz",
       "integrity": "sha512-kFF6n+gC/5CRQIyaMTFoBPio2xUe0k9rZhMNdUobWRmc/twfeLVkODx+8UVYaNyKilTge8G0JFqwvFKku/jKEw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@ariakit/core": "0.4.15",
         "@floating-ui/dom": "^1.0.0",
@@ -2918,6 +2922,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -2941,6 +2946,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       }
@@ -5129,6 +5135,7 @@
       "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.8.0.tgz",
       "integrity": "sha512-l9ALUGHtFB/JfsqmA+9iYAp2a+cCwdNO/cyIr2y7nJLJsz1aae6qVP8XxT7Kbudg0IQRSIMXj0+iivFdbD1xPA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@azure/abort-controller": "^2.0.0",
         "@azure/core-auth": "^1.9.0",
@@ -5210,6 +5217,7 @@
       "version": "12.0.0",
       "resolved": "https://registry.npmjs.org/@azure/search-documents/-/search-documents-12.0.0.tgz",
       "integrity": "sha512-d9d53f2WWBpLHifk+LVn+AG52zuXvjgxJAdaH6kuT2qwrO1natcigtTgBM8qrI3iDYaDXsQhJSIMEgg9WKSoWA==",
+      "peer": true,
       "dependencies": {
         "@azure/core-auth": "^1.3.0",
         "@azure/core-client": "^1.3.0",
@@ -5230,6 +5238,7 @@
       "resolved": "https://registry.npmjs.org/@azure/storage-blob/-/storage-blob-12.30.0.tgz",
       "integrity": "sha512-peDCR8blSqhsAKDbpSP/o55S4sheNwSrblvCaHUZ5xUI73XA7ieUGGwrONgD/Fng0EoDe1VOa3fAQ7+WGB3Ocg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@azure/abort-controller": "^2.1.2",
         "@azure/core-auth": "^1.9.0",
@@ -5298,6 +5307,7 @@
       "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
       "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/code-frame": "^7.27.1",
         "@babel/generator": "^7.28.5",
@@ -7593,6 +7603,7 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
+      "peer": true,
       "license": "MIT",
       "engines": {
         "node": ">=20.19.0"
@@ -7616,6 +7627,7 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
+      "peer": true,
       "license": "MIT",
       "engines": {
         "node": ">=20.19.0"
@@ -9027,6 +9039,7 @@
       "resolved": "https://registry.npmjs.org/@dicebear/collection/-/collection-9.2.4.tgz",
       "integrity": "sha512-I1wCUp0yu5qSIeMQHmDYXQIXKkKjcja/SYBxppPkYFXpR2alxb0k9/swFDdMbkY6a1c9AT1kI1y+Pg6ywQ2rTA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@dicebear/adventurer": "9.2.4",
         "@dicebear/adventurer-neutral": "9.2.4",
@@ -9071,6 +9084,7 @@
       "resolved": "https://registry.npmjs.org/@dicebear/core/-/core-9.2.4.tgz",
       "integrity": "sha512-hz6zArEcUwkZzGOSJkWICrvqnEZY7BKeiq9rqKzVJIc1tRVv0MkR0FGvIxSvXiK9TTIgKwu656xCWAGAl6oh+w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/json-schema": "^7.0.11"
       },
@@ -9605,6 +9619,7 @@
       "version": "0.10.16",
       "resolved": "https://registry.npmjs.org/@firebase/app/-/app-0.10.16.tgz",
       "integrity": "sha512-SUati2qH48gvVGnSsqMkZr1Iq7No52a3tJQ4itboSTM89Erezmw3v1RsfVymrDze9+KiOLmBpvLNKSvheITFjg==",
+      "peer": true,
       "dependencies": {
         "@firebase/component": "0.6.11",
         "@firebase/logger": "0.4.4",
@@ -9666,6 +9681,7 @@
       "version": "0.2.46",
       "resolved": "https://registry.npmjs.org/@firebase/app-compat/-/app-compat-0.2.46.tgz",
       "integrity": "sha512-9hSHWE5LMqtKIm13CnH5OZeMPbkVV3y5vgNZ5EMFHcG2ceRrncyNjG9No5XfWQw8JponZdGs4HlE4aMD/jxcFA==",
+      "peer": true,
       "dependencies": {
         "@firebase/app": "0.10.16",
         "@firebase/component": "0.6.11",
@@ -9680,7 +9696,8 @@
     "node_modules/@firebase/app-types": {
       "version": "0.9.3",
       "resolved": "https://registry.npmjs.org/@firebase/app-types/-/app-types-0.9.3.tgz",
-      "integrity": "sha512-kRVpIl4vVGJ4baogMDINbyrIOtOxqhkZQg4jTq3l8Lw6WSk0xfpEYzezFu+Kl4ve4fbPl79dvwRtaFqAC/ucCw=="
+      "integrity": "sha512-kRVpIl4vVGJ4baogMDINbyrIOtOxqhkZQg4jTq3l8Lw6WSk0xfpEYzezFu+Kl4ve4fbPl79dvwRtaFqAC/ucCw==",
+      "peer": true
     },
     "node_modules/@firebase/auth": {
       "version": "1.8.1",
@@ -10097,6 +10114,7 @@
       "version": "1.10.2",
       "resolved": "https://registry.npmjs.org/@firebase/util/-/util-1.10.2.tgz",
       "integrity": "sha512-qnSHIoE9FK+HYnNhTI8q14evyqbc/vHRivfB4TgCIUOl4tosmKSQlp7ltymOlMP4xVIJTg5wrkfcZ60X4nUf7Q==",
+      "peer": true,
       "dependencies": {
         "tslib": "^2.1.0"
       },
@@ -10331,6 +10349,7 @@
       "resolved": "https://registry.npmjs.org/@headlessui/react/-/react-2.2.4.tgz",
       "integrity": "sha512-lz+OGcAH1dK93rgSMzXmm1qKOJkBUqZf1L4M8TWLNplftQD3IkoEDdUFNfAn4ylsN6WOTVtWaLmvmaHOUk1dTA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@floating-ui/react": "^0.26.16",
         "@react-aria/focus": "^3.20.2",
@@ -11675,6 +11694,7 @@
       "resolved": "https://registry.npmjs.org/@langchain/core/-/core-0.3.80.tgz",
       "integrity": "sha512-vcJDV2vk1AlCwSh3aBm/urQ1ZrlXFFBocv11bz/NBUfLWD5/UDNMzwPdaAd2dKvNmTWa9FM2lirLU3+JCf4cRA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@cfworker/json-schema": "^4.0.2",
         "ansi-styles": "^5.0.0",
@@ -12188,6 +12208,7 @@
       "resolved": "https://registry.npmjs.org/@librechat/agents/-/agents-3.1.55.tgz",
       "integrity": "sha512-impxeKpCDlPkAVQFWnA6u6xkxDSBR/+H8uYq7rZomBeu0rUh/OhJLiI1fAwPhKXP33udNtHA8GyDi0QJj78R9w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@anthropic-ai/sdk": "^0.73.0",
         "@aws-sdk/client-bedrock-runtime": "^3.980.0",
@@ -12316,6 +12337,7 @@
       "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.27.1.tgz",
       "integrity": "sha512-sr6GbP+4edBwFndLbM60gf07z0FQ79gaExpnsjMGePXqFcSSb7t6iscpjk9DhFhwd+mTEQrzNafGP8/iGGFYaA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@hono/node-server": "^1.19.9",
         "ajv": "^8.17.1",
@@ -12697,6 +12719,7 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
       "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
       "license": "Apache-2.0",
+      "peer": true,
       "engines": {
         "node": ">=8.0.0"
       }
@@ -12706,7 +12729,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/api-logs/-/api-logs-0.211.0.tgz",
       "integrity": "sha512-swFdZq8MCdmdR22jTVGQDhwqDzcI4M10nhjXkLr1EsIzXgZBqm4ZlmmcWsg3TSNf+3mzgOiqveXmBLZuDi2Lgg==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/api": "^1.3.0"
       },
@@ -12732,6 +12754,7 @@
       "integrity": "sha512-ka4H8OM6+DlUhSAZpONu0cPBtPPTQKxbxVzC4CzVx5+K4JnroJVBtDzLAMx4/3CDTJXRvVFhpFjtl4SaiTNoyQ==",
       "license": "Apache-2.0",
       "peer": true,
+      "peer": true,
       "dependencies": {
         "@opentelemetry/semantic-conventions": "^1.29.0"
       },
@@ -13883,6 +13906,7 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/exporter-trace-otlp-proto/-/exporter-trace-otlp-proto-0.207.0.tgz",
       "integrity": "sha512-ruUQB4FkWtxHjNmSXjrhmJZFvyMm+tBzHyMm7YPQshApy4wvZUTcrpPyP/A/rCl/8M4BwoVIZdiwijMdbZaq4w==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.2.0",
         "@opentelemetry/otlp-exporter-base": "0.207.0",
@@ -14127,7 +14151,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/otlp-exporter-base/-/otlp-exporter-base-0.211.0.tgz",
       "integrity": "sha512-bp1+63V8WPV+bRI9EQG6E9YID1LIHYSZVbp7f+44g9tRzCq+rtw/o4fpL5PC31adcUsFiz/oN0MdLISSrZDdrg==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.5.0",
         "@opentelemetry/otlp-transformer": "0.211.0"
@@ -14416,7 +14439,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-logs/-/sdk-logs-0.211.0.tgz",
       "integrity": "sha512-O5nPwzgg2JHzo59kpQTPUOTzFi0Nv5LxryG27QoXBciX3zWM3z83g+SNOHhiQVYRWFSxoWn1JM2TGD5iNjOwdA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/api-logs": "0.211.0",
         "@opentelemetry/core": "2.5.0",
@@ -14619,6 +14641,7 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.2.0.tgz",
       "integrity": "sha512-xWQgL0Bmctsalg6PaXExmzdedSp3gyKV8mQBwK/j9VGdCDu2fmXIb2gAehBKbkXCpJ4HPkgv3QfoJWRT4dHWbw==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.2.0",
         "@opentelemetry/resources": "2.2.0",
@@ -15207,6 +15230,7 @@
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-checkbox/-/react-checkbox-1.0.4.tgz",
       "integrity": "sha512-CBuGQa52aAYnADZVt/KBQzXrwx6TqnlwtcIPGtVt5JkkzQwMOLJjPukimhfKEr4GQNd43C+djUh5Ikopj8pSLg==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.13.10",
         "@radix-ui/primitive": "1.0.1",
@@ -15963,6 +15987,7 @@
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-hover-card/-/react-hover-card-1.0.7.tgz",
       "integrity": "sha512-OcUN2FU0YpmajD/qkph3XzMcK/NmSk9hGWnjV68p6QiZMgILugusgQwnLSDs3oFSJYGKf3Y49zgFedhGh04k9A==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.13.10",
         "@radix-ui/primitive": "1.0.1",
@@ -15994,6 +16019,7 @@
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-icons/-/react-icons-1.3.0.tgz",
       "integrity": "sha512-jQxj/0LKgp+j9BiTXz3O3sgs26RNet2iLWmsPyRz2SIcR4q/4SbazXfnYwbAr+vLYKSfc7qxzyGQA1HLlYiuNw==",
+      "peer": true,
       "peerDependencies": {
         "react": "^16.x || ^17.x || ^18.x"
       }
@@ -17948,6 +17974,7 @@
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.0.2.tgz",
       "integrity": "sha512-YeTpuq4deV+6DusvVUW4ivBgnkHwECUu0BiN43L5UCDFgdhsRUWAghhTF5MbvNTPzmiFOx90asDSUjWuCNapwg==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.13.10",
         "@radix-ui/react-compose-refs": "1.0.1"
@@ -18139,6 +18166,7 @@
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-tabs/-/react-tabs-1.0.4.tgz",
       "integrity": "sha512-egZfYY/+wRNCflXNHx+dePvnz9FbmssDTJBtgRfDY7e8SE5oIo3Py2eCB1ckAbh1Q7cQ/6yJZThJ++sgbxibog==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.13.10",
         "@radix-ui/primitive": "1.0.1",
@@ -18169,6 +18197,7 @@
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-toast/-/react-toast-1.1.5.tgz",
       "integrity": "sha512-fRLn227WHIBRSzuRzGJ8W+5YALxofH23y0MlPLddaIpLpCDqdE0NZlS2NRQDRiptfxDeeCjgFIpexB1/zkxDlw==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.13.10",
         "@radix-ui/primitive": "1.0.1",
@@ -18560,7 +18589,6 @@
       "resolved": "https://registry.npmjs.org/@react-spring/web/-/web-10.0.1.tgz",
       "integrity": "sha512-FgQk02OqFrYyJBTTnBTWAU0WPzkHkKXauc6aeexcvATvLapUxwnfGuLlsLYF8BYjEVfkivPT04ziAue6zyRBtQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@react-spring/animated": "~10.0.1",
         "@react-spring/core": "~10.0.1",
@@ -18577,7 +18605,6 @@
       "resolved": "https://registry.npmjs.org/@react-spring/animated/-/animated-10.0.1.tgz",
       "integrity": "sha512-BGL3hA66Y8Qm3KmRZUlfG/mFbDPYajgil2/jOP0VXf2+o2WPVmcDps/eEgdDqgf5Pv9eBbyj7LschLMuSjlW3Q==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@react-spring/shared": "~10.0.1",
         "@react-spring/types": "~10.0.1"
@@ -18591,7 +18618,6 @@
       "resolved": "https://registry.npmjs.org/@react-spring/core/-/core-10.0.1.tgz",
       "integrity": "sha512-KaMMsN1qHuVTsFpg/5ajAVye7OEqhYbCq0g4aKM9bnSZlDBBYpO7Uf+9eixyXN8YEbF+YXaYj9eoWDs+npZ+sA==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@react-spring/animated": "~10.0.1",
         "@react-spring/shared": "~10.0.1",
@@ -18609,15 +18635,13 @@
       "version": "10.0.1",
       "resolved": "https://registry.npmjs.org/@react-spring/rafz/-/rafz-10.0.1.tgz",
       "integrity": "sha512-UrzG/d6Is+9i0aCAjsjWRqIlFFiC4lFqFHrH63zK935z2YDU95TOFio4VKGISJ5SG0xq4ULy7c1V3KU+XvL+Yg==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/@react-spring/web/node_modules/@react-spring/shared": {
       "version": "10.0.1",
       "resolved": "https://registry.npmjs.org/@react-spring/shared/-/shared-10.0.1.tgz",
       "integrity": "sha512-KR2tmjDShPruI/GGPfAZOOLvDgkhFseabjvxzZFFggJMPkyICLjO0J6mCIoGtdJSuHywZyc4Mmlgi+C88lS00g==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@react-spring/rafz": "~10.0.1",
         "@react-spring/types": "~10.0.1"
@@ -18630,8 +18654,7 @@
       "version": "10.0.1",
       "resolved": "https://registry.npmjs.org/@react-spring/types/-/types-10.0.1.tgz",
       "integrity": "sha512-Fk1wYVAKL+ZTYK+4YFDpHf3Slsy59pfFFvnnTfRjQQFGlyIo4VejPtDs3CbDiuBjM135YztRyZjIH2VbycB+ZQ==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/@react-stately/flags": {
       "version": "3.1.2",
@@ -18675,6 +18698,7 @@
       "version": "1.6.0",
       "resolved": "https://registry.npmjs.org/@redis/client/-/client-1.6.0.tgz",
       "integrity": "sha512-aR0uffYI700OEEH4gYnitAnv3vzVGXCFvYfdpu/CJKvk4pHfLPEy/JSZyrpQ+15WhXe1yJRXLtfQ84s4mEXnPg==",
+      "peer": true,
       "dependencies": {
         "cluster-key-slot": "1.1.2",
         "generic-pool": "3.9.0",
@@ -18863,6 +18887,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -19929,6 +19954,7 @@
       "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.4.8.tgz",
       "integrity": "sha512-q9u+MSbJVIJ1QmJ4+1u+cERXkrhuILCBDsJUBAW1MPE6sFonbCNaegFuwW9ll8kh5UdyY3jOkoOGlc7BesoLpg==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@smithy/abort-controller": "^4.2.8",
         "@smithy/protocol-http": "^5.3.8",
@@ -20478,6 +20504,7 @@
       "version": "4.36.1",
       "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-4.36.1.tgz",
       "integrity": "sha512-y7ySVHFyyQblPl3J3eQBWpXZkliroki3ARnBKsdJchlgt7yJLRDUcf4B8soufgiYt3pEQIkBWBx1N9/ZPIeUWw==",
+      "peer": true,
       "dependencies": {
         "@tanstack/query-core": "4.36.1",
         "use-sync-external-store": "^1.2.0"
@@ -21285,6 +21312,7 @@
       "version": "20.11.16",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.16.tgz",
       "integrity": "sha512-gKb0enTmRCzXSSUJDq6/sPcqrfCv2mkkG6Jt/clpn5eiCbKTY+SgZUxo+p8ZKMof5dCp9vHQUAB7wOUTod22wQ==",
+      "peer": true,
       "dependencies": {
         "undici-types": "~5.26.4"
       }
@@ -21338,6 +21366,7 @@
       "version": "18.2.53",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.2.53.tgz",
       "integrity": "sha512-52IHsMDT8qATp9B9zoOyobW8W3/0QhaJQTw1HwRj0UY2yBpCAQ7+S/CqHYQ8niAm3p4ji+rWUQ9UCib0GxQ60w==",
+      "peer": true,
       "dependencies": {
         "@types/prop-types": "*",
         "@types/scheduler": "*",
@@ -21349,6 +21378,7 @@
       "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.2.18.tgz",
       "integrity": "sha512-TJxDm6OfAX2KJWJdMEVTwWke5Sc/E/RlnPGvGfS0W7+6ocy2xhDVQVh/KvC2Uf7kACs+gDytdusDSdWfWkaNzw==",
       "devOptional": true,
+      "peer": true,
       "dependencies": {
         "@types/react": "*"
       }
@@ -21502,6 +21532,7 @@
       "integrity": "sha512-aFcXEJJCI4gUdXgoo/j9udUYIHgF23MFkg09LFz2dzEmU0+1Plk4rQWv/IYKvPHAtlkkGoB3m5e6oUp+JPsNaQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/regexpp": "^4.10.0",
         "@typescript-eslint/scope-manager": "8.24.0",
@@ -21532,6 +21563,7 @@
       "integrity": "sha512-MFDaO9CYiard9j9VepMNa9MTcqVvSny2N4hkY6roquzj8pdCBRENhErrteaQuu7Yjn1ppk0v1/ZF9CG3KIlrTA==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@typescript-eslint/scope-manager": "8.24.0",
         "@typescript-eslint/types": "8.24.0",
@@ -22026,6 +22058,152 @@
         "win32"
       ]
     },
+    "node_modules/@webassemblyjs/ast": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
+      "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/helper-numbers": "1.11.6",
+        "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
+      }
+    },
+    "node_modules/@webassemblyjs/floating-point-hex-parser": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
+      "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
+      "dev": true
+    },
+    "node_modules/@webassemblyjs/helper-api-error": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
+      "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
+      "dev": true
+    },
+    "node_modules/@webassemblyjs/helper-buffer": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
+      "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
+      "dev": true
+    },
+    "node_modules/@webassemblyjs/helper-numbers": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
+      "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/floating-point-hex-parser": "1.11.6",
+        "@webassemblyjs/helper-api-error": "1.11.6",
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
+      "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
+      "dev": true
+    },
+    "node_modules/@webassemblyjs/helper-wasm-section": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
+      "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
+        "@webassemblyjs/wasm-gen": "1.12.1"
+      }
+    },
+    "node_modules/@webassemblyjs/ieee754": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
+      "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
+      "dev": true,
+      "dependencies": {
+        "@xtuc/ieee754": "^1.2.0"
+      }
+    },
+    "node_modules/@webassemblyjs/leb128": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
+      "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
+      "dev": true,
+      "dependencies": {
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/utf8": {
+      "version": "1.11.6",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
+      "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
+      "dev": true
+    },
+    "node_modules/@webassemblyjs/wasm-edit": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
+      "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
+        "@webassemblyjs/helper-wasm-section": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-opt": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1",
+        "@webassemblyjs/wast-printer": "1.12.1"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-gen": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
+      "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
+        "@webassemblyjs/ieee754": "1.11.6",
+        "@webassemblyjs/leb128": "1.11.6",
+        "@webassemblyjs/utf8": "1.11.6"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-opt": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
+      "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-buffer": "1.12.1",
+        "@webassemblyjs/wasm-gen": "1.12.1",
+        "@webassemblyjs/wasm-parser": "1.12.1"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-parser": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
+      "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@webassemblyjs/helper-api-error": "1.11.6",
+        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
+        "@webassemblyjs/ieee754": "1.11.6",
+        "@webassemblyjs/leb128": "1.11.6",
+        "@webassemblyjs/utf8": "1.11.6"
+      }
+    },
+    "node_modules/@webassemblyjs/wast-printer": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
+      "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
+      "dev": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.12.1",
+        "@xtuc/long": "4.2.2"
+      }
+    },
     "node_modules/@xmldom/is-dom-node": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@xmldom/is-dom-node/-/is-dom-node-1.0.1.tgz",
@@ -22043,6 +22221,18 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@xtuc/ieee754": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
+      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
+      "dev": true
+    },
+    "node_modules/@xtuc/long": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
+      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
+      "dev": true
+    },
     "node_modules/abab": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz",
@@ -22104,6 +22294,7 @@
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "license": "MIT",
+      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -22165,6 +22356,7 @@
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
       "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -22193,6 +22385,15 @@
         }
       }
     },
+    "node_modules/ajv-keywords": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+      "dev": true,
+      "peerDependencies": {
+        "ajv": "^6.9.1"
+      }
+    },
     "node_modules/anser": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/anser/-/anser-2.1.1.tgz",
@@ -22693,6 +22894,7 @@
       "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.5.tgz",
       "integrity": "sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "follow-redirects": "^1.15.11",
         "form-data": "^4.0.5",
@@ -23265,6 +23467,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.8.25",
         "caniuse-lite": "^1.0.30001754",
@@ -23705,6 +23908,15 @@
         "node": ">= 6"
       }
     },
+    "node_modules/chrome-trace-event": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz",
+      "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.0"
+      }
+    },
     "node_modules/ci-info": {
       "version": "3.9.0",
       "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
@@ -23746,6 +23958,7 @@
       "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
       "integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "clsx": "^2.1.1"
       },
@@ -23910,6 +24123,7 @@
       "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
       "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=6"
       }
@@ -24143,6 +24357,7 @@
       "resolved": "https://registry.npmjs.org/connect-redis/-/connect-redis-8.1.0.tgz",
       "integrity": "sha512-Km0EYLDlmExF52UCss5gLGTtrukGC57G6WCC2aqEMft5Vr4xNWuM4tL+T97kWrw+vp40SXFteb6Xk/7MxgpwdA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=18"
       },
@@ -24772,6 +24987,7 @@
       "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz",
       "integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=0.10"
       }
@@ -25196,6 +25412,7 @@
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
       "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
       "license": "ISC",
+      "peer": true,
       "engines": {
         "node": ">=12"
       }
@@ -25823,6 +26040,7 @@
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.0.tgz",
       "integrity": "sha512-r+f6MYR1gGN1eJv0TVQbhA7if/U7P87cdPl3HN5rikqaBSBxLiCb/b9O+2eG0cxz0ghyU+mU1QkbsOwERMYlWQ==",
       "license": "(MPL-2.0 OR Apache-2.0)",
+      "peer": true,
       "optionalDependencies": {
         "@types/trusted-types": "^2.0.7"
       }
@@ -26190,6 +26408,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz",
+      "integrity": "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==",
+      "dev": true
+    },
     "node_modules/es-object-atoms": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
@@ -26344,6 +26568,7 @@
       "integrity": "sha512-BhHmn2yNOFA9H9JmmIVKJmd288g9hrVRDkdoIgRCRuSySRUHH7r/DI6aAXW9T1WwUuY3DFgrcaqB+deURBLR5g==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
         "@eslint-community/regexpp": "^4.12.1",
@@ -26404,6 +26629,7 @@
       "integrity": "sha512-lZBts941cyJyeaooiKxAtzoPHTN+GbQTJFAIdQbRhA4/8whaAraEh47Whw/ZFfrjNSnlAxqfm9i0XVAEkULjCw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "eslint-config-prettier": "build/bin/cli.js"
       },
@@ -26515,6 +26741,7 @@
       "integrity": "sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@rtsao/scc": "^1.1.0",
         "array-includes": "^3.1.8",
@@ -26764,6 +26991,28 @@
         "eslint": ">=5.0.0"
       }
     },
+    "node_modules/eslint-scope": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
+      "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
+      "dev": true,
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^4.1.1"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/eslint-scope/node_modules/estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+      "dev": true,
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
     "node_modules/eslint-visitor-keys": {
       "version": "3.4.3",
       "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
@@ -26981,6 +27230,7 @@
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.2.tgz",
       "integrity": "sha512-YolzkJNxsTL3tCJMWFxpxtG2sCjbZ4LQUBUrkdaJK0ub0p6lmJt+2+1SwhKjLc652lpH9L/79Ptez972H9tphw==",
+      "peer": true,
       "dependencies": {
         "eventsource-parser": "^3.0.0"
       },
@@ -27067,6 +27317,7 @@
       "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
       "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "accepts": "^2.0.0",
         "body-parser": "^2.2.1",
@@ -27114,13 +27365,10 @@
       }
     },
     "node_modules/express-rate-limit": {
-      "version": "8.2.1",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.2.1.tgz",
-      "integrity": "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==",
-      "license": "MIT",
-      "dependencies": {
-        "ip-address": "10.0.1"
-      },
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz",
+      "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==",
+      "peer": true,
       "engines": {
         "node": ">= 16"
       },
@@ -27136,6 +27384,7 @@
       "resolved": "https://registry.npmjs.org/express-session/-/express-session-1.18.2.tgz",
       "integrity": "sha512-SZjssGQC7TzTs9rpPDuUrR23GNZ9+2+IkA/+IJWmvQilTr5OSliEHGF+D9scbIpdC6yGtTI0/VhaHoVes2AN/A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cookie": "0.7.2",
         "cookie-signature": "1.0.7",
@@ -27654,6 +27903,7 @@
       "version": "11.0.2",
       "resolved": "https://registry.npmjs.org/firebase/-/firebase-11.0.2.tgz",
       "integrity": "sha512-w4T8BSJpzdZA25QRch5ahLsgB6uRvg1LEic4BaC5rTD1YygroI1AXp+W+rbMnr8d8EjfAv6t4k8doULIjc1P8Q==",
+      "peer": true,
       "dependencies": {
         "@firebase/analytics": "0.10.10",
         "@firebase/analytics-compat": "0.2.16",
@@ -27792,6 +28042,7 @@
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
       "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.8",
@@ -27867,7 +28118,6 @@
       "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.23.9.tgz",
       "integrity": "sha512-TqEHXj8LWfQSKqfdr5Y4mYltYLw96deu6/K9kGDd+ysqRJPNwF9nb5mZcrLmybHbU7gcJ+HQar41U3UTGanbbQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "motion-dom": "^12.23.9",
         "motion-utils": "^12.23.6",
@@ -27895,7 +28145,6 @@
       "resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.23.9.tgz",
       "integrity": "sha512-6Sv++iWS8XMFCgU1qwKj9l4xuC47Hp4+2jvPfyTXkqDg2tTzSgX6nWKD4kNFXk0k7llO59LZTPuJigza4A2K1A==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "motion-utils": "^12.23.6"
       }
@@ -27904,8 +28153,7 @@
       "version": "12.23.6",
       "resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-12.23.6.tgz",
       "integrity": "sha512-eAWoPgr4eFEOFfg2WjIsMoqJTW6Z8MTUCgn/GZ3VRpClWBdnbjryiA3ZSNLyxCTmCQx4RmYX6jX1iWHbenUPNQ==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/fresh": {
       "version": "0.5.2",
@@ -28183,6 +28431,12 @@
         "node": ">=10.13.0"
       }
     },
+    "node_modules/glob-to-regexp": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
+      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
+      "dev": true
+    },
     "node_modules/glob/node_modules/balanced-match": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
@@ -28766,8 +29020,7 @@
       "version": "1.12.1",
       "resolved": "https://registry.npmjs.org/hookified/-/hookified-1.12.1.tgz",
       "integrity": "sha512-xnKGl+iMIlhrZmGHB729MqlmPoWBznctSQTYCpFKqNsCgimJQmithcW0xSQMMFzYnV2iKUh25alswn6epgxS0Q==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/htm": {
       "version": "3.1.1",
@@ -28894,6 +29147,7 @@
       "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
       "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "agent-base": "^7.1.2",
         "debug": "4"
@@ -28956,6 +29210,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.23.2"
       },
@@ -28973,6 +29228,7 @@
       "resolved": "https://registry.npmjs.org/i18next-browser-languagedetector/-/i18next-browser-languagedetector-8.2.0.tgz",
       "integrity": "sha512-P+3zEKLnOF0qmiesW383vsLdtQVyKtCNA9cjSoKCppTKPQVfKd2W8hbVo5ZhNJKDqeM7BOcvNoKJOjpHh4Js9g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.23.2"
       }
@@ -29198,6 +29454,7 @@
       "resolved": "https://registry.npmjs.org/input-otp/-/input-otp-1.4.2.tgz",
       "integrity": "sha512-l3jWwYNvrEa6NTCt7BECfCm48GvwuZzkoeG3gBL2w4CHeOXW3eKFmf9UNYkNfYc3mxMrthMnxjIE07MT0zLBQA==",
       "license": "MIT",
+      "peer": true,
       "peerDependencies": {
         "react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc",
         "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc"
@@ -29237,6 +29494,7 @@
       "resolved": "https://registry.npmjs.org/ioredis/-/ioredis-5.3.2.tgz",
       "integrity": "sha512-1DKMMzlIHM02eBBVOFQ1+AolGjs6+xEcM4PDL7NqOS6szq7H9jSaEkIUH6/a5Hl241LzW6JLSiAbNvTQjUupUA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@ioredis/commands": "^1.1.1",
         "cluster-key-slot": "^1.1.0",
@@ -31312,6 +31570,7 @@
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
       "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "argparse": "^2.0.1"
       },
@@ -31677,6 +31936,7 @@
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-5.5.2.tgz",
       "integrity": "sha512-TXcFHbmm/z7MGd1u9ASiCSfTS+ei6Z8B3a5JHzx3oPa/o7QzWVtPRpc4KGER5RR469IC+/nfg4U5YLIuDUua2g==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@keyv/serialize": "^1.1.1"
       }
@@ -32208,6 +32468,15 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
+    "node_modules/loader-runner": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
+      "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.11.5"
+      }
+    },
     "node_modules/loader-utils": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-3.3.1.tgz",
@@ -34594,6 +34863,7 @@
       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
       "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "whatwg-url": "^5.0.0"
       },
@@ -35824,6 +36094,7 @@
       "integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==",
       "dev": true,
       "license": "Apache-2.0",
+      "peer": true,
       "bin": {
         "playwright-core": "cli.js"
       },
@@ -35889,6 +36160,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "nanoid": "^3.3.11",
         "picocolors": "^1.1.1",
@@ -37434,6 +37706,7 @@
       "version": "6.0.15",
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.15.tgz",
       "integrity": "sha512-rEYkQOMUCEMhsKbK66tbEU9QVIxbhN18YiniAwA7XQYTVBqrBy+P2p5JcdqsHgKM2zWylp8d7J6eszocfds5Sw==",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -37503,6 +37776,7 @@
       "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -37879,6 +38153,7 @@
       "resolved": "https://registry.npmjs.org/rate-limit-redis/-/rate-limit-redis-4.2.0.tgz",
       "integrity": "sha512-wV450NQyKC24NmPosJb2131RoczLdfIJdKCReNwtVpm5998U8SgKrAZrIHaN/NfQgqOHaan8Uq++B4sa5REwjA==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">= 16"
       },
@@ -37934,6 +38209,7 @@
       "version": "7.4.2",
       "resolved": "https://registry.npmjs.org/rc-input-number/-/rc-input-number-7.4.2.tgz",
       "integrity": "sha512-yGturTw7WGP+M1GbJ+UTAO7L4buxeW6oilhL9Sq3DezsRS8/9qec4UiXUbeoiX9bzvRXH11JvgskBtxSp4YSNg==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.10.1",
         "@rc-component/mini-decimal": "^1.0.1",
@@ -37963,6 +38239,7 @@
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
       "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0"
       },
@@ -38035,6 +38312,7 @@
       "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
       "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "loose-envify": "^1.1.0",
         "scheduler": "^0.23.2"
@@ -38332,6 +38610,7 @@
       "resolved": "https://registry.npmjs.org/react-resizable-panels/-/react-resizable-panels-3.0.6.tgz",
       "integrity": "sha512-b3qKHQ3MLqOgSS+FRYKapNkJZf5EQzuf6+RLiq1/IlTHw99YrZ2NJZLk4hQIzTnnIkRg2LUqyVinu6YWWpUYew==",
       "license": "MIT",
+      "peer": true,
       "peerDependencies": {
         "react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc",
         "react-dom": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
@@ -38403,6 +38682,7 @@
       "version": "8.5.3",
       "resolved": "https://registry.npmjs.org/react-textarea-autosize/-/react-textarea-autosize-8.5.3.tgz",
       "integrity": "sha512-XT1024o2pqCuZSuBt9FwHlaDeNtVrtCXu0Rnz88t1jUGheCLa3PhjE1GH8Ctm2axEtvdCl5SUHYschyQ0L5QHQ==",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.20.13",
         "use-composed-ref": "^1.3.0",
@@ -39614,6 +39894,7 @@
       "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/estree": "1.0.8"
       },
@@ -39986,6 +40267,24 @@
         "loose-envify": "^1.1.0"
       }
     },
+    "node_modules/schema-utils": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
+      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
+      "dev": true,
+      "dependencies": {
+        "@types/json-schema": "^7.0.8",
+        "ajv": "^6.12.5",
+        "ajv-keywords": "^3.5.2"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
     "node_modules/seedrandom": {
       "version": "3.0.5",
       "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
@@ -41243,6 +41542,7 @@
       "version": "1.14.0",
       "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-1.14.0.tgz",
       "integrity": "sha512-3mFKyCo/MBcgyOTlrY8T7odzZFx+w+qKSMAmdFzRvqBfLlSigU6TZnlFHK0lkMwj9Bj8OYU+9yW9lmGuS0QEnQ==",
+      "peer": true,
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/dcastil"
@@ -41252,6 +41552,7 @@
       "version": "3.4.1",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.1.tgz",
       "integrity": "sha512-qAYmXRfk3ENzuPBakNK0SRrUDipP8NQnEY6772uDhflcQz5EhRdD7JNZxyrFHVQNCwULPBn6FNPp9brpO7ctcA==",
+      "peer": true,
       "dependencies": {
         "@alloc/quick-lru": "^5.2.0",
         "arg": "^5.0.2",
@@ -41380,6 +41681,69 @@
         "node": ">=10"
       }
     },
+    "node_modules/terser-webpack-plugin": {
+      "version": "5.3.10",
+      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
+      "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.20",
+        "jest-worker": "^27.4.5",
+        "schema-utils": "^3.1.1",
+        "serialize-javascript": "^6.0.1",
+        "terser": "^5.26.0"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.1.0"
+      },
+      "peerDependenciesMeta": {
+        "@swc/core": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "uglify-js": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/terser-webpack-plugin/node_modules/jest-worker": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
+      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      }
+    },
+    "node_modules/terser-webpack-plugin/node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
     "node_modules/terser/node_modules/commander": {
       "version": "2.20.3",
       "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
@@ -41470,7 +41834,8 @@
     "node_modules/tiktoken": {
       "version": "1.0.15",
       "resolved": "https://registry.npmjs.org/tiktoken/-/tiktoken-1.0.15.tgz",
-      "integrity": "sha512-sCsrq/vMWUSEW29CJLNmPvWxlVp7yh2tlkAjpJltIKqp5CKf98ZNpdeHRmAlPVFlGEbswDc6SmI8vz64W/qErw=="
+      "integrity": "sha512-sCsrq/vMWUSEW29CJLNmPvWxlVp7yh2tlkAjpJltIKqp5CKf98ZNpdeHRmAlPVFlGEbswDc6SmI8vz64W/qErw==",
+      "peer": true
     },
     "node_modules/timers-browserify": {
       "version": "2.0.12",
@@ -41541,6 +41906,7 @@
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -41761,6 +42127,7 @@
       "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "devOptional": true,
+      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -42102,6 +42469,7 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
       "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
       "devOptional": true,
+      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -42225,6 +42593,7 @@
       "resolved": "https://registry.npmjs.org/undici/-/undici-7.20.0.tgz",
       "integrity": "sha512-MJZrkjyd7DeC+uPZh+5/YaMDxFiiEEaDgbUSVMXayofAkDWF1088CDo+2RPg7B1BuS1qf1vgNE7xqwPxE0DuSQ==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=20.18.1"
       }
@@ -42883,6 +43252,82 @@
         "node": ">=4"
       }
     },
+    "node_modules/vite": {
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/vite-plugin-compression2": {
       "version": "2.2.1",
       "resolved": "https://registry.npmjs.org/vite-plugin-compression2/-/vite-plugin-compression2-2.2.1.tgz",
@@ -42894,6 +43339,55 @@
         "tar-mini": "^0.2.0"
       }
     },
+    "node_modules/vite-plugin-node-polyfills": {
+      "version": "0.23.0",
+      "resolved": "https://registry.npmjs.org/vite-plugin-node-polyfills/-/vite-plugin-node-polyfills-0.23.0.tgz",
+      "integrity": "sha512-4n+Ys+2bKHQohPBKigFlndwWQ5fFKwaGY6muNDMTb0fSQLyBzS+jjUNRZG9sKF0S/Go4ApG6LFnUGopjkILg3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/plugin-inject": "^5.0.5",
+        "node-stdlib-browser": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/davidmyersdev"
+      },
+      "peerDependencies": {
+        "vite": "^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0"
+      }
+    },
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/vm-browserify": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.2.tgz",
@@ -42985,6 +43479,19 @@
         "makeerror": "1.0.12"
       }
     },
+    "node_modules/watchpack": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
+      "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
+      "dev": true,
+      "dependencies": {
+        "glob-to-regexp": "^0.4.1",
+        "graceful-fs": "^4.1.2"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
     "node_modules/web-namespaces": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
@@ -43011,6 +43518,62 @@
         "node": ">=12"
       }
     },
+    "node_modules/webpack": {
+      "version": "5.94.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
+      "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@types/estree": "^1.0.5",
+        "@webassemblyjs/ast": "^1.12.1",
+        "@webassemblyjs/wasm-edit": "^1.12.1",
+        "@webassemblyjs/wasm-parser": "^1.12.1",
+        "acorn": "^8.7.1",
+        "acorn-import-attributes": "^1.9.5",
+        "browserslist": "^4.21.10",
+        "chrome-trace-event": "^1.0.2",
+        "enhanced-resolve": "^5.17.1",
+        "es-module-lexer": "^1.2.1",
+        "eslint-scope": "5.1.1",
+        "events": "^3.2.0",
+        "glob-to-regexp": "^0.4.1",
+        "graceful-fs": "^4.2.11",
+        "json-parse-even-better-errors": "^2.3.1",
+        "loader-runner": "^4.2.0",
+        "mime-types": "^2.1.27",
+        "neo-async": "^2.6.2",
+        "schema-utils": "^3.2.0",
+        "tapable": "^2.1.1",
+        "terser-webpack-plugin": "^5.3.10",
+        "watchpack": "^2.4.1",
+        "webpack-sources": "^3.2.3"
+      },
+      "bin": {
+        "webpack": "bin/webpack.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependenciesMeta": {
+        "webpack-cli": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/webpack-sources": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
+      "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
+      "dev": true,
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
     "node_modules/websocket-driver": {
       "version": "0.7.4",
       "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
@@ -43189,6 +43752,7 @@
       "version": "3.11.0",
       "resolved": "https://registry.npmjs.org/winston/-/winston-3.11.0.tgz",
       "integrity": "sha512-L3yR6/MzZAOl0DsysUXHVjOwv8mKZ71TrA/41EIduGpOOV5LQVodqN+QdQ6BS6PJ/RdIshZhq84P/fStEZkk7g==",
+      "peer": true,
       "dependencies": {
         "@colors/colors": "^1.6.0",
         "@dabh/diagnostics": "^2.0.2",
@@ -43542,6 +44106,7 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.80.0.tgz",
       "integrity": "sha512-cIFJOD1DESzpjOBl763Kp1AH7UE/0fcdHe6rZXUdQ9c50uvgigvW97u3IcSeBwOkgqL/PXPBktBCh0KEu5L8XQ==",
       "dev": true,
+      "peer": true,
       "license": "MIT",
       "bin": {
         "rollup": "dist/bin/rollup"
@@ -44125,6 +44690,7 @@
       "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
       "integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
       "license": "MIT",
+      "peer": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
@@ -44134,6 +44700,7 @@
       "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.1.tgz",
       "integrity": "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==",
       "license": "ISC",
+      "peer": true,
       "peerDependencies": {
         "zod": "^3.25 || ^4"
       }
@@ -46317,7 +46884,6 @@
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "ansi-regex": "^5.0.1",
         "ansi-styles": "^5.0.0",
@@ -46349,8 +46915,7 @@
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
       "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
       "dev": true,
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "packages/client/node_modules/regenerate-unicode-properties": {
       "version": "10.2.2",
@@ -46652,7 +47217,6 @@
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/logform/-/logform-2.7.0.tgz",
       "integrity": "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==",
-      "peer": true,
       "dependencies": {
         "@colors/colors": "1.6.0",
         "@types/triple-beam": "^1.3.2",
@@ -46669,7 +47233,6 @@
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
       "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
-      "peer": true,
       "engines": {
         "node": ">= 6"
       }
@@ -46698,7 +47261,6 @@
       "version": "3.17.0",
       "resolved": "https://registry.npmjs.org/winston/-/winston-3.17.0.tgz",
       "integrity": "sha512-DLiFIXYC5fMPxaRg832S6F5mJYvePtmO5G9v9IgUFPhXm9/GkXarH/TUrBAVzhTCzAj9anE/+GjrgXp/54nOgw==",
-      "peer": true,
       "dependencies": {
         "@colors/colors": "^1.6.0",
         "@dabh/diagnostics": "^2.0.2",
@@ -46720,7 +47282,6 @@
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/winston-daily-rotate-file/-/winston-daily-rotate-file-5.0.0.tgz",
       "integrity": "sha512-JDjiXXkM5qvwY06733vf09I2wnMXpZEhxEVOSPenZMii+g7pcDcTBt2MRugnoi8BwVSuCT2jfRXBUy+n1Zz/Yw==",
-      "peer": true,
       "dependencies": {
         "file-stream-rotator": "^0.6.1",
         "object-hash": "^3.0.0",
@@ -46738,7 +47299,6 @@
       "version": "4.9.0",
       "resolved": "https://registry.npmjs.org/winston-transport/-/winston-transport-4.9.0.tgz",
       "integrity": "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==",
-      "peer": true,
       "dependencies": {
         "logform": "^2.7.0",
         "readable-stream": "^3.6.2",

From f08074a66c95da1e707a3b7d5e3a43e7c04933ce Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 2 Feb 2026 10:01:51 +0000
Subject: [PATCH 10/94] server stores conversations in pod

---
 SOLID_INTEGRATION_PROGRESS.md               |  130 ++
 api/app/clients/BaseClient.js               |    4 +
 api/models/Conversation.js                  |   95 +-
 api/models/Message.js                       |  171 +-
 api/package.json                            |    1 +
 api/server/controllers/AuthController.js    |   88 +-
 api/server/controllers/agents/request.js    |   65 +-
 api/server/index.js                         |   10 +-
 api/server/middleware/requireJwtAuth.js     |   43 +-
 api/server/middleware/validateMessageReq.js |   21 +-
 api/server/routes/agents/index.js           |    7 +
 api/server/routes/convos.js                 |   53 +-
 api/server/routes/messages.js               |  140 +-
 api/server/routes/oauth.js                  |   45 +-
 api/server/services/AuthService.js          |   36 +-
 api/server/services/SolidStorage.js         | 1930 +++++++++++++++++++
 api/strategies/jwtStrategy.js               |   28 +-
 package-lock.json                           |  310 +++
 18 files changed, 3064 insertions(+), 113 deletions(-)
 create mode 100644 SOLID_INTEGRATION_PROGRESS.md
 create mode 100644 api/server/services/SolidStorage.js

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
new file mode 100644
index 000000000000..7547ca5ee7c2
--- /dev/null
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -0,0 +1,130 @@
+# Solid Pod Integration - Progress Report
+
+## Overview
+Successfully implemented Solid Pod storage integration for LibreChat, enabling users to store conversations and messages in their personal Solid Pods instead of (or alongside) MongoDB.
+
+## Completed Milestones
+
+### 1. Authentication & Token Management
+- **Status**: Complete
+- **Details**: 
+  - Integrated Solid-OIDC authentication flow
+  - Captured and logged authorization codes from Solid provider
+  - Implemented token storage in session and cookies
+  - Handled cases where Solid provider doesn't issue refresh tokens
+  - Ensured JWT tokens are created for frontend authentication
+
+### 2. Solid Pod Access
+- **Status**: Complete
+- **Details**:
+  - Implemented authenticated fetch using OpenID access tokens
+  - Created Pod URL discovery with fallback mechanism
+  - Derived Pod URLs from WebID when not found in profile
+  - Verified Pod accessibility before operations
+
+### 3. Container Management
+- **Status**: Complete
+- **Details**:
+  - Implemented automatic container creation for base storage structure
+  - Created `/librechat/`, `/librechat/conversations/`, and `/librechat/messages/` containers
+  - Used HTTP HEAD requests to check container existence
+  - Properly parsed Turtle (RDF) format responses from Solid Pods
+
+### 4. Message Storage
+- **Status**: Complete
+- **Details**:
+  - Implemented `saveMessageToSolid` - saves individual messages as JSON files
+  - Messages stored in: `/librechat/messages/{conversationId}/{messageId}.json`
+  - Successfully tested: User messages are being saved to Pod
+  - Proper error handling and logging
+
+### 5. Conversation Storage
+- **Status**: Complete
+- **Details**:
+  - Implemented `saveConvoToSolid` - saves conversations as JSON files
+  - Conversations stored in: `/librechat/conversations/{conversationId}.json`
+  - Successfully tested: Conversations are being created in Pod
+  - Includes message references and metadata
+
+### 6. Data Retrieval
+- **Status**: Complete
+- **Details**:
+  - Implemented `getMessagesFromSolid` - retrieves all messages for a conversation
+  - Implemented `getConvosByCursorFromSolid` - retrieves conversations with pagination
+  - Properly parses Turtle format to extract `ldp:contains` items
+  - Handles empty containers gracefully (returns empty arrays, not errors)
+
+### 7. Feature Flag Implementation
+- **Status**: Complete
+- **Details**:
+  - Added `USE_SOLID_STORAGE` environment variable
+  - Integrated Solid storage functions into `Message.js` and `Conversation.js` models
+  - Maintains backward compatibility with MongoDB
+  - Original MongoDB code preserved (commented) for rollback capability
+
+## Current Status
+
+### Working Features
+1. **User Login**: Solid-OIDC authentication working correctly
+2. **Conversation Creation**: New conversations are saved to Solid Pod
+3. **Message Saving**: User messages are saved to Solid Pod
+4. **Data Retrieval**: Conversations and messages can be read from Pod
+5. **Container Structure**: Proper directory structure created automatically
+
+### Known Issues 🔧
+1. **Message Updates**: LLM response messages fail to update in Pod
+   - **Error**: `conversationId is required for updating messages`
+   - **Root Cause**: `conversationId` not always present in message object during updates
+   - **Status**: In Progress
+
+2. **Title Generation**: Endpoint `/api/convos/gen_title/{conversationId}` returns 404
+   - **Status**: To be investigated
+
+## Technical Implementation
+
+### Storage Format
+- **Format**: JSON files
+- **Structure**:
+  ```
+  /librechat/
+    /conversations/
+      {conversationId}.json
+    /messages/
+      {conversationId}/
+        {messageId}.json
+  ```
+
+### Parsing Logic
+- Uses HTTP GET requests to retrieve container contents
+- Parses Turtle (RDF) format responses
+- Extracts `ldp:contains` predicates to list files
+- Handles relative and absolute URLs
+
+### Authentication
+- Uses OpenID access tokens stored in session
+- Falls back to cookies if session unavailable
+- Tokens retrieved from multiple sources for robustness
+
+## Next Steps
+1. Fix message update functionality to handle missing `conversationId`
+2. Investigate and fix title generation endpoint
+3. Test full conversation flow (create → send message → receive LLM response → update)
+4. Performance testing with multiple conversations
+5. Error recovery and retry mechanisms
+
+## Files Modified
+- `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations
+- `api/models/Message.js` - Integrated Solid storage
+- `api/models/Conversation.js` - Integrated Solid storage
+- `api/server/routes/oauth.js` - Token logging and storage
+- `api/server/services/AuthService.js` - Token management
+- `api/server/index.js` - Session middleware ordering
+- `api/server/controllers/AuthController.js` - Refresh token handling
+
+## Dependencies Added
+- `@inrupt/solid-client@^1.30.2` - Solid Pod client library
+
+---
+
+**Report Date**: January 30, 2026  
+**Status**: 85% Complete - Core functionality working, minor fixes needed
diff --git a/api/app/clients/BaseClient.js b/api/app/clients/BaseClient.js
index 8f931f8a5e5a..efaeffeef7b4 100644
--- a/api/app/clients/BaseClient.js
+++ b/api/app/clients/BaseClient.js
@@ -1031,6 +1031,10 @@ class BaseClient {
    * @param {Partial<TMessage>} message
    */
   async updateMessageInDatabase(message) {
+    // Ensure conversationId is included if available
+    if (!message.conversationId && this.conversationId) {
+      message.conversationId = this.conversationId;
+    }
     await updateMessage(this.options.req, message);
   }
 
diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 32eac1a76419..84d5b5d8c72d 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -1,8 +1,11 @@
 const { logger } = require('@librechat/data-schemas');
-const { createTempChatExpirationDate } = require('@librechat/api');
+const { createTempChatExpirationDate, isEnabled } = require('@librechat/api');
 const { getMessages, deleteMessages } = require('./Message');
 const { Conversation } = require('~/db/models');
 
+// Feature flag to toggle between MongoDB and Solid storage
+const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+
 /**
  * Searches for a conversation by conversationId and returns a lean document with only conversationId and user.
  * @param {string} conversationId - The conversation's ID.
@@ -21,9 +24,34 @@ const searchConversation = async (conversationId) => {
  * Retrieves a single conversation for a given user and conversation ID.
  * @param {string} user - The user's ID.
  * @param {string} conversationId - The conversation's ID.
+ * @param {Object} [req] - Optional request object for Solid storage support.
  * @returns {Promise<TConversation>} The conversation object.
  */
-const getConvo = async (user, conversationId) => {
+const getConvo = async (user, conversationId, req = null) => {
+  // Use Solid storage if enabled and req is provided with openidId
+  if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+    try {
+      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+      const convo = await getConvoFromSolid(req, conversationId);
+      if (convo) {
+        return convo;
+      }
+      // If Solid storage returns null, fall through to MongoDB
+      logger.warn('[getConvo] Conversation not found in Solid Pod, falling back to MongoDB', {
+        conversationId,
+        userId: user,
+      });
+    } catch (error) {
+      logger.error('[getConvo] Error getting conversation from Solid Pod, falling back to MongoDB', {
+        error: error.message,
+        conversationId,
+        userId: user,
+      });
+      // Fall through to MongoDB storage
+    }
+  }
+
+  // MongoDB storage (original code)
   try {
     return await Conversation.findOne({ user, conversationId }).lean();
   } catch (error) {
@@ -87,6 +115,46 @@ module.exports = {
    * @returns {Promise<TConversation>} The conversation object.
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
+    // Use Solid storage if enabled
+    if (USE_SOLID_STORAGE) {
+      try {
+        if (metadata?.context) {
+          logger.debug(`[saveConvo] ${metadata.context}`);
+        }
+
+        const { saveConvoToSolid } = require('~/server/services/SolidStorage');
+        
+        const convoData = {
+          conversationId,
+          newConversationId,
+          ...convo,
+        };
+
+        if (req?.body?.isTemporary) {
+          try {
+            const appConfig = req.config;
+            convoData.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+          } catch (err) {
+            logger.error('Error creating temporary chat expiration date:', err);
+            logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
+            convoData.expiredAt = null;
+          }
+        } else {
+          convoData.expiredAt = null;
+        }
+
+        const savedConvo = await saveConvoToSolid(req, convoData, metadata);
+        return savedConvo;
+      } catch (error) {
+        logger.error('[saveConvo] Error saving conversation to Solid Pod', error);
+        if (metadata && metadata?.context) {
+          logger.info(`[saveConvo] ${metadata.context}`);
+        }
+        return { message: 'Error saving conversation' };
+      }
+    }
+
+    // MongoDB storage (original code)
     try {
       if (metadata?.context) {
         logger.debug(`[saveConvo] ${metadata.context}`);
@@ -170,8 +238,31 @@ module.exports = {
       search,
       sortBy = 'updatedAt',
       sortDirection = 'desc',
+      req, // Optional req object for Solid storage
     } = {},
   ) => {
+    // Use Solid storage if enabled and req is provided
+    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+      try {
+        const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
+        return await getConvosByCursorFromSolid(req, {
+          cursor,
+          limit,
+          isArchived,
+          tags,
+          search,
+          sortBy,
+          sortDirection,
+        });
+      } catch (error) {
+        logger.warn('[getConvosByCursor] Error getting conversations from Solid Pod, falling back to MongoDB', {
+          error: error.message,
+          user: req.user?.id,
+          hasOpenidId: !!req.user?.openidId,
+        });
+        // Fall through to MongoDB storage
+      }
+    }
     const filters = [{ user }];
     if (isArchived) {
       filters.push({ isArchived: true });
diff --git a/api/models/Message.js b/api/models/Message.js
index 8fe04f6f5409..cdf363ae64eb 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -1,10 +1,13 @@
 const { z } = require('zod');
 const { logger } = require('@librechat/data-schemas');
-const { createTempChatExpirationDate } = require('@librechat/api');
+const { createTempChatExpirationDate, isEnabled } = require('@librechat/api');
 const { Message } = require('~/db/models');
 
 const idSchema = z.string().uuid();
 
+// Feature flag to toggle between MongoDB and Solid storage
+const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+
 /**
  * Saves a message in the database.
  *
@@ -47,6 +50,127 @@ async function saveMessage(req, params, metadata) {
     return;
   }
 
+  // Use Solid storage if enabled
+  if (USE_SOLID_STORAGE) {
+    try {
+      const { saveMessageToSolid } = require('~/server/services/SolidStorage');
+      
+      const messageData = {
+        ...params,
+        messageId: params.newMessageId || params.messageId,
+      };
+
+      if (req?.body?.isTemporary) {
+        try {
+          const appConfig = req.config;
+          messageData.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+        } catch (err) {
+          logger.error('Error creating temporary chat expiration date:', err);
+          logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+          messageData.expiredAt = null;
+        }
+      } else {
+        messageData.expiredAt = null;
+      }
+
+      if (messageData.tokenCount != null && isNaN(messageData.tokenCount)) {
+        logger.warn(
+          `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${messageData.tokenCount}`,
+        );
+        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+        messageData.tokenCount = 0;
+      }
+
+      const savedMessage = await saveMessageToSolid(req, messageData, metadata);
+      return savedMessage;
+    } catch (err) {
+      logger.error('Error saving message to Solid Pod:', err);
+      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+      throw err;
+    }
+  }
+
+  // MongoDB storage (original code - commented for reference)
+  /*
+  try {
+    const update = {
+      ...params,
+      user: req.user.id,
+      messageId: params.newMessageId || params.messageId,
+    };
+
+    if (req?.body?.isTemporary) {
+      try {
+        const appConfig = req.config;
+        update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+      } catch (err) {
+        logger.error('Error creating temporary chat expiration date:', err);
+        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+        update.expiredAt = null;
+      }
+    } else {
+      update.expiredAt = null;
+    }
+
+    if (update.tokenCount != null && isNaN(update.tokenCount)) {
+      logger.warn(
+        `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${update.tokenCount}`,
+      );
+      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+      update.tokenCount = 0;
+    }
+    const message = await Message.findOneAndUpdate(
+      { messageId: params.messageId, user: req.user.id },
+      update,
+      { upsert: true, new: true },
+    );
+
+    return message.toObject();
+  } catch (err) {
+    logger.error('Error saving message:', err);
+    logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+
+    // 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
+  }
+  */
+  
+  // Fallback to MongoDB if Solid is not enabled
   try {
     const update = {
       ...params,
@@ -237,6 +361,32 @@ async function updateMessageText(req, { messageId, text }) {
  * @throws {Error} If there is an error in updating the message or if the message is not found.
  */
 async function updateMessage(req, message, metadata) {
+  // Use Solid storage if enabled
+  if (USE_SOLID_STORAGE) {
+    try {
+      const { updateMessageInSolid } = require('~/server/services/SolidStorage');
+      const updatedMessage = await updateMessageInSolid(req, message, metadata);
+      
+      return {
+        messageId: updatedMessage.messageId,
+        conversationId: updatedMessage.conversationId,
+        parentMessageId: updatedMessage.parentMessageId,
+        sender: updatedMessage.sender,
+        text: updatedMessage.text,
+        isCreatedByUser: updatedMessage.isCreatedByUser,
+        tokenCount: updatedMessage.tokenCount,
+        feedback: updatedMessage.feedback,
+      };
+    } catch (err) {
+      logger.error('Error updating message in Solid Pod:', err);
+      if (metadata && metadata?.context) {
+        logger.info(`---\`updateMessage\` context: ${metadata.context}`);
+      }
+      throw err;
+    }
+  }
+
+  // MongoDB storage (original code)
   try {
     const { messageId, ...update } = message;
     const updatedMessage = await Message.findOneAndUpdate(
@@ -283,6 +433,22 @@ async function updateMessage(req, message, metadata) {
  * @throws {Error} If there is an error in deleting messages.
  */
 async function deleteMessagesSince(req, { messageId, conversationId }) {
+  // Use Solid storage if enabled
+  if (USE_SOLID_STORAGE) {
+    try {
+      const { deleteMessagesFromSolid } = require('~/server/services/SolidStorage');
+      const deletedCount = await deleteMessagesFromSolid(req, {
+        messageId,
+        conversationId,
+      });
+      return { deletedCount };
+    } catch (err) {
+      logger.error('Error deleting messages from Solid Pod:', err);
+      throw err;
+    }
+  }
+
+  // MongoDB storage (original code)
   try {
     const message = await Message.findOne({ messageId, user: req.user.id }).lean();
 
@@ -309,6 +475,9 @@ async function deleteMessagesSince(req, { messageId, conversationId }) {
  * @throws {Error} If there is an error in retrieving messages.
  */
 async function getMessages(filter, select) {
+  // Note: getMessages doesn't have access to req, so it can't use Solid storage
+  // For Solid storage, use getMessagesFromSolid directly from routes/controllers that have req
+  // MongoDB storage (original code)
   try {
     if (select) {
       return await Message.find(filter).select(select).sort({ createdAt: 1 }).lean();
diff --git a/api/package.json b/api/package.json
index 90b0509cc0a6..3d3055447364 100644
--- a/api/package.json
+++ b/api/package.json
@@ -42,6 +42,7 @@
     "@azure/search-documents": "^12.0.0",
     "@azure/storage-blob": "^12.30.0",
     "@google/genai": "^1.19.0",
+    "@inrupt/solid-client": "^1.30.2",
     "@keyv/redis": "^4.3.3",
     "@langchain/core": "^0.3.80",
     "@librechat/agents": "^3.1.55",
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 13d024cd036f..8810aa9df4e9 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -68,17 +68,20 @@ const refreshController = async (req, res) => {
   const parsedCookies = req.headers.cookie ? cookies.parse(req.headers.cookie) : {};
   const token_provider = parsedCookies.token_provider;
 
+  // Handle OpenID users with OPENID_REUSE_TOKENS enabled
   if (token_provider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    /** For OpenID users, read refresh token from session to avoid large cookie issues */
+    /** For OpenID users with token reuse, read refresh token from session */
     const refreshToken = req.session?.openidTokens?.refreshToken || parsedCookies.refreshToken;
 
     if (!refreshToken) {
-      return res.status(200).send('Refresh token not provided');
-    }
-
-    try {
-      const openIdConfig = getOpenIdConfig();
-      const refreshParams = process.env.OPENID_SCOPE ? { scope: process.env.OPENID_SCOPE } : {};
+      // Solid provider may not provide refresh tokens - fall back to standard JWT refresh
+      logger.warn('[refreshController] No OpenID refresh token available, falling back to standard refresh');
+      // Fall through to standard refresh logic below
+    } else {
+      // We have a refresh token, use OpenID refresh flow
+      try {
+        const openIdConfig = getOpenIdConfig();
+        const refreshParams = process.env.OPENID_SCOPE ? { scope: process.env.OPENID_SCOPE } : {};
       const tokenset = await openIdClient.refreshTokenGrant(
         openIdConfig,
         refreshToken,
@@ -93,46 +96,49 @@ const refreshController = async (req, res) => {
         strategyName: 'refreshController',
       });
 
-      logger.debug(
-        `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
-      );
-
-      if (error || !user) {
-        logger.warn(
-          `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
+        logger.debug(
+          `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
         );
-        return res.status(401).redirect('/login');
-      }
 
-      // Handle migration: update user with openidId if found by email without openidId
-      // Also handle case where user has mismatched openidId (e.g., after database switch)
-      if (migration || user.openidId !== claims.sub) {
-        const reason = migration ? 'migration' : 'openidId mismatch';
-        await updateUser(user._id.toString(), {
-          provider: 'openid',
-          openidId: claims.sub,
-        });
-        logger.info(
-          `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
-        );
+        if (error || !user) {
+          logger.warn(
+            `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
+          );
+          return res.status(401).redirect('/login');
+        }
+
+        // Handle migration: update user with openidId if found by email without openidId
+        // Also handle case where user has mismatched openidId (e.g., after database switch)
+        if (migration || user.openidId !== claims.sub) {
+          const reason = migration ? 'migration' : 'openidId mismatch';
+          await updateUser(user._id.toString(), {
+            provider: 'openid',
+            openidId: claims.sub,
+          });
+          logger.info(
+            `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
+          );
+        }
+
+        const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
+
+        user.federatedTokens = {
+          access_token: tokenset.access_token,
+          id_token: tokenset.id_token,
+          refresh_token: refreshToken,
+          expires_at: claims.exp,
+        };
+
+        return res.status(200).send({ token, user });
+      } catch (error) {
+        logger.error('[refreshController] OpenID token refresh error', error);
+        // Fall through to standard refresh logic as fallback
       }
-
-      const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
-
-      user.federatedTokens = {
-        access_token: tokenset.access_token,
-        id_token: tokenset.id_token,
-        refresh_token: refreshToken,
-        expires_at: claims.exp,
-      };
-
-      return res.status(200).send({ token, user });
-    } catch (error) {
-      logger.error('[refreshController] OpenID token refresh error', error);
-      return res.status(403).send('Invalid OpenID refresh token');
     }
   }
 
+  /** For non-OpenID users or OpenID users without OPENID_REUSE_TOKENS, use standard JWT refresh */
+
   /** For non-OpenID users, read refresh token from cookies */
   const refreshToken = parsedCookies.refreshToken;
   if (!refreshToken) {
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index dea5400036da..b39426b4736d 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -305,6 +305,24 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
         }
 
         if (!wasAbortedBeforeComplete) {
+          // Always save/update the final response message with complete text FIRST
+          // This ensures the message is persisted before we emit FINAL and complete the job
+          logger.debug('[ResumableAgentController] Saving final response message', {
+            messageId: response.messageId,
+            hasText: !!response.text,
+            textLength: response.text?.length || 0,
+            hasContent: !!response.content,
+            contentLength: Array.isArray(response.content) ? response.content.length : 0,
+            contentTypes: Array.isArray(response.content) 
+              ? response.content.map(c => c?.type).filter(Boolean)
+              : [],
+          });
+          await saveMessage(
+            req,
+            { ...response, user: userId },
+            { context: 'api/server/controllers/agents/request.js - resumable response end' },
+          );
+
           const finalEvent = {
             final: true,
             conversation,
@@ -313,35 +331,25 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
             responseMessage: { ...response },
           };
 
-          logger.debug(`[ResumableAgentController] Emitting FINAL event`, {
-            streamId,
-            wasAbortedBeforeComplete,
-            userMessageId: userMessage?.messageId,
-            responseMessageId: response?.messageId,
-            conversationId: conversation?.conversationId,
-          });
-
-          await GenerationJobManager.emitDone(streamId, finalEvent);
-          GenerationJobManager.completeJob(streamId);
+          // Emit the final event to all subscribers
+          GenerationJobManager.emitDone(streamId, finalEvent);
           await decrementPendingRequest(userId);
+          
+          // Complete the job AFTER emitting FINAL and saving messages
+          // This ensures the frontend receives the FINAL event while the job is still active
+          GenerationJobManager.completeJob(streamId);
         } else {
           const finalEvent = {
             final: true,
             conversation,
             title: conversation.title,
             requestMessage: sanitizeMessageForTransmit(userMessage),
-            responseMessage: { ...response, unfinished: true },
+            responseMessage: { ...response, error: true },
+            error: { message: 'Request was aborted' },
           };
-
-          logger.debug(`[ResumableAgentController] Emitting ABORTED FINAL event`, {
-            streamId,
-            wasAbortedBeforeComplete,
-            userMessageId: userMessage?.messageId,
-            responseMessageId: response?.messageId,
-            conversationId: conversation?.conversationId,
-          });
-
-          await GenerationJobManager.emitDone(streamId, finalEvent);
+          // Emit the final event to all subscribers first
+          GenerationJobManager.emitDone(streamId, finalEvent);
+          // Then complete the job to mark it as inactive
           GenerationJobManager.completeJob(streamId, 'Request aborted');
           await decrementPendingRequest(userId);
         }
@@ -658,14 +666,13 @@ const _LegacyAgentController = async (req, res, next, initializeClient, addTitle
       });
       res.end();
 
-      // Save the message if needed
-      if (client.savedMessageIds && !client.savedMessageIds.has(messageId)) {
-        await saveMessage(
-          req,
-          { ...finalResponse, user: userId },
-          { context: 'api/server/controllers/agents/request.js - response end' },
-        );
-      }
+      // Always save/update the final response message with complete text
+      // Even if it was saved initially, we need to update it with the final text content
+      await saveMessage(
+        req,
+        { ...finalResponse, user: userId },
+        { context: 'api/server/controllers/agents/request.js - response end' },
+      );
     }
     // Edge case: sendMessage completed but abort happened during sendCompletion
     // We need to ensure a final event is sent
diff --git a/api/server/index.js b/api/server/index.js
index 5ca3ad3db0dd..ab42170ef35a 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -105,6 +105,12 @@ const startServer = async () => {
   app.use(cors());
   app.use(cookieParser());
 
+  // Configure social logins (including session middleware) BEFORE passport initialization
+  // This ensures sessions are available for all requests, including JWT-authenticated ones
+  if (isEnabled(ALLOW_SOCIAL_LOGIN)) {
+    await configureSocialLogins(app);
+  }
+
   if (!isEnabled(DISABLE_COMPRESSION)) {
     app.use(compression());
   } else {
@@ -129,10 +135,6 @@ const startServer = async () => {
     passport.use(ldapLogin);
   }
 
-  if (isEnabled(ALLOW_SOCIAL_LOGIN)) {
-    await configureSocialLogins(app);
-  }
-
   app.use('/oauth', routes.oauth);
   /* API Endpoints */
   app.use('/api/auth', routes.auth);
diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index 16b107aefc5e..12cc0fd51f90 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -6,15 +6,56 @@ const { isEnabled } = require('@librechat/api');
  * Custom Middleware to handle JWT authentication, with support for OpenID token reuse
  * Switches between JWT and OpenID authentication based on cookies and environment settings
  */
+const { logger } = require('@librechat/data-schemas');
+
 const requireJwtAuth = (req, res, next) => {
   const cookieHeader = req.headers.cookie;
   const tokenProvider = cookieHeader ? cookies.parse(cookieHeader).token_provider : null;
+  const hasAuthHeader = !!req.headers.authorization;
+
+  logger.info('[requireJwtAuth] Authentication check', {
+    path: req.path,
+    method: req.method,
+    hasCookie: !!cookieHeader,
+    tokenProvider,
+    hasAuthHeader,
+    authHeaderPrefix: req.headers.authorization?.substring(0, 30),
+    openidReuseTokens: isEnabled(process.env.OPENID_REUSE_TOKENS),
+  });
 
+  // Use OpenID authentication if token provider is OpenID and OPENID_REUSE_TOKENS is enabled
   if (tokenProvider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
+    logger.debug('[requireJwtAuth] Using OpenID JWT authentication');
     return passport.authenticate('openidJwt', { session: false })(req, res, next);
   }
 
-  return passport.authenticate('jwt', { session: false })(req, res, next);
+  // Default to standard JWT authentication
+  logger.debug('[requireJwtAuth] Using standard JWT authentication');
+  
+  // Add error handler to log authentication failures
+  return passport.authenticate('jwt', { session: false }, (err, user, info) => {
+    if (err) {
+      logger.error('[requireJwtAuth] Authentication error', {
+        error: err.message,
+        stack: err.stack,
+      });
+      return res.status(401).json({ error: 'Authentication failed', message: err.message });
+    }
+    if (!user) {
+      logger.warn('[requireJwtAuth] Authentication failed - no user', {
+        info: info?.message || 'No user returned from JWT strategy',
+        hasAuthHeader,
+        tokenProvider,
+      });
+      return res.status(401).json({ 
+        error: 'Authentication required',
+        message: 'No valid JWT token found. Make sure you are logged in and the Authorization header is sent.',
+        hint: 'Access this endpoint via the frontend app, or include Authorization: Bearer <token> header',
+      });
+    }
+    req.user = user;
+    next();
+  })(req, res, next);
 };
 
 module.exports = requireJwtAuth;
diff --git a/api/server/middleware/validateMessageReq.js b/api/server/middleware/validateMessageReq.js
index 430444a17278..7e4d21c53589 100644
--- a/api/server/middleware/validateMessageReq.js
+++ b/api/server/middleware/validateMessageReq.js
@@ -1,4 +1,8 @@
 const { getConvo } = require('~/models');
+const { isEnabled } = require('@librechat/api');
+const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+
+const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
 
 // Middleware to validate conversationId and user relationship
 const validateMessageReq = async (req, res, next) => {
@@ -12,7 +16,22 @@ const validateMessageReq = async (req, res, next) => {
     conversationId = req.body.message.conversationId;
   }
 
-  const conversation = await getConvo(req.user.id, conversationId);
+  let conversation = null;
+
+  // Use Solid storage if enabled
+  if (USE_SOLID_STORAGE && req.user?.openidId) {
+    try {
+      conversation = await getConvoFromSolid(req, conversationId);
+    } catch (error) {
+      // If Solid storage fails, fall back to MongoDB
+      // Don't log error here as it might be expected (conversation doesn't exist in Solid yet)
+    }
+  }
+
+  // Fallback to MongoDB if Solid storage is disabled or didn't find the conversation
+  if (!conversation) {
+    conversation = await getConvo(req.user.id, conversationId);
+  }
 
   if (!conversation) {
     return res.status(404).json({ error: 'Conversation not found' });
diff --git a/api/server/routes/agents/index.js b/api/server/routes/agents/index.js
index f8d39cb4d82b..05afdb9b1f90 100644
--- a/api/server/routes/agents/index.js
+++ b/api/server/routes/agents/index.js
@@ -169,6 +169,13 @@ router.get('/chat/status/:conversationId', async (req, res) => {
   const resumeState = await GenerationJobManager.getResumeState(conversationId);
   const isActive = job.status === 'running';
 
+  logger.debug('[GET /api/agents/chat/status/:conversationId] Job status check', {
+    conversationId,
+    jobStatus: job.status,
+    isActive,
+    userId: req.user.id,
+  });
+
   res.json({
     active: isActive,
     streamId: conversationId,
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index bb9c4ebea95a..3081a7904a17 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -44,6 +44,7 @@ router.get('/', async (req, res) => {
     const result = await getConvosByCursor(req.user.id, {
       cursor,
       limit,
+      req, // Pass req for Solid storage support
       isArchived,
       tags,
       search,
@@ -52,19 +53,55 @@ router.get('/', async (req, res) => {
     });
     res.status(200).json(result);
   } catch (error) {
-    logger.error('Error fetching conversations', error);
-    res.status(500).json({ error: 'Error fetching conversations' });
+    logger.error('Error fetching conversations', {
+      error: error.message,
+      stack: error.stack,
+      userId: req.user?.id,
+      hasOpenidId: !!req.user?.openidId,
+      useSolidStorage: process.env.USE_SOLID_STORAGE,
+    });
+    res.status(500).json({ 
+      error: 'Error fetching conversations',
+      message: error.message, // Include actual error message for debugging
+    });
   }
 });
 
 router.get('/:conversationId', async (req, res) => {
   const { conversationId } = req.params;
-  const convo = await getConvo(req.user.id, conversationId);
-
-  if (convo) {
-    res.status(200).json(convo);
-  } else {
-    res.status(404).end();
+  
+  logger.info('[GET /api/convos/:conversationId] Fetching conversation', {
+    conversationId,
+    userId: req.user?.id,
+    hasOpenidId: !!req.user?.openidId,
+    useSolidStorage: isEnabled(process.env.USE_SOLID_STORAGE),
+  });
+  
+  try {
+    const convo = await getConvo(req.user.id, conversationId, req);
+
+    if (convo) {
+      logger.info('[GET /api/convos/:conversationId] Conversation found', {
+        conversationId,
+        title: convo.title,
+        messageCount: convo.messages?.length || 0,
+      });
+      res.status(200).json(convo);
+    } else {
+      logger.warn('[GET /api/convos/:conversationId] Conversation not found', {
+        conversationId,
+        userId: req.user?.id,
+      });
+      res.status(404).end();
+    }
+  } catch (error) {
+    logger.error('[GET /api/convos/:conversationId] Error fetching conversation', {
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+      userId: req.user?.id,
+    });
+    res.status(500).json({ error: 'Error fetching conversation', message: error.message });
   }
 });
 
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index c208e9c40673..4bb4280854cc 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -2,7 +2,7 @@ const express = require('express');
 const { v4: uuidv4 } = require('uuid');
 const { logger } = require('@librechat/data-schemas');
 const { ContentTypes } = require('librechat-data-provider');
-const { unescapeLaTeX, countTokens } = require('@librechat/api');
+const { unescapeLaTeX, countTokens, isEnabled } = require('@librechat/api');
 const {
   saveConvo,
   getMessage,
@@ -15,6 +15,9 @@ const { findAllArtifacts, replaceArtifactContent } = require('~/server/services/
 const { requireJwtAuth, validateMessageReq } = require('~/server/middleware');
 const { getConvosQueried } = require('~/models/Conversation');
 const { Message } = require('~/db/models');
+const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
+
+const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
 
 const router = express.Router();
 router.use(requireJwtAuth);
@@ -40,28 +43,99 @@ router.get('/', async (req, res) => {
     const sortOrder = sortDirection === 'asc' ? 1 : -1;
 
     if (conversationId && messageId) {
-      const message = await Message.findOne({
-        conversationId,
-        messageId,
-        user: user,
-      }).lean();
-      response = { messages: message ? [message] : [], nextCursor: null };
-    } else if (conversationId) {
-      const filter = { conversationId, user: user };
-      if (cursor) {
-        filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
+      // Use Solid storage if enabled
+      if (USE_SOLID_STORAGE && req.user?.openidId) {
+        try {
+          const allMessages = await getMessagesFromSolid(req, conversationId);
+          const message = allMessages.find(m => m.messageId === messageId);
+          response = { messages: message ? [message] : [], nextCursor: null };
+        } catch (error) {
+          logger.error('Error getting message from Solid Pod, falling back to MongoDB', error);
+          // Fallback to MongoDB
+          const message = await Message.findOne({
+            conversationId,
+            messageId,
+            user: user,
+          }).lean();
+          response = { messages: message ? [message] : [], nextCursor: null };
+        }
+      } else {
+        // MongoDB storage
+        const message = await Message.findOne({
+          conversationId,
+          messageId,
+          user: user,
+        }).lean();
+        response = { messages: message ? [message] : [], nextCursor: null };
       }
-      const messages = await Message.find(filter)
-        .sort({ [sortField]: sortOrder })
-        .limit(pageSize + 1)
-        .lean();
-      let nextCursor = null;
-      if (messages.length > pageSize) {
-        messages.pop(); // Remove extra item used to detect next page
-        // Create cursor from the last RETURNED item (not the popped one)
-        nextCursor = messages[messages.length - 1][sortField];
+    } else if (conversationId) {
+      // Use Solid storage if enabled
+      if (USE_SOLID_STORAGE && req.user?.openidId) {
+        try {
+          const allMessages = await getMessagesFromSolid(req, conversationId);
+          
+          // Apply sorting
+          allMessages.sort((a, b) => {
+            const aVal = a[sortField] || 0;
+            const bVal = b[sortField] || 0;
+            return sortOrder === 1 ? aVal - bVal : bVal - aVal;
+          });
+          
+          // Apply cursor filtering if provided
+          let filteredMessages = allMessages;
+          if (cursor) {
+            filteredMessages = allMessages.filter(msg => {
+              const msgVal = msg[sortField] || 0;
+              return sortOrder === 1 ? msgVal > cursor : msgVal < cursor;
+            });
+          }
+          
+          // Apply pagination
+          const messages = filteredMessages.slice(0, pageSize + 1);
+          let nextCursor = null;
+          if (messages.length > pageSize) {
+            messages.pop(); // Remove extra item used to detect next page
+            // Create cursor from the last RETURNED item (not the popped one)
+            nextCursor = messages[messages.length - 1][sortField];
+          }
+          response = { messages, nextCursor };
+        } catch (error) {
+          logger.error('Error getting messages from Solid Pod, falling back to MongoDB', error);
+          // Fallback to MongoDB
+          const filter = { conversationId, user: user };
+          if (cursor) {
+            filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
+          }
+          const messages = await Message.find(filter)
+            .sort({ [sortField]: sortOrder })
+            .limit(pageSize + 1)
+            .lean();
+          let nextCursor = null;
+          if (messages.length > pageSize) {
+            messages.pop(); // Remove extra item used to detect next page
+            // Create cursor from the last RETURNED item (not the popped one)
+            nextCursor = messages[messages.length - 1][sortField];
+          }
+          response = { messages, nextCursor };
+        }
+      } else {
+        // MongoDB storage
+        const filter = { conversationId, user: user };
+        if (cursor) {
+          filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
+        }
+        const messages = await Message.find(filter)
+          .sort({ [sortField]: sortOrder })
+          .limit(pageSize + 1)
+          .lean();
+        let nextCursor = null;
+        if (messages.length > pageSize) {
+          messages.pop(); // Remove extra item used to detect next page
+          // Create cursor from the last RETURNED item (not the popped one)
+          nextCursor = messages[messages.length - 1][sortField];
+        }
+        response = { messages, nextCursor };
       }
-      response = { messages, nextCursor };
     } else if (search) {
       const searchResults = await Message.meiliSearch(search, { filter: `user = "${user}"` }, true);
 
@@ -283,8 +357,28 @@ router.post('/artifact/:messageId', async (req, res) => {
 router.get('/:conversationId', validateMessageReq, async (req, res) => {
   try {
     const { conversationId } = req.params;
-    const messages = await getMessages({ conversationId }, '-_id -__v -user');
-    res.status(200).json(messages);
+    
+    // Use Solid storage if enabled
+    if (USE_SOLID_STORAGE && req.user?.openidId) {
+      try {
+        const messages = await getMessagesFromSolid(req, conversationId);
+        // Remove internal fields for response
+        const cleanedMessages = messages.map(msg => {
+          const { _id, __v, user, ...rest } = msg;
+          return rest;
+        });
+        res.status(200).json(cleanedMessages);
+      } catch (error) {
+        logger.error('Error getting messages from Solid Pod, falling back to MongoDB', error);
+        // Fallback to MongoDB
+        const messages = await getMessages({ conversationId }, '-_id -__v -user');
+        res.status(200).json(messages);
+      }
+    } else {
+      // MongoDB storage
+      const messages = await getMessages({ conversationId }, '-_id -__v -user');
+      res.status(200).json(messages);
+    }
   } catch (error) {
     logger.error('Error fetching messages:', error);
     res.status(500).json({ error: 'Internal server error' });
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index ecc4749255f4..8a365e6bce1a 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -25,7 +25,50 @@ const domains = {
 router.use(logHeaders);
 router.use(loginLimiter);
 
-const oauthHandler = createOAuthHandler();
+const oauthHandler = async (req, res, next) => {
+  try {
+    if (res.headersSent) {
+      return;
+    }
+
+    await checkBan(req, res);
+    if (req.banned) {
+      return;
+    }
+    if (
+      req.user &&
+      req.user.provider == 'openid' &&
+      // isEnabled(process.env.OPENID_REUSE_TOKENS) === true
+      req.user.tokenset &&
+      req.user.tokenset.access_token
+    ) {
+      // Always store OpenID tokens in session (needed for Solid Pod access)
+      setOpenIDAuthTokens(req.user.tokenset, req, res, req.user._id.toString());
+      logger.info('[oauthHandler] OpenID tokens stored for Solid Pod access', {
+        userId: req.user._id.toString(),
+        hasAccessToken: !!req.user.tokenset.access_token,
+        hasRefreshToken: !!req.user.tokenset.refresh_token,
+      });
+      
+      // Also create JWT tokens for frontend authentication
+      // OPENID_REUSE_TOKENS determines if we use OpenID JWT or standard JWT
+      if (isEnabled(process.env.OPENID_REUSE_TOKENS) === true) {
+        await syncUserEntraGroupMemberships(req.user, req.user.tokenset.access_token);
+        // When OPENID_REUSE_TOKENS is enabled, setOpenIDAuthTokens handles JWT creation
+        // via the openidJwt strategy, so we don't need to call setAuthTokens
+      } else {
+        // When OPENID_REUSE_TOKENS is disabled, create standard JWT tokens
+        await setAuthTokens(req.user._id, res);
+      }
+    } else {
+      await setAuthTokens(req.user._id, res);
+    }
+    res.redirect(domains.client);
+  } catch (err) {
+    logger.error('Error in setting authentication tokens:', err);
+    next(err);
+  }
+};
 
 router.get('/error', (req, res) => {
   /** A single error message is pushed by passport when authentication fails. */
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index ef50a365b9ae..43468190d408 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -448,6 +448,8 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
 
     const refreshToken = tokenset.refresh_token || existingRefreshToken;
 
+    // Log warning if no refresh token, but continue with access token only
+    // Some providers (like Solid) may not provide refresh tokens
     if (!refreshToken) {
       logger.error('[setOpenIDAuthTokens] No refresh token available');
       return;
@@ -483,17 +485,49 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
       req.session.openidTokens = {
         accessToken: tokenset.access_token,
         idToken: tokenset.id_token,
-        refreshToken: refreshToken,
+        refreshToken: refreshToken || null, // Store null if no refresh token
         expiresAt: expirationDate.getTime(),
       };
+      
+      // Explicitly save the session to ensure it persists
+      req.session.save((err) => {
+        if (err) {
+          logger.error('[setOpenIDAuthTokens] Error saving session', {
+            error: err.message,
+            stack: err.stack,
+          });
+        } else {
+          logger.debug('[setOpenIDAuthTokens] Session saved successfully');
+        }
+      });
+      
+      logger.info('[setOpenIDAuthTokens] Tokens stored in session', {
+        hasAccessToken: !!tokenset.access_token,
+        hasRefreshToken: !!refreshToken,
+        sessionId: req.sessionID,
+        accessTokenLength: tokenset.access_token?.length,
+        expiresAt: expirationDate.toISOString(),
+      });
     } else {
       logger.warn('[setOpenIDAuthTokens] No session available, falling back to cookies');
+      if (refreshToken) {
+        res.cookie('refreshToken', refreshToken, {
+          expires: expirationDate,
+          httpOnly: true,
+          secure: isProduction,
+          sameSite: 'strict',
+        });
+      }
       res.cookie('openid_access_token', tokenset.access_token, {
         expires: expirationDate,
         httpOnly: true,
         secure: shouldUseSecureCookie(),
         sameSite: 'strict',
       });
+      logger.info('[setOpenIDAuthTokens] Tokens stored in cookies', {
+        hasAccessToken: !!tokenset.access_token,
+        hasRefreshToken: !!refreshToken,
+      });
       if (tokenset.id_token) {
         res.cookie('openid_id_token', tokenset.id_token, {
           expires: expirationDate,
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
new file mode 100644
index 000000000000..b665ac14a133
--- /dev/null
+++ b/api/server/services/SolidStorage.js
@@ -0,0 +1,1930 @@
+const { logger } = require('@librechat/data-schemas');
+const fetch = require('node-fetch');
+const {
+  getFile,
+  saveFileInContainer,
+  overwriteFile,
+  deleteFile,
+  getPodUrlAll,
+  createContainerAt,
+} = require('@inrupt/solid-client');
+
+/**
+ * Solid Storage Utility Module
+ * 
+ * This module provides functions to interact with Solid Pods for storing
+ * and retrieving messages and conversations.
+ * 
+ * Storage Structure:
+ * {podUrl}/librechat/
+ *   ├── conversations/
+ *   │   └── {conversationId}.json
+ *   └── messages/
+ *       └── {conversationId}/
+ *           └── {messageId}.json
+ */
+
+/**
+ * Get authenticated fetch function from Solid session
+ * 
+ * @param {Object} req - Express request object
+ * @returns {Promise<Function>} Authenticated fetch function
+ */
+async function getSolidFetch(req) {
+  try {
+    logger.debug('[SolidStorage] Getting authenticated fetch from session', {
+      hasSession: !!req.session,
+      sessionId: req.sessionID,
+      hasUser: !!req.user,
+      userId: req.user?.id,
+      openidId: req.user?.openidId,
+    });
+
+    // Check if user is authenticated with Solid/OpenID
+    if (!req.user || !req.user.openidId) {
+      logger.error('[SolidStorage] User not authenticated with Solid/OpenID', {
+        hasUser: !!req.user,
+        hasOpenidId: !!req.user?.openidId,
+      });
+      throw new Error('User not authenticated with Solid/OpenID');
+    }
+
+    let accessToken = null;
+    let tokenSource = 'unknown';
+
+    // Try to get access token from multiple sources (in order of preference)
+    
+    // Source 1: Session (tokens stored during OAuth callback)
+    const openidTokens = req.session?.openidTokens;
+    if (openidTokens && openidTokens.accessToken) {
+      accessToken = openidTokens.accessToken;
+      tokenSource = 'session';
+      logger.debug('[SolidStorage] Access token found in session', {
+        tokenLength: accessToken?.length,
+        expiresAt: openidTokens.expiresAt,
+        isExpired: openidTokens.expiresAt ? Date.now() > openidTokens.expiresAt : 'unknown',
+      });
+    }
+    
+    // Source 2: Cookies (fallback if session not available)
+    if (!accessToken && req.cookies?.openid_access_token) {
+      accessToken = req.cookies.openid_access_token;
+      tokenSource = 'cookies';
+      logger.debug('[SolidStorage] Access token found in cookies', {
+        tokenLength: accessToken?.length,
+      });
+    }
+    
+    // Source 3: User object tokenset (from OAuth callback - if stored in DB)
+    if (!accessToken && req.user.tokenset && req.user.tokenset.access_token) {
+      accessToken = req.user.tokenset.access_token;
+      tokenSource = 'user.tokenset';
+      logger.debug('[SolidStorage] Access token found in user.tokenset', {
+        tokenLength: accessToken?.length,
+      });
+    }
+    
+    // Source 4: User object federatedTokens (from OAuth callback - if stored in DB)
+    if (!accessToken && req.user.federatedTokens && req.user.federatedTokens.access_token) {
+      accessToken = req.user.federatedTokens.access_token;
+      tokenSource = 'user.federatedTokens';
+      logger.debug('[SolidStorage] Access token found in user.federatedTokens', {
+        tokenLength: accessToken?.length,
+      });
+    }
+
+    if (!accessToken) {
+      // Check if session exists but wasn't loaded
+      const sessionCookie = req.cookies?.['connect.sid'] || req.cookies?.connect_sid;
+      logger.error('[SolidStorage] No OpenID access token found in any source', {
+        hasSession: !!req.session,
+        sessionId: req.sessionID,
+        hasSessionCookie: !!sessionCookie,
+        sessionCookieName: sessionCookie ? 'present' : 'missing',
+        hasOpenidTokens: !!openidTokens,
+        hasCookies: !!req.cookies,
+        hasOpenidCookie: !!req.cookies?.openid_access_token,
+        hasTokenset: !!req.user.tokenset,
+        hasFederatedTokens: !!req.user.federatedTokens,
+        sessionHasAccessToken: !!openidTokens?.accessToken,
+        tokensetHasAccessToken: !!req.user.tokenset?.access_token,
+        federatedTokensHasAccessToken: !!req.user.federatedTokens?.access_token,
+        cookieKeys: req.cookies ? Object.keys(req.cookies) : [],
+        allCookies: req.cookies ? Object.keys(req.cookies).join(', ') : 'none',
+      });
+      throw new Error('No OpenID access token found. Make sure you logged in via Solid-OIDC and the session is maintained.');
+    }
+    logger.info('[SolidStorage] Access token retrieved', {
+      tokenSource,
+      tokenLength: accessToken?.length,
+      tokenPrefix: accessToken?.substring(0, 20) + '...',
+    });
+
+    // Create authenticated fetch function
+    // The access token will be used in Authorization header
+    const authenticatedFetch = async (url, options = {}) => {
+      const headers = {
+        ...options.headers,
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': options.headers?.['Content-Type'] || 'application/json',
+      };
+
+      logger.debug('[SolidStorage] Making authenticated request', {
+        url: url.toString(),
+        method: options.method || 'GET',
+        hasAuthHeader: !!headers.Authorization,
+      });
+
+      try {
+        const response = await fetch(url, {
+          ...options,
+          headers,
+        });
+
+        logger.debug('[SolidStorage] Request response', {
+          url: url.toString(),
+          status: response.status,
+          statusText: response.statusText,
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => 'Unable to read error response');
+          logger.error('[SolidStorage] Request failed', {
+            url: url.toString(),
+            status: response.status,
+            statusText: response.statusText,
+            error: errorText,
+          });
+        }
+
+        return response;
+      } catch (error) {
+        logger.error('[SolidStorage] Fetch error', {
+          url: url.toString(),
+          error: error.message,
+          stack: error.stack,
+        });
+        throw error;
+      }
+    };
+
+    logger.info('[SolidStorage] Authenticated fetch function created successfully');
+    return authenticatedFetch;
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting authenticated fetch', {
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get user's Pod URL from their WebID
+ * 
+ * @param {string} webId - User's WebID
+ * @param {Function} fetch - Authenticated fetch function
+ * @returns {Promise<string>} Primary Pod URL
+ */
+async function getPodUrl(webId, fetch) {
+  try {
+    logger.debug('[SolidStorage] Getting Pod URL from WebID', { webId });
+
+    if (!webId) {
+      logger.error('[SolidStorage] WebID is required');
+      throw new Error('WebID is required');
+    }
+
+    if (!fetch) {
+      logger.error('[SolidStorage] Fetch function is required');
+      throw new Error('Fetch function is required');
+    }
+
+    // Try to get Pod URLs from profile
+    let podUrls = [];
+    try {
+      podUrls = await getPodUrlAll(webId, { fetch });
+      logger.debug('[SolidStorage] Pod URLs retrieved from profile', {
+        webId,
+        podCount: podUrls?.length || 0,
+        podUrls: podUrls || [],
+      });
+    } catch (error) {
+      logger.warn('[SolidStorage] Failed to get Pod URLs from profile, will try fallback', {
+        webId,
+        error: error.message,
+      });
+    }
+
+    // If no Pod URLs found, derive from WebID as fallback
+    if (!podUrls || podUrls.length === 0) {
+      logger.info('[SolidStorage] No Pod URLs found in profile, deriving from WebID', { webId });
+      
+      // Extract base URL from WebID
+      // WebID format: http://localhost:3000/bisi/profile/card#me
+      // Pod URL format: http://localhost:3000/bisi/
+      try {
+        const webIdUrl = new URL(webId);
+        // Remove the fragment (#me) and path segments after the pod identifier
+        // For most Solid servers, the Pod is at the root or one level deep
+        // Pattern: http://host:port/podId/ -> Pod URL
+        const pathParts = webIdUrl.pathname.split('/').filter(p => p);
+        
+        // If path contains 'profile', 'card', or similar, remove them
+        // The Pod is usually at the base or one level up
+        let podPath = '/';
+        if (pathParts.length > 0) {
+          // For pattern like /bisi/profile/card, Pod is at /bisi/
+          // For pattern like /profile/card, Pod is at /
+          const podIdentifier = pathParts[0];
+          if (podIdentifier && podIdentifier !== 'profile' && podIdentifier !== 'card') {
+            podPath = `/${podIdentifier}/`;
+          }
+        }
+        
+        const derivedPodUrl = `${webIdUrl.protocol}//${webIdUrl.host}${podPath}`;
+        logger.info('[SolidStorage] Derived Pod URL from WebID', {
+          webId,
+          derivedPodUrl,
+          pathParts,
+        });
+        
+        // Verify the Pod URL is accessible by trying to fetch the root
+        try {
+          const response = await fetch(derivedPodUrl, {
+            method: 'HEAD',
+          });
+          if (response.ok || response.status === 401 || response.status === 403) {
+            // 401/403 means the Pod exists but we need auth (which is expected)
+            logger.info('[SolidStorage] Derived Pod URL is accessible', {
+              derivedPodUrl,
+              status: response.status,
+            });
+            return derivedPodUrl;
+          }
+        } catch (verifyError) {
+          logger.warn('[SolidStorage] Could not verify derived Pod URL, using it anyway', {
+            derivedPodUrl,
+            error: verifyError.message,
+          });
+        }
+        
+        return derivedPodUrl;
+      } catch (urlError) {
+        logger.error('[SolidStorage] Failed to derive Pod URL from WebID', {
+          webId,
+          error: urlError.message,
+        });
+        throw new Error(`Could not determine Pod URL from WebID: ${webId}`);
+      }
+    }
+
+    const primaryPodUrl = podUrls[0];
+    logger.info('[SolidStorage] Primary Pod URL determined', {
+      webId,
+      primaryPodUrl,
+      totalPods: podUrls.length,
+    });
+
+    return primaryPodUrl;
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting Pod URL', {
+      webId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get base storage path for LibreChat data in Pod
+ * 
+ * @param {string} podUrl - Pod URL
+ * @returns {string} Base storage path
+ */
+function getBaseStoragePath(podUrl) {
+  const basePath = `${podUrl}librechat/`;
+  logger.debug('[SolidStorage] Base storage path', { podUrl, basePath });
+  return basePath;
+}
+
+/**
+ * Get conversation file path
+ * 
+ * @param {string} podUrl - Pod URL
+ * @param {string} conversationId - Conversation ID
+ * @returns {string} Conversation file path
+ */
+function getConversationPath(podUrl, conversationId) {
+  const path = `${getBaseStoragePath(podUrl)}conversations/${conversationId}.json`;
+  logger.debug('[SolidStorage] Conversation path', { conversationId, path });
+  return path;
+}
+
+/**
+ * Get messages container path for a conversation
+ * 
+ * @param {string} podUrl - Pod URL
+ * @param {string} conversationId - Conversation ID
+ * @returns {string} Messages container path
+ */
+function getMessagesContainerPath(podUrl, conversationId) {
+  const path = `${getBaseStoragePath(podUrl)}messages/${conversationId}/`;
+  logger.debug('[SolidStorage] Messages container path', { conversationId, path });
+  return path;
+}
+
+/**
+ * Get message file path
+ * 
+ * @param {string} podUrl - Pod URL
+ * @param {string} conversationId - Conversation ID
+ * @param {string} messageId - Message ID
+ * @returns {string} Message file path
+ */
+function getMessagePath(podUrl, conversationId, messageId) {
+  const path = `${getMessagesContainerPath(podUrl, conversationId)}${messageId}.json`;
+  logger.debug('[SolidStorage] Message path', { conversationId, messageId, path });
+  return path;
+}
+
+/**
+ * Ensure container exists, create if it doesn't
+ * 
+ * @param {string} containerUrl - Container URL
+ * @param {Function} fetch - Authenticated fetch function
+ * @returns {Promise<void>}
+ */
+async function ensureContainerExists(containerUrl, fetch) {
+  try {
+    logger.debug('[SolidStorage] Ensuring container exists', { containerUrl });
+
+    try {
+      // Try to check if container exists using HEAD request
+      const response = await fetch(containerUrl, {
+        method: 'HEAD',
+      });
+      
+      if (response.ok || response.status === 200 || response.status === 405) {
+        // Container exists (405 Method Not Allowed is also OK - means container exists but doesn't support HEAD)
+        logger.debug('[SolidStorage] Container already exists', { 
+          containerUrl,
+          status: response.status,
+        });
+        return;
+      }
+      
+      // If we get here, container might not exist
+      if (response.status === 404) {
+        throw new Error('Container not found');
+      }
+    } catch (error) {
+      // Container doesn't exist, create it
+      if (error.status === 404 || error.message?.includes('404') || error.message?.includes('not found') || error.message?.includes('Container not found')) {
+        logger.info('[SolidStorage] Container does not exist, creating', { containerUrl });
+        try {
+          await createContainerAt(containerUrl, { fetch });
+          logger.info('[SolidStorage] Container created successfully', { containerUrl });
+        } catch (createError) {
+          // If creation fails with 409, container already exists (race condition)
+          if (createError.status === 409 || createError.message?.includes('409') || createError.message?.includes('already exists')) {
+            logger.debug('[SolidStorage] Container already exists (race condition)', { containerUrl });
+            return;
+          }
+          throw createError;
+        }
+      } else {
+        logger.error('[SolidStorage] Error checking container existence', {
+          containerUrl,
+          error: error.message,
+          errorStatus: error.status,
+        });
+        throw error;
+      }
+    }
+  } catch (error) {
+    logger.error('[SolidStorage] Error ensuring container exists', {
+      containerUrl,
+      error: error.message,
+      errorStatus: error.status,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Ensure base storage structure exists
+ * 
+ * @param {string} podUrl - Pod URL
+ * @param {Function} fetch - Authenticated fetch function
+ * @returns {Promise<void>}
+ */
+async function ensureBaseStructure(podUrl, fetch) {
+  try {
+    logger.debug('[SolidStorage] Ensuring base storage structure exists', { podUrl });
+
+    const basePath = getBaseStoragePath(podUrl);
+    const conversationsPath = `${basePath}conversations/`;
+    const messagesPath = `${basePath}messages/`;
+
+    // Ensure base librechat container
+    await ensureContainerExists(basePath, fetch);
+
+    // Ensure conversations container
+    await ensureContainerExists(conversationsPath, fetch);
+
+    // Ensure messages container
+    await ensureContainerExists(messagesPath, fetch);
+
+    logger.info('[SolidStorage] Base storage structure ensured', {
+      podUrl,
+      basePath,
+      conversationsPath,
+      messagesPath,
+    });
+  } catch (error) {
+    logger.error('[SolidStorage] Error ensuring base structure', {
+      podUrl,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Save a message to Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} messageData - Message data to save
+ * @param {string} messageData.messageId - Message ID
+ * @param {string} messageData.conversationId - Conversation ID
+ * @param {string} messageData.text - Message text
+ * @param {string} messageData.sender - Sender identifier
+ * @param {boolean} messageData.isCreatedByUser - Whether message was created by user
+ * @param {string} messageData.endpoint - Endpoint where message originated
+ * @param {string} [messageData.parentMessageId] - Parent message ID
+ * @param {string} [messageData.error] - Error message
+ * @param {boolean} [messageData.unfinished] - Whether message is unfinished
+ * @param {Array} [messageData.files] - Files associated with message
+ * @param {string} [messageData.finish_reason] - Finish reason
+ * @param {number} [messageData.tokenCount] - Token count
+ * @param {string} [messageData.plugin] - Plugin name
+ * @param {Array} [messageData.plugins] - Plugin array
+ * @param {string} [messageData.model] - Model used
+ * @param {Date} [messageData.expiredAt] - Expiration date
+ * @param {Object} [metadata] - Additional metadata
+ * @returns {Promise<Object>} Saved message data
+ */
+async function saveMessageToSolid(req, messageData, metadata) {
+  try {
+    logger.info('[SolidStorage] Saving message to Solid Pod', {
+      messageId: messageData.messageId,
+      conversationId: messageData.conversationId,
+      context: metadata?.context,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!messageData.messageId) {
+      throw new Error('messageId is required');
+    }
+
+    if (!messageData.conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Ensure base structure exists
+    await ensureBaseStructure(podUrl, authenticatedFetch);
+
+    // Ensure messages container for this conversation exists
+    const messagesContainerPath = getMessagesContainerPath(podUrl, messageData.conversationId);
+    await ensureContainerExists(messagesContainerPath, authenticatedFetch);
+
+    // Prepare message object with all fields
+    const messageToSave = {
+      messageId: messageData.newMessageId || messageData.messageId,
+      conversationId: messageData.conversationId,
+      user: req.user.id,
+      text: messageData.text || '',
+      content: messageData.content || undefined, // For agent endpoints, content is an array
+      sender: messageData.sender,
+      isCreatedByUser: messageData.isCreatedByUser,
+      endpoint: messageData.endpoint,
+      parentMessageId: messageData.parentMessageId || null,
+      error: messageData.error || null,
+      unfinished: messageData.unfinished || false,
+      files: messageData.files || [],
+      finish_reason: messageData.finish_reason || null,
+      tokenCount: messageData.tokenCount || 0,
+      plugin: messageData.plugin || null,
+      plugins: messageData.plugins || [],
+      model: messageData.model || null,
+      expiredAt: messageData.expiredAt || null,
+      createdAt: messageData.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    // Get message file path
+    const messagePath = getMessagePath(
+      podUrl,
+      messageData.conversationId,
+      messageToSave.messageId
+    );
+
+    // Convert message to JSON string
+    const messageJson = JSON.stringify(messageToSave, null, 2);
+    
+    // Use Buffer for Node.js compatibility (Blob is available in Node 18+ but Buffer is more universal)
+    const messageBuffer = Buffer.from(messageJson, 'utf-8');
+
+    logger.debug('[SolidStorage] Saving message file', {
+      messagePath,
+      messageId: messageToSave.messageId,
+      conversationId: messageToSave.conversationId,
+      textLength: messageToSave.text?.length || 0,
+      hasContent: !!messageToSave.content,
+      contentLength: Array.isArray(messageToSave.content) ? messageToSave.content.length : 0,
+      contentTypes: Array.isArray(messageToSave.content) 
+        ? messageToSave.content.map(c => c?.type).filter(Boolean)
+        : [],
+      bufferSize: messageBuffer.length,
+    });
+
+    // Check if message already exists (for update vs create)
+    let messageExists = false;
+    try {
+      await getFile(messagePath, { fetch: authenticatedFetch });
+      messageExists = true;
+      logger.debug('[SolidStorage] Message file already exists, will overwrite', {
+        messagePath,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        messageExists = false;
+        logger.debug('[SolidStorage] Message file does not exist, will create', {
+          messagePath,
+        });
+      } else {
+        // Some other error occurred, log it but continue
+        logger.warn('[SolidStorage] Error checking if message exists, will try to save anyway', {
+          messagePath,
+          error: error.message,
+        });
+      }
+    }
+
+    // Save or overwrite the message file
+    if (messageExists) {
+      await overwriteFile(messagePath, messageBuffer, {
+        contentType: 'application/json',
+        fetch: authenticatedFetch,
+      });
+      logger.info('[SolidStorage] Message file overwritten successfully', {
+        messagePath,
+        messageId: messageToSave.messageId,
+      });
+    } else {
+      await saveFileInContainer(messagesContainerPath, messageBuffer, {
+        slug: `${messageToSave.messageId}.json`,
+        contentType: 'application/json',
+        fetch: authenticatedFetch,
+      });
+      logger.info('[SolidStorage] Message file saved successfully', {
+        messagePath,
+        messageId: messageToSave.messageId,
+      });
+    }
+
+    if (metadata?.context) {
+      logger.info(`[SolidStorage] ---saveMessageToSolid context: ${metadata.context}`);
+    }
+
+    return messageToSave;
+  } catch (error) {
+    logger.error('[SolidStorage] Error saving message to Solid Pod', {
+      messageId: messageData?.messageId,
+      conversationId: messageData?.conversationId,
+      error: error.message,
+      stack: error.stack,
+      context: metadata?.context,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get all messages for a conversation from Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {string} conversationId - Conversation ID
+ * @returns {Promise<Array>} Array of message objects, sorted by createdAt
+ */
+async function getMessagesFromSolid(req, conversationId) {
+  try {
+    logger.info('[SolidStorage] Getting messages from Solid Pod', {
+      conversationId,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get messages container path
+    const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
+
+    logger.debug('[SolidStorage] Reading messages container', {
+      messagesContainerPath,
+      conversationId,
+    });
+
+    // Get all files in the messages container
+    // Solid Pods return Turtle (RDF) format with ldp:contains predicates
+    let messageFiles = [];
+    try {
+      const response = await authenticatedFetch(messagesContainerPath, {
+        method: 'GET',
+        headers: {
+          'Accept': 'text/turtle, application/ld+json, */*',
+        },
+      });
+      
+      if (response.status === 404) {
+        // Container doesn't exist, return empty array
+        logger.info('[SolidStorage] Messages container does not exist, returning empty array', {
+          messagesContainerPath,
+        });
+        return [];
+      }
+      
+      if (!response.ok) {
+        throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
+      }
+      
+      // Parse the response (Solid containers return Turtle format)
+      // Format: ldp:contains <item1>, <item2>, <item3>.
+      const text = await response.text();
+      
+      // Parse Turtle format to extract all items from ldp:contains
+      // Handle both single and comma-separated items
+      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
+      const allItems = [];
+      let match;
+      
+      while ((match = ldpContainsPattern.exec(text)) !== null) {
+        // Extract all URLs from the matched group (handles comma-separated items)
+        const itemsString = match[1];
+        const itemPattern = /<([^>]+)>/g;
+        let itemMatch;
+        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
+          const itemUrl = itemMatch[1];
+          // Convert relative URLs to absolute URLs
+          const absoluteUrl = itemUrl.startsWith('http') 
+            ? itemUrl 
+            : new URL(itemUrl, messagesContainerPath).href;
+          allItems.push({ url: absoluteUrl });
+        }
+      }
+      
+      // Filter for JSON files only
+      messageFiles = allItems.filter((item) => {
+        const url = item.url || '';
+        return url.endsWith('.json') && !url.endsWith('.meta.json');
+      });
+      
+      logger.debug('[SolidStorage] Found message files', {
+        conversationId,
+        fileCount: messageFiles.length,
+        files: messageFiles.map(f => f.url),
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        // Container doesn't exist, return empty array
+        logger.info('[SolidStorage] Messages container does not exist, returning empty array', {
+          messagesContainerPath,
+        });
+        return [];
+      }
+      throw error;
+    }
+
+    logger.debug('[SolidStorage] Found message files', {
+      conversationId,
+      fileCount: messageFiles.length,
+    });
+
+    // Read all message files
+    const messages = [];
+    for (const fileInfo of messageFiles) {
+      try {
+        const fileUrl = fileInfo.url;
+        logger.debug('[SolidStorage] Reading message file', {
+          fileUrl,
+          conversationId,
+        });
+
+        const file = await getFile(fileUrl, { fetch: authenticatedFetch });
+        const fileText = await file.text();
+        const messageData = JSON.parse(fileText);
+
+        // Validate that this message belongs to the current user
+        if (messageData.user !== req.user.id) {
+          logger.warn('[SolidStorage] Message belongs to different user, skipping', {
+            messageId: messageData.messageId,
+            messageUserId: messageData.user,
+            currentUserId: req.user.id,
+          });
+          continue;
+        }
+
+        // Validate that this message belongs to the requested conversation
+        if (messageData.conversationId !== conversationId) {
+          logger.warn('[SolidStorage] Message belongs to different conversation, skipping', {
+            messageId: messageData.messageId,
+            messageConversationId: messageData.conversationId,
+            requestedConversationId: conversationId,
+          });
+          continue;
+        }
+
+        messages.push(messageData);
+      } catch (error) {
+        logger.error('[SolidStorage] Error reading message file', {
+          fileUrl: fileInfo.url,
+          conversationId,
+          error: error.message,
+        });
+        // Continue with other files even if one fails
+      }
+    }
+
+    // Sort messages by createdAt (ascending)
+    messages.sort((a, b) => {
+      const dateA = new Date(a.createdAt || 0);
+      const dateB = new Date(b.createdAt || 0);
+      return dateA - dateB;
+    });
+
+    logger.info('[SolidStorage] Messages retrieved successfully', {
+      conversationId,
+      messageCount: messages.length,
+    });
+
+    return messages;
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting messages from Solid Pod', {
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Update an existing message in Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} messageData - Message data to update
+ * @param {string} messageData.messageId - Message ID (required)
+ * @param {string} [messageData.text] - Updated message text
+ * @param {Array} [messageData.files] - Updated files array
+ * @param {boolean} [messageData.isCreatedByUser] - Updated isCreatedByUser flag
+ * @param {string} [messageData.sender] - Updated sender
+ * @param {number} [messageData.tokenCount] - Updated token count
+ * @param {string} [messageData.finish_reason] - Updated finish reason
+ * @param {boolean} [messageData.unfinished] - Updated unfinished flag
+ * @param {string} [messageData.error] - Updated error message
+ * @param {Object} [metadata] - Additional metadata
+ * @returns {Promise<Object>} Updated message data
+ */
+async function updateMessageInSolid(req, messageData, metadata) {
+  try {
+    logger.info('[SolidStorage] Updating message in Solid Pod', {
+      messageId: messageData.messageId,
+      context: metadata?.context,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!messageData.messageId) {
+      throw new Error('messageId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // First, try to get the existing message to merge updates
+    let existingMessage = null;
+    let conversationId = messageData.conversationId;
+
+    // If conversationId is not provided, we need to find it from the existing message
+    if (!conversationId) {
+      logger.warn('[SolidStorage] conversationId not provided in update, searching for message in Pod', {
+        messageId: messageData.messageId,
+        updateFields: Object.keys(messageData),
+      });
+      
+      // Search for the message across all conversation message containers
+      // We'll check the messages container for all conversation subdirectories
+      const basePath = getBaseStoragePath(podUrl);
+      const messagesContainerPath = `${basePath}messages/`;
+      
+      try {
+        // Get list of all conversation directories in messages container
+        const response = await authenticatedFetch(messagesContainerPath, {
+          method: 'GET',
+          headers: {
+            'Accept': 'text/turtle, application/ld+json, */*',
+          },
+        });
+        
+        if (response.ok) {
+          const text = await response.text();
+          // Parse Turtle format to extract conversation directories
+          const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
+          const allItems = [];
+          let match;
+          
+          while ((match = ldpContainsPattern.exec(text)) !== null) {
+            const itemsString = match[1];
+            const itemPattern = /<([^>]+)>/g;
+            let itemMatch;
+            while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
+              const itemUrl = itemMatch[1];
+              // Only include directories (ending with /)
+              if (itemUrl.endsWith('/')) {
+                const absoluteUrl = itemUrl.startsWith('http') 
+                  ? itemUrl 
+                  : new URL(itemUrl, messagesContainerPath).href;
+                allItems.push(absoluteUrl);
+              }
+            }
+          }
+          
+          logger.debug('[SolidStorage] Searching for message across conversation directories', {
+            messageId: messageData.messageId,
+            directoryCount: allItems.length,
+          });
+          
+          // Search each conversation directory for the message
+          for (const conversationDir of allItems) {
+            try {
+              const messageFileUrl = `${conversationDir}${messageData.messageId}.json`;
+              const fileResponse = await authenticatedFetch(messageFileUrl, { method: 'HEAD' });
+              
+              if (fileResponse.ok) {
+                // Found the message! Extract conversationId from the directory path
+                // Format: .../messages/{conversationId}/
+                const pathParts = conversationDir.split('/');
+                const conversationIdIndex = pathParts.findIndex(part => part === 'messages') + 1;
+                if (conversationIdIndex > 0 && pathParts[conversationIdIndex]) {
+                  conversationId = pathParts[conversationIdIndex];
+                  logger.info('[SolidStorage] Found conversationId from message location', {
+                    messageId: messageData.messageId,
+                    conversationId,
+                    searchPath: conversationDir,
+                  });
+                  break;
+                }
+              }
+            } catch (searchError) {
+              // Continue searching other directories
+              logger.debug('[SolidStorage] Message not found in conversation directory', {
+                conversationDir,
+                messageId: messageData.messageId,
+                error: searchError.message,
+              });
+            }
+          }
+        } else {
+          logger.warn('[SolidStorage] Failed to list messages container', {
+            messagesContainerPath,
+            status: response.status,
+            statusText: response.statusText,
+          });
+        }
+      } catch (searchError) {
+        logger.error('[SolidStorage] Error searching for message in Pod', {
+          messageId: messageData.messageId,
+          error: searchError.message,
+          stack: searchError.stack,
+        });
+      }
+      
+      // If we still don't have conversationId, throw error
+      if (!conversationId) {
+        const error = new Error('conversationId is required for updating messages. Could not find message in Pod to determine conversationId.');
+        logger.error('[SolidStorage] Failed to find conversationId for message update', {
+          messageId: messageData.messageId,
+          updateFields: Object.keys(messageData),
+        });
+        throw error;
+      }
+    }
+
+    // Now we have conversationId, get the message path
+    const messagePath = getMessagePath(podUrl, conversationId, messageData.messageId);
+
+    try {
+      const file = await getFile(messagePath, { fetch: authenticatedFetch });
+      const fileText = await file.text();
+      existingMessage = JSON.parse(fileText);
+
+      // Validate that this message belongs to the current user
+      if (existingMessage.user !== req.user.id) {
+        throw new Error('Message does not belong to current user');
+      }
+
+      logger.debug('[SolidStorage] Existing message found', {
+        messageId: messageData.messageId,
+        conversationId,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        throw new Error(`Message with ID ${messageData.messageId} not found`);
+      }
+      throw error;
+    }
+
+    // Merge existing message with updates
+    // Only update content if it's explicitly provided (not undefined)
+    const updatedMessage = {
+      ...existingMessage,
+      ...messageData,
+      // Preserve content if not provided in update (for agent endpoints)
+      content: messageData.content !== undefined ? messageData.content : existingMessage.content,
+      messageId: existingMessage.messageId, // Don't allow changing messageId
+      conversationId: existingMessage.conversationId, // Don't allow changing conversationId
+      user: existingMessage.user, // Don't allow changing user
+      updatedAt: new Date().toISOString(),
+      // Preserve createdAt
+      createdAt: existingMessage.createdAt,
+    };
+
+    // Convert to JSON and create buffer
+    const messageJson = JSON.stringify(updatedMessage, null, 2);
+    const messageBuffer = Buffer.from(messageJson, 'utf-8');
+
+    logger.debug('[SolidStorage] Updating message file', {
+      messagePath,
+      messageId: updatedMessage.messageId,
+      conversationId: updatedMessage.conversationId,
+    });
+
+    // Overwrite the message file
+    await overwriteFile(messagePath, messageBuffer, {
+      contentType: 'application/json',
+      fetch: authenticatedFetch,
+    });
+
+    logger.info('[SolidStorage] Message updated successfully', {
+      messagePath,
+      messageId: updatedMessage.messageId,
+    });
+
+    if (metadata?.context) {
+      logger.info(`[SolidStorage] ---updateMessageInSolid context: ${metadata.context}`);
+    }
+
+    return updatedMessage;
+  } catch (error) {
+    logger.error('[SolidStorage] Error updating message in Solid Pod', {
+      messageId: messageData?.messageId,
+      conversationId: messageData?.conversationId,
+      error: error.message,
+      stack: error.stack,
+      context: metadata?.context,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Delete messages from Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} params - Delete parameters
+ * @param {string} params.conversationId - Conversation ID (required)
+ * @param {string} [params.messageId] - If provided, delete all messages after this message
+ * @param {Array<string>} [params.messageIds] - Specific message IDs to delete
+ * @returns {Promise<number>} Number of messages deleted
+ */
+async function deleteMessagesFromSolid(req, params) {
+  try {
+    logger.info('[SolidStorage] Deleting messages from Solid Pod', {
+      conversationId: params.conversationId,
+      messageId: params.messageId,
+      messageIds: params.messageIds,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!params.conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get messages container path
+    const messagesContainerPath = getMessagesContainerPath(podUrl, params.conversationId);
+
+    // Get all messages for the conversation
+    const allMessages = await getMessagesFromSolid(req, params.conversationId);
+
+    if (allMessages.length === 0) {
+      logger.info('[SolidStorage] No messages found to delete', {
+        conversationId: params.conversationId,
+      });
+      return 0;
+    }
+
+    let messagesToDelete = [];
+
+    // Case 1: Delete messages after a specific messageId
+    if (params.messageId) {
+      const referenceMessage = allMessages.find((msg) => msg.messageId === params.messageId);
+      if (!referenceMessage) {
+        logger.warn('[SolidStorage] Reference message not found', {
+          messageId: params.messageId,
+          conversationId: params.conversationId,
+        });
+        return 0;
+      }
+
+      const referenceDate = new Date(referenceMessage.createdAt || 0);
+      messagesToDelete = allMessages.filter((msg) => {
+        const msgDate = new Date(msg.createdAt || 0);
+        return msgDate > referenceDate;
+      });
+
+      logger.debug('[SolidStorage] Filtering messages after reference message', {
+        referenceMessageId: params.messageId,
+        referenceDate: referenceDate.toISOString(),
+        totalMessages: allMessages.length,
+        messagesToDelete: messagesToDelete.length,
+      });
+    }
+    // Case 2: Delete specific message IDs
+    else if (params.messageIds && Array.isArray(params.messageIds) && params.messageIds.length > 0) {
+      messagesToDelete = allMessages.filter((msg) => params.messageIds.includes(msg.messageId));
+      logger.debug('[SolidStorage] Filtering specific message IDs', {
+        requestedIds: params.messageIds.length,
+        foundMessages: messagesToDelete.length,
+      });
+    }
+    // Case 3: Delete all messages (if neither messageId nor messageIds provided)
+    else {
+      messagesToDelete = allMessages;
+      logger.debug('[SolidStorage] Deleting all messages', {
+        totalMessages: allMessages.length,
+      });
+    }
+
+    if (messagesToDelete.length === 0) {
+      logger.info('[SolidStorage] No messages to delete after filtering', {
+        conversationId: params.conversationId,
+      });
+      return 0;
+    }
+
+    // Delete each message file
+    let deletedCount = 0;
+    for (const message of messagesToDelete) {
+      try {
+        const messagePath = getMessagePath(podUrl, params.conversationId, message.messageId);
+        
+        logger.debug('[SolidStorage] Deleting message file', {
+          messagePath,
+          messageId: message.messageId,
+        });
+
+        await deleteFile(messagePath, { fetch: authenticatedFetch });
+        deletedCount++;
+
+        logger.debug('[SolidStorage] Message file deleted successfully', {
+          messageId: message.messageId,
+        });
+      } catch (error) {
+        if (error.status === 404 || error.message?.includes('404')) {
+          // File already doesn't exist, count it as deleted
+          logger.debug('[SolidStorage] Message file already deleted', {
+            messageId: message.messageId,
+          });
+          deletedCount++;
+        } else {
+          logger.error('[SolidStorage] Error deleting message file', {
+            messageId: message.messageId,
+            error: error.message,
+          });
+          // Continue with other messages even if one fails
+        }
+      }
+    }
+
+    logger.info('[SolidStorage] Messages deleted successfully', {
+      conversationId: params.conversationId,
+      deletedCount,
+      totalRequested: messagesToDelete.length,
+    });
+
+    return deletedCount;
+  } catch (error) {
+    logger.error('[SolidStorage] Error deleting messages from Solid Pod', {
+      conversationId: params?.conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Save a conversation to Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} convoData - Conversation data to save
+ * @param {string} convoData.conversationId - Conversation ID (required)
+ * @param {string} [convoData.newConversationId] - New conversation ID (for renaming)
+ * @param {string} [convoData.title] - Conversation title
+ * @param {string} [convoData.endpoint] - Endpoint where conversation originated
+ * @param {string} [convoData.model] - Model used
+ * @param {string} [convoData.agent_id] - Agent ID
+ * @param {string} [convoData.assistant_id] - Assistant ID
+ * @param {string} [convoData.spec] - Spec
+ * @param {string} [convoData.iconURL] - Icon URL
+ * @param {Array} [convoData.messages] - Array of message references
+ * @param {Array} [convoData.files] - Array of file IDs
+ * @param {string} [convoData.promptPrefix] - Prompt prefix
+ * @param {number} [convoData.temperature] - Temperature setting
+ * @param {number} [convoData.topP] - Top P setting
+ * @param {number} [convoData.presence_penalty] - Presence penalty
+ * @param {number} [convoData.frequency_penalty] - Frequency penalty
+ * @param {Date} [convoData.expiredAt] - Expiration date
+ * @param {Object} [metadata] - Additional metadata
+ * @returns {Promise<Object>} Saved conversation data
+ */
+async function saveConvoToSolid(req, convoData, metadata) {
+  try {
+    logger.info('[SolidStorage] Saving conversation to Solid Pod', {
+      conversationId: convoData.conversationId,
+      newConversationId: convoData.newConversationId,
+      context: metadata?.context,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!convoData.conversationId && !convoData.newConversationId) {
+      throw new Error('conversationId or newConversationId is required');
+    }
+
+    // Use newConversationId if provided, otherwise use conversationId
+    const finalConversationId = convoData.newConversationId || convoData.conversationId;
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Ensure base structure exists
+    await ensureBaseStructure(podUrl, authenticatedFetch);
+
+    // Get conversation file path
+    const conversationPath = getConversationPath(podUrl, finalConversationId);
+
+    // Get messages for this conversation (just IDs for reference)
+    // Note: We call getMessagesFromSolid directly since it's in the same module
+    const messages = await getMessagesFromSolid(req, finalConversationId);
+    const messageRefs = messages.map((msg) => ({
+      messageId: msg.messageId,
+      createdAt: msg.createdAt,
+    }));
+
+    // Prepare conversation object
+    const conversationToSave = {
+      conversationId: finalConversationId,
+      user: req.user.id,
+      title: convoData.title || null,
+      endpoint: convoData.endpoint || null,
+      model: convoData.model || null,
+      agent_id: convoData.agent_id || null,
+      assistant_id: convoData.assistant_id || null,
+      spec: convoData.spec || null,
+      iconURL: convoData.iconURL || null,
+      messages: messageRefs,
+      files: convoData.files || [],
+      promptPrefix: convoData.promptPrefix || null,
+      temperature: convoData.temperature || null,
+      topP: convoData.topP || null,
+      presence_penalty: convoData.presence_penalty || null,
+      frequency_penalty: convoData.frequency_penalty || null,
+      expiredAt: convoData.expiredAt || null,
+      createdAt: convoData.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    // Convert to JSON and create buffer
+    const conversationJson = JSON.stringify(conversationToSave, null, 2);
+    const conversationBuffer = Buffer.from(conversationJson, 'utf-8');
+
+    logger.debug('[SolidStorage] Saving conversation file', {
+      conversationPath,
+      conversationId: finalConversationId,
+      messageCount: messageRefs.length,
+    });
+
+    // Check if conversation already exists
+    let conversationExists = false;
+    try {
+      await getFile(conversationPath, { fetch: authenticatedFetch });
+      conversationExists = true;
+      logger.debug('[SolidStorage] Conversation file already exists, will overwrite', {
+        conversationPath,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        conversationExists = false;
+        logger.debug('[SolidStorage] Conversation file does not exist, will create', {
+          conversationPath,
+        });
+      } else {
+        logger.warn('[SolidStorage] Error checking if conversation exists, will try to save anyway', {
+          conversationPath,
+          error: error.message,
+        });
+      }
+    }
+
+    // If conversationId changed, delete old file
+    if (convoData.newConversationId && convoData.conversationId !== convoData.newConversationId) {
+      const oldConversationPath = getConversationPath(podUrl, convoData.conversationId);
+      try {
+        await deleteFile(oldConversationPath, { fetch: authenticatedFetch });
+        logger.info('[SolidStorage] Old conversation file deleted after rename', {
+          oldConversationPath,
+          newConversationId: convoData.newConversationId,
+        });
+      } catch (error) {
+        if (error.status !== 404) {
+          logger.warn('[SolidStorage] Error deleting old conversation file', {
+            oldConversationPath,
+            error: error.message,
+          });
+        }
+      }
+    }
+
+    // Save or overwrite the conversation file
+    const conversationsContainerPath = `${getBaseStoragePath(podUrl)}conversations/`;
+    if (conversationExists) {
+      await overwriteFile(conversationPath, conversationBuffer, {
+        contentType: 'application/json',
+        fetch: authenticatedFetch,
+      });
+      logger.info('[SolidStorage] Conversation file overwritten successfully', {
+        conversationPath,
+        conversationId: finalConversationId,
+      });
+    } else {
+      await saveFileInContainer(conversationsContainerPath, conversationBuffer, {
+        slug: `${finalConversationId}.json`,
+        contentType: 'application/json',
+        fetch: authenticatedFetch,
+      });
+      logger.info('[SolidStorage] Conversation file saved successfully', {
+        conversationPath,
+        conversationId: finalConversationId,
+      });
+    }
+
+    if (metadata?.context) {
+      logger.info(`[SolidStorage] ---saveConvoToSolid context: ${metadata.context}`);
+    }
+
+    return conversationToSave;
+  } catch (error) {
+    logger.error('[SolidStorage] Error saving conversation to Solid Pod', {
+      conversationId: convoData?.conversationId,
+      newConversationId: convoData?.newConversationId,
+      error: error.message,
+      stack: error.stack,
+      context: metadata?.context,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get a single conversation from Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {string} conversationId - Conversation ID
+ * @returns {Promise<Object|null>} Conversation object or null if not found
+ */
+async function getConvoFromSolid(req, conversationId) {
+  try {
+    logger.info('[SolidStorage] Getting conversation from Solid Pod', {
+      conversationId,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get conversation file path
+    const conversationPath = getConversationPath(podUrl, conversationId);
+
+    logger.debug('[SolidStorage] Reading conversation file', {
+      conversationPath,
+      conversationId,
+    });
+
+    try {
+      const file = await getFile(conversationPath, { fetch: authenticatedFetch });
+      const fileText = await file.text();
+      const conversationData = JSON.parse(fileText);
+
+      // Validate that this conversation belongs to the current user
+      if (conversationData.user !== req.user.id) {
+        logger.warn('[SolidStorage] Conversation belongs to different user', {
+          conversationId,
+          conversationUserId: conversationData.user,
+          currentUserId: req.user.id,
+        });
+        return null;
+      }
+
+      logger.info('[SolidStorage] Conversation retrieved successfully', {
+        conversationId,
+        title: conversationData.title,
+        hasEndpoint: !!conversationData.endpoint,
+        hasModel: !!conversationData.model,
+        messageCount: conversationData.messages?.length || 0,
+        userId: conversationData.user,
+        expectedUserId: req.user.id,
+      });
+
+      return conversationData;
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        logger.info('[SolidStorage] Conversation not found', {
+          conversationId,
+        });
+        return null;
+      }
+      throw error;
+    }
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting conversation from Solid Pod', {
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get conversations with cursor-based pagination from Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} options - Query options
+ * @param {string} [options.cursor] - Base64-encoded cursor for pagination
+ * @param {number} [options.limit=25] - Maximum number of conversations to return
+ * @param {boolean} [options.isArchived=false] - Filter by archived status
+ * @param {Array<string>} [options.tags] - Filter by tags
+ * @param {string} [options.search] - Search query (in-memory text matching)
+ * @param {string} [options.sortBy='updatedAt'] - Sort field: 'title', 'createdAt', or 'updatedAt'
+ * @param {string} [options.sortDirection='desc'] - Sort direction: 'asc' or 'desc'
+ * @returns {Promise<{conversations: Array, nextCursor: string|null}>} Conversations and next cursor
+ */
+async function getConvosByCursorFromSolid(req, options = {}) {
+  try {
+    const {
+      cursor,
+      limit = 25,
+      isArchived = false,
+      tags,
+      search,
+      sortBy = 'updatedAt',
+      sortDirection = 'desc',
+    } = options;
+
+    logger.info('[SolidStorage] Getting conversations with cursor from Solid Pod', {
+      cursor: cursor ? 'present' : 'none',
+      limit,
+      isArchived,
+      tags: tags?.length || 0,
+      search: search || 'none',
+      sortBy,
+      sortDirection,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    // Validate sortBy field
+    const validSortFields = ['title', 'createdAt', 'updatedAt'];
+    if (!validSortFields.includes(sortBy)) {
+      throw new Error(
+        `Invalid sortBy field: ${sortBy}. Must be one of ${validSortFields.join(', ')}`,
+      );
+    }
+
+    const finalSortBy = sortBy;
+    const finalSortDirection = sortDirection === 'asc' ? 'asc' : 'desc';
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get conversations container path
+    const conversationsContainerPath = `${getBaseStoragePath(podUrl)}conversations/`;
+
+    logger.debug('[SolidStorage] Reading conversations container', {
+      conversationsContainerPath,
+    });
+
+    // Get all conversation files
+    // Solid Pods return Turtle (RDF) format with ldp:contains predicates
+    let containerContents = [];
+    try {
+      // Try to get container contents using direct HTTP request
+      const response = await authenticatedFetch(conversationsContainerPath, {
+        method: 'GET',
+        headers: {
+          'Accept': 'text/turtle, application/ld+json, */*',
+        },
+      });
+      
+      if (response.status === 404) {
+        // Container doesn't exist, return empty result
+        logger.info('[SolidStorage] Conversations container does not exist (404), returning empty array', {
+          conversationsContainerPath,
+        });
+        return { conversations: [], nextCursor: null };
+      }
+      
+      if (!response.ok) {
+        throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
+      }
+      
+      // Parse the response as text (Solid containers return Turtle format)
+      // Format: ldp:contains <item1>, <item2>, <item3>.
+      const text = await response.text();
+      
+      // Parse Turtle format to extract all items from ldp:contains
+      // Handle both single and comma-separated items: ldp:contains <item1>, <item2>.
+      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
+      const allItems = [];
+      let match;
+      
+      while ((match = ldpContainsPattern.exec(text)) !== null) {
+        // Extract all URLs from the matched group (handles comma-separated items)
+        const itemsString = match[1];
+        const itemPattern = /<([^>]+)>/g;
+        let itemMatch;
+        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
+          const itemUrl = itemMatch[1];
+          // Convert relative URLs to absolute URLs
+          const absoluteUrl = itemUrl.startsWith('http') 
+            ? itemUrl 
+            : new URL(itemUrl, conversationsContainerPath).href;
+          allItems.push({ url: absoluteUrl });
+        }
+      }
+      
+      containerContents = allItems;
+      
+      logger.debug('[SolidStorage] Container contents retrieved', {
+        conversationsContainerPath,
+        itemCount: containerContents.length,
+        items: containerContents.map(c => c.url),
+      });
+    } catch (error) {
+      // Log full error details for debugging
+      const errorMessage = error?.message || String(error) || 'Unknown error';
+      const errorStatus = error?.status || error?.statusCode || error?.response?.status || 'no status';
+      const errorName = error?.name || 'Unknown';
+      
+      logger.warn('[SolidStorage] Error getting container contents', {
+        conversationsContainerPath,
+        errorMessage,
+        errorName,
+        errorStatus,
+        errorType: typeof error,
+        errorString: String(error),
+        errorKeys: error ? Object.keys(error) : [],
+        hasResponse: !!error?.response,
+        responseStatus: error?.response?.status,
+        responseStatusText: error?.response?.statusText,
+      });
+      
+      // Check if error is a 404 (container doesn't exist)
+      const isNotFound = 
+        errorStatus === 404 || 
+        errorStatus === '404' ||
+        errorMessage?.includes('404') || 
+        errorMessage?.includes('Not Found') ||
+        errorMessage?.toLowerCase().includes('not found') ||
+        errorMessage?.toLowerCase().includes('404');
+      
+      if (isNotFound) {
+        // Container doesn't exist, return empty result (this is expected for new users)
+        logger.info('[SolidStorage] Conversations container does not exist (404), returning empty array', {
+          conversationsContainerPath,
+          errorStatus,
+          errorMessage,
+        });
+        return { conversations: [], nextCursor: null };
+      }
+      
+      // Log unexpected errors but don't throw - return empty array instead
+      // This prevents fallback to MongoDB when Solid storage is enabled
+      logger.warn('[SolidStorage] Unexpected error getting container contents, returning empty array', {
+        conversationsContainerPath,
+        errorMessage,
+        errorName,
+        errorStatus,
+        errorStack: error?.stack,
+      });
+      
+      // Return empty array instead of throwing to avoid MongoDB fallback
+      return { conversations: [], nextCursor: null };
+    }
+
+    // Filter for JSON files only
+    const conversationFiles = Array.from(containerContents).filter((item) => {
+      const url = item.url || '';
+      return url.endsWith('.json') && !url.endsWith('.meta.json');
+    });
+
+    logger.debug('[SolidStorage] Found conversation files', {
+      fileCount: conversationFiles.length,
+    });
+
+    // Read all conversation files
+    const allConversations = [];
+    for (const fileInfo of conversationFiles) {
+      try {
+        const fileUrl = fileInfo.url;
+        const file = await getFile(fileUrl, { fetch: authenticatedFetch });
+        const fileText = await file.text();
+        const conversationData = JSON.parse(fileText);
+
+        // Validate that this conversation belongs to the current user
+        if (conversationData.user !== req.user.id) {
+          continue;
+        }
+
+        allConversations.push(conversationData);
+      } catch (error) {
+        logger.error('[SolidStorage] Error reading conversation file', {
+          fileUrl: fileInfo.url,
+          error: error.message,
+        });
+        // Continue with other files even if one fails
+      }
+    }
+
+    logger.debug('[SolidStorage] All conversations loaded', {
+      totalCount: allConversations.length,
+    });
+
+    // Apply filters
+    let filtered = allConversations;
+
+    // Filter by archived status
+    if (isArchived) {
+      filtered = filtered.filter((convo) => convo.isArchived === true);
+    } else {
+      filtered = filtered.filter(
+        (convo) => !convo.isArchived || convo.isArchived === false,
+      );
+    }
+
+    // Filter by tags
+    if (Array.isArray(tags) && tags.length > 0) {
+      filtered = filtered.filter((convo) => {
+        const convoTags = convo.tags || [];
+        return tags.some((tag) => convoTags.includes(tag));
+      });
+    }
+
+    // Filter out expired conversations
+    filtered = filtered.filter((convo) => {
+      if (!convo.expiredAt) {
+        return true;
+      }
+      const expiredDate = new Date(convo.expiredAt);
+      return expiredDate > new Date();
+    });
+
+    // Apply search (in-memory text matching)
+    if (search) {
+      const searchLower = search.toLowerCase();
+      filtered = filtered.filter((convo) => {
+        const title = (convo.title || '').toLowerCase();
+        return title.includes(searchLower);
+      });
+    }
+
+    // Apply cursor filter
+    if (cursor) {
+      try {
+        const decoded = JSON.parse(Buffer.from(cursor, 'base64').toString());
+        const { primary, secondary } = decoded;
+        const primaryValue = finalSortBy === 'title' ? primary : new Date(primary);
+        const secondaryValue = new Date(secondary);
+        const op = finalSortDirection === 'asc' ? 'gt' : 'lt';
+
+        filtered = filtered.filter((convo) => {
+          const convoPrimary = finalSortBy === 'title' ? convo[finalSortBy] : new Date(convo[finalSortBy]);
+          const convoSecondary = new Date(convo.updatedAt);
+
+          if (op === 'gt') {
+            return (
+              convoPrimary > primaryValue ||
+              (convoPrimary.getTime && convoPrimary.getTime() === primaryValue.getTime() &&
+                convoSecondary > secondaryValue)
+            );
+          } else {
+            return (
+              convoPrimary < primaryValue ||
+              (convoPrimary.getTime && convoPrimary.getTime() === primaryValue.getTime() &&
+                convoSecondary < secondaryValue)
+            );
+          }
+        });
+      } catch (err) {
+        logger.warn('[SolidStorage] Invalid cursor format, starting from beginning', {
+          error: err.message,
+        });
+      }
+    }
+
+    // Sort conversations
+    const sortOrder = finalSortDirection === 'asc' ? 1 : -1;
+    filtered.sort((a, b) => {
+      let aPrimary = a[finalSortBy];
+      let bPrimary = b[finalSortBy];
+
+      if (finalSortBy !== 'title') {
+        aPrimary = new Date(aPrimary || 0);
+        bPrimary = new Date(bPrimary || 0);
+      } else {
+        aPrimary = (aPrimary || '').toLowerCase();
+        bPrimary = (bPrimary || '').toLowerCase();
+      }
+
+      if (aPrimary < bPrimary) {
+        return -1 * sortOrder;
+      }
+      if (aPrimary > bPrimary) {
+        return 1 * sortOrder;
+      }
+
+      // If primary values are equal, sort by updatedAt
+      const aSecondary = new Date(a.updatedAt || 0);
+      const bSecondary = new Date(b.updatedAt || 0);
+      if (aSecondary < bSecondary) {
+        return -1 * sortOrder;
+      }
+      if (aSecondary > bSecondary) {
+        return 1 * sortOrder;
+      }
+      return 0;
+    });
+
+    // Apply limit + 1 to detect if there are more results
+    const limited = filtered.slice(0, limit + 1);
+
+    // Extract next cursor if there are more results
+    let nextCursor = null;
+    if (limited.length > limit) {
+      limited.pop(); // Remove extra item used to detect next page
+      const lastReturned = limited[limited.length - 1];
+      const primaryValue = lastReturned[finalSortBy];
+      const primaryStr = finalSortBy === 'title' ? primaryValue : new Date(primaryValue).toISOString();
+      const secondaryStr = new Date(lastReturned.updatedAt).toISOString();
+      const composite = { primary: primaryStr, secondary: secondaryStr };
+      nextCursor = Buffer.from(JSON.stringify(composite)).toString('base64');
+    }
+
+    // Select only required fields (matching MongoDB behavior)
+    const conversations = limited.map((convo) => ({
+      conversationId: convo.conversationId,
+      endpoint: convo.endpoint,
+      title: convo.title,
+      createdAt: convo.createdAt,
+      updatedAt: convo.updatedAt,
+      user: convo.user,
+      model: convo.model,
+      agent_id: convo.agent_id,
+      assistant_id: convo.assistant_id,
+      spec: convo.spec,
+      iconURL: convo.iconURL,
+    }));
+
+    logger.info('[SolidStorage] Conversations retrieved successfully', {
+      returnedCount: conversations.length,
+      nextCursor: nextCursor ? 'present' : 'none',
+    });
+
+    return { conversations, nextCursor };
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting conversations from Solid Pod', {
+      errorMessage: error.message,
+      errorName: error.name,
+      errorStatus: error.status,
+      errorCode: error.code,
+      stack: error.stack,
+      userId: req.user?.id,
+      openidId: req.user?.openidId,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Delete conversations from Solid Pod
+ * 
+ * @param {Object} req - Express request object
+ * @param {Array<string>} conversationIds - Array of conversation IDs to delete
+ * @returns {Promise<number>} Number of conversations deleted
+ */
+async function deleteConvosFromSolid(req, conversationIds) {
+  try {
+    logger.info('[SolidStorage] Deleting conversations from Solid Pod', {
+      conversationIds,
+      count: conversationIds?.length || 0,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!Array.isArray(conversationIds) || conversationIds.length === 0) {
+      logger.warn('[SolidStorage] No conversation IDs provided for deletion');
+      return 0;
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    let deletedCount = 0;
+
+    // Delete each conversation and its associated messages
+    for (const conversationId of conversationIds) {
+      try {
+        // Get conversation file path
+        const conversationPath = getConversationPath(podUrl, conversationId);
+
+        // Verify conversation belongs to user before deleting
+        try {
+          const conversation = await getConvoFromSolid(req, conversationId);
+          if (!conversation) {
+            logger.warn('[SolidStorage] Conversation not found or does not belong to user', {
+              conversationId,
+            });
+            continue;
+          }
+        } catch (error) {
+          logger.warn('[SolidStorage] Error verifying conversation ownership, skipping', {
+            conversationId,
+            error: error.message,
+          });
+          continue;
+        }
+
+        // Delete all messages for this conversation
+        try {
+          const messagesDeleted = await deleteMessagesFromSolid(req, {
+            conversationId,
+          });
+          logger.debug('[SolidStorage] Messages deleted for conversation', {
+            conversationId,
+            messagesDeleted,
+          });
+        } catch (error) {
+          logger.warn('[SolidStorage] Error deleting messages for conversation, continuing', {
+            conversationId,
+            error: error.message,
+          });
+          // Continue with conversation deletion even if messages fail
+        }
+
+        // Delete the conversation file
+        try {
+          await deleteFile(conversationPath, { fetch: authenticatedFetch });
+          deletedCount++;
+          logger.info('[SolidStorage] Conversation deleted successfully', {
+            conversationId,
+            conversationPath,
+          });
+        } catch (error) {
+          if (error.status === 404 || error.message?.includes('404')) {
+            // File already doesn't exist, count it as deleted
+            deletedCount++;
+            logger.debug('[SolidStorage] Conversation file already deleted', {
+              conversationId,
+            });
+          } else {
+            logger.error('[SolidStorage] Error deleting conversation file', {
+              conversationId,
+              conversationPath,
+              error: error.message,
+            });
+            // Continue with other conversations even if one fails
+          }
+        }
+      } catch (error) {
+        logger.error('[SolidStorage] Error processing conversation deletion', {
+          conversationId,
+          error: error.message,
+        });
+        // Continue with other conversations even if one fails
+      }
+    }
+
+    logger.info('[SolidStorage] Conversations deleted successfully', {
+      requestedCount: conversationIds.length,
+      deletedCount,
+    });
+
+    return deletedCount;
+  } catch (error) {
+    logger.error('[SolidStorage] Error deleting conversations from Solid Pod', {
+      conversationIds,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+module.exports = {
+  getSolidFetch,
+  getPodUrl,
+  getBaseStoragePath,
+  getConversationPath,
+  getMessagesContainerPath,
+  getMessagePath,
+  ensureContainerExists,
+  ensureBaseStructure,
+  saveMessageToSolid,
+  getMessagesFromSolid,
+  updateMessageInSolid,
+  deleteMessagesFromSolid,
+  saveConvoToSolid,
+  getConvoFromSolid,
+  getConvosByCursorFromSolid,
+  deleteConvosFromSolid,
+  // Re-export solid-client functions for convenience
+  getFile,
+  saveFileInContainer,
+  overwriteFile,
+  deleteFile,
+};
diff --git a/api/strategies/jwtStrategy.js b/api/strategies/jwtStrategy.js
index 386b7bafa1be..1c0e9d4766f9 100644
--- a/api/strategies/jwtStrategy.js
+++ b/api/strategies/jwtStrategy.js
@@ -1,13 +1,39 @@
 const { logger } = require('@librechat/data-schemas');
 const { SystemRoles } = require('librechat-data-provider');
 const { Strategy: JwtStrategy, ExtractJwt } = require('passport-jwt');
+const cookies = require('cookie');
 const { getUserById, updateUser } = require('~/models');
 
+// Custom JWT extractor that checks both Authorization header and cookies
+const jwtExtractor = (req) => {
+  // Try Authorization header first (standard way)
+  const authHeader = ExtractJwt.fromAuthHeaderAsBearerToken()(req);
+  if (authHeader) {
+    logger.debug('[jwtStrategy] JWT extracted from Authorization header');
+    return authHeader;
+  }
+
+  // Fallback: Try to extract from cookies (for browser direct access)
+  const cookieHeader = req.headers.cookie;
+  if (cookieHeader) {
+    const parsedCookies = cookies.parse(cookieHeader);
+    // Check for token in cookies (some implementations store it here)
+    if (parsedCookies.token) {
+      logger.debug('[jwtStrategy] JWT extracted from cookie');
+      return parsedCookies.token;
+    }
+  }
+
+  logger.debug('[jwtStrategy] No JWT found in Authorization header or cookies');
+  return null;
+};
+
 // JWT strategy
 const jwtLogin = () =>
   new JwtStrategy(
     {
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      // jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      jwtFromRequest: jwtExtractor,
       secretOrKey: process.env.JWT_SECRET,
     },
     async (payload, done) => {
diff --git a/package-lock.json b/package-lock.json
index 10864619ef0d..0b555e4572b2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -57,6 +57,7 @@
         "@azure/search-documents": "^12.0.0",
         "@azure/storage-blob": "^12.30.0",
         "@google/genai": "^1.19.0",
+        "@inrupt/solid-client": "^1.30.2",
         "@keyv/redis": "^4.3.3",
         "@langchain/core": "^0.3.80",
         "@librechat/agents": "^3.1.55",
@@ -7294,6 +7295,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@bergos/jsonparse": {
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/@bergos/jsonparse/-/jsonparse-1.4.2.tgz",
+      "integrity": "sha512-qUt0QNJjvg4s1zk+AuLM6s/zcsQ8MvGn7+1f0vPuxvpCYa08YtTryuDInngbEyW5fNGGYe2znKt61RMGd5HnXg==",
+      "engines": [
+        "node >= 0.2.0"
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "buffer": "^6.0.3"
+      }
+    },
     "node_modules/@braintree/sanitize-url": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.1.tgz",
@@ -9580,6 +9593,15 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@fastify/busboy": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz",
+      "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/@firebase/analytics": {
       "version": "0.10.10",
       "resolved": "https://registry.npmjs.org/@firebase/analytics/-/analytics-0.10.10.tgz",
@@ -10801,6 +10823,51 @@
         "url": "https://opencollective.com/libvips"
       }
     },
+    "node_modules/@inrupt/solid-client": {
+      "version": "1.30.2",
+      "resolved": "https://registry.npmjs.org/@inrupt/solid-client/-/solid-client-1.30.2.tgz",
+      "integrity": "sha512-8Lwh0ZC1d9c939O+dAsT5oheSKIBX5A0uk7fhaJ0qDBFZGKT/jnIy6TrBpvn/nYZAvCA2XSvZHgBfEX7r0FCKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@inrupt/universal-fetch": "^1.0.1",
+        "@rdfjs/dataset": "^1.1.0",
+        "@types/rdfjs__dataset": "^1.0.4",
+        "buffer": "^6.0.3",
+        "http-link-header": "^1.1.0",
+        "jsonld-context-parser": "^2.3.0",
+        "jsonld-streaming-parser": "^3.2.0",
+        "n3": "^1.10.0",
+        "uuid": "^9.0.0"
+      },
+      "engines": {
+        "node": "^16.0.0 || ^18.0.0 || ^20.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "^2.3.2"
+      }
+    },
+    "node_modules/@inrupt/universal-fetch": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@inrupt/universal-fetch/-/universal-fetch-1.0.1.tgz",
+      "integrity": "sha512-oqbG7jS1fa6hVkjSir+u5Ab3eSbyxFyOjsgjDICL27mAd5z8oImTSETnY2hYbkRaJQYKMBOXhtm7L5/+EbeVJg==",
+      "license": "MIT",
+      "dependencies": {
+        "node-fetch": "^2.6.7",
+        "undici": "^5.19.1"
+      }
+    },
+    "node_modules/@inrupt/universal-fetch/node_modules/undici": {
+      "version": "5.29.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-5.29.0.tgz",
+      "integrity": "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==",
+      "license": "MIT",
+      "dependencies": {
+        "@fastify/busboy": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.0"
+      }
+    },
     "node_modules/@ioredis/commands": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@ioredis/commands/-/commands-1.2.0.tgz",
@@ -18426,6 +18493,39 @@
         "node": ">=8.x"
       }
     },
+    "node_modules/@rdfjs/data-model": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@rdfjs/data-model/-/data-model-1.3.4.tgz",
+      "integrity": "sha512-iKzNcKvJotgbFDdti7GTQDCYmL7GsGldkYStiP0K8EYtN7deJu5t7U11rKTz+nR7RtesUggT+lriZ7BakFv8QQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@rdfjs/types": ">=1.0.1"
+      },
+      "bin": {
+        "rdfjs-data-model-test": "bin/test.js"
+      }
+    },
+    "node_modules/@rdfjs/dataset": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@rdfjs/dataset/-/dataset-1.1.1.tgz",
+      "integrity": "sha512-BNwCSvG0cz0srsG5esq6CQKJc1m8g/M0DZpLuiEp0MMpfwguXX7VeS8TCg4UUG3DV/DqEvhy83ZKSEjdsYseeA==",
+      "license": "MIT",
+      "dependencies": {
+        "@rdfjs/data-model": "^1.2.0"
+      },
+      "bin": {
+        "rdfjs-dataset-test": "bin/test.js"
+      }
+    },
+    "node_modules/@rdfjs/types": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@rdfjs/types/-/types-2.0.1.tgz",
+      "integrity": "sha512-uyAzpugX7KekAXAHq26m3JlUIZJOC0uSBhpnefGV5i15bevDyyejoB7I+9MKeUrzXD8OOUI3+4FeV1wwQr5ihA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@react-aria/focus": {
       "version": "3.20.5",
       "resolved": "https://registry.npmjs.org/@react-aria/focus/-/focus-3.20.5.tgz",
@@ -21182,6 +21282,15 @@
       "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
       "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA=="
     },
+    "node_modules/@types/http-link-header": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@types/http-link-header/-/http-link-header-1.0.7.tgz",
+      "integrity": "sha512-snm5oLckop0K3cTDAiBnZDy6ncx9DJ3mCRDvs42C884MbVYPP74Tiq2hFsSDRTyjK6RyDYDIulPiW23ge+g5Lw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/istanbul-lib-coverage": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
@@ -21362,6 +21471,15 @@
       "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
       "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ=="
     },
+    "node_modules/@types/rdfjs__dataset": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/rdfjs__dataset/-/rdfjs__dataset-1.0.5.tgz",
+      "integrity": "sha512-8OBC9Kr/ZSgNoUTe5mHTDPHaPt8Xen4XbYfqcbYv56d+4WdKliHXaFmFc0L4I5vsynE5JGu21Hvg2zWgX1Az6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "rdf-js": "^4.0.2"
+      }
+    },
     "node_modules/@types/react": {
       "version": "18.2.53",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.2.53.tgz",
@@ -21393,6 +21511,22 @@
         "@types/react": "*"
       }
     },
+    "node_modules/@types/readable-stream": {
+      "version": "2.3.15",
+      "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-2.3.15.tgz",
+      "integrity": "sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "safe-buffer": "~5.1.1"
+      }
+    },
+    "node_modules/@types/readable-stream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
     "node_modules/@types/resolve": {
       "version": "1.20.2",
       "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz",
@@ -22246,6 +22380,18 @@
       "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
       "dev": true
     },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
+      }
+    },
     "node_modules/abstract-logging": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/abstract-logging/-/abstract-logging-2.0.1.tgz",
@@ -23724,6 +23870,12 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/canonicalize": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/canonicalize/-/canonicalize-1.0.8.tgz",
+      "integrity": "sha512-0CNTVCLZggSh7bc5VkX5WWPWO+cyZbNd07IHIsSXLia/eAq+r836hgk+8BKoEh7949Mda87VUOitx5OddVj64A==",
+      "license": "Apache-2.0"
+    },
     "node_modules/ccount": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
@@ -27211,6 +27363,15 @@
         "es5-ext": "~0.10.14"
       }
     },
+    "node_modules/event-target-shim": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/eventemitter3": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz",
@@ -29116,6 +29277,15 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/http-link-header": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/http-link-header/-/http-link-header-1.1.3.tgz",
+      "integrity": "sha512-3cZ0SRL8fb9MUlU3mKM61FcQvPfXx2dBrZW3Vbg5CXa8jFlK8OaEpePenLe1oEXQduhz8b0QjsqfS59QP4AJDQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/http-parser-js": {
       "version": "0.5.8",
       "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz",
@@ -31731,6 +31901,74 @@
         "graceful-fs": "^4.1.6"
       }
     },
+    "node_modules/jsonld-context-parser": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/jsonld-context-parser/-/jsonld-context-parser-2.4.0.tgz",
+      "integrity": "sha512-ZYOfvh525SdPd9ReYY58dxB3E2RUEU4DJ6ZibO8AitcowPeBH4L5rCAitE2om5G1P+HMEgYEYEr4EZKbVN4tpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-link-header": "^1.0.1",
+        "@types/node": "^18.0.0",
+        "cross-fetch": "^3.0.6",
+        "http-link-header": "^1.0.2",
+        "relative-to-absolute-iri": "^1.0.5"
+      },
+      "bin": {
+        "jsonld-context-parse": "bin/jsonld-context-parse.js"
+      }
+    },
+    "node_modules/jsonld-context-parser/node_modules/@types/node": {
+      "version": "18.19.130",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
+      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/jsonld-streaming-parser": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/jsonld-streaming-parser/-/jsonld-streaming-parser-3.4.0.tgz",
+      "integrity": "sha512-897CloyQgQidfkB04dLM5XaAXVX/cN9A2hvgHJo4y4jRhIpvg3KLMBBfcrswepV2N3T8c/Rp2JeFdWfVsbVZ7g==",
+      "license": "MIT",
+      "dependencies": {
+        "@bergos/jsonparse": "^1.4.0",
+        "@rdfjs/types": "*",
+        "@types/http-link-header": "^1.0.1",
+        "@types/readable-stream": "^2.3.13",
+        "buffer": "^6.0.3",
+        "canonicalize": "^1.0.1",
+        "http-link-header": "^1.0.2",
+        "jsonld-context-parser": "^2.4.0",
+        "rdf-data-factory": "^1.1.0",
+        "readable-stream": "^4.0.0"
+      }
+    },
+    "node_modules/jsonld-streaming-parser/node_modules/readable-stream": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.7.0.tgz",
+      "integrity": "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==",
+      "license": "MIT",
+      "dependencies": {
+        "abort-controller": "^3.0.0",
+        "buffer": "^6.0.3",
+        "events": "^3.3.0",
+        "process": "^0.11.10",
+        "string_decoder": "^1.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
+    "node_modules/jsonld-streaming-parser/node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
     "node_modules/jsonpointer": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
@@ -34766,6 +35004,44 @@
         "thenify-all": "^1.0.0"
       }
     },
+    "node_modules/n3": {
+      "version": "1.26.0",
+      "resolved": "https://registry.npmjs.org/n3/-/n3-1.26.0.tgz",
+      "integrity": "sha512-SQknS0ua90rN+3RHuk8BeIqeYyqIH/+ecViZxX08jR4j6MugqWRjtONl3uANG/crWXnOM2WIqBJtjIhVYFha+w==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer": "^6.0.3",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=12.0"
+      }
+    },
+    "node_modules/n3/node_modules/readable-stream": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.7.0.tgz",
+      "integrity": "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==",
+      "license": "MIT",
+      "dependencies": {
+        "abort-controller": "^3.0.0",
+        "buffer": "^6.0.3",
+        "events": "^3.3.0",
+        "process": "^0.11.10",
+        "string_decoder": "^1.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
+    "node_modules/n3/node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
     "node_modules/nanoid": {
       "version": "3.3.11",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
@@ -38234,6 +38510,34 @@
         "react-dom": ">=16.9.0"
       }
     },
+    "node_modules/rdf-data-factory": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/rdf-data-factory/-/rdf-data-factory-1.1.3.tgz",
+      "integrity": "sha512-ny6CI7m2bq4lfQQmDYvcb2l1F9KtGwz9chipX4oWu2aAtVoXjb7k3d8J1EsgAsEbMXnBipB/iuRen5H2fwRWWQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@rdfjs/types": "^1.0.0"
+      }
+    },
+    "node_modules/rdf-data-factory/node_modules/@rdfjs/types": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@rdfjs/types/-/types-1.1.2.tgz",
+      "integrity": "sha512-wqpOJK1QCbmsGNtyzYnojPU8gRDPid2JO0Q0kMtb4j65xhCK880cnKAfEOwC+dX85VJcCByQx5zOwyyfCjDJsg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/rdf-js": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/rdf-js/-/rdf-js-4.0.2.tgz",
+      "integrity": "sha512-ApvlFa/WsQh8LpPK/6hctQwG06Z9ztQQGWVtrcrf9L6+sejHNXLPOqL+w7q3hF+iL0C4sv3AX1PUtGkLNzyZ0Q==",
+      "deprecated": "Use @types/rdf-js instead. See https://github.com/rdfjs/types?tab=readme-ov-file#what-about-typesrdf-js",
+      "license": "MIT",
+      "dependencies": {
+        "@rdfjs/types": "*"
+      }
+    },
     "node_modules/react": {
       "version": "18.3.1",
       "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
@@ -39036,6 +39340,12 @@
       "resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.14.0.tgz",
       "integrity": "sha512-+2FW2CcT0K3P+JMR8YG846bmDwplKUTsWgT2ENwdQ1UdVfRk3GQrh6Mi4sTopy30gI8Uau5CEqHTDZ6YvWIUPA=="
     },
+    "node_modules/relative-to-absolute-iri": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/relative-to-absolute-iri/-/relative-to-absolute-iri-1.0.7.tgz",
+      "integrity": "sha512-Xjyl4HmIzg2jzK/Un2gELqbcE8Fxy85A/aLSHE6PE/3+OGsFwmKVA1vRyGaz6vLWSqLDMHA+5rjD/xbibSQN1Q==",
+      "license": "MIT"
+    },
     "node_modules/remark-directive": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/remark-directive/-/remark-directive-3.0.0.tgz",

From caf5fe9c75697a454424cdbc3f30e9c3e24b7217 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 11:37:29 +0000
Subject: [PATCH 11/94] updated progress documentation

---
 SOLID_INTEGRATION_PROGRESS.md                 |  78 +++++--
 api/models/Conversation.js                    |  29 ++-
 api/server/middleware/buildEndpointOption.js  |  25 +-
 api/server/middleware/validate/convoAccess.js |  15 +-
 api/server/routes/agents/chat.js              |   1 +
 api/server/routes/agents/index.js             |   1 +
 .../services/Endpoints/agents/initialize.js   |  25 ++
 api/server/services/SolidStorage.js           |  65 +++++-
 client/src/data-provider/SSE/queries.ts       |   4 +-
 client/src/hooks/SSE/useResumableSSE.ts       | 157 +++++++------
 packages/data-provider/src/createPayload.ts   | 213 +++++++++++++++++-
 11 files changed, 518 insertions(+), 95 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 7547ca5ee7c2..2ed715df7f7f 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -62,23 +62,56 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Maintains backward compatibility with MongoDB
   - Original MongoDB code preserved (commented) for rollback capability
 
+### 8. Conversation Access Validation
+- **Status**: Complete
+- **Details**:
+  - Updated `validateConvoAccess` middleware to check Solid storage
+  - Modified `searchConversation` to query Solid Pod when `USE_SOLID_STORAGE` is enabled
+  - Ensures users can only access their own conversations from Solid Pod
+  - Maintains MongoDB fallback for non-Solid users
+
+### 9. Payload Normalization & Model Extraction
+- **Status**: Complete
+- **Details**:
+  - Implemented conversation object normalization in `createPayload` for Solid storage compatibility
+  - Handles Solid storage format differences (messages as objects vs IDs, null vs undefined)
+  - Added fallback mechanism for schema validation failures
+  - Extracts `model` and `endpoint` from messages when missing in conversation metadata
+  - Ensures `resendFiles` is included in payloads for agents endpoints (defaults to `true`)
+  - Fixed model extraction in `buildEndpointOption` middleware to load from Solid when missing
+
+### 10. Full Conversation Flow
+- **Status**: Complete
+- **Details**:
+  - Users can start new conversations
+  - Users can continue existing conversations
+  - Model information is correctly extracted and passed through the request chain
+  - All required payload fields are included for agents endpoints
+
 ## Current Status
 
 ### Working Features
 1. **User Login**: Solid-OIDC authentication working correctly
 2. **Conversation Creation**: New conversations are saved to Solid Pod
-3. **Message Saving**: User messages are saved to Solid Pod
+3. **Message Saving**: User messages and AI responses are saved to Solid Pod
 4. **Data Retrieval**: Conversations and messages can be read from Pod
 5. **Container Structure**: Proper directory structure created automatically
+6. **Conversation Continuation**: Users can send multiple messages in the same conversation
+7. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
+8. **Access Control**: Conversation access validation works for Solid storage users
 
 ### Known Issues 🔧
-1. **Message Updates**: LLM response messages fail to update in Pod
-   - **Error**: `conversationId is required for updating messages`
-   - **Root Cause**: `conversationId` not always present in message object during updates
-   - **Status**: In Progress
-
-2. **Title Generation**: Endpoint `/api/convos/gen_title/{conversationId}` returns 404
-   - **Status**: To be investigated
+1. **Title Retrieval on Page Refresh**
+   - **Issue**: When the page is refreshed, conversation titles revert to "untitled" instead of loading the saved title from Solid Pod
+   - **Impact**: Users lose visual context of their conversations after refresh
+   - **Status**: To be fixed
+   - **Priority**: High
+
+2. **Conversation Menu Options**
+   - **Issue**: Share, Rename, Duplicate, Archive, and Delete options need to be implemented for Solid storage
+   - **Impact**: Users cannot manage their conversations stored in Solid Pod
+   - **Status**: Not yet implemented
+   - **Priority**: High
 
 ## Technical Implementation
 
@@ -106,25 +139,38 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - Tokens retrieved from multiple sources for robustness
 
 ## Next Steps
-1. Fix message update functionality to handle missing `conversationId`
-2. Investigate and fix title generation endpoint
-3. Test full conversation flow (create → send message → receive LLM response → update)
-4. Performance testing with multiple conversations
-5. Error recovery and retry mechanisms
+
+1. **Conversation Menu Options Implementation**
+   - Implement Share functionality for Solid storage conversations
+   - Implement Rename functionality (update conversation title in Solid Pod)
+   - Implement Duplicate functionality (create copy in Solid Pod)
+   - Implement Archive functionality (mark as archived in Solid Pod)
+   - Implement Delete functionality (remove from Solid Pod)
+   - Ensure all operations work seamlessly with Solid storage backend
+
+2. **Fix Title Retrieval on Page Refresh**
+   - Issue: When page is refreshed, conversation titles revert to "untitled" instead of loading from Solid Pod
+   - Root Cause: Title not being properly retrieved/loaded from Solid storage on initial page load
+   - Priority: High (affects user experience)
+
 
 ## Files Modified
 - `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations
 - `api/models/Message.js` - Integrated Solid storage
-- `api/models/Conversation.js` - Integrated Solid storage
+- `api/models/Conversation.js` - Integrated Solid storage, updated `searchConversation` for Solid support
 - `api/server/routes/oauth.js` - Token logging and storage
 - `api/server/services/AuthService.js` - Token management
 - `api/server/index.js` - Session middleware ordering
 - `api/server/controllers/AuthController.js` - Refresh token handling
+- `api/server/middleware/validate/convoAccess.js` - Added Solid storage support for conversation access validation
+- `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing
+- `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
+- `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library
 
 ---
 
-**Report Date**: January 30, 2026  
-**Status**: 85% Complete - Core functionality working, minor fixes needed
+**Report Date**: February 2, 2026  
+
diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 84d5b5d8c72d..fd3b5ccea82d 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -9,10 +9,37 @@ const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
 /**
  * Searches for a conversation by conversationId and returns a lean document with only conversationId and user.
  * @param {string} conversationId - The conversation's ID.
+ * @param {Object} [req] - Optional request object for Solid storage support.
  * @returns {Promise<{conversationId: string, user: string} | null>} The conversation object with selected fields or null if not found.
  */
-const searchConversation = async (conversationId) => {
+const searchConversation = async (conversationId, req = null) => {
   try {
+    // Use Solid storage if enabled and req is provided with openidId
+    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+      try {
+        const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+        const convo = await getConvoFromSolid(req, conversationId);
+        if (convo) {
+          // Return only conversationId and user to match MongoDB format
+          return {
+            conversationId: convo.conversationId,
+            user: convo.user,
+          };
+        }
+        // If Solid storage returns null, fall through to MongoDB
+        logger.debug('[searchConversation] Conversation not found in Solid Pod, falling back to MongoDB', {
+          conversationId,
+        });
+      } catch (error) {
+        logger.error('[searchConversation] Error getting conversation from Solid Pod, falling back to MongoDB', {
+          error: error.message,
+          conversationId,
+        });
+        // Fall through to MongoDB storage
+      }
+    }
+
+    // MongoDB storage (original code)
     return await Conversation.findOne({ conversationId }, 'conversationId user').lean();
   } catch (error) {
     logger.error('[searchConversation] Error searching conversation', error);
diff --git a/api/server/middleware/buildEndpointOption.js b/api/server/middleware/buildEndpointOption.js
index 64ed8e746684..3c360a79500d 100644
--- a/api/server/middleware/buildEndpointOption.js
+++ b/api/server/middleware/buildEndpointOption.js
@@ -1,4 +1,4 @@
-const { handleError } = require('@librechat/api');
+const { handleError, isEnabled } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
 const {
   EndpointURLs,
@@ -12,6 +12,7 @@ const assistants = require('~/server/services/Endpoints/assistants');
 const { getEndpointsConfig } = require('~/server/services/Config');
 const agents = require('~/server/services/Endpoints/agents');
 const { updateFilesUsage } = require('~/models');
+const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
 
 const buildFunction = {
   [EModelEndpoint.agents]: agents.buildOptions,
@@ -89,6 +90,28 @@ async function buildEndpointOption(req, res, next) {
     }
   }
 
+  // If model is missing and we have a conversationId, try to load it from Solid storage
+  if (!parsedBody.model && req.body?.conversationId && 
+      req.body.conversationId !== 'new' && 
+      isEnabled(USE_SOLID_STORAGE) && 
+      req.user?.openidId) {
+    try {
+      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+      const conversation = await getConvoFromSolid(req, req.body.conversationId);
+      
+      if (conversation?.model) {
+        parsedBody.model = conversation.model;
+      }
+    } catch (error) {
+      // Don't fail the request if we can't load from Solid - just log a warning
+      logger.warn('[buildEndpointOption] Could not load conversation from Solid to extract model', {
+        conversationId: req.body.conversationId,
+        error: error.message,
+      });
+      // Continue without the model - it might be set elsewhere or the request might fail later
+    }
+  }
+
   try {
     const isAgents =
       isAgentsEndpoint(endpoint) || req.baseUrl.startsWith(EndpointURLs[EModelEndpoint.agents]);
diff --git a/api/server/middleware/validate/convoAccess.js b/api/server/middleware/validate/convoAccess.js
index 127bfdc53026..f987e32ffe8e 100644
--- a/api/server/middleware/validate/convoAccess.js
+++ b/api/server/middleware/validate/convoAccess.js
@@ -1,5 +1,6 @@
 const { isEnabled } = require('@librechat/api');
 const { Constants, ViolationTypes, Time } = require('librechat-data-provider');
+const { logger } = require('@librechat/data-schemas');
 const { searchConversation } = require('~/models/Conversation');
 const denyRequest = require('~/server/middleware/denyRequest');
 const { logViolation, getLogStores } = require('~/cache');
@@ -51,13 +52,18 @@ const validateConvoAccess = async (req, res, next) => {
       }
     }
 
-    const conversation = await searchConversation(conversationId);
+    const conversation = await searchConversation(conversationId, req);
 
     if (!conversation) {
       return next();
     }
 
     if (conversation.user !== userId) {
+      logger.error('[validateConvoAccess] Authorization failed', {
+        conversationId,
+        conversationUserId: conversation.user,
+        currentUserId: userId,
+      });
       const errorMessage = {
         type,
         error: 'User not authorized for this conversation',
@@ -74,7 +80,12 @@ const validateConvoAccess = async (req, res, next) => {
     }
     next();
   } catch (error) {
-    console.error('Error validating conversation access:', error);
+    logger.error('[validateConvoAccess] Error validating conversation access:', {
+      error: error.message,
+      stack: error.stack,
+      conversationId,
+      userId,
+    });
     res.status(500).json({ error: 'Internal server error' });
   }
 };
diff --git a/api/server/routes/agents/chat.js b/api/server/routes/agents/chat.js
index 37b83f4f5447..750ce6fc5ace 100644
--- a/api/server/routes/agents/chat.js
+++ b/api/server/routes/agents/chat.js
@@ -25,6 +25,7 @@ const checkAgentResourceAccess = canAccessAgentFromBody({
   requiredPermission: PermissionBits.VIEW,
 });
 
+
 router.use(moderateText);
 router.use(checkAgentAccess);
 router.use(checkAgentResourceAccess);
diff --git a/api/server/routes/agents/index.js b/api/server/routes/agents/index.js
index 05afdb9b1f90..8844f331b449 100644
--- a/api/server/routes/agents/index.js
+++ b/api/server/routes/agents/index.js
@@ -277,6 +277,7 @@ router.post('/chat/abort', async (req, res) => {
 });
 
 const chatRouter = express.Router();
+
 chatRouter.use(configMiddleware);
 
 if (isEnabled(LIMIT_MESSAGE_IP)) {
diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.js
index e71270ef8530..f7f886e665c6 100644
--- a/api/server/services/Endpoints/agents/initialize.js
+++ b/api/server/services/Endpoints/agents/initialize.js
@@ -152,6 +152,31 @@ const initializeClient = async ({ req, res, signal, endpointOption }) => {
     throw new Error('Agent not found');
   }
 
+  // If agent doesn't have a model, try to get it from multiple sources
+  // This is especially important for Solid storage where the model might be in the conversation
+  if (!primaryAgent.model) {
+    // Try multiple sources for the model
+    const modelFromEndpointOption = 
+      endpointOption.model || 
+      endpointOption.model_parameters?.model ||
+      req.body?.model ||
+      req.body?.model_parameters?.model;
+    
+    if (modelFromEndpointOption) {
+      logger.info('[initializeClient] Setting model from endpointOption/request body', {
+        agentId: primaryAgent.id,
+        model: modelFromEndpointOption,
+      });
+      primaryAgent.model = modelFromEndpointOption;
+    } else {
+      logger.warn('[initializeClient] No model found in endpointOption or request body', {
+        agentId: primaryAgent.id,
+        endpointOptionKeys: Object.keys(endpointOption),
+        reqBodyKeys: Object.keys(req.body || {}),
+      });
+    }
+  }
+
   const modelsConfig = await getModelsConfig(req);
   const validationResult = await validateAgentModel({
     req,
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index b665ac14a133..33f5c49b8db5 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1229,13 +1229,40 @@ async function saveConvoToSolid(req, convoData, metadata) {
       createdAt: msg.createdAt,
     }));
 
+    // If model or endpoint are missing, try to extract them from messages
+    let finalModel = convoData.model;
+    let finalEndpoint = convoData.endpoint;
+    
+    if (!finalModel || !finalEndpoint) {
+      // Find the first message with a model (usually the AI response)
+      const messageWithModel = messages.find(msg => msg.model && msg.endpoint);
+      
+      if (messageWithModel) {
+        if (!finalModel && messageWithModel.model) {
+          logger.info('[SolidStorage] Extracting model from messages when saving', {
+            conversationId: finalConversationId,
+            extractedModel: messageWithModel.model,
+          });
+          finalModel = messageWithModel.model;
+        }
+        
+        if (!finalEndpoint && messageWithModel.endpoint) {
+          logger.info('[SolidStorage] Extracting endpoint from messages when saving', {
+            conversationId: finalConversationId,
+            extractedEndpoint: messageWithModel.endpoint,
+          });
+          finalEndpoint = messageWithModel.endpoint;
+        }
+      }
+    }
+
     // Prepare conversation object
     const conversationToSave = {
       conversationId: finalConversationId,
       user: req.user.id,
       title: convoData.title || null,
-      endpoint: convoData.endpoint || null,
-      model: convoData.model || null,
+      endpoint: finalEndpoint || null,
+      model: finalModel || null,
       agent_id: convoData.agent_id || null,
       assistant_id: convoData.assistant_id || null,
       spec: convoData.spec || null,
@@ -1392,6 +1419,40 @@ async function getConvoFromSolid(req, conversationId) {
         return null;
       }
 
+      // If model or endpoint are missing, try to extract them from messages
+      if (!conversationData.model || !conversationData.endpoint) {
+        try {
+          const messages = await getMessagesFromSolid(req, conversationId);
+          
+          // Find the first message with a model (usually the AI response)
+          const messageWithModel = messages.find(msg => msg.model && msg.endpoint);
+          
+          if (messageWithModel) {
+            if (!conversationData.model && messageWithModel.model) {
+              logger.info('[SolidStorage] Extracting model from messages', {
+                conversationId,
+                extractedModel: messageWithModel.model,
+              });
+              conversationData.model = messageWithModel.model;
+            }
+            
+            if (!conversationData.endpoint && messageWithModel.endpoint) {
+              logger.info('[SolidStorage] Extracting endpoint from messages', {
+                conversationId,
+                extractedEndpoint: messageWithModel.endpoint,
+              });
+              conversationData.endpoint = messageWithModel.endpoint;
+            }
+          }
+        } catch (error) {
+          // If we can't get messages, log but don't fail
+          logger.warn('[SolidStorage] Could not extract model/endpoint from messages', {
+            conversationId,
+            error: error.message,
+          });
+        }
+      }
+
       logger.info('[SolidStorage] Conversation retrieved successfully', {
         conversationId,
         title: conversationData.title,
diff --git a/client/src/data-provider/SSE/queries.ts b/client/src/data-provider/SSE/queries.ts
index 76c500c5303d..94e71fad8baa 100644
--- a/client/src/data-provider/SSE/queries.ts
+++ b/client/src/data-provider/SSE/queries.ts
@@ -140,7 +140,7 @@ export function useTitleGeneration(enabled = true) {
  * - Shows generation indicators in conversation list
  */
 export function useActiveJobs(enabled = true) {
-  return useQuery({
+  const query = useQuery({
     queryKey: [QueryKeys.activeJobs],
     queryFn: () => dataService.getActiveJobs(),
     enabled,
@@ -150,4 +150,6 @@ export function useActiveJobs(enabled = true) {
     refetchInterval: (data) => ((data?.activeJobIds?.length ?? 0) > 0 ? 5_000 : false),
     retry: false,
   });
+  
+  return query;
 }
diff --git a/client/src/hooks/SSE/useResumableSSE.ts b/client/src/hooks/SSE/useResumableSSE.ts
index 831bf042adf5..f20dfa9dc750 100644
--- a/client/src/hooks/SSE/useResumableSSE.ts
+++ b/client/src/hooks/SSE/useResumableSSE.ts
@@ -149,7 +149,6 @@ export default function useResumableSSE(
 
       const baseUrl = `${apiBaseUrl()}/api/agents/chat/stream/${encodeURIComponent(currentStreamId)}`;
       const url = isResume ? `${baseUrl}?resume=true` : baseUrl;
-      console.log('[ResumableSSE] Subscribing to stream:', url, { isResume });
 
       const sse = new SSE(url, {
         headers: { Authorization: `Bearer ${token}` },
@@ -158,7 +157,6 @@ export default function useResumableSSE(
       sseRef.current = sse;
 
       sse.addEventListener('open', () => {
-        console.log('[ResumableSSE] Stream connected');
         setAbortScroll(false);
         // Restore UI state on successful connection (including reconnection)
         setIsSubmitting(true);
@@ -224,10 +222,6 @@ export default function useResumableSSE(
           }
 
           if (data.sync != null) {
-            console.log('[ResumableSSE] SYNC received', {
-              runSteps: data.resumeState?.runSteps?.length ?? 0,
-            });
-
             const runId = v4();
             setActiveRunId(runId);
 
@@ -262,34 +256,18 @@ export default function useResumableSSE(
                 );
               }
 
-              console.log('[ResumableSSE] SYNC update', {
-                userMsgId,
-                serverResponseId,
-                responseIdx,
-                foundMessageId: responseIdx >= 0 ? messages[responseIdx]?.messageId : null,
-                messagesCount: messages.length,
-                aggregatedContentLength: data.resumeState.aggregatedContent?.length,
-              });
-
               if (responseIdx >= 0) {
                 // Update existing response message with aggregatedContent
                 const updated = [...messages];
-                const oldContent = updated[responseIdx]?.content;
                 updated[responseIdx] = {
                   ...updated[responseIdx],
                   content: data.resumeState.aggregatedContent,
                 };
-                console.log('[ResumableSSE] SYNC updating message', {
-                  messageId: updated[responseIdx]?.messageId,
-                  oldContentLength: Array.isArray(oldContent) ? oldContent.length : 0,
-                  newContentLength: data.resumeState.aggregatedContent?.length,
-                });
                 setMessages(updated);
                 // Sync both content handler and step handler with the updated message
                 // so subsequent deltas build on synced content, not stale content
                 resetContentHandler();
                 syncStepMessage(updated[responseIdx]);
-                console.log('[ResumableSSE] SYNC complete, handlers synced');
               } else {
                 // Add new response message
                 const responseId = serverResponseId ?? `${userMsgId}_`;
@@ -350,7 +328,6 @@ export default function useResumableSSE(
 
         // 404 means job doesn't exist (completed/deleted) - don't retry
         if (responseCode === 404) {
-          console.log('[ResumableSSE] Stream not found (404) - job completed or expired');
           sse.close();
           removeActiveJob(currentStreamId);
           setIsSubmitting(false);
@@ -385,7 +362,6 @@ export default function useResumableSSE(
          * Only check e.data if there's no HTTP responseCode, since HTTP errors may also have body data.
          */
         if (!responseCode && e.data) {
-          console.log('[ResumableSSE] Server-sent error event received:', e.data);
           sse.close();
           removeActiveJob(currentStreamId);
 
@@ -409,8 +385,6 @@ export default function useResumableSSE(
               // Not JSON or parsing failed - treat as generic error
             }
 
-            console.log('[ResumableSSE] Error type check:', { isKnownError, errorString });
-
             // Display the error to user via errorHandler
             errorHandler({
               data: { text: errorString } as unknown as Parameters<typeof errorHandler>[0]['data'],
@@ -483,8 +457,6 @@ export default function useResumableSSE(
           console.log('[ResumableSSE] Stream closed for reconnect - preserving state');
           return;
         }
-
-        console.log('[ResumableSSE] Stream aborted (intentional close) - no reconnect');
         // Clear any pending reconnect attempts
         if (reconnectTimeoutRef.current) {
           clearTimeout(reconnectTimeoutRef.current);
@@ -553,13 +525,26 @@ export default function useResumableSSE(
    */
   const startGeneration = useCallback(
     async (currentSubmission: TSubmission): Promise<string | null> => {
-      const payloadData = createPayload(currentSubmission);
-      let { payload } = payloadData;
-      payload = removeNullishValues(payload) as TPayload;
+      // Check if submission is still valid
+      if (!currentSubmission || !currentSubmission.userMessage || !currentSubmission.endpointOption) {
+        return null;
+      }
+      
+      try {
+        let payloadData;
+        try {
+          payloadData = createPayload(currentSubmission);
+        } catch (payloadError) {
+          console.error('[ResumableSSE] Error in createPayload:', payloadError);
+          throw payloadError;
+        }
+        
+        let { payload } = payloadData;
+        payload = removeNullishValues(payload) as TPayload;
 
-      clearStepMaps();
+        clearStepMaps();
 
-      const url = payloadData.server;
+        const url = payloadData.server;
 
       const maxRetries = 3;
       let lastError: unknown = null;
@@ -568,9 +553,13 @@ export default function useResumableSSE(
         try {
           // Use request.post which handles auth token refresh via axios interceptors
           const data = (await request.post(url, payload)) as { streamId: string };
-          console.log('[ResumableSSE] Generation started:', { streamId: data.streamId });
           return data.streamId;
         } catch (error) {
+          console.error('[ResumableSSE] POST request failed:', { 
+            attempt, 
+            error: error instanceof Error ? error.message : String(error),
+            url,
+          });
           lastError = error;
           // Check if it's a network error (retry) vs server error (don't retry)
           const isNetworkError =
@@ -592,29 +581,35 @@ export default function useResumableSSE(
         }
       }
 
-      console.error('[ResumableSSE] Error starting generation:', lastError);
-
-      const axiosError = lastError as { response?: { data?: Record<string, unknown> } };
-      const errorData = axiosError?.response?.data;
-      if (errorData) {
-        errorHandler({
-          data: { text: JSON.stringify(errorData) } as unknown as Parameters<
-            typeof errorHandler
-          >[0]['data'],
-          submission: currentSubmission as EventSubmission,
-        });
-      } else {
-        errorHandler({ data: undefined, submission: currentSubmission as EventSubmission });
+        console.error('[ResumableSSE] Error starting generation after all retries:', lastError);
+
+        const axiosError = lastError as { response?: { data?: Record<string, unknown> } };
+        const errorData = axiosError?.response?.data;
+        if (errorData) {
+          console.error('[ResumableSSE] Error data from server:', errorData);
+          errorHandler({
+            data: { text: JSON.stringify(errorData) } as unknown as Parameters<
+              typeof errorHandler
+            >[0]['data'],
+            submission: currentSubmission as EventSubmission,
+          });
+        } else {
+          console.error('[ResumableSSE] No error data from server');
+          errorHandler({ data: undefined, submission: currentSubmission as EventSubmission });
+        }
+        setIsSubmitting(false);
+        return null;
+      } catch (error) {
+        console.error('[ResumableSSE] Unexpected error in startGeneration:', error);
+        setIsSubmitting(false);
+        return null;
       }
-      setIsSubmitting(false);
-      return null;
     },
     [clearStepMaps, errorHandler, setIsSubmitting],
   );
 
   useEffect(() => {
     if (!submission || Object.keys(submission).length === 0) {
-      console.log('[ResumableSSE] No submission, cleaning up');
       // Clear reconnect timeout if submission is cleared
       if (reconnectTimeoutRef.current) {
         clearTimeout(reconnectTimeoutRef.current);
@@ -631,48 +626,68 @@ export default function useResumableSSE(
       return;
     }
 
+    // Validate submission has required properties
+    if (!submission.userMessage || !submission.endpointOption) {
+      return;
+    }
+
     const resumeStreamId = (submission as TSubmission & { resumeStreamId?: string }).resumeStreamId;
-    console.log('[ResumableSSE] Effect triggered', {
-      conversationId: submission.conversation?.conversationId,
-      hasResumeStreamId: !!resumeStreamId,
-      resumeStreamId,
-      userMessageId: submission.userMessage?.messageId,
-    });
 
     submissionRef.current = submission;
 
     const initStream = async () => {
+      // Check if submission was cleared while we were waiting
+      if (!submissionRef.current || submissionRef.current !== submission) {
+        return;
+      }
+      
       setIsSubmitting(true);
       setShowStopButton(true);
 
       if (resumeStreamId) {
         // Resume: just subscribe to existing stream, don't start new generation
-        console.log('[ResumableSSE] Resuming existing stream:', resumeStreamId);
         setStreamId(resumeStreamId);
         // Optimistically add to active jobs (in case it's not already there)
         addActiveJob(resumeStreamId);
         subscribeToStream(resumeStreamId, submission, true); // isResume=true
       } else {
         // New generation: start and then subscribe
-        console.log('[ResumableSSE] Starting NEW generation');
-        const newStreamId = await startGeneration(submission);
-        if (newStreamId) {
-          setStreamId(newStreamId);
-          // Optimistically add to active jobs
-          addActiveJob(newStreamId);
-          // Queue title generation if this is a new conversation (first message)
-          const isNewConvo = submission.userMessage?.parentMessageId === Constants.NO_PARENT;
-          if (isNewConvo) {
-            queueTitleGeneration(newStreamId);
+        // Check if submission is still valid before calling startGeneration
+        if (!submission || !submission.userMessage || !submission.endpointOption) {
+          setIsSubmitting(false);
+          setShowStopButton(false);
+          return;
+        }
+        
+        try {
+          const newStreamId = await startGeneration(submission);
+          
+          if (newStreamId) {
+            setStreamId(newStreamId);
+            // Optimistically add to active jobs
+            addActiveJob(newStreamId);
+            // Queue title generation if this is a new conversation (first message)
+            const isNewConvo = submission.userMessage?.parentMessageId === Constants.NO_PARENT;
+            if (isNewConvo) {
+              queueTitleGeneration(newStreamId);
+            }
+            subscribeToStream(newStreamId, submission);
+          } else {
+            console.error('[ResumableSSE] Failed to get streamId from startGeneration');
+            setIsSubmitting(false);
+            setShowStopButton(false);
           }
-          subscribeToStream(newStreamId, submission);
-        } else {
-          console.error('[ResumableSSE] Failed to get streamId from startGeneration');
+        } catch (error) {
+          console.error('[ResumableSSE] Error in startGeneration call:', error);
+          setIsSubmitting(false);
+          setShowStopButton(false);
         }
       }
     };
 
-    initStream();
+    initStream().catch((error) => {
+      console.error('[ResumableSSE] Error in initStream:', error);
+    });
 
     return () => {
       console.log('[ResumableSSE] Cleanup - closing SSE, resetting UI state');
diff --git a/packages/data-provider/src/createPayload.ts b/packages/data-provider/src/createPayload.ts
index 3056a7021b99..2d2a89e709a7 100644
--- a/packages/data-provider/src/createPayload.ts
+++ b/packages/data-provider/src/createPayload.ts
@@ -15,7 +15,98 @@ export default function createPayload(submission: t.TSubmission) {
     ephemeralAgent,
     endpointOption,
   } = submission;
-  const { conversationId } = s.tConvoUpdateSchema.parse(conversation);
+  
+  // Normalize conversation object for Solid storage compatibility
+  // Solid storage may return messages as objects instead of IDs, and null values instead of undefined
+  // Wrap in try-catch to ensure we can always fall back if normalization fails
+  let normalizedConversation: Record<string, unknown>;
+  try {
+    normalizedConversation = { ...conversation };
+    
+    // Convert messages array from objects to IDs if needed
+    if (Array.isArray(normalizedConversation.messages)) {
+      normalizedConversation.messages = normalizedConversation.messages.map((msg: unknown) => {
+        if (typeof msg === 'string') {
+          return msg;
+        }
+        if (typeof msg === 'object' && msg !== null && 'messageId' in msg) {
+          return (msg as { messageId: string }).messageId;
+        }
+        return String(msg);
+      }) as string[];
+    }
+  } catch (normalizationError) {
+    // If normalization fails, just use the original conversation and let the fallback handle it
+    normalizedConversation = conversation as Record<string, unknown>;
+  }
+  
+  // Convert ALL null values to undefined for optional fields that expect specific types
+  // This is necessary because Zod schemas use .optional() which means undefined, not null
+  const nullableNumberFields = [
+    'topP', 'top_p', 'topK', 'frequency_penalty', 'presence_penalty', 
+    'temperature', 'maxOutputTokens', 'maxContextTokens', 'max_tokens',
+    'thinkingBudget', 'fileTokenLimit'
+  ];
+  
+  const nullableStringFields = [
+    'assistant_id', 'agent_id', 'model', 'modelLabel', 'userLabel',
+    'promptPrefix', 'system', 'context', 'title', 'conversationId',
+    'endpoint', 'endpointType', 'parentMessageId', 'artifacts',
+    'imageDetail', 'reasoning_effort', 'reasoning_summary', 'verbosity'
+  ];
+  
+  const nullableBooleanFields = [
+    'isArchived', 'promptCache', 'thinking', 'stream', 'resendFiles'
+  ];
+  
+  // Convert null to undefined for all nullable fields
+  for (const field of nullableNumberFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  for (const field of nullableStringFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  for (const field of nullableBooleanFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  // Handle createdAt and updatedAt - convert Date objects to strings, or null to undefined
+  if ('createdAt' in normalizedConversation) {
+    if (normalizedConversation.createdAt === null) {
+      normalizedConversation.createdAt = undefined;
+    } else if (normalizedConversation.createdAt instanceof Date) {
+      normalizedConversation.createdAt = normalizedConversation.createdAt.toISOString();
+    }
+  }
+  
+  if ('updatedAt' in normalizedConversation) {
+    if (normalizedConversation.updatedAt === null) {
+      normalizedConversation.updatedAt = undefined;
+    } else if (normalizedConversation.updatedAt instanceof Date) {
+      normalizedConversation.updatedAt = normalizedConversation.updatedAt.toISOString();
+    }
+  }
+  
+  // Use safeParse to handle validation errors gracefully
+  // safeParse never throws, it always returns { success: true, data } or { success: false, error }
+  const parseResult = s.tConvoUpdateSchema.safeParse(normalizedConversation);
+  
+  if (!parseResult.success) {
+    // Fallback: try to extract conversationId directly if parse fails
+    // For new conversations, conversationId can be null or 'new', which is valid
+    const conversationIdRaw = conversation?.conversationId ?? normalizedConversation?.conversationId ?? null;
+    
+    // Allow null or 'new' for new conversations
+    if (conversationIdRaw === null || conversationIdRaw === 'new') {
+      const conversationId = conversationIdRaw;
   const { endpoint: _e, endpointType } = endpointOption as {
     endpoint: s.EModelEndpoint;
     endpointType?: s.EModelEndpoint;
@@ -29,6 +120,122 @@ export default function createPayload(submission: t.TSubmission) {
       (isEdited ? '/modify' : '');
   }
 
+      const payload: t.TPayload = {
+        ...userMessage,
+        ...endpointOption,
+        endpoint,
+        addedConvo,
+        isTemporary,
+        isRegenerate,
+        editedContent,
+        conversationId: conversationId as string | null,
+        isContinued: !!(isEdited && isContinued),
+        ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+      };
+
+      return { server, payload };
+    }
+    
+    // For existing conversations, conversationId must be a valid string
+    if (typeof conversationIdRaw !== 'string') {
+      throw new Error('Invalid conversation: conversationId must be a string');
+    }
+
+    const conversationId: string = conversationIdRaw;
+    
+    // Extract important fields from the conversation object and endpointOption
+    // This is especially important for Solid storage where the conversation might have the model
+    // Check endpointOption first, then conversation, as endpointOption takes precedence
+    const conversationFields = {
+      model: (endpointOption as { model?: string })?.model ?? conversation?.model ?? normalizedConversation?.model,
+      modelLabel: (endpointOption as { modelLabel?: string })?.modelLabel ?? conversation?.modelLabel ?? normalizedConversation?.modelLabel,
+      temperature: (endpointOption as { temperature?: number })?.temperature ?? conversation?.temperature ?? normalizedConversation?.temperature,
+      topP: (endpointOption as { topP?: number })?.topP ?? conversation?.topP ?? normalizedConversation?.topP,
+      top_p: (endpointOption as { top_p?: number })?.top_p ?? conversation?.top_p ?? normalizedConversation?.top_p,
+      frequency_penalty: (endpointOption as { frequency_penalty?: number })?.frequency_penalty ?? conversation?.frequency_penalty ?? normalizedConversation?.frequency_penalty,
+      presence_penalty: (endpointOption as { presence_penalty?: number })?.presence_penalty ?? conversation?.presence_penalty ?? normalizedConversation?.presence_penalty,
+      maxOutputTokens: (endpointOption as { maxOutputTokens?: number })?.maxOutputTokens ?? conversation?.maxOutputTokens ?? normalizedConversation?.maxOutputTokens,
+      max_tokens: (endpointOption as { max_tokens?: number })?.max_tokens ?? conversation?.max_tokens ?? normalizedConversation?.max_tokens,
+      system: (endpointOption as { system?: string })?.system ?? conversation?.system ?? normalizedConversation?.system,
+      promptPrefix: (endpointOption as { promptPrefix?: string })?.promptPrefix ?? conversation?.promptPrefix ?? normalizedConversation?.promptPrefix,
+    };
+    
+    // Filter out null/undefined values
+    const validConversationFields = Object.fromEntries(
+      Object.entries(conversationFields).filter(([_, value]) => value !== null && value !== undefined)
+    );
+    
+    // Continue with the fallback conversationId
+    const { endpoint: _e, endpointType } = endpointOption as {
+      endpoint: s.EModelEndpoint;
+      endpointType?: s.EModelEndpoint;
+    };
+
+    const endpoint = _e as s.EModelEndpoint;
+    let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
+    if (s.isAssistantsEndpoint(endpoint)) {
+      server =
+        EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
+        (isEdited ? '/modify' : '');
+    }
+
+    // Ensure model is explicitly included - check all sources
+    const finalModel = (endpointOption as { model?: string })?.model || 
+                      validConversationFields.model || 
+                      conversation?.model || 
+                      normalizedConversation?.model;
+
+    // Extract resendFiles - default to true for agents endpoints if not specified
+    const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
+    const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+    const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
+    const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+
+    const payload: t.TPayload = {
+      ...userMessage,
+      ...endpointOption,
+      ...validConversationFields, // Merge conversation fields, with endpointOption taking precedence
+      endpoint,
+      addedConvo,
+      isTemporary,
+      isRegenerate,
+      editedContent,
+      conversationId,
+      isContinued: !!(isEdited && isContinued),
+      ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+      // Explicitly include model at top level - this ensures it's always in the payload if available
+      ...(finalModel ? { model: finalModel as string } : {}),
+      // Explicitly include resendFiles - always true for agents endpoints if not specified
+      ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
+    };
+
+    return { server, payload };
+  }
+  const { conversationId } = parseResult.data;
+  const { endpoint: _e, endpointType } = endpointOption as {
+    endpoint: s.EModelEndpoint;
+    endpointType?: s.EModelEndpoint;
+  };
+
+  const endpoint = _e as s.EModelEndpoint;
+  let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
+  if (s.isAssistantsEndpoint(endpoint)) {
+    server =
+      EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
+      (isEdited ? '/modify' : '');
+  }
+
+  // Extract model from conversation if not in endpointOption (for Solid storage compatibility)
+  const modelFromConversation = conversation?.model ?? normalizedConversation?.model;
+  const modelFromEndpointOption = (endpointOption as { model?: string })?.model;
+  const finalModel = (modelFromEndpointOption || modelFromConversation) as string | undefined;
+
+  // Extract resendFiles - default to true for agents endpoints if not specified
+  const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
+  const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+  const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
+  const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+
   const payload: t.TPayload = {
     ...userMessage,
     ...endpointOption,
@@ -40,6 +247,10 @@ export default function createPayload(submission: t.TSubmission) {
     conversationId,
     isContinued: !!(isEdited && isContinued),
     ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+    // Explicitly include model at top level for buildEndpointOption to find it
+    ...(finalModel ? { model: finalModel } : {}),
+    // Explicitly include resendFiles - always true for agents endpoints if not specified
+    ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
   };
 
   return { server, payload };

From 4c4e8e074a0a64288609dac888ae297780f4da19 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 12:05:50 +0000
Subject: [PATCH 12/94] fix(solid): Save conversation titles to Solid Pod and
 preserve existing data on updates

- Added req.user?.openidId check in saveConvo to ensure Solid storage is only used for Solid users
- Fix saveConvoToSolid to merge updates with existing conversation data instead of overwriting
- Preserve all conversation fields when only updating specific fields (e.g., title)
- Fixes issue where conversation titles were not being saved to Solid Pod and where titles would revert to "untitled" after page refresh
---
 api/models/Conversation.js          | 10 +++-
 api/server/services/SolidStorage.js | 91 ++++++++++++++++-------------
 2 files changed, 59 insertions(+), 42 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index fd3b5ccea82d..931e81565588 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -142,8 +142,8 @@ module.exports = {
    * @returns {Promise<TConversation>} The conversation object.
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
-    // Use Solid storage if enabled
-    if (USE_SOLID_STORAGE) {
+    // Use Solid storage if enabled and user is a Solid user
+    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
       try {
         if (metadata?.context) {
           logger.debug(`[saveConvo] ${metadata.context}`);
@@ -177,7 +177,11 @@ module.exports = {
         if (metadata && metadata?.context) {
           logger.info(`[saveConvo] ${metadata.context}`);
         }
-        return { message: 'Error saving conversation' };
+        // Fall through to MongoDB if Solid save fails
+        logger.warn('[saveConvo] Falling back to MongoDB after Solid save failure', {
+          conversationId,
+          error: error.message,
+        });
       }
     }
 
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 33f5c49b8db5..306679a29f4b 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1221,6 +1221,29 @@ async function saveConvoToSolid(req, convoData, metadata) {
     // Get conversation file path
     const conversationPath = getConversationPath(podUrl, finalConversationId);
 
+    // Check if conversation already exists and load it to preserve existing data
+    let existingConversation = null;
+    try {
+      const existingFile = await getFile(conversationPath, { fetch: authenticatedFetch });
+      const existingFileText = await existingFile.text();
+      existingConversation = JSON.parse(existingFileText);
+      logger.debug('[SolidStorage] Loaded existing conversation for merge', {
+        conversationId: finalConversationId,
+        hasTitle: !!existingConversation.title,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        logger.debug('[SolidStorage] Conversation does not exist yet, will create new', {
+          conversationId: finalConversationId,
+        });
+      } else {
+        logger.warn('[SolidStorage] Error loading existing conversation, will create new', {
+          conversationId: finalConversationId,
+          error: error.message,
+        });
+      }
+    }
+
     // Get messages for this conversation (just IDs for reference)
     // Note: We call getMessagesFromSolid directly since it's in the same module
     const messages = await getMessagesFromSolid(req, finalConversationId);
@@ -1229,9 +1252,16 @@ async function saveConvoToSolid(req, convoData, metadata) {
       createdAt: msg.createdAt,
     }));
 
+    // Start with existing conversation data if available, otherwise use defaults
+    const baseConversation = existingConversation || {
+      conversationId: finalConversationId,
+      user: req.user.id,
+      createdAt: new Date().toISOString(),
+    };
+
     // If model or endpoint are missing, try to extract them from messages
-    let finalModel = convoData.model;
-    let finalEndpoint = convoData.endpoint;
+    let finalModel = convoData.model ?? baseConversation.model;
+    let finalEndpoint = convoData.endpoint ?? baseConversation.endpoint;
     
     if (!finalModel || !finalEndpoint) {
       // Find the first message with a model (usually the AI response)
@@ -1256,26 +1286,28 @@ async function saveConvoToSolid(req, convoData, metadata) {
       }
     }
 
-    // Prepare conversation object
+    // Merge existing conversation with updates from convoData
+    // convoData takes precedence for fields that are explicitly provided
     const conversationToSave = {
       conversationId: finalConversationId,
       user: req.user.id,
-      title: convoData.title || null,
-      endpoint: finalEndpoint || null,
-      model: finalModel || null,
-      agent_id: convoData.agent_id || null,
-      assistant_id: convoData.assistant_id || null,
-      spec: convoData.spec || null,
-      iconURL: convoData.iconURL || null,
+      // Title: use new value if provided, otherwise preserve existing, otherwise null
+      title: convoData.title !== undefined ? (convoData.title || null) : (baseConversation.title || null),
+      endpoint: finalEndpoint || baseConversation.endpoint || null,
+      model: finalModel || baseConversation.model || null,
+      agent_id: convoData.agent_id !== undefined ? (convoData.agent_id || null) : (baseConversation.agent_id || null),
+      assistant_id: convoData.assistant_id !== undefined ? (convoData.assistant_id || null) : (baseConversation.assistant_id || null),
+      spec: convoData.spec !== undefined ? (convoData.spec || null) : (baseConversation.spec || null),
+      iconURL: convoData.iconURL !== undefined ? (convoData.iconURL || null) : (baseConversation.iconURL || null),
       messages: messageRefs,
-      files: convoData.files || [],
-      promptPrefix: convoData.promptPrefix || null,
-      temperature: convoData.temperature || null,
-      topP: convoData.topP || null,
-      presence_penalty: convoData.presence_penalty || null,
-      frequency_penalty: convoData.frequency_penalty || null,
-      expiredAt: convoData.expiredAt || null,
-      createdAt: convoData.createdAt || new Date().toISOString(),
+      files: convoData.files !== undefined ? (convoData.files || []) : (baseConversation.files || []),
+      promptPrefix: convoData.promptPrefix !== undefined ? (convoData.promptPrefix || null) : (baseConversation.promptPrefix || null),
+      temperature: convoData.temperature !== undefined ? (convoData.temperature || null) : (baseConversation.temperature || null),
+      topP: convoData.topP !== undefined ? (convoData.topP || null) : (baseConversation.topP || null),
+      presence_penalty: convoData.presence_penalty !== undefined ? (convoData.presence_penalty || null) : (baseConversation.presence_penalty || null),
+      frequency_penalty: convoData.frequency_penalty !== undefined ? (convoData.frequency_penalty || null) : (baseConversation.frequency_penalty || null),
+      expiredAt: convoData.expiredAt !== undefined ? (convoData.expiredAt || null) : (baseConversation.expiredAt || null),
+      createdAt: baseConversation.createdAt || new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     };
 
@@ -1289,27 +1321,8 @@ async function saveConvoToSolid(req, convoData, metadata) {
       messageCount: messageRefs.length,
     });
 
-    // Check if conversation already exists
-    let conversationExists = false;
-    try {
-      await getFile(conversationPath, { fetch: authenticatedFetch });
-      conversationExists = true;
-      logger.debug('[SolidStorage] Conversation file already exists, will overwrite', {
-        conversationPath,
-      });
-    } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
-        conversationExists = false;
-        logger.debug('[SolidStorage] Conversation file does not exist, will create', {
-          conversationPath,
-        });
-      } else {
-        logger.warn('[SolidStorage] Error checking if conversation exists, will try to save anyway', {
-          conversationPath,
-          error: error.message,
-        });
-      }
-    }
+    // Determine if conversation exists (we already loaded it above if it exists)
+    const conversationExists = existingConversation !== null;
 
     // If conversationId changed, delete old file
     if (convoData.newConversationId && convoData.conversationId !== convoData.newConversationId) {

From 7c091a06e00d66378a179fafbb5647d7f592c8d0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 12:08:27 +0000
Subject: [PATCH 13/94] update progress documentation

---
 SOLID_INTEGRATION_PROGRESS.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 2ed715df7f7f..4f2b9f77926c 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -88,6 +88,14 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Model information is correctly extracted and passed through the request chain
   - All required payload fields are included for agents endpoints
 
+### 11. Title Persistence
+- **Status**: Complete
+- **Details**:
+  - Conversation titles are properly saved to Solid Pod when generated
+  - Titles persist correctly after page refresh
+  - `saveConvo` correctly identifies Solid users before saving to Solid Pod
+  - `saveConvoToSolid` merges updates with existing conversation data to prevent data loss
+
 ## Current Status
 
 ### Working Features
@@ -99,15 +107,10 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 6. **Conversation Continuation**: Users can send multiple messages in the same conversation
 7. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
 8. **Access Control**: Conversation access validation works for Solid storage users
+9. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
 
 ### Known Issues 🔧
-1. **Title Retrieval on Page Refresh**
-   - **Issue**: When the page is refreshed, conversation titles revert to "untitled" instead of loading the saved title from Solid Pod
-   - **Impact**: Users lose visual context of their conversations after refresh
-   - **Status**: To be fixed
-   - **Priority**: High
-
-2. **Conversation Menu Options**
+1. **Conversation Menu Options**
    - **Issue**: Share, Rename, Duplicate, Archive, and Delete options need to be implemented for Solid storage
    - **Impact**: Users cannot manage their conversations stored in Solid Pod
    - **Status**: Not yet implemented
@@ -148,11 +151,6 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
    - Implement Delete functionality (remove from Solid Pod)
    - Ensure all operations work seamlessly with Solid storage backend
 
-2. **Fix Title Retrieval on Page Refresh**
-   - Issue: When page is refreshed, conversation titles revert to "untitled" instead of loading from Solid Pod
-   - Root Cause: Title not being properly retrieved/loaded from Solid storage on initial page load
-   - Priority: High (affects user experience)
-
 
 ## Files Modified
 - `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations
@@ -166,11 +164,14 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
 - `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
+- `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod
+- `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library
 
 ---
 
-**Report Date**: February 2, 2026  
+**Report Date**: February 3, 2026  
+
 

From 673df961d94e9887d87f63d173131ba79f38d8f7 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 15:00:53 +0000
Subject: [PATCH 14/94] fix(solid): Enable conversation duplication for Solid
 storage users

- Add req parameter to duplicateConversation function for Solid storage support
- Implement individual save operations for Solid users (saveConvo/saveMessage)
- Maintain parent-child message relationships when duplicating
- Use getMessagesFromSolid to retrieve messages from Solid Pod
- Preserve existing bulk save approach for MongoDB users
---
 api/server/routes/convos.js     |   1 +
 api/server/utils/import/fork.js | 109 ++++++++++++++++++++++++++++++--
 2 files changed, 103 insertions(+), 7 deletions(-)

diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index 3081a7904a17..a3a11c9cd1a5 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -325,6 +325,7 @@ router.post('/duplicate', async (req, res) => {
       userId: req.user.id,
       conversationId,
       title,
+      req, // Pass req for Solid storage support
     });
     res.status(201).json(result);
   } catch (error) {
diff --git a/api/server/utils/import/fork.js b/api/server/utils/import/fork.js
index c4ce8cb5d4b0..cbccb5042bab 100644
--- a/api/server/utils/import/fork.js
+++ b/api/server/utils/import/fork.js
@@ -358,26 +358,121 @@ function splitAtTargetLevel(messages, targetMessageId) {
  * @param {object} params - The parameters for duplicating the conversation.
  * @param {string} params.userId - The ID of the user duplicating the conversation.
  * @param {string} params.conversationId - The ID of the conversation to duplicate.
+ * @param {object} [params.req] - Optional Express request object for Solid storage support.
  * @returns {Promise<{ conversation: TConversation, messages: TMessage[] }>} The duplicated conversation and messages.
  */
-async function duplicateConversation({ userId, conversationId }) {
+async function duplicateConversation({ userId, conversationId, req }) {
+  const { isEnabled } = require('@librechat/api');
+  const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+  const isSolidUser = USE_SOLID_STORAGE && req && req.user?.openidId;
+
   // Get original conversation
-  const originalConvo = await getConvo(userId, conversationId);
+  const originalConvo = await getConvo(userId, conversationId, req);
   if (!originalConvo) {
     throw new Error('Conversation not found');
   }
 
   // Get original messages
-  const originalMessages = await getMessages({
-    user: userId,
-    conversationId,
-  });
+  let originalMessages;
+  if (isSolidUser) {
+    const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
+    originalMessages = await getMessagesFromSolid(req, conversationId);
+  } else {
+    originalMessages = await getMessages({
+      user: userId,
+      conversationId,
+    });
+  }
+
+  if (!originalMessages || originalMessages.length === 0) {
+    throw new Error('No messages found in conversation');
+  }
 
   const messagesToClone = getMessagesUpToTargetLevel(
     originalMessages,
     originalMessages[originalMessages.length - 1].messageId,
   );
 
+  // For Solid users, save individually to support Solid storage
+  if (isSolidUser) {
+    const { saveConvo } = require('~/models/Conversation');
+    const { saveMessage } = require('~/models/Message');
+    const { v4: uuidv4 } = require('uuid');
+    const newConversationId = uuidv4();
+    const now = new Date();
+
+    // Create ID mapping for parent message relationships
+    const idMapping = new Map();
+    const sortedMessages = [...messagesToClone].sort((a, b) => {
+      if (a.parentMessageId === Constants.NO_PARENT) {
+        return -1;
+      }
+      if (b.parentMessageId === Constants.NO_PARENT) {
+        return 1;
+      }
+      return 0;
+    });
+
+    // First pass: create ID mapping
+    for (const message of sortedMessages) {
+      const newMessageId = uuidv4();
+      idMapping.set(message.messageId, newMessageId);
+    }
+
+    // Create new conversation
+    const newConvo = {
+      ...originalConvo,
+      conversationId: newConversationId,
+      title: originalConvo.title,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+    };
+    delete newConvo._id;
+
+    // Save conversation
+    await saveConvo(req, newConvo, { context: 'duplicateConversation' });
+
+    // Save messages individually with proper parent ID mapping
+    const savedMessages = [];
+    for (const message of sortedMessages) {
+      const newMessageId = idMapping.get(message.messageId);
+      const newParentMessageId =
+        message.parentMessageId === Constants.NO_PARENT
+          ? Constants.NO_PARENT
+          : idMapping.get(message.parentMessageId) || Constants.NO_PARENT;
+
+      const newMessage = {
+        ...message,
+        messageId: newMessageId,
+        parentMessageId: newParentMessageId,
+        conversationId: newConversationId,
+        createdAt: message.createdAt || now.toISOString(),
+        updatedAt: message.updatedAt || now.toISOString(),
+      };
+      delete newMessage._id;
+
+      const savedMessage = await saveMessage(req, newMessage, {
+        context: 'duplicateConversation',
+      });
+      savedMessages.push(savedMessage);
+    }
+
+    logger.debug(
+      `user: ${userId} | New conversation "${originalConvo.title}" duplicated from conversation ID ${conversationId}`,
+    );
+
+    // Get the saved conversation and messages
+    const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
+    const conversation = await getConvo(userId, newConversationId, req);
+    const messages = await getMessagesFromSolid(req, newConversationId);
+
+    return {
+      conversation,
+      messages,
+    };
+  }
+
+  // For MongoDB users, use the existing bulk save approach
   const importBatchBuilder = createImportBatchBuilder(userId);
   importBatchBuilder.startConversation(originalConvo.endpoint ?? EModelEndpoint.openAI);
 
@@ -393,7 +488,7 @@ async function duplicateConversation({ userId, conversationId }) {
     `user: ${userId} | New conversation "${originalConvo.title}" duplicated from conversation ID ${conversationId}`,
   );
 
-  const conversation = await getConvo(userId, result.conversation.conversationId);
+  const conversation = await getConvo(userId, result.conversation.conversationId, req);
   const messages = await getMessages({
     user: userId,
     conversationId: conversation.conversationId,

From f539c850afd750cc508496e2ed9976dfd8bd93f0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 15:05:24 +0000
Subject: [PATCH 15/94] update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 4f2b9f77926c..ebc734b3305c 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -96,6 +96,15 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - `saveConvo` correctly identifies Solid users before saving to Solid Pod
   - `saveConvoToSolid` merges updates with existing conversation data to prevent data loss
 
+### 12. Conversation Management Operations
+- **Status**: Partially Complete
+- **Details**:
+  - **Rename**: Working - Users can rename conversations stored in Solid Pod
+  - **Duplicate**: Working - Users can duplicate conversations and all messages from Solid Pod
+  - **Share**: Not yet implemented
+  - **Archive**: Not yet implemented
+  - **Delete**: Not yet implemented
+
 ## Current Status
 
 ### Working Features
@@ -108,11 +117,13 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 7. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
 8. **Access Control**: Conversation access validation works for Solid storage users
 9. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
+10. **Conversation Rename**: Users can rename conversations stored in Solid Pod
+11. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
 
 ### Known Issues 🔧
 1. **Conversation Menu Options**
-   - **Issue**: Share, Rename, Duplicate, Archive, and Delete options need to be implemented for Solid storage
-   - **Impact**: Users cannot manage their conversations stored in Solid Pod
+   - **Issue**: Share, Archive, and Delete options need to be implemented for Solid storage
+   - **Impact**: Users cannot share, archive, or delete conversations stored in Solid Pod
    - **Status**: Not yet implemented
    - **Priority**: High
 
@@ -145,8 +156,6 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 
 1. **Conversation Menu Options Implementation**
    - Implement Share functionality for Solid storage conversations
-   - Implement Rename functionality (update conversation title in Solid Pod)
-   - Implement Duplicate functionality (create copy in Solid Pod)
    - Implement Archive functionality (mark as archived in Solid Pod)
    - Implement Delete functionality (remove from Solid Pod)
    - Ensure all operations work seamlessly with Solid storage backend
@@ -166,6 +175,8 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
 - `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod
 - `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data
+- `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
+- `api/server/routes/convos.js` - Updated duplicate endpoint to pass `req` for Solid storage support
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library

From 5adb126e8b7df04901e1e38f0a4c1ac4fc179038 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 17:27:25 +0000
Subject: [PATCH 16/94] fix(solid): Enable conversation deletion for Solid
 storage users

- Added req parameter to deleteConvos function for Solid storage support
- Implemented Solid storage deletion using deleteConvosFromSolid
- Delete all associated messages when deleting conversations
- Handle both single conversation and bulk deletion scenarios
- Maintained MongoDB compatibility for non-Solid users
---
 api/models/Conversation.js          | 70 ++++++++++++++++++++++++++++-
 api/server/routes/convos.js         |  4 +-
 api/server/services/SolidStorage.js | 40 ++++++++++++++++-
 3 files changed, 109 insertions(+), 5 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 931e81565588..8e0b6f6837d5 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -459,6 +459,7 @@ module.exports = {
    * @function
    * @param {string|ObjectId} user - The user's ID.
    * @param {Object} filter - Additional filter criteria for the conversations to be deleted.
+   * @param {Object} [req] - Optional Express request object for Solid storage support.
    * @returns {Promise<{ n: number, ok: number, deletedCount: number, messages: { n: number, ok: number, deletedCount: number } }>}
    *          An object containing the count of deleted conversations and associated messages.
    * @throws {Error} Throws an error if there's an issue with the database operations.
@@ -469,7 +470,74 @@ module.exports = {
    * const result = await deleteConvos(user, filter);
    * logger.error(result); // { n: 5, ok: 1, deletedCount: 5, messages: { n: 10, ok: 1, deletedCount: 10 } }
    */
-  deleteConvos: async (user, filter) => {
+  deleteConvos: async (user, filter, req = null) => {
+    // Use Solid storage if enabled and req is provided with openidId
+    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+      try {
+        const { deleteConvosFromSolid } = require('~/server/services/SolidStorage');
+        const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
+
+        let conversationIds = [];
+
+        // If conversationId is specified in filter, use it directly
+        if (filter.conversationId) {
+          conversationIds = [filter.conversationId];
+        } else {
+          // Otherwise, get all conversations matching the filter from Solid Pod
+          // For now, we'll get all conversations and filter in memory
+          // This is not ideal for large datasets, but Solid Pod doesn't support complex queries
+          const allConversations = await getConvosByCursorFromSolid(req, {
+            limit: 10000, // Large limit to get all conversations
+            isArchived: filter.isArchived,
+          });
+
+          // Filter conversations based on the filter criteria
+          let filteredConversations = allConversations.conversations;
+          
+          if (filter.conversationId) {
+            filteredConversations = filteredConversations.filter(
+              (c) => c.conversationId === filter.conversationId
+            );
+          }
+          
+          if (filter.endpoint) {
+            filteredConversations = filteredConversations.filter(
+              (c) => c.endpoint === filter.endpoint
+            );
+          }
+
+          conversationIds = filteredConversations.map((c) => c.conversationId);
+        }
+
+        if (!conversationIds.length) {
+          throw new Error('Conversation not found or already deleted.');
+        }
+
+        const deletedCount = await deleteConvosFromSolid(req, conversationIds);
+
+        // Return format similar to MongoDB deleteMany result
+        return {
+          n: deletedCount,
+          ok: deletedCount > 0 ? 1 : 0,
+          deletedCount,
+          messages: {
+            n: deletedCount, // Messages are deleted as part of deleteConvosFromSolid
+            ok: deletedCount > 0 ? 1 : 0,
+            deletedCount,
+          },
+        };
+      } catch (error) {
+        logger.error('[deleteConvos] Error deleting conversations from Solid Pod', {
+          error: error.message,
+          stack: error.stack,
+          filter,
+          userId: user,
+        });
+        throw error;
+      }
+    }
+
+    // MongoDB storage (original code)
     try {
       const userFilter = { ...filter, user };
       const conversations = await Conversation.find(userFilter).select('conversationId');
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index a3a11c9cd1a5..0e50e86a7486 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -165,7 +165,7 @@ router.delete('/', async (req, res) => {
   }
 
   try {
-    const dbResponse = await deleteConvos(req.user.id, filter);
+    const dbResponse = await deleteConvos(req.user.id, filter, req); // Pass req for Solid storage support
     if (filter.conversationId) {
       await deleteToolCalls(req.user.id, filter.conversationId);
       await deleteConvoSharedLink(req.user.id, filter.conversationId);
@@ -179,7 +179,7 @@ router.delete('/', async (req, res) => {
 
 router.delete('/all', async (req, res) => {
   try {
-    const dbResponse = await deleteConvos(req.user.id, {});
+    const dbResponse = await deleteConvos(req.user.id, {}, req); // Pass req for Solid storage support
     await deleteToolCalls(req.user.id);
     await deleteAllSharedLinks(req.user.id);
     res.status(201).json(dbResponse);
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 306679a29f4b..94ba63ae1b56 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1918,14 +1918,50 @@ async function deleteConvosFromSolid(req, conversationIds) {
           const messagesDeleted = await deleteMessagesFromSolid(req, {
             conversationId,
           });
-          logger.debug('[SolidStorage] Messages deleted for conversation', {
+          
+          logger.info('[SolidStorage] Messages deleted for conversation', {
             conversationId,
             messagesDeleted,
           });
+          
+          if (messagesDeleted === 0) {
+            logger.warn('[SolidStorage] No messages were deleted - this may indicate an issue', {
+              conversationId,
+            });
+          }
+          
+          // Also try to delete the messages container directory if it's empty
+          // This is optional - some Solid servers handle empty containers automatically
+          try {
+            const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
+            // Try to delete the container - this may fail if it's not empty or not allowed
+            // We'll just log and continue if it fails
+            try {
+              await deleteFile(messagesContainerPath, { fetch: authenticatedFetch });
+              logger.debug('[SolidStorage] Messages container directory deleted', {
+                conversationId,
+                messagesContainerPath,
+              });
+            } catch (containerError) {
+              // It's okay if we can't delete the container - the files are already deleted
+              logger.debug('[SolidStorage] Could not delete messages container (may not be empty or not allowed)', {
+                conversationId,
+                messagesContainerPath,
+                error: containerError.message,
+              });
+            }
+          } catch (containerPathError) {
+            // Ignore errors when trying to delete the container
+            logger.debug('[SolidStorage] Error getting messages container path for deletion', {
+              conversationId,
+              error: containerPathError.message,
+            });
+          }
         } catch (error) {
-          logger.warn('[SolidStorage] Error deleting messages for conversation, continuing', {
+          logger.error('[SolidStorage] Error deleting messages for conversation - THIS IS A PROBLEM', {
             conversationId,
             error: error.message,
+            stack: error.stack,
           });
           // Continue with conversation deletion even if messages fail
         }

From 399b46c3dbed27a90e387891b1f7c0937f215138 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Feb 2026 17:30:50 +0000
Subject: [PATCH 17/94] Update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index ebc734b3305c..afdc6ba3e2c6 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -101,9 +101,9 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - **Details**:
   - **Rename**: Working - Users can rename conversations stored in Solid Pod
   - **Duplicate**: Working - Users can duplicate conversations and all messages from Solid Pod
+  - **Delete**: Working - Users can delete conversations and all associated messages from Solid Pod
   - **Share**: Not yet implemented
   - **Archive**: Not yet implemented
-  - **Delete**: Not yet implemented
 
 ## Current Status
 
@@ -119,11 +119,12 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 9. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
 10. **Conversation Rename**: Users can rename conversations stored in Solid Pod
 11. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
+12. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
 
 ### Known Issues 🔧
 1. **Conversation Menu Options**
-   - **Issue**: Share, Archive, and Delete options need to be implemented for Solid storage
-   - **Impact**: Users cannot share, archive, or delete conversations stored in Solid Pod
+   - **Issue**: Share and Archive options need to be implemented for Solid storage
+   - **Impact**: Users cannot share or archive conversations stored in Solid Pod
    - **Status**: Not yet implemented
    - **Priority**: High
 
@@ -157,7 +158,6 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 1. **Conversation Menu Options Implementation**
    - Implement Share functionality for Solid storage conversations
    - Implement Archive functionality (mark as archived in Solid Pod)
-   - Implement Delete functionality (remove from Solid Pod)
    - Ensure all operations work seamlessly with Solid storage backend
 
 
@@ -173,10 +173,10 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
 - `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
-- `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod
-- `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data
+- `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod, added Solid storage support to `deleteConvos`
+- `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data, improved message deletion logging
 - `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
-- `api/server/routes/convos.js` - Updated duplicate endpoint to pass `req` for Solid storage support
+- `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library

From 8f9cfbe1943222927ff01e236e66b28616bdc011 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 4 Feb 2026 11:06:14 +0000
Subject: [PATCH 18/94] feat: implement archive functionality for Solid storage
 users - Add support for archiving and unarchiving conversations stored in
 Solid Pods. - The isArchived field is now properly saved, retrieved, and
 filtered when fetching conversations for Solid-authenticated users.

---
 api/server/services/SolidStorage.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 94ba63ae1b56..ef8bebebe699 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1307,6 +1307,7 @@ async function saveConvoToSolid(req, convoData, metadata) {
       presence_penalty: convoData.presence_penalty !== undefined ? (convoData.presence_penalty || null) : (baseConversation.presence_penalty || null),
       frequency_penalty: convoData.frequency_penalty !== undefined ? (convoData.frequency_penalty || null) : (baseConversation.frequency_penalty || null),
       expiredAt: convoData.expiredAt !== undefined ? (convoData.expiredAt || null) : (baseConversation.expiredAt || null),
+      isArchived: convoData.isArchived !== undefined ? (convoData.isArchived || false) : (baseConversation.isArchived || false),
       createdAt: baseConversation.createdAt || new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     };
@@ -1838,6 +1839,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       assistant_id: convo.assistant_id,
       spec: convo.spec,
       iconURL: convo.iconURL,
+      isArchived: convo.isArchived || false,
     }));
 
     logger.info('[SolidStorage] Conversations retrieved successfully', {

From 77f4c08e87af8a8eb7424767ff30f52d711cc058 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 4 Feb 2026 11:19:17 +0000
Subject: [PATCH 19/94] Update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index afdc6ba3e2c6..15c4c8c0d89a 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -102,8 +102,8 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - **Rename**: Working - Users can rename conversations stored in Solid Pod
   - **Duplicate**: Working - Users can duplicate conversations and all messages from Solid Pod
   - **Delete**: Working - Users can delete conversations and all associated messages from Solid Pod
+  - **Archive**: Working - Users can archive and unarchive conversations stored in Solid Pod
   - **Share**: Not yet implemented
-  - **Archive**: Not yet implemented
 
 ## Current Status
 
@@ -120,13 +120,14 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 10. **Conversation Rename**: Users can rename conversations stored in Solid Pod
 11. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
 12. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
+13. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
 
 ### Known Issues 🔧
 1. **Conversation Menu Options**
-   - **Issue**: Share and Archive options need to be implemented for Solid storage
-   - **Impact**: Users cannot share or archive conversations stored in Solid Pod
+   - **Issue**: Share option needs to be implemented for Solid storage
+   - **Impact**: Users cannot share conversations stored in Solid Pod
    - **Status**: Not yet implemented
-   - **Priority**: High
+   - **Priority**: Medium
 
 ## Technical Implementation
 
@@ -157,7 +158,6 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 
 1. **Conversation Menu Options Implementation**
    - Implement Share functionality for Solid storage conversations
-   - Implement Archive functionality (mark as archived in Solid Pod)
    - Ensure all operations work seamlessly with Solid storage backend
 
 
@@ -177,6 +177,7 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data, improved message deletion logging
 - `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
 - `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
+- `api/server/services/SolidStorage.js` - Added `isArchived` field support in `saveConvoToSolid` and `getConvosByCursorFromSolid` for archive functionality
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library

From 43844477354baa8885a436c51e8c49d953dc4a3f Mon Sep 17 00:00:00 2001
From: Jesse Wright <63333554+jeswr@users.noreply.github.com>
Date: Thu, 5 Feb 2026 09:54:59 +0000
Subject: [PATCH 20/94] Comment out unused fields and add TODOs

Commented out several lines in conversation object construction and added TODOs for future enhancements.
---
 api/server/services/SolidStorage.js | 35 ++++++++++++++++-------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index ef8bebebe699..4857b9bbdf8a 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1213,6 +1213,7 @@ async function saveConvoToSolid(req, convoData, metadata) {
 
     // Get authenticated fetch and Pod URL
     const authenticatedFetch = await getSolidFetch(req);
+    // 
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
 
     // Ensure base structure exists
@@ -1289,25 +1290,27 @@ async function saveConvoToSolid(req, convoData, metadata) {
     // Merge existing conversation with updates from convoData
     // convoData takes precedence for fields that are explicitly provided
     const conversationToSave = {
+      ...baseConversation,
+      ...convoData,
       conversationId: finalConversationId,
       user: req.user.id,
       // Title: use new value if provided, otherwise preserve existing, otherwise null
-      title: convoData.title !== undefined ? (convoData.title || null) : (baseConversation.title || null),
-      endpoint: finalEndpoint || baseConversation.endpoint || null,
-      model: finalModel || baseConversation.model || null,
-      agent_id: convoData.agent_id !== undefined ? (convoData.agent_id || null) : (baseConversation.agent_id || null),
-      assistant_id: convoData.assistant_id !== undefined ? (convoData.assistant_id || null) : (baseConversation.assistant_id || null),
-      spec: convoData.spec !== undefined ? (convoData.spec || null) : (baseConversation.spec || null),
-      iconURL: convoData.iconURL !== undefined ? (convoData.iconURL || null) : (baseConversation.iconURL || null),
+      // title: convoData.title !== undefined ? (convoData.title || null) : (baseConversation.title || null),
+      // endpoint: finalEndpoint || baseConversation.endpoint || null,
+      // model: finalModel || baseConversation.model || null,
+      // agent_id: convoData.agent_id !== undefined ? (convoData.agent_id || null) : (baseConversation.agent_id || null),
+      // assistant_id: convoData.assistant_id !== undefined ? (convoData.assistant_id || null) : (baseConversation.assistant_id || null),
+      // spec: convoData.spec !== undefined ? (convoData.spec || null) : (baseConversation.spec || null),
+      // iconURL: convoData.iconURL !== undefined ? (convoData.iconURL || null) : (baseConversation.iconURL || null),
       messages: messageRefs,
-      files: convoData.files !== undefined ? (convoData.files || []) : (baseConversation.files || []),
-      promptPrefix: convoData.promptPrefix !== undefined ? (convoData.promptPrefix || null) : (baseConversation.promptPrefix || null),
-      temperature: convoData.temperature !== undefined ? (convoData.temperature || null) : (baseConversation.temperature || null),
-      topP: convoData.topP !== undefined ? (convoData.topP || null) : (baseConversation.topP || null),
-      presence_penalty: convoData.presence_penalty !== undefined ? (convoData.presence_penalty || null) : (baseConversation.presence_penalty || null),
-      frequency_penalty: convoData.frequency_penalty !== undefined ? (convoData.frequency_penalty || null) : (baseConversation.frequency_penalty || null),
-      expiredAt: convoData.expiredAt !== undefined ? (convoData.expiredAt || null) : (baseConversation.expiredAt || null),
-      isArchived: convoData.isArchived !== undefined ? (convoData.isArchived || false) : (baseConversation.isArchived || false),
+      // files: convoData.files !== undefined ? (convoData.files || []) : (baseConversation.files || []),
+      // promptPrefix: convoData.promptPrefix !== undefined ? (convoData.promptPrefix || null) : (baseConversation.promptPrefix || null),
+      // temperature: convoData.temperature !== undefined ? (convoData.temperature || null) : (baseConversation.temperature || null),
+      // topP: convoData.topP !== undefined ? (convoData.topP || null) : (baseConversation.topP || null),
+      // presence_penalty: convoData.presence_penalty !== undefined ? (convoData.presence_penalty || null) : (baseConversation.presence_penalty || null),
+      // frequency_penalty: convoData.frequency_penalty !== undefined ? (convoData.frequency_penalty || null) : (baseConversation.frequency_penalty || null),
+      // expiredAt: convoData.expiredAt !== undefined ? (convoData.expiredAt || null) : (baseConversation.expiredAt || null),
+      // isArchived: convoData.isArchived !== undefined ? (convoData.isArchived || false) : (baseConversation.isArchived || false),
       createdAt: baseConversation.createdAt || new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     };
@@ -1551,6 +1554,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
 
     // Get authenticated fetch and Pod URL
     const authenticatedFetch = await getSolidFetch(req);
+    // TODO: Allow user to select their storage (can happen after the initial PR).
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
 
     // Get conversations container path
@@ -1590,6 +1594,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       
       // Parse Turtle format to extract all items from ldp:contains
       // Handle both single and comma-separated items: ldp:contains <item1>, <item2>.
+      // TODO: Use object mapper to parse this.
       const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
       const allItems = [];
       let match;

From 69a12105dcd876f9d126c8ac7de00294c2e46023 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 5 Feb 2026 09:59:13 +0000
Subject: [PATCH 21/94] debugging sharing

---
 api/server/routes/convos.js                |   4 +-
 api/server/routes/share.js                 |  51 +-
 api/server/services/SolidStorage.js        | 516 ++++++++++++++++++++-
 packages/data-schemas/src/methods/share.ts | 341 +++++++++++++-
 packages/data-schemas/src/schema/share.ts  |   5 +
 5 files changed, 891 insertions(+), 26 deletions(-)

diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index 0e50e86a7486..01e966c2f8e7 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -167,8 +167,8 @@ router.delete('/', async (req, res) => {
   try {
     const dbResponse = await deleteConvos(req.user.id, filter, req); // Pass req for Solid storage support
     if (filter.conversationId) {
-      await deleteToolCalls(req.user.id, filter.conversationId);
-      await deleteConvoSharedLink(req.user.id, filter.conversationId);
+          await deleteToolCalls(req.user.id, filter.conversationId);
+          await deleteConvoSharedLink(req.user.id, filter.conversationId, req);
     }
     res.status(201).json(dbResponse);
   } catch (error) {
diff --git a/api/server/routes/share.js b/api/server/routes/share.js
index 6400b8b637a5..e4c49409701a 100644
--- a/api/server/routes/share.js
+++ b/api/server/routes/share.js
@@ -99,16 +99,59 @@ router.get('/link/:conversationId', requireJwtAuth, async (req, res) => {
 
 router.post('/:conversationId', requireJwtAuth, async (req, res) => {
   try {
+    logger.info('[share route] Creating shared link', {
+      userId: req.user.id,
+      conversationId: req.params.conversationId,
+      targetMessageId: req.body.targetMessageId,
+      hasOpenidId: !!req.user.openidId,
+      openidId: req.user.openidId,
+    });
     const { targetMessageId } = req.body;
-    const created = await createSharedLink(req.user.id, req.params.conversationId, targetMessageId);
+    
+    // Check if createSharedLink exists
+    if (typeof createSharedLink !== 'function') {
+      logger.error('[share route] createSharedLink is not a function', {
+        type: typeof createSharedLink,
+        createSharedLink,
+      });
+      return res.status(500).json({ message: 'Share service not available' });
+    }
+    
+    logger.info('[share route] Calling createSharedLink', {
+      userId: req.user.id,
+      conversationId: req.params.conversationId,
+      targetMessageId,
+      hasReq: !!req,
+    });
+    
+    const created = await createSharedLink(req.user.id, req.params.conversationId, targetMessageId, req);
+    
+    logger.info('[share route] createSharedLink returned', {
+      hasResult: !!created,
+      resultType: typeof created,
+    });
+    
     if (created) {
       res.status(200).json(created);
     } else {
       res.status(404).end();
     }
   } catch (error) {
-    logger.error('Error creating shared link:', error);
-    res.status(500).json({ message: 'Error creating shared link' });
+    console.error('[share route] Error caught:', error);
+    logger.error('Error creating shared link:', {
+      error: error?.message || String(error),
+      errorName: error?.name,
+      errorCode: error?.code,
+      stack: error?.stack,
+      errorType: typeof error,
+      errorString: String(error),
+      errorKeys: error ? Object.keys(error) : [],
+      userId: req.user?.id,
+      conversationId: req.params?.conversationId,
+      fullError: error,
+    });
+    const errorMessage = error?.message || error?.code || 'Error creating shared link';
+    res.status(500).json({ message: errorMessage });
   }
 });
 
@@ -128,7 +171,7 @@ router.patch('/:shareId', requireJwtAuth, async (req, res) => {
 
 router.delete('/:shareId', requireJwtAuth, async (req, res) => {
   try {
-    const result = await deleteSharedLink(req.user.id, req.params.shareId);
+    const result = await deleteSharedLink(req.user.id, req.params.shareId, req);
 
     if (!result) {
       return res.status(404).json({ message: 'Share not found' });
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 4857b9bbdf8a..2be69effe2e7 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -7,6 +7,9 @@ const {
   deleteFile,
   getPodUrlAll,
   createContainerAt,
+  getPublicAccess,
+  setPublicAccess,
+  removePublicAccess,
 } = require('@inrupt/solid-client');
 
 /**
@@ -1426,12 +1429,84 @@ async function getConvoFromSolid(req, conversationId) {
       const fileText = await file.text();
       const conversationData = JSON.parse(fileText);
 
+      logger.info('[SolidStorage] Conversation file read successfully, checking user ID', {
+        conversationId,
+        conversationUserId: conversationData.user,
+        conversationUserIdType: typeof conversationData.user,
+        currentUserId: req.user.id,
+        currentUserIdType: typeof req.user.id,
+        conversationHasUser: 'user' in conversationData,
+        conversationDataKeys: Object.keys(conversationData),
+      });
+
       // Validate that this conversation belongs to the current user
-      if (conversationData.user !== req.user.id) {
-        logger.warn('[SolidStorage] Conversation belongs to different user', {
+      // Convert both to strings for comparison to handle ObjectId vs string mismatches
+      // Handle cases where user might be an ObjectId object (MongoDB) or a string
+      let conversationUserId = conversationData.user;
+      if (!conversationUserId) {
+        logger.error('[SolidStorage] Conversation has no user field - RETURNING NULL', {
           conversationId,
-          conversationUserId: conversationData.user,
-          currentUserId: req.user.id,
+          conversationDataKeys: Object.keys(conversationData),
+        });
+        return null;
+      }
+      
+      if (conversationUserId && typeof conversationUserId === 'object' && conversationUserId.toString) {
+        conversationUserId = conversationUserId.toString();
+      } else {
+        conversationUserId = String(conversationUserId || '');
+      }
+      
+      let currentUserId = req.user.id;
+      if (!currentUserId) {
+        logger.error('[SolidStorage] Request has no user ID - RETURNING NULL', {
+          conversationId,
+          hasUser: !!req.user,
+          userKeys: req.user ? Object.keys(req.user) : [],
+        });
+        return null;
+      }
+      
+      if (currentUserId && typeof currentUserId === 'object' && currentUserId.toString) {
+        currentUserId = currentUserId.toString();
+      } else {
+        currentUserId = String(currentUserId || '');
+      }
+      
+      // Trim whitespace and compare
+      conversationUserId = conversationUserId.trim();
+      currentUserId = currentUserId.trim();
+      
+      logger.info('[SolidStorage] Comparing user IDs in getConvoFromSolid', {
+        conversationId,
+        conversationUserIdRaw: conversationData.user,
+        conversationUserIdString: conversationUserId,
+        currentUserIdRaw: req.user.id,
+        currentUserIdString: currentUserId,
+        userIdType: typeof req.user.id,
+        conversationUserIdType: typeof conversationData.user,
+        userIdsMatch: conversationUserId === currentUserId,
+        conversationUserIdLength: conversationUserId.length,
+        currentUserIdLength: currentUserId.length,
+        areEqual: conversationUserId === currentUserId,
+        conversationUserIdCharCodes: conversationUserId.split('').map(c => c.charCodeAt(0)),
+        currentUserIdCharCodes: currentUserId.split('').map(c => c.charCodeAt(0)),
+      });
+      
+      if (conversationUserId !== currentUserId) {
+        logger.error('[SolidStorage] Conversation belongs to different user - RETURNING NULL', {
+          conversationId,
+          conversationUserIdRaw: conversationData.user,
+          conversationUserIdString: conversationUserId,
+          currentUserIdRaw: req.user.id,
+          currentUserIdString: currentUserId,
+          userIdType: typeof req.user.id,
+          conversationUserIdType: typeof conversationData.user,
+          conversationUserIdLength: conversationUserId.length,
+          currentUserIdLength: currentUserId.length,
+          areEqual: conversationUserId === currentUserId,
+          conversationUserIdCharCodes: conversationUserId.split('').map(c => c.charCodeAt(0)),
+          currentUserIdCharCodes: currentUserId.split('').map(c => c.charCodeAt(0)),
         });
         return null;
       }
@@ -2022,6 +2097,436 @@ async function deleteConvosFromSolid(req, conversationIds) {
   }
 }
 
+/**
+ * Set public read access for a shared conversation and its messages
+ * This makes the conversation and all its messages publicly accessible
+ * 
+ * @param {Object} req - Express request object
+ * @param {string} conversationId - The conversation ID to share
+ * @returns {Promise<void>}
+ */
+async function setPublicAccessForShare(req, conversationId) {
+  try {
+    logger.info('[SolidStorage] Setting public access for shared conversation', {
+      conversationId,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get conversation file path
+    const conversationPath = getConversationPath(podUrl, conversationId);
+
+    // Verify conversation belongs to user before sharing
+    try {
+      const conversation = await getConvoFromSolid(req, conversationId);
+      if (!conversation) {
+        throw new Error('Conversation not found or does not belong to user');
+      }
+    } catch (error) {
+      logger.error('[SolidStorage] Error verifying conversation ownership before sharing', {
+        conversationId,
+        error: error.message,
+      });
+      throw error;
+    }
+
+    // Get all messages for this conversation
+    const messages = await getMessagesFromSolid(req, conversationId);
+
+    if (messages.length === 0) {
+      logger.warn('[SolidStorage] No messages found for conversation to share', {
+        conversationId,
+      });
+      throw new Error('No messages to share');
+    }
+
+    // Set public read access on conversation file
+    try {
+      const conversationFile = await getFile(conversationPath, { fetch: authenticatedFetch });
+      await setPublicAccess(conversationFile, { read: true }, { fetch: authenticatedFetch });
+      logger.info('[SolidStorage] Public read access set on conversation file', {
+        conversationPath,
+        conversationId,
+      });
+    } catch (error) {
+      logger.error('[SolidStorage] Error setting public access on conversation file', {
+        conversationPath,
+        conversationId,
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
+
+    // Set public read access on messages container
+    const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
+    try {
+      const messagesContainer = await getFile(messagesContainerPath, { fetch: authenticatedFetch });
+      await setPublicAccess(messagesContainer, { read: true }, { fetch: authenticatedFetch });
+      logger.info('[SolidStorage] Public read access set on messages container', {
+        messagesContainerPath,
+        conversationId,
+      });
+    } catch (error) {
+      logger.error('[SolidStorage] Error setting public access on messages container', {
+        messagesContainerPath,
+        conversationId,
+        error: error.message,
+        stack: error.stack,
+      });
+      // Continue with message files even if container access fails
+    }
+
+    // Set public read access on each message file
+    let messagesShared = 0;
+    for (const message of messages) {
+      try {
+        const messagePath = getMessagePath(podUrl, conversationId, message.messageId);
+        const messageFile = await getFile(messagePath, { fetch: authenticatedFetch });
+        await setPublicAccess(messageFile, { read: true }, { fetch: authenticatedFetch });
+        messagesShared++;
+      } catch (error) {
+        logger.error('[SolidStorage] Error setting public access on message file', {
+          messageId: message.messageId,
+          conversationId,
+          error: error.message,
+        });
+        // Continue with other messages even if one fails
+      }
+    }
+
+    logger.info('[SolidStorage] Public access set for shared conversation', {
+      conversationId,
+      messagesShared,
+      totalMessages: messages.length,
+    });
+  } catch (error) {
+    logger.error('[SolidStorage] Error setting public access for share', {
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Remove public read access for a shared conversation and its messages
+ * This unshares the conversation and makes it private again
+ * 
+ * @param {Object} req - Express request object
+ * @param {string} conversationId - The conversation ID to unshare
+ * @returns {Promise<void>}
+ */
+async function removePublicAccessForShare(req, conversationId) {
+  try {
+    logger.info('[SolidStorage] Removing public access for shared conversation', {
+      conversationId,
+    });
+
+    // Validate required fields
+    if (!req?.user?.id) {
+      throw new Error('User not authenticated');
+    }
+
+    if (!conversationId) {
+      throw new Error('conversationId is required');
+    }
+
+    // Get authenticated fetch and Pod URL
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+
+    // Get conversation file path
+    const conversationPath = getConversationPath(podUrl, conversationId);
+
+    // Remove public read access from conversation file
+    try {
+      const conversationFile = await getFile(conversationPath, { fetch: authenticatedFetch });
+      await removePublicAccess(conversationFile, { fetch: authenticatedFetch });
+      logger.info('[SolidStorage] Public read access removed from conversation file', {
+        conversationPath,
+        conversationId,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        logger.debug('[SolidStorage] Conversation file not found when removing public access', {
+          conversationPath,
+          conversationId,
+        });
+      } else {
+        logger.error('[SolidStorage] Error removing public access from conversation file', {
+          conversationPath,
+          conversationId,
+          error: error.message,
+          stack: error.stack,
+        });
+        // Continue with other files even if one fails
+      }
+    }
+
+    // Remove public read access from messages container
+    const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
+    try {
+      const messagesContainer = await getFile(messagesContainerPath, { fetch: authenticatedFetch });
+      await removePublicAccess(messagesContainer, { fetch: authenticatedFetch });
+      logger.info('[SolidStorage] Public read access removed from messages container', {
+        messagesContainerPath,
+        conversationId,
+      });
+    } catch (error) {
+      if (error.status === 404 || error.message?.includes('404')) {
+        logger.debug('[SolidStorage] Messages container not found when removing public access', {
+          messagesContainerPath,
+          conversationId,
+        });
+      } else {
+        logger.error('[SolidStorage] Error removing public access from messages container', {
+          messagesContainerPath,
+          conversationId,
+          error: error.message,
+        });
+        // Continue with message files even if container access fails
+      }
+    }
+
+    // Try to get messages (they might not exist if conversation was deleted)
+    let messages = [];
+    try {
+      messages = await getMessagesFromSolid(req, conversationId);
+    } catch (error) {
+      logger.debug('[SolidStorage] Could not fetch messages when removing public access (conversation may be deleted)', {
+        conversationId,
+        error: error.message,
+      });
+    }
+
+    // Remove public read access from each message file
+    let messagesUnshared = 0;
+    for (const message of messages) {
+      try {
+        const messagePath = getMessagePath(podUrl, conversationId, message.messageId);
+        const messageFile = await getFile(messagePath, { fetch: authenticatedFetch });
+        await removePublicAccess(messageFile, { fetch: authenticatedFetch });
+        messagesUnshared++;
+      } catch (error) {
+        if (error.status === 404 || error.message?.includes('404')) {
+          logger.debug('[SolidStorage] Message file not found when removing public access', {
+            messageId: message.messageId,
+            conversationId,
+          });
+          messagesUnshared++; // Count as unshared if already deleted
+        } else {
+          logger.error('[SolidStorage] Error removing public access from message file', {
+            messageId: message.messageId,
+            conversationId,
+            error: error.message,
+          });
+          // Continue with other messages even if one fails
+        }
+      }
+    }
+
+    logger.info('[SolidStorage] Public access removed for shared conversation', {
+      conversationId,
+      messagesUnshared,
+      totalMessages: messages.length,
+    });
+  } catch (error) {
+    logger.error('[SolidStorage] Error removing public access for share', {
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Get shared messages from Solid Pod using public access (no authentication required)
+ * 
+ * @param {string} shareId - The share ID
+ * @param {string} conversationId - The conversation ID (from SharedLink)
+ * @param {string} podUrl - The Pod URL where the conversation is stored
+ * @param {string} [targetMessageId] - Optional target message ID for branch sharing
+ * @returns {Promise<Object|null>} Shared conversation with messages, or null if not found
+ */
+async function getSharedMessagesFromSolid(shareId, conversationId, podUrl, targetMessageId) {
+  try {
+    logger.info('[SolidStorage] Getting shared messages from Solid Pod', {
+      shareId,
+      conversationId,
+      targetMessageId,
+    });
+
+    // Use unauthenticated fetch for public access
+    const publicFetch = fetch;
+
+    // Get conversation file path
+    const conversationPath = getConversationPath(podUrl, conversationId);
+
+    // Try to fetch conversation file with public access
+    let conversationData;
+    try {
+      const file = await getFile(conversationPath, { fetch: publicFetch });
+      const fileText = await file.text();
+      conversationData = JSON.parse(fileText);
+    } catch (error) {
+      if (error.status === 404 || error.status === 403) {
+        logger.warn('[SolidStorage] Conversation not found or not publicly accessible', {
+          conversationId,
+          shareId,
+          error: error.message,
+        });
+        return null;
+      }
+      throw error;
+    }
+
+    // Get all messages for this conversation using public access
+    const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
+    let messages = [];
+    
+    try {
+      // Try to get container contents
+      const containerResponse = await publicFetch(messagesContainerPath, {
+        method: 'GET',
+        headers: {
+          'Accept': 'text/turtle',
+        },
+      });
+
+      if (!containerResponse.ok) {
+        if (containerResponse.status === 404 || containerResponse.status === 403) {
+          logger.warn('[SolidStorage] Messages container not found or not publicly accessible', {
+            conversationId,
+            shareId,
+            status: containerResponse.status,
+          });
+          return null;
+        }
+        throw new Error(`Failed to fetch messages container: ${containerResponse.status} ${containerResponse.statusText}`);
+      }
+
+      const containerText = await containerResponse.text();
+      
+      // Parse Turtle format to extract all items from ldp:contains
+      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
+      const allItems = [];
+      let match;
+      
+      while ((match = ldpContainsPattern.exec(containerText)) !== null) {
+        const itemsString = match[1];
+        const itemPattern = /<([^>]+)>/g;
+        let itemMatch;
+        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
+          const itemUrl = itemMatch[1];
+          const absoluteUrl = itemUrl.startsWith('http') 
+            ? itemUrl 
+            : new URL(itemUrl, messagesContainerPath).href;
+          allItems.push({ url: absoluteUrl });
+        }
+      }
+
+      // Filter for JSON files only
+      const containerContents = allItems.filter((item) => {
+        const url = item.url || '';
+        return url.endsWith('.json') && !url.endsWith('.meta.json');
+      });
+
+      // Read all message files
+      for (const item of containerContents) {
+        const url = item.url || '';
+        if (url.endsWith('.json') && !url.endsWith('.meta.json')) {
+          try {
+            const messageFile = await getFile(url, { fetch: publicFetch });
+            const messageText = await messageFile.text();
+            const messageData = JSON.parse(messageText);
+            messages.push(messageData);
+          } catch (error) {
+            logger.warn('[SolidStorage] Error reading message file from public access', {
+              messageUrl: url,
+              error: error.message,
+            });
+            // Continue with other messages
+          }
+        }
+      }
+
+      // Sort messages by createdAt
+      messages.sort((a, b) => {
+        const dateA = new Date(a.createdAt || 0);
+        const dateB = new Date(b.createdAt || 0);
+        return dateA - dateB;
+      });
+    } catch (error) {
+      logger.error('[SolidStorage] Error fetching messages from Solid Pod', {
+        conversationId,
+        shareId,
+        error: error.message,
+        stack: error.stack,
+      });
+      return null;
+    }
+
+    // Filter messages by targetMessageId if present (branch sharing)
+    let messagesToShare = messages;
+    if (targetMessageId) {
+      // Find the target message and get all messages up to it
+      const targetIndex = messages.findIndex(msg => msg.messageId === targetMessageId);
+      if (targetIndex >= 0) {
+        messagesToShare = messages.slice(0, targetIndex + 1);
+      } else {
+        logger.warn('[SolidStorage] Target message not found in shared messages', {
+          targetMessageId,
+          conversationId,
+          shareId,
+        });
+        messagesToShare = messages; // Return all messages if target not found
+      }
+    }
+
+    if (messagesToShare.length === 0) {
+      logger.warn('[SolidStorage] No messages to share', {
+        conversationId,
+        shareId,
+      });
+      return null;
+    }
+
+    // Return shared conversation data (anonymization will be done in the share methods)
+    return {
+      shareId,
+      title: conversationData.title || 'Untitled',
+      isPublic: true,
+      createdAt: conversationData.createdAt,
+      updatedAt: conversationData.updatedAt,
+      conversationId: conversationId, // Will be anonymized later
+      messages: messagesToShare, // Will be anonymized later
+      targetMessageId,
+    };
+  } catch (error) {
+    logger.error('[SolidStorage] Error getting shared messages from Solid Pod', {
+      shareId,
+      conversationId,
+      error: error.message,
+      stack: error.stack,
+    });
+    return null;
+  }
+}
+
 module.exports = {
   getSolidFetch,
   getPodUrl,
@@ -2039,6 +2544,9 @@ module.exports = {
   getConvoFromSolid,
   getConvosByCursorFromSolid,
   deleteConvosFromSolid,
+  setPublicAccessForShare,
+  removePublicAccessForShare,
+  getSharedMessagesFromSolid,
   // Re-export solid-client functions for convenience
   getFile,
   saveFileInContainer,
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 2a0d2bc3bd88..94c064e7f323 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -162,6 +162,56 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
     try {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
       const share = (await SharedLink.findOne({ shareId, isPublic: true })
+        .select('-_id -__v -user')
+        .lean()) as t.ISharedLink | null;
+
+      if (!share?.conversationId || !share.isPublic) {
+        return null;
+      }
+
+      // Check if this is a Solid share (has podUrl)
+      if (share.podUrl) {
+        // Get shared messages from Solid Pod
+        try {
+          const { getSharedMessagesFromSolid } = require('~/server/services/SolidStorage');
+          const solidShare = await getSharedMessagesFromSolid(
+            shareId,
+            share.conversationId,
+            share.podUrl,
+            share.targetMessageId,
+          );
+
+          if (!solidShare) {
+            return null;
+          }
+
+          // Anonymize the conversation and messages
+          const newConvoId = anonymizeConvoId(solidShare.conversationId);
+          const result: t.SharedMessagesResult = {
+            shareId: solidShare.shareId || shareId,
+            title: solidShare.title,
+            isPublic: solidShare.isPublic,
+            createdAt: solidShare.createdAt,
+            updatedAt: solidShare.updatedAt,
+            conversationId: newConvoId,
+            messages: anonymizeMessages(solidShare.messages, newConvoId),
+          };
+
+          return result;
+        } catch (error) {
+          logger.error('[getSharedMessages] Error getting shared messages from Solid Pod', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            shareId,
+            conversationId: share.conversationId,
+            podUrl: share.podUrl,
+          });
+          // Fall through to return null if Solid fetch fails
+          return null;
+        }
+      }
+
+      // MongoDB share - use existing logic
+      const shareWithMessages = (await SharedLink.findOne({ shareId, isPublic: true })
         .populate({
           path: 'messages',
           select: '-_id -__v -user',
@@ -169,23 +219,23 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
         .select('-_id -__v -user')
         .lean()) as (t.ISharedLink & { messages: t.IMessage[] }) | null;
 
-      if (!share?.conversationId || !share.isPublic) {
+      if (!shareWithMessages?.messages) {
         return null;
       }
 
       /** Filtered messages based on targetMessageId if present (branch-specific sharing) */
-      let messagesToShare: t.IMessage[] = share.messages;
-      if (share.targetMessageId) {
-        messagesToShare = getMessagesUpToTarget(share.messages, share.targetMessageId);
+      let messagesToShare: t.IMessage[] = shareWithMessages.messages;
+      if (shareWithMessages.targetMessageId) {
+        messagesToShare = getMessagesUpToTarget(shareWithMessages.messages, shareWithMessages.targetMessageId);
       }
 
-      const newConvoId = anonymizeConvoId(share.conversationId);
+      const newConvoId = anonymizeConvoId(shareWithMessages.conversationId);
       const result: t.SharedMessagesResult = {
-        shareId: share.shareId || shareId,
-        title: share.title,
-        isPublic: share.isPublic,
-        createdAt: share.createdAt,
-        updatedAt: share.updatedAt,
+        shareId: shareWithMessages.shareId || shareId,
+        title: shareWithMessages.title,
+        isPublic: shareWithMessages.isPublic,
+        createdAt: shareWithMessages.createdAt,
+        updatedAt: shareWithMessages.updatedAt,
         conversationId: newConvoId,
         messages: anonymizeMessages(messagesToShare, newConvoId),
       };
@@ -316,6 +366,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
   async function deleteConvoSharedLink(
     user: string,
     conversationId: string,
+    req?: any, // Optional Express request object for Solid storage support
   ): Promise<t.DeleteAllSharesResult> {
     if (!user || !conversationId) {
       throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
@@ -323,6 +374,39 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
 
     try {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
+      
+      // Find all shares for this conversation to check if any are Solid shares
+      const shares = await SharedLink.find({ user, conversationId }).lean();
+      
+      // If any shares are Solid shares, remove public access
+      if (req) {
+        const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
+        const isSolidUser = USE_SOLID_STORAGE && req?.user?.openidId;
+        
+        if (isSolidUser) {
+          const solidShares = shares.filter(share => share.podUrl);
+          for (const share of solidShares) {
+            try {
+              const { removePublicAccessForShare } = require('~/server/services/SolidStorage');
+              await removePublicAccessForShare(req, conversationId);
+              logger.info('[deleteConvoSharedLink] Public access removed for Solid share', {
+                shareId: share.shareId,
+                conversationId,
+              });
+              // Only need to remove access once per conversation
+              break;
+            } catch (error) {
+              logger.error('[deleteConvoSharedLink] Error removing public access for Solid share', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                shareId: share.shareId,
+                conversationId,
+              });
+              // Continue with deletion even if removing public access fails
+            }
+          }
+        }
+      }
+      
       const result = await SharedLink.deleteMany({ user, conversationId });
       return {
         message: 'Shared links deleted successfully',
@@ -345,7 +429,28 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
     user: string,
     conversationId: string,
     targetMessageId?: string,
+    req?: any, // Optional Express request object for Solid storage support
   ): Promise<t.CreateShareResult> {
+    // Use both console and logger to ensure we see the log
+    console.error('[createSharedLink] FUNCTION CALLED', {
+      user,
+      conversationId,
+      targetMessageId,
+      hasReq: !!req,
+      hasUser: !!req?.user,
+      userId: req?.user?.id,
+      openidId: req?.user?.openidId,
+    });
+    logger.error('[createSharedLink] FUNCTION CALLED', {
+      user,
+      conversationId,
+      targetMessageId,
+      hasReq: !!req,
+      hasUser: !!req?.user,
+      userId: req?.user?.id,
+      openidId: req?.user?.openidId,
+    });
+    
     if (!user || !conversationId) {
       throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
     }
@@ -354,7 +459,148 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
       const Conversation = mongoose.models.Conversation as SchemaWithMeiliMethods;
 
-      const [existingShare, conversationMessages] = await Promise.all([
+      // Check if this is a Solid user
+      const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
+      const isSolidUser = USE_SOLID_STORAGE && req?.user?.openidId;
+
+      logger.info('[createSharedLink] Checking user type', {
+        user,
+        conversationId,
+        USE_SOLID_STORAGE: !!USE_SOLID_STORAGE,
+        hasReq: !!req,
+        hasUser: !!req?.user,
+        hasOpenidId: !!req?.user?.openidId,
+        openidId: req?.user?.openidId,
+        isSolidUser,
+      });
+
+      let conversation;
+      let conversationMessages;
+      let podUrl: string | undefined;
+
+      if (isSolidUser) {
+        logger.info('[createSharedLink] Detected Solid user, using Solid storage path');
+        // Check for existing share first (same as MongoDB)
+        const existingShare = (await SharedLink.findOne({
+          conversationId,
+          user,
+          isPublic: true,
+          ...(targetMessageId && { targetMessageId }),
+        })
+          .select('-_id -__v -user')
+          .lean()) as t.ISharedLink | null;
+
+        if (existingShare && existingShare.isPublic) {
+          logger.error('[createSharedLink] Share already exists', {
+            user,
+            conversationId,
+            targetMessageId,
+          });
+          throw new ShareServiceError('Share already exists', 'SHARE_EXISTS');
+        } else if (existingShare) {
+          await SharedLink.deleteOne({
+            conversationId,
+            user,
+            ...(targetMessageId && { targetMessageId }),
+          });
+        }
+
+        // For Solid users, get conversation and messages from Solid Pod
+        try {
+          logger.info('[createSharedLink] Starting Solid share creation', {
+            user,
+            conversationId,
+            userId: req.user?.id,
+            openidId: req.user?.openidId,
+          });
+          
+          const { getConvoFromSolid, getMessagesFromSolid, getPodUrl, setPublicAccessForShare } = require('~/server/services/SolidStorage');
+          const authenticatedFetch = await require('~/server/services/SolidStorage').getSolidFetch(req);
+          
+          // Get Pod URL
+          podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+          logger.info('[createSharedLink] Pod URL retrieved', {
+            podUrl,
+            conversationId,
+          });
+          
+          // Get conversation from Solid
+          try {
+            logger.info('[createSharedLink] Getting conversation from Solid Pod', {
+              user,
+              conversationId,
+              podUrl,
+              userId: req.user?.id,
+              openidId: req.user?.openidId,
+            });
+            conversation = await getConvoFromSolid(req, conversationId);
+            if (!conversation) {
+              logger.error('[createSharedLink] Conversation not found in Solid Pod (returned null)', {
+                user,
+                conversationId,
+                podUrl,
+                userId: req.user?.id,
+                openidId: req.user?.openidId,
+                userIdType: typeof req.user?.id,
+              });
+              throw new ShareServiceError(
+                'Conversation not found or access denied',
+                'CONVERSATION_NOT_FOUND',
+              );
+            }
+            logger.info('[createSharedLink] Conversation retrieved from Solid Pod', {
+              conversationId,
+              hasTitle: !!conversation.title,
+              conversationUserId: conversation.user,
+              conversationUserIdType: typeof conversation.user,
+              requestUserId: req.user?.id,
+              requestUserIdType: typeof req.user?.id,
+              userIdsMatch: String(conversation.user) === String(req.user?.id),
+            });
+          } catch (convoError) {
+            if (convoError instanceof ShareServiceError) {
+              throw convoError;
+            }
+            logger.error('[createSharedLink] Error calling getConvoFromSolid', {
+              error: convoError instanceof Error ? convoError.message : 'Unknown error',
+              errorStack: convoError instanceof Error ? convoError.stack : undefined,
+              errorName: convoError instanceof Error ? convoError.name : undefined,
+              user,
+              conversationId,
+              podUrl,
+              userId: req.user?.id,
+              openidId: req.user?.openidId,
+            });
+            throw new ShareServiceError(
+              'Conversation not found or access denied',
+              'CONVERSATION_NOT_FOUND',
+            );
+          }
+
+          // Get messages from Solid
+          conversationMessages = await getMessagesFromSolid(req, conversationId);
+          if (!conversationMessages || conversationMessages.length === 0) {
+            logger.error('[createSharedLink] No messages found in Solid Pod', {
+              user,
+              conversationId,
+            });
+            throw new ShareServiceError('No messages to share', 'NO_MESSAGES');
+          }
+        } catch (error) {
+          if (error instanceof ShareServiceError) {
+            throw error;
+          }
+          logger.error('[createSharedLink] Error getting conversation/messages from Solid Pod', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            errorStack: error instanceof Error ? error.stack : undefined,
+            user,
+            conversationId,
+          });
+          throw new ShareServiceError('Error accessing Solid Pod', 'SOLID_ACCESS_ERROR');
+        }
+      } else {
+        // For MongoDB users, use existing logic
+        const [existingShare, mongoMessages] = await Promise.all([
         SharedLink.findOne({
           conversationId,
           user,
@@ -381,7 +627,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
         });
       }
 
-      const conversation = (await Conversation.findOne({ conversationId, user }).lean()) as {
+        conversation = (await Conversation.findOne({ conversationId, user }).lean()) as {
         title?: string;
       } | null;
 
@@ -394,21 +640,57 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       }
 
       // Check if there are any messages to share
-      if (!conversationMessages || conversationMessages.length === 0) {
+        if (!mongoMessages || mongoMessages.length === 0) {
         throw new ShareServiceError('No messages to share', 'NO_MESSAGES');
+        }
+
+        conversationMessages = mongoMessages;
       }
 
       const title = conversation.title || 'Untitled';
 
       const shareId = nanoid();
-      await SharedLink.create({
+      
+      // Create SharedLink with podUrl if Solid user
+      const sharedLinkData: any = {
         shareId,
         conversationId,
-        messages: conversationMessages,
         title,
         user,
         ...(targetMessageId && { targetMessageId }),
-      });
+      };
+
+      if (isSolidUser && podUrl) {
+        sharedLinkData.podUrl = podUrl;
+        // For Solid, we don't store message ObjectIds, but we still need the array for schema compatibility
+        sharedLinkData.messages = [];
+      } else {
+        // For MongoDB, store message ObjectIds
+        sharedLinkData.messages = conversationMessages;
+      }
+
+      await SharedLink.create(sharedLinkData);
+
+      // For Solid users, set public access on conversation and messages
+      if (isSolidUser && req) {
+        try {
+          const { setPublicAccessForShare } = require('~/server/services/SolidStorage');
+          await setPublicAccessForShare(req, conversationId);
+          logger.info('[createSharedLink] Public access set for Solid share', {
+            shareId,
+            conversationId,
+          });
+        } catch (error) {
+          logger.error('[createSharedLink] Error setting public access for Solid share', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            shareId,
+            conversationId,
+          });
+          // Delete the SharedLink if setting public access fails
+          await SharedLink.deleteOne({ shareId });
+          throw new ShareServiceError('Error setting public access', 'SOLID_ACCESS_ERROR');
+        }
+      }
 
       return { shareId, conversationId };
     } catch (error) {
@@ -519,6 +801,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
   async function deleteSharedLink(
     user: string,
     shareId: string,
+    req?: any, // Optional Express request object for Solid storage support
   ): Promise<t.DeleteShareResult | null> {
     if (!user || !shareId) {
       throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
@@ -526,6 +809,32 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
 
     try {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
+      const share = await SharedLink.findOne({ shareId, user }).lean();
+
+      if (!share) {
+        return null;
+      }
+
+      // If this is a Solid share, remove public access before deleting
+      if (share.podUrl && req) {
+        try {
+          const { removePublicAccessForShare } = require('~/server/services/SolidStorage');
+          await removePublicAccessForShare(req, share.conversationId);
+          logger.info('[deleteSharedLink] Public access removed for Solid share', {
+            shareId,
+            conversationId: share.conversationId,
+          });
+        } catch (error) {
+          logger.error('[deleteSharedLink] Error removing public access for Solid share', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            shareId,
+            conversationId: share.conversationId,
+          });
+          // Continue with deletion even if removing public access fails
+        }
+      }
+
+      // Delete the SharedLink
       const result = await SharedLink.findOneAndDelete({ shareId, user }).lean();
 
       if (!result) {
diff --git a/packages/data-schemas/src/schema/share.ts b/packages/data-schemas/src/schema/share.ts
index 987dd10fc2ac..698f4475614a 100644
--- a/packages/data-schemas/src/schema/share.ts
+++ b/packages/data-schemas/src/schema/share.ts
@@ -8,6 +8,7 @@ export interface ISharedLink extends Document {
   shareId?: string;
   targetMessageId?: string;
   isPublic: boolean;
+  podUrl?: string; // Pod URL for Solid storage shares
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -40,6 +41,10 @@ const shareSchema: Schema<ISharedLink> = new Schema(
       type: Boolean,
       default: true,
     },
+    podUrl: {
+      type: String,
+      required: false,
+    },
   },
   { timestamps: true },
 );

From 6ae866b891a7e1d37ab9bfa23ce3ff8a12a60452 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 5 Feb 2026 14:28:39 +0000
Subject: [PATCH 22/94] feat: Implement share functionality for Solid  users

- Added support for sharing conversations stored in Solid Pods by granting
public read access via ACL (Access Control List) while preserving owner
write permissions. This allows Solid users to share conversations while
maintaining the ability to continue adding more messages to the conversation(write access)
---
 api/package.json                           |   1 +
 api/server/routes/share.js                 |  29 +-
 api/server/services/SolidStorage.js        | 510 +++++++++++++++++++--
 package-lock.json                          |   1 +
 packages/data-schemas/src/methods/share.ts |  31 --
 packages/data-schemas/src/types/share.ts   |   1 +
 6 files changed, 475 insertions(+), 98 deletions(-)

diff --git a/api/package.json b/api/package.json
index 3d3055447364..e35ae9a2ae4d 100644
--- a/api/package.json
+++ b/api/package.json
@@ -89,6 +89,7 @@
     "module-alias": "^2.2.3",
     "mongoose": "^8.12.1",
     "multer": "^2.1.0",
+    "n3": "^1.26.0",
     "nanoid": "^3.3.7",
     "node-fetch": "^2.7.0",
     "nodemailer": "^7.0.11",
diff --git a/api/server/routes/share.js b/api/server/routes/share.js
index e4c49409701a..e850c76ab6c2 100644
--- a/api/server/routes/share.js
+++ b/api/server/routes/share.js
@@ -99,56 +99,29 @@ router.get('/link/:conversationId', requireJwtAuth, async (req, res) => {
 
 router.post('/:conversationId', requireJwtAuth, async (req, res) => {
   try {
-    logger.info('[share route] Creating shared link', {
-      userId: req.user.id,
-      conversationId: req.params.conversationId,
-      targetMessageId: req.body.targetMessageId,
-      hasOpenidId: !!req.user.openidId,
-      openidId: req.user.openidId,
-    });
     const { targetMessageId } = req.body;
     
     // Check if createSharedLink exists
     if (typeof createSharedLink !== 'function') {
-      logger.error('[share route] createSharedLink is not a function', {
-        type: typeof createSharedLink,
-        createSharedLink,
-      });
+      logger.error('[share route] createSharedLink is not a function');
       return res.status(500).json({ message: 'Share service not available' });
     }
     
-    logger.info('[share route] Calling createSharedLink', {
-      userId: req.user.id,
-      conversationId: req.params.conversationId,
-      targetMessageId,
-      hasReq: !!req,
-    });
-    
     const created = await createSharedLink(req.user.id, req.params.conversationId, targetMessageId, req);
     
-    logger.info('[share route] createSharedLink returned', {
-      hasResult: !!created,
-      resultType: typeof created,
-    });
-    
     if (created) {
       res.status(200).json(created);
     } else {
       res.status(404).end();
     }
   } catch (error) {
-    console.error('[share route] Error caught:', error);
     logger.error('Error creating shared link:', {
       error: error?.message || String(error),
       errorName: error?.name,
       errorCode: error?.code,
       stack: error?.stack,
-      errorType: typeof error,
-      errorString: String(error),
-      errorKeys: error ? Object.keys(error) : [],
       userId: req.user?.id,
       conversationId: req.params?.conversationId,
-      fullError: error,
     });
     const errorMessage = error?.message || error?.code || 'Error creating shared link';
     res.status(500).json({ message: errorMessage });
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 2be69effe2e7..448ce891a7af 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1,5 +1,6 @@
 const { logger } = require('@librechat/data-schemas');
 const fetch = require('node-fetch');
+const { DataFactory, Writer } = require('n3');
 const {
   getFile,
   saveFileInContainer,
@@ -7,11 +8,13 @@ const {
   deleteFile,
   getPodUrlAll,
   createContainerAt,
-  getPublicAccess,
-  setPublicAccess,
-  removePublicAccess,
 } = require('@inrupt/solid-client');
 
+// ACL/ACP namespaces
+const ACL_NS = 'http://www.w3.org/ns/auth/acl#';
+const RDF_NS = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
+
 /**
  * Solid Storage Utility Module
  * 
@@ -1297,23 +1300,7 @@ async function saveConvoToSolid(req, convoData, metadata) {
       ...convoData,
       conversationId: finalConversationId,
       user: req.user.id,
-      // Title: use new value if provided, otherwise preserve existing, otherwise null
-      // title: convoData.title !== undefined ? (convoData.title || null) : (baseConversation.title || null),
-      // endpoint: finalEndpoint || baseConversation.endpoint || null,
-      // model: finalModel || baseConversation.model || null,
-      // agent_id: convoData.agent_id !== undefined ? (convoData.agent_id || null) : (baseConversation.agent_id || null),
-      // assistant_id: convoData.assistant_id !== undefined ? (convoData.assistant_id || null) : (baseConversation.assistant_id || null),
-      // spec: convoData.spec !== undefined ? (convoData.spec || null) : (baseConversation.spec || null),
-      // iconURL: convoData.iconURL !== undefined ? (convoData.iconURL || null) : (baseConversation.iconURL || null),
       messages: messageRefs,
-      // files: convoData.files !== undefined ? (convoData.files || []) : (baseConversation.files || []),
-      // promptPrefix: convoData.promptPrefix !== undefined ? (convoData.promptPrefix || null) : (baseConversation.promptPrefix || null),
-      // temperature: convoData.temperature !== undefined ? (convoData.temperature || null) : (baseConversation.temperature || null),
-      // topP: convoData.topP !== undefined ? (convoData.topP || null) : (baseConversation.topP || null),
-      // presence_penalty: convoData.presence_penalty !== undefined ? (convoData.presence_penalty || null) : (baseConversation.presence_penalty || null),
-      // frequency_penalty: convoData.frequency_penalty !== undefined ? (convoData.frequency_penalty || null) : (baseConversation.frequency_penalty || null),
-      // expiredAt: convoData.expiredAt !== undefined ? (convoData.expiredAt || null) : (baseConversation.expiredAt || null),
-      // isArchived: convoData.isArchived !== undefined ? (convoData.isArchived || false) : (baseConversation.isArchived || false),
       createdAt: baseConversation.createdAt || new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     };
@@ -2097,6 +2084,398 @@ async function deleteConvosFromSolid(req, conversationIds) {
   }
 }
 
+/**
+ * Gets the ACL URL for a resource
+ * @param {string} resourceUrl - The resource URL
+ * @param {Function} fetchFn - Authenticated fetch function
+ * @returns {Promise<string>} The ACL URL
+ */
+async function getAclUrl(resourceUrl, fetchFn) {
+  try {
+    const response = await fetchFn(resourceUrl, {
+      method: 'HEAD',
+      headers: {
+        Accept: '*/*',
+      },
+    });
+    // Even if we get 403, we can still try to get the Link header
+    const linkHeader = response.headers.get('Link');
+    if (linkHeader) {
+      const aclMatch = linkHeader.match(/<([^>]+)>;\s*rel=["']acl["']/i);
+      if (aclMatch && aclMatch[1]) {
+        return aclMatch[1];
+      }
+    }
+  } catch (error) {
+    // If HEAD fails (including 403), fall back to appending .acl
+    logger.debug('[SolidStorage] Failed to discover ACL URL via Link header, using fallback', {
+      resourceUrl,
+      error: error.message,
+      errorStatus: error.status,
+    });
+  }
+  // Default: append .acl to the resource URL
+  if (resourceUrl.endsWith('/')) {
+    return resourceUrl + '.acl';
+  }
+  return resourceUrl + '.acl';
+}
+
+/**
+ * Fetches an existing ACL or returns null if it doesn't exist
+ * @param {string} aclUrl - The ACL URL
+ * @param {Function} fetchFn - Authenticated fetch function
+ * @returns {Promise<string|null>} The ACL Turtle content or null
+ */
+async function fetchAcl(aclUrl, fetchFn) {
+  try {
+    const response = await fetchFn(aclUrl, {
+      method: 'GET',
+      headers: {
+        Accept: 'text/turtle',
+      },
+    });
+    if (!response.ok) {
+      // Treat 404 and 403 as "no ACL exists" - we'll create a new one
+      if (response.status === 404 || response.status === 403) {
+        return null;
+      }
+      throw new Error(`Failed to fetch ACL: ${response.statusText}`);
+    }
+    return await response.text();
+  } catch (error) {
+    // Treat 404 and 403 as "no ACL exists"
+    if (error.status === 404 || error.status === 403 || error.message?.includes('404') || error.message?.includes('403')) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Checks if public access already exists in ACL Turtle content
+ * @param {string} aclTurtle - The ACL Turtle content
+ * @returns {boolean} True if public access exists
+ */
+function hasPublicAccessInAcl(aclTurtle) {
+  return aclTurtle.includes('acl:agentClass') && aclTurtle.includes('foaf:Agent');
+}
+
+/**
+ * Creates a new ACL with public read access and owner permissions
+ * @param {string} resourceUrl - The resource URL
+ * @param {string} aclUrl - The ACL URL
+ * @param {boolean} isContainer - Whether this is a container (needs acl:default)
+ * @param {string} [ownerWebId] - Optional owner WebID to grant full permissions
+ * @returns {Promise<string>} The ACL Turtle content
+ */
+async function createPublicAcl(resourceUrl, aclUrl, isContainer = false, ownerWebId = null) {
+  const { namedNode, blankNode, quad } = DataFactory;
+  const quads = [];
+  
+  // If owner WebID is provided, create Authorization for owner with full permissions
+  if (ownerWebId) {
+    const ownerAuthNode = blankNode('ownerAuth');
+    
+    // Authorization: type
+    quads.push(quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
+    
+    // Authorization: agent (the owner)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}agent`), namedNode(ownerWebId)));
+    
+    // Authorization: accessTo (the resource)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
+    
+    // If this is a container, also add default access for resources within it
+    if (isContainer) {
+      quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
+    }
+    
+    // Authorization: mode (Write, Append, Control for owner)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Write`)));
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Append`)));
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Control`)));
+  }
+  
+  // Create Authorization for public access
+  const authNode = blankNode('publicAuth');
+  
+  // Authorization: type
+  quads.push(quad(authNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
+  
+  // Authorization: agentClass (foaf:Agent = anyone/public)
+  quads.push(quad(authNode, namedNode(`${ACL_NS}agentClass`), namedNode(`${FOAF_NS}Agent`)));
+  
+  // Authorization: accessTo (the resource)
+  quads.push(quad(authNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
+  
+  // If this is a container, also add default access for resources within it
+  if (isContainer) {
+    quads.push(quad(authNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
+  }
+  
+  // Authorization: mode (Read access)
+  quads.push(quad(authNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Read`)));
+  
+  // Convert quads to Turtle using N3 Writer
+  return new Promise((resolve, reject) => {
+    const writer = new Writer({ prefixes: { acl: ACL_NS, rdf: RDF_NS, foaf: FOAF_NS } });
+    quads.forEach((q) => writer.addQuad(q));
+    writer.end((error, result) => {
+      if (error) reject(error);
+      else resolve(result);
+    });
+  });
+}
+
+/**
+ * Updates an existing ACL by adding public read access and ensuring owner permissions
+ * @param {string} existingTurtle - The existing ACL Turtle content
+ * @param {string} aclUrl - The ACL URL
+ * @param {string} resourceUrl - The resource URL
+ * @param {boolean} isContainer - Whether this is a container (needs acl:default)
+ * @param {string} [ownerWebId] - Optional owner WebID to ensure full permissions
+ * @returns {Promise<string>} The updated ACL Turtle content
+ */
+async function updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, isContainer = false, ownerWebId = null) {
+  const { namedNode, blankNode, quad } = DataFactory;
+  const quads = [];
+  
+  // Check if owner permissions exist in the existing ACL
+  const hasOwnerPermissions = ownerWebId && existingTurtle.includes(ownerWebId);
+  
+  // If owner WebID is provided and owner permissions don't exist, add them
+  if (ownerWebId && !hasOwnerPermissions) {
+    const ownerAuthNode = blankNode('ownerAuth');
+    
+    // Authorization: type
+    quads.push(quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
+    
+    // Authorization: agent (the owner)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}agent`), namedNode(ownerWebId)));
+    
+    // Authorization: accessTo (the resource)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
+    
+    // If this is a container, also add default access for resources within it
+    if (isContainer) {
+      quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
+    }
+    
+    // Authorization: mode (Write, Append, Control for owner)
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Write`)));
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Append`)));
+    quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Control`)));
+  }
+  
+  // Check if public access already exists
+  if (hasPublicAccessInAcl(existingTurtle)) {
+    // If we added owner permissions, combine them with existing ACL
+    if (quads.length > 0) {
+      const newTurtle = await new Promise((resolve, reject) => {
+        const writer = new Writer({ prefixes: { acl: ACL_NS, rdf: RDF_NS, foaf: FOAF_NS } });
+        quads.forEach((q) => writer.addQuad(q));
+        writer.end((error, result) => {
+          if (error) reject(error);
+          else resolve(result);
+        });
+      });
+      return existingTurtle + '\n' + newTurtle;
+    }
+    return existingTurtle; // Public access already exists, no changes needed
+  }
+  
+  // Create Authorization for public access
+  const authNode = blankNode('publicAuth');
+  quads.push(quad(authNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
+  quads.push(quad(authNode, namedNode(`${ACL_NS}agentClass`), namedNode(`${FOAF_NS}Agent`)));
+  quads.push(quad(authNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
+  
+  // If this is a container, also add default access for resources within it
+  if (isContainer) {
+    quads.push(quad(authNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
+  }
+  
+  quads.push(quad(authNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Read`)));
+  
+  // Convert new quads to Turtle
+  const newTurtle = await new Promise((resolve, reject) => {
+    const writer = new Writer({ prefixes: { acl: ACL_NS, rdf: RDF_NS, foaf: FOAF_NS } });
+    quads.forEach((q) => writer.addQuad(q));
+    writer.end((error, result) => {
+      if (error) reject(error);
+      else resolve(result);
+    });
+  });
+  
+  // Combine existing and new Turtle
+  return existingTurtle + '\n' + newTurtle;
+}
+
+/**
+ * Grants public read access to a Solid resource using manual ACL Turtle approach
+ * @param {string} resourceUrl - The resource URL
+ * @param {Function} fetchFn - Authenticated fetch function
+ * @param {boolean} isContainer - Whether this is a container (needs acl:default)
+ * @param {string} [ownerWebId] - Optional owner WebID to grant full permissions
+ * @returns {Promise<void>}
+ */
+async function grantPublicReadAccess(resourceUrl, fetchFn, isContainer = false, ownerWebId = null) {
+  // Get ACL URL - if HEAD fails with 403, we'll still try to create the ACL file
+  let aclUrl;
+  try {
+    aclUrl = await getAclUrl(resourceUrl, fetchFn);
+  } catch (error) {
+    // If HEAD fails, fall back to appending .acl
+    logger.debug('[SolidStorage] Failed to get ACL URL via HEAD, using fallback', {
+      resourceUrl,
+      error: error.message,
+    });
+    if (resourceUrl.endsWith('/')) {
+      aclUrl = resourceUrl + '.acl';
+    } else {
+      aclUrl = resourceUrl + '.acl';
+    }
+  }
+  
+  // Fetch existing ACL or create new one
+  // If we get 403, treat it as "no ACL exists" and create a new one
+  let existingTurtle = null;
+  try {
+    existingTurtle = await fetchAcl(aclUrl, fetchFn);
+  } catch (error) {
+    // If fetch fails (including 403), treat as no ACL exists
+    logger.debug('[SolidStorage] Failed to fetch existing ACL, will create new one', {
+      aclUrl,
+      error: error.message,
+    });
+    existingTurtle = null;
+  }
+  
+  let turtle;
+  
+  if (existingTurtle) {
+    // Update existing ACL with public access and ensure owner permissions
+    turtle = await updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, isContainer, ownerWebId);
+  } else {
+    // Create new ACL with public access and owner permissions
+    turtle = await createPublicAcl(resourceUrl, aclUrl, isContainer, ownerWebId);
+  }
+  
+  // Save ACL - even if we got 403 before, we should be able to PUT the ACL file
+  const response = await fetchFn(aclUrl, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'text/turtle',
+    },
+    body: turtle,
+  });
+  
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    throw new Error(`Failed to save ACL: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  
+  logger.debug('[SolidStorage] ACL file created/updated successfully', {
+    aclUrl,
+    resourceUrl,
+    isContainer,
+    hasOwnerPermissions: !!ownerWebId,
+  });
+}
+
+/**
+ * Removes public read access from a Solid resource using manual ACL Turtle approach
+ * @param {string} resourceUrl - The resource URL
+ * @param {Function} fetchFn - Authenticated fetch function
+ * @returns {Promise<void>}
+ */
+async function removePublicReadAccess(resourceUrl, fetchFn) {
+  const aclUrl = await getAclUrl(resourceUrl, fetchFn);
+  
+  // Fetch existing ACL
+  const existingTurtle = await fetchAcl(aclUrl, fetchFn);
+  
+  if (!existingTurtle) {
+    // No ACL exists, nothing to remove
+    return;
+  }
+  
+  // Check if public access exists
+  if (!hasPublicAccessInAcl(existingTurtle)) {
+    // Public access doesn't exist, nothing to remove
+    return;
+  }
+  
+  // Remove public access lines from Turtle
+  // This is a simple approach - remove lines containing foaf:Agent
+  const lines = existingTurtle.split('\n');
+  const filteredLines = [];
+  let skipNext = false;
+  let inPublicAuth = false;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Detect start of public authorization (blank node with foaf:Agent)
+    if (line.includes('foaf:Agent') && (line.includes('acl:agentClass') || line.includes('acl:Authorization'))) {
+      inPublicAuth = true;
+      skipNext = true;
+      continue;
+    }
+    
+    // Skip lines that are part of the public authorization
+    if (inPublicAuth) {
+      if (line.trim().endsWith('.') && !line.includes('foaf:Agent')) {
+        inPublicAuth = false;
+        skipNext = false;
+      }
+      continue;
+    }
+    
+    // Skip lines that are clearly part of public auth block
+    if (skipNext && (line.includes('acl:accessTo') || line.includes('acl:mode') || line.includes('acl:Read'))) {
+      if (line.trim().endsWith('.')) {
+        skipNext = false;
+      }
+      continue;
+    }
+    
+    skipNext = false;
+    filteredLines.push(line);
+  }
+  
+  const updatedTurtle = filteredLines.join('\n');
+  
+  // Save updated ACL (or delete if empty)
+  if (updatedTurtle.trim().length === 0) {
+    // Delete ACL file if it's empty
+    try {
+      await fetchFn(aclUrl, {
+        method: 'DELETE',
+      });
+    } catch (error) {
+      logger.warn('[SolidStorage] Error deleting empty ACL', {
+        aclUrl,
+        error: error.message,
+      });
+    }
+  } else {
+    const response = await fetchFn(aclUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'text/turtle',
+      },
+      body: updatedTurtle,
+    });
+    
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new Error(`Failed to save ACL: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+  }
+}
+
 /**
  * Set public read access for a shared conversation and its messages
  * This makes the conversation and all its messages publicly accessible
@@ -2151,10 +2530,17 @@ async function setPublicAccessForShare(req, conversationId) {
       throw new Error('No messages to share');
     }
 
-    // Set public read access on conversation file
+    // Get owner WebID for preserving owner permissions
+    const ownerWebId = req.user.openidId;
+
+    // Set public read access on conversation file using manual Turtle approach
     try {
-      const conversationFile = await getFile(conversationPath, { fetch: authenticatedFetch });
-      await setPublicAccess(conversationFile, { read: true }, { fetch: authenticatedFetch });
+      logger.debug('[SolidStorage] Setting public access on conversation file', {
+        conversationPath,
+        conversationId,
+        ownerWebId,
+      });
+      await grantPublicReadAccess(conversationPath, authenticatedFetch, false, ownerWebId);
       logger.info('[SolidStorage] Public read access set on conversation file', {
         conversationPath,
         conversationId,
@@ -2164,17 +2550,21 @@ async function setPublicAccessForShare(req, conversationId) {
         conversationPath,
         conversationId,
         error: error.message,
+        errorName: error.name,
+        errorCode: error.code,
         stack: error.stack,
       });
       throw error;
     }
 
-    // Set public read access on messages container
+    // Set public read access on messages container using manual Turtle approach
+    // IMPORTANT: For containers, we need to set acl:default so files within inherit access
+    // IMPORTANT: We must preserve owner permissions so the owner can still add messages
     const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
     try {
-      const messagesContainer = await getFile(messagesContainerPath, { fetch: authenticatedFetch });
-      await setPublicAccess(messagesContainer, { read: true }, { fetch: authenticatedFetch });
-      logger.info('[SolidStorage] Public read access set on messages container', {
+      
+      await grantPublicReadAccess(messagesContainerPath, authenticatedFetch, true, ownerWebId); // isContainer=true, ownerWebId
+      logger.info('[SolidStorage] Public read access set on messages container (with default)', {
         messagesContainerPath,
         conversationId,
       });
@@ -2188,19 +2578,52 @@ async function setPublicAccessForShare(req, conversationId) {
       // Continue with message files even if container access fails
     }
 
-    // Set public read access on each message file
+    // Set public read access on each message file using manual Turtle approach
     let messagesShared = 0;
     for (const message of messages) {
       try {
         const messagePath = getMessagePath(podUrl, conversationId, message.messageId);
-        const messageFile = await getFile(messagePath, { fetch: authenticatedFetch });
-        await setPublicAccess(messageFile, { read: true }, { fetch: authenticatedFetch });
-        messagesShared++;
+      
+        try {
+          await grantPublicReadAccess(messagePath, authenticatedFetch, false, ownerWebId);
+          messagesShared++;
+        } catch (grantError) {
+          // If grantPublicReadAccess fails, try to create ACL file directly
+          // This handles cases where we get 403 on HEAD/GET but can still PUT the ACL
+          logger.debug('[SolidStorage] grantPublicReadAccess failed, trying direct ACL creation', {
+            messagePath,
+            messageId: message.messageId,
+            error: grantError.message,
+          });
+          
+          const aclUrl = messagePath.endsWith('/') ? messagePath + '.acl' : messagePath + '.acl';
+          const turtle = await createPublicAcl(messagePath, aclUrl, false, ownerWebId);
+          
+          const response = await authenticatedFetch(aclUrl, {
+            method: 'PUT',
+            headers: {
+              'Content-Type': 'text/turtle',
+            },
+            body: turtle,
+          });
+          
+          if (response.ok) {
+            logger.info('[SolidStorage] ACL file created directly for message file', {
+              messagePath,
+              messageId: message.messageId,
+            });
+            messagesShared++;
+          } else {
+            const errorText = await response.text().catch(() => response.statusText);
+            throw new Error(`Failed to create ACL directly: ${response.status} ${response.statusText} - ${errorText}`);
+          }
+        }
       } catch (error) {
         logger.error('[SolidStorage] Error setting public access on message file', {
           messageId: message.messageId,
           conversationId,
           error: error.message,
+          errorStatus: error.status,
         });
         // Continue with other messages even if one fails
       }
@@ -2251,10 +2674,13 @@ async function removePublicAccessForShare(req, conversationId) {
     // Get conversation file path
     const conversationPath = getConversationPath(podUrl, conversationId);
 
-    // Remove public read access from conversation file
+    // Remove public read access from conversation file using manual Turtle approach
     try {
-      const conversationFile = await getFile(conversationPath, { fetch: authenticatedFetch });
-      await removePublicAccess(conversationFile, { fetch: authenticatedFetch });
+      logger.debug('[SolidStorage] Removing public access from conversation file', {
+        conversationPath,
+        conversationId,
+      });
+      await removePublicReadAccess(conversationPath, authenticatedFetch);
       logger.info('[SolidStorage] Public read access removed from conversation file', {
         conversationPath,
         conversationId,
@@ -2276,11 +2702,14 @@ async function removePublicAccessForShare(req, conversationId) {
       }
     }
 
-    // Remove public read access from messages container
+    // Remove public read access from messages container using manual Turtle approach
     const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
     try {
-      const messagesContainer = await getFile(messagesContainerPath, { fetch: authenticatedFetch });
-      await removePublicAccess(messagesContainer, { fetch: authenticatedFetch });
+      logger.debug('[SolidStorage] Removing public access from messages container', {
+        messagesContainerPath,
+        conversationId,
+      });
+      await removePublicReadAccess(messagesContainerPath, authenticatedFetch);
       logger.info('[SolidStorage] Public read access removed from messages container', {
         messagesContainerPath,
         conversationId,
@@ -2312,13 +2741,16 @@ async function removePublicAccessForShare(req, conversationId) {
       });
     }
 
-    // Remove public read access from each message file
+    // Remove public read access from each message file using manual Turtle approach
     let messagesUnshared = 0;
     for (const message of messages) {
       try {
         const messagePath = getMessagePath(podUrl, conversationId, message.messageId);
-        const messageFile = await getFile(messagePath, { fetch: authenticatedFetch });
-        await removePublicAccess(messageFile, { fetch: authenticatedFetch });
+        logger.debug('[SolidStorage] Removing public access from message file', {
+          messagePath,
+          messageId: message.messageId,
+        });
+        await removePublicReadAccess(messagePath, authenticatedFetch);
         messagesUnshared++;
       } catch (error) {
         if (error.status === 404 || error.message?.includes('404')) {
diff --git a/package-lock.json b/package-lock.json
index 0b555e4572b2..f2f2b4d39114 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -104,6 +104,7 @@
         "module-alias": "^2.2.3",
         "mongoose": "^8.12.1",
         "multer": "^2.1.0",
+        "n3": "^1.26.0",
         "nanoid": "^3.3.7",
         "node-fetch": "^2.7.0",
         "nodemailer": "^7.0.11",
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 94c064e7f323..61bc8417367e 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -431,26 +431,6 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
     targetMessageId?: string,
     req?: any, // Optional Express request object for Solid storage support
   ): Promise<t.CreateShareResult> {
-    // Use both console and logger to ensure we see the log
-    console.error('[createSharedLink] FUNCTION CALLED', {
-      user,
-      conversationId,
-      targetMessageId,
-      hasReq: !!req,
-      hasUser: !!req?.user,
-      userId: req?.user?.id,
-      openidId: req?.user?.openidId,
-    });
-    logger.error('[createSharedLink] FUNCTION CALLED', {
-      user,
-      conversationId,
-      targetMessageId,
-      hasReq: !!req,
-      hasUser: !!req?.user,
-      userId: req?.user?.id,
-      openidId: req?.user?.openidId,
-    });
-    
     if (!user || !conversationId) {
       throw new ShareServiceError('Missing required parameters', 'INVALID_PARAMS');
     }
@@ -463,17 +443,6 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
       const isSolidUser = USE_SOLID_STORAGE && req?.user?.openidId;
 
-      logger.info('[createSharedLink] Checking user type', {
-        user,
-        conversationId,
-        USE_SOLID_STORAGE: !!USE_SOLID_STORAGE,
-        hasReq: !!req,
-        hasUser: !!req?.user,
-        hasOpenidId: !!req?.user?.openidId,
-        openidId: req?.user?.openidId,
-        isSolidUser,
-      });
-
       let conversation;
       let conversationMessages;
       let podUrl: string | undefined;
diff --git a/packages/data-schemas/src/types/share.ts b/packages/data-schemas/src/types/share.ts
index 8b54990cf49b..8b2647b655f1 100644
--- a/packages/data-schemas/src/types/share.ts
+++ b/packages/data-schemas/src/types/share.ts
@@ -10,6 +10,7 @@ export interface ISharedLink {
   shareId?: string;
   targetMessageId?: string;
   isPublic: boolean;
+  podUrl?: string; // Pod URL for Solid storage shares
   createdAt?: Date;
   updatedAt?: Date;
 }

From 5d603d86e7695bb1e90a8b81719bdbc598a0dda8 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 5 Feb 2026 14:47:19 +0000
Subject: [PATCH 23/94] uodate progress document

---
 SOLID_INTEGRATION_PROGRESS.md       | 52 +++++++++++++++++++++++------
 api/server/services/SolidStorage.js |  2 +-
 2 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 15c4c8c0d89a..1e2b8e02a952 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -97,13 +97,24 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - `saveConvoToSolid` merges updates with existing conversation data to prevent data loss
 
 ### 12. Conversation Management Operations
-- **Status**: Partially Complete
+- **Status**: Complete
 - **Details**:
   - **Rename**: Working - Users can rename conversations stored in Solid Pod
   - **Duplicate**: Working - Users can duplicate conversations and all messages from Solid Pod
   - **Delete**: Working - Users can delete conversations and all associated messages from Solid Pod
   - **Archive**: Working - Users can archive and unarchive conversations stored in Solid Pod
-  - **Share**: Not yet implemented
+  - **Share**: Working - Users can share conversations stored in Solid Pod with public read access while maintaining owner write permissions
+
+### 13. Share Functionality
+- **Status**: Complete
+- **Details**:
+  - Implemented public read access via ACL (Access Control List) for shared conversations
+  - Uses manual ACL Turtle format for reliable permission management
+  - Preserves owner permissions (Write, Append, Control) when granting public read access
+  - Applies `acl:default` on message containers so new messages automatically inherit public access
+  - Dynamically detects Solid users and routes to appropriate sharing method
+  - Fetches shared messages directly from Pod using unauthenticated requests
+  - Properly removes public access when share is deleted
 
 ## Current Status
 
@@ -121,13 +132,14 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 11. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
 12. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
 13. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
+14. **Conversation Share**: Users can share conversations stored in Solid Pod with public read access while maintaining full write permissions
 
 ### Known Issues 🔧
-1. **Conversation Menu Options**
-   - **Issue**: Share option needs to be implemented for Solid storage
-   - **Impact**: Users cannot share conversations stored in Solid Pod
-   - **Status**: Not yet implemented
+1. **Solid Authentication UI**
+   - **Issue**: Solid authentication is currently tied to the OpenID button instead of having its own dedicated button
+   - **Status**: Needs implementation
    - **Priority**: Medium
+   - **Solution**: Create a dedicated Solid login button similar to other social authentication providers (Google, GitHub, etc.)
 
 ## Technical Implementation
 
@@ -154,11 +166,24 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - Falls back to cookies if session unavailable
 - Tokens retrieved from multiple sources for robustness
 
-## Next Steps
+### Access Control (ACL)
+- Uses manual ACL Turtle format for permission management
+- Grants public read access for shared conversations while preserving owner permissions
+- Applies `acl:default` on containers to ensure new resources inherit permissions
+- Owner retains Write, Append, and Control permissions when sharing
+- Properly removes public access when share is deleted
+
+## Future Improvements
+
+1. **User Storage Selection**
+   - Allow users to select their storage Pod (currently uses default Pod URL)
+   - Location: `api/server/services/SolidStorage.js:1619`
+   - Priority: Low (can be implemented after initial PR)
 
-1. **Conversation Menu Options Implementation**
-   - Implement Share functionality for Solid storage conversations
-   - Ensure all operations work seamlessly with Solid storage backend
+2. **RDF Parsing Enhancement**
+   - Use RDF object mapper to parse Turtle format instead of regex patterns
+   - Location: `api/server/services/SolidStorage.js:1659`
+   - Priority: Low (current regex parsing works but could be more robust)
 
 
 ## Files Modified
@@ -178,12 +203,17 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
 - `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
 - `api/server/services/SolidStorage.js` - Added `isArchived` field support in `saveConvoToSolid` and `getConvosByCursorFromSolid` for archive functionality
+- `api/server/services/SolidStorage.js` - Added share functionality: `setPublicAccessForShare`, `removePublicAccessForShare`, `getSharedMessagesFromSolid`, and ACL helper functions (`createPublicAcl`, `updateAclWithPublicAccess`, `grantPublicReadAccess`, `removePublicReadAccess`)
+- `packages/data-schemas/src/methods/share.ts` - Updated `createSharedLink`, `getSharedMessages`, `deleteSharedLink`, and `deleteConvoSharedLink` to support Solid storage
+- `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
+- `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
+- `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library
 
 ---
 
-**Report Date**: February 3, 2026  
+**Report Date**: February 5, 2026  
 
 
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 448ce891a7af..eb81113ab8da 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1656,7 +1656,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       
       // Parse Turtle format to extract all items from ldp:contains
       // Handle both single and comma-separated items: ldp:contains <item1>, <item2>.
-      // TODO: Use object mapper to parse this.
+      // TODO: Use RDF object mapper to parse this.
       const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
       const allItems = [];
       let match;

From c7ab28f29139d734415444030f26ea6e1037ef20 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 6 Feb 2026 12:18:30 +0000
Subject: [PATCH 24/94] feat: Add separate Solid login button alongside OpenID
 button

- Added SolidIcon component for Solid authentication branding
- Added Solid-specific configuration (solidLoginEnabled, solidLabel, solidImageUrl)
- Added SOLID_OPENID_* environment variables for Solid authentication
- Configure both Solid and generic OpenID strategies independently
- Both buttons use the same /oauth/openid route and 'openid' strategy
- Update TypeScript types to include Solid configuration fields

This allows users to have separate "Login with Solid" and "Login with OpenID"
buttons with different labels while maintaining the same authentication flow.
The Solid button appears when SOLID_OPENID_* env vars are configured, and the
OpenID button appears when OPENID_* env vars are configured (or when Solid is
enabled, since they share the same strategy).
---
 api/server/routes/config.js                   | 12 ++-
 api/server/socialLogins.js                    | 77 ++++++++++++++++++-
 api/strategies/SolidOpenidStrategy.js         | 12 +--
 api/strategies/index.js                       |  1 +
 .../src/components/Auth/SocialLoginRender.tsx | 18 +++++
 packages/client/src/svgs/SolidIcon.tsx        | 36 +++++++++
 packages/client/src/svgs/index.ts             |  1 +
 packages/data-provider/src/config.ts          |  4 +
 8 files changed, 150 insertions(+), 11 deletions(-)
 create mode 100644 packages/client/src/svgs/SolidIcon.tsx

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index ccbbaf8a0114..068dbc66d3f1 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -49,6 +49,11 @@ router.get('/', async function (req, res) {
       !!process.env.OPENID_ISSUER &&
       !!process.env.OPENID_SESSION_SECRET;
 
+    const isSolidEnabled =
+      !!process.env.SOLID_OPENID_CLIENT_ID &&
+      !!process.env.SOLID_OPENID_ISSUER &&
+      !!process.env.SOLID_OPENID_SESSION_SECRET;
+
     const isSamlEnabled =
       !!process.env.SAML_ENTRY_POINT &&
       !!process.env.SAML_ISSUER &&
@@ -71,10 +76,15 @@ router.get('/', async function (req, res) {
         !!process.env.APPLE_TEAM_ID &&
         !!process.env.APPLE_KEY_ID &&
         !!process.env.APPLE_PRIVATE_KEY_PATH,
-      openidLoginEnabled: isOpenIdEnabled,
+      // If Solid is enabled but OpenID is not, still show OpenID button since they use the same strategy
+      openidLoginEnabled: isOpenIdEnabled || isSolidEnabled,
       openidLabel: process.env.OPENID_BUTTON_LABEL || 'Continue with OpenID',
       openidImageUrl: process.env.OPENID_IMAGE_URL,
       openidAutoRedirect: isEnabled(process.env.OPENID_AUTO_REDIRECT),
+      solidLoginEnabled: isSolidEnabled,
+      solidLabel: process.env.SOLID_OPENID_BUTTON_LABEL || 'Continue with Solid',
+      solidImageUrl: process.env.SOLID_OPENID_IMAGE_URL,
+      solidAutoRedirect: isEnabled(process.env.SOLID_OPENID_AUTO_REDIRECT),
       samlLoginEnabled: !isOpenIdEnabled && isSamlEnabled,
       samlLabel: process.env.SAML_BUTTON_LABEL,
       samlImageUrl: process.env.SAML_IMAGE_URL,
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index a65e996be15a..f23c3207f7dc 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -8,6 +8,7 @@ const {
   facebookLogin,
   discordLogin,
   setupSolidOpenId,
+  setupOpenId,
   googleLogin,
   githubLogin,
   appleLogin,
@@ -15,16 +16,74 @@ const {
 } = require('~/strategies');
 const { getLogStores } = require('~/cache');
 
+
+/**
+ * Configures Solid OpenID Connect for the application.
+ * @param {Express.Application} app - The Express application instance.
+ * @returns {Promise<void>}
+ */
+async function configureSolidOpenId(app) {
+  logger.info('Configuring Solid OpenID Connect...');
+  const sessionOptions = {
+    secret: process.env.SOLID_OPENID_SESSION_SECRET,
+    resave: false,
+    saveUninitialized: false,
+    store: getLogStores(CacheKeys.OPENID_SESSION),
+  };
+  app.use(session(sessionOptions));
+  app.use(passport.session());
+
+  const config = await setupSolidOpenId();
+  if (!config) {
+    logger.error('Solid OpenID Connect configuration failed - strategy not registered.');
+    return;
+  }
+
+  if (isEnabled(process.env.OPENID_REUSE_TOKENS)) {
+    logger.info('Solid OpenID token reuse is enabled.');
+    passport.use('solidJwt', openIdJwtLogin(config));
+  }
+  logger.info('Solid OpenID Connect configured successfully.');
+}
+
 /**
- * Configures OpenID Connect for the application.
+* Configures Solid OpenID Connect for the application.
+ * @param {Express.Application} app - The Express application instance.
+ * @returns {Promise<void>}
+ */
+async function configureSolidOpenId(app) {
+  logger.info('Configuring Solid OpenID Connect...');
+  const sessionOptions = {
+    secret: process.env.SOLID_OPENID_SESSION_SECRET,
+    resave: false,
+    saveUninitialized: false,
+    store: getLogStores(CacheKeys.OPENID_SESSION),
+  };
+  app.use(session(sessionOptions));
+  app.use(passport.session());
+
+  const config = await setupSolidOpenId();
+  if (!config) {
+    logger.error('Solid OpenID Connect configuration failed - strategy not registered.');
+    return;
+  }
+
+  if (isEnabled(process.env.OPENID_REUSE_TOKENS)) {
+    logger.info('Solid OpenID token reuse is enabled.');
+    passport.use('solidJwt', openIdJwtLogin(config));
+  }
+  logger.info('Solid OpenID Connect configured successfully.');
+}
+
+/**
+ * Configures generic OpenID Connect for the application.
  * @param {Express.Application} app - The Express application instance.
  * @returns {Promise<void>}
  */
 async function configureOpenId(app) {
   logger.info('Configuring OpenID Connect...');
-  const sessionExpiry = Number(process.env.SESSION_EXPIRY) || DEFAULT_SESSION_EXPIRY;
   const sessionOptions = {
-    secret: process.env.OPENID_SESSION_SECRET,
+    secret: process.env.SOLID_OPENID_SESSION_SECRET,
     resave: false,
     saveUninitialized: false,
     store: getLogStores(CacheKeys.OPENID_SESSION),
@@ -36,7 +95,7 @@ async function configureOpenId(app) {
   app.use(session(sessionOptions));
   app.use(passport.session());
 
-  const config = await setupSolidOpenId();
+  const config = await setupOpenId();
   if (!config) {
     logger.error('OpenID Connect configuration failed - strategy not registered.');
     return;
@@ -71,6 +130,16 @@ const configureSocialLogins = async (app) => {
   if (process.env.APPLE_CLIENT_ID && process.env.APPLE_PRIVATE_KEY_PATH) {
     passport.use(appleLogin());
   }
+  // Configure Solid OpenID if SOLID_OPENID_* env vars are present
+  if (
+    process.env.SOLID_OPENID_CLIENT_ID &&
+    process.env.SOLID_OPENID_ISSUER &&
+    process.env.SOLID_OPENID_SCOPE &&
+    process.env.SOLID_OPENID_SESSION_SECRET
+  ) {
+    await configureSolidOpenId(app);
+  }
+  // Configure generic OpenID if OPENID_* env vars are present
   if (
     process.env.OPENID_CLIENT_ID &&
     process.env.OPENID_ISSUER &&
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index d5ea0a0e4705..0ce3de9332c0 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -303,8 +303,8 @@ async function setupSolidOpenId() {
 
     /** @type {ClientMetadata} */
     const clientMetadata = {
-      client_id: process.env.OPENID_CLIENT_ID,
-      client_secret: process.env.OPENID_CLIENT_SECRET,
+      client_id: process.env.SOLID_OPENID_CLIENT_ID,
+      client_secret: process.env.SOLID_OPENID_CLIENT_SECRET,
     };
 
     if (shouldGenerateNonce) {
@@ -315,8 +315,8 @@ async function setupSolidOpenId() {
 
     /** @type {Configuration} */
     openidConfig = await client.discovery(
-      new URL(process.env.OPENID_ISSUER),
-      process.env.OPENID_CLIENT_ID,
+      new URL(process.env.SOLID_OPENID_ISSUER),
+      process.env.SOLID_OPENID_CLIENT_ID,
       clientMetadata,
       undefined,
       {
@@ -345,8 +345,8 @@ async function setupSolidOpenId() {
     const openidLogin = new CustomOpenIDStrategy(
       {
         config: openidConfig,
-        scope: process.env.OPENID_SCOPE,
-        callbackURL: process.env.DOMAIN_SERVER + process.env.OPENID_CALLBACK_URL,
+        scope: process.env.SOLID_OPENID_SCOPE,
+        callbackURL: process.env.DOMAIN_SERVER + process.env.SOLID_OPENID_CALLBACK_URL,
         clockTolerance: process.env.OPENID_CLOCK_TOLERANCE || 300,
         usePKCE,
       },
diff --git a/api/strategies/index.js b/api/strategies/index.js
index 67c105ca1d78..5ec3c2bcc36b 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -8,6 +8,7 @@ const githubLogin = require('./githubStrategy');
 const discordLogin = require('./discordStrategy');
 const facebookLogin = require('./facebookStrategy');
 const { setupSolidOpenId, getSolidOpenIdConfig } = require('./SolidOpenidStrategy');
+const { setupOpenId, getOpenIdConfig } = require('./openidStrategy');
 const jwtLogin = require('./jwtStrategy');
 const ldapLogin = require('./ldapStrategy');
 const { setupSaml } = require('./samlStrategy');
diff --git a/client/src/components/Auth/SocialLoginRender.tsx b/client/src/components/Auth/SocialLoginRender.tsx
index ad76354a5360..b648f7e35d0e 100644
--- a/client/src/components/Auth/SocialLoginRender.tsx
+++ b/client/src/components/Auth/SocialLoginRender.tsx
@@ -2,6 +2,7 @@ import {
   GoogleIcon,
   FacebookIcon,
   OpenIDIcon,
+  SolidIcon,
   GithubIcon,
   DiscordIcon,
   AppleIcon,
@@ -98,6 +99,23 @@ function SocialLoginRender({
         id="openid"
       />
     ),
+    solid: startupConfig.solidLoginEnabled && (
+      <SocialButton
+        key="solid"
+        enabled={startupConfig.solidLoginEnabled}
+        serverDomain={startupConfig.serverDomain}
+        oauthPath="openid"
+        Icon={() =>
+          startupConfig.solidImageUrl ? (
+            <img src={startupConfig.solidImageUrl} alt="Solid Logo" className="h-5 w-5" />
+          ) : (
+            <SolidIcon />
+          )
+        }
+        label={startupConfig.solidLabel}
+        id="solid"
+      />
+    ),
     saml: startupConfig.samlLoginEnabled && (
       <SocialButton
         key="saml"
diff --git a/packages/client/src/svgs/SolidIcon.tsx b/packages/client/src/svgs/SolidIcon.tsx
new file mode 100644
index 000000000000..4a5801ac5fde
--- /dev/null
+++ b/packages/client/src/svgs/SolidIcon.tsx
@@ -0,0 +1,36 @@
+import React from 'react';
+
+export default function SolidIcon() {
+  return (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      viewBox="0 0 300 300"
+      className="h-5 w-5"
+      aria-hidden="true"
+    >
+      <g fillRule="nonzero" fill="none">
+        <path
+          d="M87.97296 282.3527L27.24133 177.02207c-5.62041-9.75765-5.62041-21.77908 0-31.53674L87.97296 40.2328c5.64643-9.78367 16.08061-15.79439 27.32143-15.79439h121.3852c11.26684 0 21.72704 6.01072 27.32143 15.7944l60.75765 105.30458c5.62041 9.75766 5.62041 21.77909 0 31.53674l-60.73163 105.33061c-5.64643 9.78367-16.08061 15.79439-27.32143 15.79439H115.37245c-11.31888-.05204-21.72704-6.08878-27.3995-15.84643z"
+          fill="#FFF"
+        />
+        <path
+          d="M93.15102 275.19708l-57.1148-99.0597c-5.30816-9.1852-5.30816-20.50408 0-29.66326l57.1148-99.08572c5.33418-9.21122 15.14388-14.85765 25.73418-14.85765h114.2296c10.5903 0 20.42602 5.64643 25.73418 14.85765l57.16684 99.03368c5.30816 9.1852 5.30816 20.50408 0 29.66326L258.875 275.2231c-5.33418 9.21122-15.14388 14.85765-25.73418 14.85765H118.93724c-10.64234 0-20.45204-5.67245-25.78622-14.88367z"
+          fill="#7C4DFF"
+        />
+        <path
+          d="M118.46888 142.2328h117.53418c1.48316 0 2.65408-1.19695 2.65408-2.65409v-22.03928c0-14.6495-11.89132-26.54085-26.54081-26.54085h-70.56735c-20.5301-.026-37.15722 16.60105-37.15722 37.13115-.02594 7.83214 6.271 14.10306 14.07712 14.10306zM129.99592 239.60116H200.225c21.20663 0 38.43214-17.22551 38.43214-38.43214 0-7.07755-5.72449-12.82806-12.82806-12.82806H106.94184c-1.45715 0-2.55005 1.17091-2.55005 2.55v23.05408c-.02597 14.18112 11.47505 25.65612 25.60413 25.65612z"
+          fill="#F7F7F7"
+        />
+        <path
+          d="M109.59592 139.3185l87.66275 87.66276c5.80255 5.80255 15.19592 5.80255 20.99847 0l15.19592-15.19592c5.80255-5.80255 5.80255-15.19591 0-20.99847l-87.63673-87.66275c-5.80255-5.80255-15.19592-5.80255-20.99847 0l-15.19592 15.19592c-5.8546 5.80255-5.8546 15.22194-.02602 20.99847z"
+          fill="#F7F7F7"
+        />
+        <path
+          fill="#444"
+          opacity=".3"
+          d="M198.6898 228.46443l-51.4944-40.12347h11.39695zM144.35918 101.66698l40.56582 40.56581h13.7648z"
+        />
+      </g>
+    </svg>
+  );
+}
diff --git a/packages/client/src/svgs/index.ts b/packages/client/src/svgs/index.ts
index 1d67d4455263..85c6fbb0dc99 100644
--- a/packages/client/src/svgs/index.ts
+++ b/packages/client/src/svgs/index.ts
@@ -21,6 +21,7 @@ export { default as ContinueIcon } from './ContinueIcon';
 export { default as GoogleIcon } from './GoogleIcon';
 export { default as FacebookIcon } from './FacebookIcon';
 export { default as OpenIDIcon } from './OpenIDIcon';
+export { default as SolidIcon } from './SolidIcon';
 export { default as GithubIcon } from './GithubIcon';
 export { default as DiscordIcon } from './DiscordIcon';
 export { default as AppleIcon } from './AppleIcon';
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 48d54099627b..02dd7088b701 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -758,6 +758,10 @@ export type TStartupConfig = {
   openidLabel: string;
   openidImageUrl: string;
   openidAutoRedirect: boolean;
+  solidLoginEnabled: boolean;
+  solidLabel: string;
+  solidImageUrl?: string;
+  solidAutoRedirect: boolean;
   samlLabel: string;
   samlImageUrl: string;
   /** LDAP Auth Configuration */

From 0cb8f0542a81e37be7c416821d18b2a30d61f774 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 6 Feb 2026 12:27:58 +0000
Subject: [PATCH 25/94] update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 86 +++++++++++++++++++++++++++--------
 1 file changed, 66 insertions(+), 20 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 1e2b8e02a952..98f06db7d19b 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -13,6 +13,9 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Implemented token storage in session and cookies
   - Handled cases where Solid provider doesn't issue refresh tokens
   - Ensured JWT tokens are created for frontend authentication
+  - Added separate "Login with Solid" button with custom branding
+  - Supports both generic OpenID and Solid-specific authentication buttons
+  - Both buttons use the same authentication flow but with different labels and icons
 
 ### 2. Solid Pod Access
 - **Status**: Complete
@@ -119,27 +122,24 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 ## Current Status
 
 ### Working Features
-1. **User Login**: Solid-OIDC authentication working correctly
-2. **Conversation Creation**: New conversations are saved to Solid Pod
-3. **Message Saving**: User messages and AI responses are saved to Solid Pod
-4. **Data Retrieval**: Conversations and messages can be read from Pod
-5. **Container Structure**: Proper directory structure created automatically
-6. **Conversation Continuation**: Users can send multiple messages in the same conversation
-7. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
-8. **Access Control**: Conversation access validation works for Solid storage users
-9. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
-10. **Conversation Rename**: Users can rename conversations stored in Solid Pod
-11. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
-12. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
-13. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
-14. **Conversation Share**: Users can share conversations stored in Solid Pod with public read access while maintaining full write permissions
+1. **User Login**: Solid-OIDC authentication working correctly with dedicated "Login with Solid" button
+2. **Separate Authentication Buttons**: Both "Login with OpenID" and "Login with Solid" buttons available with custom labels and icons
+3. **Conversation Creation**: New conversations are saved to Solid Pod
+4. **Message Saving**: User messages and AI responses are saved to Solid Pod
+5. **Data Retrieval**: Conversations and messages can be read from Pod
+6. **Container Structure**: Proper directory structure created automatically
+7. **Conversation Continuation**: Users can send multiple messages in the same conversation
+8. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
+9. **Access Control**: Conversation access validation works for Solid storage users
+10. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
+11. **Conversation Rename**: Users can rename conversations stored in Solid Pod
+12. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
+13. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
+14. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
+15. **Conversation Share**: Users can share conversations stored in Solid Pod with public read access while maintaining full write permissions
 
 ### Known Issues 🔧
-1. **Solid Authentication UI**
-   - **Issue**: Solid authentication is currently tied to the OpenID button instead of having its own dedicated button
-   - **Status**: Needs implementation
-   - **Priority**: Medium
-   - **Solution**: Create a dedicated Solid login button similar to other social authentication providers (Google, GitHub, etc.)
+None currently identified.
 
 ## Technical Implementation
 
@@ -165,6 +165,10 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - Uses OpenID access tokens stored in session
 - Falls back to cookies if session unavailable
 - Tokens retrieved from multiple sources for robustness
+- Separate "Login with Solid" button using `SOLID_OPENID_*` environment variables
+- Generic "Login with OpenID" button using `OPENID_*` environment variables
+- Both buttons share the same authentication flow and `/oauth/openid` route
+- Custom SolidIcon component for Solid branding
 
 ### Access Control (ACL)
 - Uses manual ACL Turtle format for permission management
@@ -208,12 +212,54 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
 - `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
 - `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
+- `api/strategies/SolidOpenidStrategy.js` - Updated to use `SOLID_OPENID_*` environment variables and register as 'openid' strategy
+- `api/strategies/openidStrategy.js` - Generic OpenID strategy for non-Solid OpenID providers
+- `api/strategies/index.js` - Exported both `setupSolidOpenId` and `setupOpenId` functions
+- `api/server/socialLogins.js` - Added separate configuration functions for Solid and generic OpenID strategies
+- `api/server/routes/config.js` - Added Solid-specific configuration fields (`solidLoginEnabled`, `solidLabel`, `solidImageUrl`, `solidAutoRedirect`)
+- `client/src/components/Auth/SocialLoginRender.tsx` - Added Solid button component with SolidIcon
+- `packages/client/src/svgs/SolidIcon.tsx` - New Solid icon component for authentication UI
+- `packages/client/src/svgs/index.ts` - Exported SolidIcon
+- `packages/data-provider/src/config.ts` - Added Solid configuration fields to `TStartupConfig` type
 
 ## Dependencies Added
 - `@inrupt/solid-client@^1.30.2` - Solid Pod client library
 
+## Environment Variables
+
+### Solid Authentication (SOLID_OPENID_*)
+The following environment variables are required for the "Login with Solid" button:
+
+- `SOLID_OPENID_CLIENT_ID` - OAuth client ID for Solid authentication
+- `SOLID_OPENID_CLIENT_SECRET` - OAuth client secret for Solid authentication
+- `SOLID_OPENID_ISSUER` - Solid Pod provider URL (e.g., `http://localhost:3000/`)
+- `SOLID_OPENID_SCOPE` - OAuth scopes (typically `"openid webid"`)
+- `SOLID_OPENID_SESSION_SECRET` - Secret key for session management
+- `SOLID_OPENID_CALLBACK_URL` - OAuth callback URL (typically `/oauth/openid/callback`)
+
+### Optional Solid Configuration
+- `SOLID_OPENID_BUTTON_LABEL` - Custom label for the Solid login button (default: "Continue with Solid")
+- `SOLID_OPENID_IMAGE_URL` - Custom icon URL for the Solid login button
+- `SOLID_OPENID_AUTO_REDIRECT` - Enable automatic redirect to Solid provider on login page
+
+### Generic OpenID Authentication (OPENID_*)
+The following environment variables are used for the generic "Login with OpenID" button:
+
+- `OPENID_CLIENT_ID` - OAuth client ID for generic OpenID authentication
+- `OPENID_CLIENT_SECRET` - OAuth client secret for generic OpenID authentication
+- `OPENID_ISSUER` - OpenID provider URL
+- `OPENID_SCOPE` - OAuth scopes
+- `OPENID_SESSION_SECRET` - Secret key for session management
+- `OPENID_CALLBACK_URL` - OAuth callback URL (typically `/oauth/openid/callback`)
+- `OPENID_BUTTON_LABEL` - Custom label for the OpenID login button (default: "Continue with OpenID")
+- `OPENID_IMAGE_URL` - Custom icon URL for the OpenID login button
+- `OPENID_AUTO_REDIRECT` - Enable automatic redirect to OpenID provider on login page
+
+### Solid Storage
+- `USE_SOLID_STORAGE` - Enable Solid Pod storage for conversations and messages (set to `true` to enable)
+
 ---
 
-**Report Date**: February 5, 2026  
+**Report Date**: February 6, 2026
 
 

From 0a2f165907fc6021c1156c784be09fc5ba9fde3d Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 6 Feb 2026 12:32:18 +0000
Subject: [PATCH 26/94] update env.example

---
 .env.example | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.env.example b/.env.example
index 06d509a3ae29..d5c8311e4ff5 100644
--- a/.env.example
+++ b/.env.example
@@ -496,6 +496,14 @@ APPLE_KEY_ID=
 APPLE_PRIVATE_KEY_PATH=
 APPLE_CALLBACK_URL=/oauth/apple/callback
 
+#SolidOpenID
+SOLID_OPENID_CLIENT_ID=http://localhost:3080/solid-client-id
+SOLID_OPENID_ISSUER=http://localhost:3000/
+SOLID_OPENID_SESSION_SECRET=[JustGenerateARandomSessionSecret]
+SOLID_OPENID_SCOPE="openid webid"
+SOLID_OPENID_CALLBACK_URL=/oauth/openid/callback
+SOLID_OPENID_BUTTON_LABEL=Continue with Solid
+
 # OpenID
 OPENID_CLIENT_ID=
 OPENID_CLIENT_SECRET=

From 565aea75a504b51edf036dd5257bd039dce03696 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 10:00:22 +0000
Subject: [PATCH 27/94] Update api/models/Message.js

removed commented out code

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/models/Message.js | 79 -------------------------------------------
 1 file changed, 79 deletions(-)

diff --git a/api/models/Message.js b/api/models/Message.js
index cdf363ae64eb..fc4bc9cabc9e 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -90,85 +90,6 @@ async function saveMessage(req, params, metadata) {
     }
   }
 
-  // MongoDB storage (original code - commented for reference)
-  /*
-  try {
-    const update = {
-      ...params,
-      user: req.user.id,
-      messageId: params.newMessageId || params.messageId,
-    };
-
-    if (req?.body?.isTemporary) {
-      try {
-        const appConfig = req.config;
-        update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
-      } catch (err) {
-        logger.error('Error creating temporary chat expiration date:', err);
-        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-        update.expiredAt = null;
-      }
-    } else {
-      update.expiredAt = null;
-    }
-
-    if (update.tokenCount != null && isNaN(update.tokenCount)) {
-      logger.warn(
-        `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${update.tokenCount}`,
-      );
-      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-      update.tokenCount = 0;
-    }
-    const message = await Message.findOneAndUpdate(
-      { messageId: params.messageId, user: req.user.id },
-      update,
-      { upsert: true, new: true },
-    );
-
-    return message.toObject();
-  } catch (err) {
-    logger.error('Error saving message:', err);
-    logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-
-    // 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
-  }
-  */
   
   // Fallback to MongoDB if Solid is not enabled
   try {

From 12089075de415825d505d2bbebe889cb479d24ee Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 12:16:43 +0000
Subject: [PATCH 28/94] =?UTF-8?q?refactor(solid):=20address=20PR=20review?=
 =?UTF-8?q?=20=E2=80=93=20determine=20storage=20by=20login=20method,=20rem?=
 =?UTF-8?q?ove=20USE=5FSOLID=5FSTORAGE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Set provider to 'solid' for "Continue with Solid" (openid stays for generic OpenID)
- Removed USE_SOLID_STORAGE; use provider === 'solid' for Solid Pod storage
- Treat solid like openid for token storage and logout (oauth, LogoutController)
- Added isSolidUser(req) in server/utils and used it everywhere (DRY)
- Updated findOpenIDUser to allow solid provider for Solid strategy
- Updated SOLID_INTEGRATION_PROGRESS.md
---
 SOLID_INTEGRATION_PROGRESS.md                 | 16 ++++++------
 api/models/Conversation.js                    | 26 +++++++++----------
 api/models/Message.js                         | 18 ++++++-------
 .../controllers/auth/LogoutController.js      |  4 ++-
 api/server/middleware/buildEndpointOption.js  |  7 +++--
 api/server/middleware/validateMessageReq.js   |  8 +++---
 api/server/routes/convos.js                   |  7 +++--
 api/server/routes/messages.js                 | 17 ++++++------
 api/server/routes/oauth.js                    |  2 +-
 api/server/utils/import/fork.js               | 10 +++----
 api/server/utils/isSolidUser.js               | 12 +++++++++
 api/strategies/SolidOpenidStrategy.js         |  4 +--
 packages/api/src/auth/openid.ts               |  8 +++---
 packages/data-schemas/src/methods/share.ts    | 15 +++++------
 14 files changed, 79 insertions(+), 75 deletions(-)
 create mode 100644 api/server/utils/isSolidUser.js

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 98f06db7d19b..c562c1d97a88 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -57,19 +57,19 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Properly parses Turtle format to extract `ldp:contains` items
   - Handles empty containers gracefully (returns empty arrays, not errors)
 
-### 7. Feature Flag Implementation
+### 7. Storage Backend Selection (No Feature Flag)
 - **Status**: Complete
 - **Details**:
-  - Added `USE_SOLID_STORAGE` environment variable
-  - Integrated Solid storage functions into `Message.js` and `Conversation.js` models
-  - Maintains backward compatibility with MongoDB
-  - Original MongoDB code preserved (commented) for rollback capability
+  - Storage backend is determined by how the user logged in: **"Continue with Solid"** → Solid Pod; **"Continue with OpenID"** or other → MongoDB
+  - Users who click "Continue with Solid" have `provider === 'solid'`; only those get Solid storage
+  - Integrated Solid storage in `Message.js`, `Conversation.js`, routes, and share methods
+  - Maintains backward compatibility with MongoDB for all non-Solid users
 
 ### 8. Conversation Access Validation
 - **Status**: Complete
 - **Details**:
   - Updated `validateConvoAccess` middleware to check Solid storage
-  - Modified `searchConversation` to query Solid Pod when `USE_SOLID_STORAGE` is enabled
+  - Modified `searchConversation` to query Solid Pod when the user logged in via "Continue with Solid" (`provider === 'solid'`)
   - Ensures users can only access their own conversations from Solid Pod
   - Maintains MongoDB fallback for non-Solid users
 
@@ -256,10 +256,10 @@ The following environment variables are used for the generic "Login with OpenID"
 - `OPENID_AUTO_REDIRECT` - Enable automatic redirect to OpenID provider on login page
 
 ### Solid Storage
-- `USE_SOLID_STORAGE` - Enable Solid Pod storage for conversations and messages (set to `true` to enable)
+- Storage is chosen per user: **Solid Pod** for users who logged in with "Continue with Solid" (`provider === 'solid'`); **MongoDB** for everyone else. No environment variable is required.
 
 ---
 
-**Report Date**: February 6, 2026
+**Report Date**: February 11, 2026
 
 
diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 8e0b6f6837d5..a8d40aae42a5 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -1,10 +1,8 @@
 const { logger } = require('@librechat/data-schemas');
-const { createTempChatExpirationDate, isEnabled } = require('@librechat/api');
+const { createTempChatExpirationDate } = require('@librechat/api');
 const { getMessages, deleteMessages } = require('./Message');
 const { Conversation } = require('~/db/models');
-
-// Feature flag to toggle between MongoDB and Solid storage
-const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 /**
  * Searches for a conversation by conversationId and returns a lean document with only conversationId and user.
@@ -14,8 +12,8 @@ const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
  */
 const searchConversation = async (conversationId, req = null) => {
   try {
-    // Use Solid storage if enabled and req is provided with openidId
-    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+    // Use Solid storage when user logged in via "Continue with Solid"
+    if (isSolidUser(req)) {
       try {
         const { getConvoFromSolid } = require('~/server/services/SolidStorage');
         const convo = await getConvoFromSolid(req, conversationId);
@@ -55,8 +53,8 @@ const searchConversation = async (conversationId, req = null) => {
  * @returns {Promise<TConversation>} The conversation object.
  */
 const getConvo = async (user, conversationId, req = null) => {
-  // Use Solid storage if enabled and req is provided with openidId
-  if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+  // Use Solid storage when user logged in via "Continue with Solid"
+  if (isSolidUser(req)) {
     try {
       const { getConvoFromSolid } = require('~/server/services/SolidStorage');
       const convo = await getConvoFromSolid(req, conversationId);
@@ -142,8 +140,8 @@ module.exports = {
    * @returns {Promise<TConversation>} The conversation object.
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
-    // Use Solid storage if enabled and user is a Solid user
-    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+    // Use Solid storage when user logged in via "Continue with Solid"
+    if (isSolidUser(req)) {
       try {
         if (metadata?.context) {
           logger.debug(`[saveConvo] ${metadata.context}`);
@@ -272,8 +270,8 @@ module.exports = {
       req, // Optional req object for Solid storage
     } = {},
   ) => {
-    // Use Solid storage if enabled and req is provided
-    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+    // Use Solid storage when user logged in via "Continue with Solid"
+    if (isSolidUser(req)) {
       try {
         const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
         return await getConvosByCursorFromSolid(req, {
@@ -471,8 +469,8 @@ module.exports = {
    * logger.error(result); // { n: 5, ok: 1, deletedCount: 5, messages: { n: 10, ok: 1, deletedCount: 10 } }
    */
   deleteConvos: async (user, filter, req = null) => {
-    // Use Solid storage if enabled and req is provided with openidId
-    if (USE_SOLID_STORAGE && req && req.user?.openidId) {
+    // Use Solid storage when user logged in via "Continue with Solid"
+    if (isSolidUser(req)) {
       try {
         const { deleteConvosFromSolid } = require('~/server/services/SolidStorage');
         const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
diff --git a/api/models/Message.js b/api/models/Message.js
index fc4bc9cabc9e..7e441ebfa5e9 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -1,13 +1,11 @@
 const { z } = require('zod');
 const { logger } = require('@librechat/data-schemas');
-const { createTempChatExpirationDate, isEnabled } = require('@librechat/api');
+const { createTempChatExpirationDate } = require('@librechat/api');
 const { Message } = require('~/db/models');
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 const idSchema = z.string().uuid();
 
-// Feature flag to toggle between MongoDB and Solid storage
-const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
-
 /**
  * Saves a message in the database.
  *
@@ -50,8 +48,8 @@ async function saveMessage(req, params, metadata) {
     return;
   }
 
-  // Use Solid storage if enabled
-  if (USE_SOLID_STORAGE) {
+  // Use Solid storage when user logged in via "Continue with Solid"
+  if (isSolidUser(req)) {
     try {
       const { saveMessageToSolid } = require('~/server/services/SolidStorage');
       
@@ -282,8 +280,8 @@ async function updateMessageText(req, { messageId, text }) {
  * @throws {Error} If there is an error in updating the message or if the message is not found.
  */
 async function updateMessage(req, message, metadata) {
-  // Use Solid storage if enabled
-  if (USE_SOLID_STORAGE) {
+  // Use Solid storage when user logged in via "Continue with Solid"
+  if (isSolidUser(req)) {
     try {
       const { updateMessageInSolid } = require('~/server/services/SolidStorage');
       const updatedMessage = await updateMessageInSolid(req, message, metadata);
@@ -354,8 +352,8 @@ async function updateMessage(req, message, metadata) {
  * @throws {Error} If there is an error in deleting messages.
  */
 async function deleteMessagesSince(req, { messageId, conversationId }) {
-  // Use Solid storage if enabled
-  if (USE_SOLID_STORAGE) {
+  // Use Solid storage when user logged in via "Continue with Solid"
+  if (isSolidUser(req)) {
     try {
       const { deleteMessagesFromSolid } = require('~/server/services/SolidStorage');
       const deletedCount = await deleteMessagesFromSolid(req, {
diff --git a/api/server/controllers/auth/LogoutController.js b/api/server/controllers/auth/LogoutController.js
index 039ed630c225..b475b2d8bb5a 100644
--- a/api/server/controllers/auth/LogoutController.js
+++ b/api/server/controllers/auth/LogoutController.js
@@ -6,7 +6,9 @@ const { getOpenIdConfig } = require('~/strategies');
 
 const logoutController = async (req, res) => {
   const parsedCookies = req.headers.cookie ? cookies.parse(req.headers.cookie) : {};
-  const isOpenIdUser = req.user?.openidId != null && req.user?.provider === 'openid';
+  const isOpenIdUser =
+    req.user?.openidId != null &&
+    (req.user?.provider === 'openid' || req.user?.provider === 'solid');
 
   /** For OpenID users, read tokens from session (with cookie fallback) */
   let refreshToken;
diff --git a/api/server/middleware/buildEndpointOption.js b/api/server/middleware/buildEndpointOption.js
index 3c360a79500d..deda1a56077a 100644
--- a/api/server/middleware/buildEndpointOption.js
+++ b/api/server/middleware/buildEndpointOption.js
@@ -1,4 +1,4 @@
-const { handleError, isEnabled } = require('@librechat/api');
+const { handleError } = require('@librechat/api');
 const { logger } = require('@librechat/data-schemas');
 const {
   EndpointURLs,
@@ -12,7 +12,7 @@ const assistants = require('~/server/services/Endpoints/assistants');
 const { getEndpointsConfig } = require('~/server/services/Config');
 const agents = require('~/server/services/Endpoints/agents');
 const { updateFilesUsage } = require('~/models');
-const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 const buildFunction = {
   [EModelEndpoint.agents]: agents.buildOptions,
@@ -93,8 +93,7 @@ async function buildEndpointOption(req, res, next) {
   // If model is missing and we have a conversationId, try to load it from Solid storage
   if (!parsedBody.model && req.body?.conversationId && 
       req.body.conversationId !== 'new' && 
-      isEnabled(USE_SOLID_STORAGE) && 
-      req.user?.openidId) {
+      isSolidUser(req)) {
     try {
       const { getConvoFromSolid } = require('~/server/services/SolidStorage');
       const conversation = await getConvoFromSolid(req, req.body.conversationId);
diff --git a/api/server/middleware/validateMessageReq.js b/api/server/middleware/validateMessageReq.js
index 7e4d21c53589..ffe564e1ec09 100644
--- a/api/server/middleware/validateMessageReq.js
+++ b/api/server/middleware/validateMessageReq.js
@@ -1,8 +1,6 @@
 const { getConvo } = require('~/models');
-const { isEnabled } = require('@librechat/api');
 const { getConvoFromSolid } = require('~/server/services/SolidStorage');
-
-const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 // Middleware to validate conversationId and user relationship
 const validateMessageReq = async (req, res, next) => {
@@ -18,8 +16,8 @@ const validateMessageReq = async (req, res, next) => {
 
   let conversation = null;
 
-  // Use Solid storage if enabled
-  if (USE_SOLID_STORAGE && req.user?.openidId) {
+  // Use Solid storage when user logged in via "Continue with Solid"
+  if (isSolidUser(req)) {
     try {
       conversation = await getConvoFromSolid(req, conversationId);
     } catch (error) {
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index 01e966c2f8e7..ab8b93aa8518 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -18,6 +18,7 @@ const requireJwtAuth = require('~/server/middleware/requireJwtAuth');
 const { importConversations } = require('~/server/utils/import');
 const { deleteToolCalls } = require('~/models/ToolCall');
 const getLogStores = require('~/cache/getLogStores');
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 const assistantClients = {
   [EModelEndpoint.azureAssistants]: require('~/server/services/Endpoints/azureAssistants'),
@@ -57,8 +58,7 @@ router.get('/', async (req, res) => {
       error: error.message,
       stack: error.stack,
       userId: req.user?.id,
-      hasOpenidId: !!req.user?.openidId,
-      useSolidStorage: process.env.USE_SOLID_STORAGE,
+      isSolidUser: isSolidUser(req),
     });
     res.status(500).json({ 
       error: 'Error fetching conversations',
@@ -73,8 +73,7 @@ router.get('/:conversationId', async (req, res) => {
   logger.info('[GET /api/convos/:conversationId] Fetching conversation', {
     conversationId,
     userId: req.user?.id,
-    hasOpenidId: !!req.user?.openidId,
-    useSolidStorage: isEnabled(process.env.USE_SOLID_STORAGE),
+    isSolidUser: isSolidUser(req),
   });
   
   try {
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index 4bb4280854cc..042c69bed677 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -2,7 +2,7 @@ const express = require('express');
 const { v4: uuidv4 } = require('uuid');
 const { logger } = require('@librechat/data-schemas');
 const { ContentTypes } = require('librechat-data-provider');
-const { unescapeLaTeX, countTokens, isEnabled } = require('@librechat/api');
+const { unescapeLaTeX, countTokens } = require('@librechat/api');
 const {
   saveConvo,
   getMessage,
@@ -16,8 +16,7 @@ const { requireJwtAuth, validateMessageReq } = require('~/server/middleware');
 const { getConvosQueried } = require('~/models/Conversation');
 const { Message } = require('~/db/models');
 const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
-
-const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 const router = express.Router();
 router.use(requireJwtAuth);
@@ -43,8 +42,8 @@ router.get('/', async (req, res) => {
     const sortOrder = sortDirection === 'asc' ? 1 : -1;
 
     if (conversationId && messageId) {
-      // Use Solid storage if enabled
-      if (USE_SOLID_STORAGE && req.user?.openidId) {
+      // Use Solid storage when user logged in via "Continue with Solid"
+      if (isSolidUser(req)) {
         try {
           const allMessages = await getMessagesFromSolid(req, conversationId);
           const message = allMessages.find(m => m.messageId === messageId);
@@ -69,8 +68,8 @@ router.get('/', async (req, res) => {
         response = { messages: message ? [message] : [], nextCursor: null };
       }
     } else if (conversationId) {
-      // Use Solid storage if enabled
-      if (USE_SOLID_STORAGE && req.user?.openidId) {
+      // Use Solid storage when user logged in via "Continue with Solid"
+      if (isSolidUser(req)) {
         try {
           const allMessages = await getMessagesFromSolid(req, conversationId);
           
@@ -358,8 +357,8 @@ router.get('/:conversationId', validateMessageReq, async (req, res) => {
   try {
     const { conversationId } = req.params;
     
-    // Use Solid storage if enabled
-    if (USE_SOLID_STORAGE && req.user?.openidId) {
+    // Use Solid storage when user logged in via "Continue with Solid"
+    if (isSolidUser(req)) {
       try {
         const messages = await getMessagesFromSolid(req, conversationId);
         // Remove internal fields for response
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 8a365e6bce1a..4a339040e1cd 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -37,7 +37,7 @@ const oauthHandler = async (req, res, next) => {
     }
     if (
       req.user &&
-      req.user.provider == 'openid' &&
+      (req.user.provider === 'openid' || req.user.provider === 'solid') &&
       // isEnabled(process.env.OPENID_REUSE_TOKENS) === true
       req.user.tokenset &&
       req.user.tokenset.access_token
diff --git a/api/server/utils/import/fork.js b/api/server/utils/import/fork.js
index cbccb5042bab..3d85aa670f68 100644
--- a/api/server/utils/import/fork.js
+++ b/api/server/utils/import/fork.js
@@ -361,10 +361,10 @@ function splitAtTargetLevel(messages, targetMessageId) {
  * @param {object} [params.req] - Optional Express request object for Solid storage support.
  * @returns {Promise<{ conversation: TConversation, messages: TMessage[] }>} The duplicated conversation and messages.
  */
+const { isSolidUser } = require('~/server/utils/isSolidUser');
+
 async function duplicateConversation({ userId, conversationId, req }) {
-  const { isEnabled } = require('@librechat/api');
-  const USE_SOLID_STORAGE = isEnabled(process.env.USE_SOLID_STORAGE);
-  const isSolidUser = USE_SOLID_STORAGE && req && req.user?.openidId;
+  const useSolidStorage = isSolidUser(req);
 
   // Get original conversation
   const originalConvo = await getConvo(userId, conversationId, req);
@@ -374,7 +374,7 @@ async function duplicateConversation({ userId, conversationId, req }) {
 
   // Get original messages
   let originalMessages;
-  if (isSolidUser) {
+  if (useSolidStorage) {
     const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
     originalMessages = await getMessagesFromSolid(req, conversationId);
   } else {
@@ -394,7 +394,7 @@ async function duplicateConversation({ userId, conversationId, req }) {
   );
 
   // For Solid users, save individually to support Solid storage
-  if (isSolidUser) {
+  if (useSolidStorage) {
     const { saveConvo } = require('~/models/Conversation');
     const { saveMessage } = require('~/models/Message');
     const { v4: uuidv4 } = require('uuid');
diff --git a/api/server/utils/isSolidUser.js b/api/server/utils/isSolidUser.js
new file mode 100644
index 000000000000..deaab42c16ea
--- /dev/null
+++ b/api/server/utils/isSolidUser.js
@@ -0,0 +1,12 @@
+/**
+ * Determines if the request belongs to a user who logged in via "Continue with Solid".
+ * Only those users get Solid Pod storage; "Continue with OpenID" and others use MongoDB.
+ *
+ * @param {import('express').Request} [req] - Express request with optional user
+ * @returns {boolean}
+ */
+function isSolidUser(req) {
+  return !!(req && req.user?.provider === 'solid');
+}
+
+module.exports = { isSolidUser };
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 0ce3de9332c0..696b103f216a 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -441,7 +441,7 @@ async function setupSolidOpenId() {
 
           if (!user) {
             user = {
-              provider: 'openid',
+              provider: 'solid',
               openidId: userinfo.sub,
               username,
               email: email || '',
@@ -453,7 +453,7 @@ async function setupSolidOpenId() {
             const balanceConfig = getBalanceConfig(appConfig);
             user = await createUser(user, balanceConfig, true, true);
           } else {
-            user.provider = 'openid';
+            user.provider = 'solid';
             user.openidId = userinfo.sub;
             user.username = username;
             user.name = fullName;
diff --git a/packages/api/src/auth/openid.ts b/packages/api/src/auth/openid.ts
index a7079ccd1653..a1f7a4681f05 100644
--- a/packages/api/src/auth/openid.ts
+++ b/packages/api/src/auth/openid.ts
@@ -39,8 +39,10 @@ export async function findOpenIDUser({
       `[${strategyName}] user ${user ? 'found' : 'not found'} with email: ${email} for openidId: ${openidId}`,
     );
 
-    // If user found by email, check if they're allowed to use OpenID provider
-    if (user && user.provider && user.provider !== 'openid') {
+    // If user found by email, check if they're allowed to use this provider (OpenID or Solid)
+    const allowedProviders =
+      strategyName === 'SolidOpenidStrategy' ? ['openid', 'solid'] : ['openid'];
+    if (user && user.provider && !allowedProviders.includes(user.provider)) {
       logger.warn(
         `[${strategyName}] Attempted OpenID login by user ${user.email}, was registered with "${user.provider}" provider`,
       );
@@ -52,7 +54,7 @@ export async function findOpenIDUser({
       logger.info(
         `[${strategyName}] Preparing user ${user.email} for migration to OpenID with sub: ${openidId}`,
       );
-      user.provider = 'openid';
+      user.provider = strategyName === 'SolidOpenidStrategy' ? 'solid' : 'openid';
       user.openidId = openidId;
       return { user, error: null, migration: true };
     }
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 61bc8417367e..9f3a32cf627b 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -378,12 +378,10 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       // Find all shares for this conversation to check if any are Solid shares
       const shares = await SharedLink.find({ user, conversationId }).lean();
       
-      // If any shares are Solid shares, remove public access
+      // If any shares are Solid shares, remove public access (user logged in via "Continue with Solid")
       if (req) {
-        const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
-        const isSolidUser = USE_SOLID_STORAGE && req?.user?.openidId;
-        
-        if (isSolidUser) {
+        const { isSolidUser } = require('~/server/utils/isSolidUser');
+        if (isSolidUser(req)) {
           const solidShares = shares.filter(share => share.podUrl);
           for (const share of solidShares) {
             try {
@@ -439,15 +437,14 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
       const Conversation = mongoose.models.Conversation as SchemaWithMeiliMethods;
 
-      // Check if this is a Solid user
-      const USE_SOLID_STORAGE = process.env.USE_SOLID_STORAGE;
-      const isSolidUser = USE_SOLID_STORAGE && req?.user?.openidId;
+      // Check if this is a Solid user (logged in via "Continue with Solid")
+      const { isSolidUser } = require('~/server/utils/isSolidUser');
 
       let conversation;
       let conversationMessages;
       let podUrl: string | undefined;
 
-      if (isSolidUser) {
+      if (isSolidUser(req)) {
         logger.info('[createSharedLink] Detected Solid user, using Solid storage path');
         // Check for existing share first (same as MongoDB)
         const existingShare = (await SharedLink.findOne({

From 97bc6944b1bd939ade13fe79189a59cb7e028bee Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 15:03:57 +0000
Subject: [PATCH 29/94] refactor(solid): remove MongoDB fallback for Solid
 users (per PR review)

Code now allows Solid users to use Solid storage only. On Solid failure or null:
- Conversation.js: return null or rethrow (searchConversation, getConvo,
  saveConvo, getConvosByCursor)
- validateMessageReq: return 404 when conversation not in Solid
- messages routes: return 503 with "Solid storage temporarily unavailable"
---
 api/models/Conversation.js                  | 96 ++++++---------------
 api/models/Message.js                       |  2 +-
 api/server/middleware/validateMessageReq.js | 24 +++---
 api/server/routes/messages.js               | 58 +++++--------
 api/server/services/SolidStorage.js         |  2 +-
 5 files changed, 62 insertions(+), 120 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index a8d40aae42a5..c1cbde8a5808 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -12,32 +12,19 @@ const { isSolidUser } = require('~/server/utils/isSolidUser');
  */
 const searchConversation = async (conversationId, req = null) => {
   try {
-    // Use Solid storage when user logged in via "Continue with Solid"
+    // Solid users: use Solid storage only; no MongoDB fallback 
     if (isSolidUser(req)) {
-      try {
-        const { getConvoFromSolid } = require('~/server/services/SolidStorage');
-        const convo = await getConvoFromSolid(req, conversationId);
-        if (convo) {
-          // Return only conversationId and user to match MongoDB format
-          return {
-            conversationId: convo.conversationId,
-            user: convo.user,
-          };
-        }
-        // If Solid storage returns null, fall through to MongoDB
-        logger.debug('[searchConversation] Conversation not found in Solid Pod, falling back to MongoDB', {
-          conversationId,
-        });
-      } catch (error) {
-        logger.error('[searchConversation] Error getting conversation from Solid Pod, falling back to MongoDB', {
-          error: error.message,
-          conversationId,
-        });
-        // Fall through to MongoDB storage
+      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+      const convo = await getConvoFromSolid(req, conversationId);
+      if (convo) {
+        return {
+          conversationId: convo.conversationId,
+          user: convo.user,
+        };
       }
+      return null;
     }
 
-    // MongoDB storage (original code)
     return await Conversation.findOne({ conversationId }, 'conversationId user').lean();
   } catch (error) {
     logger.error('[searchConversation] Error searching conversation', error);
@@ -53,30 +40,13 @@ const searchConversation = async (conversationId, req = null) => {
  * @returns {Promise<TConversation>} The conversation object.
  */
 const getConvo = async (user, conversationId, req = null) => {
-  // Use Solid storage when user logged in via "Continue with Solid"
+  // Solid users: use Solid storage only; no MongoDB fallback 
   if (isSolidUser(req)) {
-    try {
-      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
-      const convo = await getConvoFromSolid(req, conversationId);
-      if (convo) {
-        return convo;
-      }
-      // If Solid storage returns null, fall through to MongoDB
-      logger.warn('[getConvo] Conversation not found in Solid Pod, falling back to MongoDB', {
-        conversationId,
-        userId: user,
-      });
-    } catch (error) {
-      logger.error('[getConvo] Error getting conversation from Solid Pod, falling back to MongoDB', {
-        error: error.message,
-        conversationId,
-        userId: user,
-      });
-      // Fall through to MongoDB storage
-    }
+    const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+    const convo = await getConvoFromSolid(req, conversationId);
+    return convo ?? null;
   }
 
-  // MongoDB storage (original code)
   try {
     return await Conversation.findOne({ user, conversationId }).lean();
   } catch (error) {
@@ -175,15 +145,12 @@ module.exports = {
         if (metadata && metadata?.context) {
           logger.info(`[saveConvo] ${metadata.context}`);
         }
-        // Fall through to MongoDB if Solid save fails
-        logger.warn('[saveConvo] Falling back to MongoDB after Solid save failure', {
-          conversationId,
-          error: error.message,
-        });
+        // Solid users: surface error so UI can show "Save failed"
+        throw error;
       }
     }
 
-    // MongoDB storage (original code)
+    // MongoDB storage
     try {
       if (metadata?.context) {
         logger.debug(`[saveConvo] ${metadata.context}`);
@@ -270,27 +237,18 @@ module.exports = {
       req, // Optional req object for Solid storage
     } = {},
   ) => {
-    // Use Solid storage when user logged in via "Continue with Solid"
+
     if (isSolidUser(req)) {
-      try {
-        const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
-        return await getConvosByCursorFromSolid(req, {
-          cursor,
-          limit,
-          isArchived,
-          tags,
-          search,
-          sortBy,
-          sortDirection,
-        });
-      } catch (error) {
-        logger.warn('[getConvosByCursor] Error getting conversations from Solid Pod, falling back to MongoDB', {
-          error: error.message,
-          user: req.user?.id,
-          hasOpenidId: !!req.user?.openidId,
-        });
-        // Fall through to MongoDB storage
-      }
+      const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
+      return await getConvosByCursorFromSolid(req, {
+        cursor,
+        limit,
+        isArchived,
+        tags,
+        search,
+        sortBy,
+        sortDirection,
+      });
     }
     const filters = [{ user }];
     if (isArchived) {
diff --git a/api/models/Message.js b/api/models/Message.js
index 7e441ebfa5e9..8bb056194603 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -89,7 +89,7 @@ async function saveMessage(req, params, metadata) {
   }
 
   
-  // Fallback to MongoDB if Solid is not enabled
+  // MongoDB path for non-Solid users
   try {
     const update = {
       ...params,
diff --git a/api/server/middleware/validateMessageReq.js b/api/server/middleware/validateMessageReq.js
index ffe564e1ec09..7dc8ad12c88d 100644
--- a/api/server/middleware/validateMessageReq.js
+++ b/api/server/middleware/validateMessageReq.js
@@ -1,3 +1,4 @@
+const { logger } = require('@librechat/data-schemas');
 const { getConvo } = require('~/models');
 const { getConvoFromSolid } = require('~/server/services/SolidStorage');
 const { isSolidUser } = require('~/server/utils/isSolidUser');
@@ -16,23 +17,24 @@ const validateMessageReq = async (req, res, next) => {
 
   let conversation = null;
 
-  // Use Solid storage when user logged in via "Continue with Solid"
+  // Solid users: use Solid storage only; no MongoDB fallback
   if (isSolidUser(req)) {
     try {
       conversation = await getConvoFromSolid(req, conversationId);
     } catch (error) {
-      // If Solid storage fails, fall back to MongoDB
-      // Don't log error here as it might be expected (conversation doesn't exist in Solid yet)
+      logger.error('[validateMessageReq] Error loading conversation from Solid Pod', {
+        conversationId,
+        error: error.message,
+      });
     }
-  }
-
-  // Fallback to MongoDB if Solid storage is disabled or didn't find the conversation
-  if (!conversation) {
+    if (!conversation) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
+  } else {
     conversation = await getConvo(req.user.id, conversationId);
-  }
-
-  if (!conversation) {
-    return res.status(404).json({ error: 'Conversation not found' });
+    if (!conversation) {
+      return res.status(404).json({ error: 'Conversation not found' });
+    }
   }
 
   if (conversation.user !== req.user.id) {
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index 042c69bed677..cbbd57b20873 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -42,21 +42,18 @@ router.get('/', async (req, res) => {
     const sortOrder = sortDirection === 'asc' ? 1 : -1;
 
     if (conversationId && messageId) {
-      // Use Solid storage when user logged in via "Continue with Solid"
+     
       if (isSolidUser(req)) {
         try {
           const allMessages = await getMessagesFromSolid(req, conversationId);
           const message = allMessages.find(m => m.messageId === messageId);
           response = { messages: message ? [message] : [], nextCursor: null };
         } catch (error) {
-          logger.error('Error getting message from Solid Pod, falling back to MongoDB', error);
-          // Fallback to MongoDB
-          const message = await Message.findOne({
-            conversationId,
-            messageId,
-            user: user,
-          }).lean();
-          response = { messages: message ? [message] : [], nextCursor: null };
+          logger.error('Error getting message from Solid Pod', error);
+          return res.status(503).json({
+            error: 'Failed to load from Solid Pod',
+            message: 'Solid storage is temporarily unavailable. Please try again.',
+          });
         }
       } else {
         // MongoDB storage
@@ -99,26 +96,13 @@ router.get('/', async (req, res) => {
           }
           response = { messages, nextCursor };
         } catch (error) {
-          logger.error('Error getting messages from Solid Pod, falling back to MongoDB', error);
-          // Fallback to MongoDB
-          const filter = { conversationId, user: user };
-          if (cursor) {
-            filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
-          }
-          const messages = await Message.find(filter)
-            .sort({ [sortField]: sortOrder })
-            .limit(pageSize + 1)
-            .lean();
-          let nextCursor = null;
-          if (messages.length > pageSize) {
-            messages.pop(); // Remove extra item used to detect next page
-            // Create cursor from the last RETURNED item (not the popped one)
-            nextCursor = messages[messages.length - 1][sortField];
-          }
-          response = { messages, nextCursor };
+          logger.error('Error getting messages from Solid Pod', error);
+          return res.status(503).json({
+            error: 'Failed to load from Solid Pod',
+            message: 'Solid storage is temporarily unavailable. Please try again.',
+          });
         }
       } else {
-        // MongoDB storage
         const filter = { conversationId, user: user };
         if (cursor) {
           filter[sortField] = sortOrder === 1 ? { $gt: cursor } : { $lt: cursor };
@@ -357,27 +341,25 @@ router.get('/:conversationId', validateMessageReq, async (req, res) => {
   try {
     const { conversationId } = req.params;
     
-    // Use Solid storage when user logged in via "Continue with Solid"
+
     if (isSolidUser(req)) {
       try {
         const messages = await getMessagesFromSolid(req, conversationId);
-        // Remove internal fields for response
         const cleanedMessages = messages.map(msg => {
           const { _id, __v, user, ...rest } = msg;
           return rest;
         });
-        res.status(200).json(cleanedMessages);
+        return res.status(200).json(cleanedMessages);
       } catch (error) {
-        logger.error('Error getting messages from Solid Pod, falling back to MongoDB', error);
-        // Fallback to MongoDB
-        const messages = await getMessages({ conversationId }, '-_id -__v -user');
-        res.status(200).json(messages);
+        logger.error('Error getting messages from Solid Pod', error);
+        return res.status(503).json({
+          error: 'Failed to load from Solid Pod',
+          message: 'Solid storage is temporarily unavailable. Please try again.',
+        });
       }
-    } else {
-      // MongoDB storage
-      const messages = await getMessages({ conversationId }, '-_id -__v -user');
-      res.status(200).json(messages);
     }
+    const messages = await getMessages({ conversationId }, '-_id -__v -user');
+    res.status(200).json(messages);
   } catch (error) {
     logger.error('Error fetching messages:', error);
     res.status(500).json({ error: 'Internal server error' });
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index eb81113ab8da..5943d7d27c74 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1722,7 +1722,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       }
       
       // Log unexpected errors but don't throw - return empty array instead
-      // This prevents fallback to MongoDB when Solid storage is enabled
+      // This prevents fallback to MongoDB when user is logged in via "Continue with Solid"
       logger.warn('[SolidStorage] Unexpected error getting container contents, returning empty array', {
         conversationsContainerPath,
         errorMessage,

From a4384b26abd699b06baf5711fc3ebd39632253d0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 15:06:32 +0000
Subject: [PATCH 30/94] update progress doc

---
 SOLID_INTEGRATION_PROGRESS.md | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index c562c1d97a88..2f40db63f45d 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -63,15 +63,20 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Storage backend is determined by how the user logged in: **"Continue with Solid"** → Solid Pod; **"Continue with OpenID"** or other → MongoDB
   - Users who click "Continue with Solid" have `provider === 'solid'`; only those get Solid storage
   - Integrated Solid storage in `Message.js`, `Conversation.js`, routes, and share methods
+  - Shared `isSolidUser(req)` helper in `api/server/utils/isSolidUser.js` used everywhere (DRY)
   - Maintains backward compatibility with MongoDB for all non-Solid users
 
-### 8. Conversation Access Validation
+### 8. Conversation Access Validation & No MongoDB Fallback for Solid Users
 - **Status**: Complete
 - **Details**:
   - Updated `validateConvoAccess` middleware to check Solid storage
   - Modified `searchConversation` to query Solid Pod when the user logged in via "Continue with Solid" (`provider === 'solid'`)
   - Ensures users can only access their own conversations from Solid Pod
-  - Maintains MongoDB fallback for non-Solid users
+  - **No MongoDB fallback for Solid users (per PR review)**: When a user is logged in with Solid, we never fall back to MongoDB on Solid failure or null. Errors are surfaced so the UI can show "Save failed" or "Load failed" instead of writing/reading from the wrong store:
+    - **Conversation.js**: `searchConversation`, `getConvo`, `saveConvo`, `getConvosByCursor` return null or rethrow for Solid users; no MongoDB path
+    - **validateMessageReq.js**: Solid users get 404 if conversation not in Solid; no MongoDB lookup
+    - **messages.js** routes: Solid errors return 503 with "Solid storage temporarily unavailable"; no MongoDB read
+  - Non-Solid users continue to use MongoDB only
 
 ### 9. Payload Normalization & Model Extraction
 - **Status**: Complete
@@ -192,14 +197,17 @@ None currently identified.
 
 ## Files Modified
 - `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations
-- `api/models/Message.js` - Integrated Solid storage
-- `api/models/Conversation.js` - Integrated Solid storage, updated `searchConversation` for Solid support
+- `api/server/utils/isSolidUser.js` (NEW) - Shared helper to detect Solid login (`provider === 'solid'`), used across models, routes, and middleware (DRY)
+- `api/models/Message.js` - Integrated Solid storage; MongoDB path for non-Solid users only (no fallback for Solid)
+- `api/models/Conversation.js` - Integrated Solid storage; no MongoDB fallback for Solid users (return null/rethrow on Solid failure)
 - `api/server/routes/oauth.js` - Token logging and storage
 - `api/server/services/AuthService.js` - Token management
 - `api/server/index.js` - Session middleware ordering
 - `api/server/controllers/AuthController.js` - Refresh token handling
 - `api/server/middleware/validate/convoAccess.js` - Added Solid storage support for conversation access validation
-- `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing
+- `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing; uses shared `isSolidUser`
+- `api/server/middleware/validateMessageReq.js` - Solid storage validation; no MongoDB fallback for Solid users (404 on Solid failure)
+- `api/server/routes/messages.js` - Solid message reads return 503 on Solid failure (no MongoDB fallback)
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
 - `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
 - `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod, added Solid storage support to `deleteConvos`

From f2c1b9ba0b2b2444ba3193ed4b52779a915db657 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 16:28:08 +0000
Subject: [PATCH 31/94] refactor(solid): use top-level imports for SolidStorage
 (per review)

- Conversation.js, Message.js, buildEndpointOption.js, fork.js: require SolidStorage and isSolidUser at top level
- fork.js: also require saveConvo, saveMessage at top level
---
 api/models/Conversation.js                   | 14 ++++++--------
 api/models/Message.js                        |  9 +++++----
 api/server/middleware/buildEndpointOption.js |  2 +-
 api/server/utils/import/fork.js              | 13 ++++---------
 packages/data-schemas/src/methods/share.ts   | 11 ++++++++---
 5 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index c1cbde8a5808..050523f44820 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -3,6 +3,12 @@ const { createTempChatExpirationDate } = require('@librechat/api');
 const { getMessages, deleteMessages } = require('./Message');
 const { Conversation } = require('~/db/models');
 const { isSolidUser } = require('~/server/utils/isSolidUser');
+const {
+  getConvoFromSolid,
+  saveConvoToSolid,
+  getConvosByCursorFromSolid,
+  deleteConvosFromSolid,
+} = require('~/server/services/SolidStorage');
 
 /**
  * Searches for a conversation by conversationId and returns a lean document with only conversationId and user.
@@ -14,7 +20,6 @@ const searchConversation = async (conversationId, req = null) => {
   try {
     // Solid users: use Solid storage only; no MongoDB fallback 
     if (isSolidUser(req)) {
-      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
       const convo = await getConvoFromSolid(req, conversationId);
       if (convo) {
         return {
@@ -42,7 +47,6 @@ const searchConversation = async (conversationId, req = null) => {
 const getConvo = async (user, conversationId, req = null) => {
   // Solid users: use Solid storage only; no MongoDB fallback 
   if (isSolidUser(req)) {
-    const { getConvoFromSolid } = require('~/server/services/SolidStorage');
     const convo = await getConvoFromSolid(req, conversationId);
     return convo ?? null;
   }
@@ -117,8 +121,6 @@ module.exports = {
           logger.debug(`[saveConvo] ${metadata.context}`);
         }
 
-        const { saveConvoToSolid } = require('~/server/services/SolidStorage');
-        
         const convoData = {
           conversationId,
           newConversationId,
@@ -239,7 +241,6 @@ module.exports = {
   ) => {
 
     if (isSolidUser(req)) {
-      const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
       return await getConvosByCursorFromSolid(req, {
         cursor,
         limit,
@@ -430,9 +431,6 @@ module.exports = {
     // Use Solid storage when user logged in via "Continue with Solid"
     if (isSolidUser(req)) {
       try {
-        const { deleteConvosFromSolid } = require('~/server/services/SolidStorage');
-        const { getConvosByCursorFromSolid } = require('~/server/services/SolidStorage');
-
         let conversationIds = [];
 
         // If conversationId is specified in filter, use it directly
diff --git a/api/models/Message.js b/api/models/Message.js
index 8bb056194603..0418631f61b5 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -3,6 +3,11 @@ const { logger } = require('@librechat/data-schemas');
 const { createTempChatExpirationDate } = require('@librechat/api');
 const { Message } = require('~/db/models');
 const { isSolidUser } = require('~/server/utils/isSolidUser');
+const {
+  saveMessageToSolid,
+  updateMessageInSolid,
+  deleteMessagesFromSolid,
+} = require('~/server/services/SolidStorage');
 
 const idSchema = z.string().uuid();
 
@@ -51,8 +56,6 @@ async function saveMessage(req, params, metadata) {
   // Use Solid storage when user logged in via "Continue with Solid"
   if (isSolidUser(req)) {
     try {
-      const { saveMessageToSolid } = require('~/server/services/SolidStorage');
-      
       const messageData = {
         ...params,
         messageId: params.newMessageId || params.messageId,
@@ -283,7 +286,6 @@ async function updateMessage(req, message, metadata) {
   // Use Solid storage when user logged in via "Continue with Solid"
   if (isSolidUser(req)) {
     try {
-      const { updateMessageInSolid } = require('~/server/services/SolidStorage');
       const updatedMessage = await updateMessageInSolid(req, message, metadata);
       
       return {
@@ -355,7 +357,6 @@ async function deleteMessagesSince(req, { messageId, conversationId }) {
   // Use Solid storage when user logged in via "Continue with Solid"
   if (isSolidUser(req)) {
     try {
-      const { deleteMessagesFromSolid } = require('~/server/services/SolidStorage');
       const deletedCount = await deleteMessagesFromSolid(req, {
         messageId,
         conversationId,
diff --git a/api/server/middleware/buildEndpointOption.js b/api/server/middleware/buildEndpointOption.js
index deda1a56077a..f681df8872e0 100644
--- a/api/server/middleware/buildEndpointOption.js
+++ b/api/server/middleware/buildEndpointOption.js
@@ -13,6 +13,7 @@ const { getEndpointsConfig } = require('~/server/services/Config');
 const agents = require('~/server/services/Endpoints/agents');
 const { updateFilesUsage } = require('~/models');
 const { isSolidUser } = require('~/server/utils/isSolidUser');
+const { getConvoFromSolid } = require('~/server/services/SolidStorage');
 
 const buildFunction = {
   [EModelEndpoint.agents]: agents.buildOptions,
@@ -95,7 +96,6 @@ async function buildEndpointOption(req, res, next) {
       req.body.conversationId !== 'new' && 
       isSolidUser(req)) {
     try {
-      const { getConvoFromSolid } = require('~/server/services/SolidStorage');
       const conversation = await getConvoFromSolid(req, req.body.conversationId);
       
       if (conversation?.model) {
diff --git a/api/server/utils/import/fork.js b/api/server/utils/import/fork.js
index 3d85aa670f68..97f56f609f7c 100644
--- a/api/server/utils/import/fork.js
+++ b/api/server/utils/import/fork.js
@@ -3,8 +3,10 @@ const { logger } = require('@librechat/data-schemas');
 const { EModelEndpoint, Constants, ForkOptions } = require('librechat-data-provider');
 const { createImportBatchBuilder } = require('./importBatchBuilder');
 const BaseClient = require('~/app/clients/BaseClient');
-const { getConvo } = require('~/models/Conversation');
-const { getMessages } = require('~/models/Message');
+const { getConvo, saveConvo } = require('~/models/Conversation');
+const { getMessages, saveMessage } = require('~/models/Message');
+const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
+const { isSolidUser } = require('~/server/utils/isSolidUser');
 
 /**
  * Helper function to clone messages with proper parent-child relationships and timestamps
@@ -361,8 +363,6 @@ function splitAtTargetLevel(messages, targetMessageId) {
  * @param {object} [params.req] - Optional Express request object for Solid storage support.
  * @returns {Promise<{ conversation: TConversation, messages: TMessage[] }>} The duplicated conversation and messages.
  */
-const { isSolidUser } = require('~/server/utils/isSolidUser');
-
 async function duplicateConversation({ userId, conversationId, req }) {
   const useSolidStorage = isSolidUser(req);
 
@@ -375,7 +375,6 @@ async function duplicateConversation({ userId, conversationId, req }) {
   // Get original messages
   let originalMessages;
   if (useSolidStorage) {
-    const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
     originalMessages = await getMessagesFromSolid(req, conversationId);
   } else {
     originalMessages = await getMessages({
@@ -395,9 +394,6 @@ async function duplicateConversation({ userId, conversationId, req }) {
 
   // For Solid users, save individually to support Solid storage
   if (useSolidStorage) {
-    const { saveConvo } = require('~/models/Conversation');
-    const { saveMessage } = require('~/models/Message');
-    const { v4: uuidv4 } = require('uuid');
     const newConversationId = uuidv4();
     const now = new Date();
 
@@ -462,7 +458,6 @@ async function duplicateConversation({ userId, conversationId, req }) {
     );
 
     // Get the saved conversation and messages
-    const { getMessagesFromSolid } = require('~/server/services/SolidStorage');
     const conversation = await getConvo(userId, newConversationId, req);
     const messages = await getMessagesFromSolid(req, newConversationId);
 
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 9f3a32cf627b..b7a06c7e5b62 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -439,7 +439,6 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
 
       // Check if this is a Solid user (logged in via "Continue with Solid")
       const { isSolidUser } = require('~/server/utils/isSolidUser');
-
       let conversation;
       let conversationMessages;
       let podUrl: string | undefined;
@@ -480,8 +479,14 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
             openidId: req.user?.openidId,
           });
           
-          const { getConvoFromSolid, getMessagesFromSolid, getPodUrl, setPublicAccessForShare } = require('~/server/services/SolidStorage');
-          const authenticatedFetch = await require('~/server/services/SolidStorage').getSolidFetch(req);
+          const {
+            getConvoFromSolid,
+            getMessagesFromSolid,
+            getPodUrl,
+            setPublicAccessForShare,
+            getSolidFetch,
+          } = require('~/server/services/SolidStorage');
+          const authenticatedFetch = await getSolidFetch(req);
           
           // Get Pod URL
           podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);

From f7ce1dcbbb40a7dcc38461f0124e49e7524eb88c Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 9 Feb 2026 16:36:35 +0000
Subject: [PATCH 32/94] update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 2f40db63f45d..fea8e0f01db7 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -216,7 +216,7 @@ None currently identified.
 - `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
 - `api/server/services/SolidStorage.js` - Added `isArchived` field support in `saveConvoToSolid` and `getConvosByCursorFromSolid` for archive functionality
 - `api/server/services/SolidStorage.js` - Added share functionality: `setPublicAccessForShare`, `removePublicAccessForShare`, `getSharedMessagesFromSolid`, and ACL helper functions (`createPublicAcl`, `updateAclWithPublicAccess`, `grantPublicReadAccess`, `removePublicReadAccess`)
-- `packages/data-schemas/src/methods/share.ts` - Updated `createSharedLink`, `getSharedMessages`, `deleteSharedLink`, and `deleteConvoSharedLink` to support Solid storage
+- `packages/data-schemas/src/methods/share.ts` - Updated `createSharedLink`, `getSharedMessages`, `deleteSharedLink`, and `deleteConvoSharedLink` to support Solid storage; uses inline require() for SolidStorage/isSolidUser to avoid circular dependency with data-schemas
 - `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
 - `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
 - `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
@@ -266,6 +266,10 @@ The following environment variables are used for the generic "Login with OpenID"
 ### Solid Storage
 - Storage is chosen per user: **Solid Pod** for users who logged in with "Continue with Solid" (`provider === 'solid'`); **MongoDB** for everyone else. No environment variable is required.
 
+### Imports (top-level vs inline)
+- **API code** (Conversation.js, Message.js, buildEndpointOption.js, validateMessageReq.js, messages.js, convos.js, fork.js): SolidStorage and isSolidUser are required at **top level** for clarity and tooling (per PR review).
+- **packages/data-schemas share.ts**: SolidStorage and isSolidUser use **inline** `require()` inside the functions that need them, to avoid a circular dependency (data-schemas ← SolidStorage ← data-schemas for `logger`). Top-level require there caused `logger` to be undefined at load time and backend crash.
+
 ---
 
 **Report Date**: February 11, 2026

From d7d4efd2ce552d6c5c0ce7ab6b8d12ec3f1e9067 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 14:35:41 +0000
Subject: [PATCH 33/94] refactor(solid): DRY and centralize storage logic (per
 PR review)

---
 api/models/Conversation.js                  | 76 ++++++------------
 api/models/Message.js                       | 85 +++++++--------------
 api/server/middleware/validateMessageReq.js | 29 ++-----
 3 files changed, 59 insertions(+), 131 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 050523f44820..84a049063bb5 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -114,84 +114,58 @@ module.exports = {
    * @returns {Promise<TConversation>} The conversation object.
    */
   saveConvo: async (req, { conversationId, newConversationId, ...convo }, metadata) => {
-    // Use Solid storage when user logged in via "Continue with Solid"
-    if (isSolidUser(req)) {
-      try {
-        if (metadata?.context) {
-          logger.debug(`[saveConvo] ${metadata.context}`);
-        }
-
-        const convoData = {
-          conversationId,
-          newConversationId,
-          ...convo,
-        };
+    if (metadata?.context) {
+      logger.debug(`[saveConvo] ${metadata.context}`);
+    }
 
-        if (req?.body?.isTemporary) {
-          try {
-            const appConfig = req.config;
-            convoData.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
-          } catch (err) {
-            logger.error('Error creating temporary chat expiration date:', err);
-            logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
-            convoData.expiredAt = null;
-          }
-        } else {
-          convoData.expiredAt = null;
-        }
+    // Build shared payload: expiredAt and base convo fields
+    let expiredAt = null;
+    if (req?.body?.isTemporary) {
+      try {
+        const appConfig = req.config;
+        expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+      } catch (err) {
+        logger.error('Error creating temporary chat expiration date:', err);
+        logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
+      }
+    }
+    const baseConvo = {
+      conversationId,
+      newConversationId,
+      ...convo,
+      expiredAt,
+    };
 
-        const savedConvo = await saveConvoToSolid(req, convoData, metadata);
+    if (isSolidUser(req)) {
+      try {
+        const savedConvo = await saveConvoToSolid(req, baseConvo, metadata);
         return savedConvo;
       } catch (error) {
         logger.error('[saveConvo] Error saving conversation to Solid Pod', error);
         if (metadata && metadata?.context) {
           logger.info(`[saveConvo] ${metadata.context}`);
         }
-        // Solid users: surface error so UI can show "Save failed"
         throw error;
       }
     }
 
-    // MongoDB storage
     try {
-      if (metadata?.context) {
-        logger.debug(`[saveConvo] ${metadata.context}`);
-      }
-
       const messages = await getMessages({ conversationId }, '_id');
-      const update = { ...convo, messages, user: req.user.id };
-
+      const update = { ...convo, messages, user: req.user.id, expiredAt };
       if (newConversationId) {
         update.conversationId = newConversationId;
       }
 
-      if (req?.body?.isTemporary) {
-        try {
-          const appConfig = req.config;
-          update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
-        } catch (err) {
-          logger.error('Error creating temporary chat expiration date:', err);
-          logger.info(`---\`saveConvo\` context: ${metadata?.context}`);
-          update.expiredAt = null;
-        }
-      } 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 },
         updateOperation,
-        {
-          new: true,
-          upsert: metadata?.noUpsert !== true,
-        },
+        { new: true, upsert: metadata?.noUpsert !== true },
       );
 
       if (!conversation) {
diff --git a/api/models/Message.js b/api/models/Message.js
index 0418631f61b5..087887735492 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -53,36 +53,36 @@ async function saveMessage(req, params, metadata) {
     return;
   }
 
-  // Use Solid storage when user logged in via "Continue with Solid"
-  if (isSolidUser(req)) {
+  // Build shared payload once: messageId, expiredAt, tokenCount
+  let expiredAt = null;
+  if (req?.body?.isTemporary) {
     try {
-      const messageData = {
-        ...params,
-        messageId: params.newMessageId || params.messageId,
-      };
-
-      if (req?.body?.isTemporary) {
-        try {
-          const appConfig = req.config;
-          messageData.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
-        } catch (err) {
-          logger.error('Error creating temporary chat expiration date:', err);
-          logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-          messageData.expiredAt = null;
-        }
-      } else {
-        messageData.expiredAt = null;
-      }
-
-      if (messageData.tokenCount != null && isNaN(messageData.tokenCount)) {
-        logger.warn(
-          `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${messageData.tokenCount}`,
-        );
-        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-        messageData.tokenCount = 0;
-      }
+      const appConfig = req.config;
+      expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
+    } catch (err) {
+      logger.error('Error creating temporary chat expiration date:', err);
+      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+    }
+  }
+  const messageId = params.newMessageId || params.messageId;
+  let tokenCount = params.tokenCount;
+  if (tokenCount != null && isNaN(tokenCount)) {
+    logger.warn(
+      `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${tokenCount}`,
+    );
+    logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
+    tokenCount = 0;
+  }
+  const baseMessage = {
+    ...params,
+    messageId,
+    expiredAt,
+    tokenCount: tokenCount ?? 0,
+  };
 
-      const savedMessage = await saveMessageToSolid(req, messageData, metadata);
+  if (isSolidUser(req)) {
+    try {
+      const savedMessage = await saveMessageToSolid(req, baseMessage, metadata);
       return savedMessage;
     } catch (err) {
       logger.error('Error saving message to Solid Pod:', err);
@@ -91,35 +91,8 @@ async function saveMessage(req, params, metadata) {
     }
   }
 
-  
-  // MongoDB path for non-Solid users
   try {
-    const update = {
-      ...params,
-      user: req.user.id,
-      messageId: params.newMessageId || params.messageId,
-    };
-
-    if (req?.body?.isTemporary) {
-      try {
-        const appConfig = req.config;
-        update.expiredAt = createTempChatExpirationDate(appConfig?.interfaceConfig);
-      } catch (err) {
-        logger.error('Error creating temporary chat expiration date:', err);
-        logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-        update.expiredAt = null;
-      }
-    } else {
-      update.expiredAt = null;
-    }
-
-    if (update.tokenCount != null && isNaN(update.tokenCount)) {
-      logger.warn(
-        `Resetting invalid \`tokenCount\` for message \`${params.messageId}\`: ${update.tokenCount}`,
-      );
-      logger.info(`---\`saveMessage\` context: ${metadata?.context}`);
-      update.tokenCount = 0;
-    }
+    const update = { ...baseMessage, user: req.user.id };
     const message = await Message.findOneAndUpdate(
       { messageId: params.messageId, user: req.user.id },
       update,
diff --git a/api/server/middleware/validateMessageReq.js b/api/server/middleware/validateMessageReq.js
index 7dc8ad12c88d..e0a282b4cbb4 100644
--- a/api/server/middleware/validateMessageReq.js
+++ b/api/server/middleware/validateMessageReq.js
@@ -1,9 +1,7 @@
-const { logger } = require('@librechat/data-schemas');
 const { getConvo } = require('~/models');
-const { getConvoFromSolid } = require('~/server/services/SolidStorage');
-const { isSolidUser } = require('~/server/utils/isSolidUser');
 
-// Middleware to validate conversationId and user relationship
+// Middleware to validate conversationId and user relationship.
+// getConvo(user, conversationId, req) handles Solid vs MongoDB internally.
 const validateMessageReq = async (req, res, next) => {
   let conversationId = req.params.conversationId || req.body.conversationId;
 
@@ -15,26 +13,9 @@ const validateMessageReq = async (req, res, next) => {
     conversationId = req.body.message.conversationId;
   }
 
-  let conversation = null;
-
-  // Solid users: use Solid storage only; no MongoDB fallback
-  if (isSolidUser(req)) {
-    try {
-      conversation = await getConvoFromSolid(req, conversationId);
-    } catch (error) {
-      logger.error('[validateMessageReq] Error loading conversation from Solid Pod', {
-        conversationId,
-        error: error.message,
-      });
-    }
-    if (!conversation) {
-      return res.status(404).json({ error: 'Conversation not found' });
-    }
-  } else {
-    conversation = await getConvo(req.user.id, conversationId);
-    if (!conversation) {
-      return res.status(404).json({ error: 'Conversation not found' });
-    }
+  const conversation = await getConvo(req.user.id, conversationId, req);
+  if (!conversation) {
+    return res.status(404).json({ error: 'Conversation not found' });
   }
 
   if (conversation.user !== req.user.id) {

From 9b135c1feccf29767099a9df01f3a8c544717578 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 14:42:20 +0000
Subject: [PATCH 34/94] remove line space

---
 api/server/routes/agents/chat.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/api/server/routes/agents/chat.js b/api/server/routes/agents/chat.js
index 750ce6fc5ace..37b83f4f5447 100644
--- a/api/server/routes/agents/chat.js
+++ b/api/server/routes/agents/chat.js
@@ -25,7 +25,6 @@ const checkAgentResourceAccess = canAccessAgentFromBody({
   requiredPermission: PermissionBits.VIEW,
 });
 
-
 router.use(moderateText);
 router.use(checkAgentAccess);
 router.use(checkAgentResourceAccess);

From 03a3d16aa8862b176c6b75dfb2e1ecce847874b9 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 14:44:16 +0000
Subject: [PATCH 35/94] chore: remove debug logs

---
 api/server/routes/agents/index.js | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/api/server/routes/agents/index.js b/api/server/routes/agents/index.js
index 8844f331b449..262c126d2d6a 100644
--- a/api/server/routes/agents/index.js
+++ b/api/server/routes/agents/index.js
@@ -169,13 +169,6 @@ router.get('/chat/status/:conversationId', async (req, res) => {
   const resumeState = await GenerationJobManager.getResumeState(conversationId);
   const isActive = job.status === 'running';
 
-  logger.debug('[GET /api/agents/chat/status/:conversationId] Job status check', {
-    conversationId,
-    jobStatus: job.status,
-    isActive,
-    userId: req.user.id,
-  });
-
   res.json({
     active: isActive,
     streamId: conversationId,

From 4adc6c7623be8cc7b78d7961d542a9316bf4a4cb Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 15:08:41 +0000
Subject: [PATCH 36/94] chore: clean up unneccessary log

---
 api/server/middleware/validate/convoAccess.js | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/api/server/middleware/validate/convoAccess.js b/api/server/middleware/validate/convoAccess.js
index f987e32ffe8e..4f495cd1d62f 100644
--- a/api/server/middleware/validate/convoAccess.js
+++ b/api/server/middleware/validate/convoAccess.js
@@ -59,11 +59,6 @@ const validateConvoAccess = async (req, res, next) => {
     }
 
     if (conversation.user !== userId) {
-      logger.error('[validateConvoAccess] Authorization failed', {
-        conversationId,
-        conversationUserId: conversation.user,
-        currentUserId: userId,
-      });
       const errorMessage = {
         type,
         error: 'User not authorized for this conversation',

From e6d7850262c76476812b5ff71182c38d13cb033c Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 15:28:21 +0000
Subject: [PATCH 37/94] refactor(buildEndpointOption): use getConvo for missing
 model instead of Solid-only path

Load conversation via getConvo(req.user.id, conversationId, req) when model
is missing; storage (Solid vs MongoDB) is handled in the model layer so this
middleware stays storage-agnostic and addresses the PR review.
---
 api/server/middleware/buildEndpointOption.js | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/api/server/middleware/buildEndpointOption.js b/api/server/middleware/buildEndpointOption.js
index f681df8872e0..362e50e28736 100644
--- a/api/server/middleware/buildEndpointOption.js
+++ b/api/server/middleware/buildEndpointOption.js
@@ -11,9 +11,7 @@ const azureAssistants = require('~/server/services/Endpoints/azureAssistants');
 const assistants = require('~/server/services/Endpoints/assistants');
 const { getEndpointsConfig } = require('~/server/services/Config');
 const agents = require('~/server/services/Endpoints/agents');
-const { updateFilesUsage } = require('~/models');
-const { isSolidUser } = require('~/server/utils/isSolidUser');
-const { getConvoFromSolid } = require('~/server/services/SolidStorage');
+const { updateFilesUsage, getConvo } = require('~/models');
 
 const buildFunction = {
   [EModelEndpoint.agents]: agents.buildOptions,
@@ -91,23 +89,18 @@ async function buildEndpointOption(req, res, next) {
     }
   }
 
-  // If model is missing and we have a conversationId, try to load it from Solid storage
-  if (!parsedBody.model && req.body?.conversationId && 
-      req.body.conversationId !== 'new' && 
-      isSolidUser(req)) {
+  // If model is missing and we have a conversationId, load the conversation (Solid or MongoDB) to get the model
+  if (!parsedBody.model && req.body?.conversationId && req.body.conversationId !== 'new') {
     try {
-      const conversation = await getConvoFromSolid(req, req.body.conversationId);
-      
+      const conversation = await getConvo(req.user?.id, req.body.conversationId, req);
       if (conversation?.model) {
         parsedBody.model = conversation.model;
       }
     } catch (error) {
-      // Don't fail the request if we can't load from Solid - just log a warning
-      logger.warn('[buildEndpointOption] Could not load conversation from Solid to extract model', {
+      logger.warn('[buildEndpointOption] Could not load conversation to extract model', {
         conversationId: req.body.conversationId,
         error: error.message,
       });
-      // Continue without the model - it might be set elsewhere or the request might fail later
     }
   }
 

From da106b19bde54fabb028714878ae7966c36f96e6 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 17:01:34 +0000
Subject: [PATCH 38/94] fix(config): set openidLoginEnabled from OpenID only so
 Solid-only shows one button

Stop setting openidLoginEnabled when only Solid is enabled so the login page
shows the Solid button only, not both OpenID and Solid.
---
 api/server/routes/config.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 068dbc66d3f1..5520f9ea4f0c 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -76,8 +76,7 @@ router.get('/', async function (req, res) {
         !!process.env.APPLE_TEAM_ID &&
         !!process.env.APPLE_KEY_ID &&
         !!process.env.APPLE_PRIVATE_KEY_PATH,
-      // If Solid is enabled but OpenID is not, still show OpenID button since they use the same strategy
-      openidLoginEnabled: isOpenIdEnabled || isSolidEnabled,
+      openidLoginEnabled: isOpenIdEnabled,
       openidLabel: process.env.OPENID_BUTTON_LABEL || 'Continue with OpenID',
       openidImageUrl: process.env.OPENID_IMAGE_URL,
       openidAutoRedirect: isEnabled(process.env.OPENID_AUTO_REDIRECT),

From 4df19b74a9db686b9522246b65313e306a9413b7 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 17:17:32 +0000
Subject: [PATCH 39/94] chore(requireJwtAuth): remove debug auth logging

---
 api/server/middleware/requireJwtAuth.js | 26 -------------------------
 1 file changed, 26 deletions(-)

diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index 12cc0fd51f90..f95672c717ff 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -6,47 +6,21 @@ const { isEnabled } = require('@librechat/api');
  * Custom Middleware to handle JWT authentication, with support for OpenID token reuse
  * Switches between JWT and OpenID authentication based on cookies and environment settings
  */
-const { logger } = require('@librechat/data-schemas');
-
 const requireJwtAuth = (req, res, next) => {
   const cookieHeader = req.headers.cookie;
   const tokenProvider = cookieHeader ? cookies.parse(cookieHeader).token_provider : null;
-  const hasAuthHeader = !!req.headers.authorization;
-
-  logger.info('[requireJwtAuth] Authentication check', {
-    path: req.path,
-    method: req.method,
-    hasCookie: !!cookieHeader,
-    tokenProvider,
-    hasAuthHeader,
-    authHeaderPrefix: req.headers.authorization?.substring(0, 30),
-    openidReuseTokens: isEnabled(process.env.OPENID_REUSE_TOKENS),
-  });
 
   // Use OpenID authentication if token provider is OpenID and OPENID_REUSE_TOKENS is enabled
   if (tokenProvider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    logger.debug('[requireJwtAuth] Using OpenID JWT authentication');
     return passport.authenticate('openidJwt', { session: false })(req, res, next);
   }
 
   // Default to standard JWT authentication
-  logger.debug('[requireJwtAuth] Using standard JWT authentication');
-  
-  // Add error handler to log authentication failures
   return passport.authenticate('jwt', { session: false }, (err, user, info) => {
     if (err) {
-      logger.error('[requireJwtAuth] Authentication error', {
-        error: err.message,
-        stack: err.stack,
-      });
       return res.status(401).json({ error: 'Authentication failed', message: err.message });
     }
     if (!user) {
-      logger.warn('[requireJwtAuth] Authentication failed - no user', {
-        info: info?.message || 'No user returned from JWT strategy',
-        hasAuthHeader,
-        tokenProvider,
-      });
       return res.status(401).json({ 
         error: 'Authentication required',
         message: 'No valid JWT token found. Make sure you are logged in and the Authorization header is sent.',

From 34fbedee840522fcabcdc78a17d56f9e86df18da Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 17:57:21 +0000
Subject: [PATCH 40/94] refactor(Solid): use schema-aligned docs from model
 layer, remove doc rebuild in SolidStorage

Model layer builds full message/conversation docs; Solid only persists and
merges existing Pod data for partial updates.
---
 api/models/Conversation.js          |  12 +-
 api/models/Message.js               |   9 +-
 api/server/services/SolidStorage.js | 233 +++++++---------------------
 3 files changed, 77 insertions(+), 177 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 84a049063bb5..8835acf0d5f3 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -138,7 +138,17 @@ module.exports = {
 
     if (isSolidUser(req)) {
       try {
-        const savedConvo = await saveConvoToSolid(req, baseConvo, metadata);
+        // Full document aligned with schema (same shape as MongoDB); SolidStorage adds messages + timestamps
+        const finalConversationId = newConversationId || conversationId;
+        const convoDocument = {
+          ...baseConvo,
+          conversationId: finalConversationId,
+          user: req.user.id,
+        };
+        if (newConversationId && newConversationId !== conversationId) {
+          convoDocument.previousConversationId = conversationId;
+        }
+        const savedConvo = await saveConvoToSolid(req, convoDocument, metadata);
         return savedConvo;
       } catch (error) {
         logger.error('[saveConvo] Error saving conversation to Solid Pod', error);
diff --git a/api/models/Message.js b/api/models/Message.js
index 087887735492..31fa1882d73f 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -82,7 +82,14 @@ async function saveMessage(req, params, metadata) {
 
   if (isSolidUser(req)) {
     try {
-      const savedMessage = await saveMessageToSolid(req, baseMessage, metadata);
+      // Full document aligned with schema (same shape as MongoDB); SolidStorage only persists it
+      const messageDocument = {
+        ...baseMessage,
+        user: req.user.id,
+        createdAt: baseMessage.createdAt || new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+      const savedMessage = await saveMessageToSolid(req, messageDocument, metadata);
       return savedMessage;
     } catch (err) {
       logger.error('Error saving message to Solid Pod:', err);
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 5943d7d27c74..022dc6a3a778 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -461,127 +461,63 @@ async function ensureBaseStructure(podUrl, fetch) {
 }
 
 /**
- * Save a message to Solid Pod
- * 
+ * Save a message to Solid Pod.
+ * Document content is built in the model layer (schema-aligned); this only persists it.
+ *
  * @param {Object} req - Express request object
- * @param {Object} messageData - Message data to save
- * @param {string} messageData.messageId - Message ID
- * @param {string} messageData.conversationId - Conversation ID
- * @param {string} messageData.text - Message text
- * @param {string} messageData.sender - Sender identifier
- * @param {boolean} messageData.isCreatedByUser - Whether message was created by user
- * @param {string} messageData.endpoint - Endpoint where message originated
- * @param {string} [messageData.parentMessageId] - Parent message ID
- * @param {string} [messageData.error] - Error message
- * @param {boolean} [messageData.unfinished] - Whether message is unfinished
- * @param {Array} [messageData.files] - Files associated with message
- * @param {string} [messageData.finish_reason] - Finish reason
- * @param {number} [messageData.tokenCount] - Token count
- * @param {string} [messageData.plugin] - Plugin name
- * @param {Array} [messageData.plugins] - Plugin array
- * @param {string} [messageData.model] - Model used
- * @param {Date} [messageData.expiredAt] - Expiration date
+ * @param {Object} messageDocument - Full message document (same shape as MongoDB / IMessage)
  * @param {Object} [metadata] - Additional metadata
- * @returns {Promise<Object>} Saved message data
+ * @returns {Promise<Object>} Saved message document
  */
-async function saveMessageToSolid(req, messageData, metadata) {
+async function saveMessageToSolid(req, messageDocument, metadata) {
   try {
     logger.info('[SolidStorage] Saving message to Solid Pod', {
-      messageId: messageData.messageId,
-      conversationId: messageData.conversationId,
+      messageId: messageDocument.messageId,
+      conversationId: messageDocument.conversationId,
       context: metadata?.context,
     });
 
-    // Validate required fields
     if (!req?.user?.id) {
       throw new Error('User not authenticated');
     }
-
-    if (!messageData.messageId) {
+    if (!messageDocument.messageId) {
       throw new Error('messageId is required');
     }
-
-    if (!messageData.conversationId) {
+    if (!messageDocument.conversationId) {
       throw new Error('conversationId is required');
     }
 
-    // Get authenticated fetch and Pod URL
     const authenticatedFetch = await getSolidFetch(req);
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
-
-    // Ensure base structure exists
     await ensureBaseStructure(podUrl, authenticatedFetch);
 
-    // Ensure messages container for this conversation exists
-    const messagesContainerPath = getMessagesContainerPath(podUrl, messageData.conversationId);
+    const messagesContainerPath = getMessagesContainerPath(podUrl, messageDocument.conversationId);
     await ensureContainerExists(messagesContainerPath, authenticatedFetch);
 
-    // Prepare message object with all fields
-    const messageToSave = {
-      messageId: messageData.newMessageId || messageData.messageId,
-      conversationId: messageData.conversationId,
-      user: req.user.id,
-      text: messageData.text || '',
-      content: messageData.content || undefined, // For agent endpoints, content is an array
-      sender: messageData.sender,
-      isCreatedByUser: messageData.isCreatedByUser,
-      endpoint: messageData.endpoint,
-      parentMessageId: messageData.parentMessageId || null,
-      error: messageData.error || null,
-      unfinished: messageData.unfinished || false,
-      files: messageData.files || [],
-      finish_reason: messageData.finish_reason || null,
-      tokenCount: messageData.tokenCount || 0,
-      plugin: messageData.plugin || null,
-      plugins: messageData.plugins || [],
-      model: messageData.model || null,
-      expiredAt: messageData.expiredAt || null,
-      createdAt: messageData.createdAt || new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    };
-
-    // Get message file path
     const messagePath = getMessagePath(
       podUrl,
-      messageData.conversationId,
-      messageToSave.messageId
+      messageDocument.conversationId,
+      messageDocument.messageId
     );
 
-    // Convert message to JSON string
-    const messageJson = JSON.stringify(messageToSave, null, 2);
-    
-    // Use Buffer for Node.js compatibility (Blob is available in Node 18+ but Buffer is more universal)
+    const messageJson = JSON.stringify(messageDocument, null, 2);
     const messageBuffer = Buffer.from(messageJson, 'utf-8');
 
     logger.debug('[SolidStorage] Saving message file', {
       messagePath,
-      messageId: messageToSave.messageId,
-      conversationId: messageToSave.conversationId,
-      textLength: messageToSave.text?.length || 0,
-      hasContent: !!messageToSave.content,
-      contentLength: Array.isArray(messageToSave.content) ? messageToSave.content.length : 0,
-      contentTypes: Array.isArray(messageToSave.content) 
-        ? messageToSave.content.map(c => c?.type).filter(Boolean)
-        : [],
+      messageId: messageDocument.messageId,
+      conversationId: messageDocument.conversationId,
       bufferSize: messageBuffer.length,
     });
 
-    // Check if message already exists (for update vs create)
     let messageExists = false;
     try {
       await getFile(messagePath, { fetch: authenticatedFetch });
       messageExists = true;
-      logger.debug('[SolidStorage] Message file already exists, will overwrite', {
-        messagePath,
-      });
     } catch (error) {
       if (error.status === 404 || error.message?.includes('404')) {
         messageExists = false;
-        logger.debug('[SolidStorage] Message file does not exist, will create', {
-          messagePath,
-        });
       } else {
-        // Some other error occurred, log it but continue
         logger.warn('[SolidStorage] Error checking if message exists, will try to save anyway', {
           messagePath,
           error: error.message,
@@ -589,7 +525,6 @@ async function saveMessageToSolid(req, messageData, metadata) {
       }
     }
 
-    // Save or overwrite the message file
     if (messageExists) {
       await overwriteFile(messagePath, messageBuffer, {
         contentType: 'application/json',
@@ -597,17 +532,17 @@ async function saveMessageToSolid(req, messageData, metadata) {
       });
       logger.info('[SolidStorage] Message file overwritten successfully', {
         messagePath,
-        messageId: messageToSave.messageId,
+        messageId: messageDocument.messageId,
       });
     } else {
       await saveFileInContainer(messagesContainerPath, messageBuffer, {
-        slug: `${messageToSave.messageId}.json`,
+        slug: `${messageDocument.messageId}.json`,
         contentType: 'application/json',
         fetch: authenticatedFetch,
       });
       logger.info('[SolidStorage] Message file saved successfully', {
         messagePath,
-        messageId: messageToSave.messageId,
+        messageId: messageDocument.messageId,
       });
     }
 
@@ -615,11 +550,11 @@ async function saveMessageToSolid(req, messageData, metadata) {
       logger.info(`[SolidStorage] ---saveMessageToSolid context: ${metadata.context}`);
     }
 
-    return messageToSave;
+    return messageDocument;
   } catch (error) {
     logger.error('[SolidStorage] Error saving message to Solid Pod', {
-      messageId: messageData?.messageId,
-      conversationId: messageData?.conversationId,
+      messageId: messageDocument?.messageId,
+      conversationId: messageDocument?.conversationId,
       error: error.message,
       stack: error.stack,
       context: metadata?.context,
@@ -1173,62 +1108,37 @@ async function deleteMessagesFromSolid(req, params) {
 }
 
 /**
- * Save a conversation to Solid Pod
- * 
+ * Save a conversation to Solid Pod.
+ * Document content is built in the model layer (schema-aligned); this only adds
+ * messages refs + timestamps and persists it.
+ *
  * @param {Object} req - Express request object
- * @param {Object} convoData - Conversation data to save
- * @param {string} convoData.conversationId - Conversation ID (required)
- * @param {string} [convoData.newConversationId] - New conversation ID (for renaming)
- * @param {string} [convoData.title] - Conversation title
- * @param {string} [convoData.endpoint] - Endpoint where conversation originated
- * @param {string} [convoData.model] - Model used
- * @param {string} [convoData.agent_id] - Agent ID
- * @param {string} [convoData.assistant_id] - Assistant ID
- * @param {string} [convoData.spec] - Spec
- * @param {string} [convoData.iconURL] - Icon URL
- * @param {Array} [convoData.messages] - Array of message references
- * @param {Array} [convoData.files] - Array of file IDs
- * @param {string} [convoData.promptPrefix] - Prompt prefix
- * @param {number} [convoData.temperature] - Temperature setting
- * @param {number} [convoData.topP] - Top P setting
- * @param {number} [convoData.presence_penalty] - Presence penalty
- * @param {number} [convoData.frequency_penalty] - Frequency penalty
- * @param {Date} [convoData.expiredAt] - Expiration date
+ * @param {Object} convoDocument - Full conversation document (same shape as MongoDB / IConversation)
  * @param {Object} [metadata] - Additional metadata
- * @returns {Promise<Object>} Saved conversation data
+ * @returns {Promise<Object>} Saved conversation document
  */
-async function saveConvoToSolid(req, convoData, metadata) {
+async function saveConvoToSolid(req, convoDocument, metadata) {
   try {
+    const finalConversationId = convoDocument.conversationId;
     logger.info('[SolidStorage] Saving conversation to Solid Pod', {
-      conversationId: convoData.conversationId,
-      newConversationId: convoData.newConversationId,
+      conversationId: finalConversationId,
+      newConversationId: convoDocument.newConversationId,
       context: metadata?.context,
     });
 
-    // Validate required fields
     if (!req?.user?.id) {
       throw new Error('User not authenticated');
     }
-
-    if (!convoData.conversationId && !convoData.newConversationId) {
-      throw new Error('conversationId or newConversationId is required');
+    if (!finalConversationId) {
+      throw new Error('conversationId is required');
     }
 
-    // Use newConversationId if provided, otherwise use conversationId
-    const finalConversationId = convoData.newConversationId || convoData.conversationId;
-
-    // Get authenticated fetch and Pod URL
     const authenticatedFetch = await getSolidFetch(req);
-    // 
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
-
-    // Ensure base structure exists
     await ensureBaseStructure(podUrl, authenticatedFetch);
 
-    // Get conversation file path
     const conversationPath = getConversationPath(podUrl, finalConversationId);
 
-    // Check if conversation already exists and load it to preserve existing data
     let existingConversation = null;
     try {
       const existingFile = await getFile(conversationPath, { fetch: authenticatedFetch });
@@ -1251,62 +1161,38 @@ async function saveConvoToSolid(req, convoData, metadata) {
       }
     }
 
-    // Get messages for this conversation (just IDs for reference)
-    // Note: We call getMessagesFromSolid directly since it's in the same module
     const messages = await getMessagesFromSolid(req, finalConversationId);
     const messageRefs = messages.map((msg) => ({
       messageId: msg.messageId,
       createdAt: msg.createdAt,
     }));
 
-    // Start with existing conversation data if available, otherwise use defaults
-    const baseConversation = existingConversation || {
-      conversationId: finalConversationId,
-      user: req.user.id,
-      createdAt: new Date().toISOString(),
-    };
+    // Preserve existing Pod fields (e.g. title) when the user only sends a partial update (e.g. after sending a message)
+    if (existingConversation) {
+      convoDocument = { ...existingConversation, ...convoDocument };
+    }
 
-    // If model or endpoint are missing, try to extract them from messages
-    let finalModel = convoData.model ?? baseConversation.model;
-    let finalEndpoint = convoData.endpoint ?? baseConversation.endpoint;
-    
-    if (!finalModel || !finalEndpoint) {
-      // Find the first message with a model (usually the AI response)
-      const messageWithModel = messages.find(msg => msg.model && msg.endpoint);
-      
+    // Fill missing model/endpoint from first message (schema content stays in model layer; this is a fallback)
+    if ((!convoDocument.model || !convoDocument.endpoint) && messages.length > 0) {
+      const messageWithModel = messages.find((msg) => msg.model && msg.endpoint);
       if (messageWithModel) {
-        if (!finalModel && messageWithModel.model) {
-          logger.info('[SolidStorage] Extracting model from messages when saving', {
-            conversationId: finalConversationId,
-            extractedModel: messageWithModel.model,
-          });
-          finalModel = messageWithModel.model;
+        if (!convoDocument.model && messageWithModel.model) {
+          convoDocument.model = messageWithModel.model;
         }
-        
-        if (!finalEndpoint && messageWithModel.endpoint) {
-          logger.info('[SolidStorage] Extracting endpoint from messages when saving', {
-            conversationId: finalConversationId,
-            extractedEndpoint: messageWithModel.endpoint,
-          });
-          finalEndpoint = messageWithModel.endpoint;
+        if (!convoDocument.endpoint && messageWithModel.endpoint) {
+          convoDocument.endpoint = messageWithModel.endpoint;
         }
       }
     }
 
-    // Merge existing conversation with updates from convoData
-    // convoData takes precedence for fields that are explicitly provided
-    const conversationToSave = {
-      ...baseConversation,
-      ...convoData,
-      conversationId: finalConversationId,
-      user: req.user.id,
-      messages: messageRefs,
-      createdAt: baseConversation.createdAt || new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    };
+    convoDocument.messages = messageRefs;
+    convoDocument.updatedAt = new Date().toISOString();
+    convoDocument.createdAt = convoDocument.createdAt || existingConversation?.createdAt || new Date().toISOString();
 
-    // Convert to JSON and create buffer
-    const conversationJson = JSON.stringify(conversationToSave, null, 2);
+    const previousConversationId = convoDocument.previousConversationId;
+    delete convoDocument.previousConversationId;
+
+    const conversationJson = JSON.stringify(convoDocument, null, 2);
     const conversationBuffer = Buffer.from(conversationJson, 'utf-8');
 
     logger.debug('[SolidStorage] Saving conversation file', {
@@ -1315,17 +1201,15 @@ async function saveConvoToSolid(req, convoData, metadata) {
       messageCount: messageRefs.length,
     });
 
-    // Determine if conversation exists (we already loaded it above if it exists)
     const conversationExists = existingConversation !== null;
 
-    // If conversationId changed, delete old file
-    if (convoData.newConversationId && convoData.conversationId !== convoData.newConversationId) {
-      const oldConversationPath = getConversationPath(podUrl, convoData.conversationId);
+    if (previousConversationId) {
+      const oldConversationPath = getConversationPath(podUrl, previousConversationId);
       try {
         await deleteFile(oldConversationPath, { fetch: authenticatedFetch });
         logger.info('[SolidStorage] Old conversation file deleted after rename', {
           oldConversationPath,
-          newConversationId: convoData.newConversationId,
+          newConversationId: convoDocument.conversationId,
         });
       } catch (error) {
         if (error.status !== 404) {
@@ -1337,7 +1221,6 @@ async function saveConvoToSolid(req, convoData, metadata) {
       }
     }
 
-    // Save or overwrite the conversation file
     const conversationsContainerPath = `${getBaseStoragePath(podUrl)}conversations/`;
     if (conversationExists) {
       await overwriteFile(conversationPath, conversationBuffer, {
@@ -1364,11 +1247,11 @@ async function saveConvoToSolid(req, convoData, metadata) {
       logger.info(`[SolidStorage] ---saveConvoToSolid context: ${metadata.context}`);
     }
 
-    return conversationToSave;
+    return convoDocument;
   } catch (error) {
     logger.error('[SolidStorage] Error saving conversation to Solid Pod', {
-      conversationId: convoData?.conversationId,
-      newConversationId: convoData?.newConversationId,
+      conversationId: convoDocument?.conversationId,
+      newConversationId: convoDocument?.newConversationId,
       error: error.message,
       stack: error.stack,
       context: metadata?.context,

From cc45ff85879b9ee382150a0feaf8c9f18dfbcca9 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 18:00:45 +0000
Subject: [PATCH 41/94] update progress document

---
 SOLID_INTEGRATION_PROGRESS.md | 38 +++++++++++++++++++++++++----------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index fea8e0f01db7..90b86d648827 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -86,7 +86,7 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Added fallback mechanism for schema validation failures
   - Extracts `model` and `endpoint` from messages when missing in conversation metadata
   - Ensures `resendFiles` is included in payloads for agents endpoints (defaults to `true`)
-  - Fixed model extraction in `buildEndpointOption` middleware to load from Solid when missing
+  - **buildEndpointOption** (per PR review): Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model; no Solid-specific logic in that middleware—storage is chosen in the model layer
 
 ### 10. Full Conversation Flow
 - **Status**: Complete
@@ -100,9 +100,9 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 - **Status**: Complete
 - **Details**:
   - Conversation titles are properly saved to Solid Pod when generated
-  - Titles persist correctly after page refresh
+  - Titles persist correctly after page refresh and after sending more messages
   - `saveConvo` correctly identifies Solid users before saving to Solid Pod
-  - `saveConvoToSolid` merges updates with existing conversation data to prevent data loss
+  - **saveConvoToSolid** merges existing Pod conversation into the incoming document before writing, so partial updates (e.g. after POST message or BaseClient saveConvo) preserve fields like `title` instead of overwriting the file and losing the generated title
 
 ### 12. Conversation Management Operations
 - **Status**: Complete
@@ -124,6 +124,21 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - Fetches shared messages directly from Pod using unauthenticated requests
   - Properly removes public access when share is deleted
 
+### 14. Schema-Aligned Document Content (PR Review)
+- **Status**: Complete
+- **Details**:
+  - **Single source of document shape**: JSON written to the Solid Pod now matches the same document shape as MongoDB; shape is defined in the model layer and aligned with `packages/data-schemas` (message + convo schema and types).
+  - **Messages**: `Message.js` builds the full message document (including `user`, `createdAt`, `updatedAt`) and passes it to `saveMessageToSolid`. SolidStorage only validates ids, resolves paths, and writes that document; the previous hand-built field list and defaults in SolidStorage were removed.
+  - **Conversations**: `Conversation.js` builds the full conversation document (conversationId, user, …convo, expiredAt, `previousConversationId` when renaming) and passes it to `saveConvoToSolid`. SolidStorage only adds Pod-specific data (message refs from the Pod, timestamps, optional model/endpoint fallback from messages), then merges with existing Pod conversation (to preserve e.g. title on partial updates) and writes. It no longer constructs the conversation payload from a custom field list.
+  - **Partial updates**: When the caller sends a partial update (e.g. after sending a message with no `title`), existing conversation from the Pod is merged into the incoming document before writing so fields like `title` are preserved.
+
+### 15. PR Review: Config, Logging, Convos
+- **Status**: Complete
+- **Details**:
+  - **config.js**: `openidLoginEnabled` set to `isOpenIdEnabled` only (removed `|| isSolidEnabled`) so when only Solid is enabled the login page shows one Solid button, not both OpenID and Solid.
+  - **requireJwtAuth.js**: Removed non–Solid-specific debug logging added during auth flow debugging; reviewer suggested upstreaming useful logging in a separate PR if needed.
+  - **convos.js**: No code change; reviewer concern addressed by clarification—`getConvo(req.user.id, conversationId, req)` in `Conversation.js` already branches on `isSolidUser(req)` and uses Solid when the user is a Solid user.
+
 ## Current Status
 
 ### Working Features
@@ -196,22 +211,23 @@ None currently identified.
 
 
 ## Files Modified
-- `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations
+- `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations; schema-aligned: accepts full document from model layer, only adds message refs + timestamps + merge with existing for partial updates (no custom document content)
 - `api/server/utils/isSolidUser.js` (NEW) - Shared helper to detect Solid login (`provider === 'solid'`), used across models, routes, and middleware (DRY)
-- `api/models/Message.js` - Integrated Solid storage; MongoDB path for non-Solid users only (no fallback for Solid)
-- `api/models/Conversation.js` - Integrated Solid storage; no MongoDB fallback for Solid users (return null/rethrow on Solid failure)
+- `api/models/Message.js` - Integrated Solid storage; builds full message document (user, createdAt, updatedAt) and passes to SolidStorage; MongoDB path for non-Solid users only (no fallback for Solid)
+- `api/models/Conversation.js` - Integrated Solid storage; builds full conversation document and passes to SolidStorage; no MongoDB fallback for Solid users (return null/rethrow on Solid failure); passes `previousConversationId` when renaming
 - `api/server/routes/oauth.js` - Token logging and storage
 - `api/server/services/AuthService.js` - Token management
 - `api/server/index.js` - Session middleware ordering
 - `api/server/controllers/AuthController.js` - Refresh token handling
 - `api/server/middleware/validate/convoAccess.js` - Added Solid storage support for conversation access validation
-- `api/server/middleware/buildEndpointOption.js` - Added model extraction from Solid storage when missing; uses shared `isSolidUser`
+- `api/server/middleware/buildEndpointOption.js` - Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model (no Solid-specific logic)
 - `api/server/middleware/validateMessageReq.js` - Solid storage validation; no MongoDB fallback for Solid users (404 on Solid failure)
+- `api/server/middleware/requireJwtAuth.js` - Removed debug auth logging (per PR review)
+- `api/server/routes/config.js` - `openidLoginEnabled: isOpenIdEnabled` only so Solid-only shows one button (per PR review)
 - `api/server/routes/messages.js` - Solid message reads return 503 on Solid failure (no MongoDB fallback)
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
 - `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
-- `api/models/Conversation.js` - Fixed `saveConvo` to check for Solid users before saving to Solid Pod, added Solid storage support to `deleteConvos`
-- `api/server/services/SolidStorage.js` - Enhanced `saveConvoToSolid` to merge updates with existing conversation data, improved message deletion logging
+- `api/server/services/SolidStorage.js` - Schema-aligned: `saveMessageToSolid` accepts full message document; `saveConvoToSolid` accepts full convo document, merges with existing Pod conversation to preserve title (and other fields) on partial updates
 - `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
 - `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
 - `api/server/services/SolidStorage.js` - Added `isArchived` field support in `saveConvoToSolid` and `getConvosByCursorFromSolid` for archive functionality
@@ -267,11 +283,11 @@ The following environment variables are used for the generic "Login with OpenID"
 - Storage is chosen per user: **Solid Pod** for users who logged in with "Continue with Solid" (`provider === 'solid'`); **MongoDB** for everyone else. No environment variable is required.
 
 ### Imports (top-level vs inline)
-- **API code** (Conversation.js, Message.js, buildEndpointOption.js, validateMessageReq.js, messages.js, convos.js, fork.js): SolidStorage and isSolidUser are required at **top level** for clarity and tooling (per PR review).
+- **API code** (Conversation.js, Message.js, buildEndpointOption.js, validateMessageReq.js, messages.js, convos.js, fork.js): SolidStorage and isSolidUser are required at **top level** for clarity and tooling (per PR review). buildEndpointOption.js now uses only `getConvo` from `~/models` (no SolidStorage/isSolidUser).
 - **packages/data-schemas share.ts**: SolidStorage and isSolidUser use **inline** `require()` inside the functions that need them, to avoid a circular dependency (data-schemas ← SolidStorage ← data-schemas for `logger`). Top-level require there caused `logger` to be undefined at load time and backend crash.
 
 ---
 
-**Report Date**: February 11, 2026
+**Report Date**: February 10, 2026
 
 

From 2d565208dee564005b2bedd6dcae2ac119cdebd0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 10 Feb 2026 19:36:58 +0000
Subject: [PATCH 42/94] Merge main; fix OAuth callback imports and Solid login
 config

---
 api/server/routes/config.js          |   7 +-
 api/server/routes/oauth.js           |   6 +-
 api/strategies/index.js              |   5 +-
 package-lock.json                    | 384 +--------------------------
 packages/data-provider/src/config.ts |   2 +-
 5 files changed, 24 insertions(+), 380 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 5520f9ea4f0c..fb49a2804da5 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -62,10 +62,15 @@ router.get('/', async function (req, res) {
 
     const balanceConfig = getBalanceConfig(appConfig);
 
+    let socialLogins = appConfig?.registration?.socialLogins ?? defaultSocialLogins;
+    if (isSolidEnabled && !socialLogins.includes('solid')) {
+      socialLogins = [...socialLogins, 'solid'];
+    }
+
     /** @type {TStartupConfig} */
     const payload = {
       appTitle: process.env.APP_TITLE || 'LibreChat',
-      socialLogins: appConfig?.registration?.socialLogins ?? defaultSocialLogins,
+      socialLogins,
       discordLoginEnabled: !!process.env.DISCORD_CLIENT_ID && !!process.env.DISCORD_CLIENT_SECRET,
       facebookLoginEnabled:
         !!process.env.FACEBOOK_CLIENT_ID && !!process.env.FACEBOOK_CLIENT_SECRET,
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 4a339040e1cd..98469fb76eff 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -4,9 +4,11 @@ const passport = require('passport');
 const { randomState } = require('openid-client');
 const { logger } = require('@librechat/data-schemas');
 const { ErrorTypes } = require('librechat-data-provider');
-const { createSetBalanceConfig } = require('@librechat/api');
-const { checkDomainAllowed, loginLimiter, logHeaders } = require('~/server/middleware');
+const { createSetBalanceConfig, isEnabled } = require('@librechat/api');
+const { checkDomainAllowed, loginLimiter, logHeaders, checkBan } = require('~/server/middleware');
 const { createOAuthHandler } = require('~/server/controllers/auth/oauth');
+const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
+const { syncUserEntraGroupMemberships } = require('~/server/services/PermissionService');
 const { getAppConfig } = require('~/server/services/Config');
 const { Balance } = require('~/db/models');
 
diff --git a/api/strategies/index.js b/api/strategies/index.js
index 5ec3c2bcc36b..b5c3e069dc80 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -1,4 +1,5 @@
 const { setupOpenId, getOpenIdConfig, getOpenIdEmail } = require('./openidStrategy');
+const { setupSolidOpenId, getSolidOpenIdConfig } = require('./SolidOpenidStrategy');
 const openIdJwtLogin = require('./openIdJwtStrategy');
 const facebookLogin = require('./facebookStrategy');
 const discordLogin = require('./discordStrategy');
@@ -7,8 +8,6 @@ const googleLogin = require('./googleStrategy');
 const githubLogin = require('./githubStrategy');
 const discordLogin = require('./discordStrategy');
 const facebookLogin = require('./facebookStrategy');
-const { setupSolidOpenId, getSolidOpenIdConfig } = require('./SolidOpenidStrategy');
-const { setupOpenId, getOpenIdConfig } = require('./openidStrategy');
 const jwtLogin = require('./jwtStrategy');
 const ldapLogin = require('./ldapStrategy');
 const { setupSaml } = require('./samlStrategy');
@@ -27,6 +26,8 @@ module.exports = {
   setupOpenId,
   getOpenIdConfig,
   getOpenIdEmail,
+  setupSolidOpenId,
+  getSolidOpenIdConfig,
   ldapLogin,
   setupSaml,
   openIdJwtLogin,
diff --git a/package-lock.json b/package-lock.json
index f2f2b4d39114..03cfb2e0945a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12822,7 +12822,6 @@
       "integrity": "sha512-ka4H8OM6+DlUhSAZpONu0cPBtPPTQKxbxVzC4CzVx5+K4JnroJVBtDzLAMx4/3CDTJXRvVFhpFjtl4SaiTNoyQ==",
       "license": "Apache-2.0",
       "peer": true,
-      "peer": true,
       "dependencies": {
         "@opentelemetry/semantic-conventions": "^1.29.0"
       },
@@ -14383,7 +14382,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/otlp-transformer/-/otlp-transformer-0.211.0.tgz",
       "integrity": "sha512-julhCJ9dXwkOg9svuuYqqjXLhVaUgyUvO2hWbTxwjvLXX2rG3VtAaB0SzxMnGTuoCZizBT7Xqqm2V7+ggrfCXA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/api-logs": "0.211.0",
         "@opentelemetry/core": "2.5.0",
@@ -14406,7 +14404,6 @@
       "integrity": "sha512-jx6+sE9h/UryaCZhsJWbJtTEy47yXoGNYI4z8ZaRncM0zBKeRqjO2JEcOUYwrYGb1WLhXM1FfMzW3annvFv0rw==",
       "hasInstallScript": true,
       "license": "BSD-3-Clause",
-      "peer": true,
       "dependencies": {
         "@protobufjs/aspromise": "^1.1.2",
         "@protobufjs/base64": "^1.1.2",
@@ -14490,7 +14487,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-2.5.0.tgz",
       "integrity": "sha512-F8W52ApePshpoSrfsSk1H2yJn9aKjCrbpQF1M9Qii0GHzbfVeFUB+rc3X4aggyZD8x9Gu3Slua+s6krmq6Dt8g==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.5.0",
         "@opentelemetry/semantic-conventions": "^1.29.0"
@@ -14524,7 +14520,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-metrics/-/sdk-metrics-2.5.0.tgz",
       "integrity": "sha512-BeJLtU+f5Gf905cJX9vXFQorAr6TAfK3SPvTFqP+scfIpDQEJfRaGJWta7sJgP+m4dNtBf9y3yvBKVAZZtJQVA==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.5.0",
         "@opentelemetry/resources": "2.5.0"
@@ -14709,7 +14704,6 @@
       "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.2.0.tgz",
       "integrity": "sha512-xWQgL0Bmctsalg6PaXExmzdedSp3gyKV8mQBwK/j9VGdCDu2fmXIb2gAehBKbkXCpJ4HPkgv3QfoJWRT4dHWbw==",
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "@opentelemetry/core": "2.2.0",
         "@opentelemetry/resources": "2.2.0",
@@ -22193,152 +22187,6 @@
         "win32"
       ]
     },
-    "node_modules/@webassemblyjs/ast": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.12.1.tgz",
-      "integrity": "sha512-EKfMUOPRRUTy5UII4qJDGPpqfwjOmZ5jeGFwid9mnoqIFK+e0vqoi1qH56JpmZSzEL53jKnNzScdmftJyG5xWg==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/helper-numbers": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/floating-point-hex-parser": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz",
-      "integrity": "sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==",
-      "dev": true
-    },
-    "node_modules/@webassemblyjs/helper-api-error": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz",
-      "integrity": "sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==",
-      "dev": true
-    },
-    "node_modules/@webassemblyjs/helper-buffer": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.12.1.tgz",
-      "integrity": "sha512-nzJwQw99DNDKr9BVCOZcLuJJUlqkJh+kVzVl6Fmq/tI5ZtEyWT1KZMyOXltXLZJmDtvLCDgwsyrkohEtopTXCw==",
-      "dev": true
-    },
-    "node_modules/@webassemblyjs/helper-numbers": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz",
-      "integrity": "sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/floating-point-hex-parser": "1.11.6",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz",
-      "integrity": "sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==",
-      "dev": true
-    },
-    "node_modules/@webassemblyjs/helper-wasm-section": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.12.1.tgz",
-      "integrity": "sha512-Jif4vfB6FJlUlSbgEMHUyk1j234GTNG9dBJ4XJdOySoj518Xj0oGsNi59cUQF4RRMS9ouBUxDDdyBVfPTypa5g==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/wasm-gen": "1.12.1"
-      }
-    },
-    "node_modules/@webassemblyjs/ieee754": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz",
-      "integrity": "sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==",
-      "dev": true,
-      "dependencies": {
-        "@xtuc/ieee754": "^1.2.0"
-      }
-    },
-    "node_modules/@webassemblyjs/leb128": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz",
-      "integrity": "sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==",
-      "dev": true,
-      "dependencies": {
-        "@xtuc/long": "4.2.2"
-      }
-    },
-    "node_modules/@webassemblyjs/utf8": {
-      "version": "1.11.6",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz",
-      "integrity": "sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==",
-      "dev": true
-    },
-    "node_modules/@webassemblyjs/wasm-edit": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.12.1.tgz",
-      "integrity": "sha512-1DuwbVvADvS5mGnXbE+c9NfA8QRcZ6iKquqjjmR10k6o+zzsRVesil54DKexiowcFCPdr/Q0qaMgB01+SQ1u6g==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/helper-wasm-section": "1.12.1",
-        "@webassemblyjs/wasm-gen": "1.12.1",
-        "@webassemblyjs/wasm-opt": "1.12.1",
-        "@webassemblyjs/wasm-parser": "1.12.1",
-        "@webassemblyjs/wast-printer": "1.12.1"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-gen": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.12.1.tgz",
-      "integrity": "sha512-TDq4Ojh9fcohAw6OIMXqiIcTq5KUXTGRkVxbSo1hQnSy6lAM5GSdfwWeSxpAo0YzgsgF182E/U0mDNhuA0tW7w==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-opt": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.12.1.tgz",
-      "integrity": "sha512-Jg99j/2gG2iaz3hijw857AVYekZe2SAskcqlWIZXjji5WStnOpVoat3gQfT/Q5tb2djnCjBtMocY/Su1GfxPBg==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-buffer": "1.12.1",
-        "@webassemblyjs/wasm-gen": "1.12.1",
-        "@webassemblyjs/wasm-parser": "1.12.1"
-      }
-    },
-    "node_modules/@webassemblyjs/wasm-parser": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.12.1.tgz",
-      "integrity": "sha512-xikIi7c2FHXysxXe3COrVUPSheuBtpcfhbpFj4gmu7KRLYOzANztwUU0IbsqvMqzuNK2+glRGWCEqZo1WCLyAQ==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@webassemblyjs/helper-api-error": "1.11.6",
-        "@webassemblyjs/helper-wasm-bytecode": "1.11.6",
-        "@webassemblyjs/ieee754": "1.11.6",
-        "@webassemblyjs/leb128": "1.11.6",
-        "@webassemblyjs/utf8": "1.11.6"
-      }
-    },
-    "node_modules/@webassemblyjs/wast-printer": {
-      "version": "1.12.1",
-      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.12.1.tgz",
-      "integrity": "sha512-+X4WAlOisVWQMikjbcvY2e0rwPsKQ9F688lksZhBcPycBBuii3O7m8FACbDMWDojpAqvjIncrG8J0XHKyQfVeA==",
-      "dev": true,
-      "dependencies": {
-        "@webassemblyjs/ast": "1.12.1",
-        "@xtuc/long": "4.2.2"
-      }
-    },
     "node_modules/@xmldom/is-dom-node": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@xmldom/is-dom-node/-/is-dom-node-1.0.1.tgz",
@@ -22356,18 +22204,6 @@
         "node": ">=10.0.0"
       }
     },
-    "node_modules/@xtuc/ieee754": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
-      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
-      "dev": true
-    },
-    "node_modules/@xtuc/long": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
-      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
-      "dev": true
-    },
     "node_modules/abab": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz",
@@ -22532,15 +22368,6 @@
         }
       }
     },
-    "node_modules/ajv-keywords": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
-      "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
-      "dev": true,
-      "peerDependencies": {
-        "ajv": "^6.9.1"
-      }
-    },
     "node_modules/anser": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/anser/-/anser-2.1.1.tgz",
@@ -24061,15 +23888,6 @@
         "node": ">= 6"
       }
     },
-    "node_modules/chrome-trace-event": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz",
-      "integrity": "sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==",
-      "dev": true,
-      "engines": {
-        "node": ">=6.0"
-      }
-    },
     "node_modules/ci-info": {
       "version": "3.9.0",
       "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz",
@@ -26561,12 +26379,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/es-module-lexer": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz",
-      "integrity": "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==",
-      "dev": true
-    },
     "node_modules/es-object-atoms": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
@@ -27144,28 +26956,6 @@
         "eslint": ">=5.0.0"
       }
     },
-    "node_modules/eslint-scope": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz",
-      "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==",
-      "dev": true,
-      "dependencies": {
-        "esrecurse": "^4.3.0",
-        "estraverse": "^4.1.1"
-      },
-      "engines": {
-        "node": ">=8.0.0"
-      }
-    },
-    "node_modules/eslint-scope/node_modules/estraverse": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
-      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
-      "dev": true,
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
     "node_modules/eslint-visitor-keys": {
       "version": "3.4.3",
       "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
@@ -27479,7 +27269,6 @@
       "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
       "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "accepts": "^2.0.0",
         "body-parser": "^2.2.1",
@@ -27527,10 +27316,14 @@
       }
     },
     "node_modules/express-rate-limit": {
-      "version": "7.5.0",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz",
-      "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==",
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.2.1.tgz",
+      "integrity": "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g==",
+      "license": "MIT",
       "peer": true,
+      "dependencies": {
+        "ip-address": "10.0.1"
+      },
       "engines": {
         "node": ">= 16"
       },
@@ -29174,6 +28967,7 @@
       "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.3.tgz",
       "integrity": "sha512-SFsVSjp8sj5UumXOOFlkZOG6XS9SJDKw0TbwFeV+AJ8xlST8kxK5Z/5EYa111UY8732lK2S/xB653ceuaoGwpg==",
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=16.9.0"
       }
@@ -32185,6 +31979,7 @@
       "resolved": "https://registry.npmjs.org/keyv-file/-/keyv-file-5.2.0.tgz",
       "integrity": "sha512-5JEBqQiDzjGCQHtf7KLReJdHKchaJyUZW+9TvBu+4dc+uuTqUG9KcdA3ICMXlwky3qjKc0ecNCNefbgjyDtlAg==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@keyv/serialize": "^1.0.1",
         "tslib": "^1.14.1"
@@ -32707,15 +32502,6 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
-    "node_modules/loader-runner": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz",
-      "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==",
-      "dev": true,
-      "engines": {
-        "node": ">=6.11.5"
-      }
-    },
     "node_modules/loader-utils": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-3.3.1.tgz",
@@ -40578,24 +40364,6 @@
         "loose-envify": "^1.1.0"
       }
     },
-    "node_modules/schema-utils": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz",
-      "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==",
-      "dev": true,
-      "dependencies": {
-        "@types/json-schema": "^7.0.8",
-        "ajv": "^6.12.5",
-        "ajv-keywords": "^3.5.2"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      }
-    },
     "node_modules/seedrandom": {
       "version": "3.0.5",
       "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
@@ -41979,6 +41747,7 @@
       "resolved": "https://registry.npmjs.org/terser/-/terser-5.27.0.tgz",
       "integrity": "sha512-bi1HRwVRskAjheeYl291n3JC4GgO/Ty4z1nVs5AAsmonJulGxpSektecnNedrwK9C7vpvVtcX3cw00VSLt7U2A==",
       "dev": true,
+      "peer": true,
       "dependencies": {
         "@jridgewell/source-map": "^0.3.3",
         "acorn": "^8.8.2",
@@ -41992,69 +41761,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/terser-webpack-plugin": {
-      "version": "5.3.10",
-      "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz",
-      "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==",
-      "dev": true,
-      "dependencies": {
-        "@jridgewell/trace-mapping": "^0.3.20",
-        "jest-worker": "^27.4.5",
-        "schema-utils": "^3.1.1",
-        "serialize-javascript": "^6.0.1",
-        "terser": "^5.26.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependencies": {
-        "webpack": "^5.1.0"
-      },
-      "peerDependenciesMeta": {
-        "@swc/core": {
-          "optional": true
-        },
-        "esbuild": {
-          "optional": true
-        },
-        "uglify-js": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/jest-worker": {
-      "version": "27.5.1",
-      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
-      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
-      "dev": true,
-      "dependencies": {
-        "@types/node": "*",
-        "merge-stream": "^2.0.0",
-        "supports-color": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/terser-webpack-plugin/node_modules/supports-color": {
-      "version": "8.1.1",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
-      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
-      "dev": true,
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/supports-color?sponsor=1"
-      }
-    },
     "node_modules/terser/node_modules/commander": {
       "version": "2.20.3",
       "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
@@ -42780,7 +42486,6 @@
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
       "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
       "devOptional": true,
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -43790,19 +43495,6 @@
         "makeerror": "1.0.12"
       }
     },
-    "node_modules/watchpack": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz",
-      "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==",
-      "dev": true,
-      "dependencies": {
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.1.2"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
     "node_modules/web-namespaces": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
@@ -43829,62 +43521,6 @@
         "node": ">=12"
       }
     },
-    "node_modules/webpack": {
-      "version": "5.94.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.94.0.tgz",
-      "integrity": "sha512-KcsGn50VT+06JH/iunZJedYGUJS5FGjow8wb9c0v5n1Om8O1g4L6LjtfxwlXIATopoQu+vOXXa7gYisWxCoPyg==",
-      "dev": true,
-      "peer": true,
-      "dependencies": {
-        "@types/estree": "^1.0.5",
-        "@webassemblyjs/ast": "^1.12.1",
-        "@webassemblyjs/wasm-edit": "^1.12.1",
-        "@webassemblyjs/wasm-parser": "^1.12.1",
-        "acorn": "^8.7.1",
-        "acorn-import-attributes": "^1.9.5",
-        "browserslist": "^4.21.10",
-        "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.17.1",
-        "es-module-lexer": "^1.2.1",
-        "eslint-scope": "5.1.1",
-        "events": "^3.2.0",
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.2.11",
-        "json-parse-even-better-errors": "^2.3.1",
-        "loader-runner": "^4.2.0",
-        "mime-types": "^2.1.27",
-        "neo-async": "^2.6.2",
-        "schema-utils": "^3.2.0",
-        "tapable": "^2.1.1",
-        "terser-webpack-plugin": "^5.3.10",
-        "watchpack": "^2.4.1",
-        "webpack-sources": "^3.2.3"
-      },
-      "bin": {
-        "webpack": "bin/webpack.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/webpack"
-      },
-      "peerDependenciesMeta": {
-        "webpack-cli": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/webpack-sources": {
-      "version": "3.2.3",
-      "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz",
-      "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==",
-      "dev": true,
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
     "node_modules/websocket-driver": {
       "version": "0.7.4",
       "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 02dd7088b701..0afafe323c2a 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -8,7 +8,7 @@ import { apiBaseUrl } from './api-endpoints';
 import { FileSources } from './types/files';
 import { MCPServersSchema } from './mcp';
 
-export const defaultSocialLogins = ['google', 'facebook', 'openid', 'github', 'discord', 'saml'];
+export const defaultSocialLogins = ['google', 'facebook', 'openid', 'solid', 'github', 'discord', 'saml'];
 
 export const defaultRetrievalModels = [
   'gpt-4o',

From 48d7020b5d3c13bf070fe51cc79243b6ca2982d9 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 13:50:16 +0000
Subject: [PATCH 43/94] checkout these files from main to remove unwanted
 changes

---
 api/server/routes/agents/index.js             |   1 -
 .../services/Endpoints/agents/initialize.js   |  25 ---
 client/src/hooks/SSE/useResumableSSE.ts       | 157 ++++++++----------
 3 files changed, 71 insertions(+), 112 deletions(-)

diff --git a/api/server/routes/agents/index.js b/api/server/routes/agents/index.js
index 262c126d2d6a..f8d39cb4d82b 100644
--- a/api/server/routes/agents/index.js
+++ b/api/server/routes/agents/index.js
@@ -270,7 +270,6 @@ router.post('/chat/abort', async (req, res) => {
 });
 
 const chatRouter = express.Router();
-
 chatRouter.use(configMiddleware);
 
 if (isEnabled(LIMIT_MESSAGE_IP)) {
diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.js
index f7f886e665c6..e71270ef8530 100644
--- a/api/server/services/Endpoints/agents/initialize.js
+++ b/api/server/services/Endpoints/agents/initialize.js
@@ -152,31 +152,6 @@ const initializeClient = async ({ req, res, signal, endpointOption }) => {
     throw new Error('Agent not found');
   }
 
-  // If agent doesn't have a model, try to get it from multiple sources
-  // This is especially important for Solid storage where the model might be in the conversation
-  if (!primaryAgent.model) {
-    // Try multiple sources for the model
-    const modelFromEndpointOption = 
-      endpointOption.model || 
-      endpointOption.model_parameters?.model ||
-      req.body?.model ||
-      req.body?.model_parameters?.model;
-    
-    if (modelFromEndpointOption) {
-      logger.info('[initializeClient] Setting model from endpointOption/request body', {
-        agentId: primaryAgent.id,
-        model: modelFromEndpointOption,
-      });
-      primaryAgent.model = modelFromEndpointOption;
-    } else {
-      logger.warn('[initializeClient] No model found in endpointOption or request body', {
-        agentId: primaryAgent.id,
-        endpointOptionKeys: Object.keys(endpointOption),
-        reqBodyKeys: Object.keys(req.body || {}),
-      });
-    }
-  }
-
   const modelsConfig = await getModelsConfig(req);
   const validationResult = await validateAgentModel({
     req,
diff --git a/client/src/hooks/SSE/useResumableSSE.ts b/client/src/hooks/SSE/useResumableSSE.ts
index f20dfa9dc750..831bf042adf5 100644
--- a/client/src/hooks/SSE/useResumableSSE.ts
+++ b/client/src/hooks/SSE/useResumableSSE.ts
@@ -149,6 +149,7 @@ export default function useResumableSSE(
 
       const baseUrl = `${apiBaseUrl()}/api/agents/chat/stream/${encodeURIComponent(currentStreamId)}`;
       const url = isResume ? `${baseUrl}?resume=true` : baseUrl;
+      console.log('[ResumableSSE] Subscribing to stream:', url, { isResume });
 
       const sse = new SSE(url, {
         headers: { Authorization: `Bearer ${token}` },
@@ -157,6 +158,7 @@ export default function useResumableSSE(
       sseRef.current = sse;
 
       sse.addEventListener('open', () => {
+        console.log('[ResumableSSE] Stream connected');
         setAbortScroll(false);
         // Restore UI state on successful connection (including reconnection)
         setIsSubmitting(true);
@@ -222,6 +224,10 @@ export default function useResumableSSE(
           }
 
           if (data.sync != null) {
+            console.log('[ResumableSSE] SYNC received', {
+              runSteps: data.resumeState?.runSteps?.length ?? 0,
+            });
+
             const runId = v4();
             setActiveRunId(runId);
 
@@ -256,18 +262,34 @@ export default function useResumableSSE(
                 );
               }
 
+              console.log('[ResumableSSE] SYNC update', {
+                userMsgId,
+                serverResponseId,
+                responseIdx,
+                foundMessageId: responseIdx >= 0 ? messages[responseIdx]?.messageId : null,
+                messagesCount: messages.length,
+                aggregatedContentLength: data.resumeState.aggregatedContent?.length,
+              });
+
               if (responseIdx >= 0) {
                 // Update existing response message with aggregatedContent
                 const updated = [...messages];
+                const oldContent = updated[responseIdx]?.content;
                 updated[responseIdx] = {
                   ...updated[responseIdx],
                   content: data.resumeState.aggregatedContent,
                 };
+                console.log('[ResumableSSE] SYNC updating message', {
+                  messageId: updated[responseIdx]?.messageId,
+                  oldContentLength: Array.isArray(oldContent) ? oldContent.length : 0,
+                  newContentLength: data.resumeState.aggregatedContent?.length,
+                });
                 setMessages(updated);
                 // Sync both content handler and step handler with the updated message
                 // so subsequent deltas build on synced content, not stale content
                 resetContentHandler();
                 syncStepMessage(updated[responseIdx]);
+                console.log('[ResumableSSE] SYNC complete, handlers synced');
               } else {
                 // Add new response message
                 const responseId = serverResponseId ?? `${userMsgId}_`;
@@ -328,6 +350,7 @@ export default function useResumableSSE(
 
         // 404 means job doesn't exist (completed/deleted) - don't retry
         if (responseCode === 404) {
+          console.log('[ResumableSSE] Stream not found (404) - job completed or expired');
           sse.close();
           removeActiveJob(currentStreamId);
           setIsSubmitting(false);
@@ -362,6 +385,7 @@ export default function useResumableSSE(
          * Only check e.data if there's no HTTP responseCode, since HTTP errors may also have body data.
          */
         if (!responseCode && e.data) {
+          console.log('[ResumableSSE] Server-sent error event received:', e.data);
           sse.close();
           removeActiveJob(currentStreamId);
 
@@ -385,6 +409,8 @@ export default function useResumableSSE(
               // Not JSON or parsing failed - treat as generic error
             }
 
+            console.log('[ResumableSSE] Error type check:', { isKnownError, errorString });
+
             // Display the error to user via errorHandler
             errorHandler({
               data: { text: errorString } as unknown as Parameters<typeof errorHandler>[0]['data'],
@@ -457,6 +483,8 @@ export default function useResumableSSE(
           console.log('[ResumableSSE] Stream closed for reconnect - preserving state');
           return;
         }
+
+        console.log('[ResumableSSE] Stream aborted (intentional close) - no reconnect');
         // Clear any pending reconnect attempts
         if (reconnectTimeoutRef.current) {
           clearTimeout(reconnectTimeoutRef.current);
@@ -525,26 +553,13 @@ export default function useResumableSSE(
    */
   const startGeneration = useCallback(
     async (currentSubmission: TSubmission): Promise<string | null> => {
-      // Check if submission is still valid
-      if (!currentSubmission || !currentSubmission.userMessage || !currentSubmission.endpointOption) {
-        return null;
-      }
-      
-      try {
-        let payloadData;
-        try {
-          payloadData = createPayload(currentSubmission);
-        } catch (payloadError) {
-          console.error('[ResumableSSE] Error in createPayload:', payloadError);
-          throw payloadError;
-        }
-        
-        let { payload } = payloadData;
-        payload = removeNullishValues(payload) as TPayload;
+      const payloadData = createPayload(currentSubmission);
+      let { payload } = payloadData;
+      payload = removeNullishValues(payload) as TPayload;
 
-        clearStepMaps();
+      clearStepMaps();
 
-        const url = payloadData.server;
+      const url = payloadData.server;
 
       const maxRetries = 3;
       let lastError: unknown = null;
@@ -553,13 +568,9 @@ export default function useResumableSSE(
         try {
           // Use request.post which handles auth token refresh via axios interceptors
           const data = (await request.post(url, payload)) as { streamId: string };
+          console.log('[ResumableSSE] Generation started:', { streamId: data.streamId });
           return data.streamId;
         } catch (error) {
-          console.error('[ResumableSSE] POST request failed:', { 
-            attempt, 
-            error: error instanceof Error ? error.message : String(error),
-            url,
-          });
           lastError = error;
           // Check if it's a network error (retry) vs server error (don't retry)
           const isNetworkError =
@@ -581,35 +592,29 @@ export default function useResumableSSE(
         }
       }
 
-        console.error('[ResumableSSE] Error starting generation after all retries:', lastError);
-
-        const axiosError = lastError as { response?: { data?: Record<string, unknown> } };
-        const errorData = axiosError?.response?.data;
-        if (errorData) {
-          console.error('[ResumableSSE] Error data from server:', errorData);
-          errorHandler({
-            data: { text: JSON.stringify(errorData) } as unknown as Parameters<
-              typeof errorHandler
-            >[0]['data'],
-            submission: currentSubmission as EventSubmission,
-          });
-        } else {
-          console.error('[ResumableSSE] No error data from server');
-          errorHandler({ data: undefined, submission: currentSubmission as EventSubmission });
-        }
-        setIsSubmitting(false);
-        return null;
-      } catch (error) {
-        console.error('[ResumableSSE] Unexpected error in startGeneration:', error);
-        setIsSubmitting(false);
-        return null;
+      console.error('[ResumableSSE] Error starting generation:', lastError);
+
+      const axiosError = lastError as { response?: { data?: Record<string, unknown> } };
+      const errorData = axiosError?.response?.data;
+      if (errorData) {
+        errorHandler({
+          data: { text: JSON.stringify(errorData) } as unknown as Parameters<
+            typeof errorHandler
+          >[0]['data'],
+          submission: currentSubmission as EventSubmission,
+        });
+      } else {
+        errorHandler({ data: undefined, submission: currentSubmission as EventSubmission });
       }
+      setIsSubmitting(false);
+      return null;
     },
     [clearStepMaps, errorHandler, setIsSubmitting],
   );
 
   useEffect(() => {
     if (!submission || Object.keys(submission).length === 0) {
+      console.log('[ResumableSSE] No submission, cleaning up');
       // Clear reconnect timeout if submission is cleared
       if (reconnectTimeoutRef.current) {
         clearTimeout(reconnectTimeoutRef.current);
@@ -626,68 +631,48 @@ export default function useResumableSSE(
       return;
     }
 
-    // Validate submission has required properties
-    if (!submission.userMessage || !submission.endpointOption) {
-      return;
-    }
-
     const resumeStreamId = (submission as TSubmission & { resumeStreamId?: string }).resumeStreamId;
+    console.log('[ResumableSSE] Effect triggered', {
+      conversationId: submission.conversation?.conversationId,
+      hasResumeStreamId: !!resumeStreamId,
+      resumeStreamId,
+      userMessageId: submission.userMessage?.messageId,
+    });
 
     submissionRef.current = submission;
 
     const initStream = async () => {
-      // Check if submission was cleared while we were waiting
-      if (!submissionRef.current || submissionRef.current !== submission) {
-        return;
-      }
-      
       setIsSubmitting(true);
       setShowStopButton(true);
 
       if (resumeStreamId) {
         // Resume: just subscribe to existing stream, don't start new generation
+        console.log('[ResumableSSE] Resuming existing stream:', resumeStreamId);
         setStreamId(resumeStreamId);
         // Optimistically add to active jobs (in case it's not already there)
         addActiveJob(resumeStreamId);
         subscribeToStream(resumeStreamId, submission, true); // isResume=true
       } else {
         // New generation: start and then subscribe
-        // Check if submission is still valid before calling startGeneration
-        if (!submission || !submission.userMessage || !submission.endpointOption) {
-          setIsSubmitting(false);
-          setShowStopButton(false);
-          return;
-        }
-        
-        try {
-          const newStreamId = await startGeneration(submission);
-          
-          if (newStreamId) {
-            setStreamId(newStreamId);
-            // Optimistically add to active jobs
-            addActiveJob(newStreamId);
-            // Queue title generation if this is a new conversation (first message)
-            const isNewConvo = submission.userMessage?.parentMessageId === Constants.NO_PARENT;
-            if (isNewConvo) {
-              queueTitleGeneration(newStreamId);
-            }
-            subscribeToStream(newStreamId, submission);
-          } else {
-            console.error('[ResumableSSE] Failed to get streamId from startGeneration');
-            setIsSubmitting(false);
-            setShowStopButton(false);
+        console.log('[ResumableSSE] Starting NEW generation');
+        const newStreamId = await startGeneration(submission);
+        if (newStreamId) {
+          setStreamId(newStreamId);
+          // Optimistically add to active jobs
+          addActiveJob(newStreamId);
+          // Queue title generation if this is a new conversation (first message)
+          const isNewConvo = submission.userMessage?.parentMessageId === Constants.NO_PARENT;
+          if (isNewConvo) {
+            queueTitleGeneration(newStreamId);
           }
-        } catch (error) {
-          console.error('[ResumableSSE] Error in startGeneration call:', error);
-          setIsSubmitting(false);
-          setShowStopButton(false);
+          subscribeToStream(newStreamId, submission);
+        } else {
+          console.error('[ResumableSSE] Failed to get streamId from startGeneration');
         }
       }
     };
 
-    initStream().catch((error) => {
-      console.error('[ResumableSSE] Error in initStream:', error);
-    });
+    initStream();
 
     return () => {
       console.log('[ResumableSSE] Cleanup - closing SSE, resetting UI state');

From e0fd7be85ecde954b2fbb06cbf92ed1bc23c3511 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 13:50:36 +0000
Subject: [PATCH 44/94] removed dupplicate imports caused by rebase

---
 api/strategies/index.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/api/strategies/index.js b/api/strategies/index.js
index b5c3e069dc80..98816c8c3568 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -6,14 +6,10 @@ const discordLogin = require('./discordStrategy');
 const passportLogin = require('./localStrategy');
 const googleLogin = require('./googleStrategy');
 const githubLogin = require('./githubStrategy');
-const discordLogin = require('./discordStrategy');
-const facebookLogin = require('./facebookStrategy');
 const jwtLogin = require('./jwtStrategy');
 const ldapLogin = require('./ldapStrategy');
 const { setupSaml } = require('./samlStrategy');
 const appleLogin = require('./appleStrategy');
-const ldapLogin = require('./ldapStrategy');
-const jwtLogin = require('./jwtStrategy');
 
 module.exports = {
   appleLogin,

From 358f3a4652fbe612322288136f083aa9ceca6480 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 13:50:50 +0000
Subject: [PATCH 45/94] fixed undefined error

---
 api/server/socialLogins.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index f23c3207f7dc..eb5193b16aae 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -82,6 +82,7 @@ async function configureSolidOpenId(app) {
  */
 async function configureOpenId(app) {
   logger.info('Configuring OpenID Connect...');
+  const sessionExpiry = Number(process.env.SESSION_EXPIRY) || DEFAULT_SESSION_EXPIRY;
   const sessionOptions = {
     secret: process.env.SOLID_OPENID_SESSION_SECRET,
     resave: false,

From dac646ec4e7ba1057f5075b3e8f3c803e839344b Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 14:08:19 +0000
Subject: [PATCH 46/94] checkout createpayload.ts file from main, to remove
 redundant code

---
 packages/data-provider/src/createPayload.ts | 213 +-------------------
 1 file changed, 1 insertion(+), 212 deletions(-)

diff --git a/packages/data-provider/src/createPayload.ts b/packages/data-provider/src/createPayload.ts
index 2d2a89e709a7..3056a7021b99 100644
--- a/packages/data-provider/src/createPayload.ts
+++ b/packages/data-provider/src/createPayload.ts
@@ -15,98 +15,7 @@ export default function createPayload(submission: t.TSubmission) {
     ephemeralAgent,
     endpointOption,
   } = submission;
-  
-  // Normalize conversation object for Solid storage compatibility
-  // Solid storage may return messages as objects instead of IDs, and null values instead of undefined
-  // Wrap in try-catch to ensure we can always fall back if normalization fails
-  let normalizedConversation: Record<string, unknown>;
-  try {
-    normalizedConversation = { ...conversation };
-    
-    // Convert messages array from objects to IDs if needed
-    if (Array.isArray(normalizedConversation.messages)) {
-      normalizedConversation.messages = normalizedConversation.messages.map((msg: unknown) => {
-        if (typeof msg === 'string') {
-          return msg;
-        }
-        if (typeof msg === 'object' && msg !== null && 'messageId' in msg) {
-          return (msg as { messageId: string }).messageId;
-        }
-        return String(msg);
-      }) as string[];
-    }
-  } catch (normalizationError) {
-    // If normalization fails, just use the original conversation and let the fallback handle it
-    normalizedConversation = conversation as Record<string, unknown>;
-  }
-  
-  // Convert ALL null values to undefined for optional fields that expect specific types
-  // This is necessary because Zod schemas use .optional() which means undefined, not null
-  const nullableNumberFields = [
-    'topP', 'top_p', 'topK', 'frequency_penalty', 'presence_penalty', 
-    'temperature', 'maxOutputTokens', 'maxContextTokens', 'max_tokens',
-    'thinkingBudget', 'fileTokenLimit'
-  ];
-  
-  const nullableStringFields = [
-    'assistant_id', 'agent_id', 'model', 'modelLabel', 'userLabel',
-    'promptPrefix', 'system', 'context', 'title', 'conversationId',
-    'endpoint', 'endpointType', 'parentMessageId', 'artifacts',
-    'imageDetail', 'reasoning_effort', 'reasoning_summary', 'verbosity'
-  ];
-  
-  const nullableBooleanFields = [
-    'isArchived', 'promptCache', 'thinking', 'stream', 'resendFiles'
-  ];
-  
-  // Convert null to undefined for all nullable fields
-  for (const field of nullableNumberFields) {
-    if (field in normalizedConversation && normalizedConversation[field] === null) {
-      normalizedConversation[field] = undefined;
-    }
-  }
-  
-  for (const field of nullableStringFields) {
-    if (field in normalizedConversation && normalizedConversation[field] === null) {
-      normalizedConversation[field] = undefined;
-    }
-  }
-  
-  for (const field of nullableBooleanFields) {
-    if (field in normalizedConversation && normalizedConversation[field] === null) {
-      normalizedConversation[field] = undefined;
-    }
-  }
-  
-  // Handle createdAt and updatedAt - convert Date objects to strings, or null to undefined
-  if ('createdAt' in normalizedConversation) {
-    if (normalizedConversation.createdAt === null) {
-      normalizedConversation.createdAt = undefined;
-    } else if (normalizedConversation.createdAt instanceof Date) {
-      normalizedConversation.createdAt = normalizedConversation.createdAt.toISOString();
-    }
-  }
-  
-  if ('updatedAt' in normalizedConversation) {
-    if (normalizedConversation.updatedAt === null) {
-      normalizedConversation.updatedAt = undefined;
-    } else if (normalizedConversation.updatedAt instanceof Date) {
-      normalizedConversation.updatedAt = normalizedConversation.updatedAt.toISOString();
-    }
-  }
-  
-  // Use safeParse to handle validation errors gracefully
-  // safeParse never throws, it always returns { success: true, data } or { success: false, error }
-  const parseResult = s.tConvoUpdateSchema.safeParse(normalizedConversation);
-  
-  if (!parseResult.success) {
-    // Fallback: try to extract conversationId directly if parse fails
-    // For new conversations, conversationId can be null or 'new', which is valid
-    const conversationIdRaw = conversation?.conversationId ?? normalizedConversation?.conversationId ?? null;
-    
-    // Allow null or 'new' for new conversations
-    if (conversationIdRaw === null || conversationIdRaw === 'new') {
-      const conversationId = conversationIdRaw;
+  const { conversationId } = s.tConvoUpdateSchema.parse(conversation);
   const { endpoint: _e, endpointType } = endpointOption as {
     endpoint: s.EModelEndpoint;
     endpointType?: s.EModelEndpoint;
@@ -120,122 +29,6 @@ export default function createPayload(submission: t.TSubmission) {
       (isEdited ? '/modify' : '');
   }
 
-      const payload: t.TPayload = {
-        ...userMessage,
-        ...endpointOption,
-        endpoint,
-        addedConvo,
-        isTemporary,
-        isRegenerate,
-        editedContent,
-        conversationId: conversationId as string | null,
-        isContinued: !!(isEdited && isContinued),
-        ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
-      };
-
-      return { server, payload };
-    }
-    
-    // For existing conversations, conversationId must be a valid string
-    if (typeof conversationIdRaw !== 'string') {
-      throw new Error('Invalid conversation: conversationId must be a string');
-    }
-
-    const conversationId: string = conversationIdRaw;
-    
-    // Extract important fields from the conversation object and endpointOption
-    // This is especially important for Solid storage where the conversation might have the model
-    // Check endpointOption first, then conversation, as endpointOption takes precedence
-    const conversationFields = {
-      model: (endpointOption as { model?: string })?.model ?? conversation?.model ?? normalizedConversation?.model,
-      modelLabel: (endpointOption as { modelLabel?: string })?.modelLabel ?? conversation?.modelLabel ?? normalizedConversation?.modelLabel,
-      temperature: (endpointOption as { temperature?: number })?.temperature ?? conversation?.temperature ?? normalizedConversation?.temperature,
-      topP: (endpointOption as { topP?: number })?.topP ?? conversation?.topP ?? normalizedConversation?.topP,
-      top_p: (endpointOption as { top_p?: number })?.top_p ?? conversation?.top_p ?? normalizedConversation?.top_p,
-      frequency_penalty: (endpointOption as { frequency_penalty?: number })?.frequency_penalty ?? conversation?.frequency_penalty ?? normalizedConversation?.frequency_penalty,
-      presence_penalty: (endpointOption as { presence_penalty?: number })?.presence_penalty ?? conversation?.presence_penalty ?? normalizedConversation?.presence_penalty,
-      maxOutputTokens: (endpointOption as { maxOutputTokens?: number })?.maxOutputTokens ?? conversation?.maxOutputTokens ?? normalizedConversation?.maxOutputTokens,
-      max_tokens: (endpointOption as { max_tokens?: number })?.max_tokens ?? conversation?.max_tokens ?? normalizedConversation?.max_tokens,
-      system: (endpointOption as { system?: string })?.system ?? conversation?.system ?? normalizedConversation?.system,
-      promptPrefix: (endpointOption as { promptPrefix?: string })?.promptPrefix ?? conversation?.promptPrefix ?? normalizedConversation?.promptPrefix,
-    };
-    
-    // Filter out null/undefined values
-    const validConversationFields = Object.fromEntries(
-      Object.entries(conversationFields).filter(([_, value]) => value !== null && value !== undefined)
-    );
-    
-    // Continue with the fallback conversationId
-    const { endpoint: _e, endpointType } = endpointOption as {
-      endpoint: s.EModelEndpoint;
-      endpointType?: s.EModelEndpoint;
-    };
-
-    const endpoint = _e as s.EModelEndpoint;
-    let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
-    if (s.isAssistantsEndpoint(endpoint)) {
-      server =
-        EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
-        (isEdited ? '/modify' : '');
-    }
-
-    // Ensure model is explicitly included - check all sources
-    const finalModel = (endpointOption as { model?: string })?.model || 
-                      validConversationFields.model || 
-                      conversation?.model || 
-                      normalizedConversation?.model;
-
-    // Extract resendFiles - default to true for agents endpoints if not specified
-    const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
-    const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
-    const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
-    const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
-
-    const payload: t.TPayload = {
-      ...userMessage,
-      ...endpointOption,
-      ...validConversationFields, // Merge conversation fields, with endpointOption taking precedence
-      endpoint,
-      addedConvo,
-      isTemporary,
-      isRegenerate,
-      editedContent,
-      conversationId,
-      isContinued: !!(isEdited && isContinued),
-      ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
-      // Explicitly include model at top level - this ensures it's always in the payload if available
-      ...(finalModel ? { model: finalModel as string } : {}),
-      // Explicitly include resendFiles - always true for agents endpoints if not specified
-      ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
-    };
-
-    return { server, payload };
-  }
-  const { conversationId } = parseResult.data;
-  const { endpoint: _e, endpointType } = endpointOption as {
-    endpoint: s.EModelEndpoint;
-    endpointType?: s.EModelEndpoint;
-  };
-
-  const endpoint = _e as s.EModelEndpoint;
-  let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
-  if (s.isAssistantsEndpoint(endpoint)) {
-    server =
-      EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
-      (isEdited ? '/modify' : '');
-  }
-
-  // Extract model from conversation if not in endpointOption (for Solid storage compatibility)
-  const modelFromConversation = conversation?.model ?? normalizedConversation?.model;
-  const modelFromEndpointOption = (endpointOption as { model?: string })?.model;
-  const finalModel = (modelFromEndpointOption || modelFromConversation) as string | undefined;
-
-  // Extract resendFiles - default to true for agents endpoints if not specified
-  const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
-  const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
-  const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
-  const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
-
   const payload: t.TPayload = {
     ...userMessage,
     ...endpointOption,
@@ -247,10 +40,6 @@ export default function createPayload(submission: t.TSubmission) {
     conversationId,
     isContinued: !!(isEdited && isContinued),
     ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
-    // Explicitly include model at top level for buildEndpointOption to find it
-    ...(finalModel ? { model: finalModel } : {}),
-    // Explicitly include resendFiles - always true for agents endpoints if not specified
-    ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
   };
 
   return { server, payload };

From 595be2911eb1c00ba3fb3860bb96db47d353f42e Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 14:49:07 +0000
Subject: [PATCH 47/94] moved inline imports to top level

---
 packages/data-schemas/src/methods/share.ts | 28 +++++++++++-----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index b7a06c7e5b62..53e25841f39e 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -5,6 +5,10 @@ import type { SchemaWithMeiliMethods } from '~/models/plugins/mongoMeili';
 import type * as t from '~/types';
 import logger from '~/config/winston';
 
+// Solid storage and auth helpers – required at runtime when share methods run in api server context
+const getSolidStorage = () => require('~/server/services/SolidStorage');
+const getIsSolidUser = () => require('~/server/utils/isSolidUser').isSolidUser;
+
 class ShareServiceError extends Error {
   code: string;
   constructor(message: string, code: string) {
@@ -173,7 +177,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       if (share.podUrl) {
         // Get shared messages from Solid Pod
         try {
-          const { getSharedMessagesFromSolid } = require('~/server/services/SolidStorage');
+          const { getSharedMessagesFromSolid } = getSolidStorage();
           const solidShare = await getSharedMessagesFromSolid(
             shareId,
             share.conversationId,
@@ -205,12 +209,11 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
             conversationId: share.conversationId,
             podUrl: share.podUrl,
           });
-          // Fall through to return null if Solid fetch fails
           return null;
         }
       }
 
-      // MongoDB share - use existing logic
+      // MongoDB share - use existing logic (separate query with populate to get messages)
       const shareWithMessages = (await SharedLink.findOne({ shareId, isPublic: true })
         .populate({
           path: 'messages',
@@ -380,12 +383,11 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       
       // If any shares are Solid shares, remove public access (user logged in via "Continue with Solid")
       if (req) {
-        const { isSolidUser } = require('~/server/utils/isSolidUser');
-        if (isSolidUser(req)) {
+        if (getIsSolidUser()(req)) {
           const solidShares = shares.filter(share => share.podUrl);
           for (const share of solidShares) {
             try {
-              const { removePublicAccessForShare } = require('~/server/services/SolidStorage');
+              const { removePublicAccessForShare } = getSolidStorage();
               await removePublicAccessForShare(req, conversationId);
               logger.info('[deleteConvoSharedLink] Public access removed for Solid share', {
                 shareId: share.shareId,
@@ -438,12 +440,11 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       const Conversation = mongoose.models.Conversation as SchemaWithMeiliMethods;
 
       // Check if this is a Solid user (logged in via "Continue with Solid")
-      const { isSolidUser } = require('~/server/utils/isSolidUser');
       let conversation;
       let conversationMessages;
       let podUrl: string | undefined;
 
-      if (isSolidUser(req)) {
+      if (req && getIsSolidUser()(req)) {
         logger.info('[createSharedLink] Detected Solid user, using Solid storage path');
         // Check for existing share first (same as MongoDB)
         const existingShare = (await SharedLink.findOne({
@@ -483,9 +484,8 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
             getConvoFromSolid,
             getMessagesFromSolid,
             getPodUrl,
-            setPublicAccessForShare,
             getSolidFetch,
-          } = require('~/server/services/SolidStorage');
+          } = getSolidStorage();
           const authenticatedFetch = await getSolidFetch(req);
           
           // Get Pod URL
@@ -631,7 +631,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
         ...(targetMessageId && { targetMessageId }),
       };
 
-      if (isSolidUser && podUrl) {
+      if (podUrl) {
         sharedLinkData.podUrl = podUrl;
         // For Solid, we don't store message ObjectIds, but we still need the array for schema compatibility
         sharedLinkData.messages = [];
@@ -643,9 +643,9 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       await SharedLink.create(sharedLinkData);
 
       // For Solid users, set public access on conversation and messages
-      if (isSolidUser && req) {
+      if (req && podUrl) {
         try {
-          const { setPublicAccessForShare } = require('~/server/services/SolidStorage');
+          const { setPublicAccessForShare } = getSolidStorage();
           await setPublicAccessForShare(req, conversationId);
           logger.info('[createSharedLink] Public access set for Solid share', {
             shareId,
@@ -789,7 +789,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       // If this is a Solid share, remove public access before deleting
       if (share.podUrl && req) {
         try {
-          const { removePublicAccessForShare } = require('~/server/services/SolidStorage');
+          const { removePublicAccessForShare } = getSolidStorage();
           await removePublicAccessForShare(req, share.conversationId);
           logger.info('[deleteSharedLink] Public access removed for Solid share', {
             shareId,

From df2876dd84d5e55213f637290175b4be0f611338 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 15:32:05 +0000
Subject: [PATCH 48/94] brought back the createPayload.ts changes and added
 explanatory comments

---
 packages/data-provider/src/createPayload.ts | 230 +++++++++++++++++++-
 1 file changed, 229 insertions(+), 1 deletion(-)

diff --git a/packages/data-provider/src/createPayload.ts b/packages/data-provider/src/createPayload.ts
index 3056a7021b99..b2a36f0bf70b 100644
--- a/packages/data-provider/src/createPayload.ts
+++ b/packages/data-provider/src/createPayload.ts
@@ -2,6 +2,17 @@ import type * as t from './types';
 import { EndpointURLs } from './config';
 import * as s from './schemas';
 
+/**
+ * Builds the request payload for the chat/agents API.
+ *
+ * When using Solid storage, the conversation object can come back with a different shape than
+ * the rest of the app expects (e.g. after loading from the Pod ).
+ * Without normalizing here, the first message in a conversation works, but continuing the
+ * conversation (second message) fails because createPayload receives invalid or mismatched
+ * data (messages as objects, null instead of undefined, model on conversation, etc.).
+ * The normalization below ensures we always produce a valid payload for both the initial
+ * and follow-up requests.
+ */
 export default function createPayload(submission: t.TSubmission) {
   const {
     isEdited,
@@ -15,7 +26,105 @@ export default function createPayload(submission: t.TSubmission) {
     ephemeralAgent,
     endpointOption,
   } = submission;
-  const { conversationId } = s.tConvoUpdateSchema.parse(conversation);
+
+  /**
+   * Normalize conversation for Solid storage compatibility.
+   * Solid can give us: messages as full objects with
+   * messageId instead of an array of IDs; null instead of undefined for optional fields.
+   * We convert to the shape tConvoUpdateSchema and downstream code expect.
+   */
+  let normalizedConversation: Record<string, unknown>;
+  try {
+    normalizedConversation = { ...conversation };
+
+    // Messages: ensure we have an array of message IDs (schema expects string[]), not objects
+    if (Array.isArray(normalizedConversation.messages)) {
+      normalizedConversation.messages = normalizedConversation.messages.map((msg: unknown) => {
+        if (typeof msg === 'string') {
+          return msg;
+        }
+        if (typeof msg === 'object' && msg !== null && 'messageId' in msg) {
+          return (msg as { messageId: string }).messageId;
+        }
+        return String(msg);
+      }) as string[];
+    }
+  } catch {
+    normalizedConversation = conversation as Record<string, unknown>;
+  }
+
+  /**
+   * Zod .optional() means "undefined is valid", not null. JSON/Storage often use null for
+   * missing optional fields. Convert null → undefined so schema parse succeeds.
+   */
+  const nullableNumberFields = [
+    'topP', 'top_p', 'topK', 'frequency_penalty', 'presence_penalty', 
+    'temperature', 'maxOutputTokens', 'maxContextTokens', 'max_tokens',
+    'thinkingBudget', 'fileTokenLimit'
+  ];
+  
+  const nullableStringFields = [
+    'assistant_id', 'agent_id', 'model', 'modelLabel', 'userLabel',
+    'promptPrefix', 'system', 'context', 'title', 'conversationId',
+    'endpoint', 'endpointType', 'parentMessageId', 'artifacts',
+    'imageDetail', 'reasoning_effort', 'reasoning_summary', 'verbosity'
+  ];
+  
+  const nullableBooleanFields = [
+    'isArchived', 'promptCache', 'thinking', 'stream', 'resendFiles'
+  ];
+  
+  // Convert null to undefined for all nullable fields
+  for (const field of nullableNumberFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  for (const field of nullableStringFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  for (const field of nullableBooleanFields) {
+    if (field in normalizedConversation && normalizedConversation[field] === null) {
+      normalizedConversation[field] = undefined;
+    }
+  }
+  
+  // Handle createdAt and updatedAt - convert Date objects to strings, or null to undefined
+  if ('createdAt' in normalizedConversation) {
+    if (normalizedConversation.createdAt === null) {
+      normalizedConversation.createdAt = undefined;
+    } else if (normalizedConversation.createdAt instanceof Date) {
+      normalizedConversation.createdAt = normalizedConversation.createdAt.toISOString();
+    }
+  }
+  
+  if ('updatedAt' in normalizedConversation) {
+    if (normalizedConversation.updatedAt === null) {
+      normalizedConversation.updatedAt = undefined;
+    } else if (normalizedConversation.updatedAt instanceof Date) {
+      normalizedConversation.updatedAt = normalizedConversation.updatedAt.toISOString();
+    }
+  }
+  
+  /**
+   * Use safeParse so we don't throw on invalid/conversation shapes (e.g. from Solid).
+   * If parse fails, we still try to build a valid payload from conversation + endpointOption
+   * (fallback below) so follow-up messages can succeed.
+   */
+  const parseResult = s.tConvoUpdateSchema.safeParse(normalizedConversation);
+
+  if (!parseResult.success) {
+    // Fallback: build payload from raw conversationId and conversation/endpointOption fields
+    // (e.g. new convo: conversationId null/'new'; existing: we need conversationId + model etc.)
+    const conversationIdRaw = conversation?.conversationId ?? normalizedConversation?.conversationId ?? null;
+    
+    // Allow null or 'new' for new conversations
+    if (conversationIdRaw === null || conversationIdRaw === 'new') {
+      const conversationId = conversationIdRaw;
   const { endpoint: _e, endpointType } = endpointOption as {
     endpoint: s.EModelEndpoint;
     endpointType?: s.EModelEndpoint;
@@ -29,6 +138,121 @@ export default function createPayload(submission: t.TSubmission) {
       (isEdited ? '/modify' : '');
   }
 
+      const payload: t.TPayload = {
+        ...userMessage,
+        ...endpointOption,
+        endpoint,
+        addedConvo,
+        isTemporary,
+        isRegenerate,
+        editedContent,
+        conversationId: conversationId as string | null,
+        isContinued: !!(isEdited && isContinued),
+        ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+      };
+
+      return { server, payload };
+    }
+    
+    // For existing conversations, conversationId must be a valid string
+    if (typeof conversationIdRaw !== 'string') {
+      throw new Error('Invalid conversation: conversationId must be a string');
+    }
+
+    const conversationId: string = conversationIdRaw;
+    
+    // Solid often stores model (and other options) on the conversation; pull from conversation
+    // when not in endpointOption so the payload has a model for the backend.
+    const conversationFields = {
+      model: (endpointOption as { model?: string })?.model ?? conversation?.model ?? normalizedConversation?.model,
+      modelLabel: (endpointOption as { modelLabel?: string })?.modelLabel ?? conversation?.modelLabel ?? normalizedConversation?.modelLabel,
+      temperature: (endpointOption as { temperature?: number })?.temperature ?? conversation?.temperature ?? normalizedConversation?.temperature,
+      topP: (endpointOption as { topP?: number })?.topP ?? conversation?.topP ?? normalizedConversation?.topP,
+      top_p: (endpointOption as { top_p?: number })?.top_p ?? conversation?.top_p ?? normalizedConversation?.top_p,
+      frequency_penalty: (endpointOption as { frequency_penalty?: number })?.frequency_penalty ?? conversation?.frequency_penalty ?? normalizedConversation?.frequency_penalty,
+      presence_penalty: (endpointOption as { presence_penalty?: number })?.presence_penalty ?? conversation?.presence_penalty ?? normalizedConversation?.presence_penalty,
+      maxOutputTokens: (endpointOption as { maxOutputTokens?: number })?.maxOutputTokens ?? conversation?.maxOutputTokens ?? normalizedConversation?.maxOutputTokens,
+      max_tokens: (endpointOption as { max_tokens?: number })?.max_tokens ?? conversation?.max_tokens ?? normalizedConversation?.max_tokens,
+      system: (endpointOption as { system?: string })?.system ?? conversation?.system ?? normalizedConversation?.system,
+      promptPrefix: (endpointOption as { promptPrefix?: string })?.promptPrefix ?? conversation?.promptPrefix ?? normalizedConversation?.promptPrefix,
+    };
+    
+    // Filter out null/undefined values
+    const validConversationFields = Object.fromEntries(
+      Object.entries(conversationFields).filter(([_, value]) => value !== null && value !== undefined)
+    );
+    
+    // Continue with the fallback conversationId
+    const { endpoint: _e, endpointType } = endpointOption as {
+      endpoint: s.EModelEndpoint;
+      endpointType?: s.EModelEndpoint;
+    };
+
+    const endpoint = _e as s.EModelEndpoint;
+    let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
+    if (s.isAssistantsEndpoint(endpoint)) {
+      server =
+        EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
+        (isEdited ? '/modify' : '');
+    }
+
+    // Ensure model is explicitly included - check all sources
+    const finalModel = (endpointOption as { model?: string })?.model || 
+                      validConversationFields.model || 
+                      conversation?.model || 
+                      normalizedConversation?.model;
+
+    // Extract resendFiles - default to true for agents endpoints if not specified
+    const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
+    const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+    const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
+    const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+
+    const payload: t.TPayload = {
+      ...userMessage,
+      ...endpointOption,
+      ...validConversationFields, // Merge conversation fields, with endpointOption taking precedence
+      endpoint,
+      addedConvo,
+      isTemporary,
+      isRegenerate,
+      editedContent,
+      conversationId,
+      isContinued: !!(isEdited && isContinued),
+      ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+      // Explicitly include model at top level - this ensures it's always in the payload if available
+      ...(finalModel ? { model: finalModel as string } : {}),
+      // Explicitly include resendFiles - always true for agents endpoints if not specified
+      ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
+    };
+
+    return { server, payload };
+  }
+  const { conversationId } = parseResult.data;
+  const { endpoint: _e, endpointType } = endpointOption as {
+    endpoint: s.EModelEndpoint;
+    endpointType?: s.EModelEndpoint;
+  };
+
+  const endpoint = _e as s.EModelEndpoint;
+  let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
+  if (s.isAssistantsEndpoint(endpoint)) {
+    server =
+      EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
+      (isEdited ? '/modify' : '');
+  }
+
+  // Model can live on the conversation when loaded from Solid; include it in payload if present
+  const modelFromConversation = conversation?.model ?? normalizedConversation?.model;
+  const modelFromEndpointOption = (endpointOption as { model?: string })?.model;
+  const finalModel = (modelFromEndpointOption || modelFromConversation) as string | undefined;
+
+  // Extract resendFiles - default to true for agents endpoints if not specified
+  const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
+  const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+  const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
+  const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+
   const payload: t.TPayload = {
     ...userMessage,
     ...endpointOption,
@@ -40,6 +264,10 @@ export default function createPayload(submission: t.TSubmission) {
     conversationId,
     isContinued: !!(isEdited && isContinued),
     ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,
+    // Explicitly include model at top level for buildEndpointOption to find it
+    ...(finalModel ? { model: finalModel } : {}),
+    // Explicitly include resendFiles - always true for agents endpoints if not specified
+    ...(s.isAgentsEndpoint(endpoint) ? { resendFiles } : {}),
   };
 
   return { server, payload };

From d046c4e412489c13b157f08763ec3e81c8c022f5 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 15:35:36 +0000
Subject: [PATCH 49/94] checkout docker-compose.yml from main to rebase it

---
 docker-compose.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docker-compose.yml b/docker-compose.yml
index 61f214f34773..079cdb74b6de 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -28,8 +28,6 @@ services:
       - ./uploads:/app/uploads
       - ./logs:/app/logs
   mongodb:
-    ports:
-      - "27017:27017"
     container_name: chat-mongodb
     image: mongo:8.0.17
     restart: always

From cc05a651a837f7c1e0948f3f162ae4b624329bde Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 15:48:33 +0000
Subject: [PATCH 50/94] used N3 for parsing rather than Regex

---
 api/server/services/SolidStorage.js | 126 ++++++++--------------------
 1 file changed, 36 insertions(+), 90 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 022dc6a3a778..fb61d0d5d52e 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1,6 +1,28 @@
 const { logger } = require('@librechat/data-schemas');
 const fetch = require('node-fetch');
-const { DataFactory, Writer } = require('n3');
+const { DataFactory, Writer, Parser } = require('n3');
+
+// LDP (Linked Data Platform) namespace for parsing container Turtle responses
+const LDP_NS = 'http://www.w3.org/ns/ldp#';
+
+/**
+ * Parse Turtle RDF and extract all ldp:contains object URLs.
+ * Uses N3 parser instead of regex for correct handling of Turtle format.
+ * @param {string} text - Raw Turtle response body
+ * @param {string} baseUrl - Base IRI for resolving relative URLs
+ * @returns {string[]} Absolute URLs of contained resources
+ */
+function parseLdpContainsFromTurtle(text, baseUrl) {
+  const parser = new Parser({ baseIRI: baseUrl });
+  const quads = parser.parse(text);
+  return quads
+    .filter((q) => q.predicate.value === `${LDP_NS}contains`)
+    .map((q) => q.object)
+    .filter((obj) => obj && obj.termType === 'NamedNode')
+    .map((obj) =>
+      obj.value.startsWith('http') ? obj.value : new URL(obj.value, baseUrl).href
+    );
+}
 const {
   getFile,
   saveFileInContainer,
@@ -620,31 +642,11 @@ async function getMessagesFromSolid(req, conversationId) {
         throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
       }
       
-      // Parse the response (Solid containers return Turtle format)
-      // Format: ldp:contains <item1>, <item2>, <item3>.
+      // Parse the response with N3 (Solid containers return Turtle RDF with ldp:contains)
       const text = await response.text();
-      
-      // Parse Turtle format to extract all items from ldp:contains
-      // Handle both single and comma-separated items
-      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
-      const allItems = [];
-      let match;
-      
-      while ((match = ldpContainsPattern.exec(text)) !== null) {
-        // Extract all URLs from the matched group (handles comma-separated items)
-        const itemsString = match[1];
-        const itemPattern = /<([^>]+)>/g;
-        let itemMatch;
-        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
-          const itemUrl = itemMatch[1];
-          // Convert relative URLs to absolute URLs
-          const absoluteUrl = itemUrl.startsWith('http') 
-            ? itemUrl 
-            : new URL(itemUrl, messagesContainerPath).href;
-          allItems.push({ url: absoluteUrl });
-        }
-      }
-      
+      const containedUrls = parseLdpContainsFromTurtle(text, messagesContainerPath);
+      const allItems = containedUrls.map((url) => ({ url }));
+
       // Filter for JSON files only
       messageFiles = allItems.filter((item) => {
         const url = item.url || '';
@@ -804,27 +806,10 @@ async function updateMessageInSolid(req, messageData, metadata) {
         
         if (response.ok) {
           const text = await response.text();
-          // Parse Turtle format to extract conversation directories
-          const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
-          const allItems = [];
-          let match;
-          
-          while ((match = ldpContainsPattern.exec(text)) !== null) {
-            const itemsString = match[1];
-            const itemPattern = /<([^>]+)>/g;
-            let itemMatch;
-            while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
-              const itemUrl = itemMatch[1];
-              // Only include directories (ending with /)
-              if (itemUrl.endsWith('/')) {
-                const absoluteUrl = itemUrl.startsWith('http') 
-                  ? itemUrl 
-                  : new URL(itemUrl, messagesContainerPath).href;
-                allItems.push(absoluteUrl);
-              }
-            }
-          }
-          
+          const containedUrls = parseLdpContainsFromTurtle(text, messagesContainerPath);
+          // Only include directories (ending with /)
+          const allItems = containedUrls.filter((url) => url.endsWith('/'));
+
           logger.debug('[SolidStorage] Searching for message across conversation directories', {
             messageId: messageData.messageId,
             directoryCount: allItems.length,
@@ -1533,33 +1518,10 @@ async function getConvosByCursorFromSolid(req, options = {}) {
         throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
       }
       
-      // Parse the response as text (Solid containers return Turtle format)
-      // Format: ldp:contains <item1>, <item2>, <item3>.
+      // Parse with N3 (Solid containers return Turtle RDF with ldp:contains)
       const text = await response.text();
-      
-      // Parse Turtle format to extract all items from ldp:contains
-      // Handle both single and comma-separated items: ldp:contains <item1>, <item2>.
-      // TODO: Use RDF object mapper to parse this.
-      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
-      const allItems = [];
-      let match;
-      
-      while ((match = ldpContainsPattern.exec(text)) !== null) {
-        // Extract all URLs from the matched group (handles comma-separated items)
-        const itemsString = match[1];
-        const itemPattern = /<([^>]+)>/g;
-        let itemMatch;
-        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
-          const itemUrl = itemMatch[1];
-          // Convert relative URLs to absolute URLs
-          const absoluteUrl = itemUrl.startsWith('http') 
-            ? itemUrl 
-            : new URL(itemUrl, conversationsContainerPath).href;
-          allItems.push({ url: absoluteUrl });
-        }
-      }
-      
-      containerContents = allItems;
+      const containedUrls = parseLdpContainsFromTurtle(text, conversationsContainerPath);
+      containerContents = containedUrls.map((url) => ({ url }));
       
       logger.debug('[SolidStorage] Container contents retrieved', {
         conversationsContainerPath,
@@ -2735,24 +2697,8 @@ async function getSharedMessagesFromSolid(shareId, conversationId, podUrl, targe
       }
 
       const containerText = await containerResponse.text();
-      
-      // Parse Turtle format to extract all items from ldp:contains
-      const ldpContainsPattern = /ldp:contains\s+((?:<[^>]+>(?:\s*,\s*<[^>]+>)*))/g;
-      const allItems = [];
-      let match;
-      
-      while ((match = ldpContainsPattern.exec(containerText)) !== null) {
-        const itemsString = match[1];
-        const itemPattern = /<([^>]+)>/g;
-        let itemMatch;
-        while ((itemMatch = itemPattern.exec(itemsString)) !== null) {
-          const itemUrl = itemMatch[1];
-          const absoluteUrl = itemUrl.startsWith('http') 
-            ? itemUrl 
-            : new URL(itemUrl, messagesContainerPath).href;
-          allItems.push({ url: absoluteUrl });
-        }
-      }
+      const containedUrls = parseLdpContainsFromTurtle(containerText, messagesContainerPath);
+      const allItems = containedUrls.map((url) => ({ url }));
 
       // Filter for JSON files only
       const containerContents = allItems.filter((item) => {

From 69abfea059ea73caf48e926b9be8a9457d5d0979 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 16:08:59 +0000
Subject: [PATCH 51/94] ran npm run lint:fix to fix ESLint build fail

---
 api/models/Conversation.js                  |  13 +-
 api/models/Message.js                       |   2 +-
 api/server/controllers/AuthController.js    |   4 +-
 api/server/controllers/agents/request.js    |   6 +-
 api/server/middleware/requireJwtAuth.js     |   5 +-
 api/server/routes/convos.js                 |  10 +-
 api/server/routes/messages.js               |  14 +-
 api/server/routes/oauth.js                  |   6 +-
 api/server/routes/share.js                  |  13 +-
 api/server/services/AuthService.js          |   4 +-
 api/server/services/SolidStorage.js         | 474 ++++++++++++--------
 api/strategies/SolidOpenidStrategy.js       |  10 +-
 client/src/data-provider/SSE/queries.ts     |   2 +-
 config/create-user.js                       |   8 +-
 packages/api/src/utils/graph.spec.ts        |  10 +-
 packages/api/src/utils/graph.ts             |  24 +-
 packages/data-provider/src/config.ts        |  10 +-
 packages/data-provider/src/createPayload.ts | 187 +++++---
 packages/data-schemas/src/methods/share.ts  | 120 ++---
 19 files changed, 550 insertions(+), 372 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 8835acf0d5f3..c47bcd5a94f4 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -18,7 +18,7 @@ const {
  */
 const searchConversation = async (conversationId, req = null) => {
   try {
-    // Solid users: use Solid storage only; no MongoDB fallback 
+    // Solid users: use Solid storage only; no MongoDB fallback
     if (isSolidUser(req)) {
       const convo = await getConvoFromSolid(req, conversationId);
       if (convo) {
@@ -45,7 +45,7 @@ const searchConversation = async (conversationId, req = null) => {
  * @returns {Promise<TConversation>} The conversation object.
  */
 const getConvo = async (user, conversationId, req = null) => {
-  // Solid users: use Solid storage only; no MongoDB fallback 
+  // Solid users: use Solid storage only; no MongoDB fallback
   if (isSolidUser(req)) {
     const convo = await getConvoFromSolid(req, conversationId);
     return convo ?? null;
@@ -223,7 +223,6 @@ module.exports = {
       req, // Optional req object for Solid storage
     } = {},
   ) => {
-
     if (isSolidUser(req)) {
       return await getConvosByCursorFromSolid(req, {
         cursor,
@@ -431,16 +430,16 @@ module.exports = {
 
           // Filter conversations based on the filter criteria
           let filteredConversations = allConversations.conversations;
-          
+
           if (filter.conversationId) {
             filteredConversations = filteredConversations.filter(
-              (c) => c.conversationId === filter.conversationId
+              (c) => c.conversationId === filter.conversationId,
             );
           }
-          
+
           if (filter.endpoint) {
             filteredConversations = filteredConversations.filter(
-              (c) => c.endpoint === filter.endpoint
+              (c) => c.endpoint === filter.endpoint,
             );
           }
 
diff --git a/api/models/Message.js b/api/models/Message.js
index 31fa1882d73f..59d01a5bbd92 100644
--- a/api/models/Message.js
+++ b/api/models/Message.js
@@ -267,7 +267,7 @@ async function updateMessage(req, message, metadata) {
   if (isSolidUser(req)) {
     try {
       const updatedMessage = await updateMessageInSolid(req, message, metadata);
-      
+
       return {
         messageId: updatedMessage.messageId,
         conversationId: updatedMessage.conversationId,
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 8810aa9df4e9..5d1b3deb0f28 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -75,7 +75,9 @@ const refreshController = async (req, res) => {
 
     if (!refreshToken) {
       // Solid provider may not provide refresh tokens - fall back to standard JWT refresh
-      logger.warn('[refreshController] No OpenID refresh token available, falling back to standard refresh');
+      logger.warn(
+        '[refreshController] No OpenID refresh token available, falling back to standard refresh',
+      );
       // Fall through to standard refresh logic below
     } else {
       // We have a refresh token, use OpenID refresh flow
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index b39426b4736d..db8527993630 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -313,8 +313,8 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
             textLength: response.text?.length || 0,
             hasContent: !!response.content,
             contentLength: Array.isArray(response.content) ? response.content.length : 0,
-            contentTypes: Array.isArray(response.content) 
-              ? response.content.map(c => c?.type).filter(Boolean)
+            contentTypes: Array.isArray(response.content)
+              ? response.content.map((c) => c?.type).filter(Boolean)
               : [],
           });
           await saveMessage(
@@ -334,7 +334,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
           // Emit the final event to all subscribers
           GenerationJobManager.emitDone(streamId, finalEvent);
           await decrementPendingRequest(userId);
-          
+
           // Complete the job AFTER emitting FINAL and saving messages
           // This ensures the frontend receives the FINAL event while the job is still active
           GenerationJobManager.completeJob(streamId);
diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index f95672c717ff..93ee07fccbea 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -21,9 +21,10 @@ const requireJwtAuth = (req, res, next) => {
       return res.status(401).json({ error: 'Authentication failed', message: err.message });
     }
     if (!user) {
-      return res.status(401).json({ 
+      return res.status(401).json({
         error: 'Authentication required',
-        message: 'No valid JWT token found. Make sure you are logged in and the Authorization header is sent.',
+        message:
+          'No valid JWT token found. Make sure you are logged in and the Authorization header is sent.',
         hint: 'Access this endpoint via the frontend app, or include Authorization: Bearer <token> header',
       });
     }
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index ab8b93aa8518..081206103443 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -60,7 +60,7 @@ router.get('/', async (req, res) => {
       userId: req.user?.id,
       isSolidUser: isSolidUser(req),
     });
-    res.status(500).json({ 
+    res.status(500).json({
       error: 'Error fetching conversations',
       message: error.message, // Include actual error message for debugging
     });
@@ -69,13 +69,13 @@ router.get('/', async (req, res) => {
 
 router.get('/:conversationId', async (req, res) => {
   const { conversationId } = req.params;
-  
+
   logger.info('[GET /api/convos/:conversationId] Fetching conversation', {
     conversationId,
     userId: req.user?.id,
     isSolidUser: isSolidUser(req),
   });
-  
+
   try {
     const convo = await getConvo(req.user.id, conversationId, req);
 
@@ -166,8 +166,8 @@ router.delete('/', async (req, res) => {
   try {
     const dbResponse = await deleteConvos(req.user.id, filter, req); // Pass req for Solid storage support
     if (filter.conversationId) {
-          await deleteToolCalls(req.user.id, filter.conversationId);
-          await deleteConvoSharedLink(req.user.id, filter.conversationId, req);
+      await deleteToolCalls(req.user.id, filter.conversationId);
+      await deleteConvoSharedLink(req.user.id, filter.conversationId, req);
     }
     res.status(201).json(dbResponse);
   } catch (error) {
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index cbbd57b20873..3775913fb2d3 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -42,11 +42,10 @@ router.get('/', async (req, res) => {
     const sortOrder = sortDirection === 'asc' ? 1 : -1;
 
     if (conversationId && messageId) {
-     
       if (isSolidUser(req)) {
         try {
           const allMessages = await getMessagesFromSolid(req, conversationId);
-          const message = allMessages.find(m => m.messageId === messageId);
+          const message = allMessages.find((m) => m.messageId === messageId);
           response = { messages: message ? [message] : [], nextCursor: null };
         } catch (error) {
           logger.error('Error getting message from Solid Pod', error);
@@ -69,23 +68,23 @@ router.get('/', async (req, res) => {
       if (isSolidUser(req)) {
         try {
           const allMessages = await getMessagesFromSolid(req, conversationId);
-          
+
           // Apply sorting
           allMessages.sort((a, b) => {
             const aVal = a[sortField] || 0;
             const bVal = b[sortField] || 0;
             return sortOrder === 1 ? aVal - bVal : bVal - aVal;
           });
-          
+
           // Apply cursor filtering if provided
           let filteredMessages = allMessages;
           if (cursor) {
-            filteredMessages = allMessages.filter(msg => {
+            filteredMessages = allMessages.filter((msg) => {
               const msgVal = msg[sortField] || 0;
               return sortOrder === 1 ? msgVal > cursor : msgVal < cursor;
             });
           }
-          
+
           // Apply pagination
           const messages = filteredMessages.slice(0, pageSize + 1);
           let nextCursor = null;
@@ -340,12 +339,11 @@ router.post('/artifact/:messageId', async (req, res) => {
 router.get('/:conversationId', validateMessageReq, async (req, res) => {
   try {
     const { conversationId } = req.params;
-    
 
     if (isSolidUser(req)) {
       try {
         const messages = await getMessagesFromSolid(req, conversationId);
-        const cleanedMessages = messages.map(msg => {
+        const cleanedMessages = messages.map((msg) => {
           const { _id, __v, user, ...rest } = msg;
           return rest;
         });
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 98469fb76eff..9d081ebd348d 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -51,7 +51,7 @@ const oauthHandler = async (req, res, next) => {
         hasAccessToken: !!req.user.tokenset.access_token,
         hasRefreshToken: !!req.user.tokenset.refresh_token,
       });
-      
+
       // Also create JWT tokens for frontend authentication
       // OPENID_REUSE_TOKENS determines if we use OpenID JWT or standard JWT
       if (isEnabled(process.env.OPENID_REUSE_TOKENS) === true) {
@@ -147,7 +147,7 @@ router.get('/openid', (req, res, next) => {
  */
 const logAuthorizationCode = (req, res, next) => {
   const { code, state, error } = req.query;
-  
+
   if (code) {
     logger.info('[OpenID Callback] Authorization code received from Solid provider', {
       authorizationCode: code,
@@ -171,7 +171,7 @@ const logAuthorizationCode = (req, res, next) => {
       queryParams: req.query,
     });
   }
-  
+
   next();
 };
 
diff --git a/api/server/routes/share.js b/api/server/routes/share.js
index e850c76ab6c2..bb373443f1c3 100644
--- a/api/server/routes/share.js
+++ b/api/server/routes/share.js
@@ -100,15 +100,20 @@ router.get('/link/:conversationId', requireJwtAuth, async (req, res) => {
 router.post('/:conversationId', requireJwtAuth, async (req, res) => {
   try {
     const { targetMessageId } = req.body;
-    
+
     // Check if createSharedLink exists
     if (typeof createSharedLink !== 'function') {
       logger.error('[share route] createSharedLink is not a function');
       return res.status(500).json({ message: 'Share service not available' });
     }
-    
-    const created = await createSharedLink(req.user.id, req.params.conversationId, targetMessageId, req);
-    
+
+    const created = await createSharedLink(
+      req.user.id,
+      req.params.conversationId,
+      targetMessageId,
+      req,
+    );
+
     if (created) {
       res.status(200).json(created);
     } else {
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index 43468190d408..f68cbf901352 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -488,7 +488,7 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
         refreshToken: refreshToken || null, // Store null if no refresh token
         expiresAt: expirationDate.getTime(),
       };
-      
+
       // Explicitly save the session to ensure it persists
       req.session.save((err) => {
         if (err) {
@@ -500,7 +500,7 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
           logger.debug('[setOpenIDAuthTokens] Session saved successfully');
         }
       });
-      
+
       logger.info('[setOpenIDAuthTokens] Tokens stored in session', {
         hasAccessToken: !!tokenset.access_token,
         hasRefreshToken: !!refreshToken,
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index fb61d0d5d52e..430fcc9fce30 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -19,9 +19,7 @@ function parseLdpContainsFromTurtle(text, baseUrl) {
     .filter((q) => q.predicate.value === `${LDP_NS}contains`)
     .map((q) => q.object)
     .filter((obj) => obj && obj.termType === 'NamedNode')
-    .map((obj) =>
-      obj.value.startsWith('http') ? obj.value : new URL(obj.value, baseUrl).href
-    );
+    .map((obj) => (obj.value.startsWith('http') ? obj.value : new URL(obj.value, baseUrl).href));
 }
 const {
   getFile,
@@ -39,10 +37,10 @@ const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
 
 /**
  * Solid Storage Utility Module
- * 
+ *
  * This module provides functions to interact with Solid Pods for storing
  * and retrieving messages and conversations.
- * 
+ *
  * Storage Structure:
  * {podUrl}/librechat/
  *   ├── conversations/
@@ -54,7 +52,7 @@ const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
 
 /**
  * Get authenticated fetch function from Solid session
- * 
+ *
  * @param {Object} req - Express request object
  * @returns {Promise<Function>} Authenticated fetch function
  */
@@ -81,7 +79,7 @@ async function getSolidFetch(req) {
     let tokenSource = 'unknown';
 
     // Try to get access token from multiple sources (in order of preference)
-    
+
     // Source 1: Session (tokens stored during OAuth callback)
     const openidTokens = req.session?.openidTokens;
     if (openidTokens && openidTokens.accessToken) {
@@ -93,7 +91,7 @@ async function getSolidFetch(req) {
         isExpired: openidTokens.expiresAt ? Date.now() > openidTokens.expiresAt : 'unknown',
       });
     }
-    
+
     // Source 2: Cookies (fallback if session not available)
     if (!accessToken && req.cookies?.openid_access_token) {
       accessToken = req.cookies.openid_access_token;
@@ -102,7 +100,7 @@ async function getSolidFetch(req) {
         tokenLength: accessToken?.length,
       });
     }
-    
+
     // Source 3: User object tokenset (from OAuth callback - if stored in DB)
     if (!accessToken && req.user.tokenset && req.user.tokenset.access_token) {
       accessToken = req.user.tokenset.access_token;
@@ -111,7 +109,7 @@ async function getSolidFetch(req) {
         tokenLength: accessToken?.length,
       });
     }
-    
+
     // Source 4: User object federatedTokens (from OAuth callback - if stored in DB)
     if (!accessToken && req.user.federatedTokens && req.user.federatedTokens.access_token) {
       accessToken = req.user.federatedTokens.access_token;
@@ -140,7 +138,9 @@ async function getSolidFetch(req) {
         cookieKeys: req.cookies ? Object.keys(req.cookies) : [],
         allCookies: req.cookies ? Object.keys(req.cookies).join(', ') : 'none',
       });
-      throw new Error('No OpenID access token found. Make sure you logged in via Solid-OIDC and the session is maintained.');
+      throw new Error(
+        'No OpenID access token found. Make sure you logged in via Solid-OIDC and the session is maintained.',
+      );
     }
     logger.info('[SolidStorage] Access token retrieved', {
       tokenSource,
@@ -153,7 +153,7 @@ async function getSolidFetch(req) {
     const authenticatedFetch = async (url, options = {}) => {
       const headers = {
         ...options.headers,
-        'Authorization': `Bearer ${accessToken}`,
+        Authorization: `Bearer ${accessToken}`,
         'Content-Type': options.headers?.['Content-Type'] || 'application/json',
       };
 
@@ -209,7 +209,7 @@ async function getSolidFetch(req) {
 
 /**
  * Get user's Pod URL from their WebID
- * 
+ *
  * @param {string} webId - User's WebID
  * @param {Function} fetch - Authenticated fetch function
  * @returns {Promise<string>} Primary Pod URL
@@ -247,7 +247,7 @@ async function getPodUrl(webId, fetch) {
     // If no Pod URLs found, derive from WebID as fallback
     if (!podUrls || podUrls.length === 0) {
       logger.info('[SolidStorage] No Pod URLs found in profile, deriving from WebID', { webId });
-      
+
       // Extract base URL from WebID
       // WebID format: http://localhost:3000/bisi/profile/card#me
       // Pod URL format: http://localhost:3000/bisi/
@@ -256,8 +256,8 @@ async function getPodUrl(webId, fetch) {
         // Remove the fragment (#me) and path segments after the pod identifier
         // For most Solid servers, the Pod is at the root or one level deep
         // Pattern: http://host:port/podId/ -> Pod URL
-        const pathParts = webIdUrl.pathname.split('/').filter(p => p);
-        
+        const pathParts = webIdUrl.pathname.split('/').filter((p) => p);
+
         // If path contains 'profile', 'card', or similar, remove them
         // The Pod is usually at the base or one level up
         let podPath = '/';
@@ -269,14 +269,14 @@ async function getPodUrl(webId, fetch) {
             podPath = `/${podIdentifier}/`;
           }
         }
-        
+
         const derivedPodUrl = `${webIdUrl.protocol}//${webIdUrl.host}${podPath}`;
         logger.info('[SolidStorage] Derived Pod URL from WebID', {
           webId,
           derivedPodUrl,
           pathParts,
         });
-        
+
         // Verify the Pod URL is accessible by trying to fetch the root
         try {
           const response = await fetch(derivedPodUrl, {
@@ -296,7 +296,7 @@ async function getPodUrl(webId, fetch) {
             error: verifyError.message,
           });
         }
-        
+
         return derivedPodUrl;
       } catch (urlError) {
         logger.error('[SolidStorage] Failed to derive Pod URL from WebID', {
@@ -327,7 +327,7 @@ async function getPodUrl(webId, fetch) {
 
 /**
  * Get base storage path for LibreChat data in Pod
- * 
+ *
  * @param {string} podUrl - Pod URL
  * @returns {string} Base storage path
  */
@@ -339,7 +339,7 @@ function getBaseStoragePath(podUrl) {
 
 /**
  * Get conversation file path
- * 
+ *
  * @param {string} podUrl - Pod URL
  * @param {string} conversationId - Conversation ID
  * @returns {string} Conversation file path
@@ -352,7 +352,7 @@ function getConversationPath(podUrl, conversationId) {
 
 /**
  * Get messages container path for a conversation
- * 
+ *
  * @param {string} podUrl - Pod URL
  * @param {string} conversationId - Conversation ID
  * @returns {string} Messages container path
@@ -365,7 +365,7 @@ function getMessagesContainerPath(podUrl, conversationId) {
 
 /**
  * Get message file path
- * 
+ *
  * @param {string} podUrl - Pod URL
  * @param {string} conversationId - Conversation ID
  * @param {string} messageId - Message ID
@@ -379,7 +379,7 @@ function getMessagePath(podUrl, conversationId, messageId) {
 
 /**
  * Ensure container exists, create if it doesn't
- * 
+ *
  * @param {string} containerUrl - Container URL
  * @param {Function} fetch - Authenticated fetch function
  * @returns {Promise<void>}
@@ -393,31 +393,42 @@ async function ensureContainerExists(containerUrl, fetch) {
       const response = await fetch(containerUrl, {
         method: 'HEAD',
       });
-      
+
       if (response.ok || response.status === 200 || response.status === 405) {
         // Container exists (405 Method Not Allowed is also OK - means container exists but doesn't support HEAD)
-        logger.debug('[SolidStorage] Container already exists', { 
+        logger.debug('[SolidStorage] Container already exists', {
           containerUrl,
           status: response.status,
         });
         return;
       }
-      
+
       // If we get here, container might not exist
       if (response.status === 404) {
         throw new Error('Container not found');
       }
     } catch (error) {
       // Container doesn't exist, create it
-      if (error.status === 404 || error.message?.includes('404') || error.message?.includes('not found') || error.message?.includes('Container not found')) {
+      if (
+        error.status === 404 ||
+        error.message?.includes('404') ||
+        error.message?.includes('not found') ||
+        error.message?.includes('Container not found')
+      ) {
         logger.info('[SolidStorage] Container does not exist, creating', { containerUrl });
         try {
           await createContainerAt(containerUrl, { fetch });
           logger.info('[SolidStorage] Container created successfully', { containerUrl });
         } catch (createError) {
           // If creation fails with 409, container already exists (race condition)
-          if (createError.status === 409 || createError.message?.includes('409') || createError.message?.includes('already exists')) {
-            logger.debug('[SolidStorage] Container already exists (race condition)', { containerUrl });
+          if (
+            createError.status === 409 ||
+            createError.message?.includes('409') ||
+            createError.message?.includes('already exists')
+          ) {
+            logger.debug('[SolidStorage] Container already exists (race condition)', {
+              containerUrl,
+            });
             return;
           }
           throw createError;
@@ -444,7 +455,7 @@ async function ensureContainerExists(containerUrl, fetch) {
 
 /**
  * Ensure base storage structure exists
- * 
+ *
  * @param {string} podUrl - Pod URL
  * @param {Function} fetch - Authenticated fetch function
  * @returns {Promise<void>}
@@ -519,7 +530,7 @@ async function saveMessageToSolid(req, messageDocument, metadata) {
     const messagePath = getMessagePath(
       podUrl,
       messageDocument.conversationId,
-      messageDocument.messageId
+      messageDocument.messageId,
     );
 
     const messageJson = JSON.stringify(messageDocument, null, 2);
@@ -587,7 +598,7 @@ async function saveMessageToSolid(req, messageDocument, metadata) {
 
 /**
  * Get all messages for a conversation from Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {string} conversationId - Conversation ID
  * @returns {Promise<Array>} Array of message objects, sorted by createdAt
@@ -626,10 +637,10 @@ async function getMessagesFromSolid(req, conversationId) {
       const response = await authenticatedFetch(messagesContainerPath, {
         method: 'GET',
         headers: {
-          'Accept': 'text/turtle, application/ld+json, */*',
+          Accept: 'text/turtle, application/ld+json, */*',
         },
       });
-      
+
       if (response.status === 404) {
         // Container doesn't exist, return empty array
         logger.info('[SolidStorage] Messages container does not exist, returning empty array', {
@@ -637,11 +648,13 @@ async function getMessagesFromSolid(req, conversationId) {
         });
         return [];
       }
-      
+
       if (!response.ok) {
-        throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
+        throw new Error(
+          `Failed to get container contents: ${response.status} ${response.statusText}`,
+        );
       }
-      
+
       // Parse the response with N3 (Solid containers return Turtle RDF with ldp:contains)
       const text = await response.text();
       const containedUrls = parseLdpContainsFromTurtle(text, messagesContainerPath);
@@ -652,11 +665,11 @@ async function getMessagesFromSolid(req, conversationId) {
         const url = item.url || '';
         return url.endsWith('.json') && !url.endsWith('.meta.json');
       });
-      
+
       logger.debug('[SolidStorage] Found message files', {
         conversationId,
         fileCount: messageFiles.length,
-        files: messageFiles.map(f => f.url),
+        files: messageFiles.map((f) => f.url),
       });
     } catch (error) {
       if (error.status === 404 || error.message?.includes('404')) {
@@ -744,7 +757,7 @@ async function getMessagesFromSolid(req, conversationId) {
 
 /**
  * Update an existing message in Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {Object} messageData - Message data to update
  * @param {string} messageData.messageId - Message ID (required)
@@ -785,25 +798,28 @@ async function updateMessageInSolid(req, messageData, metadata) {
 
     // If conversationId is not provided, we need to find it from the existing message
     if (!conversationId) {
-      logger.warn('[SolidStorage] conversationId not provided in update, searching for message in Pod', {
-        messageId: messageData.messageId,
-        updateFields: Object.keys(messageData),
-      });
-      
+      logger.warn(
+        '[SolidStorage] conversationId not provided in update, searching for message in Pod',
+        {
+          messageId: messageData.messageId,
+          updateFields: Object.keys(messageData),
+        },
+      );
+
       // Search for the message across all conversation message containers
       // We'll check the messages container for all conversation subdirectories
       const basePath = getBaseStoragePath(podUrl);
       const messagesContainerPath = `${basePath}messages/`;
-      
+
       try {
         // Get list of all conversation directories in messages container
         const response = await authenticatedFetch(messagesContainerPath, {
           method: 'GET',
           headers: {
-            'Accept': 'text/turtle, application/ld+json, */*',
+            Accept: 'text/turtle, application/ld+json, */*',
           },
         });
-        
+
         if (response.ok) {
           const text = await response.text();
           const containedUrls = parseLdpContainsFromTurtle(text, messagesContainerPath);
@@ -814,18 +830,18 @@ async function updateMessageInSolid(req, messageData, metadata) {
             messageId: messageData.messageId,
             directoryCount: allItems.length,
           });
-          
+
           // Search each conversation directory for the message
           for (const conversationDir of allItems) {
             try {
               const messageFileUrl = `${conversationDir}${messageData.messageId}.json`;
               const fileResponse = await authenticatedFetch(messageFileUrl, { method: 'HEAD' });
-              
+
               if (fileResponse.ok) {
                 // Found the message! Extract conversationId from the directory path
                 // Format: .../messages/{conversationId}/
                 const pathParts = conversationDir.split('/');
-                const conversationIdIndex = pathParts.findIndex(part => part === 'messages') + 1;
+                const conversationIdIndex = pathParts.findIndex((part) => part === 'messages') + 1;
                 if (conversationIdIndex > 0 && pathParts[conversationIdIndex]) {
                   conversationId = pathParts[conversationIdIndex];
                   logger.info('[SolidStorage] Found conversationId from message location', {
@@ -859,10 +875,12 @@ async function updateMessageInSolid(req, messageData, metadata) {
           stack: searchError.stack,
         });
       }
-      
+
       // If we still don't have conversationId, throw error
       if (!conversationId) {
-        const error = new Error('conversationId is required for updating messages. Could not find message in Pod to determine conversationId.');
+        const error = new Error(
+          'conversationId is required for updating messages. Could not find message in Pod to determine conversationId.',
+        );
         logger.error('[SolidStorage] Failed to find conversationId for message update', {
           messageId: messageData.messageId,
           updateFields: Object.keys(messageData),
@@ -950,7 +968,7 @@ async function updateMessageInSolid(req, messageData, metadata) {
 
 /**
  * Delete messages from Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {Object} params - Delete parameters
  * @param {string} params.conversationId - Conversation ID (required)
@@ -1019,7 +1037,11 @@ async function deleteMessagesFromSolid(req, params) {
       });
     }
     // Case 2: Delete specific message IDs
-    else if (params.messageIds && Array.isArray(params.messageIds) && params.messageIds.length > 0) {
+    else if (
+      params.messageIds &&
+      Array.isArray(params.messageIds) &&
+      params.messageIds.length > 0
+    ) {
       messagesToDelete = allMessages.filter((msg) => params.messageIds.includes(msg.messageId));
       logger.debug('[SolidStorage] Filtering specific message IDs', {
         requestedIds: params.messageIds.length,
@@ -1046,7 +1068,7 @@ async function deleteMessagesFromSolid(req, params) {
     for (const message of messagesToDelete) {
       try {
         const messagePath = getMessagePath(podUrl, params.conversationId, message.messageId);
-        
+
         logger.debug('[SolidStorage] Deleting message file', {
           messagePath,
           messageId: message.messageId,
@@ -1172,7 +1194,8 @@ async function saveConvoToSolid(req, convoDocument, metadata) {
 
     convoDocument.messages = messageRefs;
     convoDocument.updatedAt = new Date().toISOString();
-    convoDocument.createdAt = convoDocument.createdAt || existingConversation?.createdAt || new Date().toISOString();
+    convoDocument.createdAt =
+      convoDocument.createdAt || existingConversation?.createdAt || new Date().toISOString();
 
     const previousConversationId = convoDocument.previousConversationId;
     delete convoDocument.previousConversationId;
@@ -1247,7 +1270,7 @@ async function saveConvoToSolid(req, convoDocument, metadata) {
 
 /**
  * Get a single conversation from Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {string} conversationId - Conversation ID
  * @returns {Promise<Object|null>} Conversation object or null if not found
@@ -1305,13 +1328,17 @@ async function getConvoFromSolid(req, conversationId) {
         });
         return null;
       }
-      
-      if (conversationUserId && typeof conversationUserId === 'object' && conversationUserId.toString) {
+
+      if (
+        conversationUserId &&
+        typeof conversationUserId === 'object' &&
+        conversationUserId.toString
+      ) {
         conversationUserId = conversationUserId.toString();
       } else {
         conversationUserId = String(conversationUserId || '');
       }
-      
+
       let currentUserId = req.user.id;
       if (!currentUserId) {
         logger.error('[SolidStorage] Request has no user ID - RETURNING NULL', {
@@ -1321,17 +1348,17 @@ async function getConvoFromSolid(req, conversationId) {
         });
         return null;
       }
-      
+
       if (currentUserId && typeof currentUserId === 'object' && currentUserId.toString) {
         currentUserId = currentUserId.toString();
       } else {
         currentUserId = String(currentUserId || '');
       }
-      
+
       // Trim whitespace and compare
       conversationUserId = conversationUserId.trim();
       currentUserId = currentUserId.trim();
-      
+
       logger.info('[SolidStorage] Comparing user IDs in getConvoFromSolid', {
         conversationId,
         conversationUserIdRaw: conversationData.user,
@@ -1344,10 +1371,10 @@ async function getConvoFromSolid(req, conversationId) {
         conversationUserIdLength: conversationUserId.length,
         currentUserIdLength: currentUserId.length,
         areEqual: conversationUserId === currentUserId,
-        conversationUserIdCharCodes: conversationUserId.split('').map(c => c.charCodeAt(0)),
-        currentUserIdCharCodes: currentUserId.split('').map(c => c.charCodeAt(0)),
+        conversationUserIdCharCodes: conversationUserId.split('').map((c) => c.charCodeAt(0)),
+        currentUserIdCharCodes: currentUserId.split('').map((c) => c.charCodeAt(0)),
       });
-      
+
       if (conversationUserId !== currentUserId) {
         logger.error('[SolidStorage] Conversation belongs to different user - RETURNING NULL', {
           conversationId,
@@ -1360,8 +1387,8 @@ async function getConvoFromSolid(req, conversationId) {
           conversationUserIdLength: conversationUserId.length,
           currentUserIdLength: currentUserId.length,
           areEqual: conversationUserId === currentUserId,
-          conversationUserIdCharCodes: conversationUserId.split('').map(c => c.charCodeAt(0)),
-          currentUserIdCharCodes: currentUserId.split('').map(c => c.charCodeAt(0)),
+          conversationUserIdCharCodes: conversationUserId.split('').map((c) => c.charCodeAt(0)),
+          currentUserIdCharCodes: currentUserId.split('').map((c) => c.charCodeAt(0)),
         });
         return null;
       }
@@ -1370,10 +1397,10 @@ async function getConvoFromSolid(req, conversationId) {
       if (!conversationData.model || !conversationData.endpoint) {
         try {
           const messages = await getMessagesFromSolid(req, conversationId);
-          
+
           // Find the first message with a model (usually the AI response)
-          const messageWithModel = messages.find(msg => msg.model && msg.endpoint);
-          
+          const messageWithModel = messages.find((msg) => msg.model && msg.endpoint);
+
           if (messageWithModel) {
             if (!conversationData.model && messageWithModel.model) {
               logger.info('[SolidStorage] Extracting model from messages', {
@@ -1382,7 +1409,7 @@ async function getConvoFromSolid(req, conversationId) {
               });
               conversationData.model = messageWithModel.model;
             }
-            
+
             if (!conversationData.endpoint && messageWithModel.endpoint) {
               logger.info('[SolidStorage] Extracting endpoint from messages', {
                 conversationId,
@@ -1432,7 +1459,7 @@ async function getConvoFromSolid(req, conversationId) {
 
 /**
  * Get conversations with cursor-based pagination from Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {Object} options - Query options
  * @param {string} [options.cursor] - Base64-encoded cursor for pagination
@@ -1502,38 +1529,44 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       const response = await authenticatedFetch(conversationsContainerPath, {
         method: 'GET',
         headers: {
-          'Accept': 'text/turtle, application/ld+json, */*',
+          Accept: 'text/turtle, application/ld+json, */*',
         },
       });
-      
+
       if (response.status === 404) {
         // Container doesn't exist, return empty result
-        logger.info('[SolidStorage] Conversations container does not exist (404), returning empty array', {
-          conversationsContainerPath,
-        });
+        logger.info(
+          '[SolidStorage] Conversations container does not exist (404), returning empty array',
+          {
+            conversationsContainerPath,
+          },
+        );
         return { conversations: [], nextCursor: null };
       }
-      
+
       if (!response.ok) {
-        throw new Error(`Failed to get container contents: ${response.status} ${response.statusText}`);
+        throw new Error(
+          `Failed to get container contents: ${response.status} ${response.statusText}`,
+        );
       }
-      
+
       // Parse with N3 (Solid containers return Turtle RDF with ldp:contains)
       const text = await response.text();
       const containedUrls = parseLdpContainsFromTurtle(text, conversationsContainerPath);
       containerContents = containedUrls.map((url) => ({ url }));
-      
+
       logger.debug('[SolidStorage] Container contents retrieved', {
         conversationsContainerPath,
         itemCount: containerContents.length,
-        items: containerContents.map(c => c.url),
+        items: containerContents.map((c) => c.url),
       });
     } catch (error) {
       // Log full error details for debugging
       const errorMessage = error?.message || String(error) || 'Unknown error';
-      const errorStatus = error?.status || error?.statusCode || error?.response?.status || 'no status';
+      const errorStatus =
+        error?.status || error?.statusCode || error?.response?.status || 'no status';
       const errorName = error?.name || 'Unknown';
-      
+
       logger.warn('[SolidStorage] Error getting container contents', {
         conversationsContainerPath,
         errorMessage,
@@ -1546,36 +1579,42 @@ async function getConvosByCursorFromSolid(req, options = {}) {
         responseStatus: error?.response?.status,
         responseStatusText: error?.response?.statusText,
       });
-      
+
       // Check if error is a 404 (container doesn't exist)
-      const isNotFound = 
-        errorStatus === 404 || 
+      const isNotFound =
+        errorStatus === 404 ||
         errorStatus === '404' ||
-        errorMessage?.includes('404') || 
+        errorMessage?.includes('404') ||
         errorMessage?.includes('Not Found') ||
         errorMessage?.toLowerCase().includes('not found') ||
         errorMessage?.toLowerCase().includes('404');
-      
+
       if (isNotFound) {
         // Container doesn't exist, return empty result (this is expected for new users)
-        logger.info('[SolidStorage] Conversations container does not exist (404), returning empty array', {
-          conversationsContainerPath,
-          errorStatus,
-          errorMessage,
-        });
+        logger.info(
+          '[SolidStorage] Conversations container does not exist (404), returning empty array',
+          {
+            conversationsContainerPath,
+            errorStatus,
+            errorMessage,
+          },
+        );
         return { conversations: [], nextCursor: null };
       }
-      
+
       // Log unexpected errors but don't throw - return empty array instead
       // This prevents fallback to MongoDB when user is logged in via "Continue with Solid"
-      logger.warn('[SolidStorage] Unexpected error getting container contents, returning empty array', {
-        conversationsContainerPath,
-        errorMessage,
-        errorName,
-        errorStatus,
-        errorStack: error?.stack,
-      });
-      
+      logger.warn(
+        '[SolidStorage] Unexpected error getting container contents, returning empty array',
+        {
+          conversationsContainerPath,
+          errorMessage,
+          errorName,
+          errorStatus,
+          errorStack: error?.stack,
+        },
+      );
+
       // Return empty array instead of throwing to avoid MongoDB fallback
       return { conversations: [], nextCursor: null };
     }
@@ -1625,9 +1664,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
     if (isArchived) {
       filtered = filtered.filter((convo) => convo.isArchived === true);
     } else {
-      filtered = filtered.filter(
-        (convo) => !convo.isArchived || convo.isArchived === false,
-      );
+      filtered = filtered.filter((convo) => !convo.isArchived || convo.isArchived === false);
     }
 
     // Filter by tags
@@ -1666,19 +1703,22 @@ async function getConvosByCursorFromSolid(req, options = {}) {
         const op = finalSortDirection === 'asc' ? 'gt' : 'lt';
 
         filtered = filtered.filter((convo) => {
-          const convoPrimary = finalSortBy === 'title' ? convo[finalSortBy] : new Date(convo[finalSortBy]);
+          const convoPrimary =
+            finalSortBy === 'title' ? convo[finalSortBy] : new Date(convo[finalSortBy]);
           const convoSecondary = new Date(convo.updatedAt);
 
           if (op === 'gt') {
             return (
               convoPrimary > primaryValue ||
-              (convoPrimary.getTime && convoPrimary.getTime() === primaryValue.getTime() &&
+              (convoPrimary.getTime &&
+                convoPrimary.getTime() === primaryValue.getTime() &&
                 convoSecondary > secondaryValue)
             );
           } else {
             return (
               convoPrimary < primaryValue ||
-              (convoPrimary.getTime && convoPrimary.getTime() === primaryValue.getTime() &&
+              (convoPrimary.getTime &&
+                convoPrimary.getTime() === primaryValue.getTime() &&
                 convoSecondary < secondaryValue)
             );
           }
@@ -1732,7 +1772,8 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       limited.pop(); // Remove extra item used to detect next page
       const lastReturned = limited[limited.length - 1];
       const primaryValue = lastReturned[finalSortBy];
-      const primaryStr = finalSortBy === 'title' ? primaryValue : new Date(primaryValue).toISOString();
+      const primaryStr =
+        finalSortBy === 'title' ? primaryValue : new Date(primaryValue).toISOString();
       const secondaryStr = new Date(lastReturned.updatedAt).toISOString();
       const composite = { primary: primaryStr, secondary: secondaryStr };
       nextCursor = Buffer.from(JSON.stringify(composite)).toString('base64');
@@ -1776,7 +1817,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
 
 /**
  * Delete conversations from Solid Pod
- * 
+ *
  * @param {Object} req - Express request object
  * @param {Array<string>} conversationIds - Array of conversation IDs to delete
  * @returns {Promise<number>} Number of conversations deleted
@@ -1832,18 +1873,18 @@ async function deleteConvosFromSolid(req, conversationIds) {
           const messagesDeleted = await deleteMessagesFromSolid(req, {
             conversationId,
           });
-          
+
           logger.info('[SolidStorage] Messages deleted for conversation', {
             conversationId,
             messagesDeleted,
           });
-          
+
           if (messagesDeleted === 0) {
             logger.warn('[SolidStorage] No messages were deleted - this may indicate an issue', {
               conversationId,
             });
           }
-          
+
           // Also try to delete the messages container directory if it's empty
           // This is optional - some Solid servers handle empty containers automatically
           try {
@@ -1858,11 +1899,14 @@ async function deleteConvosFromSolid(req, conversationIds) {
               });
             } catch (containerError) {
               // It's okay if we can't delete the container - the files are already deleted
-              logger.debug('[SolidStorage] Could not delete messages container (may not be empty or not allowed)', {
-                conversationId,
-                messagesContainerPath,
-                error: containerError.message,
-              });
+              logger.debug(
+                '[SolidStorage] Could not delete messages container (may not be empty or not allowed)',
+                {
+                  conversationId,
+                  messagesContainerPath,
+                  error: containerError.message,
+                },
+              );
             }
           } catch (containerPathError) {
             // Ignore errors when trying to delete the container
@@ -1872,11 +1916,14 @@ async function deleteConvosFromSolid(req, conversationIds) {
             });
           }
         } catch (error) {
-          logger.error('[SolidStorage] Error deleting messages for conversation - THIS IS A PROBLEM', {
-            conversationId,
-            error: error.message,
-            stack: error.stack,
-          });
+          logger.error(
+            '[SolidStorage] Error deleting messages for conversation - THIS IS A PROBLEM',
+            {
+              conversationId,
+              error: error.message,
+              stack: error.stack,
+            },
+          );
           // Continue with conversation deletion even if messages fail
         }
 
@@ -1990,7 +2037,12 @@ async function fetchAcl(aclUrl, fetchFn) {
     return await response.text();
   } catch (error) {
     // Treat 404 and 403 as "no ACL exists"
-    if (error.status === 404 || error.status === 403 || error.message?.includes('404') || error.message?.includes('403')) {
+    if (
+      error.status === 404 ||
+      error.status === 403 ||
+      error.message?.includes('404') ||
+      error.message?.includes('403')
+    ) {
       return null;
     }
     throw error;
@@ -2017,51 +2069,53 @@ function hasPublicAccessInAcl(aclTurtle) {
 async function createPublicAcl(resourceUrl, aclUrl, isContainer = false, ownerWebId = null) {
   const { namedNode, blankNode, quad } = DataFactory;
   const quads = [];
-  
+
   // If owner WebID is provided, create Authorization for owner with full permissions
   if (ownerWebId) {
     const ownerAuthNode = blankNode('ownerAuth');
-    
+
     // Authorization: type
-    quads.push(quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
-    
+    quads.push(
+      quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)),
+    );
+
     // Authorization: agent (the owner)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}agent`), namedNode(ownerWebId)));
-    
+
     // Authorization: accessTo (the resource)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
-    
+
     // If this is a container, also add default access for resources within it
     if (isContainer) {
       quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
     }
-    
+
     // Authorization: mode (Write, Append, Control for owner)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Write`)));
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Append`)));
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Control`)));
   }
-  
+
   // Create Authorization for public access
   const authNode = blankNode('publicAuth');
-  
+
   // Authorization: type
   quads.push(quad(authNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
-  
+
   // Authorization: agentClass (foaf:Agent = anyone/public)
   quads.push(quad(authNode, namedNode(`${ACL_NS}agentClass`), namedNode(`${FOAF_NS}Agent`)));
-  
+
   // Authorization: accessTo (the resource)
   quads.push(quad(authNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
-  
+
   // If this is a container, also add default access for resources within it
   if (isContainer) {
     quads.push(quad(authNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
   }
-  
+
   // Authorization: mode (Read access)
   quads.push(quad(authNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Read`)));
-  
+
   // Convert quads to Turtle using N3 Writer
   return new Promise((resolve, reject) => {
     const writer = new Writer({ prefixes: { acl: ACL_NS, rdf: RDF_NS, foaf: FOAF_NS } });
@@ -2082,37 +2136,45 @@ async function createPublicAcl(resourceUrl, aclUrl, isContainer = false, ownerWe
  * @param {string} [ownerWebId] - Optional owner WebID to ensure full permissions
  * @returns {Promise<string>} The updated ACL Turtle content
  */
-async function updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, isContainer = false, ownerWebId = null) {
+async function updateAclWithPublicAccess(
+  existingTurtle,
+  aclUrl,
+  resourceUrl,
+  isContainer = false,
+  ownerWebId = null,
+) {
   const { namedNode, blankNode, quad } = DataFactory;
   const quads = [];
-  
+
   // Check if owner permissions exist in the existing ACL
   const hasOwnerPermissions = ownerWebId && existingTurtle.includes(ownerWebId);
-  
+
   // If owner WebID is provided and owner permissions don't exist, add them
   if (ownerWebId && !hasOwnerPermissions) {
     const ownerAuthNode = blankNode('ownerAuth');
-    
+
     // Authorization: type
-    quads.push(quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
-    
+    quads.push(
+      quad(ownerAuthNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)),
+    );
+
     // Authorization: agent (the owner)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}agent`), namedNode(ownerWebId)));
-    
+
     // Authorization: accessTo (the resource)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
-    
+
     // If this is a container, also add default access for resources within it
     if (isContainer) {
       quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
     }
-    
+
     // Authorization: mode (Write, Append, Control for owner)
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Write`)));
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Append`)));
     quads.push(quad(ownerAuthNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Control`)));
   }
-  
+
   // Check if public access already exists
   if (hasPublicAccessInAcl(existingTurtle)) {
     // If we added owner permissions, combine them with existing ACL
@@ -2129,20 +2191,20 @@ async function updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, is
     }
     return existingTurtle; // Public access already exists, no changes needed
   }
-  
+
   // Create Authorization for public access
   const authNode = blankNode('publicAuth');
   quads.push(quad(authNode, namedNode(`${RDF_NS}type`), namedNode(`${ACL_NS}Authorization`)));
   quads.push(quad(authNode, namedNode(`${ACL_NS}agentClass`), namedNode(`${FOAF_NS}Agent`)));
   quads.push(quad(authNode, namedNode(`${ACL_NS}accessTo`), namedNode(resourceUrl)));
-  
+
   // If this is a container, also add default access for resources within it
   if (isContainer) {
     quads.push(quad(authNode, namedNode(`${ACL_NS}default`), namedNode(resourceUrl)));
   }
-  
+
   quads.push(quad(authNode, namedNode(`${ACL_NS}mode`), namedNode(`${ACL_NS}Read`)));
-  
+
   // Convert new quads to Turtle
   const newTurtle = await new Promise((resolve, reject) => {
     const writer = new Writer({ prefixes: { acl: ACL_NS, rdf: RDF_NS, foaf: FOAF_NS } });
@@ -2152,7 +2214,7 @@ async function updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, is
       else resolve(result);
     });
   });
-  
+
   // Combine existing and new Turtle
   return existingTurtle + '\n' + newTurtle;
 }
@@ -2182,7 +2244,7 @@ async function grantPublicReadAccess(resourceUrl, fetchFn, isContainer = false,
       aclUrl = resourceUrl + '.acl';
     }
   }
-  
+
   // Fetch existing ACL or create new one
   // If we get 403, treat it as "no ACL exists" and create a new one
   let existingTurtle = null;
@@ -2196,17 +2258,23 @@ async function grantPublicReadAccess(resourceUrl, fetchFn, isContainer = false,
     });
     existingTurtle = null;
   }
-  
+
   let turtle;
-  
+
   if (existingTurtle) {
     // Update existing ACL with public access and ensure owner permissions
-    turtle = await updateAclWithPublicAccess(existingTurtle, aclUrl, resourceUrl, isContainer, ownerWebId);
+    turtle = await updateAclWithPublicAccess(
+      existingTurtle,
+      aclUrl,
+      resourceUrl,
+      isContainer,
+      ownerWebId,
+    );
   } else {
     // Create new ACL with public access and owner permissions
     turtle = await createPublicAcl(resourceUrl, aclUrl, isContainer, ownerWebId);
   }
-  
+
   // Save ACL - even if we got 403 before, we should be able to PUT the ACL file
   const response = await fetchFn(aclUrl, {
     method: 'PUT',
@@ -2215,12 +2283,12 @@ async function grantPublicReadAccess(resourceUrl, fetchFn, isContainer = false,
     },
     body: turtle,
   });
-  
+
   if (!response.ok) {
     const errorText = await response.text().catch(() => response.statusText);
     throw new Error(`Failed to save ACL: ${response.status} ${response.statusText} - ${errorText}`);
   }
-  
+
   logger.debug('[SolidStorage] ACL file created/updated successfully', {
     aclUrl,
     resourceUrl,
@@ -2237,38 +2305,41 @@ async function grantPublicReadAccess(resourceUrl, fetchFn, isContainer = false,
  */
 async function removePublicReadAccess(resourceUrl, fetchFn) {
   const aclUrl = await getAclUrl(resourceUrl, fetchFn);
-  
+
   // Fetch existing ACL
   const existingTurtle = await fetchAcl(aclUrl, fetchFn);
-  
+
   if (!existingTurtle) {
     // No ACL exists, nothing to remove
     return;
   }
-  
+
   // Check if public access exists
   if (!hasPublicAccessInAcl(existingTurtle)) {
     // Public access doesn't exist, nothing to remove
     return;
   }
-  
+
   // Remove public access lines from Turtle
   // This is a simple approach - remove lines containing foaf:Agent
   const lines = existingTurtle.split('\n');
   const filteredLines = [];
   let skipNext = false;
   let inPublicAuth = false;
-  
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    
+
     // Detect start of public authorization (blank node with foaf:Agent)
-    if (line.includes('foaf:Agent') && (line.includes('acl:agentClass') || line.includes('acl:Authorization'))) {
+    if (
+      line.includes('foaf:Agent') &&
+      (line.includes('acl:agentClass') || line.includes('acl:Authorization'))
+    ) {
       inPublicAuth = true;
       skipNext = true;
       continue;
     }
-    
+
     // Skip lines that are part of the public authorization
     if (inPublicAuth) {
       if (line.trim().endsWith('.') && !line.includes('foaf:Agent')) {
@@ -2277,21 +2348,24 @@ async function removePublicReadAccess(resourceUrl, fetchFn) {
       }
       continue;
     }
-    
+
     // Skip lines that are clearly part of public auth block
-    if (skipNext && (line.includes('acl:accessTo') || line.includes('acl:mode') || line.includes('acl:Read'))) {
+    if (
+      skipNext &&
+      (line.includes('acl:accessTo') || line.includes('acl:mode') || line.includes('acl:Read'))
+    ) {
       if (line.trim().endsWith('.')) {
         skipNext = false;
       }
       continue;
     }
-    
+
     skipNext = false;
     filteredLines.push(line);
   }
-  
+
   const updatedTurtle = filteredLines.join('\n');
-  
+
   // Save updated ACL (or delete if empty)
   if (updatedTurtle.trim().length === 0) {
     // Delete ACL file if it's empty
@@ -2313,10 +2387,12 @@ async function removePublicReadAccess(resourceUrl, fetchFn) {
       },
       body: updatedTurtle,
     });
-    
+
     if (!response.ok) {
       const errorText = await response.text().catch(() => response.statusText);
-      throw new Error(`Failed to save ACL: ${response.status} ${response.statusText} - ${errorText}`);
+      throw new Error(
+        `Failed to save ACL: ${response.status} ${response.statusText} - ${errorText}`,
+      );
     }
   }
 }
@@ -2324,7 +2400,7 @@ async function removePublicReadAccess(resourceUrl, fetchFn) {
 /**
  * Set public read access for a shared conversation and its messages
  * This makes the conversation and all its messages publicly accessible
- * 
+ *
  * @param {Object} req - Express request object
  * @param {string} conversationId - The conversation ID to share
  * @returns {Promise<void>}
@@ -2407,7 +2483,6 @@ async function setPublicAccessForShare(req, conversationId) {
     // IMPORTANT: We must preserve owner permissions so the owner can still add messages
     const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
     try {
-      
       await grantPublicReadAccess(messagesContainerPath, authenticatedFetch, true, ownerWebId); // isContainer=true, ownerWebId
       logger.info('[SolidStorage] Public read access set on messages container (with default)', {
         messagesContainerPath,
@@ -2428,7 +2503,7 @@ async function setPublicAccessForShare(req, conversationId) {
     for (const message of messages) {
       try {
         const messagePath = getMessagePath(podUrl, conversationId, message.messageId);
-      
+
         try {
           await grantPublicReadAccess(messagePath, authenticatedFetch, false, ownerWebId);
           messagesShared++;
@@ -2440,10 +2515,10 @@ async function setPublicAccessForShare(req, conversationId) {
             messageId: message.messageId,
             error: grantError.message,
           });
-          
+
           const aclUrl = messagePath.endsWith('/') ? messagePath + '.acl' : messagePath + '.acl';
           const turtle = await createPublicAcl(messagePath, aclUrl, false, ownerWebId);
-          
+
           const response = await authenticatedFetch(aclUrl, {
             method: 'PUT',
             headers: {
@@ -2451,7 +2526,7 @@ async function setPublicAccessForShare(req, conversationId) {
             },
             body: turtle,
           });
-          
+
           if (response.ok) {
             logger.info('[SolidStorage] ACL file created directly for message file', {
               messagePath,
@@ -2460,7 +2535,9 @@ async function setPublicAccessForShare(req, conversationId) {
             messagesShared++;
           } else {
             const errorText = await response.text().catch(() => response.statusText);
-            throw new Error(`Failed to create ACL directly: ${response.status} ${response.statusText} - ${errorText}`);
+            throw new Error(
+              `Failed to create ACL directly: ${response.status} ${response.statusText} - ${errorText}`,
+            );
           }
         }
       } catch (error) {
@@ -2492,7 +2569,7 @@ async function setPublicAccessForShare(req, conversationId) {
 /**
  * Remove public read access for a shared conversation and its messages
  * This unshares the conversation and makes it private again
- * 
+ *
  * @param {Object} req - Express request object
  * @param {string} conversationId - The conversation ID to unshare
  * @returns {Promise<void>}
@@ -2580,10 +2657,13 @@ async function removePublicAccessForShare(req, conversationId) {
     try {
       messages = await getMessagesFromSolid(req, conversationId);
     } catch (error) {
-      logger.debug('[SolidStorage] Could not fetch messages when removing public access (conversation may be deleted)', {
-        conversationId,
-        error: error.message,
-      });
+      logger.debug(
+        '[SolidStorage] Could not fetch messages when removing public access (conversation may be deleted)',
+        {
+          conversationId,
+          error: error.message,
+        },
+      );
     }
 
     // Remove public read access from each message file using manual Turtle approach
@@ -2632,7 +2712,7 @@ async function removePublicAccessForShare(req, conversationId) {
 
 /**
  * Get shared messages from Solid Pod using public access (no authentication required)
- * 
+ *
  * @param {string} shareId - The share ID
  * @param {string} conversationId - The conversation ID (from SharedLink)
  * @param {string} podUrl - The Pod URL where the conversation is stored
@@ -2674,13 +2754,13 @@ async function getSharedMessagesFromSolid(shareId, conversationId, podUrl, targe
     // Get all messages for this conversation using public access
     const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
     let messages = [];
-    
+
     try {
       // Try to get container contents
       const containerResponse = await publicFetch(messagesContainerPath, {
         method: 'GET',
         headers: {
-          'Accept': 'text/turtle',
+          Accept: 'text/turtle',
         },
       });
 
@@ -2693,7 +2773,9 @@ async function getSharedMessagesFromSolid(shareId, conversationId, podUrl, targe
           });
           return null;
         }
-        throw new Error(`Failed to fetch messages container: ${containerResponse.status} ${containerResponse.statusText}`);
+        throw new Error(
+          `Failed to fetch messages container: ${containerResponse.status} ${containerResponse.statusText}`,
+        );
       }
 
       const containerText = await containerResponse.text();
@@ -2745,7 +2827,7 @@ async function getSharedMessagesFromSolid(shareId, conversationId, podUrl, targe
     let messagesToShare = messages;
     if (targetMessageId) {
       // Find the target message and get all messages up to it
-      const targetIndex = messages.findIndex(msg => msg.messageId === targetMessageId);
+      const targetIndex = messages.findIndex((msg) => msg.messageId === targetMessageId);
       if (targetIndex >= 0) {
         messagesToShare = messages.slice(0, targetIndex + 1);
       } else {
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 696b103f216a..549d0e56758d 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -64,7 +64,9 @@ async function customFetch(url, options) {
     const response = await undici.fetch(url, fetchOptions);
 
     if (debugOpenId) {
-      logger.debug(`[SolidOpenidStrategy] Response status: ${response.status} ${response.statusText}`);
+      logger.debug(
+        `[SolidOpenidStrategy] Response status: ${response.status} ${response.statusText}`,
+      );
       logger.debug(`[SolidOpenidStrategy] Response headers: ${logHeaders(response.headers)}`);
     }
 
@@ -367,7 +369,11 @@ async function setupSolidOpenId() {
           // TODO: jeswr - Potentially fetch an email from the user's WebID if they have a `foaf:mbox`
           // TODO: jeswr - Can codebase support email or WebID rather than requiring email?
           // TODO: jeswr - Suggest opening issues for these once we PR the changes upstream
-          const email = userinfo.email || userinfo.preferred_username || userinfo.upn || `${userinfo.webid}@FAKEDOMAIN.TLD`;
+          const email =
+            userinfo.email ||
+            userinfo.preferred_username ||
+            userinfo.upn ||
+            `${userinfo.webid}@FAKEDOMAIN.TLD`;
           if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
             logger.error(
               `[SolidOpenidStrategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
diff --git a/client/src/data-provider/SSE/queries.ts b/client/src/data-provider/SSE/queries.ts
index 94e71fad8baa..9c683ab5b7ac 100644
--- a/client/src/data-provider/SSE/queries.ts
+++ b/client/src/data-provider/SSE/queries.ts
@@ -150,6 +150,6 @@ export function useActiveJobs(enabled = true) {
     refetchInterval: (data) => ((data?.activeJobIds?.length ?? 0) > 0 ? 5_000 : false),
     retry: false,
   });
-  
+
   return query;
 }
diff --git a/config/create-user.js b/config/create-user.js
index 3688d736e24c..2b7608c4a982 100644
--- a/config/create-user.js
+++ b/config/create-user.js
@@ -14,7 +14,9 @@ const connect = require('./connect');
   console.purple('--------------------------');
 
   if (process.argv.length < 5) {
-    console.orange('Usage: npm run create-user -- <email> <name> <username> [--email-verified=false]');
+    console.orange(
+      'Usage: npm run create-user -- <email> <name> <username> [--email-verified=false]',
+    );
     console.orange('Note: if you do not pass in the arguments, you will be prompted for them.');
     console.orange(
       'If you really need to pass in the password, you can do so as the 4th argument (not recommended for security).',
@@ -88,9 +90,9 @@ If \`n\`, and email service is configured, the user will be sent a verification
 If \`n\`, and email service is not configured, you must have the \`ALLOW_UNVERIFIED_EMAIL_LOGIN\` .env variable set to true,
 or the user will need to attempt logging in to have a verification link sent to them.`);
 
-    const normalizedEmailVerifiedInput = emailVerifiedInput.trim().toLowerCase()
+    const normalizedEmailVerifiedInput = emailVerifiedInput.trim().toLowerCase();
 
-    emailVerified = true
+    emailVerified = true;
 
     if (normalizedEmailVerifiedInput === 'n') {
       emailVerified = false;
diff --git a/packages/api/src/utils/graph.spec.ts b/packages/api/src/utils/graph.spec.ts
index 4f1fa14983ef..71d9464e67c2 100644
--- a/packages/api/src/utils/graph.spec.ts
+++ b/packages/api/src/utils/graph.spec.ts
@@ -94,9 +94,9 @@ describe('Graph Token Utilities', () => {
     });
 
     it('should return false for non-object values', () => {
-      expect(recordContainsGraphTokenPlaceholder('string' as unknown as Record<string, string>)).toBe(
-        false,
-      );
+      expect(
+        recordContainsGraphTokenPlaceholder('string' as unknown as Record<string, string>),
+      ).toBe(false);
     });
   });
 
@@ -242,7 +242,9 @@ describe('Graph Token Utilities', () => {
     it('should return original value when graph token exchange fails', async () => {
       mockExtractOpenIDTokenInfo.mockReturnValue({ accessToken: 'access-token' });
       mockIsOpenIDTokenValid.mockReturnValue(true);
-      const failingResolver: GraphTokenResolver = jest.fn().mockRejectedValue(new Error('Exchange failed'));
+      const failingResolver: GraphTokenResolver = jest
+        .fn()
+        .mockRejectedValue(new Error('Exchange failed'));
 
       const value = 'Bearer {{LIBRECHAT_GRAPH_ACCESS_TOKEN}}';
       const result = await resolveGraphTokenPlaceholder(value, {
diff --git a/packages/api/src/utils/graph.ts b/packages/api/src/utils/graph.ts
index 0ff3fc3583e8..3bb3d2bf4c36 100644
--- a/packages/api/src/utils/graph.ts
+++ b/packages/api/src/utils/graph.ts
@@ -11,10 +11,7 @@ import {
  * Pre-computed regex for matching the Graph token placeholder.
  * Escapes curly braces in the placeholder string for safe regex use.
  */
-const GRAPH_TOKEN_REGEX = new RegExp(
-  GRAPH_TOKEN_PLACEHOLDER.replace(/[{}]/g, '\\$&'),
-  'g',
-);
+const GRAPH_TOKEN_REGEX = new RegExp(GRAPH_TOKEN_PLACEHOLDER.replace(/[{}]/g, '\\$&'), 'g');
 
 /**
  * Response from a Graph API token exchange.
@@ -143,7 +140,9 @@ export async function resolveGraphTokenPlaceholder(
       return value.replace(GRAPH_TOKEN_REGEX, graphTokenResponse.access_token);
     }
 
-    logger.warn('[resolveGraphTokenPlaceholder] Graph token exchange did not return an access token');
+    logger.warn(
+      '[resolveGraphTokenPlaceholder] Graph token exchange did not return an access token',
+    );
     return value;
   } catch (error) {
     logger.error('[resolveGraphTokenPlaceholder] Failed to exchange token for Graph API:', error);
@@ -185,14 +184,13 @@ export async function resolveGraphTokensInRecord(
  * @param graphOptions - Options for Graph token resolution
  * @returns The options with Graph token placeholders resolved
  */
-export async function preProcessGraphTokens<T extends {
-  headers?: Record<string, string>;
-  env?: Record<string, string>;
-  url?: string;
-}>(
-  options: T,
-  graphOptions: GraphTokenOptions,
-): Promise<T> {
+export async function preProcessGraphTokens<
+  T extends {
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+    url?: string;
+  },
+>(options: T, graphOptions: GraphTokenOptions): Promise<T> {
   if (!mcpOptionsContainGraphTokenPlaceholder(options)) {
     return options;
   }
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 0afafe323c2a..9f2f7557f81a 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -8,7 +8,15 @@ import { apiBaseUrl } from './api-endpoints';
 import { FileSources } from './types/files';
 import { MCPServersSchema } from './mcp';
 
-export const defaultSocialLogins = ['google', 'facebook', 'openid', 'solid', 'github', 'discord', 'saml'];
+export const defaultSocialLogins = [
+  'google',
+  'facebook',
+  'openid',
+  'solid',
+  'github',
+  'discord',
+  'saml',
+];
 
 export const defaultRetrievalModels = [
   'gpt-4o',
diff --git a/packages/data-provider/src/createPayload.ts b/packages/data-provider/src/createPayload.ts
index b2a36f0bf70b..ca3bb16fc847 100644
--- a/packages/data-provider/src/createPayload.ts
+++ b/packages/data-provider/src/createPayload.ts
@@ -58,41 +58,61 @@ export default function createPayload(submission: t.TSubmission) {
    * missing optional fields. Convert null → undefined so schema parse succeeds.
    */
   const nullableNumberFields = [
-    'topP', 'top_p', 'topK', 'frequency_penalty', 'presence_penalty', 
-    'temperature', 'maxOutputTokens', 'maxContextTokens', 'max_tokens',
-    'thinkingBudget', 'fileTokenLimit'
+    'topP',
+    'top_p',
+    'topK',
+    'frequency_penalty',
+    'presence_penalty',
+    'temperature',
+    'maxOutputTokens',
+    'maxContextTokens',
+    'max_tokens',
+    'thinkingBudget',
+    'fileTokenLimit',
   ];
-  
+
   const nullableStringFields = [
-    'assistant_id', 'agent_id', 'model', 'modelLabel', 'userLabel',
-    'promptPrefix', 'system', 'context', 'title', 'conversationId',
-    'endpoint', 'endpointType', 'parentMessageId', 'artifacts',
-    'imageDetail', 'reasoning_effort', 'reasoning_summary', 'verbosity'
-  ];
-  
-  const nullableBooleanFields = [
-    'isArchived', 'promptCache', 'thinking', 'stream', 'resendFiles'
+    'assistant_id',
+    'agent_id',
+    'model',
+    'modelLabel',
+    'userLabel',
+    'promptPrefix',
+    'system',
+    'context',
+    'title',
+    'conversationId',
+    'endpoint',
+    'endpointType',
+    'parentMessageId',
+    'artifacts',
+    'imageDetail',
+    'reasoning_effort',
+    'reasoning_summary',
+    'verbosity',
   ];
-  
+
+  const nullableBooleanFields = ['isArchived', 'promptCache', 'thinking', 'stream', 'resendFiles'];
+
   // Convert null to undefined for all nullable fields
   for (const field of nullableNumberFields) {
     if (field in normalizedConversation && normalizedConversation[field] === null) {
       normalizedConversation[field] = undefined;
     }
   }
-  
+
   for (const field of nullableStringFields) {
     if (field in normalizedConversation && normalizedConversation[field] === null) {
       normalizedConversation[field] = undefined;
     }
   }
-  
+
   for (const field of nullableBooleanFields) {
     if (field in normalizedConversation && normalizedConversation[field] === null) {
       normalizedConversation[field] = undefined;
     }
   }
-  
+
   // Handle createdAt and updatedAt - convert Date objects to strings, or null to undefined
   if ('createdAt' in normalizedConversation) {
     if (normalizedConversation.createdAt === null) {
@@ -101,7 +121,7 @@ export default function createPayload(submission: t.TSubmission) {
       normalizedConversation.createdAt = normalizedConversation.createdAt.toISOString();
     }
   }
-  
+
   if ('updatedAt' in normalizedConversation) {
     if (normalizedConversation.updatedAt === null) {
       normalizedConversation.updatedAt = undefined;
@@ -109,7 +129,7 @@ export default function createPayload(submission: t.TSubmission) {
       normalizedConversation.updatedAt = normalizedConversation.updatedAt.toISOString();
     }
   }
-  
+
   /**
    * Use safeParse so we don't throw on invalid/conversation shapes (e.g. from Solid).
    * If parse fails, we still try to build a valid payload from conversation + endpointOption
@@ -120,23 +140,24 @@ export default function createPayload(submission: t.TSubmission) {
   if (!parseResult.success) {
     // Fallback: build payload from raw conversationId and conversation/endpointOption fields
     // (e.g. new convo: conversationId null/'new'; existing: we need conversationId + model etc.)
-    const conversationIdRaw = conversation?.conversationId ?? normalizedConversation?.conversationId ?? null;
-    
+    const conversationIdRaw =
+      conversation?.conversationId ?? normalizedConversation?.conversationId ?? null;
+
     // Allow null or 'new' for new conversations
     if (conversationIdRaw === null || conversationIdRaw === 'new') {
       const conversationId = conversationIdRaw;
-  const { endpoint: _e, endpointType } = endpointOption as {
-    endpoint: s.EModelEndpoint;
-    endpointType?: s.EModelEndpoint;
-  };
+      const { endpoint: _e, endpointType } = endpointOption as {
+        endpoint: s.EModelEndpoint;
+        endpointType?: s.EModelEndpoint;
+      };
 
-  const endpoint = _e as s.EModelEndpoint;
-  let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
-  if (s.isAssistantsEndpoint(endpoint)) {
-    server =
-      EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
-      (isEdited ? '/modify' : '');
-  }
+      const endpoint = _e as s.EModelEndpoint;
+      let server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
+      if (s.isAssistantsEndpoint(endpoint)) {
+        server =
+          EndpointURLs[(endpointType ?? endpoint) as 'assistants' | 'azureAssistants'] +
+          (isEdited ? '/modify' : '');
+      }
 
       const payload: t.TPayload = {
         ...userMessage,
@@ -153,35 +174,70 @@ export default function createPayload(submission: t.TSubmission) {
 
       return { server, payload };
     }
-    
+
     // For existing conversations, conversationId must be a valid string
     if (typeof conversationIdRaw !== 'string') {
       throw new Error('Invalid conversation: conversationId must be a string');
     }
 
     const conversationId: string = conversationIdRaw;
-    
+
     // Solid often stores model (and other options) on the conversation; pull from conversation
     // when not in endpointOption so the payload has a model for the backend.
     const conversationFields = {
-      model: (endpointOption as { model?: string })?.model ?? conversation?.model ?? normalizedConversation?.model,
-      modelLabel: (endpointOption as { modelLabel?: string })?.modelLabel ?? conversation?.modelLabel ?? normalizedConversation?.modelLabel,
-      temperature: (endpointOption as { temperature?: number })?.temperature ?? conversation?.temperature ?? normalizedConversation?.temperature,
-      topP: (endpointOption as { topP?: number })?.topP ?? conversation?.topP ?? normalizedConversation?.topP,
-      top_p: (endpointOption as { top_p?: number })?.top_p ?? conversation?.top_p ?? normalizedConversation?.top_p,
-      frequency_penalty: (endpointOption as { frequency_penalty?: number })?.frequency_penalty ?? conversation?.frequency_penalty ?? normalizedConversation?.frequency_penalty,
-      presence_penalty: (endpointOption as { presence_penalty?: number })?.presence_penalty ?? conversation?.presence_penalty ?? normalizedConversation?.presence_penalty,
-      maxOutputTokens: (endpointOption as { maxOutputTokens?: number })?.maxOutputTokens ?? conversation?.maxOutputTokens ?? normalizedConversation?.maxOutputTokens,
-      max_tokens: (endpointOption as { max_tokens?: number })?.max_tokens ?? conversation?.max_tokens ?? normalizedConversation?.max_tokens,
-      system: (endpointOption as { system?: string })?.system ?? conversation?.system ?? normalizedConversation?.system,
-      promptPrefix: (endpointOption as { promptPrefix?: string })?.promptPrefix ?? conversation?.promptPrefix ?? normalizedConversation?.promptPrefix,
+      model:
+        (endpointOption as { model?: string })?.model ??
+        conversation?.model ??
+        normalizedConversation?.model,
+      modelLabel:
+        (endpointOption as { modelLabel?: string })?.modelLabel ??
+        conversation?.modelLabel ??
+        normalizedConversation?.modelLabel,
+      temperature:
+        (endpointOption as { temperature?: number })?.temperature ??
+        conversation?.temperature ??
+        normalizedConversation?.temperature,
+      topP:
+        (endpointOption as { topP?: number })?.topP ??
+        conversation?.topP ??
+        normalizedConversation?.topP,
+      top_p:
+        (endpointOption as { top_p?: number })?.top_p ??
+        conversation?.top_p ??
+        normalizedConversation?.top_p,
+      frequency_penalty:
+        (endpointOption as { frequency_penalty?: number })?.frequency_penalty ??
+        conversation?.frequency_penalty ??
+        normalizedConversation?.frequency_penalty,
+      presence_penalty:
+        (endpointOption as { presence_penalty?: number })?.presence_penalty ??
+        conversation?.presence_penalty ??
+        normalizedConversation?.presence_penalty,
+      maxOutputTokens:
+        (endpointOption as { maxOutputTokens?: number })?.maxOutputTokens ??
+        conversation?.maxOutputTokens ??
+        normalizedConversation?.maxOutputTokens,
+      max_tokens:
+        (endpointOption as { max_tokens?: number })?.max_tokens ??
+        conversation?.max_tokens ??
+        normalizedConversation?.max_tokens,
+      system:
+        (endpointOption as { system?: string })?.system ??
+        conversation?.system ??
+        normalizedConversation?.system,
+      promptPrefix:
+        (endpointOption as { promptPrefix?: string })?.promptPrefix ??
+        conversation?.promptPrefix ??
+        normalizedConversation?.promptPrefix,
     };
-    
+
     // Filter out null/undefined values
     const validConversationFields = Object.fromEntries(
-      Object.entries(conversationFields).filter(([_, value]) => value !== null && value !== undefined)
+      Object.entries(conversationFields).filter(
+        ([_, value]) => value !== null && value !== undefined,
+      ),
     );
-    
+
     // Continue with the fallback conversationId
     const { endpoint: _e, endpointType } = endpointOption as {
       endpoint: s.EModelEndpoint;
@@ -197,16 +253,25 @@ export default function createPayload(submission: t.TSubmission) {
     }
 
     // Ensure model is explicitly included - check all sources
-    const finalModel = (endpointOption as { model?: string })?.model || 
-                      validConversationFields.model || 
-                      conversation?.model || 
-                      normalizedConversation?.model;
+    const finalModel =
+      (endpointOption as { model?: string })?.model ||
+      validConversationFields.model ||
+      conversation?.model ||
+      normalizedConversation?.model;
 
     // Extract resendFiles - default to true for agents endpoints if not specified
     const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
-    const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
-    const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
-    const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+    const resendFilesFromConversation =
+      typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+    const resendFilesFromNormalized =
+      typeof normalizedConversation?.resendFiles === 'boolean'
+        ? (normalizedConversation.resendFiles as boolean)
+        : undefined;
+    const resendFiles: boolean =
+      resendFilesFromOption ??
+      resendFilesFromConversation ??
+      resendFilesFromNormalized ??
+      (s.isAgentsEndpoint(endpoint) ? true : false);
 
     const payload: t.TPayload = {
       ...userMessage,
@@ -249,9 +314,17 @@ export default function createPayload(submission: t.TSubmission) {
 
   // Extract resendFiles - default to true for agents endpoints if not specified
   const resendFilesFromOption = (endpointOption as { resendFiles?: boolean })?.resendFiles;
-  const resendFilesFromConversation = typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
-  const resendFilesFromNormalized = typeof normalizedConversation?.resendFiles === 'boolean' ? normalizedConversation.resendFiles as boolean : undefined;
-  const resendFiles: boolean = resendFilesFromOption ?? resendFilesFromConversation ?? resendFilesFromNormalized ?? (s.isAgentsEndpoint(endpoint) ? true : false);
+  const resendFilesFromConversation =
+    typeof conversation?.resendFiles === 'boolean' ? conversation.resendFiles : undefined;
+  const resendFilesFromNormalized =
+    typeof normalizedConversation?.resendFiles === 'boolean'
+      ? (normalizedConversation.resendFiles as boolean)
+      : undefined;
+  const resendFiles: boolean =
+    resendFilesFromOption ??
+    resendFilesFromConversation ??
+    resendFilesFromNormalized ??
+    (s.isAgentsEndpoint(endpoint) ? true : false);
 
   const payload: t.TPayload = {
     ...userMessage,
diff --git a/packages/data-schemas/src/methods/share.ts b/packages/data-schemas/src/methods/share.ts
index 53e25841f39e..5bb13961c0f8 100644
--- a/packages/data-schemas/src/methods/share.ts
+++ b/packages/data-schemas/src/methods/share.ts
@@ -229,7 +229,10 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       /** Filtered messages based on targetMessageId if present (branch-specific sharing) */
       let messagesToShare: t.IMessage[] = shareWithMessages.messages;
       if (shareWithMessages.targetMessageId) {
-        messagesToShare = getMessagesUpToTarget(shareWithMessages.messages, shareWithMessages.targetMessageId);
+        messagesToShare = getMessagesUpToTarget(
+          shareWithMessages.messages,
+          shareWithMessages.targetMessageId,
+        );
       }
 
       const newConvoId = anonymizeConvoId(shareWithMessages.conversationId);
@@ -377,14 +380,14 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
 
     try {
       const SharedLink = mongoose.models.SharedLink as Model<t.ISharedLink>;
-      
+
       // Find all shares for this conversation to check if any are Solid shares
       const shares = await SharedLink.find({ user, conversationId }).lean();
-      
+
       // If any shares are Solid shares, remove public access (user logged in via "Continue with Solid")
       if (req) {
         if (getIsSolidUser()(req)) {
-          const solidShares = shares.filter(share => share.podUrl);
+          const solidShares = shares.filter((share) => share.podUrl);
           for (const share of solidShares) {
             try {
               const { removePublicAccessForShare } = getSolidStorage();
@@ -406,7 +409,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
           }
         }
       }
-      
+
       const result = await SharedLink.deleteMany({ user, conversationId });
       return {
         message: 'Shared links deleted successfully',
@@ -479,22 +482,18 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
             userId: req.user?.id,
             openidId: req.user?.openidId,
           });
-          
-          const {
-            getConvoFromSolid,
-            getMessagesFromSolid,
-            getPodUrl,
-            getSolidFetch,
-          } = getSolidStorage();
+
+          const { getConvoFromSolid, getMessagesFromSolid, getPodUrl, getSolidFetch } =
+            getSolidStorage();
           const authenticatedFetch = await getSolidFetch(req);
-          
+
           // Get Pod URL
           podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
           logger.info('[createSharedLink] Pod URL retrieved', {
             podUrl,
             conversationId,
           });
-          
+
           // Get conversation from Solid
           try {
             logger.info('[createSharedLink] Getting conversation from Solid Pod', {
@@ -506,14 +505,17 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
             });
             conversation = await getConvoFromSolid(req, conversationId);
             if (!conversation) {
-              logger.error('[createSharedLink] Conversation not found in Solid Pod (returned null)', {
-                user,
-                conversationId,
-                podUrl,
-                userId: req.user?.id,
-                openidId: req.user?.openidId,
-                userIdType: typeof req.user?.id,
-              });
+              logger.error(
+                '[createSharedLink] Conversation not found in Solid Pod (returned null)',
+                {
+                  user,
+                  conversationId,
+                  podUrl,
+                  userId: req.user?.id,
+                  openidId: req.user?.openidId,
+                  userIdType: typeof req.user?.id,
+                },
+              );
               throw new ShareServiceError(
                 'Conversation not found or access denied',
                 'CONVERSATION_NOT_FOUND',
@@ -572,47 +574,47 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       } else {
         // For MongoDB users, use existing logic
         const [existingShare, mongoMessages] = await Promise.all([
-        SharedLink.findOne({
-          conversationId,
-          user,
-          isPublic: true,
-          ...(targetMessageId && { targetMessageId }),
-        })
-          .select('-_id -__v -user')
-          .lean() as Promise<t.ISharedLink | null>,
-        Message.find({ conversationId, user }).sort({ createdAt: 1 }).lean(),
-      ]);
+          SharedLink.findOne({
+            conversationId,
+            user,
+            isPublic: true,
+            ...(targetMessageId && { targetMessageId }),
+          })
+            .select('-_id -__v -user')
+            .lean() as Promise<t.ISharedLink | null>,
+          Message.find({ conversationId, user }).sort({ createdAt: 1 }).lean(),
+        ]);
 
-      if (existingShare && existingShare.isPublic) {
-        logger.error('[createSharedLink] Share already exists', {
-          user,
-          conversationId,
-          targetMessageId,
-        });
-        throw new ShareServiceError('Share already exists', 'SHARE_EXISTS');
-      } else if (existingShare) {
-        await SharedLink.deleteOne({
-          conversationId,
-          user,
-          ...(targetMessageId && { targetMessageId }),
-        });
-      }
+        if (existingShare && existingShare.isPublic) {
+          logger.error('[createSharedLink] Share already exists', {
+            user,
+            conversationId,
+            targetMessageId,
+          });
+          throw new ShareServiceError('Share already exists', 'SHARE_EXISTS');
+        } else if (existingShare) {
+          await SharedLink.deleteOne({
+            conversationId,
+            user,
+            ...(targetMessageId && { targetMessageId }),
+          });
+        }
 
         conversation = (await Conversation.findOne({ conversationId, user }).lean()) as {
-        title?: string;
-      } | null;
-
-      // Check if user owns the conversation
-      if (!conversation) {
-        throw new ShareServiceError(
-          'Conversation not found or access denied',
-          'CONVERSATION_NOT_FOUND',
-        );
-      }
+          title?: string;
+        } | null;
+
+        // Check if user owns the conversation
+        if (!conversation) {
+          throw new ShareServiceError(
+            'Conversation not found or access denied',
+            'CONVERSATION_NOT_FOUND',
+          );
+        }
 
-      // Check if there are any messages to share
+        // Check if there are any messages to share
         if (!mongoMessages || mongoMessages.length === 0) {
-        throw new ShareServiceError('No messages to share', 'NO_MESSAGES');
+          throw new ShareServiceError('No messages to share', 'NO_MESSAGES');
         }
 
         conversationMessages = mongoMessages;
@@ -621,7 +623,7 @@ export function createShareMethods(mongoose: typeof import('mongoose')) {
       const title = conversation.title || 'Untitled';
 
       const shareId = nanoid();
-      
+
       // Create SharedLink with podUrl if Solid user
       const sharedLinkData: any = {
         shareId,

From 1b6c95673e9c189fc1df51e3fa577f336a4b17f5 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 17 Feb 2026 16:26:47 +0000
Subject: [PATCH 52/94] fix lint errors

---
 api/models/Conversation.js                       | 2 +-
 api/server/controllers/agents/request.js         | 2 +-
 api/server/middleware/requireJwtAuth.js          | 2 +-
 api/server/routes/messages.js                    | 2 +-
 api/server/routes/oauth.js                       | 2 +-
 api/server/services/SolidStorage.js              | 2 +-
 client/src/components/Auth/SocialLoginRender.tsx | 4 ++--
 client/src/locales/en/translation.json           | 1 +
 8 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index c47bcd5a94f4..29cc7c3fcfae 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -290,7 +290,7 @@ module.exports = {
             },
           ],
         };
-      } catch (err) {
+      } catch (_err) {
         logger.warn('[getConvosByCursor] Invalid cursor format, starting from beginning');
       }
       if (cursorFilter) {
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index db8527993630..4ca2426a2cf3 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -630,7 +630,7 @@ const _LegacyAgentController = async (req, res, next, initializeClient, addTitle
     let response = await client.sendMessage(text, messageOptions);
 
     // Extract what we need and immediately break reference
-    const messageId = response.messageId;
+    const _messageId = response.messageId;
     const endpoint = endpointOption.endpoint;
     response.endpoint = endpoint;
 
diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index 93ee07fccbea..21564e8e753d 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -16,7 +16,7 @@ const requireJwtAuth = (req, res, next) => {
   }
 
   // Default to standard JWT authentication
-  return passport.authenticate('jwt', { session: false }, (err, user, info) => {
+  return passport.authenticate('jwt', { session: false }, (err, user, _info) => {
     if (err) {
       return res.status(401).json({ error: 'Authentication failed', message: err.message });
     }
diff --git a/api/server/routes/messages.js b/api/server/routes/messages.js
index 3775913fb2d3..01d7fdb871ec 100644
--- a/api/server/routes/messages.js
+++ b/api/server/routes/messages.js
@@ -344,7 +344,7 @@ router.get('/:conversationId', validateMessageReq, async (req, res) => {
       try {
         const messages = await getMessagesFromSolid(req, conversationId);
         const cleanedMessages = messages.map((msg) => {
-          const { _id, __v, user, ...rest } = msg;
+          const { _id, __v, user: _user, ...rest } = msg;
           return rest;
         });
         return res.status(200).json(cleanedMessages);
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 9d081ebd348d..474dce66805a 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -6,7 +6,7 @@ const { logger } = require('@librechat/data-schemas');
 const { ErrorTypes } = require('librechat-data-provider');
 const { createSetBalanceConfig, isEnabled } = require('@librechat/api');
 const { checkDomainAllowed, loginLimiter, logHeaders, checkBan } = require('~/server/middleware');
-const { createOAuthHandler } = require('~/server/controllers/auth/oauth');
+const { createOAuthHandler: _createOAuthHandler } = require('~/server/controllers/auth/oauth');
 const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
 const { syncUserEntraGroupMemberships } = require('~/server/services/PermissionService');
 const { getAppConfig } = require('~/server/services/Config');
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 430fcc9fce30..92acae57dd4e 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -998,7 +998,7 @@ async function deleteMessagesFromSolid(req, params) {
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
 
     // Get messages container path
-    const messagesContainerPath = getMessagesContainerPath(podUrl, params.conversationId);
+    const _messagesContainerPath = getMessagesContainerPath(podUrl, params.conversationId);
 
     // Get all messages for the conversation
     const allMessages = await getMessagesFromSolid(req, params.conversationId);
diff --git a/client/src/components/Auth/SocialLoginRender.tsx b/client/src/components/Auth/SocialLoginRender.tsx
index b648f7e35d0e..3e45785a7d21 100644
--- a/client/src/components/Auth/SocialLoginRender.tsx
+++ b/client/src/components/Auth/SocialLoginRender.tsx
@@ -11,7 +11,7 @@ import {
 
 import SocialButton from './SocialButton';
 
-import { useLocalize } from '~/hooks';
+import { useLocalize, TranslationKeys } from '~/hooks';
 
 import { TStartupConfig } from 'librechat-data-provider';
 
@@ -142,7 +142,7 @@ function SocialLoginRender({
           <>
             <div className="relative mt-6 flex w-full items-center justify-center border border-t border-gray-300 uppercase dark:border-gray-600">
               <div className="absolute bg-white px-3 text-xs text-black dark:bg-gray-900 dark:text-white">
-                Or
+                {localize('com_auth_or' as TranslationKeys)}
               </div>
             </div>
             <div className="mt-8" />
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 35d83004891b..b7aa7b4ac2d9 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -190,6 +190,7 @@
   "com_auth_name_min_length": "Name must be at least 3 characters",
   "com_auth_name_required": "Name is required",
   "com_auth_no_account": "Don't have an account?",
+  "com_auth_or": "Or",
   "com_auth_password": "Password",
   "com_auth_password_confirm": "Confirm password",
   "com_auth_password_forgot": "Forgot Password?",

From 55788d6cc95e3d038d7ce05ab50fcad3a41bd464 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 10:25:47 +0000
Subject: [PATCH 53/94] test update: expect deleteConvos to be called with req
 (Solid support)

---
 api/server/routes/__tests__/convos.spec.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/server/routes/__tests__/convos.spec.js b/api/server/routes/__tests__/convos.spec.js
index 931ef006d00e..eff41bbddfbd 100644
--- a/api/server/routes/__tests__/convos.spec.js
+++ b/api/server/routes/__tests__/convos.spec.js
@@ -151,7 +151,7 @@ describe('Convos Routes', () => {
       expect(response.body).toEqual(mockDbResponse);
 
       /** Verify deleteConvos was called with correct userId */
-      expect(deleteConvos).toHaveBeenCalledWith('test-user-123', {});
+      expect(deleteConvos).toHaveBeenCalledWith('test-user-123', {}, expect.anything());
       expect(deleteConvos).toHaveBeenCalledTimes(1);
 
       /** Verify deleteToolCalls was called with correct userId */

From 29e543f682e28c39daa0a86d0a1e3f74b33c1539 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 10:27:10 +0000
Subject: [PATCH 54/94] test(convos) update: expect deleteConvos and
 deleteConvoSharedLink with req in DELETE

---
 api/server/routes/__tests__/convos.spec.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/api/server/routes/__tests__/convos.spec.js b/api/server/routes/__tests__/convos.spec.js
index eff41bbddfbd..2cbafd86c924 100644
--- a/api/server/routes/__tests__/convos.spec.js
+++ b/api/server/routes/__tests__/convos.spec.js
@@ -327,13 +327,13 @@ describe('Convos Routes', () => {
       /** Verify deleteConvos was called with correct parameters */
       expect(deleteConvos).toHaveBeenCalledWith('test-user-123', {
         conversationId: mockConversationId,
-      });
+      }, expect.anything());
 
       /** Verify deleteToolCalls was called */
       expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123', mockConversationId);
 
       /** Verify deleteConvoSharedLink was called */
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId);
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
     });
 
     it('should not call deleteConvoSharedLink when no conversationId provided', async () => {

From 5617004bf627b65a6497de40a73951c7b1a24e48 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 10:28:15 +0000
Subject: [PATCH 55/94] test(convos) update: expect deleteConvoSharedLink with
 req in remaining DELETE tests

---
 api/server/routes/__tests__/convos.spec.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/api/server/routes/__tests__/convos.spec.js b/api/server/routes/__tests__/convos.spec.js
index 2cbafd86c924..aeea165282c4 100644
--- a/api/server/routes/__tests__/convos.spec.js
+++ b/api/server/routes/__tests__/convos.spec.js
@@ -371,7 +371,7 @@ describe('Convos Routes', () => {
         });
 
       expect(response.status).toBe(201);
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId);
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
     });
 
     it('should return 400 when no parameters provided', async () => {
@@ -489,7 +489,7 @@ describe('Convos Routes', () => {
       expect(response.status).toBe(201);
 
       /** Verify shared links were deleted for the specific conversation */
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId);
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
 
       /** Verify it was called after the conversation was deleted */
       expect(deleteConvoSharedLink).toHaveBeenCalledAfter(deleteConvos);

From 4b3a6576d941a5b2ababd56ab4b64388574f2052 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 10:43:23 +0000
Subject: [PATCH 56/94] fix eslint build fail

---
 api/server/routes/__tests__/convos.spec.js | 28 +++++++++++++++++-----
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/api/server/routes/__tests__/convos.spec.js b/api/server/routes/__tests__/convos.spec.js
index aeea165282c4..5ea91091ffb1 100644
--- a/api/server/routes/__tests__/convos.spec.js
+++ b/api/server/routes/__tests__/convos.spec.js
@@ -325,15 +325,23 @@ describe('Convos Routes', () => {
       expect(response.body).toEqual(mockDbResponse);
 
       /** Verify deleteConvos was called with correct parameters */
-      expect(deleteConvos).toHaveBeenCalledWith('test-user-123', {
-        conversationId: mockConversationId,
-      }, expect.anything());
+      expect(deleteConvos).toHaveBeenCalledWith(
+        'test-user-123',
+        {
+          conversationId: mockConversationId,
+        },
+        expect.anything(),
+      );
 
       /** Verify deleteToolCalls was called */
       expect(deleteToolCalls).toHaveBeenCalledWith('test-user-123', mockConversationId);
 
       /** Verify deleteConvoSharedLink was called */
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith(
+        'test-user-123',
+        mockConversationId,
+        expect.anything(),
+      );
     });
 
     it('should not call deleteConvoSharedLink when no conversationId provided', async () => {
@@ -371,7 +379,11 @@ describe('Convos Routes', () => {
         });
 
       expect(response.status).toBe(201);
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith(
+        'test-user-123',
+        mockConversationId,
+        expect.anything(),
+      );
     });
 
     it('should return 400 when no parameters provided', async () => {
@@ -489,7 +501,11 @@ describe('Convos Routes', () => {
       expect(response.status).toBe(201);
 
       /** Verify shared links were deleted for the specific conversation */
-      expect(deleteConvoSharedLink).toHaveBeenCalledWith('test-user-123', mockConversationId, expect.anything());
+      expect(deleteConvoSharedLink).toHaveBeenCalledWith(
+        'test-user-123',
+        mockConversationId,
+        expect.anything(),
+      );
 
       /** Verify it was called after the conversation was deleted */
       expect(deleteConvoSharedLink).toHaveBeenCalledAfter(deleteConvos);

From 07703595afd8b56e6f1303f25f4a75c13462b016 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:12:34 +0000
Subject: [PATCH 57/94] Update packages/api/src/auth/openid.ts

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 packages/api/src/auth/openid.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/api/src/auth/openid.ts b/packages/api/src/auth/openid.ts
index a1f7a4681f05..61e22378a4f1 100644
--- a/packages/api/src/auth/openid.ts
+++ b/packages/api/src/auth/openid.ts
@@ -42,7 +42,7 @@ export async function findOpenIDUser({
     // If user found by email, check if they're allowed to use this provider (OpenID or Solid)
     const allowedProviders =
       strategyName === 'SolidOpenidStrategy' ? ['openid', 'solid'] : ['openid'];
-    if (user && user.provider && !allowedProviders.includes(user.provider)) {
+    if (user?.provider && !allowedProviders.includes(user.provider)) {
       logger.warn(
         `[${strategyName}] Attempted OpenID login by user ${user.email}, was registered with "${user.provider}" provider`,
       );

From a02a76bdc29b9e968209afcf406e286daac7f74e Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:19:02 +0000
Subject: [PATCH 58/94] Added comment back

---
 api/models/Conversation.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 29cc7c3fcfae..49c5798dcb5d 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -171,7 +171,8 @@ module.exports = {
       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 },
         updateOperation,

From 2c740481c9b24ec7d806c01590e4b5b8e4c58033 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:28:27 +0000
Subject: [PATCH 59/94] remove commented code

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/strategies/jwtStrategy.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/api/strategies/jwtStrategy.js b/api/strategies/jwtStrategy.js
index 1c0e9d4766f9..e9cffba05994 100644
--- a/api/strategies/jwtStrategy.js
+++ b/api/strategies/jwtStrategy.js
@@ -32,7 +32,6 @@ const jwtExtractor = (req) => {
 const jwtLogin = () =>
   new JwtStrategy(
     {
-      // jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
       jwtFromRequest: jwtExtractor,
       secretOrKey: process.env.JWT_SECRET,
     },

From c3405067e46b84c904ebfe89c3630393285c66ad Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:38:45 +0000
Subject: [PATCH 60/94] checkout queries.ts file from main to rebase

---
 client/src/data-provider/SSE/queries.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/client/src/data-provider/SSE/queries.ts b/client/src/data-provider/SSE/queries.ts
index 9c683ab5b7ac..76c500c5303d 100644
--- a/client/src/data-provider/SSE/queries.ts
+++ b/client/src/data-provider/SSE/queries.ts
@@ -140,7 +140,7 @@ export function useTitleGeneration(enabled = true) {
  * - Shows generation indicators in conversation list
  */
 export function useActiveJobs(enabled = true) {
-  const query = useQuery({
+  return useQuery({
     queryKey: [QueryKeys.activeJobs],
     queryFn: () => dataService.getActiveJobs(),
     enabled,
@@ -150,6 +150,4 @@ export function useActiveJobs(enabled = true) {
     refetchInterval: (data) => ((data?.activeJobIds?.length ?? 0) > 0 ? 5_000 : false),
     retry: false,
   });
-
-  return query;
 }

From 983f47acbbe03201f41d7cce18ab197bc93b3825 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:48:22 +0000
Subject: [PATCH 61/94] fix Unrelated re-ordering

---
 api/strategies/index.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/api/strategies/index.js b/api/strategies/index.js
index 98816c8c3568..f666f15464d0 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -6,10 +6,10 @@ const discordLogin = require('./discordStrategy');
 const passportLogin = require('./localStrategy');
 const googleLogin = require('./googleStrategy');
 const githubLogin = require('./githubStrategy');
-const jwtLogin = require('./jwtStrategy');
-const ldapLogin = require('./ldapStrategy');
 const { setupSaml } = require('./samlStrategy');
 const appleLogin = require('./appleStrategy');
+const ldapLogin = require('./ldapStrategy');
+const jwtLogin = require('./jwtStrategy');
 
 module.exports = {
   appleLogin,

From a38a3fc7c4505a5e0e8036a7352e4ffb0c876b3e Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:50:57 +0000
Subject: [PATCH 62/94] remove optional chaining

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 packages/data-provider/src/config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 9f2f7557f81a..5a0b0fd3367d 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -768,7 +768,7 @@ export type TStartupConfig = {
   openidAutoRedirect: boolean;
   solidLoginEnabled: boolean;
   solidLabel: string;
-  solidImageUrl?: string;
+  solidImageUrl: string;
   solidAutoRedirect: boolean;
   samlLabel: string;
   samlImageUrl: string;

From 9d5c9dd98b38b288a7d4d29812cb21b4442ba6e6 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:52:13 +0000
Subject: [PATCH 63/94] remove fetch require import

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/server/services/SolidStorage.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 92acae57dd4e..4684e98fc7c6 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1,5 +1,4 @@
 const { logger } = require('@librechat/data-schemas');
-const fetch = require('node-fetch');
 const { DataFactory, Writer, Parser } = require('n3');
 
 // LDP (Linked Data Platform) namespace for parsing container Turtle responses

From ef72a16e49bf2f55194e5386780f8f3ef6ab5bf6 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 11:53:39 +0000
Subject: [PATCH 64/94] Update api/server/services/SolidStorage.js

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/server/services/SolidStorage.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 4684e98fc7c6..5f2c5559b001 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -671,7 +671,7 @@ async function getMessagesFromSolid(req, conversationId) {
         files: messageFiles.map((f) => f.url),
       });
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error.status === 404) {
         // Container doesn't exist, return empty array
         logger.info('[SolidStorage] Messages container does not exist, returning empty array', {
           messagesContainerPath,

From f323f2b165fdcaf35d9c00c551b3278ee15ed26d Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 15:32:00 +0000
Subject: [PATCH 65/94] feat(SolidStorage): robust Pod discovery via Link
 header, profile storage, path walk

---
 api/package.json                    |   1 +
 api/server/services/SolidStorage.js | 120 ++++++++++++++++++++++------
 package-lock.json                   |   1 +
 3 files changed, 97 insertions(+), 25 deletions(-)

diff --git a/api/package.json b/api/package.json
index e35ae9a2ae4d..b0a363984d74 100644
--- a/api/package.json
+++ b/api/package.json
@@ -71,6 +71,7 @@
     "firebase": "^11.0.2",
     "form-data": "^4.0.4",
     "handlebars": "^4.7.7",
+    "http-link-header": "^1.1.3",
     "https-proxy-agent": "^7.0.6",
     "ioredis": "^5.3.2",
     "js-yaml": "^4.1.1",
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 5f2c5559b001..3fafe54e5a7e 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1,5 +1,6 @@
 const { logger } = require('@librechat/data-schemas');
 const { DataFactory, Writer, Parser } = require('n3');
+const LinkHeader = require('http-link-header');
 
 // LDP (Linked Data Platform) namespace for parsing container Turtle responses
 const LDP_NS = 'http://www.w3.org/ns/ldp#';
@@ -27,12 +28,23 @@ const {
   deleteFile,
   getPodUrlAll,
   createContainerAt,
+  getSolidDataset,
+  getThing,
+  getUrl,
 } = require('@inrupt/solid-client');
 
 // ACL/ACP namespaces
 const ACL_NS = 'http://www.w3.org/ns/auth/acl#';
 const RDF_NS = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
 const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
+/** PIM Space vocabulary: Storage type (Link header) and storage predicate (profile data) */
+const PIM_SPACE_STORAGE_TYPE = 'http://www.w3.org/ns/pim/space#Storage';
+const PIM_SPACE_STORAGE_PREDICATE = 'http://www.w3.org/ns/pim/space#storage';
+
+/** @param {string} url - @returns {string} URL with trailing slash */
+function ensureTrailingSlash(url) {
+  return url.endsWith('/') ? url : `${url}/`;
+}
 
 /**
  * Solid Storage Utility Module
@@ -206,6 +218,67 @@ async function getSolidFetch(req) {
   }
 }
 
+/**
+ * Discover Pod root from a resource URL using Solid conventions (Link header, profile storage, path walk).
+ * Based on https://github.com/SolidLabResearch/Bashlib/blob/80de25cbb4b3ed057f95e25bc057f1be9b00cef3/src/utils/util.ts getPodRoot.
+ * Uses http-link-header (same as Bashlib) for Link header parsing.
+ *
+ * Real servers (e.g. solidcommunity.net): profile document has Link headers but no Storage type;
+ * the Pod root (e.g. https://user.solidcommunity.net/) returns Link: <http://www.w3.org/ns/pim/space#Storage>; rel="type".
+ * The profile Turtle has space:storage on the #me subject (WebID), not on the document URL.
+ *
+ * @param {string} url - Resource URL (e.g. WebID document URL without fragment) for HEAD/path walk
+ * @param {Function} fetch - Authenticated fetch function
+ * @param {string} [webId] - Full WebID (with #me) so we can read space:storage from the profile subject
+ * @returns {Promise<string|null>} Pod root URL with trailing slash, or null if not found
+ */
+async function getPodRoot(url, fetch, webId) {
+  if (!url || !fetch) return null;
+  try {
+    const res = await fetch(url, { method: 'HEAD' });
+    if (!res.ok) return null;
+
+    const linkHeaders = res.headers.get('Link');
+    if (linkHeaders) {
+      const parsed = LinkHeader.parse(linkHeaders);
+      for (const ref of parsed.refs) {
+        const isStorageType =
+          ref.rel === 'type' &&
+          (ref.uri === PIM_SPACE_STORAGE_TYPE || ref.type === PIM_SPACE_STORAGE_TYPE);
+        if (isStorageType) {
+          const podUrl = ensureTrailingSlash(url);
+          logger.debug('[SolidStorage] Pod root from Link header', { url, podUrl });
+          return podUrl;
+        }
+      }
+    }
+
+    try {
+      const ds = await getSolidDataset(url, { fetch });
+      // space:storage is on the WebID subject (#me), not the document URL (see solidcommunity.net profile/card)
+      const thing = webId ? getThing(ds, webId) : getThing(ds, url);
+      const storageUrl = thing ? getUrl(thing, PIM_SPACE_STORAGE_PREDICATE) : null;
+      if (storageUrl) {
+        const podUrl = ensureTrailingSlash(storageUrl);
+        logger.debug('[SolidStorage] Pod root from profile storage predicate', { url, podUrl });
+        return podUrl;
+      }
+    } catch (_ignored) {
+      // Not a Solid dataset or no storage pointer
+    }
+
+    const splitUrl = url.split('/');
+    const index = url.endsWith('/') ? splitUrl.length - 2 : splitUrl.length - 1;
+    if (index < 0) return null;
+    const nextUrl = splitUrl.slice(0, index).join('/') + '/';
+    if (nextUrl === url) return null; // avoid infinite loop when at server root
+    return getPodRoot(nextUrl, fetch, webId);
+  } catch (err) {
+    logger.debug('[SolidStorage] getPodRoot failed for url', { url, error: err?.message });
+    return null;
+  }
+}
+
 /**
  * Get user's Pod URL from their WebID
  *
@@ -243,50 +316,48 @@ async function getPodUrl(webId, fetch) {
       });
     }
 
-    // If no Pod URLs found, derive from WebID as fallback
+    // If no Pod URLs found, use Solid discovery (Link header + profile storage + path walk), then path heuristic
     if (!podUrls || podUrls.length === 0) {
       logger.info('[SolidStorage] No Pod URLs found in profile, deriving from WebID', { webId });
 
-      // Extract base URL from WebID
-      // WebID format: http://localhost:3000/bisi/profile/card#me
-      // Pod URL format: http://localhost:3000/bisi/
       try {
         const webIdUrl = new URL(webId);
-        // Remove the fragment (#me) and path segments after the pod identifier
-        // For most Solid servers, the Pod is at the root or one level deep
-        // Pattern: http://host:port/podId/ -> Pod URL
-        const pathParts = webIdUrl.pathname.split('/').filter((p) => p);
+        // Resource URL = WebID without fragment (e.g. http://localhost:3000/bisi/profile/card)
+        const resourceUrl = webIdUrl.hash
+          ? webIdUrl.href.replace(webIdUrl.hash, '')
+          : webIdUrl.href;
+
+        // 1) Solid discovery: Link header, then profile storage predicate, then path walk (Bashlib getPodRoot)
+        // Pass webId so we can read space:storage from the #me subject in the profile document
+        let derivedPodUrl = await getPodRoot(resourceUrl, fetch, webId);
+        if (derivedPodUrl) {
+          logger.info('[SolidStorage] Derived Pod URL via Solid discovery', {
+            webId,
+            derivedPodUrl,
+          });
+          return derivedPodUrl;
+        }
 
-        // If path contains 'profile', 'card', or similar, remove them
-        // The Pod is usually at the base or one level up
+        // 2) Fallback: path-based heuristic (WebID format: .../podId/profile/card#me -> Pod at .../podId/)
+        const pathParts = webIdUrl.pathname.split('/').filter((p) => p);
         let podPath = '/';
         if (pathParts.length > 0) {
-          // For pattern like /bisi/profile/card, Pod is at /bisi/
-          // For pattern like /profile/card, Pod is at /
           const podIdentifier = pathParts[0];
           if (podIdentifier && podIdentifier !== 'profile' && podIdentifier !== 'card') {
             podPath = `/${podIdentifier}/`;
           }
         }
-
-        const derivedPodUrl = `${webIdUrl.protocol}//${webIdUrl.host}${podPath}`;
-        logger.info('[SolidStorage] Derived Pod URL from WebID', {
+        derivedPodUrl = `${webIdUrl.protocol}//${webIdUrl.host}${podPath}`;
+        logger.info('[SolidStorage] Derived Pod URL from path heuristic', {
           webId,
           derivedPodUrl,
           pathParts,
         });
 
-        // Verify the Pod URL is accessible by trying to fetch the root
+        // Verify the derived Pod URL is accessible
         try {
-          const response = await fetch(derivedPodUrl, {
-            method: 'HEAD',
-          });
+          const response = await fetch(derivedPodUrl, { method: 'HEAD' });
           if (response.ok || response.status === 401 || response.status === 403) {
-            // 401/403 means the Pod exists but we need auth (which is expected)
-            logger.info('[SolidStorage] Derived Pod URL is accessible', {
-              derivedPodUrl,
-              status: response.status,
-            });
             return derivedPodUrl;
           }
         } catch (verifyError) {
@@ -295,7 +366,6 @@ async function getPodUrl(webId, fetch) {
             error: verifyError.message,
           });
         }
-
         return derivedPodUrl;
       } catch (urlError) {
         logger.error('[SolidStorage] Failed to derive Pod URL from WebID', {
diff --git a/package-lock.json b/package-lock.json
index 03cfb2e0945a..365c14f99dc0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -86,6 +86,7 @@
         "firebase": "^11.0.2",
         "form-data": "^4.0.4",
         "handlebars": "^4.7.7",
+        "http-link-header": "^1.1.3",
         "https-proxy-agent": "^7.0.6",
         "ioredis": "^5.3.2",
         "js-yaml": "^4.1.1",

From 2989f9e6786710f3ae13193b9147d12e2e494175 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 18 Feb 2026 16:32:47 +0000
Subject: [PATCH 66/94] feat(SolidStorage): ensure base structure once after
 login, baton for writes

- Run ensureBaseStructure in background after Solid/OpenID login (oauth handler)
- Writes await baton so they don't run until base structure is ready
- Lazy init if user never hit OAuth callback; return promise so .catch() is safe
---
 api/server/routes/oauth.js          | 10 +++++
 api/server/services/SolidStorage.js | 66 ++++++++++++++++++++++++++++-
 2 files changed, 74 insertions(+), 2 deletions(-)

diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 474dce66805a..2dd37a0fc1fc 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -9,6 +9,7 @@ const { checkDomainAllowed, loginLimiter, logHeaders, checkBan } = require('~/se
 const { createOAuthHandler: _createOAuthHandler } = require('~/server/controllers/auth/oauth');
 const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
 const { syncUserEntraGroupMemberships } = require('~/server/services/PermissionService');
+const { startBaseStructureAfterLogin } = require('~/server/services/SolidStorage');
 const { getAppConfig } = require('~/server/services/Config');
 const { Balance } = require('~/db/models');
 
@@ -62,6 +63,15 @@ const oauthHandler = async (req, res, next) => {
         // When OPENID_REUSE_TOKENS is disabled, create standard JWT tokens
         await setAuthTokens(req.user._id, res);
       }
+      // Ensure Solid Pod base structure in background so writes don't call it every time (baton)
+      if (req.user.openidId) {
+        startBaseStructureAfterLogin(req).catch((err) =>
+          logger.warn('[oauthHandler] Solid base structure init after login failed', {
+            openidId: req.user.openidId,
+            error: err?.message,
+          }),
+        );
+      }
     } else {
       await setAuthTokens(req.user._id, res);
     }
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 3fafe54e5a7e..3713f2c53418 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -562,6 +562,67 @@ async function ensureBaseStructure(podUrl, fetch) {
   }
 }
 
+/** Per-user baton: openidId -> Promise that resolves when ensureBaseStructure has completed for that Pod */
+const baseStructureBatonMap = new Map();
+
+/**
+ * Waits for the Pod base structure to be ready for this user (baton).
+ * If login already started ensureBaseStructure in the background, we wait for it.
+ * Otherwise we run it once (lazy) and cache the promise so other writes wait too.
+ *
+ * @param {Object} req - Express request (must have req.user.openidId)
+ * @returns {Promise<void>}
+ */
+async function ensureBaseStructureReady(req) {
+  const openidId = req?.user?.openidId;
+  if (!openidId) {
+    throw new Error('User not authenticated with Solid/OpenID');
+  }
+  let promise = baseStructureBatonMap.get(openidId);
+  if (!promise) {
+    const authenticatedFetch = await getSolidFetch(req);
+    const podUrl = await getPodUrl(openidId, authenticatedFetch);
+    promise = ensureBaseStructure(podUrl, authenticatedFetch).catch((err) => {
+      baseStructureBatonMap.delete(openidId);
+      throw err;
+    });
+    baseStructureBatonMap.set(openidId, promise);
+  }
+  await promise;
+}
+
+/**
+ * Starts ensureBaseStructure in the background for this user (call after Solid/OpenID login).
+ * Writes will wait for this to complete via ensureBaseStructureReady (baton).
+ * Safe to call multiple times per user; only the first run is used.
+ *
+ * @param {Object} req - Express request (must have req.user with openidId and session for fetch)
+ */
+function startBaseStructureAfterLogin(req) {
+  const openidId = req?.user?.openidId;
+  if (!openidId) return Promise.resolve();
+  const existing = baseStructureBatonMap.get(openidId);
+  if (existing) return existing;
+
+  const promise = (async () => {
+    try {
+      const authenticatedFetch = await getSolidFetch(req);
+      const podUrl = await getPodUrl(openidId, authenticatedFetch);
+      await ensureBaseStructure(podUrl, authenticatedFetch);
+      logger.debug('[SolidStorage] Base structure ready after login', { openidId });
+    } catch (err) {
+      baseStructureBatonMap.delete(openidId);
+      logger.warn('[SolidStorage] Base structure init after login failed', {
+        openidId,
+        error: err?.message,
+      });
+      throw err;
+    }
+  })();
+  baseStructureBatonMap.set(openidId, promise);
+  return promise;
+}
+
 /**
  * Save a message to Solid Pod.
  * Document content is built in the model layer (schema-aligned); this only persists it.
@@ -589,9 +650,9 @@ async function saveMessageToSolid(req, messageDocument, metadata) {
       throw new Error('conversationId is required');
     }
 
+    await ensureBaseStructureReady(req);
     const authenticatedFetch = await getSolidFetch(req);
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
-    await ensureBaseStructure(podUrl, authenticatedFetch);
 
     const messagesContainerPath = getMessagesContainerPath(podUrl, messageDocument.conversationId);
     await ensureContainerExists(messagesContainerPath, authenticatedFetch);
@@ -1209,9 +1270,9 @@ async function saveConvoToSolid(req, convoDocument, metadata) {
       throw new Error('conversationId is required');
     }
 
+    await ensureBaseStructureReady(req);
     const authenticatedFetch = await getSolidFetch(req);
     const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
-    await ensureBaseStructure(podUrl, authenticatedFetch);
 
     const conversationPath = getConversationPath(podUrl, finalConversationId);
 
@@ -2948,6 +3009,7 @@ module.exports = {
   getMessagePath,
   ensureContainerExists,
   ensureBaseStructure,
+  startBaseStructureAfterLogin,
   saveMessageToSolid,
   getMessagesFromSolid,
   updateMessageInSolid,

From e9f7016511f595c799f06f3a48ad70279e125174 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 19 Feb 2026 14:30:52 +0000
Subject: [PATCH 67/94] fix(solid): use status-only error checks

---
 api/server/services/SolidStorage.js | 55 ++++++++++++-----------------
 1 file changed, 23 insertions(+), 32 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 3713f2c53418..66c1a42c67cb 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -474,27 +474,21 @@ async function ensureContainerExists(containerUrl, fetch) {
 
       // If we get here, container might not exist
       if (response.status === 404) {
-        throw new Error('Container not found');
+        const err = new Error('Container not found');
+        err.status = 404;
+        err.response = { status: 404 };
+        throw err;
       }
     } catch (error) {
-      // Container doesn't exist, create it
-      if (
-        error.status === 404 ||
-        error.message?.includes('404') ||
-        error.message?.includes('not found') ||
-        error.message?.includes('Container not found')
-      ) {
+      // Container doesn't exist, create it (use status only)
+      if (error?.status === 404 || error?.response?.status === 404) {
         logger.info('[SolidStorage] Container does not exist, creating', { containerUrl });
         try {
           await createContainerAt(containerUrl, { fetch });
           logger.info('[SolidStorage] Container created successfully', { containerUrl });
         } catch (createError) {
           // If creation fails with 409, container already exists (race condition)
-          if (
-            createError.status === 409 ||
-            createError.message?.includes('409') ||
-            createError.message?.includes('already exists')
-          ) {
+          if (createError?.status === 409 || createError?.response?.status === 409) {
             logger.debug('[SolidStorage] Container already exists (race condition)', {
               containerUrl,
             });
@@ -678,7 +672,7 @@ async function saveMessageToSolid(req, messageDocument, metadata) {
       await getFile(messagePath, { fetch: authenticatedFetch });
       messageExists = true;
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         messageExists = false;
       } else {
         logger.warn('[SolidStorage] Error checking if message exists, will try to save anyway', {
@@ -1037,7 +1031,7 @@ async function updateMessageInSolid(req, messageData, metadata) {
         conversationId,
       });
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         throw new Error(`Message with ID ${messageData.messageId} not found`);
       }
       throw error;
@@ -1211,7 +1205,7 @@ async function deleteMessagesFromSolid(req, params) {
           messageId: message.messageId,
         });
       } catch (error) {
-        if (error.status === 404 || error.message?.includes('404')) {
+        if (error?.status === 404 || error?.response?.status === 404) {
           // File already doesn't exist, count it as deleted
           logger.debug('[SolidStorage] Message file already deleted', {
             messageId: message.messageId,
@@ -1286,7 +1280,7 @@ async function saveConvoToSolid(req, convoDocument, metadata) {
         hasTitle: !!existingConversation.title,
       });
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         logger.debug('[SolidStorage] Conversation does not exist yet, will create new', {
           conversationId: finalConversationId,
         });
@@ -1569,7 +1563,7 @@ async function getConvoFromSolid(req, conversationId) {
 
       return conversationData;
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         logger.info('[SolidStorage] Conversation not found', {
           conversationId,
         });
@@ -1710,14 +1704,11 @@ async function getConvosByCursorFromSolid(req, options = {}) {
         responseStatusText: error?.response?.statusText,
       });
 
-      // Check if error is a 404 (container doesn't exist)
+      // Check if error is a 404 (container doesn't exist) - use status only
       const isNotFound =
         errorStatus === 404 ||
         errorStatus === '404' ||
-        errorMessage?.includes('404') ||
-        errorMessage?.includes('Not Found') ||
-        errorMessage?.toLowerCase().includes('not found') ||
-        errorMessage?.toLowerCase().includes('404');
+        error?.response?.status === 404;
 
       if (isNotFound) {
         // Container doesn't exist, return empty result (this is expected for new users)
@@ -2066,7 +2057,7 @@ async function deleteConvosFromSolid(req, conversationIds) {
             conversationPath,
           });
         } catch (error) {
-          if (error.status === 404 || error.message?.includes('404')) {
+          if (error?.status === 404 || error?.response?.status === 404) {
             // File already doesn't exist, count it as deleted
             deletedCount++;
             logger.debug('[SolidStorage] Conversation file already deleted', {
@@ -2166,12 +2157,12 @@ async function fetchAcl(aclUrl, fetchFn) {
     }
     return await response.text();
   } catch (error) {
-    // Treat 404 and 403 as "no ACL exists"
+    // Treat 404 and 403 as "no ACL exists" (use status only)
     if (
-      error.status === 404 ||
-      error.status === 403 ||
-      error.message?.includes('404') ||
-      error.message?.includes('403')
+      error?.status === 404 ||
+      error?.status === 403 ||
+      error?.response?.status === 404 ||
+      error?.response?.status === 403
     ) {
       return null;
     }
@@ -2738,7 +2729,7 @@ async function removePublicAccessForShare(req, conversationId) {
         conversationId,
       });
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         logger.debug('[SolidStorage] Conversation file not found when removing public access', {
           conversationPath,
           conversationId,
@@ -2767,7 +2758,7 @@ async function removePublicAccessForShare(req, conversationId) {
         conversationId,
       });
     } catch (error) {
-      if (error.status === 404 || error.message?.includes('404')) {
+      if (error?.status === 404 || error?.response?.status === 404) {
         logger.debug('[SolidStorage] Messages container not found when removing public access', {
           messagesContainerPath,
           conversationId,
@@ -2808,7 +2799,7 @@ async function removePublicAccessForShare(req, conversationId) {
         await removePublicReadAccess(messagePath, authenticatedFetch);
         messagesUnshared++;
       } catch (error) {
-        if (error.status === 404 || error.message?.includes('404')) {
+        if (error?.status === 404 || error?.response?.status === 404) {
           logger.debug('[SolidStorage] Message file not found when removing public access', {
             messageId: message.messageId,
             conversationId,

From 6bc3f0feb815321ba74ecea7af09fe197c3e2986 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 19 Feb 2026 14:39:45 +0000
Subject: [PATCH 68/94] perf(solid): fetch message files in parallel in
 getMessagesFromSolid

Use Promise.all over messageFiles so getFile + file.text() run in parallel
instead of sequentially; keep per-file error handling and validation.
---
 api/server/services/SolidStorage.js | 78 ++++++++++++++++-------------
 1 file changed, 42 insertions(+), 36 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 66c1a42c67cb..642fc0e19ef9 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -811,49 +811,55 @@ async function getMessagesFromSolid(req, conversationId) {
       fileCount: messageFiles.length,
     });
 
-    // Read all message files
-    const messages = [];
-    for (const fileInfo of messageFiles) {
-      try {
+    // Read all message files in parallel
+    const messageDataResults = await Promise.all(
+      messageFiles.map(async (fileInfo) => {
         const fileUrl = fileInfo.url;
-        logger.debug('[SolidStorage] Reading message file', {
-          fileUrl,
-          conversationId,
-        });
-
-        const file = await getFile(fileUrl, { fetch: authenticatedFetch });
-        const fileText = await file.text();
-        const messageData = JSON.parse(fileText);
-
-        // Validate that this message belongs to the current user
-        if (messageData.user !== req.user.id) {
-          logger.warn('[SolidStorage] Message belongs to different user, skipping', {
-            messageId: messageData.messageId,
-            messageUserId: messageData.user,
-            currentUserId: req.user.id,
+        try {
+          logger.debug('[SolidStorage] Reading message file', {
+            fileUrl,
+            conversationId,
           });
-          continue;
-        }
-
-        // Validate that this message belongs to the requested conversation
-        if (messageData.conversationId !== conversationId) {
-          logger.warn('[SolidStorage] Message belongs to different conversation, skipping', {
-            messageId: messageData.messageId,
-            messageConversationId: messageData.conversationId,
-            requestedConversationId: conversationId,
+          const file = await getFile(fileUrl, { fetch: authenticatedFetch });
+          const fileText = await file.text();
+          const messageData = JSON.parse(fileText);
+          return messageData;
+        } catch (error) {
+          logger.error('[SolidStorage] Error reading message file', {
+            fileUrl,
+            conversationId,
+            error: error.message,
           });
-          continue;
+          return null;
         }
+      }),
+    );
 
-        messages.push(messageData);
-      } catch (error) {
-        logger.error('[SolidStorage] Error reading message file', {
-          fileUrl: fileInfo.url,
-          conversationId,
-          error: error.message,
+    const messages = [];
+    for (const messageData of messageDataResults) {
+      if (!messageData) continue;
+
+      // Validate that this message belongs to the current user
+      if (messageData.user !== req.user.id) {
+        logger.warn('[SolidStorage] Message belongs to different user, skipping', {
+          messageId: messageData.messageId,
+          messageUserId: messageData.user,
+          currentUserId: req.user.id,
         });
-        // Continue with other files even if one fails
+        continue;
+      }
+
+      // Validate that this message belongs to the requested conversation
+      if (messageData.conversationId !== conversationId) {
+        logger.warn('[SolidStorage] Message belongs to different conversation, skipping', {
+          messageId: messageData.messageId,
+          messageConversationId: messageData.conversationId,
+          requestedConversationId: conversationId,
+        });
+        continue;
       }
+
+      messages.push(messageData);
     }
 
     // Sort messages by createdAt (ascending)

From 7c038ae65a8c88cb80a3bdfd1993f4d5cecd6f0e Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 19 Feb 2026 15:25:24 +0000
Subject: [PATCH 69/94] perf(solid): cache Pod URL in session to avoid repeated
 profile requests

---
 api/server/services/SolidStorage.js | 66 ++++++++++++++++++-----------
 1 file changed, 42 insertions(+), 24 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 642fc0e19ef9..db2447f96957 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -394,6 +394,36 @@ async function getPodUrl(webId, fetch) {
   }
 }
 
+/**
+ * Get authenticated fetch and Pod URL for the current Solid user, with session cache.
+ * Pod URL is fetched once per session (e.g. at first use after login) to avoid repeated profile requests.
+ *
+ * @param {Object} req - Express request (must have req.user.openidId and session)
+ * @returns {Promise<{ authenticatedFetch: Function, podUrl: string }>}
+ */
+async function getSolidFetchAndPodUrl(req) {
+  const openidId = req?.user?.openidId;
+  if (!openidId) {
+    throw new Error('User not authenticated with Solid/OpenID');
+  }
+
+  const cached =
+    req.session?.solidCachedPodUrlWebId === openidId && req.session?.solidCachedPodUrl;
+  if (cached) {
+    const authenticatedFetch = await getSolidFetch(req);
+    logger.debug('[SolidStorage] Using cached Pod URL from session', { openidId });
+    return { authenticatedFetch, podUrl: req.session.solidCachedPodUrl };
+  }
+
+  const authenticatedFetch = await getSolidFetch(req);
+  const podUrl = await getPodUrl(openidId, authenticatedFetch);
+  if (req.session) {
+    req.session.solidCachedPodUrl = podUrl;
+    req.session.solidCachedPodUrlWebId = openidId;
+  }
+  return { authenticatedFetch, podUrl };
+}
+
 /**
  * Get base storage path for LibreChat data in Pod
  *
@@ -574,8 +604,7 @@ async function ensureBaseStructureReady(req) {
   }
   let promise = baseStructureBatonMap.get(openidId);
   if (!promise) {
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
     promise = ensureBaseStructure(podUrl, authenticatedFetch).catch((err) => {
       baseStructureBatonMap.delete(openidId);
       throw err;
@@ -600,8 +629,7 @@ function startBaseStructureAfterLogin(req) {
 
   const promise = (async () => {
     try {
-      const authenticatedFetch = await getSolidFetch(req);
-      const podUrl = await getPodUrl(openidId, authenticatedFetch);
+      const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
       await ensureBaseStructure(podUrl, authenticatedFetch);
       logger.debug('[SolidStorage] Base structure ready after login', { openidId });
     } catch (err) {
@@ -645,8 +673,7 @@ async function saveMessageToSolid(req, messageDocument, metadata) {
     }
 
     await ensureBaseStructureReady(req);
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     const messagesContainerPath = getMessagesContainerPath(podUrl, messageDocument.conversationId);
     await ensureContainerExists(messagesContainerPath, authenticatedFetch);
@@ -743,8 +770,7 @@ async function getMessagesFromSolid(req, conversationId) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // Get messages container path
     const messagesContainerPath = getMessagesContainerPath(podUrl, conversationId);
@@ -919,8 +945,7 @@ async function updateMessageInSolid(req, messageData, metadata) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // First, try to get the existing message to merge updates
     let existingMessage = null;
@@ -1124,8 +1149,7 @@ async function deleteMessagesFromSolid(req, params) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // Get messages container path
     const _messagesContainerPath = getMessagesContainerPath(podUrl, params.conversationId);
@@ -1271,8 +1295,7 @@ async function saveConvoToSolid(req, convoDocument, metadata) {
     }
 
     await ensureBaseStructureReady(req);
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     const conversationPath = getConversationPath(podUrl, finalConversationId);
 
@@ -1421,8 +1444,7 @@ async function getConvoFromSolid(req, conversationId) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // Get conversation file path
     const conversationPath = getConversationPath(podUrl, conversationId);
@@ -1640,9 +1662,8 @@ async function getConvosByCursorFromSolid(req, options = {}) {
     const finalSortDirection = sortDirection === 'asc' ? 'asc' : 'desc';
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
     // TODO: Allow user to select their storage (can happen after the initial PR).
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
 
     // Get conversations container path
     const conversationsContainerPath = `${getBaseStoragePath(podUrl)}conversations/`;
@@ -1967,8 +1988,7 @@ async function deleteConvosFromSolid(req, conversationIds) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     let deletedCount = 0;
 
@@ -2548,8 +2568,7 @@ async function setPublicAccessForShare(req, conversationId) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // Get conversation file path
     const conversationPath = getConversationPath(podUrl, conversationId);
@@ -2717,8 +2736,7 @@ async function removePublicAccessForShare(req, conversationId) {
     }
 
     // Get authenticated fetch and Pod URL
-    const authenticatedFetch = await getSolidFetch(req);
-    const podUrl = await getPodUrl(req.user.openidId, authenticatedFetch);
+    const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
 
     // Get conversation file path
     const conversationPath = getConversationPath(podUrl, conversationId);

From b3e7939d2cee7e4d4cb4503f373a79e6138ebbb2 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 19 Feb 2026 15:33:50 +0000
Subject: [PATCH 70/94] chore: fixing eslinting

---
 api/models/Conversation.js          | 2 +-
 api/server/services/SolidStorage.js | 8 ++------
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/api/models/Conversation.js b/api/models/Conversation.js
index 49c5798dcb5d..f681fd15258b 100644
--- a/api/models/Conversation.js
+++ b/api/models/Conversation.js
@@ -171,7 +171,7 @@ module.exports = {
       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 },
diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index db2447f96957..53bd859dbbc0 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -407,8 +407,7 @@ async function getSolidFetchAndPodUrl(req) {
     throw new Error('User not authenticated with Solid/OpenID');
   }
 
-  const cached =
-    req.session?.solidCachedPodUrlWebId === openidId && req.session?.solidCachedPodUrl;
+  const cached = req.session?.solidCachedPodUrlWebId === openidId && req.session?.solidCachedPodUrl;
   if (cached) {
     const authenticatedFetch = await getSolidFetch(req);
     logger.debug('[SolidStorage] Using cached Pod URL from session', { openidId });
@@ -1732,10 +1731,7 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       });
 
       // Check if error is a 404 (container doesn't exist) - use status only
-      const isNotFound =
-        errorStatus === 404 ||
-        errorStatus === '404' ||
-        error?.response?.status === 404;
+      const isNotFound = errorStatus === 404 || errorStatus === '404' || error?.response?.status === 404;
 
       if (isNotFound) {
         // Container doesn't exist, return empty result (this is expected for new users)

From 4031ab692062149ed2c653e4158a5c9b6f3c6479 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Thu, 19 Feb 2026 15:42:12 +0000
Subject: [PATCH 71/94] chore: fix linting

---
 api/server/services/SolidStorage.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 53bd859dbbc0..2720783b1879 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -1731,7 +1731,8 @@ async function getConvosByCursorFromSolid(req, options = {}) {
       });
 
       // Check if error is a 404 (container doesn't exist) - use status only
-      const isNotFound = errorStatus === 404 || errorStatus === '404' || error?.response?.status === 404;
+      const isNotFound =
+        errorStatus === 404 || errorStatus === '404' || error?.response?.status === 404;
 
       if (isNotFound) {
         // Container doesn't exist, return empty result (this is expected for new users)

From ff6f506e5b8bbeb1637ddb64f8325c06aa086cf8 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Fri, 20 Feb 2026 15:35:06 +0000
Subject: [PATCH 72/94] jesse's changes for code optimization

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/server/services/SolidStorage.js | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 2720783b1879..c175a865e637 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -407,15 +407,8 @@ async function getSolidFetchAndPodUrl(req) {
     throw new Error('User not authenticated with Solid/OpenID');
   }
 
-  const cached = req.session?.solidCachedPodUrlWebId === openidId && req.session?.solidCachedPodUrl;
-  if (cached) {
-    const authenticatedFetch = await getSolidFetch(req);
-    logger.debug('[SolidStorage] Using cached Pod URL from session', { openidId });
-    return { authenticatedFetch, podUrl: req.session.solidCachedPodUrl };
-  }
-
   const authenticatedFetch = await getSolidFetch(req);
-  const podUrl = await getPodUrl(openidId, authenticatedFetch);
+  const podUrl = req.session?.solidCachedPodUrl ?? await getPodUrl(openidId, authenticatedFetch);
   if (req.session) {
     req.session.solidCachedPodUrl = podUrl;
     req.session.solidCachedPodUrlWebId = openidId;

From 17dd55fbb7982ed3422980fdc864a421c76c250b Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 20 Feb 2026 15:55:58 +0000
Subject: [PATCH 73/94] refactor(solid): use ensureBaseStructureReady in
 startBaseStructureAfterLogin

---
 api/server/services/SolidStorage.js | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index c175a865e637..87bc6a7174ad 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -616,25 +616,7 @@ async function ensureBaseStructureReady(req) {
 function startBaseStructureAfterLogin(req) {
   const openidId = req?.user?.openidId;
   if (!openidId) return Promise.resolve();
-  const existing = baseStructureBatonMap.get(openidId);
-  if (existing) return existing;
-
-  const promise = (async () => {
-    try {
-      const { authenticatedFetch, podUrl } = await getSolidFetchAndPodUrl(req);
-      await ensureBaseStructure(podUrl, authenticatedFetch);
-      logger.debug('[SolidStorage] Base structure ready after login', { openidId });
-    } catch (err) {
-      baseStructureBatonMap.delete(openidId);
-      logger.warn('[SolidStorage] Base structure init after login failed', {
-        openidId,
-        error: err?.message,
-      });
-      throw err;
-    }
-  })();
-  baseStructureBatonMap.set(openidId, promise);
-  return promise;
+  return ensureBaseStructureReady(req);
 }
 
 /**

From e426888c6a0e9febb7a7719644a19cd9c0f3faf3 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 20 Feb 2026 16:16:37 +0000
Subject: [PATCH 74/94] fix linting error

---
 api/server/services/SolidStorage.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/server/services/SolidStorage.js b/api/server/services/SolidStorage.js
index 87bc6a7174ad..f94ffc3a6d06 100644
--- a/api/server/services/SolidStorage.js
+++ b/api/server/services/SolidStorage.js
@@ -408,7 +408,7 @@ async function getSolidFetchAndPodUrl(req) {
   }
 
   const authenticatedFetch = await getSolidFetch(req);
-  const podUrl = req.session?.solidCachedPodUrl ?? await getPodUrl(openidId, authenticatedFetch);
+  const podUrl = req.session?.solidCachedPodUrl ?? (await getPodUrl(openidId, authenticatedFetch));
   if (req.session) {
     req.session.solidCachedPodUrl = podUrl;
     req.session.solidCachedPodUrlWebId = openidId;

From 7fc04f289eb190da4b15d54129288c75c6fc9692 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 23 Feb 2026 11:33:00 +0000
Subject: [PATCH 75/94] fixing merge conflict errors

---
 api/server/controllers/AuthController.js | 15 ++++++------
 api/server/socialLogins.js               | 30 ------------------------
 package-lock.json                        |  1 +
 3 files changed, 8 insertions(+), 38 deletions(-)

diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 5d1b3deb0f28..31e7e78f5b88 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -78,10 +78,11 @@ const refreshController = async (req, res) => {
       logger.warn(
         '[refreshController] No OpenID refresh token available, falling back to standard refresh',
       );
-      // Fall through to standard refresh logic below
-    } else {
-      // We have a refresh token, use OpenID refresh flow
-      try {
+      return res.status(200).send('Refresh token not provided');
+    }
+
+    // We have a refresh token, use OpenID refresh flow
+    try {
         const openIdConfig = getOpenIdConfig();
         const refreshParams = process.env.OPENID_SCOPE ? { scope: process.env.OPENID_SCOPE } : {};
       const tokenset = await openIdClient.refreshTokenGrant(
@@ -132,10 +133,8 @@ const refreshController = async (req, res) => {
         };
 
         return res.status(200).send({ token, user });
-      } catch (error) {
-        logger.error('[refreshController] OpenID token refresh error', error);
-        // Fall through to standard refresh logic as fallback
-      }
+    } catch (error) {
+      logger.error('[refreshController] OpenID token refresh error', error);
     }
   }
 
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index eb5193b16aae..3e1fb1c5505a 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -16,36 +16,6 @@ const {
 } = require('~/strategies');
 const { getLogStores } = require('~/cache');
 
-
-/**
- * Configures Solid OpenID Connect for the application.
- * @param {Express.Application} app - The Express application instance.
- * @returns {Promise<void>}
- */
-async function configureSolidOpenId(app) {
-  logger.info('Configuring Solid OpenID Connect...');
-  const sessionOptions = {
-    secret: process.env.SOLID_OPENID_SESSION_SECRET,
-    resave: false,
-    saveUninitialized: false,
-    store: getLogStores(CacheKeys.OPENID_SESSION),
-  };
-  app.use(session(sessionOptions));
-  app.use(passport.session());
-
-  const config = await setupSolidOpenId();
-  if (!config) {
-    logger.error('Solid OpenID Connect configuration failed - strategy not registered.');
-    return;
-  }
-
-  if (isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    logger.info('Solid OpenID token reuse is enabled.');
-    passport.use('solidJwt', openIdJwtLogin(config));
-  }
-  logger.info('Solid OpenID Connect configured successfully.');
-}
-
 /**
 * Configures Solid OpenID Connect for the application.
  * @param {Express.Application} app - The Express application instance.
diff --git a/package-lock.json b/package-lock.json
index 365c14f99dc0..1f7f24aaec42 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23831,6 +23831,7 @@
       "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.1.1.tgz",
       "integrity": "sha512-f0yv5CPKaFxfsPTBzX7vGuim4oIC1/gcS7LUGdBSwl2dU6+FON6LVUksdOo1qJjoUvXNn45urgh8C+0a24pACQ==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@chevrotain/cst-dts-gen": "11.1.1",
         "@chevrotain/gast": "11.1.1",

From 65c5d029badf11f635debfe16c91eda6c7f2130a Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Mon, 23 Feb 2026 11:48:23 +0000
Subject: [PATCH 76/94] fix ESlint fails

---
 api/server/controllers/AuthController.js | 64 ++++++++++++------------
 api/server/services/AuthService.js       | 11 ++--
 2 files changed, 38 insertions(+), 37 deletions(-)

diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 31e7e78f5b88..8f6c00e2fb33 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -99,40 +99,40 @@ const refreshController = async (req, res) => {
         strategyName: 'refreshController',
       });
 
-        logger.debug(
-          `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
+      logger.debug(
+        `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
+      );
+
+      if (error || !user) {
+        logger.warn(
+          `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
+        );
+        return res.status(401).redirect('/login');
+      }
+
+      // Handle migration: update user with openidId if found by email without openidId
+      // Also handle case where user has mismatched openidId (e.g., after database switch)
+      if (migration || user.openidId !== claims.sub) {
+        const reason = migration ? 'migration' : 'openidId mismatch';
+        await updateUser(user._id.toString(), {
+          provider: 'openid',
+          openidId: claims.sub,
+        });
+        logger.info(
+          `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
         );
+      }
 
-        if (error || !user) {
-          logger.warn(
-            `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
-          );
-          return res.status(401).redirect('/login');
-        }
-
-        // Handle migration: update user with openidId if found by email without openidId
-        // Also handle case where user has mismatched openidId (e.g., after database switch)
-        if (migration || user.openidId !== claims.sub) {
-          const reason = migration ? 'migration' : 'openidId mismatch';
-          await updateUser(user._id.toString(), {
-            provider: 'openid',
-            openidId: claims.sub,
-          });
-          logger.info(
-            `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
-          );
-        }
-
-        const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
-
-        user.federatedTokens = {
-          access_token: tokenset.access_token,
-          id_token: tokenset.id_token,
-          refresh_token: refreshToken,
-          expires_at: claims.exp,
-        };
-
-        return res.status(200).send({ token, user });
+      const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
+
+      user.federatedTokens = {
+        access_token: tokenset.access_token,
+        id_token: tokenset.id_token,
+        refresh_token: refreshToken,
+        expires_at: claims.exp,
+      };
+
+      return res.status(200).send({ token, user });
     } catch (error) {
       logger.error('[refreshController] OpenID token refresh error', error);
     }
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index f68cbf901352..31a0e884a08c 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -514,7 +514,7 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
         res.cookie('refreshToken', refreshToken, {
           expires: expirationDate,
           httpOnly: true,
-          secure: isProduction,
+          secure: shouldUseSecureCookie(),
           sameSite: 'strict',
         });
       }
@@ -524,10 +524,7 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
         secure: shouldUseSecureCookie(),
         sameSite: 'strict',
       });
-      logger.info('[setOpenIDAuthTokens] Tokens stored in cookies', {
-        hasAccessToken: !!tokenset.access_token,
-        hasRefreshToken: !!refreshToken,
-      });
+     
       if (tokenset.id_token) {
         res.cookie('openid_id_token', tokenset.id_token, {
           expires: expirationDate,
@@ -536,6 +533,10 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
           sameSite: 'strict',
         });
       }
+      logger.info('[setOpenIDAuthTokens] Tokens stored in cookies', {
+        hasAccessToken: !!tokenset.access_token,
+        hasRefreshToken: !!refreshToken,
+      });
     }
 
     /** Small cookie to indicate token provider (required for auth middleware) */

From b46b02bf8fafa9fa8dfbe633e558409763b44f9b Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 24 Feb 2026 11:32:48 +0000
Subject: [PATCH 77/94] fix(auth): allow Solid login when IdP does not send
 refresh token

Rebase had reverted behavior: setOpenIDAuthTokens was returning early when
!refreshToken, so session.openidTokens was never set and later requests
failed with "No OpenID access token found". Restore: log a warning and
continue storing access token in session; only set refreshToken cookie
when present; keep correct if/else for session vs cookie fallback.
---
 api/server/services/AuthService.js | 31 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index 31a0e884a08c..bf1125425ca1 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -451,8 +451,10 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
     // Log warning if no refresh token, but continue with access token only
     // Some providers (like Solid) may not provide refresh tokens
     if (!refreshToken) {
-      logger.error('[setOpenIDAuthTokens] No refresh token available');
-      return;
+      logger.warn('[setOpenIDAuthTokens] No refresh token available - will use access token only', {
+        hasAccessToken: !!tokenset.access_token,
+        provider: req.user?.provider,
+      });
     }
 
     /**
@@ -465,20 +467,17 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
     const appAuthToken = tokenset.id_token || tokenset.access_token;
 
     /**
-     * Always set refresh token cookie so it survives express session expiry.
-     * The session cookie maxAge (SESSION_EXPIRY, default 15 min) is typically shorter
-     * than the OIDC token lifetime (~1 hour). Without this cookie fallback, the refresh
-     * token stored only in the session is lost when the session expires, causing the user
-     * to be signed out on the next token refresh attempt.
-     * The refresh token is small (opaque string) so it doesn't hit the HTTP/2 header
-     * size limits that motivated session storage for the larger access_token/id_token.
+     * Set refresh token cookie when available so it survives express session expiry.
+     * Some providers (e.g. Solid) may not issue refresh tokens; then we rely on session only.
      */
-    res.cookie('refreshToken', refreshToken, {
-      expires: expirationDate,
-      httpOnly: true,
-      secure: shouldUseSecureCookie(),
-      sameSite: 'strict',
-    });
+    if (refreshToken) {
+      res.cookie('refreshToken', refreshToken, {
+        expires: expirationDate,
+        httpOnly: true,
+        secure: shouldUseSecureCookie(),
+        sameSite: 'strict',
+      });
+    }
 
     /** Store tokens server-side in session to avoid large cookies */
     if (req.session) {
@@ -524,7 +523,7 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
         secure: shouldUseSecureCookie(),
         sameSite: 'strict',
       });
-     
+
       if (tokenset.id_token) {
         res.cookie('openid_id_token', tokenset.id_token, {
           expires: expirationDate,

From 56e7662a7b92a302ebd50e08401bdc4455562e9a Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 25 Feb 2026 10:43:16 +0000
Subject: [PATCH 78/94] fix(solid): post-login redirect and refresh token
 support for Solid OIDC

---
 .env.example                             |  5 +++-
 SOLID_INTEGRATION_PROGRESS.md            | 30 ++++++++++++++++++++----
 api/server/middleware/optionalJwtAuth.js |  8 +++++--
 api/server/middleware/requireJwtAuth.js  | 10 +++++---
 api/server/services/AuthService.js       |  5 ++--
 api/strategies/SolidOpenidStrategy.js    |  5 ++++
 6 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/.env.example b/.env.example
index d5c8311e4ff5..3b6206a0be86 100644
--- a/.env.example
+++ b/.env.example
@@ -497,10 +497,13 @@ APPLE_PRIVATE_KEY_PATH=
 APPLE_CALLBACK_URL=/oauth/apple/callback
 
 #SolidOpenID
+# For remote IdPs (e.g. solidcommunity.net), use a public app URL for CLIENT_ID and ISSUER; the IdP fetches the client_id URL.
 SOLID_OPENID_CLIENT_ID=http://localhost:3080/solid-client-id
+SOLID_OPENID_CLIENT_SECRET=
 SOLID_OPENID_ISSUER=http://localhost:3000/
 SOLID_OPENID_SESSION_SECRET=[JustGenerateARandomSessionSecret]
-SOLID_OPENID_SCOPE="openid webid"
+# Include offline_access for refresh token support when the IdP supports it (e.g. solidcommunity.net). Local CSS with static client may not return a refresh token.
+SOLID_OPENID_SCOPE="openid webid offline_access"
 SOLID_OPENID_CALLBACK_URL=/oauth/openid/callback
 SOLID_OPENID_BUTTON_LABEL=Continue with Solid
 
diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 90b86d648827..b9e0a58560cd 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -139,6 +139,19 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - **requireJwtAuth.js**: Removed non–Solid-specific debug logging added during auth flow debugging; reviewer suggested upstreaming useful logging in a separate PR if needed.
   - **convos.js**: No code change; reviewer concern addressed by clarification—`getConvo(req.user.id, conversationId, req)` in `Conversation.js` already branches on `isSolidUser(req)` and uses Solid when the user is a Solid user.
 
+### 16. Refresh Token Support & Post-Login Redirect
+- **Status**: Complete
+- **Details**:
+  - **Post-login redirect fix**: After Solid OAuth callback, the client calls `/api/auth/refresh`. When the IdP does not return a refresh token (e.g. local Community Solid Server with static client), we now return `{ token, user }` from the **session** (decode id_token for `sub`, find user by openidId, return session token). This prevents the client from redirecting to `/login` when no refresh token is available.
+  - **Refresh token flow**: When a refresh token *is* present (session or cookie), the refresh controller uses `performOpenIDRefresh` with Solid config and `SOLID_OPENID_SCOPE` to exchange it for new tokens and return `{ token, user }`. Code is ready for IdPs that issue refresh tokens (e.g. solidcommunity.net when properly registered).
+  - **prompt=consent**: Added `prompt=consent` to the Solid authorization request so that IdPs that support it (e.g. node-oidc-provider) will issue a refresh token when `offline_access` is in scope. Without it, many IdPs do not return a refresh token.
+  - **JWT strategy by provider**: Solid registers the strategy name `solidJwt`; generic OpenID registers `openidJwt`. Updated `requireJwtAuth.js` and `optionalJwtAuth.js` to use `solidJwt` when `token_provider === 'solid'` and `openidJwt` when `token_provider === 'openid'`, so API requests after Solid login authenticate correctly when only Solid is configured (generic OpenID may be unregistered e.g. due to HTTPS requirement).
+  - **Token storage**: `setOpenIDAuthTokens` in AuthService stores access, id, and refresh tokens in session; sets `token_provider` cookie from `req.user?.provider` (so Solid gets `token_provider=solid`); only sets the refresh-token cookie when a refresh token exists. No early return when refresh token is missing—access token is always stored so session fallback can work.
+- **Findings**:
+  - **Local CSS (Community Solid Server)** with static client registration (`SOLID_OPENID_CLIENT_ID` / secret from env) does **not** return a refresh token in the token response by default. The server response only includes `access_token`, `id_token`, `expires_in`, `scope`, `token_type`. Adding `prompt=consent` and `scope=openid webid offline_access` is correct and required for IdPs that do support refresh tokens; for local CSS the static client may need to be explicitly configured on the server to allow `refresh_token` grant and `offline_access` scope.
+  - **solidcommunity.net** (remote IdP): The IdP **dereferences the client_id URL** to fetch client metadata. If `SOLID_OPENID_CLIENT_ID` is a localhost URL (e.g. `http://localhost:3080/solid-client-id`), the remote server cannot reach it and returns 500 ("request to http://localhost:3080/solid-client-id failed, reason: connect ECONNREFUSED"). To use solidcommunity.net, the app must be hosted at a **public URL** and `SOLID_OPENID_CLIENT_ID` must be a publicly reachable URL (or a client id issued by their registration process). Redirect URI must also be public.
+  - **SOLID_OPENID_SCOPE**: Use `"openid webid offline_access"` for refresh token support when the IdP supports it.
+
 ## Current Status
 
 ### Working Features
@@ -189,6 +202,9 @@ None currently identified.
 - Generic "Login with OpenID" button using `OPENID_*` environment variables
 - Both buttons share the same authentication flow and `/oauth/openid` route
 - Custom SolidIcon component for Solid branding
+- **Refresh token**: When the IdP returns a refresh token, it is stored in session (and cookie when present) and used by `/api/auth/refresh` to obtain new tokens. When no refresh token is returned (e.g. local CSS with static client), a session fallback returns the current session token and user so the client does not redirect to `/login`.
+- **Authorization request**: Solid flow sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
+- **JWT strategies**: Solid uses `solidJwt`, generic OpenID uses `openidJwt`; `requireJwtAuth` and `optionalJwtAuth` select the strategy based on `token_provider` cookie.
 
 ### Access Control (ACL)
 - Uses manual ACL Turtle format for permission management
@@ -218,11 +234,15 @@ None currently identified.
 - `api/server/routes/oauth.js` - Token logging and storage
 - `api/server/services/AuthService.js` - Token management
 - `api/server/index.js` - Session middleware ordering
-- `api/server/controllers/AuthController.js` - Refresh token handling
+- `api/server/controllers/AuthController.js` - Refresh token handling; session fallback when no refresh token (decode session token, find user by openidId, return { token, user }); `performOpenIDRefresh` shared helper; Solid vs openid branch by `token_provider`
+- `api/server/services/AuthService.js` - setOpenIDAuthTokens: store access/id/refresh in session; set `token_provider` cookie from req.user?.provider; refresh-token cookie only when refresh token present; no early return when refresh token missing
+- `api/server/middleware/requireJwtAuth.js` - Use `solidJwt` when token_provider is solid, `openidJwt` when openid (so Solid-only config works)
+- `api/server/middleware/optionalJwtAuth.js` - Use `solidJwt` when token_provider is solid, `openidJwt` when openid; support both for OPENID_REUSE_TOKENS
+- `api/strategies/SolidOpenidStrategy.js` - Added `prompt=consent` in authorizationRequestParams for refresh token support; removed temporary SOLID_DEBUG_TOKENS logging
 - `api/server/middleware/validate/convoAccess.js` - Added Solid storage support for conversation access validation
 - `api/server/middleware/buildEndpointOption.js` - Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model (no Solid-specific logic)
 - `api/server/middleware/validateMessageReq.js` - Solid storage validation; no MongoDB fallback for Solid users (404 on Solid failure)
-- `api/server/middleware/requireJwtAuth.js` - Removed debug auth logging (per PR review)
+- `api/server/middleware/requireJwtAuth.js` - Removed debug auth logging (per PR review); use solidJwt/openidJwt by token_provider
 - `api/server/routes/config.js` - `openidLoginEnabled: isOpenIdEnabled` only so Solid-only shows one button (per PR review)
 - `api/server/routes/messages.js` - Solid message reads return 503 on Solid failure (no MongoDB fallback)
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
@@ -236,7 +256,7 @@ None currently identified.
 - `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
 - `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
 - `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
-- `api/strategies/SolidOpenidStrategy.js` - Updated to use `SOLID_OPENID_*` environment variables and register as 'openid' strategy
+- `api/strategies/SolidOpenidStrategy.js` - Updated to use `SOLID_OPENID_*` environment variables and register as 'solid' strategy; prompt=consent for refresh token support
 - `api/strategies/openidStrategy.js` - Generic OpenID strategy for non-Solid OpenID providers
 - `api/strategies/index.js` - Exported both `setupSolidOpenId` and `setupOpenId` functions
 - `api/server/socialLogins.js` - Added separate configuration functions for Solid and generic OpenID strategies
@@ -257,7 +277,7 @@ The following environment variables are required for the "Login with Solid" butt
 - `SOLID_OPENID_CLIENT_ID` - OAuth client ID for Solid authentication
 - `SOLID_OPENID_CLIENT_SECRET` - OAuth client secret for Solid authentication
 - `SOLID_OPENID_ISSUER` - Solid Pod provider URL (e.g., `http://localhost:3000/`)
-- `SOLID_OPENID_SCOPE` - OAuth scopes (typically `"openid webid"`)
+- `SOLID_OPENID_SCOPE` - OAuth scopes (use `"openid webid offline_access"` for refresh token support when the IdP supports it)
 - `SOLID_OPENID_SESSION_SECRET` - Secret key for session management
 - `SOLID_OPENID_CALLBACK_URL` - OAuth callback URL (typically `/oauth/openid/callback`)
 
@@ -288,6 +308,6 @@ The following environment variables are used for the generic "Login with OpenID"
 
 ---
 
-**Report Date**: February 10, 2026
+**Report Date**: February 25, 2026
 
 
diff --git a/api/server/middleware/optionalJwtAuth.js b/api/server/middleware/optionalJwtAuth.js
index 2f59fdda4af0..7ea1ef8dc5c7 100644
--- a/api/server/middleware/optionalJwtAuth.js
+++ b/api/server/middleware/optionalJwtAuth.js
@@ -16,8 +16,12 @@ const optionalJwtAuth = (req, res, next) => {
     }
     next();
   };
-  if (tokenProvider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    return passport.authenticate('openidJwt', { session: false }, callback)(req, res, next);
+  if (
+    (tokenProvider === 'openid' || tokenProvider === 'solid') &&
+    isEnabled(process.env.OPENID_REUSE_TOKENS)
+  ) {
+    const strategy = tokenProvider === 'solid' ? 'solidJwt' : 'openidJwt';
+    return passport.authenticate(strategy, { session: false }, callback)(req, res, next);
   }
   passport.authenticate('jwt', { session: false }, callback)(req, res, next);
 };
diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index 21564e8e753d..8ce8e5864772 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -10,9 +10,13 @@ const requireJwtAuth = (req, res, next) => {
   const cookieHeader = req.headers.cookie;
   const tokenProvider = cookieHeader ? cookies.parse(cookieHeader).token_provider : null;
 
-  // Use OpenID authentication if token provider is OpenID and OPENID_REUSE_TOKENS is enabled
-  if (tokenProvider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    return passport.authenticate('openidJwt', { session: false })(req, res, next);
+  // Use OpenID/Solid JWT authentication when OPENID_REUSE_TOKENS is enabled
+  if (
+    (tokenProvider === 'openid' || tokenProvider === 'solid') &&
+    isEnabled(process.env.OPENID_REUSE_TOKENS)
+  ) {
+    const strategy = tokenProvider === 'solid' ? 'solidJwt' : 'openidJwt';
+    return passport.authenticate(strategy, { session: false })(req, res, next);
   }
 
   // Default to standard JWT authentication
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index bf1125425ca1..53da0742be8d 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -538,8 +538,9 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
       });
     }
 
-    /** Small cookie to indicate token provider (required for auth middleware) */
-    res.cookie('token_provider', 'openid', {
+    /** Small cookie to indicate token provider (required for auth middleware and refresh flow) */
+    const tokenProvider = req.user?.provider || 'openid';
+    res.cookie('token_provider', tokenProvider, {
       expires: expirationDate,
       httpOnly: true,
       secure: shouldUseSecureCookie(),
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 549d0e56758d..845483ada674 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -137,6 +137,11 @@ class CustomOpenIDStrategy extends OpenIDStrategy {
       logger.debug('[SolidOpenidStrategy] Generated nonce for federated provider:', nonce);
     }
 
+    /** Request consent so CSS/node-oidc-provider issues a refresh_token when offline_access is in scope */
+    if (!params.has('prompt')) {
+      params.set('prompt', 'consent');
+    }
+
     return params;
   }
 }

From c1bf3cd111722cf5619d9c9fc53a6647c21278b0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 25 Feb 2026 10:59:14 +0000
Subject: [PATCH 79/94] fix ESlint fails

---
 api/server/controllers/AuthController.js | 66 ++++++++++++++++++++++--
 api/server/socialLogins.js               |  2 +-
 2 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 8f6c00e2fb33..169a3f0ad0e1 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -132,10 +132,70 @@ const refreshController = async (req, res) => {
         expires_at: claims.exp,
       };
 
-      return res.status(200).send({ token, user });
-    } catch (error) {
-      logger.error('[refreshController] OpenID token refresh error', error);
+    res.status(200).send({ token, user });
+    return true;
+  } catch (error) {
+    logger.error('[refreshController] OpenID token refresh error', error);
+    return false;
+  }
+}
+
+const refreshController = async (req, res) => {
+  const parsedCookies = req.headers.cookie ? cookies.parse(req.headers.cookie) : {};
+  const token_provider = parsedCookies.token_provider;
+
+  // Handle OpenID or Solid users with OPENID_REUSE_TOKENS enabled
+  const useOpenIDRefresh =
+    (token_provider === 'openid' || token_provider === 'solid') &&
+    isEnabled(process.env.OPENID_REUSE_TOKENS);
+
+  if (useOpenIDRefresh) {
+    const refreshToken = req.session?.openidTokens?.refreshToken || parsedCookies.refreshToken;
+
+    if (!refreshToken) {
+      // No refresh token (e.g. Solid IdP didn't return one) but we may have a valid session from the OAuth callback
+      const sessionToken =
+        req.session?.openidTokens?.idToken || req.session?.openidTokens?.accessToken;
+      if (sessionToken) {
+        try {
+          const payload = jwt.decode(sessionToken);
+          const sub = payload?.sub;
+          if (sub) {
+            const { user, error } = await findOpenIDUser({
+              findUser,
+              email: payload.email,
+              openidId: sub,
+              idOnTheSource: payload.oid,
+              strategyName: 'refreshController',
+            });
+            if (!error && user) {
+              const token = sessionToken;
+              logger.debug(
+                '[refreshController] Returning token from session (no refresh token available)',
+              );
+              return res.status(200).send({ token, user });
+            }
+          }
+        } catch (err) {
+          logger.debug('[refreshController] Session token decode/lookup failed', err.message);
+        }
+      }
+      logger.warn(
+        '[refreshController] No OpenID refresh token available, falling back to standard refresh',
+      );
+      return res.status(200).send('Refresh token not provided');
     }
+
+    const openIdConfig = token_provider === 'solid' ? getSolidOpenIdConfig() : getOpenIdConfig();
+    let refreshParams = {};
+    if (token_provider === 'solid' && process.env.SOLID_OPENID_SCOPE) {
+      refreshParams = { scope: process.env.SOLID_OPENID_SCOPE };
+    } else if (process.env.OPENID_SCOPE) {
+      refreshParams = { scope: process.env.OPENID_SCOPE };
+    }
+
+    const sent = await performOpenIDRefresh(req, res, openIdConfig, refreshToken, refreshParams);
+    if (sent) return;
   }
 
   /** For non-OpenID users or OpenID users without OPENID_REUSE_TOKENS, use standard JWT refresh */
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index 3e1fb1c5505a..a33764c6f3db 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -17,7 +17,7 @@ const {
 const { getLogStores } = require('~/cache');
 
 /**
-* Configures Solid OpenID Connect for the application.
+ * Configures Solid OpenID Connect for the application.
  * @param {Express.Application} app - The Express application instance.
  * @returns {Promise<void>}
  */

From 5edb22eded8c0f4e53e93697df6d89c9e6bfa269 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 25 Feb 2026 14:03:18 +0000
Subject: [PATCH 80/94] fix unit testing fail

---
 api/server/services/AuthService.spec.js | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/api/server/services/AuthService.spec.js b/api/server/services/AuthService.spec.js
index da78f8d7752e..d8dfc21565ab 100644
--- a/api/server/services/AuthService.spec.js
+++ b/api/server/services/AuthService.spec.js
@@ -53,7 +53,15 @@ function mockResponse() {
 /** Helper to build a mock Express request with session */
 function mockRequest(sessionData = {}) {
   return {
-    session: { openidTokens: null, ...sessionData },
+    session: {
+      openidTokens: null,
+      ...sessionData,
+      save: jest.fn((callback) => {
+        if (typeof callback === 'function') {
+          callback();
+        }
+      }),
+    },
   };
 }
 

From e03cfdbc57bc66468ddc9c6a986fcdcea1eb903b Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 25 Feb 2026 14:21:01 +0000
Subject: [PATCH 81/94] fix: Updated the test to expect the token (id_token or
 access_token) when no refresh token is present.

---
 api/server/services/AuthService.spec.js | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/api/server/services/AuthService.spec.js b/api/server/services/AuthService.spec.js
index d8dfc21565ab..a3750c78ee17 100644
--- a/api/server/services/AuthService.spec.js
+++ b/api/server/services/AuthService.spec.js
@@ -253,12 +253,15 @@ describe('setOpenIDAuthTokens', () => {
       expect(result).toBeUndefined();
     });
 
-    it('should return undefined when no refresh token is available', () => {
+    it('should return id_token when no refresh token is available (session fallback)', () => {
       const tokenset = { access_token: 'access', id_token: 'id' };
       const req = mockRequest();
       const res = mockResponse();
       const result = setOpenIDAuthTokens(tokenset, req, res, 'user-123');
-      expect(result).toBeUndefined();
+      expect(result).toBe('id');
+      expect(req.session.openidTokens.accessToken).toBe('access');
+      expect(req.session.openidTokens.idToken).toBe('id');
+      expect(req.session.openidTokens.refreshToken).toBeUndefined();
     });
 
     it('should use existingRefreshToken when tokenset has no refresh_token', () => {

From 85f68ebde9c59d32638e642c53cb51a9b4e15baa Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Wed, 25 Feb 2026 14:35:13 +0000
Subject: [PATCH 82/94] test(auth): fix setOpenIDAuthTokens spec for
 no-refresh-token behavior

---
 api/server/services/AuthService.spec.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/server/services/AuthService.spec.js b/api/server/services/AuthService.spec.js
index a3750c78ee17..c072a25fb53c 100644
--- a/api/server/services/AuthService.spec.js
+++ b/api/server/services/AuthService.spec.js
@@ -261,7 +261,7 @@ describe('setOpenIDAuthTokens', () => {
       expect(result).toBe('id');
       expect(req.session.openidTokens.accessToken).toBe('access');
       expect(req.session.openidTokens.idToken).toBe('id');
-      expect(req.session.openidTokens.refreshToken).toBeUndefined();
+      expect(req.session.openidTokens.refreshToken == null).toBe(true);
     });
 
     it('should use existingRefreshToken when tokenset has no refresh_token', () => {

From cb778764f16892d32f5abbf62facd2174203ecb1 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 12:24:53 +0000
Subject: [PATCH 83/94] fix(auth): Solid login 503, cookie provider, and
 post-callback redirect

- Register solidJwt when only SOLID_OPENID_CUSTOM_CLIENT_ID is set via
  getSolidOpenIdProvidersForJwt() (synthetic Local CSS provider).
- Preserve token_provider=solid: SolidOpenidStrategy returns provider:'solid';
  performOpenIDRefresh accepts tokenProvider and sets req.user/user.provider
  before setOpenIDAuthTokens so refresh does not overwrite cookie to openid.
- Add openid_id_token cookie when storing session tokens so first API request
  can authenticate before frontend sets Bearer header; openIdJwtStrategy
  reads JWT from Authorization then cookie.
- Fix post-callback crash and redirect by removing debug log that passed
  non-serializable req/req.user to logger.
- Add openIdAuthHelpers.sendStrategyNotRegistered503 and use in
  requireJwtAuth/optionalJwtAuth (DRY).
- Update SOLID_INTEGRATION_PROGRESS.md: Milestone 16, files modified,
  SOLID_OPENID_CUSTOM_CLIENT_ID env.
---
 .env.example                                  |  15 +-
 SOLID_INTEGRATION_PROGRESS.md                 |  72 +--
 api/server/controllers/AuthController.js      | 124 +++--
 .../controllers/auth/solidOpenIdDynamic.js    | 222 +++++++++
 api/server/index.js                           |  20 +-
 api/server/middleware/openIdAuthHelpers.js    |  20 +
 api/server/middleware/optionalJwtAuth.js      |  31 +-
 api/server/middleware/requireJwtAuth.js       |  33 +-
 api/server/routes/config.js                   |  25 +-
 api/server/routes/oauth.js                    |  24 +-
 api/server/services/AuthService.js            |  10 +
 api/server/services/Config/solidOpenId.js     | 190 ++++++++
 api/server/services/ensureSolidJwt.js         |  55 +++
 api/server/socialLogins.js                    |  77 ++-
 api/strategies/SolidOpenidStrategy.js         | 442 +++++++++---------
 api/strategies/index.js                       |  13 +-
 api/strategies/openIdJwtStrategy.js           |  18 +-
 .../src/components/Auth/SocialLoginRender.tsx |  10 +-
 .../src/components/Auth/SolidLoginButton.tsx  | 160 +++++++
 packages/data-provider/src/config.ts          |   4 +
 20 files changed, 1222 insertions(+), 343 deletions(-)
 create mode 100644 api/server/controllers/auth/solidOpenIdDynamic.js
 create mode 100644 api/server/middleware/openIdAuthHelpers.js
 create mode 100644 api/server/services/Config/solidOpenId.js
 create mode 100644 api/server/services/ensureSolidJwt.js
 create mode 100644 client/src/components/Auth/SolidLoginButton.tsx

diff --git a/.env.example b/.env.example
index 3b6206a0be86..fda1985bec9c 100644
--- a/.env.example
+++ b/.env.example
@@ -496,16 +496,21 @@ APPLE_KEY_ID=
 APPLE_PRIVATE_KEY_PATH=
 APPLE_CALLBACK_URL=/oauth/apple/callback
 
-#SolidOpenID
-# For remote IdPs (e.g. solidcommunity.net), use a public app URL for CLIENT_ID and ISSUER; the IdP fetches the client_id URL.
+#SolidOpenID (dynamic: use SOLID_OPENID_PROVIDERS)
+# Client ID document is served at DOMAIN_SERVER/solid-client-id; use that URL as clientId for each provider.
+# SOLID_OPENID_CLIENT_ID is only needed if your client_id document URL is not DOMAIN_SERVER/solid-client-id.
 SOLID_OPENID_CLIENT_ID=http://localhost:3080/solid-client-id
-SOLID_OPENID_CLIENT_SECRET=
-SOLID_OPENID_ISSUER=http://localhost:3000/
 SOLID_OPENID_SESSION_SECRET=[JustGenerateARandomSessionSecret]
-# Include offline_access for refresh token support when the IdP supports it (e.g. solidcommunity.net). Local CSS with static client may not return a refresh token.
+# Required: JSON array of Solid IdPs. Each item: issuer, clientId, clientSecret (optional), scope (optional), label (optional).
+SOLID_OPENID_PROVIDERS=[{"issuer":"http://localhost:3000/","clientId":"http://localhost:3080/solid-client-id","clientSecret":"","label":"Local CSS"}]
+# Optional: add more issuers to the array, e.g. {"issuer":"https://solidcommunity.net/","clientId":"https://your-app.com/solid-client-id","clientSecret":"...","label":"Solid Community"}
 SOLID_OPENID_SCOPE="openid webid offline_access"
 SOLID_OPENID_CALLBACK_URL=/oauth/openid/callback
 SOLID_OPENID_BUTTON_LABEL=Continue with Solid
+# Optional: allow users to type any Solid OIDC provider URL in the login modal.
+# SOLID_OPENID_CUSTOM_CLIENT_ID=
+# SOLID_OPENID_CUSTOM_CLIENT_SECRET=
+# SOLID_OPENID_CUSTOM_SCOPE="openid webid offline_access"
 
 # OpenID
 OPENID_CLIENT_ID=
diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index b9e0a58560cd..35886c418c35 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -139,17 +139,22 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - **requireJwtAuth.js**: Removed non–Solid-specific debug logging added during auth flow debugging; reviewer suggested upstreaming useful logging in a separate PR if needed.
   - **convos.js**: No code change; reviewer concern addressed by clarification—`getConvo(req.user.id, conversationId, req)` in `Conversation.js` already branches on `isSolidUser(req)` and uses Solid when the user is a Solid user.
 
-### 16. Refresh Token Support & Post-Login Redirect
+### 16. Refresh Token Support & Post-Login API Auth (Solid-Only Config)
 - **Status**: Complete
 - **Details**:
-  - **Post-login redirect fix**: After Solid OAuth callback, the client calls `/api/auth/refresh`. When the IdP does not return a refresh token (e.g. local Community Solid Server with static client), we now return `{ token, user }` from the **session** (decode id_token for `sub`, find user by openidId, return session token). This prevents the client from redirecting to `/login` when no refresh token is available.
-  - **Refresh token flow**: When a refresh token *is* present (session or cookie), the refresh controller uses `performOpenIDRefresh` with Solid config and `SOLID_OPENID_SCOPE` to exchange it for new tokens and return `{ token, user }`. Code is ready for IdPs that issue refresh tokens (e.g. solidcommunity.net when properly registered).
-  - **prompt=consent**: Added `prompt=consent` to the Solid authorization request so that IdPs that support it (e.g. node-oidc-provider) will issue a refresh token when `offline_access` is in scope. Without it, many IdPs do not return a refresh token.
-  - **JWT strategy by provider**: Solid registers the strategy name `solidJwt`; generic OpenID registers `openidJwt`. Updated `requireJwtAuth.js` and `optionalJwtAuth.js` to use `solidJwt` when `token_provider === 'solid'` and `openidJwt` when `token_provider === 'openid'`, so API requests after Solid login authenticate correctly when only Solid is configured (generic OpenID may be unregistered e.g. due to HTTPS requirement).
-  - **Token storage**: `setOpenIDAuthTokens` in AuthService stores access, id, and refresh tokens in session; sets `token_provider` cookie from `req.user?.provider` (so Solid gets `token_provider=solid`); only sets the refresh-token cookie when a refresh token exists. No early return when refresh token is missing—access token is always stored so session fallback can work.
+  - **Post-login redirect**: After Solid OAuth callback, the server redirects to `DOMAIN_CLIENT`; the client then calls `/api/auth/refresh`. When the IdP does not return a refresh token, we return `{ token, user }` from session (decode id_token for `sub`, find user by openidId). When a refresh token *is* present, `performOpenIDRefresh` exchanges it for new tokens and returns `{ token, user }`.
+  - **Refresh token**: When the Solid IdP (e.g. Local CSS) returns a refresh token in the token response, we receive it, store it in session (`req.session.openidTokens.refreshToken`) and in the `refreshToken` cookie, and use it in `/api/auth/refresh` via `performOpenIDRefresh` + `openIdClient.refreshTokenGrant`. So **yes, we now receive and use a refresh token** when the IdP provides one.
+  - **prompt=consent**: Solid authorization request sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
+  - **JWT strategy by provider**: `requireJwtAuth` and `optionalJwtAuth` use `solidJwt` when `token_provider === 'solid'` and `openidJwt` when `token_provider === 'openid'`, so API requests after Solid login authenticate correctly when only Solid is configured (generic OpenID may be unregistered e.g. due to HTTPS requirement).
+  - **token_provider cookie must stay `solid`**: The cookie is set from `req.user?.provider` in `setOpenIDAuthTokens`. (1) **OAuth callback**: Solid strategy return value now explicitly includes `provider: 'solid'` so the callback sets `token_provider=solid`. (2) **Refresh path**: When the frontend calls refresh, we pass `token_provider` from the request cookie into `performOpenIDRefresh` and set `req.user = user` and `user.provider = user.provider || tokenProvider` before calling `setOpenIDAuthTokens`, so the cookie is not overwritten to `openid` and subsequent API calls use solidJwt.
+  - **solidJwt registration**: Uses `getSolidOpenIdProvidersForJwt()` (from `SOLID_OPENID_PROVIDERS` or, when that list is empty, a synthetic Local CSS provider when `SOLID_OPENID_CUSTOM_CLIENT_ID` is set). Registration runs at startup in socialLogins and lazily in auth middleware if the strategy was not registered (e.g. IdP was down).
+  - **JWT from cookie fallback**: The openIdJwt strategy (used by solidJwt) extracts the JWT from `Authorization: Bearer` first, then from the `openid_id_token` cookie, so the first API request after redirect (before the frontend refresh sets the header) can still authenticate. When storing tokens in session we also set the `openid_id_token` cookie so that fallback works.
+  - **DRY**: Shared `sendStrategyNotRegistered503(res, tokenProvider, afterLazyInit)` in `api/server/middleware/openIdAuthHelpers.js` used by both `requireJwtAuth` and `optionalJwtAuth` for 503 responses when the OpenID/Solid strategy is not registered. Unnecessary logging removed (setOpenIDAuthTokens debug, 503 warns, Solid “no providers” debug, extra configureSolidOpenIdFromProviders info).
+- **Config**:
+  - **Dynamic-only**: Solid provider list comes from `SOLID_OPENID_PROVIDERS` only; legacy `SOLID_OPENID_ISSUER` is no longer used. `SOLID_OPENID_CUSTOM_CLIENT_ID` allows custom issuer URLs (e.g. user picks “Local CSS” from modal) with a single client id; `getSolidOpenIdProvidersForJwt()` returns a synthetic provider for Local CSS when only custom client id is set so solidJwt can still register.
 - **Findings**:
-  - **Local CSS (Community Solid Server)** with static client registration (`SOLID_OPENID_CLIENT_ID` / secret from env) does **not** return a refresh token in the token response by default. The server response only includes `access_token`, `id_token`, `expires_in`, `scope`, `token_type`. Adding `prompt=consent` and `scope=openid webid offline_access` is correct and required for IdPs that do support refresh tokens; for local CSS the static client may need to be explicitly configured on the server to allow `refresh_token` grant and `offline_access` scope.
-  - **solidcommunity.net** (remote IdP): The IdP **dereferences the client_id URL** to fetch client metadata. If `SOLID_OPENID_CLIENT_ID` is a localhost URL (e.g. `http://localhost:3080/solid-client-id`), the remote server cannot reach it and returns 500 ("request to http://localhost:3080/solid-client-id failed, reason: connect ECONNREFUSED"). To use solidcommunity.net, the app must be hosted at a **public URL** and `SOLID_OPENID_CLIENT_ID` must be a publicly reachable URL (or a client id issued by their registration process). Redirect URI must also be public.
+  - **Local CSS** with dynamic client registration (`/solid-client-id` document) can return a refresh token when configured to do so; we store and use it. With `prompt=consent` and `offline_access` scope, IdPs that support it will include a refresh token.
+  - **solidcommunity.net**: The IdP dereferences the client_id URL; a localhost client_id is not reachable. Use a public URL for production.
   - **SOLID_OPENID_SCOPE**: Use `"openid webid offline_access"` for refresh token support when the IdP supports it.
 
 ## Current Status
@@ -202,9 +207,10 @@ None currently identified.
 - Generic "Login with OpenID" button using `OPENID_*` environment variables
 - Both buttons share the same authentication flow and `/oauth/openid` route
 - Custom SolidIcon component for Solid branding
-- **Refresh token**: When the IdP returns a refresh token, it is stored in session (and cookie when present) and used by `/api/auth/refresh` to obtain new tokens. When no refresh token is returned (e.g. local CSS with static client), a session fallback returns the current session token and user so the client does not redirect to `/login`.
+- **Refresh token**: When the IdP returns a refresh token, it is stored in session (and cookie when present) and used by `/api/auth/refresh` via `performOpenIDRefresh` to obtain new tokens. When no refresh token is returned, a session fallback returns the current session token and user so the client does not redirect to `/login`.
 - **Authorization request**: Solid flow sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
-- **JWT strategies**: Solid uses `solidJwt`, generic OpenID uses `openidJwt`; `requireJwtAuth` and `optionalJwtAuth` select the strategy based on `token_provider` cookie.
+- **JWT strategies**: Solid uses `solidJwt`, generic OpenID uses `openidJwt`; `requireJwtAuth` and `optionalJwtAuth` select the strategy based on the `token_provider` cookie. The cookie is set from `req.user.provider` in `setOpenIDAuthTokens`; the refresh path passes `token_provider` into `performOpenIDRefresh` and sets `req.user`/`user.provider` so the cookie is not overwritten to `openid` after refresh.
+- **JWT extraction**: The openIdJwt/solidJwt strategy reads the JWT from `Authorization: Bearer` first, then from the `openid_id_token` cookie, so the first request after redirect can authenticate before the frontend sets the header. We set the `openid_id_token` cookie when storing tokens in session so that fallback works.
 
 ### Access Control (ACL)
 - Uses manual ACL Turtle format for permission management
@@ -231,18 +237,22 @@ None currently identified.
 - `api/server/utils/isSolidUser.js` (NEW) - Shared helper to detect Solid login (`provider === 'solid'`), used across models, routes, and middleware (DRY)
 - `api/models/Message.js` - Integrated Solid storage; builds full message document (user, createdAt, updatedAt) and passes to SolidStorage; MongoDB path for non-Solid users only (no fallback for Solid)
 - `api/models/Conversation.js` - Integrated Solid storage; builds full conversation document and passes to SolidStorage; no MongoDB fallback for Solid users (return null/rethrow on Solid failure); passes `previousConversationId` when renaming
-- `api/server/routes/oauth.js` - Token logging and storage
-- `api/server/services/AuthService.js` - Token management
-- `api/server/index.js` - Session middleware ordering
-- `api/server/controllers/AuthController.js` - Refresh token handling; session fallback when no refresh token (decode session token, find user by openidId, return { token, user }); `performOpenIDRefresh` shared helper; Solid vs openid branch by `token_provider`
-- `api/server/services/AuthService.js` - setOpenIDAuthTokens: store access/id/refresh in session; set `token_provider` cookie from req.user?.provider; refresh-token cookie only when refresh token present; no early return when refresh token missing
-- `api/server/middleware/requireJwtAuth.js` - Use `solidJwt` when token_provider is solid, `openidJwt` when openid (so Solid-only config works)
-- `api/server/middleware/optionalJwtAuth.js` - Use `solidJwt` when token_provider is solid, `openidJwt` when openid; support both for OPENID_REUSE_TOKENS
-- `api/strategies/SolidOpenidStrategy.js` - Added `prompt=consent` in authorizationRequestParams for refresh token support; removed temporary SOLID_DEBUG_TOKENS logging
-- `api/server/middleware/validate/convoAccess.js` - Added Solid storage support for conversation access validation
+- `api/server/services/Config/solidOpenId.js` - getSolidOpenIdProviders (SOLID_OPENID_PROVIDERS only); getSolidOpenIdProvidersForJwt (includes synthetic Local CSS when only SOLID_OPENID_CUSTOM_CLIENT_ID); getSolidOpenIdProviderByIssuer
+- `api/server/services/ensureSolidJwt.js` (NEW) - Ensures solidJwt strategy registered at startup or lazily; uses getSolidOpenIdProvidersForJwt
+- `api/server/middleware/openIdAuthHelpers.js` (NEW) - Shared sendStrategyNotRegistered503 for requireJwtAuth and optionalJwtAuth (DRY)
+- `api/server/routes/oauth.js` - OAuth handler stores OpenID/Solid tokens via setOpenIDAuthTokens; startBaseStructureAfterLogin for Solid
+- `api/server/services/AuthService.js` - setOpenIDAuthTokens: store access/id/refresh in session; set openid_id_token cookie when using session (for first-request auth); set token_provider cookie from req.user?.provider; refresh-token cookie when present
+- `api/server/index.js` - Session middleware ordering; /solid-client-id endpoint for dynamic client metadata
+- `api/server/controllers/AuthController.js` - performOpenIDRefresh accepts tokenProvider param; sets req.user and user.provider before setOpenIDAuthTokens so token_provider cookie preserved on refresh; session fallback when no refresh token; Solid vs openid by token_provider
+- `api/server/middleware/requireJwtAuth.js` - Use solidJwt when token_provider is solid, openidJwt when openid; lazy solidJwt registration; sendStrategyNotRegistered503 from openIdAuthHelpers
+- `api/server/middleware/optionalJwtAuth.js` - Same strategy selection and 503 helper as requireJwtAuth
+- `api/strategies/SolidOpenidStrategy.js` - verifySolidUser return includes provider: 'solid'; prompt=consent for refresh token; SOLID_OPENID_* env; register as 'solid'
+- `api/strategies/openIdJwtStrategy.js` - jwtFromRequest: Authorization Bearer then openid_id_token cookie; used by solidJwt and openidJwt
+- `api/server/controllers/auth/solidOpenIdDynamic.js` - startSolidOpenIdFlow, handleSolidOpenIdCallback (multi-issuer with PKCE)
+- `api/server/middleware/validate/convoAccess.js` - Solid storage support for conversation access validation
 - `api/server/middleware/buildEndpointOption.js` - Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model (no Solid-specific logic)
 - `api/server/middleware/validateMessageReq.js` - Solid storage validation; no MongoDB fallback for Solid users (404 on Solid failure)
-- `api/server/middleware/requireJwtAuth.js` - Removed debug auth logging (per PR review); use solidJwt/openidJwt by token_provider
+- `api/server/socialLogins.js` - Solid configured from getSolidOpenIdProvidersForJwt(); configureSolidOpenIdFromProviders (session + solidJwt); registerSolidJwtFromProviders; ensureSolidJwtFromProvidersOnce
 - `api/server/routes/config.js` - `openidLoginEnabled: isOpenIdEnabled` only so Solid-only shows one button (per PR review)
 - `api/server/routes/messages.js` - Solid message reads return 503 on Solid failure (no MongoDB fallback)
 - `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
@@ -256,11 +266,9 @@ None currently identified.
 - `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
 - `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
 - `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
-- `api/strategies/SolidOpenidStrategy.js` - Updated to use `SOLID_OPENID_*` environment variables and register as 'solid' strategy; prompt=consent for refresh token support
 - `api/strategies/openidStrategy.js` - Generic OpenID strategy for non-Solid OpenID providers
-- `api/strategies/index.js` - Exported both `setupSolidOpenId` and `setupOpenId` functions
-- `api/server/socialLogins.js` - Added separate configuration functions for Solid and generic OpenID strategies
-- `api/server/routes/config.js` - Added Solid-specific configuration fields (`solidLoginEnabled`, `solidLabel`, `solidImageUrl`, `solidAutoRedirect`)
+- `api/strategies/index.js` - Exported setupSolidOpenIdFromProvider, getSolidOpenIdConfig, verifySolidUser (dynamic flow; setupSolidOpenId deprecated)
+- `api/server/routes/config.js` - openidLoginEnabled: isOpenIdEnabled only; Solid config (solidLoginEnabled, solidLabel, solidImageUrl, solidAutoRedirect)
 - `client/src/components/Auth/SocialLoginRender.tsx` - Added Solid button component with SolidIcon
 - `packages/client/src/svgs/SolidIcon.tsx` - New Solid icon component for authentication UI
 - `packages/client/src/svgs/index.ts` - Exported SolidIcon
@@ -272,16 +280,16 @@ None currently identified.
 ## Environment Variables
 
 ### Solid Authentication (SOLID_OPENID_*)
-The following environment variables are required for the "Login with Solid" button:
+Solid login is configured dynamically via `SOLID_OPENID_PROVIDERS` (JSON array of issuers). The following are used:
 
-- `SOLID_OPENID_CLIENT_ID` - OAuth client ID for Solid authentication
-- `SOLID_OPENID_CLIENT_SECRET` - OAuth client secret for Solid authentication
-- `SOLID_OPENID_ISSUER` - Solid Pod provider URL (e.g., `http://localhost:3000/`)
-- `SOLID_OPENID_SCOPE` - OAuth scopes (use `"openid webid offline_access"` for refresh token support when the IdP supports it)
-- `SOLID_OPENID_SESSION_SECRET` - Secret key for session management
-- `SOLID_OPENID_CALLBACK_URL` - OAuth callback URL (typically `/oauth/openid/callback`)
+- `SOLID_OPENID_PROVIDERS` - **Required.** JSON array; each item: `issuer`, `clientId`, optional `clientSecret`, `scope`, `label`
+- `SOLID_OPENID_CLIENT_ID` - Optional; used when your client_id document URL is not `DOMAIN_SERVER/solid-client-id`
+- `SOLID_OPENID_SESSION_SECRET` - Secret key for session management (recommended when using Solid)
+- `SOLID_OPENID_SCOPE` - Default scope (e.g. `"openid webid offline_access"`)
+- `SOLID_OPENID_CALLBACK_URL` - OAuth callback path (typically `/oauth/openid/callback`)
 
 ### Optional Solid Configuration
+- `SOLID_OPENID_CUSTOM_CLIENT_ID` - Optional; when set, allows logging in with any allowed issuer (e.g. user picks "Local CSS" from modal) using this client id; used by getSolidOpenIdProviderByIssuer and getSolidOpenIdProvidersForJwt when SOLID_OPENID_PROVIDERS is empty
 - `SOLID_OPENID_BUTTON_LABEL` - Custom label for the Solid login button (default: "Continue with Solid")
 - `SOLID_OPENID_IMAGE_URL` - Custom icon URL for the Solid login button
 - `SOLID_OPENID_AUTO_REDIRECT` - Enable automatic redirect to Solid provider on login page
@@ -308,6 +316,6 @@ The following environment variables are used for the generic "Login with OpenID"
 
 ---
 
-**Report Date**: February 25, 2026
+**Report Date**: February 27, 2026
 
 
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 169a3f0ad0e1..6eb9bd1aa07b 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -64,40 +64,31 @@ const resetPasswordController = async (req, res) => {
   }
 };
 
-const refreshController = async (req, res) => {
-  const parsedCookies = req.headers.cookie ? cookies.parse(req.headers.cookie) : {};
-  const token_provider = parsedCookies.token_provider;
-
-  // Handle OpenID users with OPENID_REUSE_TOKENS enabled
-  if (token_provider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    /** For OpenID users with token reuse, read refresh token from session */
-    const refreshToken = req.session?.openidTokens?.refreshToken || parsedCookies.refreshToken;
-
-    if (!refreshToken) {
-      // Solid provider may not provide refresh tokens - fall back to standard JWT refresh
-      logger.warn(
-        '[refreshController] No OpenID refresh token available, falling back to standard refresh',
-      );
-      return res.status(200).send('Refresh token not provided');
-    }
-
-    // We have a refresh token, use OpenID refresh flow
-    try {
-        const openIdConfig = getOpenIdConfig();
-        const refreshParams = process.env.OPENID_SCOPE ? { scope: process.env.OPENID_SCOPE } : {};
-      const tokenset = await openIdClient.refreshTokenGrant(
-        openIdConfig,
-        refreshToken,
-        refreshParams,
-      );
-      const claims = tokenset.claims();
-      const { user, error, migration } = await findOpenIDUser({
-        findUser,
-        email: getOpenIdEmail(claims),
-        openidId: claims.sub,
-        idOnTheSource: claims.oid,
-        strategyName: 'refreshController',
-      });
+/**
+ * Shared OpenID/Solid refresh flow: exchange refresh token for new tokenset, find user, update session, return token and user.
+ * @param {Object} req - Express request
+ * @param {Object} res - Express response
+ * @param {Object} openIdConfig - Issuer config from getOpenIdConfig() or getSolidOpenIdConfig()
+ * @param {string} refreshToken - Refresh token from session or cookie
+ * @param {Record<string, string>} [refreshParams] - Optional params for token endpoint (e.g. { scope: process.env.SOLID_OPENID_SCOPE })
+ * @param {string} [tokenProvider] - 'solid' or 'openid' from cookie so setOpenIDAuthTokens sets the correct token_provider cookie
+ * @returns {Promise<boolean>} True if response was sent, false if caller should continue to next handler
+ */
+async function performOpenIDRefresh(req, res, openIdConfig, refreshToken, refreshParams = {}, tokenProvider) {
+  try {
+    const tokenset = await openIdClient.refreshTokenGrant(
+      openIdConfig,
+      refreshToken,
+      Object.keys(refreshParams).length ? refreshParams : undefined,
+    );
+    const claims = tokenset.claims();
+    const { user, error, migration } = await findOpenIDUser({
+      findUser,
+      email: getOpenIdEmail(claims),
+      openidId: claims.sub,
+      idOnTheSource: claims.oid,
+      strategyName: 'refreshController',
+    });
 
       logger.debug(
         `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
@@ -115,7 +106,7 @@ const refreshController = async (req, res) => {
       if (migration || user.openidId !== claims.sub) {
         const reason = migration ? 'migration' : 'openidId mismatch';
         await updateUser(user._id.toString(), {
-          provider: 'openid',
+          provider: user.provider || 'openid',
           openidId: claims.sub,
         });
         logger.info(
@@ -123,6 +114,12 @@ const refreshController = async (req, res) => {
         );
       }
 
+    // setOpenIDAuthTokens sets token_provider cookie correctly (solid vs openid)
+    req.user = user;
+    if (tokenProvider) {
+      user.provider = user.provider || tokenProvider;
+    }
+
       const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
 
       user.federatedTokens = {
@@ -186,7 +183,53 @@ const refreshController = async (req, res) => {
       return res.status(200).send('Refresh token not provided');
     }
 
-    const openIdConfig = token_provider === 'solid' ? getSolidOpenIdConfig() : getOpenIdConfig();
+    const openIdConfig =
+      token_provider === 'solid'
+        ? (() => {
+            try {
+              return getSolidOpenIdConfig();
+            } catch (e) {
+              logger.warn('[refreshController] Solid OpenID config not initialized', {
+                message: e?.message,
+              });
+              return null;
+            }
+          })()
+        : (() => {
+            try {
+              return getOpenIdConfig();
+            } catch (e) {
+              logger.warn('[refreshController] OpenID config not initialized', { message: e?.message });
+              return null;
+            }
+          })();
+
+    if (!openIdConfig) {
+      const sessionToken =
+        req.session?.openidTokens?.idToken || req.session?.openidTokens?.accessToken;
+      if (sessionToken) {
+        try {
+          const payload = jwt.decode(sessionToken);
+          const sub = payload?.sub;
+          if (sub) {
+            const { user, error } = await findOpenIDUser({
+              findUser,
+              email: payload.email,
+              openidId: sub,
+              idOnTheSource: payload.oid,
+              strategyName: 'refreshController',
+            });
+            if (!error && user) {
+              return res.status(200).send({ token: sessionToken, user });
+            }
+          }
+        } catch (err) {
+          logger.debug('[refreshController] Session token decode/lookup failed', err.message);
+        }
+      }
+      return res.status(200).send('Refresh token not provided');
+    }
+
     let refreshParams = {};
     if (token_provider === 'solid' && process.env.SOLID_OPENID_SCOPE) {
       refreshParams = { scope: process.env.SOLID_OPENID_SCOPE };
@@ -194,7 +237,14 @@ const refreshController = async (req, res) => {
       refreshParams = { scope: process.env.OPENID_SCOPE };
     }
 
-    const sent = await performOpenIDRefresh(req, res, openIdConfig, refreshToken, refreshParams);
+    const sent = await performOpenIDRefresh(
+      req,
+      res,
+      openIdConfig,
+      refreshToken,
+      refreshParams,
+      token_provider,
+    );
     if (sent) return;
   }
 
diff --git a/api/server/controllers/auth/solidOpenIdDynamic.js b/api/server/controllers/auth/solidOpenIdDynamic.js
new file mode 100644
index 000000000000..a6316ef368b4
--- /dev/null
+++ b/api/server/controllers/auth/solidOpenIdDynamic.js
@@ -0,0 +1,222 @@
+/**
+ * Dynamic Solid OpenID flow: start and callback for multi-issuer (issuer in query / state).
+ * When frontend sends ?issuer=..., we do discovery for that issuer, store PKCE in session,
+ * redirect to IdP. On callback we read state (contains issuer), exchange code, verify user.
+ */
+
+const client = require('openid-client');
+const { logger } = require('@librechat/data-schemas');
+const { getSolidOpenIdProviderByIssuer } = require('~/server/services/Config/solidOpenId');
+const { verifySolidUser } = require('~/strategies');
+const undici = require('undici');
+
+const SESSION_KEY = 'solidOpenIdPKCE';
+const STATE_PREFIX = 'solid_';
+
+/**
+ * Encode state payload (issuer + random) for round-trip.
+ * @param {{ issuer: string, rnd: string }} payload
+ * @returns {string}
+ */
+function encodeState(payload) {
+  return STATE_PREFIX + Buffer.from(JSON.stringify(payload), 'utf8').toString('base64url');
+}
+
+/**
+ * Decode state if it's our format (starts with solid_).
+ * @param {string} state
+ * @returns {{ issuer: string, rnd: string } | null}
+ */
+function decodeState(state) {
+  if (!state || typeof state !== 'string' || !state.startsWith(STATE_PREFIX)) {
+    return null;
+  }
+  try {
+    const json = Buffer.from(state.slice(STATE_PREFIX.length), 'base64url').toString('utf8');
+    const payload = JSON.parse(json);
+    if (payload && typeof payload.issuer === 'string') {
+      return payload;
+    }
+  } catch (e) {
+    logger.debug('[solidOpenIdDynamic] decodeState failed', { error: e?.message });
+  }
+  return null;
+}
+
+async function customFetchForDiscovery(url, options) {
+  let fetchOptions = options;
+  if (process.env.PROXY) {
+    fetchOptions = { ...options, dispatcher: new undici.ProxyAgent(process.env.PROXY) };
+  }
+  return undici.fetch(url, fetchOptions);
+}
+
+const discoveryOptions = {
+  [client.customFetch]: customFetchForDiscovery,
+  execute: [client.allowInsecureRequests],
+};
+
+/**
+ * Start Solid OpenID flow for the given issuer (from query). Validate issuer, do discovery,
+ * store PKCE in session, redirect to IdP.
+ */
+async function startSolidOpenIdFlow(req, res, next) {
+  const issuer = req.query.issuer;
+  if (!issuer || typeof issuer !== 'string') {
+    return next();
+  }
+
+  const provider = getSolidOpenIdProviderByIssuer(issuer.trim());
+  if (!provider) {
+    logger.warn('[solidOpenIdDynamic] Unknown or unconfigured issuer', { issuer: issuer.slice(0, 80) });
+    res.status(400).send('Unknown or unconfigured Solid Identity Provider. Use one of the options from the login page.');
+    return;
+  }
+
+  try {
+    const clientMetadata = {
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret || undefined,
+    };
+    const clientAuth = provider.clientSecret
+      ? client.ClientSecretPost(provider.clientSecret)
+      : undefined;
+
+    const config = await client.discovery(
+      new URL(provider.issuer),
+      provider.clientId,
+      clientMetadata,
+      clientAuth,
+      discoveryOptions,
+    );
+
+    const statePayload = {
+      issuer: provider.issuer,
+      rnd: client.randomState(),
+    };
+    const state = encodeState(statePayload);
+
+    // Solid-OIDC requires PKCE for authorization code; always use it for this flow.
+    const usePKCE = true;
+    let code_verifier;
+    const authParams = {
+      redirect_uri: process.env.DOMAIN_SERVER + provider.callbackPath,
+      scope: provider.scope,
+      state,
+      prompt: 'consent',
+    };
+    if (usePKCE) {
+      code_verifier = client.randomPKCECodeVerifier();
+      authParams.code_challenge = await client.calculatePKCECodeChallenge(code_verifier);
+      authParams.code_challenge_method = 'S256';
+    }
+
+    if (!req.session) {
+      logger.error('[solidOpenIdDynamic] No session available for PKCE storage');
+      res.status(500).send('Session required for Solid login.');
+      return;
+    }
+    if (!req.session[SESSION_KEY]) {
+      req.session[SESSION_KEY] = {};
+    }
+    req.session[SESSION_KEY][state] = { code_verifier, issuer: provider.issuer };
+    req.session.save((err) => {
+      if (err) {
+        logger.error('[solidOpenIdDynamic] Session save failed', err);
+        res.status(500).send('Session error.');
+        return;
+      }
+      const redirectTo = client.buildAuthorizationUrl(config, authParams);
+      logger.info('[solidOpenIdDynamic] Redirecting to Solid IdP', { issuer: provider.issuer });
+      res.redirect(redirectTo.toString());
+    });
+  } catch (err) {
+    logger.error('[solidOpenIdDynamic] startSolidOpenIdFlow failed', err);
+    next(err);
+  }
+}
+
+/**
+ * Handle Solid OpenID callback when state is our format (multi-issuer flow).
+ * Exchange code for tokens, verify user, set req.user and call next() to run oauthHandler.
+ */
+async function handleSolidOpenIdCallback(req, res, next) {
+  const state = req.query.state;
+  const decoded = decodeState(state);
+  if (!decoded) {
+    return next();
+  }
+
+  const code = req.query.code;
+  if (!code) {
+    const errParam = req.query.error;
+    const errDesc = req.query.error_description;
+    logger.warn('[solidOpenIdDynamic] Callback missing code - IdP likely rejected the auth request', {
+      error: errParam,
+      error_description: errDesc,
+    });
+    res.redirect(`${process.env.DOMAIN_CLIENT}/login?redirect=false&error=auth_failed`);
+    return;
+  }
+
+  const sessionData = req.session && req.session[SESSION_KEY] && req.session[SESSION_KEY][state];
+  if (!sessionData || !sessionData.code_verifier) {
+    logger.warn('[solidOpenIdDynamic] No PKCE data in session for state');
+    res.redirect(`${process.env.DOMAIN_CLIENT}/login?redirect=false&error=auth_failed`);
+    return;
+  }
+
+  const provider = getSolidOpenIdProviderByIssuer(decoded.issuer);
+  if (!provider) {
+    logger.warn('[solidOpenIdDynamic] Callback issuer not configured', { issuer: decoded.issuer });
+    res.redirect(`${process.env.DOMAIN_CLIENT}/login?redirect=false&error=auth_failed`);
+    return;
+  }
+
+  try {
+    const clientMetadata = {
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret || undefined,
+    };
+    const clientAuth = provider.clientSecret
+      ? client.ClientSecretPost(provider.clientSecret)
+      : undefined;
+
+    const config = await client.discovery(
+      new URL(provider.issuer),
+      provider.clientId,
+      clientMetadata,
+      clientAuth,
+      discoveryOptions,
+    );
+
+    const currentUrl = new URL(
+      req.originalUrl || req.url,
+      process.env.DOMAIN_SERVER,
+    );
+
+    const tokenset = await client.authorizationCodeGrant(
+      config,
+      currentUrl,
+      {
+        expectedState: state,
+        ...(sessionData.code_verifier && { pkceCodeVerifier: sessionData.code_verifier }),
+      },
+    );
+
+    delete req.session[SESSION_KEY][state];
+    req.session.save(() => {});
+
+    const user = await verifySolidUser(tokenset, config);
+    req.user = user;
+    next();
+  } catch (err) {
+    logger.error('[solidOpenIdDynamic] handleSolidOpenIdCallback failed', err);
+    res.redirect(`${process.env.DOMAIN_CLIENT}/login?redirect=false&error=auth_failed`);
+  }
+}
+
+module.exports = {
+  startSolidOpenIdFlow,
+  handleSolidOpenIdCallback,
+};
diff --git a/api/server/index.js b/api/server/index.js
index ab42170ef35a..5ac8dec46a4f 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -167,19 +167,21 @@ const startServer = async () => {
   app.use('/api/mcp', routes.mcp);
 
   // Solid-OIDC Client ID Document route, see spec https://solidproject.org/TR/oidc#clientids-document
-  // TODO: Expose this route only if adequate according to config, i.e. when Solid-OIDC is in use
-  // TODO: Follow 'app.use' pattern instead of inlining route here
-  // TODO: Make path configurable instead of hardcoding here
+  // Local CSS (and other Solid IdPs) fetch this URL to get redirect_uris; they must match the redirect_uri we send in the auth request.
   app.get('/solid-client-id', (_, res) => {
-    // TODO: Use constants/enums for header name and value if available from framework
+    const callbackPath =
+      process.env.SOLID_OPENID_CALLBACK_URL || process.env.OPENID_CALLBACK_URL || '/oauth/openid/callback';
+    const baseUrl = process.env.DOMAIN_SERVER || 'http://localhost:3080';
+    const clientId = `${baseUrl}/solid-client-id`;
     res.set('Content-Type', 'application/ld+json');
-
     res.send({
       '@context': ['https://www.w3.org/ns/solid/oidc-context.jsonld'],
-      redirect_uris: [process.env.DOMAIN_SERVER + process.env.OPENID_CALLBACK_URL],
-
-      // TODO: Don't hardcode path
-      client_id: process.env.DOMAIN_SERVER + '/solid-client-id',
+      client_id: clientId,
+      client_name: process.env.SOLID_OPENID_BUTTON_LABEL || 'LibreChat Solid Client',
+      redirect_uris: [baseUrl + callbackPath],
+      scope: process.env.SOLID_OPENID_SCOPE || 'openid webid offline_access',
+      grant_types: ['refresh_token', 'authorization_code'],
+      response_types: ['code'],
     });
   });
 
diff --git a/api/server/middleware/openIdAuthHelpers.js b/api/server/middleware/openIdAuthHelpers.js
new file mode 100644
index 000000000000..1376ab366ef1
--- /dev/null
+++ b/api/server/middleware/openIdAuthHelpers.js
@@ -0,0 +1,20 @@
+/**
+ * Shared 503 response when OpenID/Solid JWT strategy is not registered.
+ * Used by requireJwtAuth and optionalJwtAuth to avoid duplicating message logic.
+ * @param {import('express').Response} res
+ * @param {'solid' | 'openid'} tokenProvider
+ * @param {boolean} [afterLazyInit] - True when lazy init was attempted for Solid and still not registered
+ */
+function sendStrategyNotRegistered503(res, tokenProvider, afterLazyInit = false) {
+  const name = tokenProvider === 'solid' ? 'Solid' : 'OpenID';
+  const message =
+    afterLazyInit && tokenProvider === 'solid'
+      ? 'You logged in with Solid, but the server could not register the Solid strategy. Ensure your Solid IdP (e.g. Local CSS) is running and SOLID_OPENID_PROVIDERS (or legacy Solid env) is set.'
+      : `You logged in with ${name}, but the server does not have the corresponding strategy registered. Please contact the administrator.`;
+  return res.status(503).json({
+    error: 'Authentication not configured',
+    message,
+  });
+}
+
+module.exports = { sendStrategyNotRegistered503 };
diff --git a/api/server/middleware/optionalJwtAuth.js b/api/server/middleware/optionalJwtAuth.js
index 7ea1ef8dc5c7..8183216a523e 100644
--- a/api/server/middleware/optionalJwtAuth.js
+++ b/api/server/middleware/optionalJwtAuth.js
@@ -1,9 +1,12 @@
 const cookies = require('cookie');
 const passport = require('passport');
 const { isEnabled } = require('@librechat/api');
+const { ensureSolidJwtRegisteredLazy } = require('../services/ensureSolidJwt');
+const { sendStrategyNotRegistered503 } = require('./openIdAuthHelpers');
 
 // This middleware does not require authentication,
 // but if the user is authenticated, it will set the user object.
+// When token_provider is solid/openid we always use the corresponding strategy (no fallback).
 const optionalJwtAuth = (req, res, next) => {
   const cookieHeader = req.headers.cookie;
   const tokenProvider = cookieHeader ? cookies.parse(cookieHeader).token_provider : null;
@@ -16,13 +19,31 @@ const optionalJwtAuth = (req, res, next) => {
     }
     next();
   };
-  if (
-    (tokenProvider === 'openid' || tokenProvider === 'solid') &&
-    isEnabled(process.env.OPENID_REUSE_TOKENS)
-  ) {
+
+  if (tokenProvider === 'solid' || tokenProvider === 'openid') {
+    const useOpenIdStrategy = isEnabled(process.env.OPENID_REUSE_TOKENS);
     const strategy = tokenProvider === 'solid' ? 'solidJwt' : 'openidJwt';
-    return passport.authenticate(strategy, { session: false }, callback)(req, res, next);
+    const strategyRegistered =
+      typeof passport._strategies === 'object' && passport._strategies[strategy];
+
+    if (useOpenIdStrategy && strategyRegistered) {
+      return passport.authenticate(strategy, { session: false }, callback)(req, res, next);
+    }
+    if (useOpenIdStrategy && !strategyRegistered && tokenProvider === 'solid') {
+      return ensureSolidJwtRegisteredLazy()
+        .then((registered) => {
+          if (registered && passport._strategies && passport._strategies.solidJwt) {
+            return passport.authenticate('solidJwt', { session: false }, callback)(req, res, next);
+          }
+          return sendStrategyNotRegistered503(res, tokenProvider, true);
+        })
+        .catch(next);
+    }
+    if (useOpenIdStrategy && !strategyRegistered) {
+      return sendStrategyNotRegistered503(res, tokenProvider);
+    }
   }
+
   passport.authenticate('jwt', { session: false }, callback)(req, res, next);
 };
 
diff --git a/api/server/middleware/requireJwtAuth.js b/api/server/middleware/requireJwtAuth.js
index 8ce8e5864772..0ed13c57c391 100644
--- a/api/server/middleware/requireJwtAuth.js
+++ b/api/server/middleware/requireJwtAuth.js
@@ -1,25 +1,42 @@
 const cookies = require('cookie');
 const passport = require('passport');
 const { isEnabled } = require('@librechat/api');
+const { ensureSolidJwtRegisteredLazy } = require('../services/ensureSolidJwt');
+const { sendStrategyNotRegistered503 } = require('./openIdAuthHelpers');
 
 /**
  * Custom Middleware to handle JWT authentication, with support for OpenID token reuse
- * Switches between JWT and OpenID authentication based on cookies and environment settings
+ * When token_provider is solid/openid we always use the corresponding strategy (no fallback).
+ * For Solid, we try lazy registration once if the strategy wasn't registered at startup (e.g. IdP was down).
  */
 const requireJwtAuth = (req, res, next) => {
   const cookieHeader = req.headers.cookie;
   const tokenProvider = cookieHeader ? cookies.parse(cookieHeader).token_provider : null;
 
-  // Use OpenID/Solid JWT authentication when OPENID_REUSE_TOKENS is enabled
-  if (
-    (tokenProvider === 'openid' || tokenProvider === 'solid') &&
-    isEnabled(process.env.OPENID_REUSE_TOKENS)
-  ) {
+  if (tokenProvider === 'solid' || tokenProvider === 'openid') {
+    const useOpenIdStrategy = isEnabled(process.env.OPENID_REUSE_TOKENS);
     const strategy = tokenProvider === 'solid' ? 'solidJwt' : 'openidJwt';
-    return passport.authenticate(strategy, { session: false })(req, res, next);
+    const strategyRegistered =
+      typeof passport._strategies === 'object' && passport._strategies[strategy];
+
+    if (useOpenIdStrategy && strategyRegistered) {
+      return passport.authenticate(strategy, { session: false })(req, res, next);
+    }
+    if (useOpenIdStrategy && !strategyRegistered && tokenProvider === 'solid') {
+      return ensureSolidJwtRegisteredLazy()
+        .then((registered) => {
+          if (registered && passport._strategies && passport._strategies.solidJwt) {
+            return passport.authenticate('solidJwt', { session: false })(req, res, next);
+          }
+          return sendStrategyNotRegistered503(res, tokenProvider, true);
+        })
+        .catch(next);
+    }
+    if (useOpenIdStrategy && !strategyRegistered) {
+      return sendStrategyNotRegistered503(res, tokenProvider);
+    }
   }
 
-  // Default to standard JWT authentication
   return passport.authenticate('jwt', { session: false }, (err, user, _info) => {
     if (err) {
       return res.status(401).json({ error: 'Authentication failed', message: err.message });
diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index fb49a2804da5..e1fa61fcc8c7 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -3,6 +3,12 @@ const { logger } = require('@librechat/data-schemas');
 const { isEnabled, getBalanceConfig } = require('@librechat/api');
 const { Constants, CacheKeys, defaultSocialLogins } = require('librechat-data-provider');
 const { getLdapConfig } = require('~/server/services/Config/ldap');
+const {
+  getSolidOpenIdProviders,
+  isSolidOpenIdEnabled,
+  normalizeIssuer,
+  DEFAULT_ISSUER_OPTIONS,
+} = require('~/server/services/Config/solidOpenId');
 const { getAppConfig } = require('~/server/services/Config/app');
 const { getProjectByName } = require('~/models/Project');
 const { getLogStores } = require('~/cache');
@@ -49,10 +55,7 @@ router.get('/', async function (req, res) {
       !!process.env.OPENID_ISSUER &&
       !!process.env.OPENID_SESSION_SECRET;
 
-    const isSolidEnabled =
-      !!process.env.SOLID_OPENID_CLIENT_ID &&
-      !!process.env.SOLID_OPENID_ISSUER &&
-      !!process.env.SOLID_OPENID_SESSION_SECRET;
+    const isSolidEnabled = isSolidOpenIdEnabled();
 
     const isSamlEnabled =
       !!process.env.SAML_ENTRY_POINT &&
@@ -89,6 +92,20 @@ router.get('/', async function (req, res) {
       solidLabel: process.env.SOLID_OPENID_BUTTON_LABEL || 'Continue with Solid',
       solidImageUrl: process.env.SOLID_OPENID_IMAGE_URL,
       solidAutoRedirect: isEnabled(process.env.SOLID_OPENID_AUTO_REDIRECT),
+      solidIdpOptions: isSolidEnabled
+        ? [
+            ...DEFAULT_ISSUER_OPTIONS,
+            ...getSolidOpenIdProviders()
+              .filter(
+                (p) =>
+                  !DEFAULT_ISSUER_OPTIONS.some(
+                    (d) => normalizeIssuer(d.issuer) === p.issuer,
+                  ),
+              )
+              .map((p) => ({ issuer: p.issuer, label: p.label })),
+          ]
+        : [],
+      solidCustomEnabled: !!process.env.SOLID_OPENID_CUSTOM_CLIENT_ID,
       samlLoginEnabled: !isOpenIdEnabled && isSamlEnabled,
       samlLabel: process.env.SAML_BUTTON_LABEL,
       samlImageUrl: process.env.SAML_IMAGE_URL,
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 2dd37a0fc1fc..8e00f1df8ff1 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -7,6 +7,10 @@ const { ErrorTypes } = require('librechat-data-provider');
 const { createSetBalanceConfig, isEnabled } = require('@librechat/api');
 const { checkDomainAllowed, loginLimiter, logHeaders, checkBan } = require('~/server/middleware');
 const { createOAuthHandler: _createOAuthHandler } = require('~/server/controllers/auth/oauth');
+const {
+  startSolidOpenIdFlow,
+  handleSolidOpenIdCallback,
+} = require('~/server/controllers/auth/solidOpenIdDynamic');
 const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
 const { syncUserEntraGroupMemberships } = require('~/server/services/PermissionService');
 const { startBaseStructureAfterLogin } = require('~/server/services/SolidStorage');
@@ -144,8 +148,9 @@ router.get(
 
 /**
  * OpenID Routes
+ * When ?issuer= is present, use dynamic Solid multi-issuer flow; otherwise Passport (single-issuer or generic OpenID).
  */
-router.get('/openid', (req, res, next) => {
+router.get('/openid', startSolidOpenIdFlow, (req, res, next) => {
   return passport.authenticate('openid', {
     session: false,
     state: randomState(),
@@ -174,6 +179,7 @@ const logAuthorizationCode = (req, res, next) => {
   } else if (error) {
     logger.warn('[OpenID Callback] OAuth error received (no authorization code)', {
       error,
+      error_description: req.query.error_description,
       state: state || 'not provided',
     });
   } else {
@@ -188,11 +194,17 @@ const logAuthorizationCode = (req, res, next) => {
 router.get(
   '/openid/callback',
   logAuthorizationCode,
-  passport.authenticate('openid', {
-    failureRedirect: `${domains.client}/oauth/error`,
-    failureMessage: true,
-    session: false,
-  }),
+  handleSolidOpenIdCallback,
+  (req, res, next) => {
+    if (req.user) {
+      return next();
+    }
+    return passport.authenticate('openid', {
+      failureRedirect: `${domains.client}/oauth/error`,
+      failureMessage: true,
+      session: false,
+    })(req, res, next);
+  },
   setBalanceConfig,
   checkDomainAllowed,
   oauthHandler,
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index 53da0742be8d..0aaa8b015716 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -488,6 +488,16 @@ const setOpenIDAuthTokens = (tokenset, req, res, userId, existingRefreshToken) =
         expiresAt: expirationDate.getTime(),
       };
 
+      // Set id_token cookie as well so first API request (before frontend refresh sets Authorization header) can authenticate
+      if (tokenset.id_token) {
+        res.cookie('openid_id_token', tokenset.id_token, {
+          expires: expirationDate,
+          httpOnly: true,
+          secure: shouldUseSecureCookie(),
+          sameSite: 'strict',
+        });
+      }
+
       // Explicitly save the session to ensure it persists
       req.session.save((err) => {
         if (err) {
diff --git a/api/server/services/Config/solidOpenId.js b/api/server/services/Config/solidOpenId.js
new file mode 100644
index 000000000000..6104d43fe370
--- /dev/null
+++ b/api/server/services/Config/solidOpenId.js
@@ -0,0 +1,190 @@
+/**
+ * Solid OpenID provider configuration.
+ * Supports multiple issuers via SOLID_OPENID_PROVIDERS (JSON array).
+ */
+
+const defaultScope = process.env.SOLID_OPENID_SCOPE || 'openid webid offline_access';
+const defaultCallbackPath =
+  process.env.SOLID_OPENID_CALLBACK_URL || '/oauth/openid/callback';
+
+/**
+ * Default display labels for known issuers (used when provider config has no label).
+ */
+const KNOWN_ISSUER_LABELS = {
+  'http://localhost:3000/': 'Local CSS',
+  'http://localhost:3000': 'Local CSS',
+  'https://solidcommunity.net/': 'Solid Community',
+  'https://solidcommunity.net': 'Solid Community',
+  'https://login.inrupt.com/': 'Inrupt',
+  'https://login.inrupt.com': 'Inrupt',
+};
+
+/** Issuer URLs for the 3 default options shown in the login modal. */
+const DEFAULT_ISSUER_OPTIONS = [
+  { issuer: 'http://localhost:3000/', label: 'Local CSS' },
+  { issuer: 'https://solidcommunity.net/', label: 'Solid Community' },
+  { issuer: 'https://login.inrupt.com/', label: 'Inrupt' },
+];
+
+/**
+ * Normalize issuer URL for comparison (trailing slash, no fragment).
+ * @param {string} issuer
+ * @returns {string}
+ */
+function normalizeIssuer(issuer) {
+  if (!issuer || typeof issuer !== 'string') {
+    return '';
+  }
+  const u = issuer.trim();
+  if (!u) {
+    return '';
+  }
+  try {
+    const url = new URL(u.startsWith('http') ? u : `https://${u}`);
+    url.hash = '';
+    let path = url.pathname;
+    if (!path.endsWith('/')) {
+      path += '/';
+    }
+    return `${url.origin}${path}`;
+  } catch {
+    return u;
+  }
+}
+
+/**
+ * Get the list of configured Solid OpenID providers.
+ * Each provider has: issuer, clientId, clientSecret, scope, label, callbackPath.
+ * Configure via SOLID_OPENID_PROVIDERS (JSON array); each entry may have
+ * issuer, clientId, clientSecret, scope (optional), label (optional).
+ *
+ * @returns {{ issuer: string, clientId: string, clientSecret: string, scope: string, label: string, callbackPath: string }[]}
+ */
+function getSolidOpenIdProviders() {
+  const providers = [];
+
+  if (process.env.SOLID_OPENID_PROVIDERS) {
+    try {
+      const parsed = JSON.parse(process.env.SOLID_OPENID_PROVIDERS);
+      if (!Array.isArray(parsed)) {
+        return providers;
+      }
+      for (const p of parsed) {
+        const issuer = normalizeIssuer(p.issuer || p.url);
+        if (!issuer || !p.clientId) {
+          continue;
+        }
+        const label =
+          p.label ||
+          KNOWN_ISSUER_LABELS[issuer] ||
+          KNOWN_ISSUER_LABELS[issuer.replace(/\/$/, '')] ||
+          issuer;
+        providers.push({
+          issuer,
+          clientId: String(p.clientId).trim(),
+          clientSecret: (p.clientSecret && String(p.clientSecret).trim()) || '',
+          scope: (p.scope && String(p.scope).trim()) || defaultScope,
+          label,
+          callbackPath: (p.callbackPath && String(p.callbackPath).trim()) || defaultCallbackPath,
+        });
+      }
+    } catch (e) {
+      // Invalid JSON
+    }
+  }
+
+  return providers;
+}
+
+/**
+ * Get provider list for solidJwt registration (startup or lazy).
+ * When SOLID_OPENID_PROVIDERS is empty but SOLID_OPENID_CUSTOM_CLIENT_ID is set, returns one synthetic
+ * provider for Local CSS so we can still register solidJwt (e.g. user picked "Local CSS" from modal).
+ * @returns {{ issuer: string, clientId: string, clientSecret: string, scope: string, label: string, callbackPath: string }[]}
+ */
+function getSolidOpenIdProvidersForJwt() {
+  const list = getSolidOpenIdProviders();
+  if (list.length > 0) {
+    return list;
+  }
+  if (process.env.SOLID_OPENID_CUSTOM_CLIENT_ID) {
+    return [
+      {
+        issuer: 'http://localhost:3000/',
+        clientId: process.env.SOLID_OPENID_CUSTOM_CLIENT_ID,
+        clientSecret: process.env.SOLID_OPENID_CUSTOM_CLIENT_SECRET || '',
+        scope: process.env.SOLID_OPENID_CUSTOM_SCOPE || defaultScope,
+        label: 'Local CSS',
+        callbackPath: defaultCallbackPath,
+      },
+    ];
+  }
+  return [];
+}
+
+/**
+ * Check if an issuer URL is allowed for "custom" (https or http localhost).
+ * @param {string} normalizedIssuer
+ * @returns {boolean}
+ */
+function isAllowedCustomIssuer(normalizedIssuer) {
+  if (!normalizedIssuer) return false;
+  try {
+    const url = new URL(normalizedIssuer);
+    if (url.protocol === 'https:') return true;
+    if (url.protocol === 'http:' && (url.hostname === 'localhost' || url.hostname === '127.0.0.1'))
+      return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get provider config by issuer (must match normalized issuer).
+ * If not in configured list, and SOLID_OPENID_CUSTOM_CLIENT_ID is set, returns a synthetic
+ * "custom" provider for any allowed issuer URL (https or http localhost).
+ * @param {string} issuer
+ * @returns {{ issuer: string, clientId: string, clientSecret: string, scope: string, label: string, callbackPath: string } | null}
+ */
+function getSolidOpenIdProviderByIssuer(issuer) {
+  const normalized = normalizeIssuer(issuer);
+  const providers = getSolidOpenIdProviders();
+  const configured = providers.find((p) => p.issuer === normalized);
+  if (configured) return configured;
+
+  // Custom issuer: use SOLID_OPENID_CUSTOM_* if set and URL is allowed
+  if (
+    process.env.SOLID_OPENID_CUSTOM_CLIENT_ID &&
+    isAllowedCustomIssuer(normalized)
+  ) {
+    return {
+      issuer: normalized,
+      clientId: process.env.SOLID_OPENID_CUSTOM_CLIENT_ID,
+      clientSecret: process.env.SOLID_OPENID_CUSTOM_CLIENT_SECRET || '',
+      scope: process.env.SOLID_OPENID_CUSTOM_SCOPE || defaultScope,
+      label: KNOWN_ISSUER_LABELS[normalized] || KNOWN_ISSUER_LABELS[normalized.replace(/\/$/, '')] || 'Custom',
+      callbackPath: defaultCallbackPath,
+    };
+  }
+  return null;
+}
+
+/**
+ * Check if Solid OpenID is enabled (at least one provider or custom credentials configured).
+ * @returns {boolean}
+ */
+function isSolidOpenIdEnabled() {
+  return getSolidOpenIdProviders().length > 0 || !!process.env.SOLID_OPENID_CUSTOM_CLIENT_ID;
+}
+
+module.exports = {
+  getSolidOpenIdProviders,
+  getSolidOpenIdProvidersForJwt,
+  getSolidOpenIdProviderByIssuer,
+  isSolidOpenIdEnabled,
+  normalizeIssuer,
+  defaultScope,
+  defaultCallbackPath,
+  DEFAULT_ISSUER_OPTIONS,
+};
diff --git a/api/server/services/ensureSolidJwt.js b/api/server/services/ensureSolidJwt.js
new file mode 100644
index 000000000000..288789759c2e
--- /dev/null
+++ b/api/server/services/ensureSolidJwt.js
@@ -0,0 +1,55 @@
+/**
+ * Ensures the solidJwt Passport strategy is registered when Solid is enabled.
+ * Used at startup (socialLogins) and on first request (lazy) if IdP was down at startup.
+ * @returns {Promise<boolean>} true if solidJwt is now registered (or was already), false otherwise
+ */
+const passport = require('passport');
+const { getSolidOpenIdProvidersForJwt } = require('./Config/solidOpenId');
+const { setupSolidOpenIdFromProvider, openIdJwtLogin } = require('~/strategies');
+const { logger } = require('@librechat/data-schemas');
+
+let lazyInitPromise = null;
+
+async function ensureSolidJwtRegistered() {
+  if (passport._strategies && passport._strategies.solidJwt) {
+    return true;
+  }
+  const providers = getSolidOpenIdProvidersForJwt();
+  if (providers.length === 0) {
+    return false;
+  }
+  const config = await setupSolidOpenIdFromProvider(providers[0]);
+  if (!config) {
+    logger.warn('[ensureSolidJwt] Discovery for first provider failed', {
+      issuer: providers[0].issuer,
+    });
+    return false;
+  }
+  if (passport._strategies && passport._strategies.solidJwt) {
+    return true;
+  }
+  passport.use('solidJwt', openIdJwtLogin(config));
+  logger.info('[ensureSolidJwt] solidJwt registered from first provider (lazy or startup).');
+  return true;
+}
+
+/**
+ * Call once from auth middleware when 503 would be returned for Solid; runs at most one discovery in flight.
+ * @returns {Promise<boolean>}
+ */
+async function ensureSolidJwtRegisteredLazy() {
+  if (passport._strategies && passport._strategies.solidJwt) {
+    return true;
+  }
+  if (!lazyInitPromise) {
+    lazyInitPromise = ensureSolidJwtRegistered().finally(() => {
+      lazyInitPromise = null;
+    });
+  }
+  return lazyInitPromise;
+}
+
+module.exports = {
+  ensureSolidJwtRegistered,
+  ensureSolidJwtRegisteredLazy,
+};
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index a33764c6f3db..222e173f250d 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -7,7 +7,7 @@ const {
   openIdJwtLogin,
   facebookLogin,
   discordLogin,
-  setupSolidOpenId,
+  setupSolidOpenIdFromProvider,
   setupOpenId,
   googleLogin,
   githubLogin,
@@ -15,14 +15,54 @@ const {
   setupSaml,
 } = require('~/strategies');
 const { getLogStores } = require('~/cache');
+const { getSolidOpenIdProviders, getSolidOpenIdProvidersForJwt, isSolidOpenIdEnabled } = require('./services/Config/solidOpenId');
+const { ensureSolidJwtRegistered } = require('./services/ensureSolidJwt');
 
 /**
- * Configures Solid OpenID Connect for the application.
+ * Registers solidJwt and sets OpenID config from the first Solid provider only (no session).
+ * Use when Solid providers exist but we didn't run configureSolidOpenId/configureSolidOpenIdFromProviders
+ * (e.g. session already added by generic OpenID). Ensures API requests with token_provider=solid succeed.
+ * @returns {Promise<void>}
+ */
+async function registerSolidJwtFromProviders() {
+  const providers = getSolidOpenIdProvidersForJwt();
+  if (providers.length === 0) {
+    logger.debug('[registerSolidJwtFromProviders] No Solid providers configured - skipping.');
+    return;
+  }
+  const config = await setupSolidOpenIdFromProvider(providers[0]);
+  if (!config) {
+    logger.warn(
+      '[registerSolidJwtFromProviders] Discovery for first provider failed - solidJwt not registered. Ensure the Solid IdP (e.g. Local CSS) is running at startup.',
+      { issuer: providers[0].issuer },
+    );
+    return;
+  }
+  if (passport._strategies && passport._strategies.solidJwt) {
+    return;
+  }
+  passport.use('solidJwt', openIdJwtLogin(config));
+  logger.info('Solid OpenID: solidJwt registered from first provider (post-login API auth).');
+}
+
+/** Wrapper for startup: use shared ensureSolidJwtRegistered when we need a final pass */
+async function ensureSolidJwtFromProvidersOnce() {
+  await ensureSolidJwtRegistered();
+}
+
+/**
+ * Configures Solid session and solidJwt when only SOLID_OPENID_PROVIDERS is set (no legacy single-issuer env).
+ * Also supports SOLID_OPENID_CUSTOM_CLIENT_ID-only: uses synthetic Local CSS provider for JWT registration.
+ * Ensures getSolidOpenIdConfig() and solidJwt work so post-login API requests and refresh succeed.
  * @param {Express.Application} app - The Express application instance.
  * @returns {Promise<void>}
  */
-async function configureSolidOpenId(app) {
-  logger.info('Configuring Solid OpenID Connect...');
+async function configureSolidOpenIdFromProviders(app) {
+  const providers = getSolidOpenIdProvidersForJwt();
+  if (providers.length === 0) {
+    return;
+  }
+  logger.info('Configuring Solid OpenID from providers (session + JWT for post-login)...');
   const sessionOptions = {
     secret: process.env.SOLID_OPENID_SESSION_SECRET,
     resave: false,
@@ -32,17 +72,16 @@ async function configureSolidOpenId(app) {
   app.use(session(sessionOptions));
   app.use(passport.session());
 
-  const config = await setupSolidOpenId();
+  const config = await setupSolidOpenIdFromProvider(providers[0]);
   if (!config) {
-    logger.error('Solid OpenID Connect configuration failed - strategy not registered.');
+    logger.warn('[configureSolidOpenIdFromProviders] Discovery for first provider failed - solidJwt not registered.');
     return;
   }
-
+  passport.use('solidJwt', openIdJwtLogin(config));
   if (isEnabled(process.env.OPENID_REUSE_TOKENS)) {
-    logger.info('Solid OpenID token reuse is enabled.');
-    passport.use('solidJwt', openIdJwtLogin(config));
+    logger.info('Solid OpenID token reuse enabled (solidJwt registered from first provider).');
   }
-  logger.info('Solid OpenID Connect configured successfully.');
+  logger.info('Solid OpenID from providers configured (session + solidJwt).');
 }
 
 /**
@@ -101,14 +140,20 @@ const configureSocialLogins = async (app) => {
   if (process.env.APPLE_CLIENT_ID && process.env.APPLE_PRIVATE_KEY_PATH) {
     passport.use(appleLogin());
   }
-  // Configure Solid OpenID if SOLID_OPENID_* env vars are present
+  // Solid: dynamic providers only (SOLID_OPENID_PROVIDERS or SOLID_OPENID_CUSTOM_CLIENT_ID). Session + solidJwt from first provider.
+  const solidProvidersForJwt = getSolidOpenIdProvidersForJwt();
+  const solidProvidersFromEnv = getSolidOpenIdProviders();
   if (
-    process.env.SOLID_OPENID_CLIENT_ID &&
-    process.env.SOLID_OPENID_ISSUER &&
-    process.env.SOLID_OPENID_SCOPE &&
-    process.env.SOLID_OPENID_SESSION_SECRET
+    process.env.SOLID_OPENID_SESSION_SECRET &&
+    solidProvidersForJwt.length > 0
   ) {
-    await configureSolidOpenId(app);
+    await configureSolidOpenIdFromProviders(app);
+  } else if (solidProvidersForJwt.length > 0) {
+    await registerSolidJwtFromProviders();
+  }
+  // Ensure solidJwt is registered whenever Solid is enabled (e.g. discovery failed earlier or IdP was down at startup)
+  if (isSolidOpenIdEnabled() && (!passport._strategies || !passport._strategies.solidJwt)) {
+    await ensureSolidJwtFromProvidersOnce();
   }
   // Configure generic OpenID if OPENID_* env vars are present
   if (
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 845483ada674..9ea545635753 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -294,6 +294,191 @@ function convertToUsername(input, defaultValue = '') {
   return defaultValue;
 }
 
+/**
+ * Verify Solid OpenID tokens and find/create user. Used by both the Passport strategy and the dynamic multi-issuer callback.
+ * @param {import('openid-client').TokenEndpointResponse & import('openid-client').TokenEndpointResponseHelpers} tokenset
+ * @param {Configuration} openidConfig
+ * @returns {Promise<Object>} User object with tokenset and federatedTokens (same shape as Passport verify callback).
+ * @throws {Error} On auth failure (email not allowed, required role missing, etc.)
+ */
+async function verifySolidUser(tokenset, openidConfig) {
+  const requiredRole = process.env.OPENID_REQUIRED_ROLE;
+  const requiredRoleParameterPath = process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH;
+  const requiredRoleTokenKind = process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND;
+  const adminRole = process.env.OPENID_ADMIN_ROLE;
+  const adminRoleParameterPath = process.env.OPENID_ADMIN_ROLE_PARAMETER_PATH;
+  const adminRoleTokenKind = process.env.OPENID_ADMIN_ROLE_TOKEN_KIND;
+
+  const claims = tokenset.claims();
+  const userinfo = {
+    ...claims,
+    ...(await getUserInfo(openidConfig, tokenset.access_token, claims.sub)),
+  };
+
+  const appConfig = await getAppConfig();
+  const email =
+    userinfo.email ||
+    userinfo.preferred_username ||
+    userinfo.upn ||
+    `${userinfo.webid}@FAKEDOMAIN.TLD`;
+  if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
+    logger.error(
+      `[SolidOpenidStrategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
+    );
+    const err = new Error('Email domain not allowed');
+    err.code = 'EMAIL_DOMAIN_NOT_ALLOWED';
+    throw err;
+  }
+
+  const result = await findOpenIDUser({
+    findUser,
+    email,
+    openidId: claims.sub,
+    idOnTheSource: claims.oid,
+    strategyName: 'SolidOpenidStrategy',
+  });
+  let user = result.user;
+  const error = result.error;
+
+  if (error) {
+    const err = new Error(ErrorTypes.AUTH_FAILED);
+    err.code = 'AUTH_FAILED';
+    throw err;
+  }
+
+  const fullName = getFullName(userinfo);
+
+  if (requiredRole) {
+    const requiredRoles = requiredRole
+      .split(',')
+      .map((role) => role.trim())
+      .filter(Boolean);
+    let decodedToken = '';
+    if (requiredRoleTokenKind === 'access') {
+      decodedToken = jwtDecode(tokenset.access_token);
+    } else if (requiredRoleTokenKind === 'id') {
+      decodedToken = jwtDecode(tokenset.id_token);
+    }
+
+    let roles = get(decodedToken, requiredRoleParameterPath);
+    if (!roles || (!Array.isArray(roles) && typeof roles !== 'string')) {
+      const rolesList =
+        requiredRoles.length === 1
+          ? `"${requiredRoles[0]}"`
+          : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
+      throw new Error(`You must have ${rolesList} role to log in.`);
+    }
+    if (!requiredRoles.some((role) => roles.includes(role))) {
+      const rolesList =
+        requiredRoles.length === 1
+          ? `"${requiredRoles[0]}"`
+          : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
+      throw new Error(`You must have ${rolesList} role to log in.`);
+    }
+  }
+
+  let username = '';
+  if (process.env.OPENID_USERNAME_CLAIM) {
+    username = userinfo[process.env.OPENID_USERNAME_CLAIM];
+  } else {
+    username = convertToUsername(
+      userinfo.preferred_username || userinfo.username || userinfo.email,
+    );
+  }
+
+  if (!user) {
+    user = {
+      provider: 'solid',
+      openidId: userinfo.sub,
+      username,
+      email: email || '',
+      emailVerified: userinfo.email_verified || false,
+      name: fullName,
+      idOnTheSource: userinfo.oid,
+    };
+    const balanceConfig = getBalanceConfig(appConfig);
+    user = await createUser(user, balanceConfig, true, true);
+  } else {
+    user.provider = 'solid';
+    user.openidId = userinfo.sub;
+    user.username = username;
+    user.name = fullName;
+    user.idOnTheSource = userinfo.oid;
+    if (email && email !== user.email) {
+      user.email = email;
+      user.emailVerified = userinfo.email_verified || false;
+    }
+  }
+
+  if (adminRole && adminRoleParameterPath && adminRoleTokenKind) {
+    let adminRoleObject;
+    switch (adminRoleTokenKind) {
+      case 'access':
+        adminRoleObject = jwtDecode(tokenset.access_token);
+        break;
+      case 'id':
+        adminRoleObject = jwtDecode(tokenset.id_token);
+        break;
+      case 'userinfo':
+        adminRoleObject = userinfo;
+        break;
+      default:
+        throw new Error(`Invalid admin role token kind: ${adminRoleTokenKind}`);
+    }
+    const adminRoles = get(adminRoleObject, adminRoleParameterPath);
+    if (
+      adminRoles &&
+      (adminRoles === true ||
+        adminRoles === adminRole ||
+        (Array.isArray(adminRoles) && adminRoles.includes(adminRole)))
+    ) {
+      user.role = 'ADMIN';
+    } else if (user.role === 'ADMIN') {
+      user.role = 'USER';
+    }
+  }
+
+  if (!!userinfo && userinfo.picture && !user.avatar?.includes('manual=true')) {
+    const imageUrl = userinfo.picture;
+    const crypto = require('crypto');
+    const fileName = crypto ? (await hashToken(userinfo.sub)) + '.png' : userinfo.sub + '.png';
+    const imageBuffer = await downloadImage(
+      imageUrl,
+      openidConfig,
+      tokenset.access_token,
+      userinfo.sub,
+    );
+    if (imageBuffer) {
+      const { saveBuffer } = getStrategyFunctions(
+        appConfig?.fileStrategy ?? process.env.CDN_PROVIDER,
+      );
+      const imagePath = await saveBuffer({
+        fileName,
+        userId: user._id.toString(),
+        buffer: imageBuffer,
+      });
+      user.avatar = imagePath ?? '';
+    }
+  }
+
+  user = await updateUser(user._id, user);
+
+  logger.info(
+    `[SolidOpenidStrategy] login success openidId: ${user.openidId} | email: ${user.email} | username: ${user.username}`,
+  );
+
+  return {
+    ...user,
+    provider: 'solid',
+    tokenset,
+    federatedTokens: {
+      access_token: tokenset.access_token,
+      refresh_token: tokenset.refresh_token,
+      expires_at: tokenset.expires_at,
+    },
+  };
+}
+
 /**
  * Sets up the OpenID strategy for authentication.
  * This function configures the OpenID client, handles proxy settings,
@@ -304,6 +489,13 @@ function convertToUsername(input, defaultValue = '') {
  * @returns {Promise<Configuration | null>} A promise that resolves when the OpenID strategy is set up and returns the openid client config object.
  * @throws {Error} If an error occurs during the setup process.
  */
+/**
+ * @deprecated Use SOLID_OPENID_PROVIDERS and setupSolidOpenIdFromProvider() instead. Not used in dynamic flow.
+ * Legacy single-issuer setup using SOLID_OPENID_ISSUER (no longer supported).
+ * @async
+ * @function setupSolidOpenId
+ * @returns {Promise<Configuration | null>}
+ */
 async function setupSolidOpenId() {
   try {
     const shouldGenerateNonce = isEnabled(process.env.OPENID_GENERATE_NONCE);
@@ -363,217 +555,13 @@ async function setupSolidOpenId() {
        */
       async (tokenset, done) => {
         try {
-          const claims = tokenset.claims();
-          const userinfo = {
-            ...claims,
-            ...(await getUserInfo(openidConfig, tokenset.access_token, claims.sub)),
-          };
-
-          const appConfig = await getAppConfig();
-          /** Azure AD sometimes doesn't return email, use preferred_username as fallback */
-          // TODO: jeswr - Potentially fetch an email from the user's WebID if they have a `foaf:mbox`
-          // TODO: jeswr - Can codebase support email or WebID rather than requiring email?
-          // TODO: jeswr - Suggest opening issues for these once we PR the changes upstream
-          const email =
-            userinfo.email ||
-            userinfo.preferred_username ||
-            userinfo.upn ||
-            `${userinfo.webid}@FAKEDOMAIN.TLD`;
-          if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {
-            logger.error(
-              `[SolidOpenidStrategy] Authentication blocked - email domain not allowed [Email: ${email}]`,
-            );
-            return done(null, false, { message: 'Email domain not allowed' });
-          }
-
-          const result = await findOpenIDUser({
-            findUser,
-            email: email,
-            openidId: claims.sub,
-            idOnTheSource: claims.oid,
-            strategyName: 'SolidOpenidStrategy',
-          });
-          let user = result.user;
-          const error = result.error;
-
-          if (error) {
-            return done(null, false, {
-              message: ErrorTypes.AUTH_FAILED,
-            });
-          }
-
-          const fullName = getFullName(userinfo);
-
-          if (requiredRole) {
-            const requiredRoles = requiredRole
-              .split(',')
-              .map((role) => role.trim())
-              .filter(Boolean);
-            let decodedToken = '';
-            if (requiredRoleTokenKind === 'access') {
-              decodedToken = jwtDecode(tokenset.access_token);
-            } else if (requiredRoleTokenKind === 'id') {
-              decodedToken = jwtDecode(tokenset.id_token);
-            }
-
-            let roles = get(decodedToken, requiredRoleParameterPath);
-            if (!roles || (!Array.isArray(roles) && typeof roles !== 'string')) {
-              logger.error(
-                `[SolidOpenidStrategy] Key '${requiredRoleParameterPath}' not found or invalid type in ${requiredRoleTokenKind} token!`,
-              );
-              const rolesList =
-                requiredRoles.length === 1
-                  ? `"${requiredRoles[0]}"`
-                  : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
-              return done(null, false, {
-                message: `You must have ${rolesList} role to log in.`,
-              });
-            }
-
-            if (!requiredRoles.some((role) => roles.includes(role))) {
-              const rolesList =
-                requiredRoles.length === 1
-                  ? `"${requiredRoles[0]}"`
-                  : `one of: ${requiredRoles.map((r) => `"${r}"`).join(', ')}`;
-              return done(null, false, {
-                message: `You must have ${rolesList} role to log in.`,
-              });
-            }
-          }
-
-          let username = '';
-          if (process.env.OPENID_USERNAME_CLAIM) {
-            username = userinfo[process.env.OPENID_USERNAME_CLAIM];
-          } else {
-            username = convertToUsername(
-              userinfo.preferred_username || userinfo.username || userinfo.email,
-            );
-          }
-
-          if (!user) {
-            user = {
-              provider: 'solid',
-              openidId: userinfo.sub,
-              username,
-              email: email || '',
-              emailVerified: userinfo.email_verified || false,
-              name: fullName,
-              idOnTheSource: userinfo.oid,
-            };
-
-            const balanceConfig = getBalanceConfig(appConfig);
-            user = await createUser(user, balanceConfig, true, true);
-          } else {
-            user.provider = 'solid';
-            user.openidId = userinfo.sub;
-            user.username = username;
-            user.name = fullName;
-            user.idOnTheSource = userinfo.oid;
-            if (email && email !== user.email) {
-              user.email = email;
-              user.emailVerified = userinfo.email_verified || false;
-            }
-          }
-
-          if (adminRole && adminRoleParameterPath && adminRoleTokenKind) {
-            let adminRoleObject;
-            switch (adminRoleTokenKind) {
-              case 'access':
-                adminRoleObject = jwtDecode(tokenset.access_token);
-                break;
-              case 'id':
-                adminRoleObject = jwtDecode(tokenset.id_token);
-                break;
-              case 'userinfo':
-                adminRoleObject = userinfo;
-                break;
-              default:
-                logger.error(
-                  `[SolidOpenidStrategy] Invalid admin role token kind: ${adminRoleTokenKind}. Must be one of 'access', 'id', or 'userinfo'.`,
-                );
-                return done(new Error('Invalid admin role token kind'));
-            }
-
-            const adminRoles = get(adminRoleObject, adminRoleParameterPath);
-
-            // Accept 3 types of values for the object extracted from adminRoleParameterPath:
-            // 1. A boolean value indicating if the user is an admin
-            // 2. A string with a single role name
-            // 3. An array of role names
-
-            if (
-              adminRoles &&
-              (adminRoles === true ||
-                adminRoles === adminRole ||
-                (Array.isArray(adminRoles) && adminRoles.includes(adminRole)))
-            ) {
-              user.role = 'ADMIN';
-              logger.info(
-                `[SolidOpenidStrategy] User ${username} is an admin based on role: ${adminRole}`,
-              );
-            } else if (user.role === 'ADMIN') {
-              user.role = 'USER';
-              logger.info(
-                `[SolidOpenidStrategy] User ${username} demoted from admin - role no longer present in token`,
-              );
-            }
-          }
-
-          if (!!userinfo && userinfo.picture && !user.avatar?.includes('manual=true')) {
-            /** @type {string | undefined} */
-            const imageUrl = userinfo.picture;
-
-            let fileName;
-            if (crypto) {
-              fileName = (await hashToken(userinfo.sub)) + '.png';
-            } else {
-              fileName = userinfo.sub + '.png';
-            }
-
-            const imageBuffer = await downloadImage(
-              imageUrl,
-              openidConfig,
-              tokenset.access_token,
-              userinfo.sub,
-            );
-            if (imageBuffer) {
-              const { saveBuffer } = getStrategyFunctions(
-                appConfig?.fileStrategy ?? process.env.CDN_PROVIDER,
-              );
-              const imagePath = await saveBuffer({
-                fileName,
-                userId: user._id.toString(),
-                buffer: imageBuffer,
-              });
-              user.avatar = imagePath ?? '';
-            }
-          }
-
-          user = await updateUser(user._id, user);
-
-          logger.info(
-            `[SolidOpenidStrategy] login success openidId: ${user.openidId} | email: ${user.email} | username: ${user.username} `,
-            {
-              user: {
-                openidId: user.openidId,
-                username: user.username,
-                email: user.email,
-                name: user.name,
-              },
-            },
-          );
-
-          done(null, {
-            ...user,
-            tokenset,
-            federatedTokens: {
-              access_token: tokenset.access_token,
-              refresh_token: tokenset.refresh_token,
-              expires_at: tokenset.expires_at,
-            },
-          });
+          const userObj = await verifySolidUser(tokenset, openidConfig);
+          done(null, userObj);
         } catch (err) {
           logger.error('[SolidOpenidStrategy] login failed', err);
+          if (err.code === 'AUTH_FAILED' || err.code === 'EMAIL_DOMAIN_NOT_ALLOWED') {
+            return done(null, false, { message: err.message });
+          }
           done(err);
         }
       },
@@ -585,6 +573,39 @@ async function setupSolidOpenId() {
     return null;
   }
 }
+
+/**
+ * Set OpenID config from a provider (e.g. first entry in SOLID_OPENID_PROVIDERS).
+ * Used when only dynamic providers are configured so getSolidOpenIdConfig() and solidJwt work.
+ * @param {{ issuer: string, clientId: string, clientSecret?: string }} provider
+ * @returns {Promise<Configuration | null>}
+ */
+async function setupSolidOpenIdFromProvider(provider) {
+  try {
+    const clientMetadata = {
+      client_id: provider.clientId,
+      client_secret: provider.clientSecret || undefined,
+    };
+    openidConfig = await client.discovery(
+      new URL(provider.issuer),
+      provider.clientId,
+      clientMetadata,
+      undefined,
+      {
+        [client.customFetch]: customFetch,
+        execute: [client.allowInsecureRequests],
+      },
+    );
+    logger.info('[SolidOpenidStrategy] OpenID config set from provider (for JWT/refresh)', {
+      issuer: provider.issuer,
+    });
+    return openidConfig;
+  } catch (err) {
+    logger.error('[SolidOpenidStrategy] setupSolidOpenIdFromProvider failed', err);
+    return null;
+  }
+}
+
 /**
  * @function getOpenIdConfig
  * @description Returns the OpenID client instance.
@@ -599,6 +620,7 @@ function getSolidOpenIdConfig() {
 }
 
 module.exports = {
-  setupSolidOpenId,
+  setupSolidOpenIdFromProvider,
   getSolidOpenIdConfig,
+  verifySolidUser,
 };
diff --git a/api/strategies/index.js b/api/strategies/index.js
index f666f15464d0..75948e74d18a 100644
--- a/api/strategies/index.js
+++ b/api/strategies/index.js
@@ -1,5 +1,9 @@
 const { setupOpenId, getOpenIdConfig, getOpenIdEmail } = require('./openidStrategy');
-const { setupSolidOpenId, getSolidOpenIdConfig } = require('./SolidOpenidStrategy');
+const {
+  setupSolidOpenIdFromProvider,
+  getSolidOpenIdConfig,
+  verifySolidUser,
+} = require('./SolidOpenidStrategy');
 const openIdJwtLogin = require('./openIdJwtStrategy');
 const facebookLogin = require('./facebookStrategy');
 const discordLogin = require('./discordStrategy');
@@ -19,11 +23,12 @@ module.exports = {
   discordLogin,
   jwtLogin,
   facebookLogin,
-  setupOpenId,
-  getOpenIdConfig,
   getOpenIdEmail,
-  setupSolidOpenId,
+  setupSolidOpenIdFromProvider,
   getSolidOpenIdConfig,
+  verifySolidUser,
+  setupOpenId,
+  getOpenIdConfig,
   ldapLogin,
   setupSaml,
   openIdJwtLogin,
diff --git a/api/strategies/openIdJwtStrategy.js b/api/strategies/openIdJwtStrategy.js
index 83a40bf9487c..131e2f92576f 100644
--- a/api/strategies/openIdJwtStrategy.js
+++ b/api/strategies/openIdJwtStrategy.js
@@ -25,6 +25,22 @@ const { updateUser, findUser } = require('~/models');
  *
  * This enables seamless migration for existing users when SharePoint integration is enabled.
  */
+/**
+ * JWT extractor: Authorization Bearer first, then cookie openid_id_token (for OpenID/Solid when header not yet set by frontend).
+ * @param {import('express').Request} req
+ * @returns {string | null}
+ */
+function jwtFromRequest(req) {
+  const fromHeader = ExtractJwt.fromAuthHeaderAsBearerToken()(req);
+  if (fromHeader) return fromHeader;
+  const cookieHeader = req.headers.cookie;
+  if (cookieHeader) {
+    const parsed = cookies.parse(cookieHeader);
+    if (parsed.openid_id_token) return parsed.openid_id_token;
+  }
+  return null;
+}
+
 const openIdJwtLogin = (openIdConfig) => {
   let jwksRsaOptions = {
     cache: isEnabled(process.env.OPENID_JWKS_URL_CACHE_ENABLED) || true,
@@ -38,7 +54,7 @@ const openIdJwtLogin = (openIdConfig) => {
 
   return new JwtStrategy(
     {
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      jwtFromRequest,
       secretOrKeyProvider: jwksRsa.passportJwtSecret(jwksRsaOptions),
       passReqToCallback: true,
     },
diff --git a/client/src/components/Auth/SocialLoginRender.tsx b/client/src/components/Auth/SocialLoginRender.tsx
index 3e45785a7d21..34a873d33d93 100644
--- a/client/src/components/Auth/SocialLoginRender.tsx
+++ b/client/src/components/Auth/SocialLoginRender.tsx
@@ -10,6 +10,7 @@ import {
 } from '@librechat/client';
 
 import SocialButton from './SocialButton';
+import SolidLoginButton from './SolidLoginButton';
 
 import { useLocalize, TranslationKeys } from '~/hooks';
 
@@ -100,11 +101,10 @@ function SocialLoginRender({
       />
     ),
     solid: startupConfig.solidLoginEnabled && (
-      <SocialButton
+      <SolidLoginButton
         key="solid"
-        enabled={startupConfig.solidLoginEnabled}
-        serverDomain={startupConfig.serverDomain}
-        oauthPath="openid"
+        startupConfig={startupConfig}
+        label={startupConfig.solidLabel}
         Icon={() =>
           startupConfig.solidImageUrl ? (
             <img src={startupConfig.solidImageUrl} alt="Solid Logo" className="h-5 w-5" />
@@ -112,8 +112,6 @@ function SocialLoginRender({
             <SolidIcon />
           )
         }
-        label={startupConfig.solidLabel}
-        id="solid"
       />
     ),
     saml: startupConfig.samlLoginEnabled && (
diff --git a/client/src/components/Auth/SolidLoginButton.tsx b/client/src/components/Auth/SolidLoginButton.tsx
new file mode 100644
index 000000000000..af76ab62c28e
--- /dev/null
+++ b/client/src/components/Auth/SolidLoginButton.tsx
@@ -0,0 +1,160 @@
+import { useState } from 'react';
+import {
+  OGDialog,
+  OGDialogTrigger,
+  OGDialogContent,
+  OGDialogHeader,
+  OGDialogTitle,
+  OGDialogDescription,
+  OGDialogFooter,
+  OGDialogClose,
+  Button,
+} from '@librechat/client';
+import type { TStartupConfig } from 'librechat-data-provider';
+
+const CUSTOM_VALUE = '__custom__';
+
+type SolidLoginButtonProps = {
+  startupConfig: TStartupConfig;
+  label: string;
+  Icon: React.ComponentType | (() => React.ReactNode);
+};
+
+function isValidIssuerUrl(url: string): boolean {
+  const t = url.trim();
+  if (!t) return false;
+  try {
+    const u = new URL(t.startsWith('http') ? t : `https://${t}`);
+    return u.protocol === 'https:' || u.protocol === 'http:';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Solid login button that opens an IdP selection modal (3 default options + optional custom URL),
+ * then redirects to serverDomain + '/oauth/openid?issuer=' + encodeURIComponent(selectedIssuer)
+ */
+function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps) {
+  const [open, setOpen] = useState(false);
+  const [selectedIssuer, setSelectedIssuer] = useState<string | null>(null);
+  const [customUrl, setCustomUrl] = useState('');
+
+  const options = startupConfig.solidIdpOptions ?? [];
+  const customEnabled = startupConfig.solidCustomEnabled === true;
+  const serverDomain = startupConfig.serverDomain || '';
+
+  const isCustomSelected = selectedIssuer === CUSTOM_VALUE;
+  const effectiveIssuer = isCustomSelected ? customUrl.trim() : selectedIssuer;
+  const canContinue =
+    serverDomain &&
+    (isCustomSelected ? isValidIssuerUrl(customUrl) : !!selectedIssuer && selectedIssuer !== CUSTOM_VALUE);
+
+  const handleContinue = () => {
+    if (!canContinue || !effectiveIssuer) return;
+    const url = `${serverDomain}/oauth/openid?issuer=${encodeURIComponent(effectiveIssuer)}`;
+    window.location.href = url;
+  };
+
+  const handleOpenChange = (next: boolean) => {
+    setOpen(next);
+    if (!next) {
+      setSelectedIssuer(null);
+      setCustomUrl('');
+    }
+  };
+
+  if (!startupConfig.solidLoginEnabled) {
+    return null;
+  }
+
+  return (
+    <div className="mt-2 flex gap-x-2">
+      <OGDialog open={open} onOpenChange={handleOpenChange}>
+        <OGDialogTrigger asChild>
+          <button
+            type="button"
+            aria-label={label}
+            className="flex w-full items-center space-x-3 rounded-2xl border border-border-light bg-surface-primary px-5 py-3 text-text-primary transition-colors duration-200 hover:bg-surface-tertiary"
+            data-testid="solid"
+          >
+            <Icon />
+            <p>{label}</p>
+          </button>
+        </OGDialogTrigger>
+        <OGDialogContent className="max-w-md">
+          <OGDialogHeader>
+            <OGDialogTitle>Choose Solid Identity Provider</OGDialogTitle>
+            <OGDialogDescription>
+              Select a provider or enter your own Solid OIDC provider URL.
+            </OGDialogDescription>
+          </OGDialogHeader>
+          <div className="py-4 space-y-3">
+            <ul className="space-y-2">
+              {options.map((opt) => (
+                <li key={opt.issuer}>
+                  <label className="flex cursor-pointer items-center gap-3 rounded-lg border border-border-light p-3 transition-colors hover:bg-surface-secondary has-[:checked]:border-green-500 has-[:checked]:bg-surface-secondary dark:has-[:checked]:border-green-500">
+                    <input
+                      type="radio"
+                      name="solid-issuer"
+                      value={opt.issuer}
+                      checked={selectedIssuer === opt.issuer}
+                      onChange={() => setSelectedIssuer(opt.issuer)}
+                      className="h-4 w-4 border-gray-300 text-green-600 focus:ring-green-500"
+                    />
+                    <span className="font-medium text-text-primary">{opt.label}</span>
+                    {opt.issuer !== opt.label && (
+                      <span
+                        className="max-w-[180px] truncate text-xs text-gray-500 dark:text-gray-400"
+                        title={opt.issuer}
+                      >
+                        {opt.issuer}
+                      </span>
+                    )}
+                  </label>
+                </li>
+              ))}
+            </ul>
+
+            {customEnabled && (
+              <>
+                <label className="flex cursor-pointer items-start gap-3 rounded-lg border border-border-light p-3 transition-colors hover:bg-surface-secondary has-[:checked]:border-green-500 has-[:checked]:bg-surface-secondary dark:has-[:checked]:border-green-500">
+                  <input
+                    type="radio"
+                    name="solid-issuer"
+                    value={CUSTOM_VALUE}
+                    checked={isCustomSelected}
+                    onChange={() => setSelectedIssuer(CUSTOM_VALUE)}
+                    className="mt-1 h-4 w-4 border-gray-300 text-green-600 focus:ring-green-500"
+                  />
+                  <div className="flex-1 min-w-0">
+                    <span className="font-medium text-text-primary block mb-1">Custom provider</span>
+                    <input
+                      type="url"
+                      placeholder="https://your-pod.example.com/"
+                      value={customUrl}
+                      onChange={(e) => setCustomUrl(e.target.value)}
+                      onFocus={() => setSelectedIssuer(CUSTOM_VALUE)}
+                      className="w-full rounded border border-border-light bg-surface-primary px-3 py-2 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 dark:bg-surface-secondary"
+                      data-testid="solid-custom-url"
+                    />
+                  </div>
+                </label>
+              </>
+            )}
+          </div>
+          <OGDialogFooter>
+            <OGDialogClose asChild>
+              <Button variant="outline">Cancel</Button>
+            </OGDialogClose>
+            <Button onClick={handleContinue} disabled={!canContinue}>
+              Continue
+            </Button>
+          </OGDialogFooter>
+        </OGDialogContent>
+      </OGDialog>
+    </div>
+  );
+}
+
+export default SolidLoginButton;
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index 5a0b0fd3367d..11cc2d04bd52 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -770,6 +770,10 @@ export type TStartupConfig = {
   solidLabel: string;
   solidImageUrl: string;
   solidAutoRedirect: boolean;
+  /** Solid IdP options for the selection modal (issuer URL + display label). Includes the 3 defaults (Local CSS, Solid Community, Inrupt) plus any from config. */
+  solidIdpOptions?: Array<{ issuer: string; label: string }>;
+  /** When true, user can enter a custom Solid OIDC provider URL in the modal. */
+  solidCustomEnabled?: boolean;
   samlLabel: string;
   samlImageUrl: string;
   /** LDAP Auth Configuration */

From 92d10222d3427c99f21db8f6e1a73a8dc64e1dd5 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 15:18:46 +0000
Subject: [PATCH 84/94] =?UTF-8?q?feat(auth):=20Solid=20IdP=20modal=20?=
 =?UTF-8?q?=E2=80=93=20URL=20input=20+=20provider=20pills?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace radio list with a single "Solid Identity Provider" input and
"Or select a provider" pill buttons. Pills fill the input
---
 .../src/components/Auth/SolidLoginButton.tsx  | 127 +++++++++---------
 1 file changed, 64 insertions(+), 63 deletions(-)

diff --git a/client/src/components/Auth/SolidLoginButton.tsx b/client/src/components/Auth/SolidLoginButton.tsx
index af76ab62c28e..4fd73e3c4b15 100644
--- a/client/src/components/Auth/SolidLoginButton.tsx
+++ b/client/src/components/Auth/SolidLoginButton.tsx
@@ -12,8 +12,6 @@ import {
 } from '@librechat/client';
 import type { TStartupConfig } from 'librechat-data-provider';
 
-const CUSTOM_VALUE = '__custom__';
-
 type SolidLoginButtonProps = {
   startupConfig: TStartupConfig;
   label: string;
@@ -32,23 +30,29 @@ function isValidIssuerUrl(url: string): boolean {
 }
 
 /**
- * Solid login button that opens an IdP selection modal (3 default options + optional custom URL),
- * then redirects to serverDomain + '/oauth/openid?issuer=' + encodeURIComponent(selectedIssuer)
+ * Solid login button that opens an IdP selection modal: URL input + optional provider pills.
+ * Redirects to serverDomain + '/oauth/openid?issuer=' + encodeURIComponent(selectedIssuer)
  */
 function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps) {
   const [open, setOpen] = useState(false);
-  const [selectedIssuer, setSelectedIssuer] = useState<string | null>(null);
-  const [customUrl, setCustomUrl] = useState('');
+  const [providerUrl, setProviderUrl] = useState('');
+  const [selectedOptionIssuer, setSelectedOptionIssuer] = useState<string | null>(null);
 
   const options = startupConfig.solidIdpOptions ?? [];
   const customEnabled = startupConfig.solidCustomEnabled === true;
   const serverDomain = startupConfig.serverDomain || '';
 
-  const isCustomSelected = selectedIssuer === CUSTOM_VALUE;
-  const effectiveIssuer = isCustomSelected ? customUrl.trim() : selectedIssuer;
+  const trimmedUrl = providerUrl.trim();
+  const effectiveIssuer = trimmedUrl;
   const canContinue =
     serverDomain &&
-    (isCustomSelected ? isValidIssuerUrl(customUrl) : !!selectedIssuer && selectedIssuer !== CUSTOM_VALUE);
+    !!trimmedUrl &&
+    (customEnabled ? isValidIssuerUrl(trimmedUrl) : options.some((opt) => opt.issuer === trimmedUrl));
+
+  const handleSelectOption = (issuer: string) => {
+    setSelectedOptionIssuer(issuer);
+    setProviderUrl(issuer);
+  };
 
   const handleContinue = () => {
     if (!canContinue || !effectiveIssuer) return;
@@ -59,8 +63,8 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
   const handleOpenChange = (next: boolean) => {
     setOpen(next);
     if (!next) {
-      setSelectedIssuer(null);
-      setCustomUrl('');
+      setProviderUrl('');
+      setSelectedOptionIssuer(null);
     }
   };
 
@@ -86,61 +90,58 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
           <OGDialogHeader>
             <OGDialogTitle>Choose Solid Identity Provider</OGDialogTitle>
             <OGDialogDescription>
-              Select a provider or enter your own Solid OIDC provider URL.
+              Enter your provider URL or pick one of the providers below.
             </OGDialogDescription>
           </OGDialogHeader>
-          <div className="py-4 space-y-3">
-            <ul className="space-y-2">
-              {options.map((opt) => (
-                <li key={opt.issuer}>
-                  <label className="flex cursor-pointer items-center gap-3 rounded-lg border border-border-light p-3 transition-colors hover:bg-surface-secondary has-[:checked]:border-green-500 has-[:checked]:bg-surface-secondary dark:has-[:checked]:border-green-500">
-                    <input
-                      type="radio"
-                      name="solid-issuer"
-                      value={opt.issuer}
-                      checked={selectedIssuer === opt.issuer}
-                      onChange={() => setSelectedIssuer(opt.issuer)}
-                      className="h-4 w-4 border-gray-300 text-green-600 focus:ring-green-500"
-                    />
-                    <span className="font-medium text-text-primary">{opt.label}</span>
-                    {opt.issuer !== opt.label && (
-                      <span
-                        className="max-w-[180px] truncate text-xs text-gray-500 dark:text-gray-400"
-                        title={opt.issuer}
-                      >
-                        {opt.issuer}
-                      </span>
-                    )}
-                  </label>
-                </li>
-              ))}
-            </ul>
+          <div className="space-y-4 py-4">
+            <div className="space-y-2">
+              <label
+                htmlFor="solid-idp-url"
+                className="text-sm font-medium text-text-primary"
+              >
+                Solid Identity Provider
+              </label>
+              <input
+                id="solid-idp-url"
+                type="url"
+                placeholder="Enter your provider URL"
+                value={providerUrl}
+                onChange={(e) => {
+                  setProviderUrl(e.target.value);
+                  if (selectedOptionIssuer && e.target.value.trim() !== selectedOptionIssuer) {
+                    setSelectedOptionIssuer(null);
+                  }
+                }}
+                className="w-full rounded-lg border border-border-light bg-surface-primary px-3 py-2.5 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 dark:placeholder:text-gray-400 dark:bg-surface-secondary"
+                data-testid="solid-custom-url"
+              />
+            </div>
 
-            {customEnabled && (
-              <>
-                <label className="flex cursor-pointer items-start gap-3 rounded-lg border border-border-light p-3 transition-colors hover:bg-surface-secondary has-[:checked]:border-green-500 has-[:checked]:bg-surface-secondary dark:has-[:checked]:border-green-500">
-                  <input
-                    type="radio"
-                    name="solid-issuer"
-                    value={CUSTOM_VALUE}
-                    checked={isCustomSelected}
-                    onChange={() => setSelectedIssuer(CUSTOM_VALUE)}
-                    className="mt-1 h-4 w-4 border-gray-300 text-green-600 focus:ring-green-500"
-                  />
-                  <div className="flex-1 min-w-0">
-                    <span className="font-medium text-text-primary block mb-1">Custom provider</span>
-                    <input
-                      type="url"
-                      placeholder="https://your-pod.example.com/"
-                      value={customUrl}
-                      onChange={(e) => setCustomUrl(e.target.value)}
-                      onFocus={() => setSelectedIssuer(CUSTOM_VALUE)}
-                      className="w-full rounded border border-border-light bg-surface-primary px-3 py-2 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 dark:bg-surface-secondary"
-                      data-testid="solid-custom-url"
-                    />
-                  </div>
-                </label>
-              </>
+            {options.length > 0 && (
+              <div className="space-y-2">
+                <p className="text-sm font-medium text-text-secondary">
+                  Or select a provider:
+                </p>
+                <div className="flex flex-wrap gap-2">
+                  {options.map((opt) => {
+                    const isSelected = providerUrl.trim() === opt.issuer;
+                    return (
+                      <button
+                        key={opt.issuer}
+                        type="button"
+                        onClick={() => handleSelectOption(opt.issuer)}
+                        className={`rounded-full border px-4 py-2 text-sm font-medium transition-colors ${
+                          isSelected
+                            ? 'border-green-500 bg-surface-secondary text-text-primary'
+                            : 'border-border-light bg-surface-primary text-text-primary hover:bg-surface-tertiary'
+                        }`}
+                      >
+                        {opt.label}
+                      </button>
+                    );
+                  })}
+                </div>
+              </div>
             )}
           </div>
           <OGDialogFooter>

From 6551861462e419752bcc07597e436a5371a4a7a2 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 15:34:38 +0000
Subject: [PATCH 85/94] fix eslint error

---
 api/server/controllers/AuthController.js      | 13 ++++++-
 .../controllers/auth/solidOpenIdDynamic.js    | 38 ++++++++++---------
 api/server/index.js                           |  4 +-
 api/server/routes/config.js                   |  7 +---
 api/server/services/Config/solidOpenId.js     | 15 ++++----
 api/server/socialLogins.js                    | 16 ++++----
 api/strategies/SolidOpenidStrategy.js         | 14 +++----
 .../src/components/Auth/SolidLoginButton.tsx  | 28 ++++++++------
 client/src/locales/en/translation.json        |  5 +++
 9 files changed, 79 insertions(+), 61 deletions(-)

diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 6eb9bd1aa07b..c50f73471b81 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -74,7 +74,14 @@ const resetPasswordController = async (req, res) => {
  * @param {string} [tokenProvider] - 'solid' or 'openid' from cookie so setOpenIDAuthTokens sets the correct token_provider cookie
  * @returns {Promise<boolean>} True if response was sent, false if caller should continue to next handler
  */
-async function performOpenIDRefresh(req, res, openIdConfig, refreshToken, refreshParams = {}, tokenProvider) {
+async function performOpenIDRefresh(
+  req,
+  res,
+  openIdConfig,
+  refreshToken,
+  refreshParams = {},
+  tokenProvider,
+) {
   try {
     const tokenset = await openIdClient.refreshTokenGrant(
       openIdConfig,
@@ -199,7 +206,9 @@ const refreshController = async (req, res) => {
             try {
               return getOpenIdConfig();
             } catch (e) {
-              logger.warn('[refreshController] OpenID config not initialized', { message: e?.message });
+              logger.warn('[refreshController] OpenID config not initialized', {
+                message: e?.message,
+              });
               return null;
             }
           })();
diff --git a/api/server/controllers/auth/solidOpenIdDynamic.js b/api/server/controllers/auth/solidOpenIdDynamic.js
index a6316ef368b4..5e7971404f40 100644
--- a/api/server/controllers/auth/solidOpenIdDynamic.js
+++ b/api/server/controllers/auth/solidOpenIdDynamic.js
@@ -68,8 +68,14 @@ async function startSolidOpenIdFlow(req, res, next) {
 
   const provider = getSolidOpenIdProviderByIssuer(issuer.trim());
   if (!provider) {
-    logger.warn('[solidOpenIdDynamic] Unknown or unconfigured issuer', { issuer: issuer.slice(0, 80) });
-    res.status(400).send('Unknown or unconfigured Solid Identity Provider. Use one of the options from the login page.');
+    logger.warn('[solidOpenIdDynamic] Unknown or unconfigured issuer', {
+      issuer: issuer.slice(0, 80),
+    });
+    res
+      .status(400)
+      .send(
+        'Unknown or unconfigured Solid Identity Provider. Use one of the options from the login page.',
+      );
     return;
   }
 
@@ -151,10 +157,13 @@ async function handleSolidOpenIdCallback(req, res, next) {
   if (!code) {
     const errParam = req.query.error;
     const errDesc = req.query.error_description;
-    logger.warn('[solidOpenIdDynamic] Callback missing code - IdP likely rejected the auth request', {
-      error: errParam,
-      error_description: errDesc,
-    });
+    logger.warn(
+      '[solidOpenIdDynamic] Callback missing code - IdP likely rejected the auth request',
+      {
+        error: errParam,
+        error_description: errDesc,
+      },
+    );
     res.redirect(`${process.env.DOMAIN_CLIENT}/login?redirect=false&error=auth_failed`);
     return;
   }
@@ -190,19 +199,12 @@ async function handleSolidOpenIdCallback(req, res, next) {
       discoveryOptions,
     );
 
-    const currentUrl = new URL(
-      req.originalUrl || req.url,
-      process.env.DOMAIN_SERVER,
-    );
+    const currentUrl = new URL(req.originalUrl || req.url, process.env.DOMAIN_SERVER);
 
-    const tokenset = await client.authorizationCodeGrant(
-      config,
-      currentUrl,
-      {
-        expectedState: state,
-        ...(sessionData.code_verifier && { pkceCodeVerifier: sessionData.code_verifier }),
-      },
-    );
+    const tokenset = await client.authorizationCodeGrant(config, currentUrl, {
+      expectedState: state,
+      ...(sessionData.code_verifier && { pkceCodeVerifier: sessionData.code_verifier }),
+    });
 
     delete req.session[SESSION_KEY][state];
     req.session.save(() => {});
diff --git a/api/server/index.js b/api/server/index.js
index 5ac8dec46a4f..6e50d3179280 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -170,7 +170,9 @@ const startServer = async () => {
   // Local CSS (and other Solid IdPs) fetch this URL to get redirect_uris; they must match the redirect_uri we send in the auth request.
   app.get('/solid-client-id', (_, res) => {
     const callbackPath =
-      process.env.SOLID_OPENID_CALLBACK_URL || process.env.OPENID_CALLBACK_URL || '/oauth/openid/callback';
+      process.env.SOLID_OPENID_CALLBACK_URL ||
+      process.env.OPENID_CALLBACK_URL ||
+      '/oauth/openid/callback';
     const baseUrl = process.env.DOMAIN_SERVER || 'http://localhost:3080';
     const clientId = `${baseUrl}/solid-client-id`;
     res.set('Content-Type', 'application/ld+json');
diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index e1fa61fcc8c7..8ef4a16a807c 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -96,12 +96,7 @@ router.get('/', async function (req, res) {
         ? [
             ...DEFAULT_ISSUER_OPTIONS,
             ...getSolidOpenIdProviders()
-              .filter(
-                (p) =>
-                  !DEFAULT_ISSUER_OPTIONS.some(
-                    (d) => normalizeIssuer(d.issuer) === p.issuer,
-                  ),
-              )
+              .filter((p) => !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer))
               .map((p) => ({ issuer: p.issuer, label: p.label })),
           ]
         : [],
diff --git a/api/server/services/Config/solidOpenId.js b/api/server/services/Config/solidOpenId.js
index 6104d43fe370..57c39c412bee 100644
--- a/api/server/services/Config/solidOpenId.js
+++ b/api/server/services/Config/solidOpenId.js
@@ -4,8 +4,7 @@
  */
 
 const defaultScope = process.env.SOLID_OPENID_SCOPE || 'openid webid offline_access';
-const defaultCallbackPath =
-  process.env.SOLID_OPENID_CALLBACK_URL || '/oauth/openid/callback';
+const defaultCallbackPath = process.env.SOLID_OPENID_CALLBACK_URL || '/oauth/openid/callback';
 
 /**
  * Default display labels for known issuers (used when provider config has no label).
@@ -88,7 +87,7 @@ function getSolidOpenIdProviders() {
           callbackPath: (p.callbackPath && String(p.callbackPath).trim()) || defaultCallbackPath,
         });
       }
-    } catch (e) {
+    } catch (_e) {
       // Invalid JSON
     }
   }
@@ -154,16 +153,16 @@ function getSolidOpenIdProviderByIssuer(issuer) {
   if (configured) return configured;
 
   // Custom issuer: use SOLID_OPENID_CUSTOM_* if set and URL is allowed
-  if (
-    process.env.SOLID_OPENID_CUSTOM_CLIENT_ID &&
-    isAllowedCustomIssuer(normalized)
-  ) {
+  if (process.env.SOLID_OPENID_CUSTOM_CLIENT_ID && isAllowedCustomIssuer(normalized)) {
     return {
       issuer: normalized,
       clientId: process.env.SOLID_OPENID_CUSTOM_CLIENT_ID,
       clientSecret: process.env.SOLID_OPENID_CUSTOM_CLIENT_SECRET || '',
       scope: process.env.SOLID_OPENID_CUSTOM_SCOPE || defaultScope,
-      label: KNOWN_ISSUER_LABELS[normalized] || KNOWN_ISSUER_LABELS[normalized.replace(/\/$/, '')] || 'Custom',
+      label:
+        KNOWN_ISSUER_LABELS[normalized] ||
+        KNOWN_ISSUER_LABELS[normalized.replace(/\/$/, '')] ||
+        'Custom',
       callbackPath: defaultCallbackPath,
     };
   }
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index 222e173f250d..081671af37ac 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -15,7 +15,11 @@ const {
   setupSaml,
 } = require('~/strategies');
 const { getLogStores } = require('~/cache');
-const { getSolidOpenIdProviders, getSolidOpenIdProvidersForJwt, isSolidOpenIdEnabled } = require('./services/Config/solidOpenId');
+const {
+  getSolidOpenIdProviders,
+  getSolidOpenIdProvidersForJwt,
+  isSolidOpenIdEnabled,
+} = require('./services/Config/solidOpenId');
 const { ensureSolidJwtRegistered } = require('./services/ensureSolidJwt');
 
 /**
@@ -74,7 +78,9 @@ async function configureSolidOpenIdFromProviders(app) {
 
   const config = await setupSolidOpenIdFromProvider(providers[0]);
   if (!config) {
-    logger.warn('[configureSolidOpenIdFromProviders] Discovery for first provider failed - solidJwt not registered.');
+    logger.warn(
+      '[configureSolidOpenIdFromProviders] Discovery for first provider failed - solidJwt not registered.',
+    );
     return;
   }
   passport.use('solidJwt', openIdJwtLogin(config));
@@ -142,11 +148,7 @@ const configureSocialLogins = async (app) => {
   }
   // Solid: dynamic providers only (SOLID_OPENID_PROVIDERS or SOLID_OPENID_CUSTOM_CLIENT_ID). Session + solidJwt from first provider.
   const solidProvidersForJwt = getSolidOpenIdProvidersForJwt();
-  const solidProvidersFromEnv = getSolidOpenIdProviders();
-  if (
-    process.env.SOLID_OPENID_SESSION_SECRET &&
-    solidProvidersForJwt.length > 0
-  ) {
+  if (process.env.SOLID_OPENID_SESSION_SECRET && solidProvidersForJwt.length > 0) {
     await configureSolidOpenIdFromProviders(app);
   } else if (solidProvidersForJwt.length > 0) {
     await registerSolidJwtFromProviders();
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index 9ea545635753..dd1f9b1a15ae 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -496,7 +496,7 @@ async function verifySolidUser(tokenset, openidConfig) {
  * @function setupSolidOpenId
  * @returns {Promise<Configuration | null>}
  */
-async function setupSolidOpenId() {
+async function _setupSolidOpenId() {
   try {
     const shouldGenerateNonce = isEnabled(process.env.OPENID_GENERATE_NONCE);
 
@@ -524,9 +524,9 @@ async function setupSolidOpenId() {
       },
     );
 
-    const requiredRole = process.env.OPENID_REQUIRED_ROLE;
-    const requiredRoleParameterPath = process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH;
-    const requiredRoleTokenKind = process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND;
+    const _requiredRole = process.env.OPENID_REQUIRED_ROLE;
+    const _requiredRoleParameterPath = process.env.OPENID_REQUIRED_ROLE_PARAMETER_PATH;
+    const _requiredRoleTokenKind = process.env.OPENID_REQUIRED_ROLE_TOKEN_KIND;
     const usePKCE = isEnabled(process.env.OPENID_USE_PKCE);
     logger.info(`[SolidOpenidStrategy] OpenID authentication configuration`, {
       generateNonce: shouldGenerateNonce,
@@ -537,9 +537,9 @@ async function setupSolidOpenId() {
 
     // Set of env variables that specify how to set if a user is an admin
     // If not set, all users will be treated as regular users
-    const adminRole = process.env.OPENID_ADMIN_ROLE;
-    const adminRoleParameterPath = process.env.OPENID_ADMIN_ROLE_PARAMETER_PATH;
-    const adminRoleTokenKind = process.env.OPENID_ADMIN_ROLE_TOKEN_KIND;
+    const _adminRole = process.env.OPENID_ADMIN_ROLE;
+    const _adminRoleParameterPath = process.env.OPENID_ADMIN_ROLE_PARAMETER_PATH;
+    const _adminRoleTokenKind = process.env.OPENID_ADMIN_ROLE_TOKEN_KIND;
 
     const openidLogin = new CustomOpenIDStrategy(
       {
diff --git a/client/src/components/Auth/SolidLoginButton.tsx b/client/src/components/Auth/SolidLoginButton.tsx
index 4fd73e3c4b15..f3c97ef540f4 100644
--- a/client/src/components/Auth/SolidLoginButton.tsx
+++ b/client/src/components/Auth/SolidLoginButton.tsx
@@ -12,6 +12,8 @@ import {
 } from '@librechat/client';
 import type { TStartupConfig } from 'librechat-data-provider';
 
+import { useLocalize, TranslationKeys } from '~/hooks';
+
 type SolidLoginButtonProps = {
   startupConfig: TStartupConfig;
   label: string;
@@ -34,6 +36,7 @@ function isValidIssuerUrl(url: string): boolean {
  * Redirects to serverDomain + '/oauth/openid?issuer=' + encodeURIComponent(selectedIssuer)
  */
 function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps) {
+  const localize = useLocalize();
   const [open, setOpen] = useState(false);
   const [providerUrl, setProviderUrl] = useState('');
   const [selectedOptionIssuer, setSelectedOptionIssuer] = useState<string | null>(null);
@@ -47,7 +50,9 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
   const canContinue =
     serverDomain &&
     !!trimmedUrl &&
-    (customEnabled ? isValidIssuerUrl(trimmedUrl) : options.some((opt) => opt.issuer === trimmedUrl));
+    (customEnabled
+      ? isValidIssuerUrl(trimmedUrl)
+      : options.some((opt) => opt.issuer === trimmedUrl));
 
   const handleSelectOption = (issuer: string) => {
     setSelectedOptionIssuer(issuer);
@@ -88,23 +93,22 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
         </OGDialogTrigger>
         <OGDialogContent className="max-w-md">
           <OGDialogHeader>
-            <OGDialogTitle>Choose Solid Identity Provider</OGDialogTitle>
+            <OGDialogTitle>
+              {localize('com_auth_solid_idp_modal_title' as TranslationKeys)}
+            </OGDialogTitle>
             <OGDialogDescription>
-              Enter your provider URL or pick one of the providers below.
+              {localize('com_auth_solid_idp_modal_description' as TranslationKeys)}
             </OGDialogDescription>
           </OGDialogHeader>
           <div className="space-y-4 py-4">
             <div className="space-y-2">
-              <label
-                htmlFor="solid-idp-url"
-                className="text-sm font-medium text-text-primary"
-              >
-                Solid Identity Provider
+              <label htmlFor="solid-idp-url" className="text-sm font-medium text-text-primary">
+                {localize('com_auth_solid_idp_label' as TranslationKeys)}
               </label>
               <input
                 id="solid-idp-url"
                 type="url"
-                placeholder="Enter your provider URL"
+                placeholder={localize('com_auth_solid_idp_placeholder' as TranslationKeys)}
                 value={providerUrl}
                 onChange={(e) => {
                   setProviderUrl(e.target.value);
@@ -120,7 +124,7 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
             {options.length > 0 && (
               <div className="space-y-2">
                 <p className="text-sm font-medium text-text-secondary">
-                  Or select a provider:
+                  {localize('com_auth_solid_select_provider' as TranslationKeys)}
                 </p>
                 <div className="flex flex-wrap gap-2">
                   {options.map((opt) => {
@@ -146,10 +150,10 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
           </div>
           <OGDialogFooter>
             <OGDialogClose asChild>
-              <Button variant="outline">Cancel</Button>
+              <Button variant="outline">{localize('com_ui_cancel' as TranslationKeys)}</Button>
             </OGDialogClose>
             <Button onClick={handleContinue} disabled={!canContinue}>
-              Continue
+              {localize('com_auth_continue' as TranslationKeys)}
             </Button>
           </OGDialogFooter>
         </OGDialogContent>
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index b7aa7b4ac2d9..ef69077486ae 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -152,6 +152,11 @@
   "com_auth_click": "Click",
   "com_auth_click_here": "Click here",
   "com_auth_continue": "Continue",
+  "com_auth_solid_idp_modal_description": "Enter your provider URL or pick one of the providers below.",
+  "com_auth_solid_idp_modal_title": "Choose Solid Identity Provider",
+  "com_auth_solid_idp_placeholder": "Enter your provider URL",
+  "com_auth_solid_idp_label": "Solid Identity Provider",
+  "com_auth_solid_select_provider": "Or select a provider:",
   "com_auth_create_account": "Create your account",
   "com_auth_discord_login": "Continue with Discord",
   "com_auth_email": "Email",

From 2a18119aa02623d315da60194ef2f53605d00462 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 15:52:20 +0000
Subject: [PATCH 86/94] fix eslint error

---
 api/server/routes/config.js                     | 4 +++-
 api/server/socialLogins.js                      | 1 -
 client/src/components/Auth/SolidLoginButton.tsx | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 8ef4a16a807c..6debe1ea1c4f 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -96,7 +96,9 @@ router.get('/', async function (req, res) {
         ? [
             ...DEFAULT_ISSUER_OPTIONS,
             ...getSolidOpenIdProviders()
-              .filter((p) => !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer))
+              .filter((p) =>
+                !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer),
+              )
               .map((p) => ({ issuer: p.issuer, label: p.label })),
           ]
         : [],
diff --git a/api/server/socialLogins.js b/api/server/socialLogins.js
index 081671af37ac..aca9c08f0cec 100644
--- a/api/server/socialLogins.js
+++ b/api/server/socialLogins.js
@@ -16,7 +16,6 @@ const {
 } = require('~/strategies');
 const { getLogStores } = require('~/cache');
 const {
-  getSolidOpenIdProviders,
   getSolidOpenIdProvidersForJwt,
   isSolidOpenIdEnabled,
 } = require('./services/Config/solidOpenId');
diff --git a/client/src/components/Auth/SolidLoginButton.tsx b/client/src/components/Auth/SolidLoginButton.tsx
index f3c97ef540f4..0bff1f1b595b 100644
--- a/client/src/components/Auth/SolidLoginButton.tsx
+++ b/client/src/components/Auth/SolidLoginButton.tsx
@@ -116,7 +116,7 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
                     setSelectedOptionIssuer(null);
                   }
                 }}
-                className="w-full rounded-lg border border-border-light bg-surface-primary px-3 py-2.5 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 dark:placeholder:text-gray-400 dark:bg-surface-secondary"
+                className="w-full rounded-lg border border-border-light bg-surface-primary px-3 py-2.5 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 bg-surface-secondary dark:placeholder:text-gray-400"
                 data-testid="solid-custom-url"
               />
             </div>

From 6d588040b16b54e5a3e6210362f3465ffad8cbf2 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 15:57:48 +0000
Subject: [PATCH 87/94] fixing eslint error

---
 api/server/routes/config.js                     | 4 +---
 client/src/components/Auth/SolidLoginButton.tsx | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 6debe1ea1c4f..8ef4a16a807c 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -96,9 +96,7 @@ router.get('/', async function (req, res) {
         ? [
             ...DEFAULT_ISSUER_OPTIONS,
             ...getSolidOpenIdProviders()
-              .filter((p) =>
-                !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer),
-              )
+              .filter((p) => !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer))
               .map((p) => ({ issuer: p.issuer, label: p.label })),
           ]
         : [],
diff --git a/client/src/components/Auth/SolidLoginButton.tsx b/client/src/components/Auth/SolidLoginButton.tsx
index 0bff1f1b595b..30bd458c381d 100644
--- a/client/src/components/Auth/SolidLoginButton.tsx
+++ b/client/src/components/Auth/SolidLoginButton.tsx
@@ -116,7 +116,7 @@ function SolidLoginButton({ startupConfig, label, Icon }: SolidLoginButtonProps)
                     setSelectedOptionIssuer(null);
                   }
                 }}
-                className="w-full rounded-lg border border-border-light bg-surface-primary px-3 py-2.5 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 bg-surface-secondary dark:placeholder:text-gray-400"
+                className="w-full rounded-lg border border-border-light bg-surface-primary bg-surface-secondary px-3 py-2.5 text-sm text-text-primary placeholder:text-gray-500 focus:border-green-500 focus:outline-none focus:ring-1 focus:ring-green-500 dark:placeholder:text-gray-400"
                 data-testid="solid-custom-url"
               />
             </div>

From c7c5d03d02cc13d3c5c323996d1580d6009eb478 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 16:05:28 +0000
Subject: [PATCH 88/94] fixing eslint error

---
 api/server/routes/config.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 8ef4a16a807c..6debe1ea1c4f 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -96,7 +96,9 @@ router.get('/', async function (req, res) {
         ? [
             ...DEFAULT_ISSUER_OPTIONS,
             ...getSolidOpenIdProviders()
-              .filter((p) => !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer))
+              .filter((p) =>
+                !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer),
+              )
               .map((p) => ({ issuer: p.issuer, label: p.label })),
           ]
         : [],

From 74a4044f309850f88e238f5297d8d203fa44f5de Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Fri, 27 Feb 2026 16:19:37 +0000
Subject: [PATCH 89/94] fixing lint error

---
 api/server/routes/config.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/api/server/routes/config.js b/api/server/routes/config.js
index 6debe1ea1c4f..aaa0a0b18143 100644
--- a/api/server/routes/config.js
+++ b/api/server/routes/config.js
@@ -96,8 +96,8 @@ router.get('/', async function (req, res) {
         ? [
             ...DEFAULT_ISSUER_OPTIONS,
             ...getSolidOpenIdProviders()
-              .filter((p) =>
-                !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer),
+              .filter(
+                (p) => !DEFAULT_ISSUER_OPTIONS.some((d) => normalizeIssuer(d.issuer) === p.issuer),
               )
               .map((p) => ({ issuer: p.issuer, label: p.label })),
           ]

From c1851d70ad51120fad1088e10384113f5e762ed6 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Mar 2026 11:04:43 +0000
Subject: [PATCH 90/94] feat(solid): get email and name from WebID profile card
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fetch the user's Solid profile document (Turtle) after login and extract
email (vcard:hasEmail → vcard:value mailto:) and name (vcard:fn or
foaf:name).
---
 SOLID_INTEGRATION_PROGRESS.md         |  12 ++-
 api/strategies/SolidOpenidStrategy.js | 127 ++++++++++++++++++++++++++
 2 files changed, 138 insertions(+), 1 deletion(-)

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
index 35886c418c35..9b2667568649 100644
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ b/SOLID_INTEGRATION_PROGRESS.md
@@ -157,6 +157,14 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
   - **solidcommunity.net**: The IdP dereferences the client_id URL; a localhost client_id is not reachable. Use a public URL for production.
   - **SOLID_OPENID_SCOPE**: Use `"openid webid offline_access"` for refresh token support when the IdP supports it.
 
+### 17. Solid Profile (WebID Card) Email and Name
+- **Status**: Complete
+- **Details**:
+  - **Profile fetch**: After Solid login, when `userinfo.webid` and an access token is available, we fetch the user's WebID profile document (Turtle) from the profile URL derived from the WebID (strip fragment, e.g. `https://pod.example.com/profile/card#me` → `https://pod.example.com/profile/card`). Request uses `Authorization: Bearer` and `Accept: text/turtle` with a 5s timeout; PROXY is respected.
+  - **Email and name extraction**: We parse the Turtle with **n3** (no regex). Email is read from the subject's `vcard:hasEmail` → object node → that node's `vcard:value` (mailto: URI); name from `vcard:fn` (preferred) or `foaf:name`. Uses **N3.Store** and **DataFactory.namedNode()** for lookups so matching is term-based and maintainable.
+  - **Integration**: `getSolidProfileFromWebId(webIdUrl, accessToken)` returns `{ email?, name? }`; best-effort (returns `{}` on fetch/parse failure). In `verifySolidUser`, we call it when `userinfo.webid` and `tokenset.access_token` exist and merge `profile.email` and `profile.name` into `userinfo`, so the real email is used instead of `...@FAKEDOMAIN.TLD` when the profile contains it, and the name appears in the UI. `getFullName(userinfo)` now considers `userinfo.name` (from profile) before given_name/family_name.
+  - **UI**: The client sidebar and account popover already display `user.name` and `user.email` from the API; no client changes were required.
+
 ## Current Status
 
 ### Working Features
@@ -175,6 +183,7 @@ Successfully implemented Solid Pod storage integration for LibreChat, enabling u
 13. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
 14. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
 15. **Conversation Share**: Users can share conversations stored in Solid Pod with public read access while maintaining full write permissions
+16. **Solid profile email/name**: When the user's WebID profile card (vCard/FOAF) contains email and/or name, these are fetched after login and used for the LibreChat user (sidebar and account popover show real email and name instead of faked email)
 
 ### Known Issues 🔧
 None currently identified.
@@ -211,6 +220,7 @@ None currently identified.
 - **Authorization request**: Solid flow sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
 - **JWT strategies**: Solid uses `solidJwt`, generic OpenID uses `openidJwt`; `requireJwtAuth` and `optionalJwtAuth` select the strategy based on the `token_provider` cookie. The cookie is set from `req.user.provider` in `setOpenIDAuthTokens`; the refresh path passes `token_provider` into `performOpenIDRefresh` and sets `req.user`/`user.provider` so the cookie is not overwritten to `openid` after refresh.
 - **JWT extraction**: The openIdJwt/solidJwt strategy reads the JWT from `Authorization: Bearer` first, then from the `openid_id_token` cookie, so the first request after redirect can authenticate before the frontend sets the header. We set the `openid_id_token` cookie when storing tokens in session so that fallback works.
+- **Solid profile (WebID card)**: When a user logs in with Solid, we optionally fetch their WebID profile document (Turtle) using the access token, parse it with n3 (Store + DataFactory), and extract `vcard:fn`/`foaf:name` for display name and `vcard:hasEmail` → `vcard:value` (mailto:) for email. This replaces the faked `...@FAKEDOMAIN.TLD` email and improves the displayed name when the profile card contains them. Best-effort; failures do not block login.
 
 ### Access Control (ACL)
 - Uses manual ACL Turtle format for permission management
@@ -246,7 +256,7 @@ None currently identified.
 - `api/server/controllers/AuthController.js` - performOpenIDRefresh accepts tokenProvider param; sets req.user and user.provider before setOpenIDAuthTokens so token_provider cookie preserved on refresh; session fallback when no refresh token; Solid vs openid by token_provider
 - `api/server/middleware/requireJwtAuth.js` - Use solidJwt when token_provider is solid, openidJwt when openid; lazy solidJwt registration; sendStrategyNotRegistered503 from openIdAuthHelpers
 - `api/server/middleware/optionalJwtAuth.js` - Same strategy selection and 503 helper as requireJwtAuth
-- `api/strategies/SolidOpenidStrategy.js` - verifySolidUser return includes provider: 'solid'; prompt=consent for refresh token; SOLID_OPENID_* env; register as 'solid'
+- `api/strategies/SolidOpenidStrategy.js` - verifySolidUser return includes provider: 'solid'; prompt=consent for refresh token; SOLID_OPENID_* env; register as 'solid'; **getSolidProfileFromWebId**: fetch WebID profile (Turtle), parse with n3 Store + DataFactory, extract vcard:fn/foaf:name and vcard:hasEmail→value (mailto:); merge into userinfo so real email/name used; getFullName considers userinfo.name
 - `api/strategies/openIdJwtStrategy.js` - jwtFromRequest: Authorization Bearer then openid_id_token cookie; used by solidJwt and openidJwt
 - `api/server/controllers/auth/solidOpenIdDynamic.js` - startSolidOpenIdFlow, handleSolidOpenIdCallback (multi-issuer with PKCE)
 - `api/server/middleware/validate/convoAccess.js` - Solid storage support for conversation access validation
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index dd1f9b1a15ae..eefff3c45cf3 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -5,6 +5,7 @@ const passport = require('passport');
 const client = require('openid-client');
 const jwtDecode = require('jsonwebtoken/decode');
 const { HttpsProxyAgent } = require('https-proxy-agent');
+const { Parser, Store, DataFactory } = require('n3');
 const { hashToken, logger } = require('@librechat/data-schemas');
 const { CacheKeys, ErrorTypes } = require('librechat-data-provider');
 const { Strategy: OpenIDStrategy } = require('openid-client/passport');
@@ -244,6 +245,121 @@ const downloadImage = async (url, config, accessToken, sub) => {
   }
 };
 
+const VCARD_NS = 'http://www.w3.org/2006/vcard/ns#';
+const FOAF_NS = 'http://xmlns.com/foaf/0.1/';
+
+/**
+ * Fetches the Solid profile document (WebID card) and extracts email and name from vCard/FOAF.
+ * Uses n3 for Turtle parsing (no regex). Best-effort: returns {} on any failure.
+ * @param {string} webIdUrl - The user's WebID (e.g. https://pod.example.com/profile/card#me)
+ * @param {string} accessToken - Bearer access token from Solid OIDC
+ * @returns {Promise<{ email?: string, name?: string }>}
+ */
+async function getSolidProfileFromWebId(webIdUrl, accessToken) {
+  if (!webIdUrl || typeof webIdUrl !== 'string' || !accessToken) {
+    return {};
+  }
+  const webId = webIdUrl.trim();
+  let profileDocUrl;
+  try {
+    const u = new URL(webId);
+    u.hash = '';
+    profileDocUrl = u.href;
+  } catch {
+    return {};
+  }
+
+  const fetchOptions = {
+    method: 'GET',
+    headers: {
+      Accept: 'text/turtle',
+      Authorization: `Bearer ${accessToken}`,
+    },
+  };
+  if (process.env.PROXY) {
+    fetchOptions.agent = new HttpsProxyAgent(process.env.PROXY);
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5000);
+  fetchOptions.signal = controller.signal;
+
+  let text;
+  try {
+    const response = await fetch(profileDocUrl, fetchOptions);
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      logger.debug(
+        `[SolidOpenidStrategy] getSolidProfileFromWebId: profile fetch failed ${response.status} ${profileDocUrl}`,
+      );
+      return {};
+    }
+    text = await response.text();
+  } catch (err) {
+    clearTimeout(timeoutId);
+    logger.debug(
+      `[SolidOpenidStrategy] getSolidProfileFromWebId: fetch error ${err.message} ${profileDocUrl}`,
+    );
+    return {};
+  }
+
+  let quads;
+  try {
+    const parser = new Parser({ baseIRI: profileDocUrl });
+    quads = parser.parse(text);
+  } catch (err) {
+    logger.debug(
+      `[SolidOpenidStrategy] getSolidProfileFromWebId: Turtle parse error ${err.message}`,
+    );
+    return {};
+  }
+
+  const { namedNode } = DataFactory;
+  const store = new Store(quads);
+  const subjectIri = webId;
+  const subjectTerm = namedNode(subjectIri);
+  const hasEmailPred = VCARD_NS + 'hasEmail';
+  const valuePred = VCARD_NS + 'value';
+  const fnPred = VCARD_NS + 'fn';
+  const foafNamePred = FOAF_NS + 'name';
+
+  let name;
+  const fnQuads = store.getQuads(subjectTerm, namedNode(fnPred), null, null);
+  if (fnQuads.length > 0 && fnQuads[0].object.termType === 'Literal' && fnQuads[0].object.value) {
+    name = fnQuads[0].object.value;
+  } else {
+    const foafNameQuads = store.getQuads(subjectTerm, namedNode(foafNamePred), null, null);
+    if (
+      foafNameQuads.length > 0 &&
+      foafNameQuads[0].object.termType === 'Literal' &&
+      foafNameQuads[0].object.value
+    ) {
+      name = foafNameQuads[0].object.value;
+    }
+  }
+
+  let email;
+  const hasEmailQuads = store.getQuads(subjectTerm, namedNode(hasEmailPred), null, null);
+  for (const q of hasEmailQuads) {
+    const emailNode = q.object;
+    const valueQuads = store.getQuads(emailNode, namedNode(valuePred), null, null);
+    for (const vq of valueQuads) {
+      if (
+        vq.object.termType === 'NamedNode' &&
+        vq.object.value.startsWith('mailto:')
+      ) {
+        email = vq.object.value.slice(7).trim();
+        break;
+      }
+    }
+    if (email) break;
+  }
+
+  const out = {};
+  if (email) out.email = email;
+  if (name) out.name = name;
+  return out;
+}
+
 /**
  * Determines the full name of a user based on OpenID userinfo and environment configuration.
  *
@@ -252,6 +368,7 @@ const downloadImage = async (url, config, accessToken, sub) => {
  * @param {string} [userinfo.family_name] - The user's last name
  * @param {string} [userinfo.username] - The user's username
  * @param {string} [userinfo.email] - The user's email address
+ * @param {string} [userinfo.name] - Full name (e.g. from Solid profile vcard:fn)
  * @returns {string} The determined full name of the user
  */
 function getFullName(userinfo) {
@@ -259,6 +376,10 @@ function getFullName(userinfo) {
     return userinfo[process.env.OPENID_NAME_CLAIM];
   }
 
+  if (userinfo.name) {
+    return userinfo.name;
+  }
+
   if (userinfo.given_name && userinfo.family_name) {
     return `${userinfo.given_name} ${userinfo.family_name}`;
   }
@@ -315,6 +436,12 @@ async function verifySolidUser(tokenset, openidConfig) {
     ...(await getUserInfo(openidConfig, tokenset.access_token, claims.sub)),
   };
 
+  if (userinfo.webid && tokenset.access_token) {
+    const profile = await getSolidProfileFromWebId(userinfo.webid, tokenset.access_token);
+    if (profile.email) userinfo.email = profile.email;
+    if (profile.name) userinfo.name = profile.name;
+  }
+
   const appConfig = await getAppConfig();
   const email =
     userinfo.email ||

From 7fccf965082aff4efd26bb7feb705f1725cde6a0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Mar 2026 14:03:45 +0000
Subject: [PATCH 91/94] fix eslint error

---
 api/server/controllers/AuthController.js | 58 ++++++++++++------------
 api/strategies/SolidOpenidStrategy.js    |  5 +-
 2 files changed, 30 insertions(+), 33 deletions(-)

diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index c50f73471b81..1c1b7d2751f9 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -18,7 +18,7 @@ const {
   findUser,
 } = require('~/models');
 const { getGraphApiToken } = require('~/server/services/GraphTokenService');
-const { getOpenIdConfig, getOpenIdEmail } = require('~/strategies');
+const { getOpenIdConfig, getSolidOpenIdConfig, getOpenIdEmail } = require('~/strategies');
 
 const registrationController = async (req, res) => {
   try {
@@ -97,29 +97,29 @@ async function performOpenIDRefresh(
       strategyName: 'refreshController',
     });
 
-      logger.debug(
-        `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
-      );
+    logger.debug(
+      `[refreshController] findOpenIDUser result: user=${user?.email ?? 'null'}, error=${error ?? 'null'}, migration=${migration}, userOpenidId=${user?.openidId ?? 'null'}, claimsSub=${claims.sub}`,
+    );
 
-      if (error || !user) {
-        logger.warn(
-          `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
-        );
-        return res.status(401).redirect('/login');
-      }
+    if (error || !user) {
+      logger.warn(
+        `[refreshController] Redirecting to /login: error=${error ?? 'null'}, user=${user ? 'exists' : 'null'}`,
+      );
+      return res.status(401).redirect('/login');
+    }
 
-      // Handle migration: update user with openidId if found by email without openidId
-      // Also handle case where user has mismatched openidId (e.g., after database switch)
-      if (migration || user.openidId !== claims.sub) {
-        const reason = migration ? 'migration' : 'openidId mismatch';
-        await updateUser(user._id.toString(), {
-          provider: user.provider || 'openid',
-          openidId: claims.sub,
-        });
-        logger.info(
-          `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
-        );
-      }
+    // Handle migration: update user with openidId if found by email without openidId
+    // Also handle case where user has mismatched openidId (e.g., after database switch)
+    if (migration || user.openidId !== claims.sub) {
+      const reason = migration ? 'migration' : 'openidId mismatch';
+      await updateUser(user._id.toString(), {
+        provider: user.provider || 'openid',
+        openidId: claims.sub,
+      });
+      logger.info(
+        `[refreshController] Updated user ${user.email} openidId (${reason}): ${user.openidId ?? 'null'} -> ${claims.sub}`,
+      );
+    }
 
     // setOpenIDAuthTokens sets token_provider cookie correctly (solid vs openid)
     req.user = user;
@@ -127,14 +127,14 @@ async function performOpenIDRefresh(
       user.provider = user.provider || tokenProvider;
     }
 
-      const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
+    const token = setOpenIDAuthTokens(tokenset, req, res, user._id.toString(), refreshToken);
 
-      user.federatedTokens = {
-        access_token: tokenset.access_token,
-        id_token: tokenset.id_token,
-        refresh_token: refreshToken,
-        expires_at: claims.exp,
-      };
+    user.federatedTokens = {
+      access_token: tokenset.access_token,
+      id_token: tokenset.id_token,
+      refresh_token: refreshToken,
+      expires_at: claims.exp,
+    };
 
     res.status(200).send({ token, user });
     return true;
diff --git a/api/strategies/SolidOpenidStrategy.js b/api/strategies/SolidOpenidStrategy.js
index eefff3c45cf3..0281bd1f9d68 100644
--- a/api/strategies/SolidOpenidStrategy.js
+++ b/api/strategies/SolidOpenidStrategy.js
@@ -343,10 +343,7 @@ async function getSolidProfileFromWebId(webIdUrl, accessToken) {
     const emailNode = q.object;
     const valueQuads = store.getQuads(emailNode, namedNode(valuePred), null, null);
     for (const vq of valueQuads) {
-      if (
-        vq.object.termType === 'NamedNode' &&
-        vq.object.value.startsWith('mailto:')
-      ) {
+      if (vq.object.termType === 'NamedNode' && vq.object.value.startsWith('mailto:')) {
         email = vq.object.value.slice(7).trim();
         break;
       }

From 2f8d0f28c12959f7b3eedcdc107f52b6d2dc36f0 Mon Sep 17 00:00:00 2001
From: Precious Oritsedere <rukyjacob@gmail.com>
Date: Tue, 3 Mar 2026 15:21:46 +0000
Subject: [PATCH 92/94] ran npm i to update package after rebase

---
 package-lock.json | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 1f7f24aaec42..8d0510719291 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7618,8 +7618,8 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
-      "peer": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=20.19.0"
       },
@@ -7642,8 +7642,8 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
-      "peer": true,
       "license": "MIT",
+      "peer": true,
       "engines": {
         "node": ">=20.19.0"
       }
@@ -7758,6 +7758,7 @@
       "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -8221,6 +8222,7 @@
       "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -22794,6 +22796,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -24711,6 +24714,7 @@
       "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -28388,12 +28392,6 @@
         "node": ">=10.13.0"
       }
     },
-    "node_modules/glob-to-regexp": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
-      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
-      "dev": true
-    },
     "node_modules/glob/node_modules/balanced-match": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
@@ -33042,6 +33040,7 @@
       "resolved": "https://registry.npmjs.org/mathjs/-/mathjs-15.1.0.tgz",
       "integrity": "sha512-HfnAcScQm9drGryodlDqeS3WAl4gUTYGDcOtcqL/8s23MZ28Ib1i8XnYK3ZdjNuaW/L4BAp9lIp8vxAMrcuu1w==",
       "license": "Apache-2.0",
+      "peer": true,
       "dependencies": {
         "@babel/runtime": "^7.26.10",
         "complex.js": "^2.2.5",
@@ -37230,6 +37229,7 @@
       "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -37600,6 +37600,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "baseline-browser-mapping": "^2.9.0",
         "caniuse-lite": "^1.0.30001759",
@@ -37771,7 +37772,6 @@
       "version": "6.0.15",
       "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.15.tgz",
       "integrity": "sha512-rEYkQOMUCEMhsKbK66tbEU9QVIxbhN18YiniAwA7XQYTVBqrBy+P2p5JcdqsHgKM2zWylp8d7J6eszocfds5Sw==",
-      "peer": true,
       "dependencies": {
         "cssesc": "^3.0.0",
         "util-deprecate": "^1.0.2"
@@ -44055,8 +44055,8 @@
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.80.0.tgz",
       "integrity": "sha512-cIFJOD1DESzpjOBl763Kp1AH7UE/0fcdHe6rZXUdQ9c50uvgigvW97u3IcSeBwOkgqL/PXPBktBCh0KEu5L8XQ==",
       "dev": true,
-      "peer": true,
       "license": "MIT",
+      "peer": true,
       "bin": {
         "rollup": "dist/bin/rollup"
       },

From 15e1344d8d253cc5b1ed4590d40655b7c79082ff Mon Sep 17 00:00:00 2001
From: Jesse Wright <63333554+jeswr@users.noreply.github.com>
Date: Wed, 4 Mar 2026 00:24:04 +0000
Subject: [PATCH 93/94] Delete SOLID_INTEGRATION_PROGRESS.md

---
 SOLID_INTEGRATION_PROGRESS.md | 331 ----------------------------------
 1 file changed, 331 deletions(-)
 delete mode 100644 SOLID_INTEGRATION_PROGRESS.md

diff --git a/SOLID_INTEGRATION_PROGRESS.md b/SOLID_INTEGRATION_PROGRESS.md
deleted file mode 100644
index 9b2667568649..000000000000
--- a/SOLID_INTEGRATION_PROGRESS.md
+++ /dev/null
@@ -1,331 +0,0 @@
-# Solid Pod Integration - Progress Report
-
-## Overview
-Successfully implemented Solid Pod storage integration for LibreChat, enabling users to store conversations and messages in their personal Solid Pods instead of (or alongside) MongoDB.
-
-## Completed Milestones
-
-### 1. Authentication & Token Management
-- **Status**: Complete
-- **Details**: 
-  - Integrated Solid-OIDC authentication flow
-  - Captured and logged authorization codes from Solid provider
-  - Implemented token storage in session and cookies
-  - Handled cases where Solid provider doesn't issue refresh tokens
-  - Ensured JWT tokens are created for frontend authentication
-  - Added separate "Login with Solid" button with custom branding
-  - Supports both generic OpenID and Solid-specific authentication buttons
-  - Both buttons use the same authentication flow but with different labels and icons
-
-### 2. Solid Pod Access
-- **Status**: Complete
-- **Details**:
-  - Implemented authenticated fetch using OpenID access tokens
-  - Created Pod URL discovery with fallback mechanism
-  - Derived Pod URLs from WebID when not found in profile
-  - Verified Pod accessibility before operations
-
-### 3. Container Management
-- **Status**: Complete
-- **Details**:
-  - Implemented automatic container creation for base storage structure
-  - Created `/librechat/`, `/librechat/conversations/`, and `/librechat/messages/` containers
-  - Used HTTP HEAD requests to check container existence
-  - Properly parsed Turtle (RDF) format responses from Solid Pods
-
-### 4. Message Storage
-- **Status**: Complete
-- **Details**:
-  - Implemented `saveMessageToSolid` - saves individual messages as JSON files
-  - Messages stored in: `/librechat/messages/{conversationId}/{messageId}.json`
-  - Successfully tested: User messages are being saved to Pod
-  - Proper error handling and logging
-
-### 5. Conversation Storage
-- **Status**: Complete
-- **Details**:
-  - Implemented `saveConvoToSolid` - saves conversations as JSON files
-  - Conversations stored in: `/librechat/conversations/{conversationId}.json`
-  - Successfully tested: Conversations are being created in Pod
-  - Includes message references and metadata
-
-### 6. Data Retrieval
-- **Status**: Complete
-- **Details**:
-  - Implemented `getMessagesFromSolid` - retrieves all messages for a conversation
-  - Implemented `getConvosByCursorFromSolid` - retrieves conversations with pagination
-  - Properly parses Turtle format to extract `ldp:contains` items
-  - Handles empty containers gracefully (returns empty arrays, not errors)
-
-### 7. Storage Backend Selection (No Feature Flag)
-- **Status**: Complete
-- **Details**:
-  - Storage backend is determined by how the user logged in: **"Continue with Solid"** → Solid Pod; **"Continue with OpenID"** or other → MongoDB
-  - Users who click "Continue with Solid" have `provider === 'solid'`; only those get Solid storage
-  - Integrated Solid storage in `Message.js`, `Conversation.js`, routes, and share methods
-  - Shared `isSolidUser(req)` helper in `api/server/utils/isSolidUser.js` used everywhere (DRY)
-  - Maintains backward compatibility with MongoDB for all non-Solid users
-
-### 8. Conversation Access Validation & No MongoDB Fallback for Solid Users
-- **Status**: Complete
-- **Details**:
-  - Updated `validateConvoAccess` middleware to check Solid storage
-  - Modified `searchConversation` to query Solid Pod when the user logged in via "Continue with Solid" (`provider === 'solid'`)
-  - Ensures users can only access their own conversations from Solid Pod
-  - **No MongoDB fallback for Solid users (per PR review)**: When a user is logged in with Solid, we never fall back to MongoDB on Solid failure or null. Errors are surfaced so the UI can show "Save failed" or "Load failed" instead of writing/reading from the wrong store:
-    - **Conversation.js**: `searchConversation`, `getConvo`, `saveConvo`, `getConvosByCursor` return null or rethrow for Solid users; no MongoDB path
-    - **validateMessageReq.js**: Solid users get 404 if conversation not in Solid; no MongoDB lookup
-    - **messages.js** routes: Solid errors return 503 with "Solid storage temporarily unavailable"; no MongoDB read
-  - Non-Solid users continue to use MongoDB only
-
-### 9. Payload Normalization & Model Extraction
-- **Status**: Complete
-- **Details**:
-  - Implemented conversation object normalization in `createPayload` for Solid storage compatibility
-  - Handles Solid storage format differences (messages as objects vs IDs, null vs undefined)
-  - Added fallback mechanism for schema validation failures
-  - Extracts `model` and `endpoint` from messages when missing in conversation metadata
-  - Ensures `resendFiles` is included in payloads for agents endpoints (defaults to `true`)
-  - **buildEndpointOption** (per PR review): Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model; no Solid-specific logic in that middleware—storage is chosen in the model layer
-
-### 10. Full Conversation Flow
-- **Status**: Complete
-- **Details**:
-  - Users can start new conversations
-  - Users can continue existing conversations
-  - Model information is correctly extracted and passed through the request chain
-  - All required payload fields are included for agents endpoints
-
-### 11. Title Persistence
-- **Status**: Complete
-- **Details**:
-  - Conversation titles are properly saved to Solid Pod when generated
-  - Titles persist correctly after page refresh and after sending more messages
-  - `saveConvo` correctly identifies Solid users before saving to Solid Pod
-  - **saveConvoToSolid** merges existing Pod conversation into the incoming document before writing, so partial updates (e.g. after POST message or BaseClient saveConvo) preserve fields like `title` instead of overwriting the file and losing the generated title
-
-### 12. Conversation Management Operations
-- **Status**: Complete
-- **Details**:
-  - **Rename**: Working - Users can rename conversations stored in Solid Pod
-  - **Duplicate**: Working - Users can duplicate conversations and all messages from Solid Pod
-  - **Delete**: Working - Users can delete conversations and all associated messages from Solid Pod
-  - **Archive**: Working - Users can archive and unarchive conversations stored in Solid Pod
-  - **Share**: Working - Users can share conversations stored in Solid Pod with public read access while maintaining owner write permissions
-
-### 13. Share Functionality
-- **Status**: Complete
-- **Details**:
-  - Implemented public read access via ACL (Access Control List) for shared conversations
-  - Uses manual ACL Turtle format for reliable permission management
-  - Preserves owner permissions (Write, Append, Control) when granting public read access
-  - Applies `acl:default` on message containers so new messages automatically inherit public access
-  - Dynamically detects Solid users and routes to appropriate sharing method
-  - Fetches shared messages directly from Pod using unauthenticated requests
-  - Properly removes public access when share is deleted
-
-### 14. Schema-Aligned Document Content (PR Review)
-- **Status**: Complete
-- **Details**:
-  - **Single source of document shape**: JSON written to the Solid Pod now matches the same document shape as MongoDB; shape is defined in the model layer and aligned with `packages/data-schemas` (message + convo schema and types).
-  - **Messages**: `Message.js` builds the full message document (including `user`, `createdAt`, `updatedAt`) and passes it to `saveMessageToSolid`. SolidStorage only validates ids, resolves paths, and writes that document; the previous hand-built field list and defaults in SolidStorage were removed.
-  - **Conversations**: `Conversation.js` builds the full conversation document (conversationId, user, …convo, expiredAt, `previousConversationId` when renaming) and passes it to `saveConvoToSolid`. SolidStorage only adds Pod-specific data (message refs from the Pod, timestamps, optional model/endpoint fallback from messages), then merges with existing Pod conversation (to preserve e.g. title on partial updates) and writes. It no longer constructs the conversation payload from a custom field list.
-  - **Partial updates**: When the caller sends a partial update (e.g. after sending a message with no `title`), existing conversation from the Pod is merged into the incoming document before writing so fields like `title` are preserved.
-
-### 15. PR Review: Config, Logging, Convos
-- **Status**: Complete
-- **Details**:
-  - **config.js**: `openidLoginEnabled` set to `isOpenIdEnabled` only (removed `|| isSolidEnabled`) so when only Solid is enabled the login page shows one Solid button, not both OpenID and Solid.
-  - **requireJwtAuth.js**: Removed non–Solid-specific debug logging added during auth flow debugging; reviewer suggested upstreaming useful logging in a separate PR if needed.
-  - **convos.js**: No code change; reviewer concern addressed by clarification—`getConvo(req.user.id, conversationId, req)` in `Conversation.js` already branches on `isSolidUser(req)` and uses Solid when the user is a Solid user.
-
-### 16. Refresh Token Support & Post-Login API Auth (Solid-Only Config)
-- **Status**: Complete
-- **Details**:
-  - **Post-login redirect**: After Solid OAuth callback, the server redirects to `DOMAIN_CLIENT`; the client then calls `/api/auth/refresh`. When the IdP does not return a refresh token, we return `{ token, user }` from session (decode id_token for `sub`, find user by openidId). When a refresh token *is* present, `performOpenIDRefresh` exchanges it for new tokens and returns `{ token, user }`.
-  - **Refresh token**: When the Solid IdP (e.g. Local CSS) returns a refresh token in the token response, we receive it, store it in session (`req.session.openidTokens.refreshToken`) and in the `refreshToken` cookie, and use it in `/api/auth/refresh` via `performOpenIDRefresh` + `openIdClient.refreshTokenGrant`. So **yes, we now receive and use a refresh token** when the IdP provides one.
-  - **prompt=consent**: Solid authorization request sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
-  - **JWT strategy by provider**: `requireJwtAuth` and `optionalJwtAuth` use `solidJwt` when `token_provider === 'solid'` and `openidJwt` when `token_provider === 'openid'`, so API requests after Solid login authenticate correctly when only Solid is configured (generic OpenID may be unregistered e.g. due to HTTPS requirement).
-  - **token_provider cookie must stay `solid`**: The cookie is set from `req.user?.provider` in `setOpenIDAuthTokens`. (1) **OAuth callback**: Solid strategy return value now explicitly includes `provider: 'solid'` so the callback sets `token_provider=solid`. (2) **Refresh path**: When the frontend calls refresh, we pass `token_provider` from the request cookie into `performOpenIDRefresh` and set `req.user = user` and `user.provider = user.provider || tokenProvider` before calling `setOpenIDAuthTokens`, so the cookie is not overwritten to `openid` and subsequent API calls use solidJwt.
-  - **solidJwt registration**: Uses `getSolidOpenIdProvidersForJwt()` (from `SOLID_OPENID_PROVIDERS` or, when that list is empty, a synthetic Local CSS provider when `SOLID_OPENID_CUSTOM_CLIENT_ID` is set). Registration runs at startup in socialLogins and lazily in auth middleware if the strategy was not registered (e.g. IdP was down).
-  - **JWT from cookie fallback**: The openIdJwt strategy (used by solidJwt) extracts the JWT from `Authorization: Bearer` first, then from the `openid_id_token` cookie, so the first API request after redirect (before the frontend refresh sets the header) can still authenticate. When storing tokens in session we also set the `openid_id_token` cookie so that fallback works.
-  - **DRY**: Shared `sendStrategyNotRegistered503(res, tokenProvider, afterLazyInit)` in `api/server/middleware/openIdAuthHelpers.js` used by both `requireJwtAuth` and `optionalJwtAuth` for 503 responses when the OpenID/Solid strategy is not registered. Unnecessary logging removed (setOpenIDAuthTokens debug, 503 warns, Solid “no providers” debug, extra configureSolidOpenIdFromProviders info).
-- **Config**:
-  - **Dynamic-only**: Solid provider list comes from `SOLID_OPENID_PROVIDERS` only; legacy `SOLID_OPENID_ISSUER` is no longer used. `SOLID_OPENID_CUSTOM_CLIENT_ID` allows custom issuer URLs (e.g. user picks “Local CSS” from modal) with a single client id; `getSolidOpenIdProvidersForJwt()` returns a synthetic provider for Local CSS when only custom client id is set so solidJwt can still register.
-- **Findings**:
-  - **Local CSS** with dynamic client registration (`/solid-client-id` document) can return a refresh token when configured to do so; we store and use it. With `prompt=consent` and `offline_access` scope, IdPs that support it will include a refresh token.
-  - **solidcommunity.net**: The IdP dereferences the client_id URL; a localhost client_id is not reachable. Use a public URL for production.
-  - **SOLID_OPENID_SCOPE**: Use `"openid webid offline_access"` for refresh token support when the IdP supports it.
-
-### 17. Solid Profile (WebID Card) Email and Name
-- **Status**: Complete
-- **Details**:
-  - **Profile fetch**: After Solid login, when `userinfo.webid` and an access token is available, we fetch the user's WebID profile document (Turtle) from the profile URL derived from the WebID (strip fragment, e.g. `https://pod.example.com/profile/card#me` → `https://pod.example.com/profile/card`). Request uses `Authorization: Bearer` and `Accept: text/turtle` with a 5s timeout; PROXY is respected.
-  - **Email and name extraction**: We parse the Turtle with **n3** (no regex). Email is read from the subject's `vcard:hasEmail` → object node → that node's `vcard:value` (mailto: URI); name from `vcard:fn` (preferred) or `foaf:name`. Uses **N3.Store** and **DataFactory.namedNode()** for lookups so matching is term-based and maintainable.
-  - **Integration**: `getSolidProfileFromWebId(webIdUrl, accessToken)` returns `{ email?, name? }`; best-effort (returns `{}` on fetch/parse failure). In `verifySolidUser`, we call it when `userinfo.webid` and `tokenset.access_token` exist and merge `profile.email` and `profile.name` into `userinfo`, so the real email is used instead of `...@FAKEDOMAIN.TLD` when the profile contains it, and the name appears in the UI. `getFullName(userinfo)` now considers `userinfo.name` (from profile) before given_name/family_name.
-  - **UI**: The client sidebar and account popover already display `user.name` and `user.email` from the API; no client changes were required.
-
-## Current Status
-
-### Working Features
-1. **User Login**: Solid-OIDC authentication working correctly with dedicated "Login with Solid" button
-2. **Separate Authentication Buttons**: Both "Login with OpenID" and "Login with Solid" buttons available with custom labels and icons
-3. **Conversation Creation**: New conversations are saved to Solid Pod
-4. **Message Saving**: User messages and AI responses are saved to Solid Pod
-5. **Data Retrieval**: Conversations and messages can be read from Pod
-6. **Container Structure**: Proper directory structure created automatically
-7. **Conversation Continuation**: Users can send multiple messages in the same conversation
-8. **Model Persistence**: Model and endpoint information is correctly stored and retrieved
-9. **Access Control**: Conversation access validation works for Solid storage users
-10. **Title Persistence**: Conversation titles are saved to Solid Pod and persist after page refresh
-11. **Conversation Rename**: Users can rename conversations stored in Solid Pod
-12. **Conversation Duplicate**: Users can duplicate conversations and all their messages from Solid Pod
-13. **Conversation Delete**: Users can delete conversations and all associated messages from Solid Pod
-14. **Conversation Archive**: Users can archive and unarchive conversations stored in Solid Pod
-15. **Conversation Share**: Users can share conversations stored in Solid Pod with public read access while maintaining full write permissions
-16. **Solid profile email/name**: When the user's WebID profile card (vCard/FOAF) contains email and/or name, these are fetched after login and used for the LibreChat user (sidebar and account popover show real email and name instead of faked email)
-
-### Known Issues 🔧
-None currently identified.
-
-## Technical Implementation
-
-### Storage Format
-- **Format**: JSON files
-- **Structure**:
-  ```
-  /librechat/
-    /conversations/
-      {conversationId}.json
-    /messages/
-      {conversationId}/
-        {messageId}.json
-  ```
-
-### Parsing Logic
-- Uses HTTP GET requests to retrieve container contents
-- Parses Turtle (RDF) format responses
-- Extracts `ldp:contains` predicates to list files
-- Handles relative and absolute URLs
-
-### Authentication
-- Uses OpenID access tokens stored in session
-- Falls back to cookies if session unavailable
-- Tokens retrieved from multiple sources for robustness
-- Separate "Login with Solid" button using `SOLID_OPENID_*` environment variables
-- Generic "Login with OpenID" button using `OPENID_*` environment variables
-- Both buttons share the same authentication flow and `/oauth/openid` route
-- Custom SolidIcon component for Solid branding
-- **Refresh token**: When the IdP returns a refresh token, it is stored in session (and cookie when present) and used by `/api/auth/refresh` via `performOpenIDRefresh` to obtain new tokens. When no refresh token is returned, a session fallback returns the current session token and user so the client does not redirect to `/login`.
-- **Authorization request**: Solid flow sends `prompt=consent` and `scope=openid webid offline_access` so IdPs that support it can issue a refresh token.
-- **JWT strategies**: Solid uses `solidJwt`, generic OpenID uses `openidJwt`; `requireJwtAuth` and `optionalJwtAuth` select the strategy based on the `token_provider` cookie. The cookie is set from `req.user.provider` in `setOpenIDAuthTokens`; the refresh path passes `token_provider` into `performOpenIDRefresh` and sets `req.user`/`user.provider` so the cookie is not overwritten to `openid` after refresh.
-- **JWT extraction**: The openIdJwt/solidJwt strategy reads the JWT from `Authorization: Bearer` first, then from the `openid_id_token` cookie, so the first request after redirect can authenticate before the frontend sets the header. We set the `openid_id_token` cookie when storing tokens in session so that fallback works.
-- **Solid profile (WebID card)**: When a user logs in with Solid, we optionally fetch their WebID profile document (Turtle) using the access token, parse it with n3 (Store + DataFactory), and extract `vcard:fn`/`foaf:name` for display name and `vcard:hasEmail` → `vcard:value` (mailto:) for email. This replaces the faked `...@FAKEDOMAIN.TLD` email and improves the displayed name when the profile card contains them. Best-effort; failures do not block login.
-
-### Access Control (ACL)
-- Uses manual ACL Turtle format for permission management
-- Grants public read access for shared conversations while preserving owner permissions
-- Applies `acl:default` on containers to ensure new resources inherit permissions
-- Owner retains Write, Append, and Control permissions when sharing
-- Properly removes public access when share is deleted
-
-## Future Improvements
-
-1. **User Storage Selection**
-   - Allow users to select their storage Pod (currently uses default Pod URL)
-   - Location: `api/server/services/SolidStorage.js:1619`
-   - Priority: Low (can be implemented after initial PR)
-
-2. **RDF Parsing Enhancement**
-   - Use RDF object mapper to parse Turtle format instead of regex patterns
-   - Location: `api/server/services/SolidStorage.js:1659`
-   - Priority: Low (current regex parsing works but could be more robust)
-
-
-## Files Modified
-- `api/server/services/SolidStorage.js` (NEW) - Core Solid Pod operations; schema-aligned: accepts full document from model layer, only adds message refs + timestamps + merge with existing for partial updates (no custom document content)
-- `api/server/utils/isSolidUser.js` (NEW) - Shared helper to detect Solid login (`provider === 'solid'`), used across models, routes, and middleware (DRY)
-- `api/models/Message.js` - Integrated Solid storage; builds full message document (user, createdAt, updatedAt) and passes to SolidStorage; MongoDB path for non-Solid users only (no fallback for Solid)
-- `api/models/Conversation.js` - Integrated Solid storage; builds full conversation document and passes to SolidStorage; no MongoDB fallback for Solid users (return null/rethrow on Solid failure); passes `previousConversationId` when renaming
-- `api/server/services/Config/solidOpenId.js` - getSolidOpenIdProviders (SOLID_OPENID_PROVIDERS only); getSolidOpenIdProvidersForJwt (includes synthetic Local CSS when only SOLID_OPENID_CUSTOM_CLIENT_ID); getSolidOpenIdProviderByIssuer
-- `api/server/services/ensureSolidJwt.js` (NEW) - Ensures solidJwt strategy registered at startup or lazily; uses getSolidOpenIdProvidersForJwt
-- `api/server/middleware/openIdAuthHelpers.js` (NEW) - Shared sendStrategyNotRegistered503 for requireJwtAuth and optionalJwtAuth (DRY)
-- `api/server/routes/oauth.js` - OAuth handler stores OpenID/Solid tokens via setOpenIDAuthTokens; startBaseStructureAfterLogin for Solid
-- `api/server/services/AuthService.js` - setOpenIDAuthTokens: store access/id/refresh in session; set openid_id_token cookie when using session (for first-request auth); set token_provider cookie from req.user?.provider; refresh-token cookie when present
-- `api/server/index.js` - Session middleware ordering; /solid-client-id endpoint for dynamic client metadata
-- `api/server/controllers/AuthController.js` - performOpenIDRefresh accepts tokenProvider param; sets req.user and user.provider before setOpenIDAuthTokens so token_provider cookie preserved on refresh; session fallback when no refresh token; Solid vs openid by token_provider
-- `api/server/middleware/requireJwtAuth.js` - Use solidJwt when token_provider is solid, openidJwt when openid; lazy solidJwt registration; sendStrategyNotRegistered503 from openIdAuthHelpers
-- `api/server/middleware/optionalJwtAuth.js` - Same strategy selection and 503 helper as requireJwtAuth
-- `api/strategies/SolidOpenidStrategy.js` - verifySolidUser return includes provider: 'solid'; prompt=consent for refresh token; SOLID_OPENID_* env; register as 'solid'; **getSolidProfileFromWebId**: fetch WebID profile (Turtle), parse with n3 Store + DataFactory, extract vcard:fn/foaf:name and vcard:hasEmail→value (mailto:); merge into userinfo so real email/name used; getFullName considers userinfo.name
-- `api/strategies/openIdJwtStrategy.js` - jwtFromRequest: Authorization Bearer then openid_id_token cookie; used by solidJwt and openidJwt
-- `api/server/controllers/auth/solidOpenIdDynamic.js` - startSolidOpenIdFlow, handleSolidOpenIdCallback (multi-issuer with PKCE)
-- `api/server/middleware/validate/convoAccess.js` - Solid storage support for conversation access validation
-- `api/server/middleware/buildEndpointOption.js` - Uses storage-agnostic `getConvo(req.user.id, conversationId, req)` to fill missing model (no Solid-specific logic)
-- `api/server/middleware/validateMessageReq.js` - Solid storage validation; no MongoDB fallback for Solid users (404 on Solid failure)
-- `api/server/socialLogins.js` - Solid configured from getSolidOpenIdProvidersForJwt(); configureSolidOpenIdFromProviders (session + solidJwt); registerSolidJwtFromProviders; ensureSolidJwtFromProvidersOnce
-- `api/server/routes/config.js` - `openidLoginEnabled: isOpenIdEnabled` only so Solid-only shows one button (per PR review)
-- `api/server/routes/messages.js` - Solid message reads return 503 on Solid failure (no MongoDB fallback)
-- `api/server/services/Endpoints/agents/initialize.js` - Enhanced model discovery from request body and endpointOption
-- `packages/data-provider/src/createPayload.ts` - Added normalization for Solid conversation objects and fallback handling
-- `api/server/services/SolidStorage.js` - Schema-aligned: `saveMessageToSolid` accepts full message document; `saveConvoToSolid` accepts full convo document, merges with existing Pod conversation to preserve title (and other fields) on partial updates
-- `api/server/utils/import/fork.js` - Added Solid storage support to `duplicateConversation` function
-- `api/server/routes/convos.js` - Updated duplicate and delete endpoints to pass `req` for Solid storage support
-- `api/server/services/SolidStorage.js` - Added `isArchived` field support in `saveConvoToSolid` and `getConvosByCursorFromSolid` for archive functionality
-- `api/server/services/SolidStorage.js` - Added share functionality: `setPublicAccessForShare`, `removePublicAccessForShare`, `getSharedMessagesFromSolid`, and ACL helper functions (`createPublicAcl`, `updateAclWithPublicAccess`, `grantPublicReadAccess`, `removePublicReadAccess`)
-- `packages/data-schemas/src/methods/share.ts` - Updated `createSharedLink`, `getSharedMessages`, `deleteSharedLink`, and `deleteConvoSharedLink` to support Solid storage; uses inline require() for SolidStorage/isSolidUser to avoid circular dependency with data-schemas
-- `packages/data-schemas/src/schema/share.ts` - Added `podUrl` field to `ISharedLink` schema
-- `packages/data-schemas/src/types/share.ts` - Added `podUrl` field to `ISharedLink` interface
-- `api/server/routes/share.js` - Updated share routes to pass `req` object for Solid storage support
-- `api/strategies/openidStrategy.js` - Generic OpenID strategy for non-Solid OpenID providers
-- `api/strategies/index.js` - Exported setupSolidOpenIdFromProvider, getSolidOpenIdConfig, verifySolidUser (dynamic flow; setupSolidOpenId deprecated)
-- `api/server/routes/config.js` - openidLoginEnabled: isOpenIdEnabled only; Solid config (solidLoginEnabled, solidLabel, solidImageUrl, solidAutoRedirect)
-- `client/src/components/Auth/SocialLoginRender.tsx` - Added Solid button component with SolidIcon
-- `packages/client/src/svgs/SolidIcon.tsx` - New Solid icon component for authentication UI
-- `packages/client/src/svgs/index.ts` - Exported SolidIcon
-- `packages/data-provider/src/config.ts` - Added Solid configuration fields to `TStartupConfig` type
-
-## Dependencies Added
-- `@inrupt/solid-client@^1.30.2` - Solid Pod client library
-
-## Environment Variables
-
-### Solid Authentication (SOLID_OPENID_*)
-Solid login is configured dynamically via `SOLID_OPENID_PROVIDERS` (JSON array of issuers). The following are used:
-
-- `SOLID_OPENID_PROVIDERS` - **Required.** JSON array; each item: `issuer`, `clientId`, optional `clientSecret`, `scope`, `label`
-- `SOLID_OPENID_CLIENT_ID` - Optional; used when your client_id document URL is not `DOMAIN_SERVER/solid-client-id`
-- `SOLID_OPENID_SESSION_SECRET` - Secret key for session management (recommended when using Solid)
-- `SOLID_OPENID_SCOPE` - Default scope (e.g. `"openid webid offline_access"`)
-- `SOLID_OPENID_CALLBACK_URL` - OAuth callback path (typically `/oauth/openid/callback`)
-
-### Optional Solid Configuration
-- `SOLID_OPENID_CUSTOM_CLIENT_ID` - Optional; when set, allows logging in with any allowed issuer (e.g. user picks "Local CSS" from modal) using this client id; used by getSolidOpenIdProviderByIssuer and getSolidOpenIdProvidersForJwt when SOLID_OPENID_PROVIDERS is empty
-- `SOLID_OPENID_BUTTON_LABEL` - Custom label for the Solid login button (default: "Continue with Solid")
-- `SOLID_OPENID_IMAGE_URL` - Custom icon URL for the Solid login button
-- `SOLID_OPENID_AUTO_REDIRECT` - Enable automatic redirect to Solid provider on login page
-
-### Generic OpenID Authentication (OPENID_*)
-The following environment variables are used for the generic "Login with OpenID" button:
-
-- `OPENID_CLIENT_ID` - OAuth client ID for generic OpenID authentication
-- `OPENID_CLIENT_SECRET` - OAuth client secret for generic OpenID authentication
-- `OPENID_ISSUER` - OpenID provider URL
-- `OPENID_SCOPE` - OAuth scopes
-- `OPENID_SESSION_SECRET` - Secret key for session management
-- `OPENID_CALLBACK_URL` - OAuth callback URL (typically `/oauth/openid/callback`)
-- `OPENID_BUTTON_LABEL` - Custom label for the OpenID login button (default: "Continue with OpenID")
-- `OPENID_IMAGE_URL` - Custom icon URL for the OpenID login button
-- `OPENID_AUTO_REDIRECT` - Enable automatic redirect to OpenID provider on login page
-
-### Solid Storage
-- Storage is chosen per user: **Solid Pod** for users who logged in with "Continue with Solid" (`provider === 'solid'`); **MongoDB** for everyone else. No environment variable is required.
-
-### Imports (top-level vs inline)
-- **API code** (Conversation.js, Message.js, buildEndpointOption.js, validateMessageReq.js, messages.js, convos.js, fork.js): SolidStorage and isSolidUser are required at **top level** for clarity and tooling (per PR review). buildEndpointOption.js now uses only `getConvo` from `~/models` (no SolidStorage/isSolidUser).
-- **packages/data-schemas share.ts**: SolidStorage and isSolidUser use **inline** `require()` inside the functions that need them, to avoid a circular dependency (data-schemas ← SolidStorage ← data-schemas for `logger`). Top-level require there caused `logger` to be undefined at load time and backend crash.
-
----
-
-**Report Date**: February 27, 2026
-
-

From e371f8fa3d96c90744388705c72a4fd372550d48 Mon Sep 17 00:00:00 2001
From: Precious_codes <Rukyjacob@gmail.com>
Date: Wed, 4 Mar 2026 08:58:12 +0000
Subject: [PATCH 94/94] Update api/server/services/Config/solidOpenId.js

Co-authored-by: Jesse Wright <63333554+jeswr@users.noreply.github.com>
---
 api/server/services/Config/solidOpenId.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/api/server/services/Config/solidOpenId.js b/api/server/services/Config/solidOpenId.js
index 57c39c412bee..6874ec2da00d 100644
--- a/api/server/services/Config/solidOpenId.js
+++ b/api/server/services/Config/solidOpenId.js
@@ -20,7 +20,6 @@ const KNOWN_ISSUER_LABELS = {
 
 /** Issuer URLs for the 3 default options shown in the login modal. */
 const DEFAULT_ISSUER_OPTIONS = [
-  { issuer: 'http://localhost:3000/', label: 'Local CSS' },
   { issuer: 'https://solidcommunity.net/', label: 'Solid Community' },
   { issuer: 'https://login.inrupt.com/', label: 'Inrupt' },
 ];