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 { createFallbackRetentionDate } from '@librechat/data-schemas';
import { isAllDataRetention, isForcedTemporaryRetention } from 'librechat-data-provider';
import type { AppConfig } from '@librechat/data-schemas';
type InterfaceConfig = AppConfig['interfaceConfig'];
const retentionExpiryCache = new WeakMap<
RetentionRequest,
{
key: string;
promise: Promise<RetentionExpiry>;
}
>();
export type RetentionConversation = {
isTemporary?: boolean | null;
expiredAt?: Date | string | number | null;
};
export type RetentionRequest = {
/** Owner-authenticated source row for operations attached to an existing message. */
fileRetentionSource?: RetentionConversation;
user?: {
id?: string;
tenantId?: string;
};
body?: {
conversationId?: string;
isTemporary?: boolean | string | null;
};
config?: {
interfaceConfig?: InterfaceConfig;
/** Kept so storage strategies can delete files for a request reduced to its retention inputs. */
paths?: Record<string, string>;
};
};
export type RetentionExpiry = {
expiredAt?: Date | null;
};
export type AgentFileRetentionRequest = {
req: RetentionRequest | null | undefined;
messageAttachment?: boolean | null;
toolResource?: string | null;
};
export type RetentionLogger = {
error: (message: string, error?: unknown) => void;
};
export type RetentionDependencies = {
getConvo: (
userId: string,
conversationId: string,
) => Promise<RetentionConversation | null | undefined>;
createExpirationDate: (interfaceConfig?: InterfaceConfig, isTemporary?: boolean) => Date;
logger?: RetentionLogger;
};
export type SharedLinkRetentionDependencies = {
getConvo: (
userId: string,
conversationId: string,
) => Promise<RetentionConversation | null | undefined>;
createExpirationDate: (interfaceConfig?: InterfaceConfig, isTemporary?: boolean) => Date;
logger?: RetentionLogger;
};
export const isBooleanOrStringTrue = (value: unknown): boolean =>
value === true || value === 'true';
export const getConversationExpirationDate = (
convo?: RetentionConversation | null,
): Date | null => {
if (convo?.expiredAt == null) {
return null;
}
const expiredAt = convo.expiredAt instanceof Date ? convo.expiredAt : new Date(convo.expiredAt);
return Number.isNaN(expiredAt.getTime()) ? null : expiredAt;
};
export const isActiveExpirationDate = (expiredAt: Date, now: Date = new Date()): boolean =>
expiredAt > now;
const createRetentionExpiry = (
req: RetentionRequest | null | undefined,
{ createExpirationDate, logger }: RetentionDependencies,
isTemporary = isBooleanOrStringTrue(req?.body?.isTemporary),
): RetentionExpiry => {
try {
return { expiredAt: createExpirationDate(req?.config?.interfaceConfig, isTemporary) };
} catch (err) {
logger?.error('[getRetentionExpiry] Error creating file expiration date:', err);
return { expiredAt: createFallbackRetentionDate() };
}
};
const getRetentionCacheKey = (req: RetentionRequest): string =>
[
req.config?.interfaceConfig?.retentionMode ?? '',
req.config?.interfaceConfig?.temporaryChatRetention ?? '',
req.config?.interfaceConfig?.generalChatRetention ?? '',
req.user?.id ?? '',
req.body?.conversationId ?? '',
String(req.body?.isTemporary ?? ''),
String(req.fileRetentionSource?.expiredAt ?? ''),
String(req.fileRetentionSource?.isTemporary ?? ''),
String(req.fileRetentionSource != null),
].join('|');
async function computeRetentionExpiry(
req: RetentionRequest | null | undefined,
dependencies: RetentionDependencies,
): Promise<RetentionExpiry> {
const interfaceConfig = req?.config?.interfaceConfig;
const isForcedTemporary = isForcedTemporaryRetention(interfaceConfig?.retentionMode);
const isRetentionAll = isAllDataRetention(interfaceConfig?.retentionMode);
const conversationId = req?.body?.conversationId;
const userId = req?.user?.id;
/** A source message's stored deadline wins in every mode, so a file attached late in a
* chat never outlives the message and conversation that reference it. */
if (req?.fileRetentionSource != null) {
const source = req.fileRetentionSource;
const expiredAt = getConversationExpirationDate(source);
if (expiredAt != null) {
return { expiredAt };
}
const isTemporary = isForcedTemporary || source.isTemporary === true;
return isRetentionAll || isTemporary
? createRetentionExpiry(req, dependencies, isTemporary)
: {};
}
if (isForcedTemporary) {
return createRetentionExpiry(req, dependencies, true);
}
if (
isRetentionAll &&
(interfaceConfig?.generalChatRetention === undefined ||
(req?.body?.isTemporary != null && !(conversationId && userId)))
) {
return createRetentionExpiry(req, dependencies);
}
if (conversationId && userId) {
try {
const convo = await dependencies.getConvo(userId, conversationId);
if (convo) {
const expiredAt = getConversationExpirationDate(convo);
if (expiredAt == null) {
if (isRetentionAll || isBooleanOrStringTrue(req?.body?.isTemporary)) {
return createRetentionExpiry(req, dependencies, convo.isTemporary === true);
}
return {};
}
if (!isActiveExpirationDate(expiredAt)) {
return { expiredAt };
}
return createRetentionExpiry(req, dependencies, convo.isTemporary !== false);
}
} catch (err) {
dependencies.logger?.error(
'[getRetentionExpiry] Error checking conversation retention:',
err,
);
if (isRetentionAll) {
const temporaryExpiry = createRetentionExpiry(req, dependencies, true).expiredAt;
const generalExpiry = createRetentionExpiry(req, dependencies, false).expiredAt;
if (temporaryExpiry && generalExpiry) {
return { expiredAt: temporaryExpiry < generalExpiry ? temporaryExpiry : generalExpiry };
}
return { expiredAt: temporaryExpiry ?? generalExpiry };
}
if (isBooleanOrStringTrue(req?.body?.isTemporary)) {
return createRetentionExpiry(req, dependencies, true);
}
return {};
}
}
if (!isRetentionAll && !isBooleanOrStringTrue(req?.body?.isTemporary)) {
return {};
}
return createRetentionExpiry(req, dependencies);
}
export async function getRetentionExpiry(
req: RetentionRequest | null | undefined,
dependencies: RetentionDependencies,
): Promise<RetentionExpiry> {
if (!req) {
return {};
}
const key = getRetentionCacheKey(req);
const cached = retentionExpiryCache.get(req);
if (cached?.key === key) {
return cached.promise;
}
const promise = computeRetentionExpiry(req, dependencies);
retentionExpiryCache.set(req, { key, promise });
return promise;
}
const isPersistentAgentResourceUpload = ({
messageAttachment,
toolResource,
}: Omit<AgentFileRetentionRequest, 'req'>): boolean => !messageAttachment && !!toolResource;
const shouldRetainPersistentAgentFile = ({
req,
messageAttachment,
toolResource,
}: AgentFileRetentionRequest): boolean => {
const interfaceConfig = req?.config?.interfaceConfig;
return (
isPersistentAgentResourceUpload({ messageAttachment, toolResource }) &&
(!isAllDataRetention(interfaceConfig?.retentionMode) ||
interfaceConfig?.retainAgentFiles === true)
);
};
export async function getAgentFileRetentionExpiry(
params: AgentFileRetentionRequest,
dependencies: RetentionDependencies,
): Promise<RetentionExpiry> {
if (shouldRetainPersistentAgentFile(params)) {
return {};
}
return await getRetentionExpiry(params.req, dependencies);
}
/**
* Resolves the retention deadline for a shared link derived from a conversation.
*
* Return values are intentionally tri-state:
* - `undefined`: no decision can be made because the conversation id or row is missing.
* - `null`: the share should be stored without an expiration.
* - `Date`: the share should expire at that date; callers reject already-expired dates.
*/
export async function getSharedLinkExpiration(
{
req,
conversationId,
}: {
req: RetentionRequest | null | undefined;
conversationId?: string | null;
},
dependencies: SharedLinkRetentionDependencies,
): Promise<Date | null | undefined> {
const userId = req?.user?.id;
if (!conversationId || !userId) {
return undefined;
}
const isRetentionAll = isAllDataRetention(req?.config?.interfaceConfig?.retentionMode);
const convo = await dependencies.getConvo(userId, conversationId);
if (!convo) {
return undefined;
}
const conversationExpiredAt = getConversationExpirationDate(convo);
if (conversationExpiredAt == null) {
if (!isRetentionAll) {
return null;
}
} else if (!isActiveExpirationDate(conversationExpiredAt)) {
return conversationExpiredAt;
}
try {
return dependencies.createExpirationDate(
req?.config?.interfaceConfig,
convo.isTemporary === true || (convo.isTemporary == null && conversationExpiredAt != null),
);
} catch (err) {
dependencies.logger?.error('[getSharedLinkExpiration] Error creating expiration date:', err);
return null;
}
}
export const createMinimalRetentionRequest = (
req?: RetentionRequest | null,
): RetentionRequest | undefined => {
if (!req) {
return undefined;
}
return {
fileRetentionSource: req.fileRetentionSource,
user: req.user
? {
id: req.user.id,
tenantId: req.user.tenantId,
}
: undefined,
body: {
conversationId: req.body?.conversationId,
isTemporary: req.body?.isTemporary,
},
config: {
interfaceConfig: req.config?.interfaceConfig,
paths: req.config?.paths,
},
};
};