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: Complete OIDC RP-Initiated Logout With id_token_hint and Redirect Race Fix (#12024)
Danny Avilab18915a96b2f
diff --git a/api/server/controllers/auth/LogoutController.js b/api/server/controllers/auth/LogoutController.jsindex 0b3cf262b8..039ed630c2 100644--- a/api/server/controllers/auth/LogoutController.js+++ b/api/server/controllers/auth/LogoutController.js@@ -8,13 +8,16 @@ 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';- /** For OpenID users, read refresh token from session; for others, use cookie */+ /** For OpenID users, read tokens from session (with cookie fallback) */let refreshToken;+ let idToken;if (isOpenIdUser && req.session?.openidTokens) {refreshToken = req.session.openidTokens.refreshToken;+ idToken = req.session.openidTokens.idToken;delete req.session.openidTokens;}refreshToken = refreshToken || parsedCookies.refreshToken;+ idToken = idToken || parsedCookies.openid_id_token;try {const logout = await logoutUser(req, refreshToken);@@ -31,21 +34,34 @@ const logoutController = async (req, res) => {isEnabled(process.env.OPENID_USE_END_SESSION_ENDPOINT) &&process.env.OPENID_ISSUER) {- const openIdConfig = getOpenIdConfig();- if (!openIdConfig) {- logger.warn(- '[logoutController] OpenID config not found. Please verify that the open id configuration and initialization are correct.',- );- } else {- const endSessionEndpoint = openIdConfig- ? openIdConfig.serverMetadata().end_session_endpoint- : null;+ let openIdConfig;+ try {+ openIdConfig = getOpenIdConfig();+ } catch (err) {+ logger.warn('[logoutController] OpenID config not available:', err.message);+ }+ if (openIdConfig) {+ const endSessionEndpoint = openIdConfig.serverMetadata().end_session_endpoint;if (endSessionEndpoint) {const endSessionUrl = new URL(endSessionEndpoint);/** Redirect back to app's login page after IdP logout */const postLogoutRedirectUri =process.env.OPENID_POST_LOGOUT_REDIRECT_URI || `${process.env.DOMAIN_CLIENT}/login`;endSessionUrl.searchParams.set('post_logout_redirect_uri', postLogoutRedirectUri);++ /** Add id_token_hint (preferred) or client_id for OIDC spec compliance */+ if (idToken) {+ endSessionUrl.searchParams.set('id_token_hint', idToken);+ } else if (process.env.OPENID_CLIENT_ID) {+ endSessionUrl.searchParams.set('client_id', process.env.OPENID_CLIENT_ID);+ } else {+ logger.warn(+ '[logoutController] Neither id_token_hint nor OPENID_CLIENT_ID is available. ' ++ 'To enable id_token_hint, set OPENID_REUSE_TOKENS=true. ' ++ 'The OIDC end-session request may be rejected by the identity provider.',+ );+ }+response.redirect = endSessionUrl.toString();} else {logger.warn(diff --git a/api/server/controllers/auth/LogoutController.spec.js b/api/server/controllers/auth/LogoutController.spec.jsnew file mode 100644index 0000000000..3f2a2de8e1--- /dev/null+++ b/api/server/controllers/auth/LogoutController.spec.js@@ -0,0 +1,259 @@+const cookies = require('cookie');++const mockLogoutUser = jest.fn();+const mockLogger = { warn: jest.fn(), error: jest.fn() };+const mockIsEnabled = jest.fn();+const mockGetOpenIdConfig = jest.fn();++jest.mock('cookie');+jest.mock('@librechat/api', () => ({ isEnabled: (...args) => mockIsEnabled(...args) }));+jest.mock('@librechat/data-schemas', () => ({ logger: mockLogger }));+jest.mock('~/server/services/AuthService', () => ({+ logoutUser: (...args) => mockLogoutUser(...args),+}));+jest.mock('~/strategies', () => ({ getOpenIdConfig: () => mockGetOpenIdConfig() }));++const { logoutController } = require('./LogoutController');++function buildReq(overrides = {}) {+ return {+ user: { _id: 'user1', openidId: 'oid1', provider: 'openid' },+ headers: { cookie: 'refreshToken=rt1' },+ session: {+ openidTokens: { refreshToken: 'srt', idToken: 'small-id-token' },+ destroy: jest.fn(),+ },+ ...overrides,+ };+}++function buildRes() {+ const res = {+ status: jest.fn().mockReturnThis(),+ send: jest.fn().mockReturnThis(),+ json: jest.fn().mockReturnThis(),+ clearCookie: jest.fn(),+ };+ return res;+}++const ORIGINAL_ENV = process.env;++beforeEach(() => {+ jest.clearAllMocks();+ process.env = {+ ...ORIGINAL_ENV,+ OPENID_USE_END_SESSION_ENDPOINT: 'true',+ OPENID_ISSUER: 'https://idp.example.com',+ OPENID_CLIENT_ID: 'my-client-id',+ DOMAIN_CLIENT: 'https://app.example.com',+ };+ cookies.parse.mockReturnValue({ refreshToken: 'cookie-rt' });+ mockLogoutUser.mockResolvedValue({ status: 200, message: 'Logout successful' });+ mockIsEnabled.mockReturnValue(true);+ mockGetOpenIdConfig.mockReturnValue({+ serverMetadata: () => ({+ end_session_endpoint: 'https://idp.example.com/logout',+ }),+ });+});++afterAll(() => {+ process.env = ORIGINAL_ENV;+});++describe('LogoutController', () => {+ describe('id_token_hint from session', () => {+ it('sets id_token_hint when session has idToken', async () => {+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toContain('id_token_hint=small-id-token');+ expect(body.redirect).not.toContain('client_id=');+ });+ });++ describe('id_token_hint from cookie fallback', () => {+ it('uses cookie id_token when session has no tokens', async () => {+ cookies.parse.mockReturnValue({+ refreshToken: 'cookie-rt',+ openid_id_token: 'cookie-id-token',+ });+ const req = buildReq({ session: { destroy: jest.fn() } });+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toContain('id_token_hint=cookie-id-token');+ });+ });++ describe('client_id fallback', () => {+ it('falls back to client_id when no idToken is available', async () => {+ cookies.parse.mockReturnValue({ refreshToken: 'cookie-rt' });+ const req = buildReq({ session: { destroy: jest.fn() } });+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toContain('client_id=my-client-id');+ expect(body.redirect).not.toContain('id_token_hint=');+ });++ it('does not produce client_id=undefined when OPENID_CLIENT_ID is unset', async () => {+ delete process.env.OPENID_CLIENT_ID;+ cookies.parse.mockReturnValue({ refreshToken: 'cookie-rt' });+ const req = buildReq({ session: { destroy: jest.fn() } });+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).not.toContain('client_id=');+ expect(body.redirect).not.toContain('undefined');+ expect(mockLogger.warn).toHaveBeenCalledWith(+ expect.stringContaining('Neither id_token_hint nor OPENID_CLIENT_ID'),+ );+ });+ });++ describe('OPENID_USE_END_SESSION_ENDPOINT disabled', () => {+ it('does not include redirect when disabled', async () => {+ mockIsEnabled.mockReturnValue(false);+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toBeUndefined();+ });+ });++ describe('OPENID_ISSUER unset', () => {+ it('does not include redirect when OPENID_ISSUER is missing', async () => {+ delete process.env.OPENID_ISSUER;+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toBeUndefined();+ });+ });++ describe('non-OpenID user', () => {+ it('does not include redirect for non-OpenID users', async () => {+ const req = buildReq({+ user: { _id: 'user1', provider: 'local' },+ });+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toBeUndefined();+ });+ });++ describe('post_logout_redirect_uri', () => {+ it('uses OPENID_POST_LOGOUT_REDIRECT_URI when set', async () => {+ process.env.OPENID_POST_LOGOUT_REDIRECT_URI = 'https://custom.example.com/logged-out';+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ const url = new URL(body.redirect);+ expect(url.searchParams.get('post_logout_redirect_uri')).toBe(+ 'https://custom.example.com/logged-out',+ );+ });++ it('defaults to DOMAIN_CLIENT/login when OPENID_POST_LOGOUT_REDIRECT_URI is unset', async () => {+ delete process.env.OPENID_POST_LOGOUT_REDIRECT_URI;+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ const url = new URL(body.redirect);+ expect(url.searchParams.get('post_logout_redirect_uri')).toBe(+ 'https://app.example.com/login',+ );+ });+ });++ describe('OpenID config not available', () => {+ it('warns and returns no redirect when getOpenIdConfig throws', async () => {+ mockGetOpenIdConfig.mockImplementation(() => {+ throw new Error('OpenID configuration has not been initialized');+ });+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toBeUndefined();+ expect(mockLogger.warn).toHaveBeenCalledWith(+ expect.stringContaining('OpenID config not available'),+ 'OpenID configuration has not been initialized',+ );+ });+ });++ describe('end_session_endpoint not in metadata', () => {+ it('warns and returns no redirect when end_session_endpoint is missing', async () => {+ mockGetOpenIdConfig.mockReturnValue({+ serverMetadata: () => ({}),+ });+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ const body = res.send.mock.calls[0][0];+ expect(body.redirect).toBeUndefined();+ expect(mockLogger.warn).toHaveBeenCalledWith(+ expect.stringContaining('end_session_endpoint not found'),+ );+ });+ });++ describe('error handling', () => {+ it('returns 500 on logoutUser error', async () => {+ mockLogoutUser.mockRejectedValue(new Error('session error'));+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ expect(res.status).toHaveBeenCalledWith(500);+ expect(res.json).toHaveBeenCalledWith({ message: 'session error' });+ });+ });++ describe('cookie clearing', () => {+ it('clears all auth cookies on successful logout', async () => {+ const req = buildReq();+ const res = buildRes();++ await logoutController(req, res);++ expect(res.clearCookie).toHaveBeenCalledWith('refreshToken');+ expect(res.clearCookie).toHaveBeenCalledWith('openid_access_token');+ expect(res.clearCookie).toHaveBeenCalledWith('openid_id_token');+ expect(res.clearCookie).toHaveBeenCalledWith('openid_user_id');+ expect(res.clearCookie).toHaveBeenCalledWith('token_provider');+ });+ });+});diff --git a/client/src/hooks/AuthContext.tsx b/client/src/hooks/AuthContext.tsxindex 86f80cde6b..ca82e10f8f 100644--- a/client/src/hooks/AuthContext.tsx+++ b/client/src/hooks/AuthContext.tsx@@ -34,11 +34,12 @@ const AuthContextProvider = ({authConfig?: TAuthConfig;children: ReactNode;}) => {+ const isExternalRedirectRef = useRef(false);const [user, setUser] = useRecoilState(store.user);+ const logoutRedirectRef = useRef<string | undefined>(undefined);const [token, setToken] = useState<string | undefined>(undefined);const [error, setError] = useState<string | undefined>(undefined);const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false);- const logoutRedirectRef = useRef<string | undefined>(undefined);const { data: userRole = null } = useGetRole(SystemRoles.USER, {enabled: !!(isAuthenticated && (user?.role ?? '')),@@ -55,7 +56,6 @@ const AuthContextProvider = ({const { token, isAuthenticated, user, redirect } = userContext;setUser(user);setToken(token);- //@ts-ignore - ok for token to be undefined initiallysetTokenHeader(token);setIsAuthenticated(isAuthenticated);@@ -106,11 +106,21 @@ const AuthContextProvider = ({});const logoutUser = useLogoutUserMutation({onSuccess: (data) => {+ if (data.redirect) {+ /** data.redirect is the IdP's end_session_endpoint URL — an absolute URL generated+ * server-side from trusted IdP metadata (not user input), so isSafeRedirect is bypassed.+ * setUserContext is debounced (50ms) and won't fire before page unload, so clear the+ * axios Authorization header synchronously to prevent in-flight requests. */+ isExternalRedirectRef.current = true;+ setTokenHeader(undefined);+ window.location.replace(data.redirect);+ return;+ }setUserContext({token: undefined,isAuthenticated: false,user: undefined,- redirect: data.redirect ?? '/login',+ redirect: '/login',});},onError: (error) => {@@ -146,8 +156,14 @@ const AuthContextProvider = ({console.log('Test mode. Skipping silent refresh.');return;}+ if (isExternalRedirectRef.current) {+ return;+ }refreshToken.mutate(undefined, {onSuccess: (data: t.TRefreshTokenResponse | undefined) => {+ if (isExternalRedirectRef.current) {+ return;+ }const { user, token = '' } = data ?? {};if (token) {setUserContext({ token, isAuthenticated: true, user });@@ -160,6 +176,9 @@ const AuthContextProvider = ({navigate(buildLoginRedirectUrl());},onError: (error) => {+ if (isExternalRedirectRef.current) {+ return;+ }console.log('refreshToken mutation error:', error);if (authConfig?.test === true) {return;@@ -171,6 +190,9 @@ const AuthContextProvider = ({}, []);useEffect(() => {+ if (isExternalRedirectRef.current) {+ return;+ }if (userQuery.data) {setUser(userQuery.data);} else if (userQuery.isError) {diff --git a/client/src/hooks/__tests__/AuthContext.spec.tsx b/client/src/hooks/__tests__/AuthContext.spec.tsxindex 5a24a31ec4..20af37e3f2 100644--- a/client/src/hooks/__tests__/AuthContext.spec.tsx+++ b/client/src/hooks/__tests__/AuthContext.spec.tsx@@ -24,6 +24,13 @@ let mockCapturedLoginOptions: {onError: (...args: unknown[]) => void;};+let mockCapturedLogoutOptions: {+ onSuccess: (...args: unknown[]) => void;+ onError: (...args: unknown[]) => void;+};++const mockRefreshMutate = jest.fn();+jest.mock('~/data-provider', () => ({useLoginUserMutation: jest.fn((options: {@@ -34,8 +41,16 @@ jest.mock('~/data-provider', () => ({return { mutate: jest.fn() };},),- useLogoutUserMutation: jest.fn(() => ({ mutate: jest.fn() })),- useRefreshTokenMutation: jest.fn(() => ({ mutate: jest.fn() })),+ useLogoutUserMutation: jest.fn(+ (options: {+ onSuccess: (...args: unknown[]) => void;+ onError: (...args: unknown[]) => void;+ }) => {+ mockCapturedLogoutOptions = options;+ return { mutate: jest.fn() };+ },+ ),+ useRefreshTokenMutation: jest.fn(() => ({ mutate: mockRefreshMutate })),useGetUserQuery: jest.fn(() => ({data: undefined,isError: false,@@ -69,6 +84,25 @@ function renderProvider() {);}+/** Renders without test:true so silentRefresh actually runs */+function renderProviderLive() {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },+ });++ return render(+ <QueryClientProvider client={queryClient}>+ <RecoilRoot>+ <MemoryRouter>+ <AuthContextProvider authConfig={{ loginRedirect: '/login' }}>+ <TestConsumer />+ </AuthContextProvider>+ </MemoryRouter>+ </RecoilRoot>+ </QueryClientProvider>,+ );+}+describe('AuthContextProvider — login onError redirect handling', () => {const originalLocation = window.location;@@ -172,3 +206,88 @@ describe('AuthContextProvider — login onError redirect handling', () => {expect(decodeURIComponent(params.get('redirect_to')!)).toBe(target);});});++describe('AuthContextProvider — logout onSuccess/onError handling', () => {+ const originalLocation = window.location;+ const mockSetTokenHeader = jest.requireMock('librechat-data-provider').setTokenHeader;++ beforeEach(() => {+ jest.clearAllMocks();+ Object.defineProperty(window, 'location', {+ value: {+ ...originalLocation,+ pathname: '/c/some-chat',+ search: '',+ hash: '',+ replace: jest.fn(),+ },+ writable: true,+ configurable: true,+ });+ });++ afterEach(() => {+ Object.defineProperty(window, 'location', {+ value: originalLocation,+ writable: true,+ configurable: true,+ });+ });++ it('calls window.location.replace and setTokenHeader(undefined) when redirect is present', () => {+ renderProvider();++ act(() => {+ mockCapturedLogoutOptions.onSuccess({+ message: 'Logout successful',+ redirect: 'https://idp.example.com/logout?id_token_hint=abc',+ });+ });++ expect(window.location.replace).toHaveBeenCalledWith(+ 'https://idp.example.com/logout?id_token_hint=abc',+ );+ expect(mockSetTokenHeader).toHaveBeenCalledWith(undefined);+ });++ it('does not call window.location.replace when redirect is absent', async () => {+ renderProvider();++ act(() => {+ mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' });+ });++ expect(window.location.replace).not.toHaveBeenCalled();+ });++ it('does not trigger silentRefresh after OIDC redirect', () => {+ renderProviderLive();+ mockRefreshMutate.mockClear();++ act(() => {+ mockCapturedLogoutOptions.onSuccess({+ message: 'Logout successful',+ redirect: 'https://idp.example.com/logout?id_token_hint=abc',+ });+ });++ expect(window.location.replace).toHaveBeenCalled();+ expect(mockRefreshMutate).not.toHaveBeenCalled();+ });++ it('clears auth state on logout error without external redirect', () => {+ jest.useFakeTimers();+ const { getByTestId } = renderProvider();++ act(() => {+ mockCapturedLogoutOptions.onError(new Error('Logout failed'));+ });+ act(() => {+ jest.advanceTimersByTime(100);+ });++ expect(window.location.replace).not.toHaveBeenCalled();+ expect(getByTestId('consumer').getAttribute('data-authenticated')).toBe('false');+ jest.useRealTimers();+ });+});diff --git a/packages/data-provider/specs/headers-helpers.spec.ts b/packages/data-provider/specs/headers-helpers.spec.tsnew file mode 100644index 0000000000..4df7a2f934--- /dev/null+++ b/packages/data-provider/specs/headers-helpers.spec.ts@@ -0,0 +1,24 @@+import axios from 'axios';+import { setTokenHeader } from '../src/headers-helpers';++describe('setTokenHeader', () => {+ afterEach(() => {+ delete axios.defaults.headers.common['Authorization'];+ });++ it('sets the Authorization header with a Bearer token', () => {+ setTokenHeader('my-token');+ expect(axios.defaults.headers.common['Authorization']).toBe('Bearer my-token');+ });++ it('deletes the Authorization header when called with undefined', () => {+ axios.defaults.headers.common['Authorization'] = 'Bearer old-token';+ setTokenHeader(undefined);+ expect(axios.defaults.headers.common['Authorization']).toBeUndefined();+ });++ it('is a no-op when clearing an already absent header', () => {+ setTokenHeader(undefined);+ expect(axios.defaults.headers.common['Authorization']).toBeUndefined();+ });+});diff --git a/packages/data-provider/specs/request-interceptor.spec.ts b/packages/data-provider/specs/request-interceptor.spec.tsnew file mode 100644index 0000000000..872f2a9f67--- /dev/null+++ b/packages/data-provider/specs/request-interceptor.spec.ts@@ -0,0 +1,102 @@+/**+ * @jest-environment jsdom+ */+import axios from 'axios';+import { setTokenHeader } from '../src/headers-helpers';++/**+ * The response interceptor in request.ts registers at import time when+ * `typeof window !== 'undefined'` (jsdom provides window).+ *+ * We use axios's built-in request adapter mock to avoid real HTTP calls,+ * and verify the interceptor's behavior by observing whether a 401 triggers+ * a refresh POST or is immediately rejected.+ */++/** Mock the axios adapter to simulate responses without HTTP */+const mockAdapter = jest.fn();+let originalAdapter: typeof axios.defaults.adapter;++beforeAll(async () => {+ originalAdapter = axios.defaults.adapter;+ axios.defaults.adapter = mockAdapter;++ /** Import triggers interceptor registration */+ await import('../src/request');+});++beforeEach(() => {+ mockAdapter.mockReset();+});++afterAll(() => {+ axios.defaults.adapter = originalAdapter;+});++afterEach(() => {+ delete axios.defaults.headers.common['Authorization'];+});++describe('axios 401 interceptor — Authorization header guard', () => {+ it('skips refresh and rejects when Authorization header is cleared', async () => {+ /** Simulate a cleared header (as done by setTokenHeader(undefined) during logout) */+ setTokenHeader(undefined);++ /** Set up adapter: first call returns 401, second would be the refresh */+ mockAdapter.mockRejectedValueOnce({+ response: { status: 401 },+ config: { url: '/api/messages', headers: {} },+ });++ try {+ await axios.get('/api/messages');+ } catch {+ // expected rejection+ }++ /**+ * If the interceptor skipped refresh, only 1 call was made (the original).+ * If it attempted refresh, there would be 2+ calls (original + refresh POST).+ */+ expect(mockAdapter).toHaveBeenCalledTimes(1);+ });++ it('attempts refresh when Authorization header is present', async () => {+ setTokenHeader('valid-token');++ /** First call: 401 on the original request */+ mockAdapter.mockRejectedValueOnce({+ response: { status: 401 },+ config: { url: '/api/messages', headers: {}, _retry: false },+ });++ /** Second call: the refresh endpoint succeeds */+ mockAdapter.mockResolvedValueOnce({+ data: { token: 'new-token' },+ status: 200,+ headers: {},+ config: {},+ });++ /** Third call: retried original request succeeds */+ mockAdapter.mockResolvedValueOnce({+ data: { messages: [] },+ status: 200,+ headers: {},+ config: {},+ });++ try {+ await axios.get('/api/messages');+ } catch {+ // may reject depending on exact flow+ }++ /** More than 1 call means the interceptor attempted refresh */+ expect(mockAdapter.mock.calls.length).toBeGreaterThan(1);++ /** Verify the second call targeted the refresh endpoint */+ const refreshCall = mockAdapter.mock.calls[1];+ expect(refreshCall[0].url).toContain('api/auth/refresh');+ });+});diff --git a/packages/data-provider/src/headers-helpers.ts b/packages/data-provider/src/headers-helpers.tsindex 195f7c7912..fa24b36997 100644--- a/packages/data-provider/src/headers-helpers.ts+++ b/packages/data-provider/src/headers-helpers.ts@@ -4,6 +4,10 @@ export function setAcceptLanguageHeader(value: string): void {axios.defaults.headers.common['Accept-Language'] = value;}-export function setTokenHeader(token: string) {- axios.defaults.headers.common['Authorization'] = 'Bearer ' + token;+export function setTokenHeader(token: string | undefined) {+ if (token === undefined) {+ delete axios.defaults.headers.common['Authorization'];+ } else {+ axios.defaults.headers.common['Authorization'] = 'Bearer ' + token;+ }}diff --git a/packages/data-provider/src/request.ts b/packages/data-provider/src/request.tsindex fd5d42d76a..8b316731fb 100644--- a/packages/data-provider/src/request.ts+++ b/packages/data-provider/src/request.ts@@ -99,6 +99,11 @@ if (typeof window !== 'undefined') {return Promise.reject(error);}+ /** Skip refresh when the Authorization header has been cleared (e.g. during logout) */+ if (!axios.defaults.headers.common['Authorization']) {+ return Promise.reject(error);+ }+if (error.response.status === 401 && !originalRequest._retry) {console.warn('401 error, refreshing token');originalRequest._retry = true;