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
import { logger } from '@librechat/data-schemas';
import { ErrorTypes, SystemRoles } from 'librechat-data-provider';
import type { IUser, AppConfig, UserMethods, UserRecord } from '@librechat/data-schemas';
import type { FilterQuery } from 'mongoose';
import type {
GetAppConfig,
GetBalanceConfig,
FindBalanceByUser,
CreateUserIfAbsent,
} from './provision';
import type { OpenIDUserLookupResult } from '~/app/metrics';
import { isMetricsConfigured, recordOpenIDUserLookup } from '~/app/metrics';
import { createUserOnce } from './provision';
export type OpenIdEmailClaims = {
email?: unknown;
preferred_username?: unknown;
upn?: unknown;
[claim: string]: unknown;
};
export type OpenIdIssuerSource = {
iss?: string;
issuer?: string;
serverMetadata?: () => { issuer?: string } | undefined;
};
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 },
null,
'',
];
export function normalizeOpenIdIssuer(issuer: string | undefined): string | undefined {
const normalized = issuer?.trim().replace(/\/+$/, '');
if (!normalized) return undefined;
if (!normalized.endsWith(OPENID_DISCOVERY_PATH)) return normalized;
return normalized.slice(0, -OPENID_DISCOVERY_PATH.length) || undefined;
}
function getIssuerFromSource(source: OpenIdIssuerSource | null | undefined): string | undefined {
if (source == null) return undefined;
const issuer = source.iss || source.serverMetadata?.()?.issuer || source.issuer;
return normalizeOpenIdIssuer(issuer);
}
function getStringClaim(claims: OpenIdEmailClaims, claim: string): string | undefined {
const value = claims[claim];
return typeof value === 'string' && value ? value : undefined;
}
export function getOpenIdIssuer(
...sources: Array<OpenIdIssuerSource | null | undefined>
): string | undefined {
for (const source of sources) {
const issuer = getIssuerFromSource(source);
if (issuer) return issuer;
}
return normalizeOpenIdIssuer(process.env.OPENID_ISSUER);
}
function isLegacyOpenIdIssuer(openidIssuer: string | undefined): boolean {
const loginIssuer = normalizeOpenIdIssuer(process.env.OPENID_ISSUER);
return openidIssuer != null && loginIssuer != null && openidIssuer === loginIssuer;
}
function hasOpenIdLookupValue(value: string | undefined): value is string {
return typeof value === 'string' && value.length > 0;
}
function getElapsedSeconds(startedAt: bigint): number {
return Number(process.hrtime.bigint() - startedAt) / 1_000_000_000;
}
function getOpenIDUserLookupResult(resolution: OpenIdUserResolution): OpenIDUserLookupResult {
if (resolution.error) return 'auth_failed';
if (resolution.migration) return 'migration';
if (resolution.user) return 'found';
return 'not_found';
}
function getIssuerExactCondition(
field: OpenIdLookupField,
value: string | undefined,
openidIssuer: string | undefined,
): FilterQuery<IUser> | null {
if (!hasOpenIdLookupValue(value) || !openidIssuer) return null;
return { [field]: value, openidIssuer };
}
function getLegacyIssuerConditions(
field: OpenIdLookupField,
value: string | undefined,
openidIssuer: string | undefined,
): FilterQuery<IUser>[] {
if (!hasOpenIdLookupValue(value) || !isLegacyOpenIdIssuer(openidIssuer)) return [];
return LEGACY_ISSUER_FILTERS.map((issuerFilter) => ({
[field]: value,
openidIssuer: issuerFilter,
}));
}
export function getIssuerBoundConditions(
field: OpenIdLookupField,
value: string | undefined,
openidIssuer: string | undefined,
): FilterQuery<IUser>[] {
const exactCondition = getIssuerExactCondition(field, value, openidIssuer);
if (!exactCondition) return [];
return [exactCondition, ...getLegacyIssuerConditions(field, value, openidIssuer)];
}
function getPrimaryLookupConditions(
openidId: string | undefined,
idOnTheSource: string | undefined,
openidIssuer: string | undefined,
): FilterQuery<IUser>[] {
const exactConditions = [
getIssuerExactCondition('openidId', openidId, openidIssuer),
getIssuerExactCondition('idOnTheSource', idOnTheSource, openidIssuer),
].filter((condition): condition is FilterQuery<IUser> => condition != null);
return [
...exactConditions,
...getLegacyIssuerConditions('openidId', openidId, openidIssuer),
...getLegacyIssuerConditions('idOnTheSource', idOnTheSource, openidIssuer),
];
}
async function findFirstOpenIdUser(
findUser: UserMethods['findUser'],
conditions: FilterQuery<IUser>[],
): Promise<IUser | null> {
for (const condition of conditions) {
const user = await findUser(condition);
if (user) return user;
}
return null;
}
export function isUserIssuerAllowed(user: IUser, openidIssuer: string | undefined): boolean {
if (!openidIssuer) return true;
const userIssuer = normalizeOpenIdIssuer(user.openidIssuer);
if (userIssuer) return userIssuer === openidIssuer;
return isLegacyOpenIdIssuer(openidIssuer);
}
function resolveIssuerBoundUser(
user: IUser | null,
normalizedIssuer: string | undefined,
strategyName: string,
context: string,
): OpenIdUserResolution | null {
if (!user?.openidId) return null;
if (!isUserIssuerAllowed(user, normalizedIssuer)) {
logger.warn(
`[${strategyName}] Rejected ${context} for ${user.email}: stored openidIssuer does not match token issuer`,
);
return { user: null, error: ErrorTypes.AUTH_FAILED, migration: false };
}
if (normalizedIssuer && !normalizeOpenIdIssuer(user.openidIssuer)) {
user.openidIssuer = normalizedIssuer;
return { user, error: null, migration: true };
}
return null;
}
/**
* Resolves the OpenID user identifier claim, honoring OPENID_EMAIL_CLAIM before
* email/preferred_username/upn fallbacks.
*/
export function getOpenIdEmail(
claims: OpenIdEmailClaims | null | undefined,
strategyName = 'openidStrategy',
): string | undefined {
if (claims == null) return undefined;
const claimKey = process.env.OPENID_EMAIL_CLAIM?.trim();
if (claimKey) {
const value = claims[claimKey];
if (typeof value === 'string' && value) return value;
if (value != null) {
logger.warn(
`[${strategyName}] OPENID_EMAIL_CLAIM="${claimKey}" resolved to a non-string value (type: ${typeof value}). Falling back to: email -> preferred_username -> upn.`,
);
} else {
logger.warn(
`[${strategyName}] OPENID_EMAIL_CLAIM="${claimKey}" not present in userinfo. Falling back to: email -> preferred_username -> upn.`,
);
}
}
return (
getStringClaim(claims, 'email') ??
getStringClaim(claims, 'preferred_username') ??
getStringClaim(claims, 'upn')
);
}
/**
* Finds or migrates a user for OpenID authentication
* @returns user object (with migration fields if needed), error message, and whether migration is needed
*/
export async function findOpenIDUser({
openidId,
findUser,
email,
openidIssuer,
idOnTheSource,
strategyName = 'openid',
}: {
openidId: string;
findUser: UserMethods['findUser'];
email?: string;
openidIssuer?: string;
idOnTheSource?: string;
strategyName?: string;
}): Promise<OpenIdUserResolution> {
const lookupStartedAt = isMetricsConfigured() ? process.hrtime.bigint() : null;
const finish = (resolution: OpenIdUserResolution): OpenIdUserResolution => {
if (lookupStartedAt != null) {
recordOpenIDUserLookup(
getOpenIDUserLookupResult(resolution),
getElapsedSeconds(lookupStartedAt),
);
}
return resolution;
};
try {
const normalizedIssuer = normalizeOpenIdIssuer(openidIssuer);
const primaryConditions = getPrimaryLookupConditions(openidId, idOnTheSource, normalizedIssuer);
let user: IUser | null = null;
if (primaryConditions.length > 0) {
user = await findFirstOpenIdUser(findUser, primaryConditions);
}
const primaryIssuerResolution = resolveIssuerBoundUser(
user,
normalizedIssuer,
strategyName,
'OpenID lookup',
);
if (primaryIssuerResolution) return finish(primaryIssuerResolution);
if (!user && email) {
user = await findUser({ email });
logger.warn(
`[${strategyName}] user ${user ? 'found' : 'not found'} with email: ${email} for openidId: ${openidId}`,
);
// If user found by email, check if they're allowed to use OpenID provider
if (user && user.provider && user.provider !== 'openid') {
logger.warn(
`[${strategyName}] Attempted OpenID login by user ${user.email}, was registered with "${user.provider}" provider`,
);
return finish({ user: null, error: ErrorTypes.AUTH_FAILED, migration: false });
}
if (user?.openidId && user.openidId !== openidId) {
logger.warn(
`[${strategyName}] Rejected email fallback for ${user.email}: stored openidId does not match token sub`,
);
return finish({ user: null, error: ErrorTypes.AUTH_FAILED, migration: false });
}
const emailIssuerResolution = resolveIssuerBoundUser(
user,
normalizedIssuer,
strategyName,
'email fallback',
);
if (emailIssuerResolution) return finish(emailIssuerResolution);
if (user && !user.openidId) {
logger.info(
`[${strategyName}] Preparing user ${user.email} for migration to OpenID with sub: ${openidId}`,
);
user.provider = 'openid';
user.openidId = openidId;
if (normalizedIssuer) user.openidIssuer = normalizedIssuer;
return finish({ user, error: null, migration: true });
}
}
return finish({ user, error: null, migration: false });
} catch (error) {
if (lookupStartedAt != null) {
recordOpenIDUserLookup('error', getElapsedSeconds(lookupStartedAt));
}
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;
}
/**
* Creates a first-login OpenID user, in the USER role, through `createUserOnce`, which admits it
* under the USER role's config and under `claimedRole`'s, the role this login's claims move it
* into, before creating it. It recovers a concurrent first login by repeating `findOpenIDUser`,
* with its provider and issuer checks, once the winner finished provisioning the account,
* admitting that account exactly as a found one (its own config and email-domain policy). The
* recovered account is refreshed with this callback's claims like any account the lookup finds.
* Returns the account with the config the login continues under, and whether this call
* created it.
*/
export async function createOpenIDUser({
lookup,
profile,
claimedRole,
getAppConfig,
getBalanceConfig,
createUserIfAbsent,
findBalanceByUser,
}: {
lookup: Parameters<typeof findOpenIDUser>[0];
profile: OpenIDProfile;
claimedRole?: string;
getAppConfig: GetAppConfig;
getBalanceConfig: GetBalanceConfig;
createUserIfAbsent: CreateUserIfAbsent;
findBalanceByUser: FindBalanceByUser;
}): Promise<{ user: UserRecord; appConfig: AppConfig; created: boolean }> {
const result = await createUserOnce({
strategyName: lookup.strategyName ?? 'openid',
newUser: {
provider: 'openid',
role: SystemRoles.USER,
openidId: profile.openidId,
username: profile.username,
email: profile.email || '',
emailVerified: profile.emailVerified,
name: profile.name,
idOnTheSource: profile.idOnTheSource,
openidIssuer: profile.openidIssuer,
},
email: profile.email ?? '',
claimedRole,
getAppConfig,
getBalanceConfig,
lookup: () => findOpenIDUser(lookup),
createUserIfAbsent,
findBalanceByUser,
});
if (result.error !== null) throw new Error(result.error);
return {
user: result.created ? result.user : applyOpenIDProfile(result.user, profile),
appConfig: result.appConfig,
created: result.created,
};
}