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 { Constants } from 'librechat-data-provider';
import type { MCPRuntimeRequestBody, RequestScopedMCPConnectionStore } from './types';
export type { MCPRuntimeRequestBody } from './types';
/**
* Builds the complete request context that runtime MCP placeholders may resolve.
* An explicit null parent means a known root turn and becomes the root sentinel.
* An omitted parent stays omitted so protocols without parent-message identity
* fail closed for configurations that require that BODY placeholder.
*/
export function createMCPRuntimeRequestBody({
messageId,
conversationId,
parentMessageId,
codeEnvironmentMode,
codeWorkspaces,
}: {
messageId: string;
conversationId: string;
parentMessageId?: string | null;
codeEnvironmentMode?: MCPRuntimeRequestBody['codeEnvironmentMode'];
codeWorkspaces?: MCPRuntimeRequestBody['codeWorkspaces'];
}): MCPRuntimeRequestBody {
return {
messageId,
conversationId,
...(codeEnvironmentMode !== undefined && { codeEnvironmentMode }),
...(codeWorkspaces !== undefined && { codeWorkspaces }),
...(parentMessageId !== undefined && {
parentMessageId: parentMessageId ?? Constants.NO_PARENT,
}),
};
}
export interface MCPRequestContext extends RequestScopedMCPConnectionStore {
cleanupStarted: boolean;
cleanupOnResponse: boolean;
responseCleanupAttached: boolean;
}
export interface MCPRequestContextOptions {
cleanupOnResponse?: boolean;
}
interface MCPResponseLike {
writableEnded?: boolean;
finished?: boolean;
destroyed?: boolean;
once?: (event: 'finish' | 'close', listener: () => void) => unknown;
}
interface Disconnectable {
disconnect: () => Promise<unknown> | unknown;
dispose?: () => Promise<unknown> | unknown;
}
const contexts = new WeakMap<object, MCPRequestContext>();
const contextRetentions = new WeakMap<
RequestScopedMCPConnectionStore,
{ holds: number; cleanupRequested: boolean }
>();
const cleanupFlights = new WeakMap<RequestScopedMCPConnectionStore, Promise<void>>();
const requestControllers = new WeakMap<RequestScopedMCPConnectionStore, AbortController>();
/** Owned by the occurrence, not an individual connection or mint waiter. */
export function getMCPRequestSignal(context: RequestScopedMCPConnectionStore): AbortSignal {
let controller = requestControllers.get(context);
if (!controller) {
controller = new AbortController();
requestControllers.set(context, controller);
if (context.cleanupStarted || context.quiesceStarted)
controller.abort(new MCPRequestQuiescedError());
}
return controller.signal;
}
function abortMCPRequest(context: RequestScopedMCPConnectionStore): void {
requestControllers.get(context)?.abort(new MCPRequestQuiescedError());
}
/** Completion cancellation is not evidence of withdrawn consent. */
export class MCPRequestQuiescedError extends Error {
constructor() {
super('MCP request has settled.');
this.name = 'AbortError';
}
}
export function createMCPRequestContext(): MCPRequestContext {
return {
connections: new Map<string, unknown>(),
pending: new Map<string, Promise<unknown>>(),
cleanupStarted: false,
cleanupOnResponse: true,
responseCleanupAttached: false,
};
}
/** Keeps normal cleanup deferred while an admitted child task owns the context. */
export function retainMCPRequestContext(context: RequestScopedMCPConnectionStore): () => void {
let retention = contextRetentions.get(context);
if (
context.cleanupStarted ||
context.quiesceStarted ||
(retention?.cleanupRequested && retention.holds === 0)
) {
throw new MCPRequestQuiescedError();
}
if (!retention) {
retention = { holds: 0, cleanupRequested: false };
contextRetentions.set(context, retention);
}
retention.holds++;
let released = false;
return () => {
if (released) return;
released = true;
retention.holds--;
if (retention.holds === 0 && retention.cleanupRequested) runCleanup(context);
};
}
function isDisconnectable(value: unknown): value is Disconnectable {
return (
value != null &&
typeof value === 'object' &&
'disconnect' in value &&
typeof value.disconnect === 'function'
);
}
/** Stops occurrence work and exposes admission failure to the settlement owner. */
export function quiesceMCPRequestContext(context?: RequestScopedMCPConnectionStore): Promise<void> {
if (!context) return Promise.resolve();
context.quiesceStarted = true;
context.cleanupStarted = true;
let flight = cleanupFlights.get(context);
if (!flight) {
flight = Promise.resolve().then(() => disposeContext(context, true));
cleanupFlights.set(context, flight);
}
// Publish the cutoff and joinable flight before synchronous abort listeners run.
abortMCPRequest(context);
return flight;
}
async function disposeContext(
context: RequestScopedMCPConnectionStore,
strict = false,
): Promise<void> {
const connections = new Map<Disconnectable, string>();
for (const [key, connection] of context.connections) {
if (isDisconnectable(connection)) connections.set(connection, key);
}
try {
const pending = Array.from(context.pending.entries());
const settled = await Promise.allSettled(pending.map(([, promise]) => promise));
for (let index = 0; index < settled.length; index++) {
const result = settled[index];
if (result.status === 'fulfilled' && isDisconnectable(result.value))
connections.set(result.value, pending[index][0]);
}
const disposed = await Promise.allSettled(
Array.from(connections).map(async ([connection, key]) => {
// Pool eviction is best-effort. Settlement must observe the connection's admission result.
if (strict && connection.dispose) {
try {
await connection.dispose();
} finally {
await context.disposeConnection?.(key, connection);
}
} else if (context.disposeConnection) await context.disposeConnection(key, connection);
else if (connection.dispose) await connection.dispose();
else await connection.disconnect();
}),
);
const failed = disposed.find((result) => result.status === 'rejected');
if (failed?.status === 'rejected') throw failed.reason;
} finally {
context.connections.clear();
context.pending.clear();
}
}
export async function cleanupMCPRequestContext(
context?: RequestScopedMCPConnectionStore,
): Promise<void> {
if (!context) return;
const retention = contextRetentions.get(context);
if (retention) {
retention.cleanupRequested = true;
if (retention.holds > 0 && !context.cleanupStarted && !context.quiesceStarted) return;
}
let flight = cleanupFlights.get(context);
if (!flight) {
if (context.cleanupStarted) {
abortMCPRequest(context);
return;
}
context.cleanupStarted = true;
flight = Promise.resolve().then(() => disposeContext(context));
cleanupFlights.set(context, flight);
}
abortMCPRequest(context);
await flight.catch(() => {
logger.warn('[MCP Request Context] Failed to dispose request-scoped connection');
});
}
function isResponseFinished(res?: MCPResponseLike): boolean {
return Boolean(res?.writableEnded || res?.finished || res?.destroyed);
}
function runCleanup(context: RequestScopedMCPConnectionStore): void {
cleanupMCPRequestContext(context).catch(() => {
logger.warn('[MCP Request Context] Cleanup failed');
});
}
function attachResponseCleanup(context: MCPRequestContext, res?: MCPResponseLike): void {
if (!res || context.responseCleanupAttached || context.cleanupOnResponse === false) {
return;
}
const cleanup = () => runCleanup(context);
if (isResponseFinished(res)) {
cleanup();
return;
}
if (typeof res.once !== 'function') {
return;
}
context.responseCleanupAttached = true;
res.once('finish', cleanup);
res.once('close', cleanup);
if (isResponseFinished(res)) {
cleanup();
}
}
export function getMCPRequestContext(
req?: object,
res?: MCPResponseLike,
options: MCPRequestContextOptions = {},
): MCPRequestContext | undefined {
if (!req) {
return undefined;
}
const cleanupOnResponse = options.cleanupOnResponse !== false;
let context = contexts.get(req);
if (!context) {
if (cleanupOnResponse && isResponseFinished(res)) {
return undefined;
}
context = createMCPRequestContext();
context.cleanupOnResponse = cleanupOnResponse;
contexts.set(req, context);
} else if (!cleanupOnResponse) {
context.cleanupOnResponse = false;
}
if (cleanupOnResponse) {
attachResponseCleanup(context, res);
}
return context.cleanupStarted ? undefined : context;
}
export async function cleanupMCPRequestContextForReq(req?: object): Promise<void> {
if (!req) {
return;
}
const context = contexts.get(req);
if (!context) {
return;
}
try {
await cleanupMCPRequestContext(context);
} finally {
// Retained request closures must keep their original scope, including its final cutoff.
if (!contextRetentions.has(context)) contexts.delete(req);
}
}