Skip to content

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

🧦 fix: Restore OpenID Refresh After the Session Store TTL Expires (#15983)

lia-by-librechat[bot]35d5a70b212f
diff --git a/api/server/controllers/AuthController.spec.js b/api/server/controllers/AuthController.spec.js
index 2f4b6985bc..e0f0892bf1 100644
--- a/api/server/controllers/AuthController.spec.js
+++ b/api/server/controllers/AuthController.spec.js
@@ -856,17 +856,15 @@ describe('refreshController – OpenID path', () => {
expect(res.status).toHaveBeenCalledWith(403);
});
- it('requires sign-in without publishing tokens when the persisted session disappeared', async () => {
+ it('refreshes with the cookie token when the persisted session expired', async () => {
req.session.reload = jest.fn((callback) => callback(new Error('failed to load session')));
await refreshController(req, res);
- expect(clearOpenIDAuthTokens).toHaveBeenCalled();
- expect(res.status).toHaveBeenCalledWith(401);
- expect(res.send).toHaveBeenCalledWith({ code: 'OPENID_SESSION_MISSING' });
- expect(setOpenIDAuthTokens).not.toHaveBeenCalled();
- expect(storeOpenIDSession).not.toHaveBeenCalled();
- expect(getRefreshTokenBridge).not.toHaveBeenCalled();
+ expect(clearOpenIDAuthTokens).not.toHaveBeenCalled();
+ expect(setOpenIDAuthTokens).toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(200);
+ expect(res.send).not.toHaveBeenCalledWith({ code: 'OPENID_SESSION_MISSING' });
});
it('does not classify a session store outage as a missing session', async () => {
diff --git a/packages/api/src/auth/openid/errors.spec.ts b/packages/api/src/auth/openid/errors.spec.ts
index 2cf196d209..d1b6ba4860 100644
--- a/packages/api/src/auth/openid/errors.spec.ts
+++ b/packages/api/src/auth/openid/errors.spec.ts
@@ -1,4 +1,4 @@
-import { isOpenIDSessionMissingError } from './errors';
+import { isOpenIDSessionMissingError, reloadOpenIDSessionIfPersisted } from './errors';
describe('isOpenIDSessionMissingError', () => {
it('recognizes the express-session missing record error', () => {
@@ -14,3 +14,35 @@ describe('isOpenIDSessionMissingError', () => {
expect(isOpenIDSessionMissingError(error)).toBe(false),
);
});
+
+describe('reloadOpenIDSessionIfPersisted', () => {
+ it('reports a persisted session that reloaded', async () => {
+ await expect(
+ reloadOpenIDSessionIfPersisted({
+ reload: (callback: (error?: Error | null) => void) => callback(null),
+ }),
+ ).resolves.toBe(true);
+ });
+
+ it('reports an absent record instead of failing the refresh', async () => {
+ await expect(
+ reloadOpenIDSessionIfPersisted({
+ reload: (callback: (error?: Error | null) => void) =>
+ callback(new Error('failed to load session')),
+ }),
+ ).resolves.toBe(false);
+ });
+
+ it('propagates a session store outage', async () => {
+ const error = new Error('connection unavailable');
+ await expect(
+ reloadOpenIDSessionIfPersisted({
+ reload: (callback: (error?: Error | null) => void) => callback(error),
+ }),
+ ).rejects.toBe(error);
+ });
+
+ it('reports a request without a reloadable session', async () => {
+ await expect(reloadOpenIDSessionIfPersisted(undefined)).resolves.toBe(false);
+ });
+});
diff --git a/packages/api/src/auth/openid/errors.ts b/packages/api/src/auth/openid/errors.ts
index f4844e9fc2..7de34b29b1 100644
--- a/packages/api/src/auth/openid/errors.ts
+++ b/packages/api/src/auth/openid/errors.ts
@@ -8,6 +8,39 @@ export function isOpenIDSessionMissingError(error: unknown): boolean {
return error instanceof Error && error.message === 'failed to load session';
}
+/**
+ * Reloads the persisted Express session before a publication decision. express-session rejects with
+ * `failed to load session` when the record is merely absent — the session-store TTL elapsed, the
+ * entry was evicted, or a logout in another replica removed it — which describes an empty session
+ * rather than one that advanced past this result. Tolerate that case so a refresh backed by a
+ * still-valid refresh token seeds a new record instead of demanding an interactive sign-in, and let
+ * every other store failure (an outage) propagate to the caller.
+ *
+ * Logout safety does not depend on this record: `revokeOpenIDRefreshTokenChain` writes a durable
+ * revoked publication flight for every refresh token it retires, so a retired token still fails.
+ *
+ * @returns `true` when the persisted record was read, `false` when it was gone.
+ */
+export async function reloadOpenIDSessionIfPersisted(
+ session?: { reload?: (callback: (error?: Error | null) => void) => void } | null,
+): Promise<boolean> {
+ if (typeof session?.reload !== 'function') {
+ return false;
+ }
+ const reload = session.reload.bind(session);
+ try {
+ await new Promise<void>((resolve, reject) => {
+ reload((error?: Error | null) => (error ? reject(error) : resolve()));
+ });
+ return true;
+ } catch (error) {
+ if (isOpenIDSessionMissingError(error)) {
+ return false;
+ }
+ throw error;
+ }
+}
+
export function toOpenIDLogArgument(error: unknown): LogArgument {
return error instanceof Error ? error : String(error);
}
diff --git a/packages/api/src/auth/openid/recovery.spec.ts b/packages/api/src/auth/openid/recovery.spec.ts
index ba512edb0b..124e3da7e8 100644
--- a/packages/api/src/auth/openid/recovery.spec.ts
+++ b/packages/api/src/auth/openid/recovery.spec.ts
@@ -51,17 +51,52 @@ describe('OpenID authentication publication settlement', () => {
return { deps, service, input };
}
- it('settles a missing-session failure immediately and preserves the original error', async () => {
+ /** A session whose persisted record is gone: the store TTL elapsed, or an eviction removed it. */
+ function missingSessionRequest() {
+ return {
+ session: {
+ reload: (callback: (error: Error) => void) => callback(new Error('failed to load session')),
+ save: (callback: (error?: Error | null) => void) => callback(null),
+ },
+ };
+ }
+
+ it('publishes into a new session when the persisted record expired', async () => {
const { deps, service, input } = setup();
- const error = new Error('failed to load session');
- const req = { session: { reload: (callback: (error: Error) => void) => callback(error) } };
- await expect(service.sendOpenIDAuthResponse({ ...input, req })).rejects.toBe(error);
- expect(deps.failOpenIDRefreshFlight).toHaveBeenCalledWith({
- key: 'publication',
- ownerId: 'owner',
- error,
- });
+ await expect(
+ service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+ ).resolves.toBe('app-token');
+ expect(deps.completeOpenIDRefreshFlight).toHaveBeenCalledTimes(1);
+ expect(deps.failOpenIDRefreshFlight).not.toHaveBeenCalled();
+ });
+
+ /**
+ * Tolerating an absent record leaves the durable revoked publication flight as the only fence
+ * against resurrecting a logged-out session, so both of its checks are pinned here: the
+ * tombstone read that precedes the reload, and the completion that follows it.
+ */
+ it('refuses a revoked generation before reloading the expired session', async () => {
+ const { deps, service, input } = setup();
+ deps.acquireOpenIDRefreshFlight.mockResolvedValue({ acquired: false, ownerId: 'other' });
+ deps.waitForOpenIDRefreshFlight.mockRejectedValue(
+ new Error('OpenID refresh was revoked by logout'),
+ );
+ await expect(
+ service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+ ).rejects.toThrow('revoked by logout');
expect(deps.completeOpenIDRefreshFlight).not.toHaveBeenCalled();
+ expect(deps.setOpenIDAuthTokens).not.toHaveBeenCalled();
+ });
+
+ it('withholds tokens when logout revokes the flight after the expired session reloaded', async () => {
+ const { deps, service, input } = setup();
+ deps.completeOpenIDRefreshFlight.mockResolvedValue(null);
+ await expect(
+ service.sendOpenIDAuthResponse({ ...input, req: missingSessionRequest() }),
+ ).rejects.toThrow('revoked before completion');
+ expect(deps.setOpenIDAuthTokens).not.toHaveBeenCalled();
+ expect(deps.deleteOpenIDSession).toHaveBeenCalledWith('refresh');
+ expect(deps.clearOpenIDAuthTokens).toHaveBeenCalled();
});
it('preserves the request error when failure settlement also fails', async () => {
diff --git a/packages/api/src/auth/openid/recovery.ts b/packages/api/src/auth/openid/recovery.ts
index baa61a5738..1413bcf93d 100644
--- a/packages/api/src/auth/openid/recovery.ts
+++ b/packages/api/src/auth/openid/recovery.ts
@@ -22,6 +22,7 @@ import type { TokenResult } from './flight';
import {
createOpenIDRefreshOwnershipError,
isOpenIDRefreshOwnershipError,
+ reloadOpenIDSessionIfPersisted,
toOpenIDLogArgument,
} from './errors';
@@ -800,12 +801,7 @@ export function createOpenIDRefreshRecoveryService(
if (assertLeaseOwned) {
await assertLeaseOwned();
}
- if (typeof req?.session?.reload === 'function') {
- const reload = req.session.reload.bind(req.session);
- await new Promise<void>((resolve, reject) => {
- reload((error?: Error | null) => (error ? reject(error) : resolve()));
- });
- }
+ await reloadOpenIDSessionIfPersisted(req?.session);
if (discardSessionTokens && req?.session?.openidTokens) {
delete req.session.openidTokens;
}
diff --git a/packages/api/src/auth/openid/session.ts b/packages/api/src/auth/openid/session.ts
index 6782bbb45b..28cbb8c383 100644
--- a/packages/api/src/auth/openid/session.ts
+++ b/packages/api/src/auth/openid/session.ts
@@ -28,6 +28,7 @@ import {
OPENID_REFRESH_CANCELLED_BEFORE_GRANT,
createOpenIDRefreshOwnershipError,
isOpenIDRefreshOwnershipError,
+ reloadOpenIDSessionIfPersisted,
toOpenIDLogArgument,
} from './errors';
@@ -1239,12 +1240,7 @@ export function createOpenIDSessionRefreshService(
}): Promise<MarkedOIDCTokens | null> {
if (!resolvedTokens?.access_token) return null;
if (assertLeaseOwned) await assertLeaseOwned();
- if (typeof req.session?.reload === 'function') {
- const reload = req.session.reload.bind(req.session);
- await new Promise<void>((resolve, reject) => {
- reload((error?: Error | null) => (error ? reject(error) : resolve()));
- });
- }
+ await reloadOpenIDSessionIfPersisted(req.session);
if (assertLeaseOwned) await assertLeaseOwned();
const requestTokens = cloneResolvedTokens(resolvedTokens);
if (
@@ -1778,11 +1774,8 @@ export function createOpenIDSessionRefreshService(
if (!req?.session || !resolvedTokens?.access_token) {
return false;
}
- if (reloadSession && typeof req.session.reload === 'function') {
- const reload = req.session.reload.bind(req.session);
- await new Promise<void>((resolve, reject) => {
- reload((error?: Error | null) => (error ? reject(error) : resolve()));
- });
+ if (reloadSession) {
+ await reloadOpenIDSessionIfPersisted(req.session);
}
const existing = req.session.openidTokens ?? {};
const generationDiffers = Boolean(