mirror of
https://github.com/getpaseo/paseo.git
synced 2026-11-09 18:04:55 +00:00
Mohamed Boudra
9a5b4aefa4
* fix(app): stop showing Updating messages for a chat that has not changed Every return to a chat fetched from the daemon just to learn nothing had changed, and the toast covered that fetch. The subscribe request that attaches a chat now carries its cursor, and the daemon answers current or behind in the same round trip, so an unchanged chat needs no fetch and shows nothing. The daemon attaches before it compares, so a commit landing in between is either delivered live or counted as behind. It never loads an agent to answer: an agent it has not loaded answers behind and resumes in the fetch, as before. The delay before an unanswered check shows the toast starts when the request is sent. A cold start's cache read alone can outlast the delay, which would flash the toast for a chat the daemon then reports current. * fix(app): keep agent details and stay quiet after a current timeline answer The timeline fetch that a current answer skips also delivered the full agent row, and the replica cache stores only part of it. After a cold reload with an empty incremental directory page, usage, modes, permissions and runtime info stayed empty. The subscribe answer now carries the row for each current chat, gated with the rest of the freshness check. The panel also reported ready before the timeline owner was published, so a connected render with cached content showed Updating messages. No owner now reads as a check that has not begun. * test(app): pin the held running turn across a freshness check A chat that left mid-turn holds its running footer until its messages are current. With the freshness check, "current" is that commit with no rows, so the tests and the timeline-sync doc now cover the check in flight, a current answer, and a behind answer that holds until the fetched rows land. * fix(app): keep hidden chats live while a subscription is replaced The old timeline subscription was released in the same tick the new one was requested. The client deletes a route on release and adds the new route only when the daemon responds, so events sent in between were dropped. Visible chats recover through the cursor check; hidden chats skip it and stayed behind until something else fetched them. Release the old subscription when the new one settles. Accepting the new route and releasing the old one happen without a socket frame in between, so each event reaches the client once. * test(app): make the plugin chat reload spec independent of the freshness answer The spec reloaded and waited for a held timeline fetch. A chat with a cached cursor now answers current and never fetches, so the wait hung until the test timed out, depending on whether the cursor had been saved before the reload. Hold the subscribe request instead: the catalog still has to arrive while the timeline is outstanding, for either answer.
58 lines
2.3 KiB
TypeScript
58 lines
2.3 KiB
TypeScript
import { test } from "../support/fixtures";
|
|
import { installDaemonWebSocketGate } from "../support/helpers/daemon-websocket-gate";
|
|
import {
|
|
withTimelinePlugin,
|
|
viewInlineThinkingExample,
|
|
requestPluginTimeline,
|
|
interactWithStreamingCard,
|
|
expectWholeCompletedCard,
|
|
expectBothConsecutiveTools,
|
|
trackPluginChatRecovery,
|
|
reconnectPluginChat,
|
|
} from "../support/helpers/plugin-timeline";
|
|
|
|
for (const width of [1100, 390]) {
|
|
test(`assistant plugin receives the whole streaming message at width ${width}`, async ({
|
|
page,
|
|
}, info) => {
|
|
await page.setViewportSize({ width, height: 900 });
|
|
const gate = await installDaemonWebSocketGate(page);
|
|
await withTimelinePlugin(page, info, "assistant", async (agent) => {
|
|
await requestPluginTimeline(agent);
|
|
await interactWithStreamingCard(page);
|
|
await agent.client.waitForFinish(agent.agentId, 30_000);
|
|
await expectWholeCompletedCard(page);
|
|
// Local state is checked during growth; the viewport remounts on the history handoff.
|
|
const recovery = trackPluginChatRecovery(page);
|
|
// A chat with a cached cursor answers current and never fetches, so hold the subscribe itself.
|
|
gate.holdNextClientRequest("agent.timeline.set_subscription.request");
|
|
await page.reload({ waitUntil: "domcontentloaded" });
|
|
await gate.waitForHeldClientRequest();
|
|
await recovery.expectCatalogWithoutRetransmission();
|
|
gate.releaseHeldClientRequest();
|
|
await expectWholeCompletedCard(page);
|
|
await recovery.expectRecoveredWithoutRetransmission();
|
|
recovery.reset();
|
|
await reconnectPluginChat(page, gate);
|
|
await recovery.expectRecoveredWithoutRetransmission();
|
|
await expectWholeCompletedCard(page);
|
|
});
|
|
});
|
|
}
|
|
|
|
test("Overview preserves both consecutive tool plugin cards", async ({ page }, info) => {
|
|
await withTimelinePlugin(page, info, "tools", async (agent) => {
|
|
await requestPluginTimeline(agent);
|
|
await agent.client.waitForFinish(agent.agentId, 30_000);
|
|
await expectBothConsecutiveTools(page);
|
|
await page.reload({ waitUntil: "domcontentloaded" });
|
|
await expectBothConsecutiveTools(page);
|
|
});
|
|
});
|
|
|
|
test("inline-thinking example renders a streamed thought through host UI", async ({
|
|
page,
|
|
}, info) => {
|
|
await viewInlineThinkingExample(page, info);
|
|
});
|