mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 14:08:21 +00:00
Playwright sends route.fetch(), the request fixture and page.request through one keep-alive agent per worker with no idle timeout, and Node's agent ignores a server's Keep-Alive hint without one. LibreChat and the fixture servers closed idle sockets after 6 s, so a request reusing a socket at that moment was reset (read ECONNRESET) or dropped (socket hang up): the remaining retried passes in wrapping.spec.ts and thread-fold.spec.ts. Run LibreChat with HTTP_KEEP_ALIVE_TIMEOUT_MS=0 and pass every fixture server and the replica proxy through keepIdleConnections(), and check in fixtures.spec.ts that each harness server answers without an idle deadline.
637 lines
18 KiB
JavaScript
637 lines
18 KiB
JavaScript
/**
|
|
* Stateful OpenAI Assistants API fixture for credential-free mock e2e tests.
|
|
*
|
|
* This deliberately implements only the provider operations LibreChat uses for
|
|
* Assistant CRUD and a text-only streamed run. It is a provider-boundary fake:
|
|
* LibreChat's real routes, OpenAI SDK client, persistence, content preflights,
|
|
* and SSE handling all remain in the request path.
|
|
*/
|
|
const http = require('http');
|
|
const { randomUUID } = require('crypto');
|
|
const { keepIdleConnections } = require('./keepalive');
|
|
|
|
const PORT = Number(process.env.E2E_ASSISTANTS_PORT) || 8890;
|
|
const DEFAULT_REPLY = process.env.E2E_ASSISTANTS_REPLY || 'E2E mock assistant reply: pong';
|
|
const MAX_BODY_BYTES = 1024 * 1024;
|
|
|
|
const assistants = new Map();
|
|
const threads = new Map();
|
|
const runs = new Map();
|
|
const requests = [];
|
|
|
|
function now() {
|
|
return Math.floor(Date.now() / 1000);
|
|
}
|
|
|
|
function createId(prefix) {
|
|
return `${prefix}_${randomUUID().replaceAll('-', '')}`;
|
|
}
|
|
|
|
function readBody(req) {
|
|
return new Promise((resolve, reject) => {
|
|
let raw = '';
|
|
req.setEncoding('utf8');
|
|
req.on('data', (chunk) => {
|
|
raw += chunk;
|
|
if (Buffer.byteLength(raw) > MAX_BODY_BYTES) {
|
|
reject(new Error('Request body exceeds fixture limit'));
|
|
req.destroy();
|
|
}
|
|
});
|
|
req.on('end', () => {
|
|
if (!raw) {
|
|
resolve({});
|
|
return;
|
|
}
|
|
try {
|
|
resolve(JSON.parse(raw));
|
|
} catch {
|
|
reject(new Error('Request body must be valid JSON'));
|
|
}
|
|
});
|
|
req.on('error', reject);
|
|
});
|
|
}
|
|
|
|
function sendJson(res, status, payload) {
|
|
const body = JSON.stringify(payload);
|
|
res.writeHead(status, {
|
|
'Content-Type': 'application/json',
|
|
'Content-Length': Buffer.byteLength(body),
|
|
});
|
|
res.end(body);
|
|
}
|
|
|
|
function sendError(res, status, message) {
|
|
sendJson(res, status, {
|
|
error: {
|
|
message,
|
|
type: status === 404 ? 'invalid_request_error' : 'e2e_fixture_error',
|
|
param: null,
|
|
code: null,
|
|
},
|
|
});
|
|
}
|
|
|
|
function asTextContent(content) {
|
|
if (typeof content === 'string') {
|
|
return [{ type: 'text', text: { value: content, annotations: [] } }];
|
|
}
|
|
if (!Array.isArray(content)) {
|
|
return [];
|
|
}
|
|
return content.map((part) => {
|
|
if (part?.type !== 'text') {
|
|
return part;
|
|
}
|
|
if (typeof part.text === 'string') {
|
|
return { ...part, text: { value: part.text, annotations: [] } };
|
|
}
|
|
return {
|
|
...part,
|
|
text: {
|
|
value: part.text?.value ?? '',
|
|
annotations: part.text?.annotations ?? [],
|
|
},
|
|
};
|
|
});
|
|
}
|
|
|
|
function createMessage({
|
|
threadId,
|
|
role,
|
|
content,
|
|
assistantId = null,
|
|
runId = null,
|
|
metadata = {},
|
|
}) {
|
|
return {
|
|
id: createId('msg'),
|
|
object: 'thread.message',
|
|
created_at: now(),
|
|
assistant_id: assistantId,
|
|
thread_id: threadId,
|
|
run_id: runId,
|
|
role,
|
|
content: asTextContent(content),
|
|
attachments: [],
|
|
metadata,
|
|
status: 'completed',
|
|
incomplete_details: null,
|
|
completed_at: now(),
|
|
incomplete_at: null,
|
|
};
|
|
}
|
|
|
|
function createAssistant(body) {
|
|
const createdAt = now();
|
|
return {
|
|
...body,
|
|
id: createId('asst'),
|
|
object: 'assistant',
|
|
created_at: createdAt,
|
|
name: body.name ?? null,
|
|
description: body.description ?? null,
|
|
instructions: body.instructions ?? null,
|
|
model: body.model,
|
|
tools: body.tools ?? [],
|
|
tool_resources: body.tool_resources ?? {},
|
|
metadata: body.metadata ?? {},
|
|
response_format: body.response_format ?? 'auto',
|
|
temperature: body.temperature ?? 1,
|
|
top_p: body.top_p ?? 1,
|
|
};
|
|
}
|
|
|
|
function listResponse(data) {
|
|
return {
|
|
object: 'list',
|
|
data,
|
|
first_id: data[0]?.id ?? null,
|
|
last_id: data[data.length - 1]?.id ?? null,
|
|
has_more: false,
|
|
};
|
|
}
|
|
|
|
function assistantReply(thread) {
|
|
const latestUserMessage = [...thread.messages]
|
|
.reverse()
|
|
.find((message) => message.role === 'user');
|
|
const text = latestUserMessage?.content
|
|
?.filter((part) => part?.type === 'text')
|
|
.map((part) => part.text?.value ?? '')
|
|
.join('\n');
|
|
const marker = text?.match(/E2E_REPLY:([A-Za-z0-9._-]+)/)?.[1];
|
|
return marker ? `E2E assistant reply ${marker}` : DEFAULT_REPLY;
|
|
}
|
|
|
|
/** The latest user text in a thread, where the e2e prompt markers live. */
|
|
function latestUserText(thread) {
|
|
const latestUserMessage = [...thread.messages]
|
|
.reverse()
|
|
.find((message) => message.role === 'user');
|
|
return (
|
|
latestUserMessage?.content
|
|
?.filter((part) => part?.type === 'text')
|
|
.map((part) => part.text?.value ?? '')
|
|
.join('\n') ?? ''
|
|
);
|
|
}
|
|
|
|
/** Open slow runs by id, so a cancel request can end the stream it belongs to. */
|
|
const slowRuns = new Map();
|
|
|
|
function runObject({ id, threadId, assistant, status, usage = null }) {
|
|
const timestamp = now();
|
|
return {
|
|
id,
|
|
object: 'thread.run',
|
|
created_at: timestamp,
|
|
assistant_id: assistant.id,
|
|
thread_id: threadId,
|
|
status,
|
|
started_at: timestamp,
|
|
expires_at: timestamp + 600,
|
|
cancelled_at: null,
|
|
failed_at: null,
|
|
completed_at: status === 'completed' ? timestamp : null,
|
|
required_action: null,
|
|
last_error: null,
|
|
model: assistant.model,
|
|
instructions: assistant.instructions ?? '',
|
|
tools: assistant.tools ?? [],
|
|
tool_resources: assistant.tool_resources ?? {},
|
|
metadata: {},
|
|
incomplete_details: null,
|
|
usage,
|
|
temperature: assistant.temperature ?? 1,
|
|
top_p: assistant.top_p ?? 1,
|
|
max_prompt_tokens: null,
|
|
max_completion_tokens: null,
|
|
truncation_strategy: { type: 'auto', last_messages: null },
|
|
response_format: assistant.response_format ?? 'auto',
|
|
tool_choice: 'auto',
|
|
parallel_tool_calls: true,
|
|
};
|
|
}
|
|
|
|
function runStep({ id, runId, threadId, assistantId, messageId, status }) {
|
|
const timestamp = now();
|
|
return {
|
|
id,
|
|
object: 'thread.run.step',
|
|
created_at: timestamp,
|
|
assistant_id: assistantId,
|
|
thread_id: threadId,
|
|
run_id: runId,
|
|
type: 'message_creation',
|
|
status,
|
|
step_details: {
|
|
type: 'message_creation',
|
|
message_creation: { message_id: messageId },
|
|
},
|
|
last_error: null,
|
|
expired_at: null,
|
|
cancelled_at: null,
|
|
failed_at: null,
|
|
completed_at: status === 'completed' ? timestamp : null,
|
|
metadata: null,
|
|
usage:
|
|
status === 'completed' ? { prompt_tokens: 8, completion_tokens: 6, total_tokens: 14 } : null,
|
|
};
|
|
}
|
|
|
|
function sendAssistantStream(res, { assistant, thread }) {
|
|
const runId = createId('run');
|
|
const stepId = createId('step');
|
|
const reply = assistantReply(thread);
|
|
const message = createMessage({
|
|
threadId: thread.id,
|
|
role: 'assistant',
|
|
content: reply,
|
|
assistantId: assistant.id,
|
|
runId,
|
|
});
|
|
const createdRun = runObject({
|
|
id: runId,
|
|
threadId: thread.id,
|
|
assistant,
|
|
status: 'queued',
|
|
});
|
|
const completedRun = runObject({
|
|
id: runId,
|
|
threadId: thread.id,
|
|
assistant,
|
|
status: 'completed',
|
|
usage: { prompt_tokens: 8, completion_tokens: 6, total_tokens: 14 },
|
|
});
|
|
const createdStep = runStep({
|
|
id: stepId,
|
|
runId,
|
|
threadId: thread.id,
|
|
assistantId: assistant.id,
|
|
messageId: message.id,
|
|
status: 'in_progress',
|
|
});
|
|
const completedStep = runStep({
|
|
id: stepId,
|
|
runId,
|
|
threadId: thread.id,
|
|
assistantId: assistant.id,
|
|
messageId: message.id,
|
|
status: 'completed',
|
|
});
|
|
const createdMessage = { ...message, content: [], status: 'in_progress', completed_at: null };
|
|
const messageDelta = {
|
|
id: message.id,
|
|
object: 'thread.message.delta',
|
|
delta: {
|
|
content: [
|
|
{
|
|
index: 0,
|
|
type: 'text',
|
|
text: { value: reply, annotations: [] },
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
runs.set(runId, completedRun);
|
|
thread.messages.push(message);
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'text/event-stream',
|
|
'Cache-Control': 'no-cache',
|
|
Connection: 'keep-alive',
|
|
});
|
|
const sendEvent = (event, data) => {
|
|
res.write(`event: ${event}\n`);
|
|
res.write(`data: ${JSON.stringify(data)}\n\n`);
|
|
};
|
|
sendEvent('thread.run.created', createdRun);
|
|
sendEvent('thread.run.step.created', createdStep);
|
|
sendEvent('thread.message.created', createdMessage);
|
|
sendEvent('thread.message.delta', messageDelta);
|
|
sendEvent('thread.message.completed', message);
|
|
sendEvent('thread.run.step.completed', completedStep);
|
|
sendEvent('thread.run.completed', completedRun);
|
|
res.write('data: [DONE]\n\n');
|
|
res.end();
|
|
}
|
|
|
|
/**
|
|
* `E2E_ASSISTANT_SLOW` streams one delta every 250ms for about thirty seconds, so a test can stop
|
|
* the run mid-stream. The run stays `in_progress` until it finishes or is cancelled.
|
|
*/
|
|
function sendSlowAssistantStream(res, { assistant, thread }) {
|
|
const runId = createId('run');
|
|
const stepId = createId('step');
|
|
const message = createMessage({
|
|
threadId: thread.id,
|
|
role: 'assistant',
|
|
content: '',
|
|
assistantId: assistant.id,
|
|
runId,
|
|
});
|
|
const run = runObject({ id: runId, threadId: thread.id, assistant, status: 'in_progress' });
|
|
runs.set(runId, run);
|
|
thread.messages.push(message);
|
|
res.writeHead(200, {
|
|
'Content-Type': 'text/event-stream',
|
|
'Cache-Control': 'no-cache',
|
|
Connection: 'keep-alive',
|
|
});
|
|
const sendEvent = (event, data) => {
|
|
res.write(`event: ${event}\n`);
|
|
res.write(`data: ${JSON.stringify(data)}\n\n`);
|
|
};
|
|
sendEvent('thread.run.created', run);
|
|
sendEvent(
|
|
'thread.run.step.created',
|
|
runStep({
|
|
id: stepId,
|
|
runId,
|
|
threadId: thread.id,
|
|
assistantId: assistant.id,
|
|
messageId: message.id,
|
|
status: 'in_progress',
|
|
}),
|
|
);
|
|
sendEvent('thread.message.created', { ...message, status: 'in_progress', completed_at: null });
|
|
let index = 0;
|
|
const finish = (status) => {
|
|
clearInterval(timer);
|
|
slowRuns.delete(runId);
|
|
const settled = { ...run, status, cancelled_at: status === 'cancelled' ? now() : null };
|
|
runs.set(runId, settled);
|
|
sendEvent(status === 'cancelled' ? 'thread.run.cancelled' : 'thread.run.completed', settled);
|
|
res.write('data: [DONE]\n\n');
|
|
res.end();
|
|
};
|
|
const timer = setInterval(() => {
|
|
index += 1;
|
|
const value = `achunk-${String(index).padStart(3, '0')} `;
|
|
message.content[0].text.value += value;
|
|
sendEvent('thread.message.delta', {
|
|
id: message.id,
|
|
object: 'thread.message.delta',
|
|
delta: { content: [{ index: 0, type: 'text', text: { value, annotations: [] } }] },
|
|
});
|
|
if (index >= 120) {
|
|
finish('completed');
|
|
}
|
|
}, 250);
|
|
slowRuns.set(runId, { finish });
|
|
res.on('close', () => {
|
|
if (slowRuns.has(runId)) {
|
|
clearInterval(timer);
|
|
slowRuns.delete(runId);
|
|
}
|
|
});
|
|
}
|
|
|
|
function recordRequest(req, url, body) {
|
|
requests.push({
|
|
method: req.method,
|
|
path: url.pathname,
|
|
query: Object.fromEntries(url.searchParams),
|
|
body,
|
|
});
|
|
}
|
|
|
|
function pathMatch(pathname, pattern) {
|
|
const match = pathname.match(pattern);
|
|
return match?.slice(1).map(decodeURIComponent) ?? null;
|
|
}
|
|
|
|
const server = http.createServer(async (req, res) => {
|
|
const url = new URL(req.url, `http://127.0.0.1:${PORT}`);
|
|
|
|
if (req.method === 'GET' && url.pathname === '/') {
|
|
sendJson(res, 200, { ok: true, service: 'fake-assistants-server' });
|
|
return;
|
|
}
|
|
|
|
if (req.method === 'GET' && url.pathname === '/__e2e/requests') {
|
|
sendJson(res, 200, { count: requests.length, requests });
|
|
return;
|
|
}
|
|
|
|
if (req.method === 'POST' && url.pathname === '/__e2e/reset') {
|
|
assistants.clear();
|
|
threads.clear();
|
|
runs.clear();
|
|
requests.length = 0;
|
|
sendJson(res, 200, { ok: true });
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const body = req.method === 'GET' || req.method === 'DELETE' ? {} : await readBody(req);
|
|
recordRequest(req, url, body);
|
|
|
|
if (req.method === 'GET' && url.pathname === '/v1/models') {
|
|
sendJson(res, 200, { object: 'list', data: [{ id: 'gpt-4o-mini', object: 'model' }] });
|
|
return;
|
|
}
|
|
|
|
if (url.pathname === '/v1/assistants') {
|
|
if (req.method === 'POST') {
|
|
if (typeof body.model !== 'string' || body.model.length === 0) {
|
|
sendError(res, 400, 'model is required');
|
|
return;
|
|
}
|
|
const assistant = createAssistant(body);
|
|
assistants.set(assistant.id, assistant);
|
|
sendJson(res, 200, assistant);
|
|
return;
|
|
}
|
|
if (req.method === 'GET') {
|
|
const order = url.searchParams.get('order') ?? 'desc';
|
|
const data = [...assistants.values()].sort((a, b) =>
|
|
order === 'asc' ? a.created_at - b.created_at : b.created_at - a.created_at,
|
|
);
|
|
sendJson(res, 200, listResponse(data));
|
|
return;
|
|
}
|
|
}
|
|
|
|
const assistantPath = pathMatch(url.pathname, /^\/v1\/assistants\/([^/]+)$/);
|
|
if (assistantPath) {
|
|
const [assistantId] = assistantPath;
|
|
const assistant = assistants.get(assistantId);
|
|
if (!assistant) {
|
|
sendError(res, 404, `No assistant found with id '${assistantId}'`);
|
|
return;
|
|
}
|
|
if (req.method === 'GET') {
|
|
sendJson(res, 200, assistant);
|
|
return;
|
|
}
|
|
if (req.method === 'POST') {
|
|
const updated = {
|
|
...assistant,
|
|
...body,
|
|
id: assistant.id,
|
|
object: assistant.object,
|
|
created_at: assistant.created_at,
|
|
};
|
|
assistants.set(assistantId, updated);
|
|
sendJson(res, 200, updated);
|
|
return;
|
|
}
|
|
if (req.method === 'DELETE') {
|
|
assistants.delete(assistantId);
|
|
sendJson(res, 200, { id: assistantId, object: 'assistant.deleted', deleted: true });
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (req.method === 'POST' && url.pathname === '/v1/threads') {
|
|
const threadId = createId('thread');
|
|
const thread = {
|
|
id: threadId,
|
|
object: 'thread',
|
|
created_at: now(),
|
|
metadata: body.metadata ?? {},
|
|
tool_resources: body.tool_resources ?? {},
|
|
messages: (body.messages ?? []).map((message) =>
|
|
createMessage({
|
|
threadId,
|
|
role: message.role,
|
|
content: message.content,
|
|
metadata: message.metadata ?? {},
|
|
}),
|
|
),
|
|
};
|
|
threads.set(threadId, thread);
|
|
const { messages: _messages, ...response } = thread;
|
|
sendJson(res, 200, response);
|
|
return;
|
|
}
|
|
|
|
const messagesPath = pathMatch(url.pathname, /^\/v1\/threads\/([^/]+)\/messages$/);
|
|
if (messagesPath) {
|
|
const [threadId] = messagesPath;
|
|
const thread = threads.get(threadId);
|
|
if (!thread) {
|
|
sendError(res, 404, `No thread found with id '${threadId}'`);
|
|
return;
|
|
}
|
|
if (req.method === 'POST') {
|
|
const message = createMessage({
|
|
threadId,
|
|
role: body.role,
|
|
content: body.content,
|
|
metadata: body.metadata ?? {},
|
|
});
|
|
thread.messages.push(message);
|
|
sendJson(res, 200, message);
|
|
return;
|
|
}
|
|
if (req.method === 'GET') {
|
|
const order = url.searchParams.get('order') ?? 'desc';
|
|
const data = [...thread.messages].sort((a, b) =>
|
|
order === 'asc' ? a.created_at - b.created_at : b.created_at - a.created_at,
|
|
);
|
|
sendJson(res, 200, listResponse(data));
|
|
return;
|
|
}
|
|
}
|
|
|
|
const messagePath = pathMatch(url.pathname, /^\/v1\/threads\/([^/]+)\/messages\/([^/]+)$/);
|
|
if (messagePath) {
|
|
const [threadId, messageId] = messagePath;
|
|
const thread = threads.get(threadId);
|
|
const message = thread?.messages.find((candidate) => candidate.id === messageId);
|
|
if (!message) {
|
|
sendError(res, 404, `No message found with id '${messageId}'`);
|
|
return;
|
|
}
|
|
if (req.method === 'GET') {
|
|
sendJson(res, 200, message);
|
|
return;
|
|
}
|
|
if (req.method === 'POST') {
|
|
Object.assign(message, body);
|
|
sendJson(res, 200, message);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const createRunPath = pathMatch(url.pathname, /^\/v1\/threads\/([^/]+)\/runs$/);
|
|
if (createRunPath && req.method === 'POST') {
|
|
const [threadId] = createRunPath;
|
|
const thread = threads.get(threadId);
|
|
const assistant = assistants.get(body.assistant_id);
|
|
if (!thread) {
|
|
sendError(res, 404, `No thread found with id '${threadId}'`);
|
|
return;
|
|
}
|
|
if (!assistant) {
|
|
sendError(res, 404, `No assistant found with id '${body.assistant_id}'`);
|
|
return;
|
|
}
|
|
if (body.stream !== true) {
|
|
sendError(res, 400, 'Only streamed runs are supported by the e2e fixture');
|
|
return;
|
|
}
|
|
const prompt = latestUserText(thread);
|
|
if (prompt.includes('E2E_ASSISTANT_ERROR')) {
|
|
sendError(res, 400, 'E2E assistant run failed');
|
|
return;
|
|
}
|
|
if (prompt.includes('E2E_ASSISTANT_SLOW')) {
|
|
sendSlowAssistantStream(res, { assistant, thread });
|
|
return;
|
|
}
|
|
sendAssistantStream(res, { assistant, thread });
|
|
return;
|
|
}
|
|
|
|
const cancelRunPath = pathMatch(
|
|
url.pathname,
|
|
/^\/v1\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/,
|
|
);
|
|
if (cancelRunPath && req.method === 'POST') {
|
|
const [threadId, runId] = cancelRunPath;
|
|
const run = runs.get(runId);
|
|
if (!run || run.thread_id !== threadId) {
|
|
sendError(res, 404, `No run found with id '${runId}'`);
|
|
return;
|
|
}
|
|
const slow = slowRuns.get(runId);
|
|
const cancelled = { ...run, status: 'cancelled', cancelled_at: now() };
|
|
if (slow) {
|
|
slow.finish('cancelled');
|
|
} else {
|
|
runs.set(runId, cancelled);
|
|
}
|
|
sendJson(res, 200, runs.get(runId) ?? cancelled);
|
|
return;
|
|
}
|
|
|
|
const runPath = pathMatch(url.pathname, /^\/v1\/threads\/([^/]+)\/runs\/([^/]+)$/);
|
|
if (runPath && req.method === 'GET') {
|
|
const [threadId, runId] = runPath;
|
|
const run = runs.get(runId);
|
|
if (!run || run.thread_id !== threadId) {
|
|
sendError(res, 404, `No run found with id '${runId}'`);
|
|
return;
|
|
}
|
|
sendJson(res, 200, run);
|
|
return;
|
|
}
|
|
|
|
sendError(res, 404, `Unhandled ${req.method} ${url.pathname}`);
|
|
} catch (error) {
|
|
if (!res.headersSent) {
|
|
sendError(res, 400, error.message);
|
|
}
|
|
}
|
|
});
|
|
|
|
keepIdleConnections(server);
|
|
server.listen(PORT, '127.0.0.1', () => {
|
|
console.log(`[e2e] fake assistants server listening on http://127.0.0.1:${PORT}`);
|
|
});
|