deer-flow/frontend/tests/e2e/scroll-on-send.spec.ts
hataa ec44f2ff3d
feat(frontend): pin the sent message to the top of the viewport (#8261)
* feat(frontend): pin the sent message to the top of the viewport

After a send, keep the user's turn at the top of the viewport and let the
streamed reply grow downward below the reading position, instead of the
viewport chasing the bottom (ChatGPT-style send behavior).

MessageList detects a freshly appended trailing human group while a run is
active and hands its key to VirtualMessageList. The list then grows a
flexible end spacer sized to the remaining viewport, so the last row can
actually reach the top (the browser clamps the scroll without it), escapes
the stick-to-bottom lock around the alignment, and re-escapes on a timeout
chain until the resize animation from the optimistic message settles; the
spacer shrinks as the reply grows and collapses when the run finishes.
Scrolling down or the scroll-to-bottom button re-locks the follow. History
pagination, thread switches and regenerates are excluded by construction
and covered by DOM tests; Playwright covers the static and the virtualized
list against a held run stream.

* style(frontend): fix scroll-on-send test lint

* fix(frontend): send-pin review follow-ups

Review follow-ups on top of the send pin:

- Hand scroll control back on the first genuine user input: the pin chain
  arms wheel/touchstart/pointerdown listeners on the scroller, and outline
  navigation plus the scroll-to-bottom button cancel it through
  cancelPinFollow — previously every tick reverted user scrolling for ~2s
  after a send.
- Capture the mount-time tail key during the first render so the mount
  absorption is idempotent under StrictMode's double effect run.
- Export LOCAL_HUMAN_MESSAGE_ID_PREFIX from core/threads/hooks and use it
  at both the mint site and the pin predicate.

---------

Co-authored-by: Willem Jiang <willem.jiang@gmail.com>
2026-11-15 20:49:43 +08:00

327 lines
11 KiB
TypeScript

import { createServer } from "node:http";
import type { AddressInfo } from "node:net";
import { expect, test, type Page } from "@playwright/test";
import { mockLangGraphAPI, MOCK_THREAD_ID } from "./utils/mock-api";
const SENT_TEXT = "Pin this message to the top of the viewport.";
const TALL_ANSWER = Array.from(
{ length: 24 },
(_, index) =>
`Paragraph ${index}: the streamed reply keeps growing line after line, ` +
"and the viewport must stay at the reader's position instead of " +
"chasing the bottom of the conversation.",
).join("\n\n");
function fillerMessages(turns: number) {
return Array.from({ length: turns }, (_, index) => [
{
type: "human",
id: `msg-human-filler-${index}`,
content: [
{
type: "text",
text: `Filler question ${index}: describe the message list scroll behavior in detail.`,
},
],
},
{
type: "ai",
id: `msg-ai-filler-${index}`,
content: `Filler answer ${index}: the message list keeps the latest turn in view, escapes the stick lock when the user scrolls up, and exposes a jump control to return.`,
additional_kwargs: {},
response_metadata: {},
invalid_tool_calls: [],
},
]).flat();
}
/**
* SSE server that answers the run handshake, then — once the send has been
* pinned — delivers the reply and holds the connection open. The held
* connection keeps `thread.isLoading` true so the pin and its end spacer
* stay alive for the assertions. `progressive` delivers the reply one
* paragraph per 200ms tick (real streaming shape); otherwise the whole tall
* answer arrives in one `values` frame.
*/
async function startHeldRunStream(options?: { progressive?: boolean }) {
const progressive = options?.progressive ?? false;
const paragraphs = TALL_ANSWER.split("\n\n");
const timers: NodeJS.Timeout[] = [];
const server = createServer((request, response) => {
let body = "";
request.on("data", (chunk: Buffer) => {
body += chunk.toString();
});
request.on("end", () => {
let inputMessages: unknown[] = [];
try {
inputMessages =
(JSON.parse(body) as { input?: { messages?: unknown[] } }).input
?.messages ?? [];
} catch {
inputMessages = [];
}
response.writeHead(200, {
"Access-Control-Allow-Origin": "*",
"Cache-Control": "no-cache",
"Content-Type": "text/event-stream",
});
const write = (event: string, data: unknown) => {
response.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
};
const answerFrame = (content: string) => ({
messages: [
...inputMessages,
{
type: "ai",
id: "msg-ai-scroll-send",
content,
additional_kwargs: {},
response_metadata: {},
invalid_tool_calls: [],
},
],
});
write("metadata", {
run_id: "run-scroll-send",
thread_id: MOCK_THREAD_ID,
});
if (progressive) {
paragraphs.forEach((paragraph, index) => {
timers.push(
setTimeout(
() =>
write(
"values",
answerFrame(paragraphs.slice(0, index + 1).join("\n\n")),
),
600 + index * 200,
),
);
});
} else {
timers.push(
setTimeout(() => write("values", answerFrame(TALL_ANSWER)), 600),
);
}
// Connection stays open: the run remains in flight.
});
});
await new Promise<void>((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", () => {
server.off("error", reject);
resolve();
});
});
const { port } = server.address() as AddressInfo;
return {
url: `http://127.0.0.1:${port}/runs/stream`,
async close() {
for (const timer of timers) clearTimeout(timer);
server.closeAllConnections();
await new Promise<void>((resolve, reject) => {
server.close((error) => (error ? reject(error) : resolve()));
});
},
};
}
test.describe("Scroll on send", () => {
// ChatGPT-style send behavior: the freshly sent user turn aligns with the
// top of the viewport, and the streamed reply grows downward below the
// reading position instead of the viewport chasing the bottom. A flexible
// end spacer makes the last row able to reach the top at all, and the
// scroll-to-bottom button re-locks the follow when the user wants it back.
async function expectSendPinned(
page: Page,
fillerTurns: number,
options?: { progressive?: boolean },
) {
const streamServer = await startHeldRunStream(options);
mockLangGraphAPI(page, {
threads: [
{
thread_id: MOCK_THREAD_ID,
title: "Scroll on send",
updated_at: "2026-11-14T12:00:00Z",
messages: fillerMessages(fillerTurns),
},
],
runStreamHandler: (route) => route.continue({ url: streamServer.url }),
});
try {
await page.goto(`/workspace/chats/${MOCK_THREAD_ID}`);
const lastFiller = page
.getByText(`Filler question ${fillerTurns - 1}`, { exact: false })
.first();
await expect(lastFiller).toBeVisible({ timeout: 15_000 });
const scroller = page.getByRole("log").locator("> div");
// The restored thread settles pinned to the bottom.
await expect
.poll(() =>
scroller.evaluate(
(el) => el.scrollHeight - el.clientHeight - el.scrollTop,
),
)
.toBeLessThanOrEqual(1);
const textarea = page.getByPlaceholder(/how can i assist you/i);
await expect(textarea).toBeVisible({ timeout: 15_000 });
await textarea.fill(SENT_TEXT);
await textarea.press("Enter");
const sentMessage = page.getByText(SENT_TEXT, { exact: true });
await expect(sentMessage).toBeVisible({ timeout: 15_000 });
// The user's message now sits at the top of the viewport (the group
// start offset is 16px), no longer hugging the bottom edge.
const scrollerHandle = await scroller.elementHandle();
const sentTopInViewport = () =>
sentMessage.evaluate(
(el, scrollerEl) =>
el.getBoundingClientRect().top -
scrollerEl.getBoundingClientRect().top,
scrollerHandle,
);
await expect.poll(sentTopInViewport).toBeLessThanOrEqual(64);
// The tall streamed reply lands below the pinned message. Escape means
// the viewport does NOT chase it: the distance to the bottom grows.
await expect
.poll(() =>
scroller.evaluate(
(el) => el.scrollHeight - el.clientHeight - el.scrollTop,
),
)
.toBeGreaterThan(200);
// A slow bottom-chasing animation (a resurrected follow lock) would
// drag the message up past the viewport top within this window; the
// pin must stay put after the content has settled.
await page.waitForTimeout(1_000);
await expect.poll(sentTopInViewport).toBeLessThanOrEqual(64);
const settledGap = await scroller.evaluate(
(el) => el.scrollHeight - el.clientHeight - el.scrollTop,
);
expect(settledGap).toBeGreaterThan(70);
// And the follow can be re-locked on demand: the jump button appears
// because the list escaped the stick lock.
await expect(
page.getByRole("button", { name: "Scroll to bottom" }),
).toBeVisible();
} finally {
await streamServer.close();
}
}
test("pins the sent user message to the top (static list)", async ({
page,
}) => {
await expectSendPinned(page, 12);
});
test("pins the sent user message to the top (virtualized list)", async ({
page,
}) => {
// 32 turns = 64 groups, past the list's virtualization threshold (60).
await expectSendPinned(page, 32);
});
// Regression: a progressively streamed reply (one paragraph per 200ms) must
// not re-lock the follow. If the end spacer shrank in lockstep with each
// chunk, the net-negative resize re-locks use-stick-to-bottom while the
// bottom gap is inside its 70px band, and every subsequent chunk drags the
// viewport down without user input.
test("keeps the pin while the reply streams in progressively", async ({
page,
}) => {
await expectSendPinned(page, 12, { progressive: true });
});
// The send-pin chain (escape + re-align ticks for ~2s after a send) must
// hand scroll control back on the first genuine user input. A wheel over
// the list inside the chain window cancels it; without the cancel, a later
// tick would revert the user's position back to the pinned offset.
test("hands scroll control back when the user wheels inside the chain window", async ({
page,
}) => {
const streamServer = await startHeldRunStream();
mockLangGraphAPI(page, {
threads: [
{
thread_id: MOCK_THREAD_ID,
title: "Scroll on send",
updated_at: "2026-11-14T12:00:00Z",
messages: fillerMessages(12),
},
],
runStreamHandler: (route) => route.continue({ url: streamServer.url }),
});
try {
await page.goto(`/workspace/chats/${MOCK_THREAD_ID}`);
await expect(
page.getByText("Filler question 11", { exact: false }).first(),
).toBeVisible({ timeout: 15_000 });
const scroller = page.getByRole("log").locator("> div");
await expect
.poll(() =>
scroller.evaluate(
(el) => el.scrollHeight - el.clientHeight - el.scrollTop,
),
)
.toBeLessThanOrEqual(1);
const textarea = page.getByPlaceholder(/how can i assist you/i);
await expect(textarea).toBeVisible({ timeout: 15_000 });
await textarea.fill(SENT_TEXT);
await textarea.press("Enter");
const sentMessage = page.getByText(SENT_TEXT, { exact: true });
await expect(sentMessage).toBeVisible({ timeout: 15_000 });
const scrollerHandle = await scroller.elementHandle();
const sentTopInViewport = () =>
sentMessage.evaluate(
(el, scrollerEl) =>
el.getBoundingClientRect().top -
scrollerEl.getBoundingClientRect().top,
scrollerHandle,
);
// The pin landed; still well inside the 2s chain window.
await expect.poll(sentTopInViewport).toBeLessThanOrEqual(64);
const box = await scroller.boundingBox();
if (!box) {
throw new Error("scroll container is not visible");
}
await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
await page.mouse.wheel(0, -240);
// The wheel-up moves the viewport up, pushing the pinned message down
// by the same amount (~240px past its pinned offset). Past several
// would-be chain ticks (350/500/700/900/1100ms) the user's position
// must hold instead of snapping back to the pin offset.
await page.waitForTimeout(1_500);
await expect.poll(sentTopInViewport).toBeGreaterThan(200);
await page.waitForTimeout(400);
await expect.poll(sentTopInViewport).toBeGreaterThan(200);
// The user is now free of the follow; the jump button shows.
await expect(
page.getByRole("button", { name: "Scroll to bottom" }),
).toBeVisible();
} finally {
await streamServer.close();
}
});
});