Problem with custom auth strategy

I created a google oauth strategy with passport, I added it to payload and in the login everything works well (you can login, generate a token, and the token is set to the payload-token http-only cookie) but in the admin panel I can't access, also, the api isn't working, i'm getting this error in the console for the admin

My users collection:

import GoogleStrategy from "../auth/google";
import finalise from "../auth/jwt";
import passport from "passport";

const Users = {
  slug: "users",
  auth: {
    tokenExpiration: 60 * 60 * 24 * 7, // 1 week
    verify: true,
    maxLoginAttempts: 5,
    lockTime: 600 * 1000,
    useAPIKey: true,
    strategies: [
      {
        name: "google",
        strategy: GoogleStrategy,
      },
    ],
  },
  endpoints: [
    {
      path: "/google",
      method: "get",
      handler: async (req, res) => {
        passport.authenticate("google", {
          scope: ["profile", "email"],
        })(req, res);
      },
    },
    {
      path: "/google/callback",
      method: "get",
      handler: async (req, res) => {
        req.payload.authenticate(req, res, () => {
          if (req?.user) {
            const final = finalise(req, res);
            return final.res.status(200).send({ token: final.token });
          }
          return res.status(401).send({ message: "Unauthorized" });
        });
      },
    },
  ],
};

export default Users;

the google strategy:

import payload from "payload";
import Strategy from "passport-google-oauth20";
import { v4 as uuidv4 } from "uuid";
import { Forbidden, LockedAuth } from "payload/errors";

require("dotenv").config();

const GoogleStrategy = new Strategy(
  {
    clientID: process.env.GOOGLE_CLIENT_ID,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    callbackURL: "/api/users/google/callback",
    scope: ["profile", "email"],
  },
  async (accessToken, refreshToken, profile, done) => {
    const { emails } = profile;
    const email = emails[0]?.value;

    if (!email) {
      done(Forbidden, false);
    }

    try {
      let user = await payload.find({
        collection: "users",
        where: {
          email: {
            equals: email,
          },
        },
      });

      if (user?.totalDocs > 0) {
        user = user.docs[0];
      }

      const isLocked = (date) => !!(date && date > Date.now());
      if (user && isLocked(user.lockUntil)) {
        throw new LockedAuth();
      }

      if (user?.totalDocs < 1) {
        user = await payload.create({
          collection: "users",
          data: {
            email,
            password: uuidv4(),
            avatar: "1",
            _verified: true,
          },
          disableVerificationEmail: true,
        });
      }

      if (user) {
        user.collection = "users";
        user._strategy = "google";
        done(null, user);
      } else {
        done(null, false);
      }
    } catch (e) {
      done(e, false);
    }
  }
);

export default GoogleStrategy;

token:

import jwt from "jsonwebtoken";

const finalise = (req, res) => {
  let user = req.user;
  user = JSON.parse(JSON.stringify(user));
  user = sanitizeInternalFields(user);

  const collections = req.payload.collections;
  const userCollection = collections[req.payload.config.admin.user];
  const collectionConfig = userCollection.config;

  const fieldsToSign = getFieldsToSign(collectionConfig, user);

  const token = jwt.sign(fieldsToSign, req.payload.secret, {
    expiresIn: collectionConfig.auth.tokenExpiration,
  });

  const cookieOptions = {
    path: "/",
    httpOnly: true,
    expires: getCookieExpiration(collectionConfig.auth.tokenExpiration),
    secure: collectionConfig.auth.cookies.secure,
    sameSite: collectionConfig.auth.cookies.sameSite,
    domain: undefined,
  };

  if (collectionConfig.auth.cookies.domain) {
    cookieOptions.domain = collectionConfig.auth.cookies.domain;
  }

  res.cookie(`payload-token`, token, cookieOptions);

  req.user = user;

  return { req, res, token };
};

export default finalise;

any ideas?