Credential callbacks jwt is undefined

[PunkFleet]

I'm able to get normal return data from the backend, but it doesn't seem to be read correctly by jwt and session:

callbacks: {        
        async signIn({ user }) {
            console.log('user signed in');
            console.log(user);
            return true;
        },
        async redirect({ url, baseUrl }) {
            return url.startsWith(baseUrl) ? url : baseUrl;
        },
        async jwt({ token, user, account }) {
            console.log('jwt user');
            console.log(user);
            console.log('jwt account');
            console.log(account);
            if (account && user) {
                // Save the access token and refresh token in the JWT on the initial login
                return {
                    access_token: account.access_token,
                    expires_at: Math.floor(Date.now() / 1000 + (account.expires_in ?? 0)),
                    refresh_token: account.refresh_token,
                };
            } else if (Date.now() < token.expires_at * 1000) {
                // If the access token has not expired yet, return it
                return token;
            } else {
                try {
                    // If the access token has expired, use the refresh token to get a new one
                    const url = `http://localhost:8000/oauth2/token`;
                    const clientId = process.env.CLIENT_ID;
                    const clientSecret = process.env.CLIENT_SECRET;

                    if (!clientId || !clientSecret) {
                        throw new Error("Missing client ID or client secret");
                    }

                    const response = await fetch(url, {
                        method: "POST",
                        headers: {
                            "Content-Type": "application/x-www-form-urlencoded",
                        },
                        body: new URLSearchParams({
                            grant_type: "refresh_token",
                            refresh_token: token.refresh_token,
                            client_id: clientId,
                            client_secret: clientSecret,
                        }),
                    });

                    if (!response.ok) {
                        throw new Error("Failed to refresh access token");
                    }

                    const refreshedTokens = await response.json();
                    return {
                        access_token: refreshedTokens.access_token,
                        expires_at: Math.floor(Date.now() / 1000 + refreshedTokens.expires_in),
                        refresh_token: refreshedTokens.refresh_token,
                    };
                } catch (error) {
                    // If the access token has expired, use the refresh token to get a new one
                    return {
                        ...token,
                        error: "RefreshAccessTokenError",
                    };
                }
            }
        },
        async session({ session, token }) {
            // Add property to session, like an access_token from a provider.
            console.log(token)
            session.error = token.error;
            session.user.access_token = token.access_token;
            session.user.expires_at = token.expires_at;
            session.user.refresh_token = token.refresh_token;
            return session;
        },
        
        authorized({auth, request: {nextUrl}}) {
            const isLoggedIn = !!auth?.user;
            const isOnAdmin = nextUrl.pathname.startsWith('/admin');
            const isOnDashboard = nextUrl.pathname.includes('/dashboard');
            const isAuthPage = nextUrl.pathname.startsWith('/auth');
            if (isOnAdmin) {
                if (isLoggedIn) return true;
                return false; // Redirect unauthenticated users to login page
            } else if (isLoggedIn && !isAuthPage && !isOnDashboard) {
                return Response.redirect(new URL('/admin/dashboard', nextUrl));
            }
            return true;
        }
    },

Here's the printout. For some reason, user and account seem to disappear after the redirection?

[auth][warn][debug-enabled] Read more: https://warnings.authjs.dev#debug-enabled
 ○ Compiling / ...
 ✓ Compiled / in 4.7s (4916 modules)
[auth][warn][debug-enabled] Read more: https://warnings.authjs.dev#debug-enabled
user signed in
{
  access_token: 'IWivnSDWNmuIqPwdZclkufxpDkqV1e',
  expires_in: 36000,
  token_type: 'Bearer',
  scope: 'read write groups introspection',
  refresh_token: 'qdOsWAqevbiURTAZe6QUQnMEjlYLBz',
  id: '33bcf59a-760e-49ae-9329-202c634aa43d'
}
jwt user
{
  access_token: 'IWivnSDWNmuIqPwdZclkufxpDkqV1e',
  expires_in: 36000,
  token_type: 'Bearer',
  scope: 'read write groups introspection',
  refresh_token: 'qdOsWAqevbiURTAZe6QUQnMEjlYLBz',
  id: '33bcf59a-760e-49ae-9329-202c634aa43d'
}
jwt account
{
  providerAccountId: '33bcf59a-760e-49ae-9329-202c634aa43d',
  type: 'credentials',
  provider: 'credentials'
}
jwt user
undefined
jwt account
undefined
{
  expires_at: 1713859746,
  iat: 1713859746,
  exp: 1716451746,
  jti: 'ff11fdb4-3505-45de-9d40-35ff1292c15f',
  error: 'RefreshAccessTokenError'
}

[davidpc-pg]

According to the documentation:

The arguments user, account, profile and isNewUser are only passed the first time this callback is called on a new session, after the user signs in. In subsequent calls, only token will be available.