Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🔓 fix: Prevent 30-Second OpenID Refresh Stalls After a Discarded Prerender (#17174)
Ravi Kumar La7e6cc89f6ff
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.jsindex 1238190f15..654d0f0e62 100644--- a/api/server/controllers/AuthController.js+++ b/api/server/controllers/AuthController.js@@ -7,6 +7,7 @@ const {createResetPasswordController,createAuthIdentityContext,createOpenIDRefreshOwnershipError,+ createOpenIDResponseDelivery,isOpenIDRefreshOwnershipError,isOpenIDSessionMissingError,isOpenIDSessionIdentityMatch,@@ -46,12 +47,7 @@ const {refreshOpenIDUser,sendOpenIDAuthResponse,} = require('~/server/services/OpenIDRefreshRecovery');-const {- assertOpenIDRefreshFlightDeliveryAvailable,- assertOpenIDRefreshSessionGenerationAvailable,- claimOpenIDRefreshFlightDelivery,- releaseOpenIDRefreshFlightDelivery,-} = require('~/server/services/OpenIDRefreshFlight');+const OpenIDRefreshFlight = require('~/server/services/OpenIDRefreshFlight');const AUTH_REFRESH_USER_PROJECTION = '-password -__v -totpSecret -backupCodes -federatedTokens';/**@@ -201,88 +197,10 @@ const getReusableOpenIDSessionToken = (openidTokens) => {return null;};-const assertReusableOpenIDSessionGeneration = async (openidTokens) =>- assertOpenIDRefreshSessionGenerationAvailable({- key: openidTokens?.publicationFlightKey,- ownerId: openidTokens?.publicationFlightOwnerId,- });--/**- * Serializes response delivery for one durable OpenID publication generation. A logout that- * reaches the same flight either tombstones it before this claim or waits for the response to- * finish before returning. The send callback keeps the final authorization check adjacent to the- * synchronous Express write while allowing callers to do slow preparation under the lease.- */-const withOpenIDResponseDelivery = async ({ res, openidTokens, context }, operation) => {- let delivery;- let responseSent = false;- let releaseStarted = false;- let listenersArmed = false;- const releaseDelivery = async () => {- if (!delivery || releaseStarted) {- return;- }- releaseStarted = true;- for (let attempt = 1; attempt <= 3; attempt++) {- try {- await releaseOpenIDRefreshFlightDelivery(delivery);- return;- } catch (error) {- if (attempt === 3) {- logger.warn(`[${context}] Failed to release OpenID response delivery`, {- error: error instanceof Error ? error.message : error,- });- return;- }- await new Promise((resolve) => setTimeout(resolve, 25));- }- }- };-- try {- await assertReusableOpenIDSessionGeneration(openidTokens);- if (openidTokens?.publicationFlightKey && openidTokens?.publicationFlightOwnerId) {- const claimed = await claimOpenIDRefreshFlightDelivery({- key: openidTokens.publicationFlightKey,- ownerId: openidTokens.publicationFlightOwnerId,- createdAt: openidTokens.publicationFlightCreatedAt,- });- if (!claimed.deliveryId) {- throw new Error('OpenID response delivery claim returned no owner');- }- delivery = {- key: openidTokens.publicationFlightKey,- ownerId: openidTokens.publicationFlightOwnerId,- deliveryId: claimed.deliveryId,- };- }-- const sendAuthorized = async (send) => {- if (delivery) {- await assertOpenIDRefreshFlightDeliveryAvailable(delivery);- if (!listenersArmed && typeof res.once === 'function') {- listenersArmed = true;- res.once('finish', () => void releaseDelivery());- res.once('close', () => void releaseDelivery());- }- } else {- await assertReusableOpenIDSessionGeneration(openidTokens);- }- const response = send();- responseSent = true;- if (delivery && typeof res.once !== 'function') {- await releaseDelivery();- }- return response;- };-- return await operation(sendAuthorized);- } finally {- if (delivery && !responseSent) {- await releaseDelivery();- }- }-};+const withOpenIDResponseDelivery = createOpenIDResponseDelivery({+ flight: OpenIDRefreshFlight,+ logger,+});const resetPasswordRequestController = async (req, res) => {try {diff --git a/api/server/controllers/AuthController.spec.js b/api/server/controllers/AuthController.spec.jsindex 62b3307c6f..c64680993a 100644--- a/api/server/controllers/AuthController.spec.js+++ b/api/server/controllers/AuthController.spec.js@@ -126,6 +126,7 @@ jest.mock('@librechat/api', () => ({TOKEN_RETIREMENT_FIELDS: jest.requireActual('@librechat/api').TOKEN_RETIREMENT_FIELDS,}));+const http = require('node:http');const { createHash } = require('node:crypto');const openIdClient = require('openid-client');const jwt = require('jsonwebtoken');@@ -383,6 +384,80 @@ describe('graphTokenController', () => {});});+ describe('with a Node HTTP response', () => {+ let server;++ /** Resolves with the server response once the request arrives, optionally after the client disconnects. */+ const receiveResponse = ({ disconnect }) =>+ new Promise((resolve) => {+ const client = http.request({+ host: '127.0.0.1',+ port: server.address().port,+ method: 'POST',+ });+ client.on('error', () => {});+ server.once('request', (_incoming, response) => {+ response.json = (body) => response.end(JSON.stringify(body));+ if (!disconnect) {+ resolve(response);+ return;+ }+ response.once('close', () => resolve(response));+ client.destroy();+ });+ client.end();+ });++ beforeEach(async () => {+ req.user.federatedTokens.access_token = 'session-access-token';+ req.session = {+ openidTokens: {+ accessToken: 'session-access-token',+ appUserId: 'user-1',+ tenantId: 'tenant-1',+ publicationFlightKey: 'publication-key',+ publicationFlightOwnerId: 'publication-owner',+ publicationFlightCreatedAt: 1000,+ },+ };+ server = http.createServer();+ await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));+ });++ afterEach(async () => {+ server.closeAllConnections();+ await new Promise((resolve) => server.close(resolve));+ });++ it('releases the delivery lease when the client disconnected before delivery', async () => {+ const response = await receiveResponse({ disconnect: true });++ await graphTokenController(req, response);++ expect(response.closed).toBe(true);+ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith({+ key: 'publication-key',+ ownerId: 'publication-owner',+ deliveryId: 'delivery-1',+ });+ });++ it('holds the delivery lease until an open response finishes', async () => {+ const response = await receiveResponse({ disconnect: false });+ const finished = new Promise((resolve) => response.once('finish', resolve));++ await graphTokenController(req, response);+ await finished;++ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);+ expect(releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith({+ key: 'publication-key',+ ownerId: 'publication-owner',+ deliveryId: 'delivery-1',+ });+ });+ });+it('does not exchange a session-backed Graph token after logout tombstones its generation', async () => {req.user.federatedTokens.access_token = 'session-access-token';req.session = {diff --git a/client/src/hooks/AuthContext.tsx b/client/src/hooks/AuthContext.tsxindex 5974ab1913..7271c2281b 100644--- a/client/src/hooks/AuthContext.tsx+++ b/client/src/hooks/AuthContext.tsx@@ -71,6 +71,9 @@ const endSessionClientState = (): void => {endPullRequestSession();void clearTTSCache();};+/** `document.prerendering` is not yet part of TypeScript's DOM types. */+const isPrerendering = (): boolean =>+ (document as Document & { prerendering?: boolean }).prerendering === true;/*** Only recognized codes override the HTTP status used by the login error translation.*/@@ -89,6 +92,7 @@ const AuthContextProvider = ({children: ReactNode;}) => {const isExternalRedirectRef = useRef(false);+ const prerenderRefreshDeferredRef = useRef(false);const [user, setUser] = useRecoilState(store.user);const logoutRedirectRef = useRef<string | undefined>(undefined);const [token, setToken] = useState<string | undefined>(undefined);@@ -304,6 +308,15 @@ const AuthContextProvider = ({if (isExternalRedirectRef.current) {return;}+ /** A prerendered page can be discarded without ever being shown. Refreshing from it rotates+ * the session for a page the user never sees, and the browser aborts the request mid-flight. */+ if (isPrerendering()) {+ if (!prerenderRefreshDeferredRef.current) {+ prerenderRefreshDeferredRef.current = true;+ document.addEventListener('prerenderingchange', () => silentRefresh(), { once: true });+ }+ return;+ }refreshToken.mutate(undefined, {onSuccess: (data: t.TRefreshTokenResponse | undefined) => {if (isExternalRedirectRef.current) {diff --git a/client/src/hooks/__tests__/AuthContext.spec.tsx b/client/src/hooks/__tests__/AuthContext.spec.tsxindex 05a02bbd37..039fdd7271 100644--- a/client/src/hooks/__tests__/AuthContext.spec.tsx+++ b/client/src/hooks/__tests__/AuthContext.spec.tsx@@ -821,6 +821,33 @@ describe('AuthContextProvider — optional authentication', () => {});});+describe('AuthContextProvider — prerendered page', () => {+ const setPrerendering = (value: boolean) =>+ Object.defineProperty(document, 'prerendering', { configurable: true, value });++ beforeEach(() => {+ jest.clearAllMocks();+ setPrerendering(true);+ });++ afterEach(() => {+ delete (document as Document & { prerendering?: boolean }).prerendering;+ });++ it('defers the silent refresh until the prerendered page is shown', () => {+ renderProviderLive();++ expect(mockRefreshMutate).not.toHaveBeenCalled();++ setPrerendering(false);+ act(() => {+ document.dispatchEvent(new Event('prerenderingchange'));+ });++ expect(mockRefreshMutate).toHaveBeenCalledTimes(1);+ });+});+describe('AuthContextProvider — silentRefresh subdirectory deployment', () => {beforeEach(() => {jest.clearAllMocks();diff --git a/packages/api/src/auth/openid/delivery.spec.ts b/packages/api/src/auth/openid/delivery.spec.tsnew file mode 100644index 0000000000..9831d45ef9--- /dev/null+++ b/packages/api/src/auth/openid/delivery.spec.ts@@ -0,0 +1,102 @@+import { EventEmitter } from 'node:events';+import type { OpenIDDeliveryResponse } from './delivery';+import { createOpenIDResponseDelivery } from './delivery';++const tokens = {+ publicationFlightKey: 'flight-key',+ publicationFlightOwnerId: 'owner-1',+ publicationFlightCreatedAt: 1,+};+const delivery = { key: 'flight-key', ownerId: 'owner-1', deliveryId: 'delivery-1' };++function createFlight() {+ return {+ assertOpenIDRefreshSessionGenerationAvailable: jest.fn().mockResolvedValue(true),+ claimOpenIDRefreshFlightDelivery: jest.fn().mockResolvedValue({ deliveryId: 'delivery-1' }),+ assertOpenIDRefreshFlightDeliveryAvailable: jest.fn().mockResolvedValue(undefined),+ releaseOpenIDRefreshFlightDelivery: jest.fn().mockResolvedValue(undefined),+ };+}++function createResponse(closed = false): EventEmitter & OpenIDDeliveryResponse {+ return Object.assign(new EventEmitter(), { closed });+}++function setup() {+ const flight = createFlight();+ const logger = { warn: jest.fn() };+ const withDelivery = createOpenIDResponseDelivery({ flight, logger });+ return { flight, logger, withDelivery };+}++describe('createOpenIDResponseDelivery', () => {+ it('releases the lease after the send when the client already disconnected', async () => {+ const { flight, withDelivery } = setup();+ const res = createResponse(true);++ const result = await withDelivery({ res, openidTokens: tokens, context: 'test' }, (send) =>+ send(() => 'sent'),+ );++ expect(result).toBe('sent');+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);+ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledWith(delivery);+ expect(res.listenerCount('finish')).toBe(0);+ expect(res.listenerCount('close')).toBe(0);+ });++ it('releases the lease once when an open response finishes and closes', async () => {+ const { flight, withDelivery } = setup();+ const res = createResponse();++ await withDelivery({ res, openidTokens: tokens, context: 'test' }, (send) =>+ send(() => 'sent'),+ );+ expect(flight.releaseOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();++ res.emit('finish');+ res.emit('close');+ await new Promise(setImmediate);++ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);+ });++ it('releases the lease when the operation fails before sending', async () => {+ const { flight, withDelivery } = setup();++ await expect(+ withDelivery({ res: createResponse(), openidTokens: tokens, context: 'test' }, async () => {+ throw new Error('preparation failed');+ }),+ ).rejects.toThrow('preparation failed');++ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(1);+ });++ it('checks the session generation again at send time without a publication flight', async () => {+ const { flight, withDelivery } = setup();++ await withDelivery({ res: createResponse(), openidTokens: null, context: 'test' }, (send) =>+ send(() => 'sent'),+ );++ expect(flight.claimOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();+ expect(flight.assertOpenIDRefreshSessionGenerationAvailable).toHaveBeenCalledTimes(2);+ expect(flight.releaseOpenIDRefreshFlightDelivery).not.toHaveBeenCalled();+ });++ it('warns after the last failed release attempt', async () => {+ const { flight, logger, withDelivery } = setup();+ flight.releaseOpenIDRefreshFlightDelivery.mockRejectedValue(new Error('store unavailable'));++ await withDelivery(+ { res: createResponse(true), openidTokens: tokens, context: 'test' },+ (send) => send(() => 'sent'),+ );++ expect(flight.releaseOpenIDRefreshFlightDelivery).toHaveBeenCalledTimes(3);+ expect(logger.warn).toHaveBeenCalledWith('[test] Failed to release OpenID response delivery', {+ error: 'store unavailable',+ });+ });+});diff --git a/packages/api/src/auth/openid/delivery.ts b/packages/api/src/auth/openid/delivery.tsnew file mode 100644index 0000000000..4924831523--- /dev/null+++ b/packages/api/src/auth/openid/delivery.ts@@ -0,0 +1,128 @@+import type { OpenIDLogger, SessionOpenIDTokens } from './types';+import type { OpenIDRefreshFlightService } from './flight';++const RELEASE_ATTEMPTS = 3;+const RELEASE_RETRY_DELAY_MS = 25;++type DeliveryFlightService = Pick<+ OpenIDRefreshFlightService,+ | 'assertOpenIDRefreshSessionGenerationAvailable'+ | 'claimOpenIDRefreshFlightDelivery'+ | 'assertOpenIDRefreshFlightDeliveryAvailable'+ | 'releaseOpenIDRefreshFlightDelivery'+>;++/** The parts of an Express response that delivery tracking reads. */+export interface OpenIDDeliveryResponse {+ closed?: boolean;+ once?: (event: 'finish' | 'close', listener: () => void) => unknown;+}++type DeliveryTokens = Pick<+ SessionOpenIDTokens,+ 'publicationFlightKey' | 'publicationFlightOwnerId' | 'publicationFlightCreatedAt'+>;++export interface OpenIDResponseDeliveryInput {+ res: OpenIDDeliveryResponse;+ openidTokens?: DeliveryTokens | null;+ context: string;+}++/** Runs the final authorization check, then the synchronous write, under the delivery lease. */+export type SendAuthorized = <T>(send: () => T) => Promise<T>;++export interface OpenIDResponseDeliveryDeps {+ flight: DeliveryFlightService;+ logger: Pick<OpenIDLogger, 'warn'>;+}++/**+ * Serializes response delivery for one durable OpenID publication generation. A logout that+ * reaches the same flight either tombstones it before this claim or waits for the response to+ * finish before returning. The send callback keeps the final authorization check adjacent to the+ * synchronous Express write while allowing callers to do slow preparation under the lease.+ * A response whose client already disconnected never emits `finish` or `close` again, so its+ * lease is released directly after the send instead of through response listeners.+ */+export function createOpenIDResponseDelivery({ flight, logger }: OpenIDResponseDeliveryDeps) {+ const assertReusableSessionGeneration = (openidTokens?: DeliveryTokens | null) =>+ flight.assertOpenIDRefreshSessionGenerationAvailable({+ key: openidTokens?.publicationFlightKey,+ ownerId: openidTokens?.publicationFlightOwnerId,+ });++ return async function withOpenIDResponseDelivery<T>(+ { res, openidTokens, context }: OpenIDResponseDeliveryInput,+ operation: (sendAuthorized: SendAuthorized) => Promise<T>,+ ): Promise<T> {+ let delivery: { key: string; ownerId: string; deliveryId: string } | undefined;+ let responseSent = false;+ let releaseStarted = false;+ let listenersArmed = false;+ const releaseDelivery = async () => {+ if (!delivery || releaseStarted) {+ return;+ }+ releaseStarted = true;+ for (let attempt = 1; attempt <= RELEASE_ATTEMPTS; attempt++) {+ try {+ await flight.releaseOpenIDRefreshFlightDelivery(delivery);+ return;+ } catch (error) {+ if (attempt === RELEASE_ATTEMPTS) {+ logger.warn(`[${context}] Failed to release OpenID response delivery`, {+ error: error instanceof Error ? error.message : error,+ });+ return;+ }+ await new Promise((resolve) => setTimeout(resolve, RELEASE_RETRY_DELAY_MS));+ }+ }+ };++ try {+ await assertReusableSessionGeneration(openidTokens);+ if (openidTokens?.publicationFlightKey && openidTokens?.publicationFlightOwnerId) {+ const claimed = await flight.claimOpenIDRefreshFlightDelivery({+ key: openidTokens.publicationFlightKey,+ ownerId: openidTokens.publicationFlightOwnerId,+ createdAt: openidTokens.publicationFlightCreatedAt,+ });+ if (!claimed.deliveryId) {+ throw new Error('OpenID response delivery claim returned no owner');+ }+ delivery = {+ key: openidTokens.publicationFlightKey,+ ownerId: openidTokens.publicationFlightOwnerId,+ deliveryId: claimed.deliveryId,+ };+ }++ const sendAuthorized: SendAuthorized = async (send) => {+ if (delivery) {+ await flight.assertOpenIDRefreshFlightDeliveryAvailable(delivery);+ if (!listenersArmed && typeof res.once === 'function' && !res.closed) {+ listenersArmed = true;+ res.once('finish', () => void releaseDelivery());+ res.once('close', () => void releaseDelivery());+ }+ } else {+ await assertReusableSessionGeneration(openidTokens);+ }+ const response = send();+ responseSent = true;+ if (delivery && !listenersArmed) {+ await releaseDelivery();+ }+ return response;+ };++ return await operation(sendAuthorized);+ } finally {+ if (delivery && !responseSent) {+ await releaseDelivery();+ }+ }+ };+}diff --git a/packages/api/src/auth/openid/index.ts b/packages/api/src/auth/openid/index.tsindex f231be88d0..cd31077cb2 100644--- a/packages/api/src/auth/openid/index.ts+++ b/packages/api/src/auth/openid/index.ts@@ -1,5 +1,6 @@export * from './errors';export * from './flight';+export * from './delivery';export * from './bridge';export * from './recovery';export * from './session';