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: Let Concurrent First OpenID Logins Continue as the New User (#16778)
Danny Avilaf556fc0b5dc2
diff --git a/api/strategies/openidStrategy.js b/api/strategies/openidStrategy.jsindex 3f2f9c22d1..99ad2b0c89 100644--- a/api/strategies/openidStrategy.js+++ b/api/strategies/openidStrategy.js@@ -13,9 +13,11 @@ const {findOpenIDUser,getOpenIdEmail,getOpenIdIssuer,+ createOpenIDUser,getBalanceConfig,selectOpenIdRole,getTokenCacheTtlMs,+ applyOpenIDProfile,getAvatarSaveParams,isEmailDomainAllowed,getAvatarFileStrategy,@@ -28,7 +30,13 @@ const {} = require('@librechat/api');const { getStrategyFunctions } = require('~/server/services/Files/strategies');const { resizeAvatar } = require('~/server/services/Files/images/avatar');-const { findUser, createUser, updateUser, findRolesByNames } = require('~/models');+const {+ findUser,+ updateUser,+ findRolesByNames,+ findBalanceByUser,+ createUserIfAbsent,+} = require('~/models');const { getAppConfig } = require('~/server/services/Config');const getLogStores = require('~/cache/getLogStores');@@ -580,14 +588,15 @@ async function processOpenIDAuth(tokenset, existingUsersOnly = false) {throw new Error('Email domain not allowed');}- const result = await findOpenIDUser({+ const lookup = {findUser,email: email,openidId: claims.sub || userinfo.sub,openidIssuer,idOnTheSource: claims.oid || userinfo.oid,strategyName: 'openidStrategy',- });+ };+ const result = await findOpenIDUser(lookup);let user = result.user;const error = result.error;@@ -595,7 +604,7 @@ async function processOpenIDAuth(tokenset, existingUsersOnly = false) {throw new Error(ErrorTypes.AUTH_FAILED);}- const appConfig = user?.tenantId ? await resolveAppConfigForUser(getAppConfig, user) : baseConfig;+ let appConfig = user?.tenantId ? await resolveAppConfigForUser(getAppConfig, user) : baseConfig;if (!isEmailDomainAllowed(email, appConfig?.registration?.allowedDomains)) {logger.error(@@ -676,33 +685,28 @@ async function processOpenIDAuth(tokenset, existingUsersOnly = false) {throw new Error('User does not exist');}- if (!user) {- user = {- provider: 'openid',- openidId: userinfo.sub,- username,- email: email || '',- emailVerified: userinfo.email_verified || false,- name: fullName,- idOnTheSource: userinfo.oid,- openidIssuer,- };+ const profile = {+ openidId: userinfo.sub,+ openidIssuer,+ username,+ name: fullName,+ email,+ emailVerified: userinfo.email_verified || false,+ idOnTheSource: userinfo.oid,+ };- const balanceConfig = getBalanceConfig(appConfig);- user = await createUser(user, balanceConfig, true, true);+ if (!user) {+ ({ user, appConfig } = await createOpenIDUser({+ lookup,+ profile,+ appConfig,+ getAppConfig,+ getBalanceConfig,+ createUserIfAbsent,+ findBalanceByUser,+ }));} else {- user.provider = 'openid';- user.openidId = userinfo.sub;- if (openidIssuer) {- user.openidIssuer = openidIssuer;- }- user.username = username;- user.name = fullName;- user.idOnTheSource = userinfo.oid;- if (email && email !== user.email) {- user.email = email;- user.emailVerified = userinfo.email_verified || false;- }+ user = applyOpenIDProfile(user, profile);}const adminRole = process.env.OPENID_ADMIN_ROLE;diff --git a/api/strategies/openidStrategy.spec.js b/api/strategies/openidStrategy.spec.jsindex 641619d100..d62eb20200 100644--- a/api/strategies/openidStrategy.spec.js+++ b/api/strategies/openidStrategy.spec.js@@ -2,7 +2,7 @@ const undici = require('undici');const fetch = require('node-fetch');const jwtDecode = require('jsonwebtoken/decode');const { ErrorTypes, FileSources } = require('librechat-data-provider');-const { findUser, createUser, updateUser, findRolesByNames } = require('~/models');+const { findUser, updateUser, findRolesByNames, createUserIfAbsent } = require('~/models');const {getOpenIdProxyDispatcher,resolveAppConfigForUser,@@ -97,9 +97,10 @@ jest.mock('@librechat/api', () => {});jest.mock('~/models', () => ({findUser: jest.fn(),- createUser: jest.fn(),+ createUserIfAbsent: jest.fn(),updateUser: jest.fn(),findRolesByNames: jest.fn(),+ findBalanceByUser: jest.fn(),}));jest.mock('@librechat/data-schemas', () => ({...jest.requireActual('@librechat/api'),@@ -264,11 +265,11 @@ describe('setupOpenId', () => {permissions: ['admin'],});- // By default, assume that no user is found, so createUser will be called+ // By default, assume that no user is found, so createUserIfAbsent will be calledfindUser.mockResolvedValue(null);- createUser.mockImplementation(async (userData) => {+ createUserIfAbsent.mockImplementation(async (userData) => {// simulate created user with an _id property- return { _id: 'newUserId', ...userData };+ return { ok: true, value: { _id: 'newUserId', ...userData } };});updateUser.mockImplementation(async (id, userData) => {return { _id: id, ...userData };@@ -420,7 +421,7 @@ describe('setupOpenId', () => {expect(getOpenIdIssuer.mock.calls[0][1]).toEqual(expect.objectContaining({ issuer: 'https://fake-issuer.com' }),);- expect(createUser).toHaveBeenCalledWith(+ expect(createUserIfAbsent).toHaveBeenCalledWith(expect.objectContaining({provider: 'openid',openidId: userinfo.sub,@@ -430,8 +431,6 @@ describe('setupOpenId', () => {name: `${userinfo.given_name} ${userinfo.family_name}`,}),{ enabled: false },- true,- true,);});@@ -447,11 +446,9 @@ describe('setupOpenId', () => {// Assertexpect(user.username).toBe(expectUsername);- expect(createUser).toHaveBeenCalledWith(+ expect(createUserIfAbsent).toHaveBeenCalledWith(expect.objectContaining({ username: expectUsername }),{ enabled: false },- true,- true,);});@@ -467,11 +464,9 @@ describe('setupOpenId', () => {// Assertexpect(user.username).toBe(expectUsername);- expect(createUser).toHaveBeenCalledWith(+ expect(createUserIfAbsent).toHaveBeenCalledWith(expect.objectContaining({ username: expectUsername }),{ enabled: false },- true,- true,);});@@ -485,11 +480,9 @@ describe('setupOpenId', () => {// Assert – username should equal the sub (converted as-is)expect(user.username).toBe(userinfo.sub);- expect(createUser).toHaveBeenCalledWith(+ expect(createUserIfAbsent).toHaveBeenCalledWith(expect.objectContaining({ username: userinfo.sub }),{ enabled: false },- true,- true,);});@@ -575,7 +568,7 @@ describe('setupOpenId', () => {// Assert – verify that the strategy rejects loginexpect(result.user).toBe(false);expect(result.details.message).toBe(ErrorTypes.AUTH_FAILED);- expect(createUser).not.toHaveBeenCalled();+ expect(createUserIfAbsent).not.toHaveBeenCalled();expect(updateUser).not.toHaveBeenCalled();});@@ -602,10 +595,109 @@ describe('setupOpenId', () => {expect(result.user).toBe(false);expect(result.details.message).toBe(ErrorTypes.AUTH_FAILED);- expect(createUser).not.toHaveBeenCalled();+ expect(createUserIfAbsent).not.toHaveBeenCalled();expect(updateUser).not.toHaveBeenCalled();});+ describe('concurrent first login', () => {+ const raceCreateWith = (existingUser) => {+ let created = false;+ const matches = (query) =>+ Object.entries(query).every(([field, value]) => existingUser[field] === value);+ findUser.mockImplementation(async (query) =>+ created && matches(query) ? existingUser : null,+ );+ createUserIfAbsent.mockImplementation(async () => {+ created = true;+ return { ok: false, error: { code: 'user_exists' } };+ });+ };++ it('continues as the user the other request created', async () => {+ raceCreateWith({+ _id: 'winnerUserId',+ provider: 'openid',+ openidId: tokenset.claims().sub,+ openidIssuer: 'https://fake-issuer.com',+ email: tokenset.claims().email,+ username: 'testusername',+ name: 'First Last',+ });++ const { user } = await validate(tokenset);++ expect(createUserIfAbsent).toHaveBeenCalledTimes(1);+ expect(updateUser).toHaveBeenCalledWith(+ 'winnerUserId',+ expect.objectContaining({ openidId: tokenset.claims().sub }),+ );+ expect(user).toEqual(+ expect.objectContaining({ _id: 'winnerUserId', email: tokenset.claims().email }),+ );+ });++ it("writes this callback's claims over the ones the other request stored", async () => {+ raceCreateWith({+ _id: 'winnerUserId',+ provider: 'openid',+ openidId: tokenset.claims().sub,+ openidIssuer: 'https://fake-issuer.com',+ email: '[email protected]',+ emailVerified: false,+ username: 'old-username',+ name: 'Old Name',+ });++ await validate(tokenset);++ expect(updateUser).toHaveBeenCalledWith(+ 'winnerUserId',+ expect.objectContaining({+ email: tokenset.claims().email,+ emailVerified: true,+ username: tokenset.claims().preferred_username,+ name: `${tokenset.claims().given_name} ${tokenset.claims().family_name}`,+ }),+ );+ });++ it('fails the login while the account it found has no start balance yet', async () => {+ const { findBalanceByUser } = require('~/models');+ const { getBalanceConfig } = require('@librechat/api');+ getBalanceConfig.mockReturnValue({ enabled: true, startBalance: 500 });+ findBalanceByUser.mockResolvedValue(null);+ raceCreateWith({+ _id: 'winnerUserId',+ provider: 'openid',+ openidId: tokenset.claims().sub,+ openidIssuer: 'https://fake-issuer.com',+ email: tokenset.claims().email,+ });++ const result = await validate(tokenset);++ expect(findBalanceByUser).toHaveBeenCalledWith('winnerUserId');+ expect(result.user).toBe(false);+ expect(result.details.message).toBe(ErrorTypes.AUTH_FAILED);+ expect(updateUser).not.toHaveBeenCalled();+ getBalanceConfig.mockReturnValue({ enabled: false });+ });++ it('fails the login when another provider took the email in the meantime', async () => {+ raceCreateWith({+ _id: 'localUserId',+ provider: 'local',+ email: tokenset.claims().email,+ });++ const result = await validate(tokenset);++ expect(result.user).toBe(false);+ expect(result.details.message).toBe(ErrorTypes.AUTH_FAILED);+ expect(updateUser).not.toHaveBeenCalled();+ });+ });+it('should enforce the required role and reject login if missing', async () => {// Arrange – simulate a token without the required role.jwtDecode.mockReturnValue({@@ -650,7 +742,7 @@ describe('setupOpenId', () => {// Assert – login succeeds when required role is present after splittingexpect(user).toBeTruthy();- expect(createUser).toHaveBeenCalled();+ expect(createUserIfAbsent).toHaveBeenCalled();});it('should allow login when roles claim is a comma-separated string containing the required role', async () => {@@ -664,7 +756,7 @@ describe('setupOpenId', () => {// Assert – login succeeds when required role is present after splittingexpect(user).toBeTruthy();- expect(createUser).toHaveBeenCalled();+ expect(createUserIfAbsent).toHaveBeenCalled();});it('should allow login when roles claim is a mixed comma-and-space-separated string containing the required role', async () => {@@ -678,7 +770,7 @@ describe('setupOpenId', () => {// Assert – login succeeds when required role is present after splittingexpect(user).toBeTruthy();- expect(createUser).toHaveBeenCalled();+ expect(createUserIfAbsent).toHaveBeenCalled();});it('should reject login when roles claim is a space-separated string that does not contain the required role', async () => {@@ -710,7 +802,7 @@ describe('setupOpenId', () => {expect(user).toBeTruthy();expect(user.email).toBe(tokenset.claims().email);expect(user.username).toBe(tokenset.claims().preferred_username);- expect(createUser).toHaveBeenCalled();+ expect(createUserIfAbsent).toHaveBeenCalled();});it('should allow login when required role is found in userinfo claims', async () => {@@ -2422,11 +2514,9 @@ describe('setupOpenId', () => {const { user } = await validate({ ...tokenset, claims: () => userinfo });expect(user.email).toBe('[email protected]');- expect(createUser).toHaveBeenCalledWith(+ expect(createUserIfAbsent).toHaveBeenCalledWith(expect.objectContaining({ email: '[email protected]' }),expect.anything(),- true,- true,);});diff --git a/packages/api/src/auth/openid.spec.ts b/packages/api/src/auth/openid.spec.tsindex 57e9aedd7a..5548bba312 100644--- a/packages/api/src/auth/openid.spec.ts+++ b/packages/api/src/auth/openid.spec.ts@@ -1,11 +1,17 @@import mongoose, { Types } from 'mongoose';import { ErrorTypes } from 'librechat-data-provider';import { MongoMemoryServer } from 'mongodb-memory-server';-import { logger, createMethods, createModels } from '@librechat/data-schemas';-import type { IUser, UserMethods } from '@librechat/data-schemas';+import { logger, tenantStorage, createMethods, createModels } from '@librechat/data-schemas';+import type { IUser, AppConfig, UserMethods } from '@librechat/data-schemas';import type { CommandStartedEvent } from 'mongodb';import type { FilterQuery } from 'mongoose';-import { findOpenIDUser, getOpenIdEmail, getOpenIdIssuer, normalizeOpenIdIssuer } from './openid';+import {+ findOpenIDUser,+ getOpenIdEmail,+ getOpenIdIssuer,+ createOpenIDUser,+ normalizeOpenIdIssuer,+} from './openid';import { recordOpenIDUserLookup } from '~/app/metrics';function newId() {@@ -17,6 +23,7 @@ jest.mock('@librechat/data-schemas', () => ({logger: {warn: jest.fn(),info: jest.fn(),+ error: jest.fn(),},}));@@ -997,3 +1004,214 @@ describe('getOpenIdEmail', () => {);});});++describe('createOpenIDUser', () => {+ let mongoServer: MongoMemoryServer;+ let User: mongoose.Model<IUser>;+ let methods: ReturnType<typeof createMethods>;++ const issuer = 'https://issuer.example.com';+ const email = '[email protected]';+ const openidId = 'first-login-sub';+ const tenantId = 'tenant-a';+ const profile = {+ openidId,+ openidIssuer: issuer,+ email,+ username: 'first-login',+ name: 'First Login',+ emailVerified: true,+ };+ const getAppConfig = jest.fn(async (): Promise<AppConfig> => appConfigWith());++ function appConfigWith(+ balance?: { enabled: boolean; startBalance: number },+ allowedDomains?: string[],+ ): AppConfig {+ return { balance, registration: { allowedDomains } } as Partial<AppConfig> as AppConfig;+ }++ function getLookup() {+ return { findUser: methods.findUser, email, openidId, openidIssuer: issuer };+ }++ function firstLogin(+ balance?: { enabled: boolean; startBalance: number },+ overrides: Partial<Parameters<typeof createOpenIDUser>[0]> = {},+ ) {+ return createOpenIDUser({+ lookup: getLookup(),+ profile,+ appConfig: appConfigWith(balance),+ getAppConfig,+ getBalanceConfig: (config: AppConfig) => config.balance ?? null,+ createUserIfAbsent: methods.createUserIfAbsent,+ findBalanceByUser: (userId) => methods.findBalanceByUser(userId),+ ...overrides,+ });+ }++ beforeAll(async () => {+ mongoServer = await MongoMemoryServer.create();+ await mongoose.connect(mongoServer.getUri(), { autoIndex: false });+ createModels(mongoose);+ User = mongoose.models.User as mongoose.Model<IUser>;+ methods = createMethods(mongoose);+ });++ afterAll(async () => {+ await mongoose.disconnect();+ await mongoServer.stop();+ });++ beforeEach(async () => {+ jest.clearAllMocks();+ await mongoose.connection.dropDatabase();+ await User.syncIndexes();+ });++ it('resolves concurrent first logins to the one user that was created', async () => {+ const lookups = await Promise.all([findOpenIDUser(getLookup()), findOpenIDUser(getLookup())]);+ expect(lookups.map((lookup) => lookup.user)).toEqual([null, null]);++ const logins = await Promise.all([firstLogin(), firstLogin()]);++ expect(await User.countDocuments({ email })).toBe(1);+ expect(logins[0].user._id.toString()).toBe(logins[1].user._id.toString());+ expect(logins[1].user).toEqual(+ expect.objectContaining({ openidId, email, provider: 'openid' }),+ );+ });++ it("refreshes the recovered user with the losing request's claims", async () => {+ await firstLogin();+ const renamed = {+ ...profile,+ email: '[email protected]',+ name: 'Renamed',+ emailVerified: false,+ };++ const { user } = await firstLogin(undefined, {+ lookup: { ...getLookup(), email: renamed.email },+ profile: renamed,+ });++ expect(await User.countDocuments()).toBe(1);+ expect(user).toEqual(+ expect.objectContaining({+ openidId,+ email: '[email protected]',+ name: 'Renamed',+ emailVerified: false,+ }),+ );+ });++ it('credits the start balance once across concurrent first logins', async () => {+ const balance = { enabled: true, startBalance: 500 };++ const [{ user }] = await Promise.all([firstLogin(balance), firstLogin(balance)]);++ const balances = await mongoose.models.Balance.find({ user: user._id }).lean<+ Array<{ tokenCredits: number }>+ >();+ expect(balances.map((record) => record.tokenCredits)).toEqual([500]);+ });++ it('fails the recovered login while the winner has not credited its start balance yet', async () => {+ await User.create({ email, provider: 'openid', openidId, openidIssuer: issuer });++ const login = firstLogin({ enabled: true, startBalance: 500 });++ await expect(login).rejects.toThrow(ErrorTypes.AUTH_FAILED);+ expect(await mongoose.models.Balance.countDocuments()).toBe(0);+ });++ it('recovers an account created without a balance when no start balance is configured', async () => {+ await User.create({ email, provider: 'openid', openidId, openidIssuer: issuer });++ const { user } = await firstLogin({ enabled: true, startBalance: 0 });++ expect(user).toEqual(expect.objectContaining({ openidId, email }));+ });++ it("applies the recovered tenant account's email-domain policy", async () => {+ await tenantStorage.run({ tenantId }, () =>+ User.create({ email, provider: 'openid', openidId, openidIssuer: issuer }),+ );+ getAppConfig.mockResolvedValueOnce(appConfigWith(undefined, ['other.example']));++ const login = tenantStorage.run({ tenantId }, () => firstLogin());++ await expect(login).rejects.toThrow('Email domain not allowed');+ expect(getAppConfig).toHaveBeenCalledWith(expect.objectContaining({ tenantId }));+ });++ it("continues when only the recovered tenant account's config sets a start balance", async () => {+ await tenantStorage.run({ tenantId }, () =>+ User.create({ email, provider: 'openid', openidId, openidIssuer: issuer }),+ );+ getAppConfig.mockResolvedValueOnce(appConfigWith({ enabled: true, startBalance: 500 }));++ const login = await tenantStorage.run({ tenantId }, () => firstLogin());++ expect(login.user).toEqual(expect.objectContaining({ openidId, tenantId }));+ });++ it('holds the recovered login on the start balance new users are created with', async () => {+ await tenantStorage.run({ tenantId }, () =>+ User.create({ email, provider: 'openid', openidId, openidIssuer: issuer }),+ );+ getAppConfig.mockResolvedValueOnce(appConfigWith({ enabled: false, startBalance: 0 }));++ const login = tenantStorage.run({ tenantId }, () =>+ firstLogin({ enabled: true, startBalance: 500 }),+ );++ await expect(login).rejects.toThrow(ErrorTypes.AUTH_FAILED);+ });++ it("continues under the recovered tenant account's config when its policy admits the email", async () => {+ await tenantStorage.run({ tenantId }, () =>+ User.create({ email, provider: 'openid', openidId, openidIssuer: issuer }),+ );+ const tenantConfig = appConfigWith(undefined, ['example.com']);+ getAppConfig.mockResolvedValueOnce(tenantConfig);++ const login = await tenantStorage.run({ tenantId }, () => firstLogin());++ expect(login.appConfig).toBe(tenantConfig);+ expect(login.user).toEqual(expect.objectContaining({ openidId, tenantId }));+ });++ it('fails the login when the email was taken by another provider in the meantime', async () => {+ await User.create({ email, provider: 'local', username: 'local-user' });++ await expect(firstLogin()).rejects.toThrow(ErrorTypes.AUTH_FAILED);+ expect(await User.countDocuments({ email })).toBe(1);+ });++ it('throws when the lookup cannot account for the existing account', async () => {+ await User.create({ email: '[email protected]', provider: 'openid', openidId: 'other-sub' });++ const login = firstLogin(undefined, {+ lookup: { findUser: methods.findUser, openidId, openidIssuer: issuer },+ profile: { ...profile, email: '[email protected]' },+ });++ await expect(login).rejects.toThrow('conflicts with an account the lookup cannot resolve');+ });++ it('rethrows other create failures without a second lookup', async () => {+ const findUser = jest.fn(methods.findUser);++ const login = firstLogin(undefined, {+ lookup: { ...getLookup(), findUser },+ profile: { ...profile, email: 'not-an-email' },+ });++ await expect(login).rejects.toMatchObject({ name: 'ValidationError' });+ expect(findUser).not.toHaveBeenCalled();+ });+});diff --git a/packages/api/src/auth/openid.ts b/packages/api/src/auth/openid.tsindex 4d346a7591..e121f48494 100644--- a/packages/api/src/auth/openid.ts+++ b/packages/api/src/auth/openid.ts@@ -1,9 +1,19 @@import { logger } from '@librechat/data-schemas';import { ErrorTypes } from 'librechat-data-provider';-import type { IUser, UserMethods } from '@librechat/data-schemas';+import type {+ IUser,+ UserMethods,+ UserRecord,+ NewUserData,+ BalanceConfig,+ CreateUserIfAbsentResult,+ AppConfig,+} from '@librechat/data-schemas';import type { FilterQuery } from 'mongoose';-import { isMetricsConfigured, recordOpenIDUserLookup } from '~/app/metrics';import type { OpenIDUserLookupResult } from '~/app/metrics';+import { isMetricsConfigured, recordOpenIDUserLookup } from '~/app/metrics';+import { resolveAppConfigForUser } from '~/app/resolve';+import { isEmailDomainAllowed } from './domain';export type OpenIdEmailClaims = {email?: unknown;@@ -21,6 +31,17 @@ export type OpenIdIssuerSource = {type OpenIdLookupField = 'openidId' | 'idOnTheSource';type OpenIdUserResolution = { user: IUser | null; error: string | null; migration: boolean };+/** The account fields an OpenID login writes from the current callback's claims. */+export type OpenIDProfile = {+ openidId: string;+ openidIssuer?: string;+ username: string;+ name: string;+ email?: string;+ emailVerified: boolean;+ idOnTheSource?: string;+};+const OPENID_DISCOVERY_PATH = '/.well-known/openid-configuration';const LEGACY_ISSUER_FILTERS: Array<FilterQuery<IUser>['openidIssuer']> = [{ $exists: false },@@ -297,3 +318,113 @@ export async function findOpenIDUser({throw error;}}++/** Returns `user` carrying the current callback's claims, as every OpenID login refreshes them. */+export function applyOpenIDProfile<T extends UserRecord>(user: T, profile: OpenIDProfile): T {+ const updated = {+ ...user,+ provider: 'openid',+ openidId: profile.openidId,+ username: profile.username,+ name: profile.name,+ idOnTheSource: profile.idOnTheSource,+ };+ if (profile.openidIssuer) {+ updated.openidIssuer = profile.openidIssuer;+ }+ if (profile.email && profile.email !== user.email) {+ updated.email = profile.email;+ updated.emailVerified = profile.emailVerified;+ }+ return updated;+}++/** Whether new users start with a balance record (the condition data-schemas credits it under). */+function hasStartBalance(balanceConfig?: BalanceConfig | null): boolean {+ return Boolean(balanceConfig?.enabled && balanceConfig.startBalance);+}++/**+ * Creates a first-login OpenID user. Concurrent first logins for one identity all miss+ * `findOpenIDUser`, and `createUserIfAbsent` reports `user_exists` for every insert but the+ * first; a rejected request repeats the lookup, with its provider and issuer checks, and+ * continues as the account that won, admitted and refreshed exactly as if its first lookup had+ * found it: a tenant account resolves its tenant config and that config's email-domain policy+ * applies, and the account carries this callback's claims. Returns the account with the config+ * the login continues under (`appConfig` for a user this request created).+ *+ * It continues only once the winner finished provisioning that account. When the config new+ * users are created under (`appConfig`) sets a start balance, the balance must exist:+ * `createUserIfAbsent` writes it before the user, but a winner on an earlier release adds it with+ * `$inc` after its insert, and login balance sync must not initialize it first; such a login fails+ * as it did before recovery existed. A start balance only the account's tenant config sets is+ * initialized by login balance sync with an insert-only write that cannot be added on top, so it+ * does not hold the login back. A conflict the lookup cannot account for throws.+ */+export async function createOpenIDUser({+ lookup,+ profile,+ appConfig,+ getAppConfig,+ getBalanceConfig,+ createUserIfAbsent,+ findBalanceByUser,+}: {+ lookup: Parameters<typeof findOpenIDUser>[0];+ profile: OpenIDProfile;+ appConfig: AppConfig;+ getAppConfig: Parameters<typeof resolveAppConfigForUser>[0];+ getBalanceConfig: (appConfig: AppConfig) => BalanceConfig | null | undefined;+ createUserIfAbsent: (+ data: NewUserData,+ balanceConfig?: BalanceConfig,+ ) => Promise<CreateUserIfAbsentResult>;+ findBalanceByUser: (userId: string) => Promise<object | null>;+}): Promise<{ user: UserRecord; appConfig: AppConfig }> {+ const created = await createUserIfAbsent(+ {+ provider: 'openid',+ openidId: profile.openidId,+ username: profile.username,+ email: profile.email || '',+ emailVerified: profile.emailVerified,+ name: profile.name,+ idOnTheSource: profile.idOnTheSource,+ openidIssuer: profile.openidIssuer,+ },+ getBalanceConfig(appConfig) ?? undefined,+ );+ if (created.ok) return { user: created.value, appConfig };++ const strategyName = lookup.strategyName ?? 'openid';+ const resolution = await findOpenIDUser(lookup);+ if (resolution.error) throw new Error(ErrorTypes.AUTH_FAILED);+ if (!resolution.user) {+ throw new Error(+ `[${strategyName}] New user conflicts with an account the lookup cannot resolve`,+ );+ }++ const userId = resolution.user._id.toString();+ const accountConfig = resolution.user.tenantId+ ? await resolveAppConfigForUser(getAppConfig, resolution.user)+ : appConfig;+ if (!isEmailDomainAllowed(profile.email ?? '', accountConfig?.registration?.allowedDomains)) {+ logger.error(+ `[${strategyName}] Authentication blocked - email domain not allowed for the recovered account [Identifier: ${profile.email}]`,+ );+ throw new Error('Email domain not allowed');+ }++ if (hasStartBalance(getBalanceConfig(appConfig)) && !(await findBalanceByUser(userId))) {+ logger.warn(+ `[${strategyName}] Concurrent first login found user ${userId} before its start balance; failing this login`,+ );+ throw new Error(ErrorTypes.AUTH_FAILED);+ }++ logger.info(+ `[${strategyName}] Concurrent first login for user ${userId}; continuing as that user`,+ );+ return { user: applyOpenIDProfile(resolution.user, profile), appConfig: accountConfig };+}diff --git a/packages/data-schemas/src/methods/user.methods.spec.ts b/packages/data-schemas/src/methods/user.methods.spec.tsindex acf4bdafd9..945260b598 100644--- a/packages/data-schemas/src/methods/user.methods.spec.ts+++ b/packages/data-schemas/src/methods/user.methods.spec.ts@@ -424,6 +424,127 @@ describe('User Methods - Database Tests', () => {});});+ describe('createUserIfAbsent', () => {+ const newUser = {+ name: 'First Login',+ email: '[email protected]',+ provider: 'openid',+ openidId: 'first-sub',+ openidIssuer: 'https://issuer.example.com',+ };++ beforeEach(async () => {+ await User.syncIndexes();+ });++ test('creates the user, credits the start balance, and returns it', async () => {+ const result = await methods.createUserIfAbsent(newUser, {+ enabled: true,+ startBalance: 500,+ });++ expect(result.ok).toBe(true);+ const created = result.ok ? result.value : null;+ expect(created).toEqual(expect.objectContaining({ email: '[email protected]' }));+ const balance = await Balance.findOne({ user: created?._id });+ expect(balance?.tokenCredits).toBe(500);+ });++ test('reports user_exists for one of two concurrent inserts and credits the balance once', async () => {+ const balanceConfig = { enabled: true, startBalance: 500 };++ const results = await Promise.all([+ methods.createUserIfAbsent(newUser, balanceConfig),+ methods.createUserIfAbsent(newUser, balanceConfig),+ ]);++ expect(results.filter((result) => result.ok)).toHaveLength(1);+ expect(results.find((result) => !result.ok)).toEqual({+ ok: false,+ error: { code: 'user_exists' },+ });+ expect(await User.countDocuments()).toBe(1);+ const balances = await Balance.find({}).lean();+ expect(balances.map((balance) => balance.tokenCredits)).toEqual([500]);+ });++ test('reports user_exists when another account holds the provider identity', async () => {+ await methods.createUserIfAbsent(newUser);++ const result = await methods.createUserIfAbsent({ ...newUser, email: '[email protected]' });++ expect(result).toEqual({ ok: false, error: { code: 'user_exists' } });+ });++ test('initializes the start balance before the user exists', async () => {+ const balanceWrite = jest.spyOn(Balance, 'findOneAndUpdate');+ const userSave = jest.spyOn(User.prototype, 'save');++ await methods.createUserIfAbsent(newUser, { enabled: true, startBalance: 500 });++ expect(balanceWrite.mock.invocationCallOrder[0]).toBeLessThan(+ userSave.mock.invocationCallOrder[0],+ );+ balanceWrite.mockRestore();+ userSave.mockRestore();+ });++ test('removes the start balance it initialized when the account already exists', async () => {+ const balanceConfig = { enabled: true, startBalance: 500 };+ const created = await methods.createUserIfAbsent(newUser, balanceConfig);++ const result = await methods.createUserIfAbsent(newUser, balanceConfig);++ expect(result).toEqual({ ok: false, error: { code: 'user_exists' } });+ const balances = await Balance.find({}).lean();+ expect(balances.map((balance) => balance.user.toString())).toEqual([+ created.ok ? created.value._id.toString() : '',+ ]);+ });++ test('removes the start balance when its write commits but reports a failure', async () => {+ const realWrite = Balance.findOneAndUpdate.bind(Balance);+ const balanceWrite = jest.spyOn(Balance, 'findOneAndUpdate').mockImplementationOnce(+ (...args: Parameters<typeof Balance.findOneAndUpdate>) =>+ ({+ lean: async () => {+ await realWrite(...args).lean();+ throw new Error('connection closed before acknowledgement');+ },+ }) as never,+ );++ await expect(+ methods.createUserIfAbsent(newUser, { enabled: true, startBalance: 500 }),+ ).rejects.toThrow('connection closed before acknowledgement');+ expect(await Balance.countDocuments()).toBe(0);+ expect(await User.countDocuments()).toBe(0);+ balanceWrite.mockRestore();+ });++ test('keeps the start balance when the insert fails without a unique-index rejection', async () => {+ const userSave = jest+ .spyOn(User.prototype, 'save')+ .mockRejectedValueOnce(new Error('connection closed before acknowledgement'));++ await expect(+ methods.createUserIfAbsent(newUser, { enabled: true, startBalance: 500 }),+ ).rejects.toThrow('connection closed before acknowledgement');+ expect(await Balance.countDocuments()).toBe(1);+ userSave.mockRestore();+ });++ test('throws failures other than an existing account without writing a balance', async () => {+ await expect(+ methods.createUserIfAbsent(+ { ...newUser, email: 'not-an-email' },+ { enabled: true, startBalance: 500 },+ ),+ ).rejects.toMatchObject({ name: 'ValidationError' });+ expect(await Balance.countDocuments()).toBe(0);+ });+ });+describe('updateUser', () => {test('should update user fields', async () => {const user = await User.create({diff --git a/packages/data-schemas/src/methods/user.ts b/packages/data-schemas/src/methods/user.tsindex 5237d415ec..a78e911968 100644--- a/packages/data-schemas/src/methods/user.ts+++ b/packages/data-schemas/src/methods/user.ts@@ -5,7 +5,15 @@ import type {RefillIntervalUnit,StatefulCodeEnvironment,} from 'librechat-data-provider';-import type { IUser, BalanceConfig, CreateUserRequest, UserDeleteResult } from '~/types';+import type {+ IUser,+ BalanceConfig,+ CreateUserRequest,+ UserRecord,+ NewUserData,+ UserDeleteResult,+ CreateUserIfAbsentResult,+} from '~/types';import type { TwoFactorEnrollmentGuard, TwoFactorEnrollmentUpdate } from '~/types';import type { CacheStore } from '~/types';import { evictAuthUserDocs } from '~/utils/eviction';@@ -64,6 +72,10 @@ export function createUserMethods(disableTTL?: boolean,returnUser?: boolean,) => Promise<mongoose.Types.ObjectId | Partial<IUser>>;+ createUserIfAbsent: (+ data: NewUserData,+ balanceConfig?: BalanceConfig,+ ) => Promise<CreateUserIfAbsentResult>;updateUser: (userId: string,updateData: Partial<IUser>,@@ -266,6 +278,48 @@ export function createUserMethods(return await User.countDocuments(filter);}+ /**+ * Initializes a new user's start balance, with auto-refill settings when complete. The write is+ * insert-only, so it never replaces a balance that already exists or the activity recorded on it.+ */+ async function creditStartBalance(+ userId: mongoose.Types.ObjectId,+ balanceConfig?: BalanceConfig,+ ): Promise<void> {+ if (!balanceConfig?.enabled || !balanceConfig?.startBalance) {+ return;+ }++ const Balance = mongoose.models.Balance;+ const initial: {+ tokenCredits: number;+ autoRefillEnabled?: boolean;+ refillIntervalValue?: number;+ refillIntervalUnit?: RefillIntervalUnit;+ refillAmount?: number;+ refillMode?: BalanceRefillMode;+ } = { tokenCredits: balanceConfig.startBalance };++ if (+ balanceConfig.autoRefillEnabled &&+ balanceConfig.refillIntervalValue != null &&+ balanceConfig.refillIntervalUnit != null &&+ balanceConfig.refillAmount != null+ ) {+ initial.autoRefillEnabled = true;+ initial.refillIntervalValue = balanceConfig.refillIntervalValue;+ initial.refillIntervalUnit = balanceConfig.refillIntervalUnit;+ initial.refillAmount = balanceConfig.refillAmount;+ initial.refillMode = balanceConfig.refillMode ?? 'add';+ }++ await Balance.findOneAndUpdate(+ { _id: userId },+ { $setOnInsert: { ...initial, user: userId } },+ { upsert: true, new: true },+ ).lean();+ }+/*** Creates a new user, optionally with a TTL of 1 week.*/@@ -276,7 +330,6 @@ export function createUserMethods(returnUser: boolean = false,): Promise<mongoose.Types.ObjectId | Partial<IUser>> {const User = mongoose.models.User;- const Balance = mongoose.models.Balance;const userData: Partial<IUser> = {...data,@@ -288,48 +341,71 @@ export function createUserMethods(}const user = await User.create(userData);+ await creditStartBalance(user._id, balanceConfig);- // If balance is enabled, create or update a balance record for the user- if (balanceConfig?.enabled && balanceConfig?.startBalance) {- const update: {- $inc: { tokenCredits: number };- $set?: {- autoRefillEnabled: boolean;- refillIntervalValue: number;- refillIntervalUnit: RefillIntervalUnit;- refillAmount: number;- refillMode?: BalanceRefillMode;- };- } = {- $inc: { tokenCredits: balanceConfig.startBalance },- };+ if (returnUser) {+ return user.toObject() as Partial<IUser>;+ }+ return user._id as mongoose.Types.ObjectId;+ }- if (- balanceConfig.autoRefillEnabled &&- balanceConfig.refillIntervalValue != null &&- balanceConfig.refillIntervalUnit != null &&- balanceConfig.refillAmount != null- ) {- update.$set = {- autoRefillEnabled: true,- refillIntervalValue: balanceConfig.refillIntervalValue,- refillIntervalUnit: balanceConfig.refillIntervalUnit,- refillAmount: balanceConfig.refillAmount,- refillMode: balanceConfig.refillMode ?? 'add',- };- }+ /**+ * Creates a user without a TTL, or reports `user_exists` when a unique email or provider+ * identity index already holds the account, as when concurrent first logins race to insert it.+ * The start balance is initialized under the new user's id before the user is inserted, so+ * the account is never visible without it and login balance sync never initializes it first.+ * A balance write that fails, or an insert a unique index rejects, removes the balance under+ * the id that never became a user; any other insert failure keeps it, since an unacknowledged+ * insert may still have committed.+ */+ async function createUserIfAbsent(+ data: NewUserData,+ balanceConfig?: BalanceConfig,+ ): Promise<CreateUserIfAbsentResult> {+ const User = mongoose.models.User as mongoose.Model<IUser>;+ const userData: Partial<IUser> = { ...data };+ delete userData.expiresAt;- await Balance.findOneAndUpdate(- { _id: user._id },- { ...update, $setOnInsert: { user: user._id } },- { upsert: true, new: true },- ).lean();+ const user = new User(userData);+ await user.validate();+ try {+ await creditStartBalance(user._id, balanceConfig);+ } catch (error) {+ await discardStartBalance(user._id, balanceConfig);+ throw error;}- if (returnUser) {- return user.toObject() as Partial<IUser>;+ try {+ await user.save({ validateBeforeSave: false });+ } catch (error) {+ if ((error as { code?: number }).code !== 11000) {+ throw error;+ }+ await discardStartBalance(user._id, balanceConfig);+ return { ok: false, error: { code: 'user_exists' } };+ }++ return { ok: true, value: user.toObject() as UserRecord };+ }++ /** Removes, best effort, the start balance initialized for an id that never became a user. */+ async function discardStartBalance(+ userId: mongoose.Types.ObjectId,+ balanceConfig?: BalanceConfig,+ ): Promise<void> {+ if (!balanceConfig?.enabled || !balanceConfig?.startBalance) {+ return;+ }+ try {+ await mongoose.models.Balance.deleteOne({ _id: userId });+ } catch {+ logger.warn(+ '[createUserIfAbsent] Could not remove the start balance of a user never created',+ {+ userId: userId.toString(),+ },+ );}- return user._id as mongoose.Types.ObjectId;}/**@@ -949,6 +1025,7 @@ export function createUserMethods(findOwnerContactUsers,countUsers,createUser,+ createUserIfAbsent,updateUser,awaitAuthUserDocEviction,consumeBackupCode,diff --git a/packages/data-schemas/src/types/user.ts b/packages/data-schemas/src/types/user.tsindex 138de99ebc..53f5bc8d23 100644--- a/packages/data-schemas/src/types/user.ts+++ b/packages/data-schemas/src/types/user.ts@@ -138,6 +138,23 @@ export interface CreateUserRequest extends Partial<IUser> {email: string;}+/** A user's own fields, without Mongoose document members. */+type UserFields = Omit<IUser, keyof Document>;++/**+ * A stored user as plain data with a storage-neutral id: what `.lean()` queries and `.toObject()`+ * return. New contracts take and return this rather than the `IUser` document type.+ */+export type UserRecord = UserFields & { _id: { toString(): string } };++/** The fields a new user is created with, as plain data. */+export type NewUserData = Partial<UserFields> & { email: string };++/** The created user, or `user_exists` when an account already holds its email or provider identity. */+export type CreateUserIfAbsentResult =+ | { ok: true; value: UserRecord }+ | { ok: false; error: { code: 'user_exists' } };+export interface UpdateUserRequest {name?: string;username?: string;