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 type {
TMessage,
TAgentQueuedTurnReceipt,
TAgentQueuedTurnFileRef,
} from 'librechat-data-provider';
import type { QueuedMessage, SettledQueuedTurnReceipt } from './types';
import { hydrateFileDeliveryMetadata } from '../files';
type AgentQueuedTurnReceipt = TAgentQueuedTurnReceipt;
function compareQueuedMessages(a: QueuedMessage, b: QueuedMessage): number {
const priority = Number(b.priority ?? false) - Number(a.priority ?? false);
if (priority !== 0) {
return priority;
}
const aServerOrder = a.server?.revision;
const bServerOrder = b.server?.revision;
if (aServerOrder != null && bServerOrder != null && aServerOrder !== bServerOrder) {
return aServerOrder - bServerOrder;
}
if (a.server != null && b.server == null) {
return -1;
}
if (a.server == null && b.server != null) {
return 1;
}
return a.createdAt - b.createdAt;
}
function queuedTurnCreatedAt(receipt: AgentQueuedTurnReceipt): number {
const createdAt = Date.parse(receipt.createdAt);
return Number.isFinite(createdAt) ? createdAt : 0;
}
export type QueuedTurnReceiptSource = 'snapshot' | 'enqueue' | 'direct';
function isAdmissionIndeterminateReceipt(receipt: AgentQueuedTurnReceipt): boolean {
return (
receipt.failure?.code === 'ADMISSION_INDETERMINATE' &&
(receipt.status === 'claimed' || receipt.status === 'dead')
);
}
function settledEvidenceForReceipt(
receipt: AgentQueuedTurnReceipt,
): SettledQueuedTurnReceipt | undefined {
if (
receipt.status === 'admitted' &&
(receipt.effectivePredecessorCreatedAt != null || receipt.rootPredecessor === true)
) {
return {
clientRequestId: receipt.clientRequestId,
status: 'admitted',
...(receipt.effectivePredecessorCreatedAt != null && {
effectivePredecessorCreatedAt: receipt.effectivePredecessorCreatedAt,
}),
...(receipt.rootPredecessor === true && { rootPredecessor: true }),
};
}
if (receipt.status === 'admitted') {
return {
clientRequestId: receipt.clientRequestId,
status: 'admitted_pending_boundary',
};
}
if (isAdmissionIndeterminateReceipt(receipt)) {
return { clientRequestId: receipt.clientRequestId, status: 'indeterminate' };
}
if (receipt.status === 'cancelled') {
return { clientRequestId: receipt.clientRequestId, status: 'cancelled' };
}
if (receipt.status === 'dead') {
return { clientRequestId: receipt.clientRequestId, status: 'dead' };
}
return undefined;
}
/** Client receipt knowledge is a monotonic evidence lattice. Enqueue is the
* only source that can carry a pre-scheduling snapshot, so it never weakens
* evidence already observed by GET/direct settlement. Indeterminate evidence
* can advance only through a later authoritative terminal observation. */
export function mergeSettledQueuedTurnEvidence(
existing: SettledQueuedTurnReceipt | undefined,
receipt: AgentQueuedTurnReceipt,
source: QueuedTurnReceiptSource,
): SettledQueuedTurnReceipt | undefined {
const incoming = settledEvidenceForReceipt(receipt);
if (existing == null) {
return incoming;
}
if (existing.status === 'admitted_pending_boundary' && incoming?.status === 'admitted') {
return incoming;
}
if (
existing.status === 'indeterminate' &&
source !== 'enqueue' &&
incoming != null &&
incoming.status !== 'indeterminate'
) {
return incoming;
}
return existing;
}
export function toQueuedTurnFileRefs(
files: TMessage['files'],
): TAgentQueuedTurnFileRef[] | undefined {
const refs = (files ?? []).flatMap((file): TAgentQueuedTurnFileRef[] => {
if (typeof file.file_id !== 'string' || file.file_id.length === 0) {
return [];
}
return [
{
file_id: file.file_id,
...(file.type != null && { type: file.type }),
...(file.filepath != null && { filepath: file.filepath }),
...(file.filename != null && { filename: file.filename }),
...(file.llmDeliveryPath != null && { llmDeliveryPath: file.llmDeliveryPath }),
...(file.height != null && { height: file.height }),
...(file.width != null && { width: file.width }),
...(file.bytes != null && { bytes: file.bytes }),
},
];
});
return refs.length > 0 ? refs : undefined;
}
export function reconcileServerQueuedTurns(
previous: QueuedMessage[],
receipts: AgentQueuedTurnReceipt[],
settledByRequestId: ReadonlyMap<string, SettledQueuedTurnReceipt>,
authoritativeSnapshot = true,
storedFiles?: Parameters<typeof hydrateFileDeliveryMetadata>[2],
): QueuedMessage[] {
const previousByClientRequestId = new Map(
previous.flatMap((item) =>
item.clientRequestId != null ? [[item.clientRequestId, item] as const] : [],
),
);
const observedClientRequestIds = new Set(receipts.map((receipt) => receipt.clientRequestId));
const projected = receipts.flatMap((receipt): QueuedMessage[] => {
const settled = settledByRequestId.get(receipt.clientRequestId);
const admissionIndeterminate = isAdmissionIndeterminateReceipt(receipt);
if (settled?.status === 'admitted' || settled?.status === 'cancelled') {
return [];
}
const optimistic = previousByClientRequestId.get(receipt.clientRequestId);
if (
(settled?.status === 'dead' ||
settled?.status === 'admitted_pending_boundary' ||
(settled?.status === 'indeterminate' && !admissionIndeterminate)) &&
receipt.status !== 'dead' &&
receipt.status !== 'admitted'
) {
return optimistic == null ? [] : [optimistic];
}
const boundaryPending = receipt.status === 'admitted';
let status: NonNullable<QueuedMessage['server']>['status'] = 'rejected';
if (admissionIndeterminate) {
status = 'indeterminate';
} else if (boundaryPending) {
status = 'uncertain';
} else if (receipt.status === 'queued' || receipt.status === 'claimed') {
status = receipt.status;
}
const files = hydrateFileDeliveryMetadata(receipt.files, optimistic?.files, storedFiles);
return [
{
id: optimistic?.id ?? receipt.clientRequestId,
text: receipt.text,
createdAt: queuedTurnCreatedAt(receipt),
clientRequestId: receipt.clientRequestId,
parentMessageId: receipt.parentMessageId,
...(receipt.expectedPredecessorCreatedAt != null && {
expectedPredecessorCreatedAt: receipt.expectedPredecessorCreatedAt,
}),
...(files != null && files.length > 0 && { files }),
...(receipt.quotes != null && receipt.quotes.length > 0 && { quotes: receipt.quotes }),
...(receipt.manualSkills != null &&
receipt.manualSkills.length > 0 && {
manualSkills: receipt.manualSkills,
}),
...(receipt.reasoningOverride != null && {
reasoningOverride: receipt.reasoningOverride,
}),
...(receipt.priority === true && { priority: true }),
server: {
id: receipt.queuedTurnId,
status,
revision: receipt.revision,
...(boundaryPending && {
uncertainSince: optimistic?.server?.uncertainSince ?? Date.now(),
}),
...(receipt.position != null && { position: receipt.position }),
...(receipt.failure?.code != null && { errorCode: receipt.failure.code }),
...(receipt.failure?.message != null && { errorMessage: receipt.failure.message }),
},
},
];
});
const retained = previous.filter((item) => {
if (item.server == null) {
return true;
}
const settled =
item.clientRequestId == null ? undefined : settledByRequestId.get(item.clientRequestId);
if (settled?.status === 'admitted' || settled?.status === 'cancelled') {
return false;
}
if (settled?.status === 'dead' || settled?.status === 'admitted_pending_boundary') {
return item.clientRequestId == null || !observedClientRequestIds.has(item.clientRequestId);
}
if (item.clientRequestId == null || observedClientRequestIds.has(item.clientRequestId)) {
return false;
}
if (!authoritativeSnapshot) {
return true;
}
return (
item.server.status === 'sending' ||
item.server.status === 'uncertain' ||
item.server.status === 'indeterminate' ||
item.server.status === 'rejected'
);
});
return [...retained, ...projected].sort(compareQueuedMessages);
}
/**
* Whether the backend owes this conversation a run it will start itself.
*
* Wider than the receipt poll's own predicate in exactly one way: `admitted`. The receipt poll
* stops there because there is nothing left to wait for, but for a pane that is not attached,
* `admitted` is the strongest evidence it will get that a run exists, and the receipt is dropped
* from the projection almost immediately after (the chip goes, so its id leaves the known set).
* Anyone deciding whether to keep listening for that run must count it.
*/
export function isQueuedTurnSuccessorOwed(receipts: unknown): boolean {
return (
Array.isArray(receipts) &&
receipts.some(
(item: AgentQueuedTurnReceipt) =>
item.status === 'queued' ||
item.status === 'admitted' ||
(item.status === 'claimed' && item.failure?.code !== 'ADMISSION_INDETERMINATE'),
)
);
}