LibreChat/e2e/specs/mock/scenarios/fold-tree.spec.ts
Dustin Healy a1ac175544
💾 feat: Persist and Continue Stored Agent Responses (#17605)
* 💾 feat: Persist and Continue Stored Agent Responses

* fix: unify response persistence and terminal ownership

* fix: Commit Canonical Responses With Conversation History

* test: Keep Interrupted Erasure Payloads Private

* fix: Fence Canonical Response Materialization During Rolling Upgrades
2026-11-10 21:04:01 -08:00

535 lines
21 KiB
TypeScript

import { expect, test } from '@playwright/test';
import type { Locator, Page, Route } from '@playwright/test';
import { messagesView } from '../helpers';
/**
* An open tool fold draws its rail as a tree: a trunk under the header's glyph with a
* curved branch into each of its rows. Hovering a row lights the route along that tree,
* from the header into the row, and the route only ever travels the drawn branches.
* Conversations are routed fixtures, so every run sees the same rows.
*/
test.describe.configure({ timeout: 120_000 });
const NO_PARENT = '00000000-0000-0000-0000-000000000000';
const DESKTOP = { viewport: { width: 1280, height: 900 }, isMobile: false, hasTouch: false };
const unique = (prefix: string) => `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
const escapeRe = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
type Part = Record<string, unknown>;
const call = (id: string, name: string, args: Record<string, string>, output: string): Part => ({
type: 'tool_call',
tool_call: { id, name, args: JSON.stringify(args), output, progress: 1, type: 'tool_call' },
});
/** Four finished calls in one batch: a single tool group with four rows. */
const GROUP_CONTENT: Part[] = [
call('g1', 'edit_file_mcp_filesystem', { path: 'src/config.ts' }, 'Edited src/config.ts'),
call('g2', 'run_command_mcp_shell', { command: 'npm test -- config' }, 'PASS config.test.ts'),
call('g3', 'run_command_mcp_shell', { command: 'npm test' }, 'Tests: 148 passed'),
call('g4', 'run_command_mcp_shell', { command: 'git diff --stat' }, '1 file changed'),
{ type: 'text', text: 'Fold tree fixture done.' },
];
/** A phase over two labeled batches: tool groups nested inside an activity phase. */
const PHASE_CONTENT: Part[] = [
call('p1', 'read_file_mcp_filesystem', { path: 'ci.yml' }, 'name: CI'),
call('p2', 'read_file_mcp_filesystem', { path: 'package.json' }, '{ "name": "app" }'),
call('p3', 'list_directory_mcp_filesystem', { path: 'src' }, 'index.ts'),
{
type: 'activity_label',
activity_label: 'Read the build config',
tool_call_ids: ['p1', 'p2', 'p3'],
status: 'ok',
},
call('p4', 'run_command_mcp_shell', { command: 'npm test' }, 'PASS'),
call('p5', 'read_file_mcp_filesystem', { path: 'src/config.ts' }, 'export const PORT = 3080;'),
{
type: 'activity_label',
activity_label: 'Ran the test suite',
tool_call_ids: ['p4', 'p5'],
status: 'ok',
},
{
type: 'activity_label',
activity_label: 'Investigated the build',
activity_label_type: 'phase',
activity_start_index: 0,
activity_end_index: 7,
activity_count: 5,
status: 'ok',
pending: false,
},
{ type: 'text', text: 'Fold tree fixture done.' },
];
async function routeConversation(page: Page, content: Part[]): Promise<string> {
const conversationId = unique('e2e-fold-tree');
const now = new Date(0).toISOString();
const message = {
messageId: `${conversationId}-msg`,
conversationId,
parentMessageId: NO_PARENT,
isCreatedByUser: false,
sender: 'Assistant',
endpoint: 'Mock Provider A',
model: 'mock-model-a',
text: '',
content,
createdAt: now,
updatedAt: now,
};
const conversation = {
conversationId,
title: 'Fold tree',
endpoint: 'Mock Provider A',
endpointType: 'custom',
model: 'mock-model-a',
createdAt: now,
updatedAt: now,
};
const convoIdRe = escapeRe(conversationId);
await page.route(new RegExp(`/api/convos/${convoIdRe}(?:\\?.*)?$`), (route: Route) =>
route.fulfill({
status: 200,
contentType: 'application/json',
body: JSON.stringify(conversation),
}),
);
await page.route(new RegExp(`/api/messages/${convoIdRe}(?:\\?.*)?$`), (route: Route) =>
route.fulfill({
status: 200,
contentType: 'application/json',
body: JSON.stringify([message]),
}),
);
return conversationId;
}
async function openConversation(page: Page, content: Part[]) {
const conversationId = await routeConversation(page, content);
await page.goto(`/c/${conversationId}`, { timeout: 30000 });
await expect(messagesView(page).getByText('Fold tree fixture done.')).toBeVisible({
timeout: 20000,
});
}
/**
* Opening a fold animates its height and can move rows under a pointer that stays put; the
* fold then re-hits the pointer and lights whichever row is under it now. A hover only names
* a row once nothing in the transcript is moving.
*/
async function waitForStillTranscript(page: Page) {
const view = messagesView(page);
await expect
.poll(() =>
view.evaluate(
(element) =>
element
.getAnimations({ subtree: true })
.filter(
(animation) =>
animation.playState === 'running' &&
animation.effect?.getComputedTiming().iterations !== Infinity,
).length,
),
)
.toBe(0);
let previous = '';
await expect
.poll(async () => {
const box = await view.getByRole('button', { name: /^Ran / }).last().boundingBox();
const current = JSON.stringify(box);
const still = current === previous;
previous = current;
return still;
})
.toBe(true);
}
/** The panel of the tool group whose header reads `name`, opened if it is folded. */
async function openGroup(page: Page, name: RegExp): Promise<Locator> {
const header = messagesView(page).getByRole('button', { name }).first();
await expect(header).toBeVisible();
if ((await header.getAttribute('aria-expanded')) !== 'true') {
await header.click();
}
await expect(header).toHaveAttribute('aria-expanded', 'true');
await waitForStillTranscript(page);
return messagesView(page)
.getByTestId('tool-call-group-panel')
.filter({ has: page.getByRole('button', { name: /^Ran / }) })
.last();
}
async function waitForTransitions(page: Page) {
await page.waitForFunction(
() =>
!document
.getAnimations()
.some(
(animation) => animation.playState === 'running' && animation instanceof CSSTransition,
),
);
}
const railOf = (panel: Locator) => panel.locator('> div > [data-testid="fold-rail"]');
const traceOf = (rail: Locator) => rail.locator('[data-fold-trace]');
const branchesOf = (rail: Locator) => rail.locator('[data-testid="fold-rail-tree"] > g > path');
const rowsOf = (panel: Locator) => panel.getByRole('button', { name: /^Ran / });
async function center(locator: Locator) {
const box = await locator.boundingBox();
expect(box).not.toBeNull();
return { x: box!.x + box!.width / 2, y: box!.y + box!.height / 2, box: box! };
}
/** The lit route ends in `row`: the bottom of its bounding box sits on the row glyph's center. */
async function expectRouteEndsAt(rail: Locator, row: Locator) {
const trace = traceOf(rail);
await expect(trace).toHaveAttribute('data-lit', '');
await expect
.poll(async () => {
const [path, glyph] = await Promise.all([
trace.boundingBox(),
row.locator('.fold-glyph').first().boundingBox(),
]);
return path == null || glyph == null
? Infinity
: Math.abs(path.y + path.height - (glyph.y + glyph.height / 2));
})
.toBeLessThan(2);
}
/**
* Records the lit path's shape on every animation frame while `act` runs, in the rail's
* own coordinates, alongside the branch points the rail drew (one radius above each
* row center).
*/
async function sampleRoute(rail: Locator, act: () => Promise<void>, ms = 900) {
await rail.evaluate((element, duration) => {
const path = element.querySelector('[data-fold-trace]')!;
const samples: string[] = [];
(window as unknown as { __foldSamples: string[] }).__foldSamples = samples;
const until = performance.now() + duration;
const step = () => {
samples.push(path.getAttribute('d') ?? '');
if (performance.now() < until) {
requestAnimationFrame(step);
}
};
requestAnimationFrame(step);
}, ms);
await act();
await rail.page().waitForTimeout(ms + 100);
return rail.evaluate((element) => ({
samples: (window as unknown as { __foldSamples: string[] }).__foldSamples,
centers: (element.getAttribute('data-centers') ?? '').split(',').map(Number),
}));
}
const tipOf = (d: string) => Number(/V ([\d.]+)/.exec(d)?.[1]);
const hasBranch = (d: string) => d.includes(' A ');
test.describe('tool fold tree (pointer)', () => {
test.use(DESKTOP);
test('an open tool fold draws a branch into each of its rows @scenario:open-tool-fold-branches-into-each-row', async ({
page,
}) => {
await openConversation(page, GROUP_CONTENT);
const panel = await openGroup(page, /^Ran 4 actions/);
const rail = railOf(panel);
const rows = rowsOf(panel);
await expect(rows).toHaveCount(4);
/** The trunk, then one branch per row. */
await expect(branchesOf(rail)).toHaveCount(5);
for (let i = 0; i < 4; i++) {
const [branch, glyph] = await Promise.all([
branchesOf(rail)
.nth(i + 1)
.boundingBox(),
rows.nth(i).locator('.fold-glyph').first().boundingBox(),
]);
expect(Math.abs(branch!.y + branch!.height - (glyph!.y + glyph!.height / 2))).toBeLessThan(2);
/** The branch stops short of the row's icon rather than running under it. */
expect(branch!.x + branch!.width).toBeLessThanOrEqual(glyph!.x + 2);
}
/** The trunk hangs from the header glyph's axis. */
const header = messagesView(page)
.getByRole('button', { name: /^Ran 4 actions/ })
.first();
const trunk = await center(branchesOf(rail).first());
const headerGlyph = await center(header.locator('.fold-glyph').first());
expect(Math.abs(trunk.x - headerGlyph.x)).toBeLessThan(2);
await expect(rail).toHaveAttribute('aria-hidden', 'true');
await expect(rail).toHaveAttribute('tabindex', '-1');
});
test('hovering a row lights the route from the header into that row @scenario:hovered-tool-row-lights-route-from-header', async ({
page,
}) => {
await openConversation(page, GROUP_CONTENT);
const panel = await openGroup(page, /^Ran 4 actions/);
const rail = railOf(panel);
const rows = rowsOf(panel);
await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');
await rows.nth(2).hover();
await expect(rail).toHaveAttribute('data-fold-lit', '2');
await expectRouteEndsAt(rail, rows.nth(2));
/** Leaving the fold fades the route out. */
await page.mouse.move(5, 5);
await expect(rail).not.toHaveAttribute('data-fold-lit');
await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');
await expect(traceOf(rail)).toHaveCSS('opacity', '0');
});
test('a row in a nested fold lights every level into its own branch @scenario:nested-fold-row-lights-each-level', async ({
page,
}) => {
await openConversation(page, PHASE_CONTENT);
const phaseHeader = messagesView(page).getByRole('button', { name: 'Investigated the build' });
await phaseHeader.click();
await expect(phaseHeader).toHaveAttribute('aria-expanded', 'true');
const phaseRail = messagesView(page)
.getByTestId('activity-phase-panel')
.locator('> div > [data-testid="fold-rail"]');
const groupHeader = messagesView(page).getByRole('button', { name: /^Ran the test suite/ });
const panel = await openGroup(page, /^Ran the test suite/);
const groupRail = railOf(panel);
const row = rowsOf(panel).first();
await row.hover();
await expectRouteEndsAt(groupRail, row);
/** The phase lights its branch into the group's header, which leads on into the row. */
await expectRouteEndsAt(phaseRail, groupHeader);
});
test('moving between rows travels the tree, never cutting across it @scenario:lit-route-travels-tree-between-rows', async ({
page,
}) => {
await openConversation(page, GROUP_CONTENT);
const panel = await openGroup(page, /^Ran 4 actions/);
const rail = railOf(panel);
const rows = rowsOf(panel);
await rows.nth(2).hover();
await expect(rail).toHaveAttribute('data-fold-lit', '2');
await expectRouteEndsAt(rail, rows.nth(2));
const { samples, centers } = await sampleRoute(rail, () => rows.nth(1).hover());
const from = centers[2] - 8;
const to = centers[1] - 8;
const moving = samples.filter((d) => d !== '');
expect(moving.length).toBeGreaterThan(3);
for (let i = 0; i < moving.length; i++) {
const tip = tipOf(moving[i]);
/** Only the trunk between the two rows: never above the new row, never via the top. */
expect(tip).toBeGreaterThanOrEqual(to - 0.5);
expect(tip).toBeLessThanOrEqual(from + 0.5);
if (i > 0) {
expect(tip).toBeLessThanOrEqual(tipOf(moving[i - 1]) + 0.5);
}
/** A branch is drawn only from a branch point, so nothing leaves the tree. */
if (hasBranch(moving[i])) {
expect(Math.min(Math.abs(tip - from), Math.abs(tip - to))).toBeLessThan(0.5);
}
}
expect(moving.some((d) => !hasBranch(d) && tipOf(d) > to + 1 && tipOf(d) < from - 1)).toBe(
true,
);
await expectRouteEndsAt(rail, rows.nth(1));
});
test('the route stays lit through a click that unfolds the hovered row @scenario:lit-route-stays-after-click-folds-rows', async ({
page,
}) => {
await openConversation(page, GROUP_CONTENT);
const panel = await openGroup(page, /^Ran 4 actions/);
const rail = railOf(panel);
const rows = rowsOf(panel);
await rows.nth(1).hover();
await expectRouteEndsAt(rail, rows.nth(1));
/** Click without moving the pointer: the row opens and the rows below it move. */
await page.mouse.down();
await page.mouse.up();
await expect(rows.nth(1)).toHaveAttribute('aria-expanded', 'true');
await expect(rail).toHaveAttribute('data-fold-lit', '1');
await expectRouteEndsAt(rail, rows.nth(1));
/** And again to fold it: still lit, still ending in the same row. */
await page.mouse.down();
await page.mouse.up();
await expect(rows.nth(1)).toHaveAttribute('aria-expanded', 'false');
await expectRouteEndsAt(rail, rows.nth(1));
});
test('with reduced motion the route is placed at once @scenario:reduced-motion-places-lit-route-at-once', async ({
page,
}) => {
await page.emulateMedia({ reducedMotion: 'reduce' });
await openConversation(page, GROUP_CONTENT);
const panel = await openGroup(page, /^Ran 4 actions/);
const rail = railOf(panel);
const rows = rowsOf(panel);
await rows.nth(0).hover();
await expectRouteEndsAt(rail, rows.nth(0));
const { samples } = await sampleRoute(rail, () => rows.nth(3).hover(), 500);
/** The shape for the first row, then the shape for the last row, and nothing between. */
expect(new Set(samples.filter((d) => d !== '')).size).toBeLessThanOrEqual(2);
await expectRouteEndsAt(rail, rows.nth(3));
});
test('a right-to-left locale mirrors the tree toward its rows @scenario:rtl-tool-tree-mirrors-branches', async ({
page,
}) => {
await page.addInitScript(() => localStorage.setItem('lang', JSON.stringify('ar')));
await openConversation(page, GROUP_CONTENT);
await expect(page.locator('html')).toHaveAttribute('dir', 'rtl', { timeout: 30000 });
const panel = messagesView(page).getByTestId('tool-call-group-panel').last();
/** The copy is Arabic, so the header is found by its place right above the panel. */
const header = panel.locator('xpath=preceding-sibling::div[1]').getByRole('button').first();
await header.click();
await expect(header).toHaveAttribute('aria-expanded', 'true');
const rail = railOf(panel);
const row = panel.locator('.fold-glyph').nth(1);
const branch = branchesOf(rail).nth(2);
const [path, glyph, trunk] = await Promise.all([
branch.boundingBox(),
row.boundingBox(),
branchesOf(rail).first().boundingBox(),
]);
/** The trunk sits to the row's right, and the branch runs leftward from it to the row. */
expect(trunk!.x).toBeGreaterThan(glyph!.x + glyph!.width);
expect(path!.x).toBeGreaterThanOrEqual(glyph!.x + glyph!.width - 2);
expect(Math.abs(path!.x + path!.width - (trunk!.x + trunk!.width / 2))).toBeLessThan(2);
expect(Math.abs(path!.y + path!.height - (glyph!.y + glyph!.height / 2))).toBeLessThan(2);
});
});
test.describe('tool fold tree (touch)', () => {
test.use({ viewport: { width: 390, height: 844 }, isMobile: true, hasTouch: true });
test('tapping a row leaves the tree dark @scenario:touch-tap-leaves-tool-tree-dark', async ({
page,
}) => {
await openConversation(page, GROUP_CONTENT);
const header = messagesView(page)
.getByRole('button', { name: /^Ran 4 actions/ })
.first();
await header.tap();
await expect(header).toHaveAttribute('aria-expanded', 'true');
const panel = messagesView(page).getByTestId('tool-call-group-panel').last();
const rail = railOf(panel);
await expect(branchesOf(rail)).toHaveCount(5);
await rowsOf(panel).nth(1).tap();
await expect(rowsOf(panel).nth(1)).toHaveAttribute('aria-expanded', 'true');
await expect(rail).not.toHaveAttribute('data-fold-lit');
await expect(traceOf(rail)).not.toHaveAttribute('data-lit', '');
});
});
test.describe('tool disclosure polish', () => {
test.use(DESKTOP);
test('a named command with Thoughts retains its command header and precise timer', async ({
page,
}) => {
await openConversation(page, [
{
type: 'tool_call',
tool_call: {
id: 'timed',
name: 'bash_tool',
args: '{"command":"echo hi"}',
output: 'hi',
progress: 1,
type: 'tool_call',
runStepStatus: 'completed',
runStepDurationMs: 10200,
},
},
{ type: 'activity_label', activity_label: 'Checked the command', pending: false },
{ type: 'think', think: 'Checking whether the output matches' },
{ type: 'text', text: 'Fold tree fixture done.' },
]);
const header = messagesView(page)
.getByRole('button', { name: /Checked the command/ })
.first();
await header.click();
await expect(messagesView(page).getByRole('button', { name: /Ran command/ })).toBeVisible();
await expect(messagesView(page).getByTestId('command-time').first()).toContainText('10.2s');
await expect(
messagesView(page)
.getByRole('button', { name: /Thoughts/ })
.last(),
).toBeVisible();
});
test('a generated failed-command title opens its error directly and retains focus', async ({
page,
}) => {
await openConversation(page, [
{
type: 'tool_call',
tool_call: {
id: 'failed',
name: 'bash_tool',
args: '{"command":"false"}',
output: 'Error: tool call failed: exit code 2',
progress: 1,
type: 'tool_call',
runStepStatus: 'failed',
runStepDurationMs: 10200,
},
},
{
type: 'activity_label',
activity_label: 'Checked the failing command',
pending: false,
status: 'failed',
},
{
type: 'activity_label',
activity_label: 'Checked the failing command',
activity_label_type: 'phase',
activity_start_index: 0,
activity_end_index: 2,
activity_count: 1,
pending: false,
status: 'failed',
},
{ type: 'text', text: 'Fold tree fixture done.' },
]);
await messagesView(page).getByTestId('failed-reveal-pill').first().click();
await expect(messagesView(page).getByRole('button', { name: /Ran command/ })).toHaveCount(0);
await expect(
messagesView(page).getByText('Error: tool call failed: exit code 2', { exact: true }),
).toBeVisible();
await expect
.poll(() => page.evaluate(() => document.activeElement?.textContent))
.toContain('exit code 2');
});
test('collapse passes through intermediate heights instead of snapping', async ({ page }) => {
await openConversation(page, GROUP_CONTENT);
await openGroup(page, /^Ran 4 actions/);
const panel = messagesView(page).getByTestId('tool-call-group-panel').last();
await expect(panel).toBeVisible();
await waitForTransitions(page);
await panel.evaluate((element) => {
const values: number[] = [];
(window as unknown as { foldHeights: number[] }).foldHeights = values;
const until = performance.now() + 600;
const sample = () => {
values.push(element.getBoundingClientRect().height);
if (performance.now() < until) requestAnimationFrame(sample);
};
requestAnimationFrame(sample);
});
await messagesView(page)
.getByRole('button', { name: /^Ran 4 actions/ })
.first()
.click();
await expect.poll(() => panel.evaluate((el) => el.getBoundingClientRect().height)).toBe(0);
const heights = await page.evaluate(
() => (window as unknown as { foldHeights: number[] }).foldHeights,
);
expect(new Set(heights.map(Math.round)).size).toBeGreaterThan(3);
});
});