LibreChat/e2e/setup/run-files-lifecycle-model.js
Joseph Licata f25242df98
🦘 feat: Share Run-Scoped Files With Subagents (#15848)
* feat: add run-scoped file sharing for subagents

Delegate current-message files through authorized execution catalogs and publish selected immutable code-output versions through the existing file pipeline.

Requires the companion agents SDK context adapter before the dependency can be released and pinned.

* fix: preserve child tool artifacts and verify file-sharing lifecycle

Keep citations and other non-sandbox artifacts on their existing delivery path while retaining private code outputs and inspected images until publication.

Cover native and text delivery, nested and sibling authorization, concurrent runs, cancellation cleanup, and checkpoint recovery through the browser harness.

* test: align file-sharing fixtures and integration cleanup

* test: repair LibreOffice conversion fixtures

* test: verify deployment skill bytes across checkout formats

* fix: align subagent file budgets and refresh boundaries

* chore: update agents SDK to 3.8.6

* refactor: move code output processing into API workspace

* fix: enforce shared file budgets for parents and teams

* fix: declare the shared file encoder interface
2026-09-12 20:14:22 -04:00

240 lines
9.7 KiB
JavaScript

const MARKER = 'E2E_RUN_FILES_LIFECYCLE:';
const CHILD_MARKER = 'E2E_RUN_FILES_LIFECYCLE_CHILD:';
/** Provider-boundary scripts; every assertion reads results from real application tools. */
function createRunFileLifecycleResponses({ findLastToolMessage, getContentText, messageType }) {
const parse = (message) => {
try {
return JSON.parse(getContentText(message?.content));
} catch {
return null;
}
};
const sameIds = (catalog, ids) =>
Array.isArray(catalog?.files) &&
JSON.stringify(catalog.files.map((file) => file.file_id).sort()) ===
JSON.stringify([...ids].sort());
const failure = (label, reason, result) => ({
response: `E2E lifecycle failed ${label}: ${reason}; ${getContentText(result?.content)}`,
});
function readScenario(text) {
const match = text.match(/E2E_RUN_FILES_LIFECYCLE(_CHILD)?:(\{[^\n]*\})/);
if (!match) return null;
try {
const value = JSON.parse(match[2]);
if (!/^[A-Za-z0-9-]+$/.test(value.label) || typeof value.childId !== 'string') return null;
return { ...value, child: Boolean(match[1]) };
} catch {
return null;
}
}
function resolveScenario(scenario, messages) {
const { label, childId, mode, phase, inputId } = scenario;
const callId = (step) => `call_e2e_lifecycle_${label}_${mode}_${phase ?? 'initial'}_${step}`;
const resultFor = (step) => findLastToolMessage(messages, callId(step));
const call = (step, name, args = {}, response = '') => ({
response,
toolCalls: [{ id: callId(step), name, args, type: 'tool_call' }],
});
const write = (step, suffix) =>
call(step, 'bash_tool', {
command: `printf 'source,count\\npdf,1\\n' > /mnt/data/e2e-run-files-${label}-${suffix}.csv\n# E2E_RUN_FILE_ARTIFACT:${label}-${suffix}`,
});
const artifactFor = (result, suffix) =>
parse(result)?.artifacts?.find(
(artifact) => artifact.filename === `e2e-run-files-${label}-${suffix}.csv`,
);
if (scenario.child) {
const inputs = resultFor('inputs');
if (!inputs) return call('inputs', 'list_run_files');
if (!sameIds(parse(inputs), mode === 'probe' ? [] : [inputId])) {
return failure(label, 'child catalog crossed current-turn/run boundaries', inputs);
}
if (mode === 'probe' || phase === 'recover') {
if ((parse(inputs)?.artifacts ?? []).length !== 0) {
return failure(label, 'new execution restored an unpublished artifact', inputs);
}
const stale = resultFor('stale');
if (!stale) {
return call('stale', 'publish_artifact', { artifact_id: scenario.artifactId });
}
if (
!getContentText(stale.content).includes(
'Only artifacts generated by this execution can be published.',
) ||
parse(stale)?.file_id
) {
return failure(label, 'stale private artifact was not rejected', stale);
}
if (mode === 'probe') {
return { response: `E2E lifecycle rejected ${label}` };
}
if (!resultFor('regenerate')) return write('regenerate', 'regenerated');
const catalog = resultFor('regenerated');
if (!catalog) return call('regenerated', 'list_run_files');
const artifact = artifactFor(catalog, 'regenerated');
if (!artifact || artifact.artifact_id === scenario.artifactId) {
return failure(label, 'regeneration did not create a new private version', catalog);
}
const publication = resultFor('republish');
if (!publication) {
return call('republish', 'publish_artifact', { artifact_id: artifact.artifact_id });
}
const published = parse(publication);
if (!published?.file_id || published.file_id === scenario.publishedId) {
return failure(
label,
'regenerated output did not receive its own durable ID',
publication,
);
}
return { response: `E2E lifecycle regenerated ${published.file_id}` };
}
if (!resultFor('write')) return write('write', mode === 'cancel' ? 'private' : 'published');
const catalog = resultFor('catalog');
if (!catalog) return call('catalog', 'list_run_files');
const artifact = artifactFor(catalog, mode === 'cancel' ? 'private' : 'published');
if (!artifact?.artifact_id)
return failure(label, 'output was not privately captured', catalog);
if (mode === 'cancel') {
return {
response: `E2E lifecycle child ${JSON.stringify({ artifactId: artifact.artifact_id })}`,
};
}
const publication = resultFor('publish');
if (!publication) {
return call('publish', 'publish_artifact', { artifact_id: artifact.artifact_id });
}
const published = parse(publication);
if (!published?.file_id) return failure(label, 'publication did not persist', publication);
if (mode === 'concurrent') {
return {
response: `E2E lifecycle child ${JSON.stringify({ publishedId: published.file_id })}`,
};
}
if (!resultFor('draft')) return write('draft', 'private');
const drafts = resultFor('drafts');
if (!drafts) return call('drafts', 'list_run_files');
const draft = artifactFor(drafts, 'private');
if (!draft?.artifact_id || draft.artifact_id === artifact.artifact_id) {
return failure(label, 'private draft was not retained beside the publication', drafts);
}
return {
response: `E2E lifecycle child ${JSON.stringify({
publishedId: published.file_id,
artifactId: draft.artifact_id,
})}`,
};
}
const child = resultFor('delegate');
if (!child) {
return call(
'delegate',
'subagent',
{ description: `${CHILD_MARKER}${JSON.stringify(scenario)}`, subagent_type: childId },
mode === 'concurrent'
? `E2E lifecycle running ${label} ${Array.from({ length: 250 }, (_, i) => `step-${i}`).join(' ')}\n`
: '',
);
}
if (mode === 'probe') {
return getContentText(child.content).includes(`E2E lifecycle rejected ${label}`)
? { response: `E2E lifecycle passed probe ${label}` }
: failure(label, 'child failed to reject the cancelled output', child);
}
const proofMatch = getContentText(child.content).match(/E2E lifecycle child (\{[^\n]*\})/);
if (!proofMatch) return failure(label, 'child produced no artifact proof', child);
const proof = JSON.parse(proofMatch[1]);
const parent = resultFor('parent');
if (!parent) return call('parent', 'list_run_files');
const expectedIds = proof.publishedId ? [inputId, proof.publishedId] : [inputId];
if (!sameIds(parse(parent), expectedIds) || (parse(parent)?.artifacts ?? []).length !== 0) {
return failure(label, 'parent catalog exposed private or unrelated files', parent);
}
if (mode === 'concurrent') {
return {
response: `E2E lifecycle passed concurrent ${label} file=${proof.publishedId}`,
};
}
if (mode === 'cancel') {
return {
response:
`E2E lifecycle private ${JSON.stringify({ label, ...proof })}\n` +
Array.from({ length: 2_000 }, (_, i) => `waiting-${i}`).join(' '),
};
}
const answer = resultFor('ask');
if (!answer) {
return call(
'ask',
'ask_user_question',
{
questions: [
{
id: 'confirmation',
question: `Resume shared files ${label}?`,
options: [{ label: `Continue ${label}`, value: `continue-${label}` }],
},
],
},
`E2E lifecycle pending ${JSON.stringify({ label, ...proof })}\n` +
Array.from({ length: 150 }, (_, i) => `preparing-${i}`).join(' '),
);
}
if (!getContentText(answer.content).includes(`continue-${label}`)) {
return failure(label, 'checkpoint resume lost the user answer', answer);
}
const restored = resultFor('restored');
if (!restored) return call('restored', 'list_run_files');
if (!sameIds(parse(restored), expectedIds) || (parse(restored)?.artifacts ?? []).length !== 0) {
return failure(label, 'resume lost the publication or restored a private draft', restored);
}
const recovery = resultFor('recover');
if (!recovery) {
return call('recover', 'subagent', {
description: `${CHILD_MARKER}${JSON.stringify({ ...scenario, phase: 'recover', ...proof })}`,
subagent_type: childId,
});
}
const regeneratedId = getContentText(recovery.content).match(
/E2E lifecycle regenerated ([\w-]+)/,
)?.[1];
if (!regeneratedId) return failure(label, 'resumed child did not regenerate', recovery);
const final = resultFor('final');
if (!final) return call('final', 'list_run_files');
if (!sameIds(parse(final), [...expectedIds, regeneratedId])) {
return failure(label, 'resumed publication was not visible to the parent', final);
}
return {
response: `E2E lifecycle passed resume ${label} original=${proof.publishedId} regenerated=${regeneratedId}`,
};
}
function resolveInvocation(messages) {
for (let index = (messages ?? []).length - 1; index >= 0; index--) {
if (!['human', 'user'].includes(messageType(messages[index]))) continue;
const scenario = readScenario(getContentText(messages[index].content));
if (scenario) return resolveScenario(scenario, messages);
}
return null;
}
return {
responsesForText: (text) =>
text.includes(MARKER)
? { responses: [''], sleep: 15, overrideSubagentModel: true, resolveInvocation }
: null,
resolveInvocation,
isFixtureAgents: (agents) =>
(agents ?? []).some((agent) => agent.name?.startsWith('E2E Lifecycle')),
};
}
module.exports = { createRunFileLifecycleResponses };