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 crypto from 'crypto';
import { logger } from '@librechat/data-schemas';
import {
ErrorTypes,
EModelEndpoint,
extractEnvVariable,
normalizeEndpointName,
} from 'librechat-data-provider';
import type { TModelsConfig, TEndpoint } from 'librechat-data-provider';
import type { AppConfig } from '@librechat/data-schemas';
import type { ServerRequest, GetUserKeyValuesFunction, UserKeyValues } from '~/types';
import type { FetchModelsParams } from '~/endpoints/models';
import type { GetAppConfigOptions } from '~/app/service';
import { fetchModels as defaultFetchModels } from '~/endpoints/models';
import { isServedCustomEndpoint } from '~/endpoints/custom/config';
import { getTokenConfigKey } from '~/endpoints/custom/initialize';
import { getAppConfigOptionsFromUser } from '~/app/service';
/**
* Built-in endpoints whose configured `models` list replaces their `*_MODELS`
* environment list. Read per request, so principal overrides can narrow them.
*/
type ConfiguredModelListEndpoint =
| EModelEndpoint.openAI
| EModelEndpoint.google
| EModelEndpoint.anthropic
| EModelEndpoint.bedrock;
const CONFIGURED_MODEL_LIST_ENDPOINTS: readonly ConfiguredModelListEndpoint[] = [
EModelEndpoint.openAI,
EModelEndpoint.google,
EModelEndpoint.anthropic,
EModelEndpoint.bedrock,
];
/**
* The model list configured for a built-in endpoint in the resolved config, or
* `undefined` when none is set. A configured list replaces the environment list
* and makes provider discovery unnecessary.
*/
export function configuredModelList(
appConfig: AppConfig | null | undefined,
endpoint: ConfiguredModelListEndpoint,
): string[] | undefined {
const models = appConfig?.endpoints?.[endpoint]?.models;
if (!Array.isArray(models)) {
return undefined;
}
return models.filter((model): model is string => typeof model === 'string');
}
import { resolveConfigSecret } from '~/admin/secrets';
import { validateEndpointURL } from '~/auth';
import { tokenConfigCache } from '~/cache';
import { isUserProvided } from '~/utils';
/**
* Stable fingerprint of a headers object, used to disambiguate the
* in-request fetch-coalescing key. Two endpoints that share the same
* baseURL+apiKey but configure different headers must NOT share a fetch
* promise, otherwise the first endpoint's filtered /models response would
* be reused for the other in the same request.
*/
function headersFingerprint(headers: Record<string, string> | undefined): string {
if (!headers || Object.keys(headers).length === 0) {
return '';
}
const ordered = Object.keys(headers)
.sort()
.map((k) => [k, headers[k]]);
return crypto.createHash('sha256').update(JSON.stringify(ordered)).digest('hex').slice(0, 16);
}
interface ResolvedEndpoint {
name: string;
endpoint: TEndpoint;
apiKey: string;
baseURL: string;
apiKeyIsUserProvided: boolean;
baseURLIsUserProvided: boolean;
}
export interface LoadConfigModelsDeps {
getAppConfig: (params: GetAppConfigOptions) => Promise<AppConfig>;
getUserKeyValues: GetUserKeyValuesFunction;
fetchModels?: (params: FetchModelsParams) => Promise<string[]>;
}
export function createLoadConfigModels(deps: LoadConfigModelsDeps) {
const { getAppConfig, getUserKeyValues, fetchModels = defaultFetchModels } = deps;
return async function loadConfigModels(req: ServerRequest): Promise<TModelsConfig> {
const appConfig = req.config ?? (await getAppConfig(getAppConfigOptionsFromUser(req.user)));
if (!appConfig) {
return {};
}
const modelsConfig: TModelsConfig = {};
const azureConfig = appConfig.endpoints?.[EModelEndpoint.azureOpenAI];
const { modelNames } = azureConfig ?? {};
if (modelNames && azureConfig) {
modelsConfig[EModelEndpoint.azureOpenAI] = modelNames;
}
if (azureConfig?.assistants && azureConfig.assistantModels) {
modelsConfig[EModelEndpoint.azureAssistants] = azureConfig.assistantModels;
}
for (const endpoint of CONFIGURED_MODEL_LIST_ENDPOINTS) {
const models = configuredModelList(appConfig, endpoint);
if (models) {
modelsConfig[endpoint] = models;
}
}
if (!Array.isArray(appConfig.endpoints?.[EModelEndpoint.custom])) {
return modelsConfig;
}
const customEndpoints = (appConfig.endpoints[EModelEndpoint.custom] as TEndpoint[]).filter(
isServedCustomEndpoint,
);
const fetchPromisesMap: Record<string, Promise<string[]>> = {};
const uniqueKeyToEndpointsMap: Record<string, string[]> = {};
/** tokenKey the deduped fetch cached its token config under, so siblings
* sharing the fetch can be backfilled with the same config afterward */
const uniqueKeyToTokenKey: Record<string, string> = {};
const endpointsMap: Record<string, TEndpoint> = {};
const tenantId = req.user?.tenantId;
const resolved: ResolvedEndpoint[] = [];
const userKeyEndpoints: ResolvedEndpoint[] = [];
for (let i = 0; i < customEndpoints.length; i++) {
const endpoint = customEndpoints[i];
const { name: configName, baseURL, apiKey } = endpoint;
const name = normalizeEndpointName(configName);
endpointsMap[name] = endpoint;
modelsConfig[name] = [];
const resolvedApiKey = resolveConfigSecret(apiKey) ?? '';
const resolvedBaseURL = extractEnvVariable(baseURL);
const entry: ResolvedEndpoint = {
name,
endpoint,
apiKey: resolvedApiKey,
baseURL: resolvedBaseURL,
apiKeyIsUserProvided: isUserProvided(resolvedApiKey),
baseURLIsUserProvided: isUserProvided(resolvedBaseURL),
};
resolved.push(entry);
if (
endpoint.models?.fetch &&
(entry.apiKeyIsUserProvided || entry.baseURLIsUserProvided) &&
req.user?.id
) {
userKeyEndpoints.push(entry);
}
}
const userKeyMap = new Map<string, UserKeyValues | null>();
if (userKeyEndpoints.length > 0 && req.user?.id) {
const userId = req.user.id;
const results = await Promise.allSettled(
userKeyEndpoints.map((e) => getUserKeyValues({ userId, name: e.name })),
);
for (let i = 0; i < userKeyEndpoints.length; i++) {
const settled = results[i];
if (settled.status === 'fulfilled') {
userKeyMap.set(userKeyEndpoints[i].name, settled.value);
} else {
const msg =
settled.reason instanceof Error ? settled.reason.message : String(settled.reason);
const isKeyNotFound =
msg.includes(ErrorTypes.NO_USER_KEY) || msg.includes(ErrorTypes.INVALID_USER_KEY);
if (isKeyNotFound) {
logger.debug(
`[loadConfigModels] No user key stored for endpoint "${userKeyEndpoints[i].name}"`,
);
} else {
logger.warn(
`[loadConfigModels] Failed to retrieve user key for "${userKeyEndpoints[i].name}": ${msg}`,
);
}
userKeyMap.set(userKeyEndpoints[i].name, null);
}
}
}
for (const {
name,
endpoint,
apiKey: API_KEY,
baseURL: BASE_URL,
apiKeyIsUserProvided,
baseURLIsUserProvided,
} of resolved) {
const { models, headers: endpointHeaders } = endpoint;
// Include a fingerprint of the configured headers so two admin-trusted
// endpoints that happen to share the same baseURL+apiKey but configure
// different (potentially user-bound) headers don't reuse each other's
// fetched model list within the same request.
const uniqueKey = `${BASE_URL}__${API_KEY}__${headersFingerprint(endpointHeaders)}`;
if (models?.fetch && !apiKeyIsUserProvided && !baseURLIsUserProvided) {
if (!fetchPromisesMap[uniqueKey]) {
/** User-scoped when configured headers resolve per user — the
* derived token config must not be cached under the shared name */
const tokenKey = getTokenConfigKey(endpoint, name, req.user?.id ?? '', tenantId);
uniqueKeyToTokenKey[uniqueKey] = tokenKey;
fetchPromisesMap[uniqueKey] = fetchModels({
name,
apiKey: API_KEY,
baseURL: BASE_URL,
baseURLIsUserProvided: false,
allowedAddresses: appConfig.endpoints?.allowedAddresses,
user: req.user?.id,
userObject: req.user,
headers: endpointHeaders,
direct: endpoint.directEndpoint,
userIdQuery: models.userIdQuery,
tokenKey,
});
}
uniqueKeyToEndpointsMap[uniqueKey] = uniqueKeyToEndpointsMap[uniqueKey] || [];
uniqueKeyToEndpointsMap[uniqueKey].push(name);
continue;
}
if (models?.fetch && userKeyMap.has(name)) {
const userKeyValues = userKeyMap.get(name);
const resolvedApiKey =
apiKeyIsUserProvided || baseURLIsUserProvided ? userKeyValues?.apiKey : API_KEY;
const resolvedBaseURL = baseURLIsUserProvided ? userKeyValues?.baseURL : BASE_URL;
if (resolvedApiKey && resolvedBaseURL) {
const userFetchKey = `user:${req.user?.id}:${name}`;
fetchPromisesMap[userFetchKey] =
fetchPromisesMap[userFetchKey] ||
(async () => {
if (baseURLIsUserProvided) {
await validateEndpointURL(
resolvedBaseURL,
name,
appConfig.endpoints?.allowedAddresses,
);
}
return fetchModels({
name,
apiKey: resolvedApiKey,
baseURL: resolvedBaseURL,
baseURLIsUserProvided,
allowedAddresses: appConfig.endpoints?.allowedAddresses,
user: req.user?.id,
userObject: req.user,
// Do not forward header overrides when the base URL is
// user-supplied: configured templates such as
// {{LIBRECHAT_OPENID_ID_TOKEN}} would otherwise resolve and be
// sent to a destination the user controls, leaking the user's
// identity token. Header overrides are only safe for endpoints
// whose base URL is admin-trusted.
headers: baseURLIsUserProvided ? undefined : endpointHeaders,
direct: endpoint.directEndpoint,
userIdQuery: models.userIdQuery,
skipCache: true,
/** Fetched with the user's key/URL — always user-scoped */
tokenKey: getTokenConfigKey(endpoint, name, req.user?.id ?? '', tenantId),
});
})();
uniqueKeyToEndpointsMap[userFetchKey] = uniqueKeyToEndpointsMap[userFetchKey] || [];
uniqueKeyToEndpointsMap[userFetchKey].push(name);
continue;
}
}
if (Array.isArray(models?.default)) {
modelsConfig[name] = models.default.map((model) =>
typeof model === 'string' ? model : model.name,
);
}
}
const settledResults = await Promise.allSettled(Object.values(fetchPromisesMap));
const uniqueKeys = Object.keys(fetchPromisesMap);
for (let i = 0; i < settledResults.length; i++) {
const currentKey = uniqueKeys[i];
const settled = settledResults[i];
if (settled.status === 'rejected') {
logger.warn(`[loadConfigModels] Model fetch failed for "${currentKey}":`, settled.reason);
}
const modelData = settled.status === 'fulfilled' ? settled.value : [];
const associatedNames = uniqueKeyToEndpointsMap[currentKey];
for (const name of associatedNames) {
const endpoint = endpointsMap[name];
const defaults = (endpoint.models?.default ?? []).map((m) =>
typeof m === 'string' ? m : m.name,
);
modelsConfig[name] = !modelData?.length ? defaults : modelData;
}
/** A shared fetch caches token config under one endpoint's tokenKey;
* copy it to the siblings so /token-config resolves each by its own
* name (the query is staleTime:Infinity and won't recover otherwise) */
const winnerTokenKey = uniqueKeyToTokenKey[currentKey];
if (settled.status === 'fulfilled' && winnerTokenKey != null && associatedNames.length > 1) {
const cache = tokenConfigCache();
const config = await cache.get(winnerTokenKey);
if (config != null) {
for (const name of associatedNames) {
const siblingKey = getTokenConfigKey(
endpointsMap[name],
name,
req.user?.id ?? '',
tenantId,
);
if (siblingKey !== winnerTokenKey) {
await cache.set(siblingKey, config);
}
}
}
}
}
return modelsConfig;
};
}