Compare commits

..
Author SHA1 Message Date
Mohamed Boudra 06a16b63b8 chore(app): keep touch diagnostics passive across window layouts 2026-11-16 05:11:25 +01:00
Mohamed Boudra 454c1b4813 chore(app): capture diagnostic evidence for lost composer taps 2026-11-16 04:55:21 +01:00
Mohamed Boudra 4f97abc62a fix(app): align composer fullscreen controls with the text rail (#9821)
Fullscreen controls retained a fixed toolbar overhang and aligned to the Send arrow inside its disc. Align their visible glyph edges with the text column independently of the toolbar geometry.
2026-11-16 10:07:15 +07:00
Mohamed Boudra 39db933e6b Keep submitted prompts scrolling down through existing momentum (#9806)
* fix(app): preserve submit scroll through existing momentum

A prompt sent during an active gesture requested the bottom, but the older gesture cancelled that request when momentum ended away. Honor the still-sticky pending request on release while allowing a newer gesture to take ownership.

* fix(app): keep delayed navigation behind user scroll intent
2026-11-16 09:40:00 +07:00
Mohamed Boudra a7a12ef4cd fix(app): keep expanded tool details within their group (#9770)
* fix(app): bound complete inline tool details within groups

Apply the detail height allowance to the complete input/output/error disclosure so expanding a tool cannot bury its collapse header outside the group viewport.

* test(app): verify tool disclosure geometry across painted frames

* test(app): measure disclosure bounds without evidence capture

* fix(app): give capped tool details one vertical scroll owner

* fix(app): allow inline tool details to scroll on iPad

A hover-only Pressable claimed the native responder around the detail scroll view. Keep hover reporting on a passive View so drags reach the capped detail and its later sections remain accessible.

* fix(app): preserve scroll position inside overflowing tool groups

Content-size changes also come from nested disclosures. Follow newly appended calls while preserving the reader’s position when a disclosure changes height.

* test(app): assert inline tool visibility on iPad

Offscreen Output nodes exist before the pan, so selector waits cannot prove reachability. Assert visibility before and after scrolling and verify that collapsing hides the contents before reopening.

* refactor(app): remove unused tool detail hover callbacks

* docs(app): correct inline detail test coverage note

* fix(app): apply grouped detail allowance to reasoning
2026-11-16 09:37:55 +07:00
paseo-bot[bot]andClaude Opus 5.5 0273b6b614 fix(app): end bare URLs at CJK and fullwidth punctuation (#9799)
A bare URL that md4c does not autolink is linked by the text-link
pattern. That pattern stopped only at ASCII whitespace, quotes and
sentence punctuation, so "https://a.com、https://b.com!" became one
link, and "看这里:https://example.com/foo,还有" linked ",还有" too.
Opening the link went to a URL ending in the encoded punctuation.

CJK, fullwidth and typographic punctuation (、。,()【】「」“”…) now
ends the URL. CJK letters in paths still stay in the link.

Refs #9743

Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 20:52:24 +00:00
paseo-bot[bot]andClaude Opus 5.5 8c88b83cd8 fix(server): preview the newest turn's reply in finished notifications (#9793)
A turn the provider starts on its own, such as Claude waking after a
background subagent, has no user message before its reply. The last
assistant message lookup joined every adjacent assistant row, so it
returned the previous turn's reply with the new one appended, and the
220-character notification preview showed only the old reply.

Stop the backward scan at the turn boundary so the lookup returns only
the newest turn's reply, while chunks of one turn are still joined.

Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 20:02:46 +00:00
tieoandClaude Opus 5.5 b55955541e fix(dictation): surface the daemon's stream error instead of a delivery timeout (#9784)
The daemon drops a dictation stream when its STT session errors and answers
every later chunk with dictation_stream_error. The app only listened for
acks, so finishing waited 30s and reported a generic timeout. The sender now
fails finish with the daemon's message, and the daemon logs the failure that
dropped the stream once instead of nothing.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 19:05:47 +00:00
49 changed files with 1080 additions and 603 deletions
+4 -2
View File
@@ -156,8 +156,10 @@ keeps following.
Following resumes only for a gesture that ends within 1 px of the end, either when the finger lifts
or when momentum stops. A release past the end counts: iOS bounces back to the end, and lines that
land during the bounce must keep scrolling in. A release anywhere short of the end stays detached
with the scroll-to-bottom pill, so the rows the user let go of never move.
land during the bounce must keep scrolling in. A release short of the end stays detached with the scroll-to-bottom pill unless you submitted
another prompt during that gesture. That submit requests the end after the gesture finishes;
a new drag after submitting takes ownership again. Rewind and tail-fetch completions do not
override a scroll away because they can arrive after the action that requested them.
### Draw distance
+2 -6
View File
@@ -126,12 +126,8 @@ keeps Explorer underneath and closing the sheet uncovers it. Semantic navigation
actual destination before revealing it, including deduplicated targets.
Compact overlay selection and saved dock visibility are independent. Folding changes geometry,
not either mode’s visibility intent. Native retains up to three recent workspaces; web retains
up to ten. Both use the existing inactive TTL. A native workspace with an open file sheet still
unmounts on navigation because its sheet stack uses the app-wide host. Other sheets close when
their retained owner becomes inactive, unless the owner already hides them on focus loss.
Import-session and tab-rename forms retain their open state on return. Review drafts survive
presentation unmounts.
not either mode’s visibility intent. Native workspace retention remains one workspace; web retains
up to ten with its existing inactive TTL.
PR discovery belongs to the active workspace: split layouts discover while active, and other
layouts discover while Explorer is active. The rail requests summary status; selected visible PR
+1 -3
View File
@@ -58,9 +58,7 @@ cannot deliver them.
Register keyboard handling with `useOverlayRegistration` from `@/keyboard`.
Pass the surface's open state, layer, handled keys and `onKeyDown`. The highest
layer gets first refusal; the latest registration wins a tie. Native registration
does not need a DOM ref. The native adapter releases overlay keyboard ownership when a retained
panel hides, even if the owner keeps its open state. Web releases ownership when the scope
detaches, preserving the original focus-return target across a hide.
does not need a DOM ref. Web adds focus trapping and restoration through its adapter.
Declaring Tab takes it from the web focus trap and hands it to `onKeyDown`; the command
center rotates its tabs with it. Native sources drop Tab from the declarations.
@@ -148,51 +148,3 @@ test.describe("mobile bottom sheet reopen", () => {
}
});
});
async function switchToNextWorkspace(page: Page, workspaceId: string) {
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${workspaceId}`));
}
test("leaving a retained workspace dismisses its model sheet", async ({ page }) => {
const first = await openMockAgentAtMobileBreakpoint(page);
const second = await seedMockAgentWorkspace({
repoPrefix: "sheet-other-workspace-",
title: "Other workspace",
initialPrompt: "Prepare another workspace.",
});
try {
await openModelSelector(page);
await switchToNextWorkspace(page, second.workspaceId);
await expect(page.getByTestId("agent-controls-model-sheet")).not.toBeInViewport();
await expectComposerVisible(page);
await switchToNextWorkspace(page, first.workspaceId);
await expect(page.getByTestId("agent-controls-model-sheet")).not.toBeInViewport();
await expectComposerVisible(page);
} finally {
await second.cleanup();
await first.cleanup();
}
});
test("leaving a retained workspace closes its context window sheet", async ({ page }) => {
const first = await openMockAgentAtMobileBreakpoint(page);
const second = await seedMockAgentWorkspace({
repoPrefix: "context-sheet-other-",
title: "Other workspace",
});
try {
await page.getByRole("button", { name: /Context window.*used/ }).click();
const sheet = page.getByRole("dialog", { name: "Context window", exact: true });
await expect(sheet).toBeInViewport();
await switchToNextWorkspace(page, second.workspaceId);
await expect(sheet).not.toBeInViewport();
await expectComposerVisible(page);
await switchToNextWorkspace(page, first.workspaceId);
await expect(sheet).not.toBeInViewport();
await expectComposerVisible(page);
} finally {
await second.cleanup();
await first.cleanup();
}
});
@@ -1,4 +1,3 @@
import { openAgentRoute, seedMockAgentWorkspace } from "../support/helpers/mock-agent";
import { expect, test } from "../support/fixtures";
import { clickNewChat } from "../support/helpers/launcher";
import { expectComposerVisible } from "../support/helpers/composer";
@@ -311,32 +310,3 @@ test.describe("Composer attachments", () => {
}
});
});
test("image lightbox hides when its retained workspace becomes inactive", async ({ page }) => {
const first = await seedMockAgentWorkspace({
repoPrefix: "image-owner-",
title: "Image workspace",
});
const second = await seedMockAgentWorkspace({
repoPrefix: "image-other-",
title: "Other workspace",
});
try {
await openAgentRoute(page, first);
await expectComposerVisible(page);
await attachImageFromMenu(page, TEST_IMAGE);
await openImageLightbox(page);
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${second.workspaceId}`));
await expect(page.getByTestId("attachment-lightbox-close")).not.toBeVisible();
await expectComposerVisible(page);
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${first.workspaceId}`));
await expect(page.getByTestId("attachment-lightbox-close")).toBeVisible();
await closeImageLightbox(page);
await expect(page.getByRole("button", { name: "Open image attachment" }).first()).toBeFocused();
} finally {
await second.cleanup();
await first.cleanup();
}
});
@@ -248,33 +248,6 @@ test.describe("review comments", () => {
}
});
test("compact review draft survives a workspace switch", async ({ page }) => {
const workspace = await seedChangedAgent("retained-review-draft-");
const other = await seedMockAgentWorkspace({
repoPrefix: "review-other-",
title: "Other workspace",
});
try {
await openReviewDiff(page, workspace);
await showCompactLayout(page);
await tapFirstAddedDiffLine(page);
await expectCompactCommentSheet(page);
await fillReviewComment(page, "Keep this unsaved review");
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${other.workspaceId}`));
await expect(page.getByTestId("review-comment-sheet")).not.toBeInViewport();
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${workspace.workspaceId}`));
await expect(page.getByRole("textbox", { name: "Review comment" })).toHaveValue(
"Keep this unsaved review",
);
await cancelReviewComment(page);
} finally {
await other.cleanup();
await workspace.cleanup();
}
});
test("wide review comments retain inline editing", async ({ page }) => {
const workspace = await seedChangedAgent("wide-review-comment-");
try {
@@ -70,8 +70,6 @@ function enableDictationCapability(message: WebSocketMessage): WebSocketMessage
async function installSyntheticMicrophone(page: Page): Promise<void> {
await page.addInitScript(() => {
const mediaDevices = navigator.mediaDevices;
const tracks: MediaStreamTrack[] = [];
Object.defineProperty(window, "dictationTestTracks", { value: tracks });
Object.defineProperty(mediaDevices, "getUserMedia", {
configurable: true,
value: async () => {
@@ -80,15 +78,13 @@ async function installSyntheticMicrophone(page: Page): Promise<void> {
const destination = context.createMediaStreamDestination();
oscillator.connect(destination);
oscillator.start();
tracks.push(...destination.stream.getTracks());
return destination.stream;
},
});
});
}
async function installDictationFailureHarness(page: Page, holdTranscript = false) {
let deliverTranscript: (() => void) | null = null;
async function installDictationFailureHarness(page: Page) {
let resolveAudioChunk!: () => void;
let resolveCreateRequest!: () => void;
const audioChunk = new Promise<void>((resolve) => {
@@ -126,14 +122,12 @@ async function installDictationFailureHarness(page: Page, holdTranscript = false
if (type === "dictation_stream_finish" && dictationId) {
sendSessionMessage(ws, {
type: "dictation_stream_finish_accepted",
payload: { dictationId, timeoutMs: holdTranscript ? 60_000 : 5_000 },
payload: { dictationId, timeoutMs: 5_000 },
});
sendSessionMessage(ws, {
type: "dictation_stream_final",
payload: { dictationId, text: TRANSCRIPT },
});
deliverTranscript = () =>
sendSessionMessage(ws, {
type: "dictation_stream_final",
payload: { dictationId, text: TRANSCRIPT },
});
if (!holdTranscript) deliverTranscript();
return;
}
if (request && type === "workspace.create.request" && typeof request.requestId === "string") {
@@ -161,11 +155,6 @@ async function installDictationFailureHarness(page: Page, holdTranscript = false
return {
waitForAudio: () => audioChunk,
hasPendingTranscript: () => deliverTranscript !== null,
deliverTranscript: () => {
if (!deliverTranscript) throw new Error("No pending transcript");
deliverTranscript();
},
waitForCreateRequest: () => createRequest,
failWorkspaceCreation: () => {
if (!failCreate) {
@@ -265,75 +254,3 @@ test("dictation shortcut leaves retained fullscreen and exposes recording contro
await agent.cleanup();
}
});
test("leaving a retained workspace stops dictation and preserves its draft", async ({ page }) => {
const first = await seedMockAgentWorkspace({
repoPrefix: "dictation-owner-",
title: "Recording workspace",
});
const second = await seedMockAgentWorkspace({
repoPrefix: "dictation-other-",
title: "Other workspace",
});
await installSyntheticMicrophone(page);
const harness = await installDictationFailureHarness(page);
try {
await openAgentRoute(page, first);
await expectComposerVisible(page);
await fillComposerDraft(page, "Keep this draft");
await page.getByRole("button", { name: "Start dictation", exact: true }).click();
await harness.waitForAudio();
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${second.workspaceId}`));
await expect.poll(() => microphoneTracksEnded(page)).toBe(true);
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${first.workspaceId}`));
await expect(composerLocator(page)).toHaveValue("Keep this draft");
await expect(page.getByRole("button", { name: "Cancel dictation", exact: true })).toHaveCount(
0,
);
} finally {
await second.cleanup();
await first.cleanup();
}
});
function microphoneTracksEnded(page: Page): Promise<boolean> {
return page.evaluate(() => {
const tracks = (window as unknown as { dictationTestTracks: MediaStreamTrack[] })
.dictationTestTracks;
return tracks.length > 0 && tracks.every((track) => track.readyState === "ended");
});
}
test("confirmed dictation survives leaving and returning while pending", async ({ page }) => {
const first = await seedMockAgentWorkspace({
repoPrefix: "dictation-processing-",
title: "Processing workspace",
});
const second = await seedMockAgentWorkspace({
repoPrefix: "dictation-other-",
title: "Other workspace",
});
await installSyntheticMicrophone(page);
const harness = await installDictationFailureHarness(page, true);
try {
await openAgentRoute(page, first);
await expectComposerVisible(page);
await page.getByRole("button", { name: "Start dictation", exact: true }).click();
await harness.waitForAudio();
await page.getByRole("button", { name: "Insert transcription", exact: true }).click();
await expect.poll(harness.hasPendingTranscript).toBe(true);
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${second.workspaceId}`));
await expect.poll(() => microphoneTracksEnded(page)).toBe(true);
await page.keyboard.press("Alt+]");
await page.waitForURL((url) => url.pathname.endsWith(`/workspace/${first.workspaceId}`));
await expect(page.getByRole("button", { name: "Cancel dictation", exact: true })).toBeVisible();
harness.deliverTranscript();
await expect(composerLocator(page)).toHaveValue(TRANSCRIPT);
} finally {
await second.cleanup();
await first.cleanup();
}
});
@@ -153,21 +153,29 @@ async function holdStreamAfterFirstCompletedToolCall(page: Page, agentId: string
type OverviewChatDisplay = "collapseToolCalls" | "collapseTurns";
// Expand thinking keeps reasoning out of tool call runs, so the first tool call starts alone.
async function configureOverviewToolCalls(page: Page, chatDisplay: OverviewChatDisplay) {
await page.addInitScript((display) => {
localStorage.setItem(
"@paseo:app-settings",
JSON.stringify({ chatDisplay: display, autoExpandReasoning: true }),
);
}, chatDisplay);
async function configureOverviewToolCalls(
page: Page,
chatDisplay: OverviewChatDisplay,
autoExpandReasoning: boolean,
) {
await page.addInitScript(
({ display, expandReasoning }) => {
localStorage.setItem(
"@paseo:app-settings",
JSON.stringify({ chatDisplay: display, autoExpandReasoning: expandReasoning }),
);
},
{ display: chatDisplay, expandReasoning: autoExpandReasoning },
);
}
async function createOverviewAgent(
page: Page,
title: string,
chatDisplay: OverviewChatDisplay = "collapseToolCalls",
autoExpandReasoning = true,
) {
await configureOverviewToolCalls(page, chatDisplay);
await configureOverviewToolCalls(page, chatDisplay, autoExpandReasoning);
return seedMockAgentWorkspace({
repoPrefix: "tool-call-overview-sheet-",
title,
@@ -401,3 +409,211 @@ test("forms a closed group when the lone tool call was left closed", async ({ pa
await agent.cleanup();
}
});
const longGroupedDetail = {
type: "unknown",
input: Array.from({ length: 80 }, (_, i) => `Long input ${i}`),
output: Array.from({ length: 80 }, (_, i) => `Long output ${i}`),
};
function provideLongReadDetail(item: Record<string, unknown> | undefined) {
if (item?.type === "tool_call" && item.name === "read") item.detail = longGroupedDetail;
}
function provideLongReasoningDetail(item: Record<string, unknown> | undefined) {
if (item?.type === "reasoning") {
item.text = Array.from({ length: 80 }, (_, i) => `Long reasoning ${i}`).join("\n");
}
}
async function provideLongToolDetails(page: Page, transformItem = provideLongReadDetail) {
await page.routeWebSocket(daemonWsRoutePattern(), (ws) => {
const server = ws.connectToServer();
ws.onMessage((message) => server.send(message));
server.onMessage((message) => {
const raw = typeof message === "string" ? message : message.toString("utf8");
const envelope = JSON.parse(raw);
const item = envelope.message?.payload?.event?.item;
transformItem(item);
if (envelope.message?.type === "fetch_agent_timeline_response") {
for (const entry of envelope.message.payload.entries) transformItem(entry.item);
}
ws.send(JSON.stringify(envelope));
});
});
}
async function toggleAndMeasureTool(badge: Locator) {
await badge.scrollIntoViewIfNeeded();
await badge.evaluate((node) => {
// Inline groups own a bounded viewport; opened turns use the chat viewport.
const container =
node.closest('[data-testid="tool-call-group"]') ??
node.closest('[data-testid="agent-chat-scroll"]');
if (!container) throw new Error("Expected a tool inside a group or chat viewport");
const frames: { top: number; height: number; containerHeight: number }[] = [];
(node as HTMLElement & { disclosureFrames: typeof frames }).disclosureFrames = frames;
node.querySelector("button")!.addEventListener(
"click",
() => {
const measure = () => {
const bounds = node.getBoundingClientRect();
frames.push({
top: bounds.top,
height: bounds.height,
containerHeight: container.getBoundingClientRect().height,
});
if (frames.length < 20) requestAnimationFrame(measure);
};
requestAnimationFrame(measure);
},
{ once: true },
);
});
await openToolDetails(badge);
await expect
.poll(() =>
badge.evaluate(
(node) => (node as HTMLElement & { disclosureFrames: unknown[] }).disclosureFrames.length,
),
)
.toBe(20);
return badge.evaluate(
(node) =>
(
node as HTMLElement & {
disclosureFrames: { top: number; height: number; containerHeight: number }[];
}
).disclosureFrames,
);
}
for (const display of ["collapseToolCalls", "collapseTurns"] as const) {
test(`keeps multi-section tool details within the group (${display})`, async ({ page }) => {
test.setTimeout(120_000);
const agent = await createOverviewAgent(page, "Bounded grouped tool details", display);
try {
await provideLongToolDetails(page);
await openOverviewAgent(page, agent);
await agent.client.sendAgentMessage(agent.agentId, "Exercise bounded grouped details.");
await agent.client.waitForAgentUpsert(
agent.agentId,
(snapshot) => snapshot.status === "idle",
30_000,
);
// A fresh mount of a finished conversation starts with its disclosures closed.
await page.reload();
await expectComposerVisible(page);
if (display === "collapseToolCalls") {
await scrollChatAwayFromBottom(page, { deltaY: -10_000, minDistanceFromBottom: 1 });
}
const group = page.getByTestId("tool-call-group").first();
if (display === "collapseTurns") {
await expect(page.getByTestId("tool-call-badge")).toHaveCount(0);
await openToolDetails(page.getByTestId("turn-summary").first());
} else {
await expect(group).toBeVisible();
await expect(group.getByTestId("tool-call-badge")).toHaveCount(0);
await openToolDetails(group);
}
const scope = display === "collapseTurns" ? page : group;
const badge = scope.getByTestId("tool-call-badge").filter({ hasText: "Read" }).first();
await expect(badge).toBeVisible();
const expandedFrames = await toggleAndMeasureTool(badge);
for (const frame of expandedFrames)
expect(frame.height).toBeLessThanOrEqual(frame.containerHeight);
expect(
Math.max(...expandedFrames.map((frame) => frame.top)) -
Math.min(...expandedFrames.map((frame) => frame.top)),
).toBeLessThanOrEqual(1);
await expect(badge).toContainText("Long output");
const collapsedFrames = await toggleAndMeasureTool(badge);
expect(
Math.max(...collapsedFrames.map((frame) => frame.top)) -
Math.min(...collapsedFrames.map((frame) => frame.top)),
).toBeLessThanOrEqual(1);
await expect(badge).not.toContainText("Long output");
} finally {
await agent.cleanup();
}
});
}
test("keeps tool headers reachable in an overflowing group", async ({ page }) => {
test.setTimeout(120_000);
const agent = await createOverviewAgent(page, "Overflowing overview tool group");
try {
const gate = await holdStreamAfterFirstCompletedToolCall(page, agent.agentId);
await openOverviewAgent(page, agent);
await agent.client.sendAgentMessage(agent.agentId, "Inspect a large tool group.");
await gate.waitForFirstCompleted();
gate.appendCompletedCalls(15);
const group = page.getByTestId("tool-call-group").first();
await openToolDetails(group);
const badges = group.getByTestId("tool-call-badge");
await expect(badges).toHaveCount(16);
await expect.poll(() => group.evaluate(hasScrolledToLatest)).toBe(true);
const first = badges.first();
for (const action of ["expand", "collapse"]) {
await test.step(`${action} the first tool without moving its header`, async () => {
await first.scrollIntoViewIfNeeded();
const headerTop = await topOf(first);
const frames = await toggleAndMeasureTool(first);
for (const frame of frames) expect(Math.abs(frame.top - headerTop)).toBeLessThanOrEqual(1);
});
}
await test.step("follow the next appended tool", async () => {
gate.appendCompletedCalls(1);
await expect(badges).toHaveCount(17);
await expect.poll(() => group.evaluate(hasScrolledToLatest)).toBe(true);
});
await test.step("reopen the group at its latest tool", async () => {
await openToolDetails(group);
await expect(badges).toHaveCount(0);
await openToolDetails(group);
await expect(badges).toHaveCount(17);
await expect.poll(() => group.evaluate(hasScrolledToLatest)).toBe(true);
});
} finally {
await agent.cleanup();
}
});
test("keeps expanded reasoning within the group viewport", async ({ page }) => {
test.setTimeout(120_000);
const agent = await createOverviewAgent(
page,
"Bounded grouped reasoning",
"collapseToolCalls",
false,
);
try {
// Seed before opening so the fixture transforms complete snapshots, not token deltas.
await agent.client.sendAgentMessage(agent.agentId, "Inspect grouped reasoning.");
await agent.client.waitForAgentUpsert(
agent.agentId,
(snapshot) => snapshot.status === "idle",
30_000,
);
await provideLongToolDetails(page, provideLongReasoningDetail);
await openOverviewAgent(page, agent);
await scrollChatAwayFromBottom(page, { deltaY: -10_000, minDistanceFromBottom: 1 });
const group = page.getByTestId("tool-call-group").first();
await openToolDetails(group);
const thought = group.getByTestId("tool-call-badge").filter({ hasText: "Thinking" }).first();
const frames = await toggleAndMeasureTool(thought);
const viewportHeight = await group.evaluate((node) => {
const scroll = Array.from(node.querySelectorAll<HTMLElement>("*")).find((child) =>
["auto", "scroll"].includes(getComputedStyle(child).overflowY),
);
if (!scroll) throw new Error("Expected the group's scroll viewport");
return scroll.getBoundingClientRect().height;
});
for (const frame of frames) expect(frame.height).toBeLessThanOrEqual(viewportHeight);
await expect(thought).toContainText("Long reasoning 79");
await openToolDetails(thought);
await expect(thought).not.toContainText("Long reasoning 79");
} finally {
await agent.cleanup();
}
});
@@ -0,0 +1,28 @@
# Inline tool detail scrolling on iPad
Use a task-owned iPad Pro 11-inch (M5) simulator in portrait (834×1210 points),
with the development bundle already loaded and a connected isolated mock host.
Set Chat display to Collapse turns. Prepare a finished turn containing a tool
named `scroll_probe`, with unknown detail: `input` is 80 newline-separated
`input-line-N` lines (N=0…79), and `output` is `SCROLL_REACHED_OUTPUT`.
Expand the turn, scroll chat to its start, and expand Scroll probe. The tool's
header must be at y=613…644 and its 400-point body below it. The fixed pan path
starts inside that body and stays inside it. Output starts below the cap.
These are replay preconditions, not asserted pixel sizes. Close other expanded
tools so the Scroll probe selector identifies this disclosure.
Replay `native-inline-tool-scroll.ios.yaml --maestro` on that explicit simulator
through the existing mobile runner or agent-device. In Expo's development menu,
turn off Tools button, then dismiss the known notification entitlement toast
with its bottom-right close button. Their transparent accessibility windows
otherwise mark app text covered. Another overlay must fail the visibility
assertions. Pass `--platform ios` and the prepared session's `--state-dir` when
replaying in that session.
The flow first asserts Input is visible and the output marker is not. After
panning it requires Output and its marker to be visible, then requires closing
the tool to hide its contents and reopening it to show Input again. Presence in
the accessibility tree is insufficient. A negative control with the passive
wrapper retained and only the detail's scrolling disabled must fail at Output
visibility. The browser disclosure suite checks tab navigation.
@@ -0,0 +1,28 @@
appId: sh.paseo.debug
---
- assertVisible:
id: workspace-tabs-scroll
- assertVisible: Scroll probe
- assertVisible: Input
- assertNotVisible: SCROLL_REACHED_OUTPUT
- repeat:
times: 7
commands:
- swipe:
start: "600,850"
end: "600,670"
duration: 600
- swipe:
start: "600,850"
end: "600,700"
duration: 600
- assertVisible: Output
- assertVisible: SCROLL_REACHED_OUTPUT
- tapOn:
point: "600,628"
- assertNotVisible: Output
- assertNotVisible: Input
- tapOn:
point: "600,628"
- assertVisible: Input
- stopApp
@@ -15,5 +15,6 @@ android {
}
dependencies {
implementation 'com.facebook.react:react-android'
testImplementation "junit:junit:4.13.2"
}
@@ -1,26 +1,48 @@
package sh.paseo.trace
import android.os.Trace
import com.facebook.react.bridge.UiThreadUtil
import com.facebook.react.bridge.ReactContext
import expo.modules.kotlin.modules.Module
import expo.modules.kotlin.modules.ModuleDefinition
class PaseoNativeTraceModule : Module() {
private var recorder: DiagnosticRecorder? = null
private var touches: TouchDiagnostics? = null
override fun definition() = ModuleDefinition {
Name("PaseoNativeTrace")
Function("startRecorder") { metadata: Map<String, String> ->
if (recorder == null) {
appContext.reactContext?.applicationContext?.let { recorder = DiagnosticRecorder(it, metadata) }
(appContext.reactContext as? ReactContext)?.let { context ->
val sink = DiagnosticRecorder(context.applicationContext, metadata)
recorder = sink
UiThreadUtil.runOnUiThread {
if (recorder === sink) {
touches = TouchDiagnostics(context, sink::record).also { it.start(appContext.currentActivity?.window) }
}
}
}
}
HeartbeatTiming.intervalMs
}
Function("record") { name: String, data: Map<String, String> -> recorder?.record(name, data) }
Function("heartbeat") { recorder?.heartbeat() }
OnActivityEntersForeground { recorder?.active(true) }
OnActivityEntersForeground {
recorder?.active(true)
UiThreadUtil.runOnUiThread { touches?.activity(appContext.currentActivity?.window) }
}
OnActivityEntersBackground { recorder?.active(false) }
OnDestroy { recorder?.close(); recorder = null }
OnDestroy {
val sink = recorder
recorder = null
UiThreadUtil.runOnUiThread {
touches?.close()
touches = null
sink?.close()
}
}
Function("beginSection") { name: String ->
Trace.beginSection(name.take(127))
@@ -0,0 +1,141 @@
package sh.paseo.trace
import android.graphics.Rect
import android.os.Build
import android.view.MotionEvent
import android.view.View
import android.view.ViewGroup
import android.view.Window
import android.view.WindowInsets
import com.facebook.react.R
import com.facebook.react.bridge.ReactContext
import com.facebook.react.bridge.UiThreadUtil
import com.facebook.react.interfaces.ExtraWindowEventListener
import com.facebook.react.uimanager.ReactPointerEventsView
import com.facebook.react.uimanager.TouchTargetHelper
import com.facebook.react.uimanager.RootView
/** Temporary touch evidence. Only attached while the diagnostic recorder is running. */
internal class TouchDiagnostics(
private val context: ReactContext,
private val write: (String, Map<String, String>) -> Unit,
) : ExtraWindowEventListener {
private val windows = mutableMapOf<Window, TouchCallback>()
private var nextWindow = 0
private var activityWindow: Window? = null
fun start(window: Window?) {
UiThreadUtil.assertOnUiThread()
context.addExtraWindowEventListener(this)
activity(window)
}
fun activity(window: Window?) {
if (activityWindow === window) return
activityWindow?.let { release(it) }
activityWindow = window
window?.let { observe(it) }
}
override fun onExtraWindowCreate(window: Window) = observe(window)
override fun onExtraWindowDestroy(window: Window) = release(window)
private fun observe(window: Window) {
if (windows.containsKey(window)) return
val callback = TouchCallback(window, window.callback, ++nextWindow, write)
windows[window] = callback
window.callback = callback
write("touch.window.open", mapOf("window" to "$nextWindow"))
}
private fun release(window: Window) {
val callback = windows.remove(window) ?: return
// Another observer may wrap ours. Disable it even when we cannot unwrap its owner.
callback.active = false
if (window.callback === callback) window.callback = callback.previous
write("touch.window.close", mapOf("window" to "${callback.id}"))
}
fun close() {
context.removeExtraWindowEventListener(this)
windows.keys.toList().forEach { release(it) }
activityWindow = null
}
}
private class TouchCallback(
private val window: Window,
val previous: Window.Callback,
val id: Int,
private val write: (String, Map<String, String>) -> Unit,
) : Window.Callback by previous {
var active = true
override fun dispatchTouchEvent(event: MotionEvent): Boolean {
val boundary = event.actionMasked == MotionEvent.ACTION_DOWN ||
event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL
if (!active || !boundary) return previous.dispatchTouchEvent(event)
val fields = mutableMapOf(
"window" to "$id", "gesture" to "${event.downTime}",
"action" to "${event.actionMasked}", "eventMs" to "${event.eventTime}",
"x" to "${event.x}", "y" to "${event.y}",
"imeVisible" to if (Build.VERSION.SDK_INT >= 30) "${window.decorView.rootWindowInsets?.isVisible(WindowInsets.Type.ime())}" else "unsupported",
"imeBottom" to if (Build.VERSION.SDK_INT >= 30) "${window.decorView.rootWindowInsets?.getInsets(WindowInsets.Type.ime())?.bottom}" else "unsupported",
"focus" to describe(window.currentFocus),
)
// This is a hit-test prediction, not proof that the eventual responder accepted the press.
// Use RN's own pointer-events and transformed-coordinate rules, rather than approximating them.
val root = reactRootAt(window.decorView, event.x.toInt(), event.y.toInt())
if (root != null) {
try {
val origin = IntArray(2)
root.getLocationOnScreen(origin)
val path = TouchTargetHelper.findTargetPathAndCoordinatesForTouch(event.rawX - origin[0], event.rawY - origin[1], root, FloatArray(2))
path.take(10).forEachIndexed { index, target ->
fields["hit$index"] = "${target.getViewId()}:${describe(target.getView())}"
}
} catch (error: RuntimeException) {
fields["hitError"] = error.javaClass.simpleName
}
}
write("touch.window.before", fields)
val handled = previous.dispatchTouchEvent(event)
write("touch.window.after", mapOf(
"window" to "$id", "gesture" to "${event.downTime}",
"action" to "${event.actionMasked}", "handled" to "$handled",
"focus" to describe(window.currentFocus),
))
return handled
}
}
private fun describe(view: View?): String {
if (view == null) return "none"
// Deliberately omit text, accessibility labels, nativeID, and content descriptions.
val pointer = (view as? ReactPointerEventsView)?.pointerEvents
val testId = (view.getTag(R.id.react_test_id) as? String)?.takeIf { it in diagnosticTestIds } ?: ""
return "${view.javaClass.simpleName}#$testId/${view.id};p=$pointer;a=${view.alpha};enabled=${view.isEnabled};frame=${view.left},${view.top},${view.width},${view.height};translation=${view.translationX},${view.translationY}"
}
// Other test IDs include user-controlled entity IDs. Keep only fixed surface names.
private val diagnosticTestIds = setOf(
"message-input-root", "composer-fullscreen", "composer-viewport", "composer-viewport-content",
"composer-dock-content", "composer-track-scroll", "agent-list-backdrop", "file-explorer-backdrop",
"workspace-create-submit", "new-workspace-launch-submit", "compact-provider-list",
)
// Expo's developer menu adds a full-window Compose host above the React root. It passes ordinary
// touches through, but RN's helper cannot traverse that host. Start at the actual React surface;
// native modal windows expose a separate RootView and receive their own observation.
private fun reactRootAt(view: View, x: Int, y: Int): ViewGroup? {
if (view.visibility != View.VISIBLE || view.alpha == 0f) return null
// getGlobalVisibleRect is relative to the window root, including for offset/freeform windows.
val bounds = Rect()
if (!view.getGlobalVisibleRect(bounds) || !bounds.contains(x, y)) return null
if (view is RootView && view is ViewGroup) return view
if (view is ViewGroup) {
for (index in view.childCount - 1 downTo 0) {
reactRootAt(view.getChildAt(index), x, y)?.let { return it }
}
}
return null
}
@@ -394,6 +394,56 @@ describe("bottom anchor controller driver", () => {
expect(harness.scrollAttempts).toHaveLength(0);
});
it("honors a submit made during a gesture when that gesture ends away", () => {
const harness = createDriverHarness({ isNearBottom: false });
harness.driver.beginUserScroll();
harness.driver.requestLocalAnchor({ agentId: "agent-1", reason: "message-sent" });
harness.scheduler.flushAll();
expect(harness.scrollAttempts).toEqual([]);
harness.driver.endUserScroll({ isAtEnd: false });
harness.scheduler.flushAll();
expect(harness.context.measurementState.offsetY).toBe(
harness.context.measurementState.contentHeight -
harness.context.measurementState.viewportHeight,
);
expect(harness.driver.getSnapshot()).toMatchObject({
mode: "sticky-bottom",
pendingRequest: null,
});
});
it.each(["rewind", "jump-to-bottom"] as const)(
"lets scrolling away supersede a late %s request",
(reason) => {
const harness = createDriverHarness({ isNearBottom: false });
harness.driver.beginUserScroll();
harness.driver.requestLocalAnchor({ agentId: "agent-1", reason });
harness.driver.endUserScroll({ isAtEnd: false });
harness.scheduler.flushAll();
expect(harness.scrollAttempts).toEqual([]);
expect(harness.driver.getSnapshot()).toMatchObject({
mode: "detached",
pendingRequest: null,
});
},
);
it("lets a new gesture supersede a submit requested during the previous gesture", () => {
const harness = createDriverHarness({ isNearBottom: false });
harness.driver.beginUserScroll();
harness.driver.requestLocalAnchor({ agentId: "agent-1", reason: "message-sent" });
harness.driver.endUserScroll({ isAtEnd: false });
harness.driver.beginUserScroll();
harness.driver.endUserScroll({ isAtEnd: false });
harness.scheduler.flushAll();
expect(harness.scrollAttempts).toEqual([]);
expect(harness.driver.getSnapshot()).toMatchObject({ mode: "detached", pendingRequest: null });
});
it("resumes following when a user scroll ends at the end", () => {
const harness = createDriverHarness({
transportBehavior: {
@@ -499,11 +499,16 @@ function createBottomAnchorControllerDriver(
cancelPendingAttempt();
setModeInternal("detached");
},
// Following resumes only for a gesture that ends at the end. Resuming from short of it would
// scroll the rows the finger just let go of, so a release above the end, or with output that
// arrived below it during the gesture, stays detached with the pill.
// A gesture ending short stays detached unless a newer prompt submission requested the end.
// Passive output must not move the rows the finger just let go of.
endUserScroll(params) {
isUserScrollActive = false;
// Submit arrives with the user's action; rewind and tail jumps can arrive after a fetch.
// A newer gesture would have detached again, so only a still-sticky submit owns release.
if (pendingRequest?.reason === "message-sent" && mode === "sticky-bottom") {
evaluate(false, "user_scroll_end");
return;
}
if (params.isAtEnd) {
if (mode === "detached") {
setModeInternal("sticky-bottom");
@@ -4,6 +4,7 @@ import { within } from "@testing-library/dom";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { i18n as testI18n } from "@/i18n/i18next";
import { ToolCallDetailsContent } from "@/components/tool-call-details";
import { ExpandableBadge } from "@/components/message";
import { page, userEvent } from "vitest/browser";
import { PlanCard } from "@/components/plan-card";
@@ -202,3 +203,87 @@ describe("tool badge file action", () => {
expect(view().queryByText("File contents")).toBeNull();
});
});
const longDetail = {
type: "unknown" as const,
input: { text: "input\n".repeat(80) },
output: { text: "output\n".repeat(80) },
};
describe("inline tool detail height", () => {
it("caps the complete detail, including input, output and error, to its allowance", () => {
act(() =>
root.render(
<QueryClientProvider client={queryClient}>
<ToolCallDetailsContent
detail={longDetail}
errorText={"error\n".repeat(80)}
maxHeight={200}
/>
</QueryClientProvider>,
),
);
expect(container.getBoundingClientRect().height).toBeLessThanOrEqual(200);
expect(container.textContent).toContain("output");
expect(container.textContent).toContain("error");
});
});
const longShellDetail = {
type: "shell" as const,
command: "echo command\n".repeat(80),
output: "output\n".repeat(80),
};
const longEditDetail = {
type: "edit" as const,
filePath: "example.txt",
oldString: "old line\n".repeat(80),
newString: "new line\n".repeat(80),
};
describe("capped tool scrolling", () => {
it.each([longShellDetail, longEditDetail])(
"gives a capped $type detail one vertical scroll owner",
(detail) => {
act(() =>
root.render(
<QueryClientProvider client={queryClient}>
<ToolCallDetailsContent detail={detail} maxHeight={200} />
</QueryClientProvider>,
),
);
const verticalScrollers = Array.from(container.querySelectorAll("*")).filter((node) =>
["auto", "scroll"].includes(getComputedStyle(node).overflowY),
);
expect(verticalScrollers).toHaveLength(1);
expect(container.getBoundingClientRect().height).toBeLessThanOrEqual(200);
},
);
});
function renderCopyOutput() {
return <button type="button">Copy output</button>;
}
describe("tool detail interaction", () => {
it("keeps detail controls in the tab order", async () => {
function Badge() {
const [expanded, setExpanded] = React.useState(true);
const toggle = React.useCallback(() => setExpanded(!expanded), [expanded]);
return (
<ExpandableBadge
label="Probe"
isExpanded={expanded}
onToggle={toggle}
renderDetails={renderCopyOutput}
/>
);
}
act(() => root.render(<Badge />));
const header = view().getByRole("button", { name: "Probe" });
act(() => header.focus());
await userEvent.keyboard("{Tab}");
expect(document.activeElement).toBe(view().getByRole("button", { name: "Copy output" }));
});
});
+4
View File
@@ -883,6 +883,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
status={call.status}
isLastInSequence={index === group.run.calls.length - 1}
defaultExpanded={false}
maxDetailHeight={GROUPED_TOOL_CALL_DETAIL_MAX_HEIGHT}
standalone={false}
onInlineDetailsExpandedChangeByItemId={setInlineDetailsExpanded}
/>
@@ -1375,6 +1376,7 @@ interface ThoughtSlotProps {
isLastInSequence: boolean;
defaultExpanded: boolean;
standalone?: boolean;
maxDetailHeight?: number;
}
// Reasoning text is paced the same way assistant text is; see @/hooks/use-revealed-text.
@@ -1386,6 +1388,7 @@ function ThoughtSlot({
isLastInSequence,
defaultExpanded,
standalone,
maxDetailHeight,
}: ThoughtSlotProps) {
const revealedText = useRevealedText(text, status === "ready" ? "complete" : "streaming");
return (
@@ -1398,6 +1401,7 @@ function ThoughtSlot({
isLastInSequence={isLastInSequence}
defaultExpanded={defaultExpanded}
standalone={standalone}
maxDetailHeight={maxDetailHeight}
forceInline={defaultExpanded}
/>
);
@@ -237,12 +237,7 @@ function WorkspaceDeckEntry({
}) {
const hasHydratedWorkspaces = useHasHydratedWorkspaces(selection.serverId);
const workspaceExists = useWorkspaceExists(selection.serverId, selection.workspaceId);
const hasOpenNativeSheets = useWorkspaceLayoutStore(
(state) =>
isNative && (state.sheetsByWorkspace[getWorkspaceSelectionKey(selection)]?.length ?? 0) > 0,
);
const shouldKeepMounted = shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets,
isActive: active,
hasHydratedWorkspaces,
workspaceExists,
@@ -662,7 +662,7 @@ function CompactSheetBody({
export function AdaptiveModalSheet({
header,
visible: requestedVisible,
visible,
onClose,
onDismiss,
children,
@@ -680,15 +680,9 @@ export function AdaptiveModalSheet({
}: AdaptiveModalSheetProps) {
const { t } = useTranslation();
const isMobile = useIsCompactFormFactor();
const isKeyboardVisible = useKeyboardVisibility(visible);
const resolvedSnapPoints = useMemo(() => snapPoints ?? ["65%", "90%"], [snapPoints]);
const isSheet = isMobile || !isWeb;
const { visible, sheetRef, handleSheetChange, handleSheetDismiss } =
useIsolatedBottomSheetVisibility({
visible: requestedVisible,
isEnabled: isSheet,
onClose,
});
const isKeyboardVisible = useKeyboardVisibility(visible);
// The sheet registers itself; the desktop dialog does not use it.
useDismissibleOverlay(visible && !isSheet, onClose);
const footerView = useMemo(
@@ -703,6 +697,11 @@ export function AdaptiveModalSheet({
}
}, [visible]);
const { sheetRef, handleSheetChange, handleSheetDismiss } = useIsolatedBottomSheetVisibility({
visible,
isEnabled: isSheet,
onClose,
});
const [shouldRenderWeb, setShouldRenderWeb] = useState(visible);
const [isWebClosing, setIsWebClosing] = useState(false);
const modalLayer = useGlobalOverlayLayer("modal", visible || shouldRenderWeb);
+5 -8
View File
@@ -15,7 +15,6 @@ const ScrollView = isWeb ? RNScrollView : GHScrollView;
interface DiffViewerProps {
diffLines: DiffLine[];
maxHeight?: number;
emptyLabel?: string;
fillAvailableHeight?: boolean;
}
@@ -119,7 +118,6 @@ function DiffSegment({
export function DiffViewer({
diffLines,
maxHeight,
emptyLabel,
fillAvailableHeight = false,
}: DiffViewerProps) {
@@ -133,12 +131,8 @@ export function DiffViewer({
);
const outerScrollStyle = React.useMemo(
() => [
styles.verticalScroll,
maxHeight !== undefined && inlineUnistylesStyle({ maxHeight }),
fillAvailableHeight && styles.fillHeight,
],
[maxHeight, fillAvailableHeight],
() => [styles.verticalScroll, fillAvailableHeight && styles.fillHeight],
[fillAvailableHeight],
);
const linesContainerStyle = React.useMemo(
() => [
@@ -184,6 +178,9 @@ export function DiffViewer({
</ScrollView>
);
// Capped tool details own vertical scrolling outside the diff.
if (!fillAvailableHeight) return horizontalScroll;
const content = (
<ScrollView
style={outerScrollStyle}
@@ -562,6 +562,34 @@ describe("bare URL sentence punctuation", () => {
expect(tree.children?.[0]?.children?.[0]?.attributes?.url).toBe("https://example.com/a.");
},
);
it.each([
["https://a.com、https://b.com!", ["https://a.com", "、", "https://b.com", "!"]],
["https://a.com(说明)以及", ["https://a.com", "(说明)以及"]],
["看这里:https://example.com/foo,还有", ["看这里:", "https://example.com/foo", ",还有"]],
["(https://example.com/a)", ["(", "https://example.com/a", ")"]],
["见【https://example.com/a】。", ["见【", "https://example.com/a", "】。"]],
["“https://example.com/a”…", ["“", "https://example.com/a", "”…"]],
[
"见https://zh.wikipedia.org/wiki/人工智能。",
["见", "https://zh.wikipedia.org/wiki/人工智能", "。"],
],
])("ends a bare URL at CJK and typographic punctuation: %s", async (source, expected) => {
const prepared = prepareMarkdownSource(source);
const tree = recognizeTextLinks(
await parseMarkdown(prepared.render(), { latexMath: false }),
prepared.linkRecognition.text,
prepared.linkRecognition.inlineCode,
);
const parts = (tree.children?.[0]?.children ?? []).map((node) =>
node.type === "Link" ? String(node.attributes?.url) : String(node.content),
);
expect(parts).toEqual(expected);
expect(toNativeLinkRecognition(prepared.linkRecognition).text).toMatchObject({
isDisabled: false,
isDefault: false,
});
});
});
it("requires workspace context for relative inline paths and escapes literal regex characters", () => {
@@ -37,9 +37,12 @@ function createTextPattern(path: string, forgeReferencePattern?: string): RegExp
// Matches bare URLs that MD4C does not autolink, like single-label or bracketed hosts.
// Quotes and unbalanced closing parentheses end the URL. Trailing sentence punctuation stays outside.
const URL_CHARACTER = String.raw`[^\s<>()"'\x60]`;
// CJK, fullwidth and typographic punctuation (、。,()【】「」“”…) also ends it; CJK letters do not.
const URL_BOUNDARY =
"\\u2018\\u2019\\u201C\\u201D\\u2026\\u3000-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\uFF01-\\uFF0F\\uFF1A-\\uFF20\\uFF3B-\\uFF40\\uFF5B-\\uFF65";
const URL_CHARACTER = String.raw`[^\s<>()"'\x60${URL_BOUNDARY}]`;
const URL_GROUP = String.raw`\(${URL_CHARACTER}*\)`;
const BARE_URL = String.raw`https?://(?:${URL_CHARACTER}|${URL_GROUP})*(?:[^\s<>()"'\x60.,;:!?]|${URL_GROUP})`;
const BARE_URL = String.raw`https?://(?:${URL_CHARACTER}|${URL_GROUP})*(?:[^\s<>()"'\x60.,;:!?${URL_BOUNDARY}]|${URL_GROUP})`;
const TEXT_PATTERN = createTextPattern(PROSE_PATH);
// One entry per distinct workspace forge remote; reuse keeps the engine's regex identity stable.
+2 -25
View File
@@ -1562,7 +1562,6 @@ interface ExpandableBadgeProps {
style?: StyleProp<ViewStyle>;
onToggle?: () => void;
onOpenFile?: () => void;
onDetailHoverChange?: (hovered: boolean) => void;
renderDetails?: () => ReactNode;
isLoading?: boolean;
isError?: boolean;
@@ -1887,7 +1886,6 @@ export const ExpandableBadge = memo(function ExpandableBadge({
isExpanded,
onToggle,
onOpenFile,
onDetailHoverChange,
renderDetails,
isLoading = false,
isError = false,
@@ -1913,11 +1911,6 @@ export const ExpandableBadge = memo(function ExpandableBadge({
}, []);
const handlePressIn = useCallback(() => setIsPressed(true), []);
const handlePressOut = useCallback(() => setIsPressed(false), []);
const handleDetailHoverIn = useCallback(() => onDetailHoverChange?.(true), [onDetailHoverChange]);
const handleDetailHoverOut = useCallback(
() => onDetailHoverChange?.(false),
[onDetailHoverChange],
);
const handleOpenFilePress = useCallback(
(event: GestureResponderEvent) => {
event.stopPropagation?.();
@@ -2207,14 +2200,9 @@ export const ExpandableBadge = memo(function ExpandableBadge({
) : null}
</View>
{detailContent ? (
<Pressable
ref={detailWrapperRef}
style={detailWrapperStyle}
onHoverIn={handleDetailHoverIn}
onHoverOut={handleDetailHoverOut}
>
<View ref={detailWrapperRef} style={detailWrapperStyle}>
{detailContent}
</Pressable>
</View>
) : null}
</View>
);
@@ -2234,7 +2222,6 @@ function areExpandableBadgePropsEqual(previous: ExpandableBadgeProps, next: Expa
if (previous.testID !== next.testID) return false;
if (previous.onToggle !== next.onToggle) return false;
if (previous.onOpenFile !== next.onOpenFile) return false;
if (previous.onDetailHoverChange !== next.onDetailHoverChange) return false;
if (previous.renderDetails !== next.renderDetails) return false;
return true;
}
@@ -2252,7 +2239,6 @@ interface ToolCallProps {
metadata?: Record<string, unknown>;
isLastInSequence?: boolean;
disableOuterSpacing?: boolean;
onInlineDetailsHoverChange?: (hovered: boolean) => void;
onInlineDetailsExpandedChange?: (expanded: boolean) => void;
onOpenFilePath?: (filePath: string) => void;
defaultExpanded?: boolean;
@@ -2276,7 +2262,6 @@ export const ToolCall = memo(function ToolCall({
metadata,
isLastInSequence = false,
disableOuterSpacing,
onInlineDetailsHoverChange,
onInlineDetailsExpandedChange,
onOpenFilePath,
defaultExpanded,
@@ -2362,13 +2347,6 @@ export const ToolCall = memo(function ToolCall({
presentation.isLoadingDetails,
]);
useEffect(() => {
if (!onInlineDetailsHoverChange || !shouldRenderInline || isExpanded) {
return;
}
onInlineDetailsHoverChange(false);
}, [isExpanded, shouldRenderInline, onInlineDetailsHoverChange]);
useEffect(() => {
if (!onInlineDetailsExpandedChange) {
return;
@@ -2435,7 +2413,6 @@ export const ToolCall = memo(function ToolCall({
isError={status === "failed"}
isLastInSequence={isLastInSequence}
disableOuterSpacing={disableOuterSpacing}
onDetailHoverChange={onInlineDetailsHoverChange}
/>
);
}, areToolCallPropsEqual);
@@ -5,6 +5,7 @@ import {
ScrollView as RNScrollView,
type StyleProp,
type ViewStyle,
type ScrollViewProps,
} from "react-native";
import { ScrollView as GHScrollView } from "react-native-gesture-handler";
import { StyleSheet } from "react-native-unistyles";
@@ -28,6 +29,25 @@ import { isWeb } from "@/constants/platform";
const ScrollView = isWeb ? RNScrollView : GHScrollView;
// A capped detail scrolls as a whole. Only full-height sheets need section scrollers.
function DetailSectionBody({
fillAvailableHeight,
style,
contentContainerStyle,
children,
...scrollProps
}: ScrollViewProps & { fillAvailableHeight: boolean }) {
const bodyStyle = useMemo(() => [style, contentContainerStyle], [style, contentContainerStyle]);
if (fillAvailableHeight) {
return (
<ScrollView {...scrollProps} style={style} contentContainerStyle={contentContainerStyle}>
{children}
</ScrollView>
);
}
return <View style={bodyStyle}>{children}</View>;
}
// ---- Content Component ----
interface ToolCallDetailsContentProps {
@@ -40,6 +60,7 @@ interface ToolCallDetailsContentProps {
}
interface DetailStyles {
fillAvailableHeight: boolean;
sectionFillStyle: StyleProp<ViewStyle>;
codeBlockFillStyle: StyleProp<ViewStyle>;
codeVerticalScrollStyle: StyleProp<ViewStyle>;
@@ -49,7 +70,6 @@ interface DetailStyles {
jsonScrollErrorCombined: StyleProp<ViewStyle>;
fullBleedContainerStyle: StyleProp<ViewStyle>;
loadingContainerStyle: StyleProp<ViewStyle>;
resolvedMaxHeight: number | undefined;
shouldFill: boolean;
isFullBleed: boolean;
}
@@ -69,7 +89,6 @@ function resolveShouldFill(
function useDetailStyles(
detail: ToolCallDetail | undefined,
resolvedMaxHeight: number | undefined,
fillAvailableHeight: boolean,
): DetailStyles {
const isFullBleed = resolveIsFullBleed(detail);
@@ -85,28 +104,14 @@ function useDetailStyles(
[codeBlockStyle, shouldFill],
);
const codeVerticalScrollStyle = useMemo(
() => [
styles.codeVerticalScroll,
resolvedMaxHeight !== undefined && inlineUnistylesStyle({ maxHeight: resolvedMaxHeight }),
shouldFill && styles.fillHeight,
],
[resolvedMaxHeight, shouldFill],
() => [styles.codeVerticalScroll, shouldFill && styles.fillHeight],
[shouldFill],
);
const scrollAreaFillStyle = useMemo(
() => [
styles.scrollArea,
resolvedMaxHeight !== undefined && inlineUnistylesStyle({ maxHeight: resolvedMaxHeight }),
shouldFill && styles.fillHeight,
],
[resolvedMaxHeight, shouldFill],
);
const scrollAreaStyle = useMemo(
() => [
styles.scrollArea,
resolvedMaxHeight !== undefined && inlineUnistylesStyle({ maxHeight: resolvedMaxHeight }),
],
[resolvedMaxHeight],
() => [styles.scrollArea, shouldFill && styles.fillHeight],
[shouldFill],
);
const scrollAreaStyle = useMemo(() => [styles.scrollArea], []);
const jsonScrollCombined = styles.jsonScroll;
const jsonScrollErrorCombined = [styles.jsonScroll, styles.jsonScrollError];
const fullBleedContainerStyle = useMemo(
@@ -122,6 +127,7 @@ function useDetailStyles(
);
return {
fillAvailableHeight,
sectionFillStyle,
codeBlockFillStyle,
codeVerticalScrollStyle,
@@ -131,7 +137,6 @@ function useDetailStyles(
jsonScrollErrorCombined,
fullBleedContainerStyle,
loadingContainerStyle,
resolvedMaxHeight,
shouldFill,
isFullBleed,
};
@@ -160,7 +165,8 @@ function ShellDetailSection({ command, output, ds }: ShellDetailProps) {
return (
<View style={ds.sectionFillStyle}>
<View style={ds.codeBlockFillStyle}>
<ScrollView
<DetailSectionBody
fillAvailableHeight={ds.fillAvailableHeight}
style={ds.codeVerticalScrollStyle}
contentContainerStyle={styles.codeVerticalContent}
nestedScrollEnabled
@@ -180,7 +186,7 @@ function ShellDetailSection({ command, output, ds }: ShellDetailProps) {
</Text>
</View>
</ScrollView>
</ScrollView>
</DetailSectionBody>
</View>
</View>
);
@@ -196,11 +202,7 @@ function EditDetailSection({ diffLines, ds }: EditDetailProps) {
<View style={ds.sectionFillStyle}>
{diffLines ? (
<View style={ds.codeBlockFillStyle}>
<DiffViewer
diffLines={diffLines}
maxHeight={ds.resolvedMaxHeight}
fillAvailableHeight={ds.shouldFill}
/>
<DiffViewer diffLines={diffLines} fillAvailableHeight={ds.shouldFill} />
</View>
) : null}
</View>
@@ -228,7 +230,8 @@ function ScrollableTextSection({
[content, filePath],
);
const body = (
<ScrollView
<DetailSectionBody
fillAvailableHeight={ds.fillAvailableHeight}
style={ds.scrollAreaFillStyle}
contentContainerStyle={styles.scrollContent}
nestedScrollEnabled
@@ -243,7 +246,7 @@ function ScrollableTextSection({
</Text>
)}
</ScrollView>
</ScrollView>
</DetailSectionBody>
);
if (!wrapInSectionFill) return body;
return <View style={ds.sectionFillStyle}>{body}</View>;
@@ -258,7 +261,8 @@ interface FetchDetailProps {
function FetchDetailSection({ url, result, ds }: FetchDetailProps) {
return (
<View style={ds.sectionFillStyle}>
<ScrollView
<DetailSectionBody
fillAvailableHeight={ds.fillAvailableHeight}
style={ds.scrollAreaFillStyle}
contentContainerStyle={styles.scrollContent}
nestedScrollEnabled
@@ -269,7 +273,7 @@ function FetchDetailSection({ url, result, ds }: FetchDetailProps) {
{result ? `${url}\n\n${result}` : url}
</Text>
</ScrollView>
</ScrollView>
</DetailSectionBody>
</View>
);
}
@@ -277,7 +281,8 @@ function FetchDetailSection({ url, result, ds }: FetchDetailProps) {
function ScrollablePlainTextSection({ text, ds }: { text: string; ds: DetailStyles }) {
return (
<View style={styles.section}>
<ScrollView
<DetailSectionBody
fillAvailableHeight={ds.fillAvailableHeight}
style={ds.scrollAreaStyle}
contentContainerStyle={styles.scrollContent}
nestedScrollEnabled
@@ -286,7 +291,7 @@ function ScrollablePlainTextSection({ text, ds }: { text: string; ds: DetailStyl
<Text selectable style={styles.plainText}>
{text}
</Text>
</ScrollView>
</DetailSectionBody>
</View>
);
}
@@ -304,7 +309,8 @@ function buildSearchSections(detail: SearchDetail, ds: DetailStyles): ReactNode[
if (detail.content) {
out.push(
<View key="search-content" style={styles.section}>
<ScrollView
<DetailSectionBody
fillAvailableHeight={ds.fillAvailableHeight}
style={ds.scrollAreaStyle}
contentContainerStyle={styles.scrollContent}
nestedScrollEnabled
@@ -315,7 +321,7 @@ function buildSearchSections(detail: SearchDetail, ds: DetailStyles): ReactNode[
{detail.content}
</Text>
</ScrollView>
</ScrollView>
</DetailSectionBody>
</View>,
);
}
@@ -548,7 +554,8 @@ export function ToolCallDetailsContent({
}: ToolCallDetailsContentProps) {
const { t } = useTranslation();
const resolvedMaxHeight = fillAvailableHeight ? undefined : (maxHeight ?? 300);
const ds = useDetailStyles(detail, resolvedMaxHeight, fillAvailableHeight);
// The allowance belongs to the whole disclosure, rather than each section.
const ds = useDetailStyles(detail, fillAvailableHeight);
const diffLines = useDiffLines(detail);
const sections: ReactNode[] = buildDetailSections(toolName, detail, diffLines, ds, t);
@@ -564,6 +571,17 @@ export function ToolCallDetailsContent({
return <Text style={styles.emptyStateText}>{t("toolCallDetails.empty")}</Text>;
}
if (resolvedMaxHeight !== undefined) {
return (
<ScrollView
style={inlineUnistylesStyle({ maxHeight: resolvedMaxHeight })}
contentContainerStyle={ds.fullBleedContainerStyle}
nestedScrollEnabled
>
{sections}
</ScrollView>
);
}
return <View style={ds.fullBleedContainerStyle}>{sections}</View>;
}
@@ -1,4 +1,3 @@
import { useRetainedPanelActive } from "@/components/retained-panel";
import {
BottomSheetModal as GorhomBottomSheetModal,
type BottomSheetModalProps,
@@ -161,7 +160,7 @@ export const IsolatedBottomSheetModal = forwardRef<
});
export function useIsolatedBottomSheetVisibility({
visible: requestedVisible,
visible,
isEnabled,
onClose,
onBack,
@@ -172,8 +171,6 @@ export function useIsolatedBottomSheetVisibility({
/** Offered Android Back before it closes the sheet; returns true when it handled the press. */
onBack?: () => boolean;
}) {
const active = useRetainedPanelActive();
const visible = requestedVisible && active;
const onCloseRef = useRef(onClose);
onCloseRef.current = onClose;
const onBackRef = useRef(onBack);
@@ -204,12 +201,11 @@ export function useIsolatedBottomSheetVisibility({
const handleSheetDismiss = useCallback(() => tracker.handleSheetDismiss(), [tracker]);
useEffect(() => {
tracker.syncDesired({ visible: requestedVisible, active, isEnabled });
}, [active, isEnabled, tracker, requestedVisible]);
tracker.syncDesired({ visible, isEnabled });
}, [isEnabled, tracker, visible]);
useDismissibleOverlay(visible && isEnabled !== false, onClose);
return {
visible,
sheetRef: setSheetRef,
handleSheetChange,
handleSheetDismiss,
@@ -291,46 +291,3 @@ it("does not cancel the owner's editor when the compact sheet leaves the tree on
expect(context.closeCount()).toBe(0);
expect(context.backPress.press()).toBe(false);
});
it("closes a retained owner's sheet and releases Back when the owner becomes inactive", () => {
const { sheet, tracker, backPress, closeCount } = setup();
tracker.attachController(sheet);
tracker.syncDesired({ visible: true, active: true });
tracker.handleSheetIndexChange(0);
tracker.syncDesired({ visible: true, active: false });
expect(sheet.events).toEqual([{ type: "present" }, { type: "dismiss" }]);
expect(closeCount()).toBe(1);
expect(backPress.press()).toBe(false);
tracker.syncDesired({ visible: false, active: false });
tracker.handleSheetDismiss();
tracker.syncDesired({ visible: false, active: true });
expect(sheet.events).toHaveLength(2);
});
it("dismisses a late opening after the inactive owner acknowledges closure", () => {
const { sheet, tracker, backPress, closeCount } = setup();
tracker.attachController(sheet);
tracker.syncDesired({ visible: true, active: true });
tracker.syncDesired({ visible: true, active: false });
expect(closeCount()).toBe(1);
tracker.syncDesired({ visible: false, active: false });
// Gorhom can drop an early dismiss before its first layout measurement.
tracker.handleSheetIndexChange(0);
expect(sheet.events).toEqual([{ type: "present" }, { type: "dismiss" }, { type: "dismiss" }]);
expect(backPress.press()).toBe(false);
tracker.handleSheetDismiss();
tracker.syncDesired({ visible: false, active: true });
expect(sheet.events).toHaveLength(3);
});
it("closes a disabled presentation on every departure after owner acknowledgement", () => {
const { tracker, closeCount } = setup();
for (let departure = 1; departure <= 2; departure++) {
tracker.syncDesired({ visible: true, active: true, isEnabled: false });
tracker.syncDesired({ visible: true, active: false, isEnabled: false });
tracker.syncDesired({ visible: true, active: false, isEnabled: false });
expect(closeCount()).toBe(departure);
tracker.syncDesired({ visible: false, active: false, isEnabled: false });
tracker.syncDesired({ visible: false, active: true, isEnabled: false });
}
});
@@ -5,7 +5,6 @@ export interface BottomSheetController {
export interface BottomSheetVisibilityInput {
visible: boolean;
active?: boolean;
isEnabled?: boolean;
}
@@ -102,16 +101,8 @@ export function createBottomSheetVisibilityTracker(opts: {
}
},
syncDesired(next) {
visible = next.visible && next.active !== false;
visible = next.visible;
isEnabled = next.isEnabled;
if (!next.visible) hasNotifiedClose = false;
// Leaving a retained owner is a close, not a temporary presentation pause.
// Clear its desired state so returning does not reopen the old sheet.
if (next.visible && next.active === false) {
dismiss();
notifyClose();
return;
}
if (isEnabled === false) return;
if (visible) {
present();
@@ -126,7 +117,9 @@ export function createBottomSheetVisibilityTracker(opts: {
},
handleSheetIndexChange(index) {
if (index !== -1) {
setPhase("presented");
if (phase === "presenting" || phase === "dismissing") {
setPhase("presented");
}
// A dismiss sent before the sheet measured its layout is dropped, and the sheet still
// finishes opening. The owner wants it hidden, so it goes again.
if (!visible && isEnabled !== false) {
+2 -15
View File
@@ -1,4 +1,3 @@
import { useRetainedPanelActive } from "@/components/retained-panel";
import { useMemo } from "react";
import {
Modal as NativeModal,
@@ -24,23 +23,11 @@ type ModalProps = Omit<NativeModalProps, "onRequestClose"> & {
function noClose() {}
export function Modal(props: ModalProps) {
const { visible: requestedVisible = true, onRequestClose, style } = props;
const active = useRetainedPanelActive();
const visible = requestedVisible && active;
const { visible = true, onRequestClose, style } = props;
useDismissibleOverlay(visible && onRequestClose !== undefined, onRequestClose ?? noClose);
const windowFrame = useAndroidWindowFrame();
const containerStyle = useMemo(() => [windowFrame, style], [windowFrame, style]);
// Hidden web chats freeze before a modal exit animation can finish.
// Remove the portal while its owner is inactive.
if (!active) return null;
return (
<NativeModal
supportedOrientations={orientations}
{...props}
visible={visible}
style={containerStyle}
/>
);
return <NativeModal supportedOrientations={orientations} {...props} style={containerStyle} />;
}
/**
@@ -1,3 +1,4 @@
import { recordComposerCommand } from "@/composer/touch-diagnostics";
import { forwardRef, useCallback, type ComponentProps } from "react";
import { Text, View, type PressableStateCallbackType } from "react-native";
import { StyleSheet } from "react-native-unistyles";
@@ -61,13 +62,18 @@ export const AgentControlTrigger = forwardRef<View, AgentControlTriggerProps>(
[disabled, isSheet, open, showToolbarLabel],
);
const activate = useCallback(() => {
recordComposerCommand("control");
onPress();
}, [onPress]);
return (
<ComboboxTrigger
{...triggerProps}
ref={ref}
collapsable={false}
disabled={disabled}
onPress={onPress}
onPress={activate}
style={triggerStyle}
accessibilityRole="button"
accessibilityLabel={accessibilityLabel}
@@ -1,3 +1,4 @@
import { recordComposerCommand } from "@/composer/touch-diagnostics";
import { useCallback, useMemo, useState, type ReactNode } from "react";
import { useTranslation } from "react-i18next";
import {
@@ -206,6 +207,7 @@ export function CompactModelSheet({
);
const open = useCallback(() => {
recordComposerCommand("model");
Keyboard.dismiss();
rootBrowser.showAll();
setIsOpen(true);
+23 -14
View File
@@ -1,3 +1,4 @@
import { useComposerTouchDiagnostics, recordComposerCommand } from "@/composer/touch-diagnostics";
import { useKeyboardFocusSurface } from "@/keyboard";
import type { SendShortcut } from "@/hooks/use-settings";
import {
@@ -1761,6 +1762,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
}, [resetComposerHeight]);
const handleSendMessage = useCallback(() => {
recordComposerCommand("send");
const liveValue = textInputRef.current?.getText() ?? valueRef.current;
if (!preserveHeightOnSubmit) {
updateLiveTextPresence("");
@@ -1790,19 +1792,18 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
exitFullscreen,
]);
const handleQueueMessage = useCallback(
() =>
queueMessageImpl({
value: textInputRef.current?.getText() ?? valueRef.current,
attachments,
cwd,
onQueue,
replaceText,
onMinimizeHeight: minimizeInputHeight,
exitFullscreen,
}),
[attachments, cwd, onQueue, replaceText, minimizeInputHeight, exitFullscreen],
);
const handleQueueMessage = useCallback(() => {
recordComposerCommand("queue");
return queueMessageImpl({
value: textInputRef.current?.getText() ?? valueRef.current,
attachments,
cwd,
onQueue,
replaceText,
onMinimizeHeight: minimizeInputHeight,
exitFullscreen,
});
}, [attachments, cwd, onQueue, replaceText, minimizeInputHeight, exitFullscreen]);
const handleDefaultSendAction = useCallback(() => {
runDefaultSendAction({
@@ -2327,8 +2328,17 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
handleRealtimeVoiceStop,
],
);
const touchDiagnostics = useComposerTouchDiagnostics({
active: isPaneFocused,
disabled,
sendDisabled: isSendButtonDisabled,
focused: isInputFocused,
fullscreen: isFullscreen,
voiceOverlay: showOverlay,
});
return (
<View
{...touchDiagnostics}
ref={rootRef}
style={
isFullscreen
@@ -2346,7 +2356,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
<ComposerInputPresentation
fullscreen={isFullscreen}
controlSizing={controlSizing}
sendIconSize={toolbarGlyph.size}
surface={textSurface}
toolbar={toolbar}
send={sendButton}
@@ -23,14 +23,13 @@ function keepEditorFocused(event: import("react-native").PointerEvent) {
/**
* One tree for both layout modes. The editing surface keeps its position so the
* mounted editor, its native buffer, selection, and focus survive every toggle;
* only the chrome around it changes. Fullscreen shows exit top right and Send
* bottom right, both on the rail the inline Send button uses; a send error sits
* only the chrome around it changes. Fullscreen keeps the exit glyph on the text
* rail and Send at the bottom right; a send error sits
* in the same footer as Send.
*/
export function ComposerInputPresentation({
fullscreen,
controlSizing,
sendIconSize,
surface,
toolbar,
send,
@@ -47,7 +46,6 @@ export function ComposerInputPresentation({
fullscreen: boolean;
/** The sizing the toolbar's stylesheet resolves to; see `resolveControlSizing`. */
controlSizing: ControlSizing;
sendIconSize: number;
surface: ReactNode;
toolbar: ReactNode;
send: ReactNode;
@@ -69,7 +67,6 @@ export function ComposerInputPresentation({
const glyphSize = iconSizeFor("md")[controlSizing];
const railOffset = resolveGlyphRailOffset({
controlSize: TOOLBAR_CONTROL_SIZES[controlSizing],
sendIconSize,
glyphIconSize: glyphSize,
});
const maximizeIcon = useCallback(
@@ -80,8 +77,8 @@ export function ComposerInputPresentation({
(color: string) => <Minimize2 color={color} size={glyphSize} />,
[glyphSize],
);
// The toolbar row bleeds 6px past the input padding; the inline glyph sits on that edge.
const enterStyle = useMemo(() => [styles.enterButton, { right: -6 + railOffset }], [railOffset]);
// Fullscreen controls share the text rail; the toolbar disc owns its separate corner inset.
const enterStyle = useMemo(() => [styles.enterButton, { right: railOffset }], [railOffset]);
const exitStyle = useMemo(() => [styles.iconButton, { marginRight: railOffset }], [railOffset]);
return (
<View
@@ -603,12 +603,14 @@ describe("retained selection", () => {
});
describe("fullscreen glyph rail", () => {
it("nudges 16px fullscreen glyphs onto the Send arrow's ink edge", () => {
expect(
resolveGlyphRailOffset({ controlSize: 28, sendIconSize: 16, glyphIconSize: 16 }),
).toBeCloseTo(4 / 3);
expect(
resolveGlyphRailOffset({ controlSize: 28, sendIconSize: 20, glyphIconSize: 16 }),
).toBeCloseTo(1 / 6);
it.each([
{ controlSize: 28, glyphIconSize: 16 },
{ controlSize: 44, glyphIconSize: 20 },
])("puts the visible fullscreen edge on the text rail ($controlSize)", (geometry) => {
const offset = resolveGlyphRailOffset(geometry);
// Maximize2 and Minimize2 reach x21 in a 24-unit viewBox, with a 2-unit stroke.
const inkInset =
(geometry.controlSize - geometry.glyphIconSize) / 2 + (geometry.glyphIconSize * 2) / 24;
expect(offset + inkInset).toBeCloseTo(0);
});
});
+5 -10
View File
@@ -234,21 +234,16 @@ export async function stopRealtimeVoice(ctx: StopRealtimeVoiceContext): Promise<
}
/**
* Offset that aligns a glyph's visible ink with the Send arrow's ink when both sit in
* equal controls on the same right rail. In Lucide's 24px viewBox ArrowUp ends at
* x19 while Maximize2/Minimize2 end at x21, so equal boxes leave the fullscreen
* glyphs visibly past the arrow.
* Put the fullscreen glyph's visible right edge on the text rail, letting its
* hit area extend into the padding. Both Lucide glyphs reach x21 of 24 and use
* the default 2-unit stroke (one viewBox unit beyond the path).
*/
export function resolveGlyphRailOffset(input: {
controlSize: number;
sendIconSize: number;
glyphIconSize: number;
}): number {
const arrowInkInset =
(input.controlSize - input.sendIconSize) / 2 + (5 * input.sendIconSize) / 24;
const glyphInkInset =
(input.controlSize - input.glyphIconSize) / 2 + (3 * input.glyphIconSize) / 24;
return arrowInkInset - glyphInkInset;
const inkInset = (input.controlSize - input.glyphIconSize) / 2 + (2 * input.glyphIconSize) / 24;
return -inkInset;
}
export function resolveComposerSurfaceText(
@@ -0,0 +1,63 @@
import { useEffect } from "react";
import type { ComposerTouchState } from "./index";
import { Keyboard, type GestureResponderEvent } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";
import { watchdog } from "@/watchdog";
/** Temporary companion to Android TouchDiagnostics. No draft text or identifiers are recorded. */
export function recordComposerCommand(command: "send" | "queue" | "control" | "model"): void {
watchdog?.record("touch.composer.command", { command });
}
function useRecordedComposerTouches(state: ComposerTouchState) {
const insets = useSafeAreaInsets();
const { active, disabled, sendDisabled, focused, fullscreen, voiceOverlay } = state;
useEffect(() => {
if (!active) return;
watchdog?.record("touch.composer.state", {
disabled: String(disabled),
sendDisabled: String(sendDisabled),
focused: String(focused),
fullscreen: String(fullscreen),
voiceOverlay: String(voiceOverlay),
});
}, [active, disabled, sendDisabled, focused, fullscreen, voiceOverlay]);
const record = (phase: string, event: GestureResponderEvent) => {
if (!watchdog) return;
const touch = event.nativeEvent;
watchdog.record("touch.composer", {
phase,
target: String(touch.target),
timestamp: String(touch.timestamp),
x: String(touch.pageX),
y: String(touch.pageY),
disabled: String(state.disabled),
sendDisabled: String(state.sendDisabled),
focused: String(state.focused),
fullscreen: String(state.fullscreen),
voiceOverlay: String(state.voiceOverlay),
keyboardVisible: String(Keyboard.isVisible()),
keyboardHeight: String(Keyboard.metrics()?.height),
safeBottom: String(insets.bottom),
});
};
return watchdog
? {
onStartShouldSetResponderCapture(event: GestureResponderEvent) {
record("capture", event);
return false;
},
onTouchEnd: (event: GestureResponderEvent) => record("end", event),
onTouchCancel: (event: GestureResponderEvent) => record("cancel", event),
}
: {};
}
function useNoComposerTouches(_state: ComposerTouchState) {
return {};
}
// Build configuration is fixed for the module lifetime. Ordinary builds subscribe to nothing.
export const useComposerTouchDiagnostics = watchdog
? useRecordedComposerTouches
: useNoComposerTouches;
@@ -0,0 +1,14 @@
/** Temporary diagnostics are Android-only. Metro selects index.android.ts on Android. */
export interface ComposerTouchState {
active: boolean;
disabled: boolean;
sendDisabled: boolean;
focused: boolean;
fullscreen: boolean;
voiceOverlay: boolean;
}
export function recordComposerCommand(_command: "send" | "queue" | "control" | "model"): void {}
export function useComposerTouchDiagnostics(_state: ComposerTouchState) {
return {};
}
@@ -90,6 +90,16 @@ class FakeDaemonClient {
cancelDictationStream(dictationId: string): void {
this.cancels.push(dictationId);
}
emitStreamError(dictationId: string, error: string): void {
const message = {
type: "dictation_stream_error",
payload: { dictationId, error, retryable: true },
} as SessionOutboundMessage;
for (const listener of this.rawMessageListeners) {
listener(message);
}
}
}
const tick = async () => {
@@ -314,6 +324,29 @@ describe("DictationStreamSender", () => {
await expect(finish).resolves.toEqual({ dictationId: "d1", text: "ok" });
});
it("fails finish with the daemon's stream error instead of waiting for acks", async () => {
const client = new FakeDaemonClient();
client.autoAck = false;
let nextId = 0;
const sender = new DictationStreamSender({
client,
format: "audio/pcm;rate=16000;bits=16",
createDictationId: () => `d${++nextId}`,
});
sender.enqueueSegment("seg0");
await tick();
client.emitStreamError("d1", "Local speech worker request timed out: commit");
sender.enqueueSegment("seg1");
await tick();
const finish = sender.finish(1);
await expect(promiseOutcome(finish, 1000)).resolves.toBe("rejected");
await expect(finish).rejects.toThrow("Local speech worker request timed out");
expect(client.finishes).toEqual([]);
expect(sender.getSegmentCount()).toBe(2);
});
it("does not replay long buffered native dictation in one synchronous burst", async () => {
const client = new FakeDaemonClient();
client.isConnected = false;
@@ -8,6 +8,10 @@ const DICTATION_DRAIN_IDLE_TIMEOUT_MS = 30_000;
const waitForNextFlushTurn = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0));
type DictationStreamAckMessage = Extract<SessionOutboundMessage, { type: "dictation_stream_ack" }>;
type DictationStreamErrorMessage = Extract<
SessionOutboundMessage,
{ type: "dictation_stream_error" }
>;
interface DrainWaitResult {
kind: "signaled" | "timed-out";
@@ -64,6 +68,7 @@ export class DictationStreamSender {
private startGeneration = 0;
private startPromise: Promise<void> | null = null;
private streamError: Error | null = null;
constructor(params: DictationStreamSenderParams) {
this.format = params.format;
@@ -88,10 +93,11 @@ export class DictationStreamSender {
}
this.clientCleanup = client.subscribeRawMessages((message) => {
if (message.type !== "dictation_stream_ack") {
return;
if (message.type === "dictation_stream_ack") {
this.handleAck(message);
} else if (message.type === "dictation_stream_error") {
this.handleStreamError(message);
}
this.handleAck(message);
});
}
@@ -127,6 +133,7 @@ export class DictationStreamSender {
this.acknowledgedSeq = -1;
this.streamReady = false;
this.startPromise = null;
this.streamError = null;
this.startGeneration += 1;
this.resolveDrainWaiters();
}
@@ -197,6 +204,7 @@ export class DictationStreamSender {
this.sendSeq = 0;
this.acknowledgedSeq = -1;
this.streamReady = false;
this.streamError = null;
const start = (async () => {
await client.startDictationStream(dictationId, this.format);
@@ -285,6 +293,25 @@ export class DictationStreamSender {
this.resolveDrainWaiters();
}
// The daemon drops a stream after an error and answers later chunks with
// errors instead of acks, so waiting for delivery can only time out.
private handleStreamError(message: DictationStreamErrorMessage): void {
if (message.payload.dictationId !== this.dictationId || this.streamError) {
return;
}
this.streamError = new Error(message.payload.error);
this.resolveDrainWaiters();
}
private throwStreamError(): void {
const error = this.streamError;
if (!error) {
return;
}
this.invalidateStream();
throw error;
}
private invalidateStream(): void {
this.resetStreamForReplay();
}
@@ -309,11 +336,13 @@ export class DictationStreamSender {
private async waitForFlushDrain(finalSeq: number): Promise<void> {
while (this.hasPendingDelivery(finalSeq)) {
this.throwStreamError();
const client = this.client;
if (!client?.isConnected || !this.dictationId || !this.streamReady) {
throw new Error("Failed to flush dictation stream");
}
const result = await this.waitForDrainSignal();
this.throwStreamError();
if (result.kind === "timed-out") {
this.invalidateStream();
throw new Error("Timed out waiting for dictation stream delivery");
-6
View File
@@ -1,4 +1,3 @@
import { useRetainedPanelActive } from "@/components/retained-panel";
import { useCallback, useEffect, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
@@ -17,7 +16,6 @@ import {
export function useDictation(options: UseDictationOptions): UseDictationResult {
const { t } = useTranslation();
const active = useRetainedPanelActive();
const {
client,
onTranscript,
@@ -338,10 +336,6 @@ export function useDictation(options: UseDictationOptions): UseDictationResult {
}
}, [audio, clearStreamingState, reportError, stopDurationTracking]);
useEffect(() => {
if (!active && isRecording && !isProcessing) void cancelDictation();
}, [active, cancelDictation, isRecording, isProcessing]);
const confirmDictation = useCallback(async () => {
if (actionGateRef.current.confirming) {
return;
@@ -1,21 +1,18 @@
import { useRetainedPanelActive } from "@/components/retained-panel";
import type { OverlayRegistration } from "./overlay-contract";
import { useLayoutEffect, useRef } from "react";
import { overlays } from "./overlays";
const setScope = (_node: unknown) => {};
export function useOverlayRegistration(input: OverlayRegistration) {
const ownerActive = useRetainedPanelActive();
const active = input.active && ownerActive;
const current = useRef(input);
current.current = input;
useLayoutEffect(() => {
if (!active) return;
if (!input.active) return;
return overlays.register({
getLayer: () => current.current.layer,
getKeys: () => current.current.keys,
onKeyDown: (event) => current.current.onKeyDown(event),
});
}, [active]);
}, [input.active]);
return setScope;
}
@@ -0,0 +1,48 @@
import { describe, expect, it } from "vitest";
import { buildEffectiveBindings } from "./keyboard-shortcuts";
import { createKeyboardPipeline } from "./internal/pipeline";
import { createOverlayRegistry } from "./internal/overlays";
describe("DOM source adapter", () => {
it("runs DOM input through the same resolver, preserving cancellation and cleanup", async () => {
const { attachDomKeyboardSource } = await import("./internal/sources/dom.web");
const actions: string[] = [];
const input = document.createElement("textarea");
input.dataset.testid = "message-input";
document.body.append(input);
input.focus();
const pipeline = createKeyboardPipeline({
getContext: () => ({ isMac: true, usesDesktopBindings: false, commandCenterOpen: false }),
getBindings: () => buildEffectiveBindings({ "command-center-toggle-cmd-k-mac": "Cmd+J" }),
isCapturing: () => false,
dispatch: (match) => {
actions.push(match.action);
return true;
},
overlays: createOverlayRegistry(),
});
const detach = attachDomKeyboardSource({
keyDown: pipeline.keyDown,
keyUp() {},
blur() {},
commandCenterOpen: () => false,
subscribeCommandCenter: () => () => {},
});
const event = new KeyboardEvent("keydown", {
key: "j",
code: "KeyJ",
metaKey: true,
bubbles: true,
cancelable: true,
});
input.dispatchEvent(event);
expect(actions).toEqual(["command-center.toggle"]);
expect(event.defaultPrevented).toBe(true);
detach();
input.dispatchEvent(
new KeyboardEvent("keydown", { key: "j", code: "KeyJ", metaKey: true, bubbles: true }),
);
expect(actions).toHaveLength(1);
input.remove();
pipeline.dispose();
});
});
@@ -1,97 +0,0 @@
import React from "react";
import { describe, expect, it } from "vitest";
import { buildEffectiveBindings } from "./keyboard-shortcuts";
import { createKeyboardPipeline } from "./internal/pipeline";
import { createOverlayRegistry } from "./internal/overlays";
describe("DOM source adapter", () => {
it("runs DOM input through the same resolver, preserving cancellation and cleanup", async () => {
const { attachDomKeyboardSource } = await import("./internal/sources/dom.web");
const actions: string[] = [];
const input = document.createElement("textarea");
input.dataset.testid = "message-input";
document.body.append(input);
input.focus();
const pipeline = createKeyboardPipeline({
getContext: () => ({ isMac: true, usesDesktopBindings: false, commandCenterOpen: false }),
getBindings: () => buildEffectiveBindings({ "command-center-toggle-cmd-k-mac": "Cmd+J" }),
isCapturing: () => false,
dispatch: (match) => {
actions.push(match.action);
return true;
},
overlays: createOverlayRegistry(),
});
const detach = attachDomKeyboardSource({
keyDown: pipeline.keyDown,
keyUp() {},
blur() {},
commandCenterOpen: () => false,
subscribeCommandCenter: () => () => {},
});
const event = new KeyboardEvent("keydown", {
key: "j",
code: "KeyJ",
metaKey: true,
bubbles: true,
cancelable: true,
});
input.dispatchEvent(event);
expect(actions).toEqual(["command-center.toggle"]);
expect(event.defaultPrevented).toBe(true);
detach();
input.dispatchEvent(
new KeyboardEvent("keydown", { key: "j", code: "KeyJ", metaKey: true, bubbles: true }),
);
expect(actions).toHaveLength(1);
input.remove();
pipeline.dispose();
});
});
it("releases a hidden retained owner's overlay keys while its scope stays mounted", async () => {
const { createElement, act } = await import("react");
const { createRoot } = await import("react-dom/client");
const { RetainedPanelActivity } = await import("@/components/retained-panel");
const { getTopOverlayKeys, hasActiveOverlay } = await import("./index");
// Exercise the native adapter itself in a real React renderer, bypassing Vite's .web resolution.
const nativeAdapterPath = "./internal/overlay-registration.ts";
const { useOverlayRegistration } = (await import(
/* @vite-ignore */ nativeAdapterPath
)) as typeof import("./internal/overlay-registration");
Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
const container = document.createElement("div");
document.body.append(container);
const root = createRoot(container);
function Viewer() {
const scope = useOverlayRegistration({
active: true,
layer: 100,
keys: ["Escape"],
manageFocus: false,
onKeyDown: () => true,
});
return createElement("button", { ref: scope, type: "button" }, "Viewer");
}
async function render(active: boolean) {
await act(async () =>
root.render(
<RetainedPanelActivity active={active}>
<Viewer />
</RetainedPanelActivity>,
),
);
}
try {
await render(true);
expect(getTopOverlayKeys()).toEqual(["Escape"]);
await render(false);
expect(container.querySelector("button")).not.toBeNull();
expect(hasActiveOverlay()).toBe(false);
expect(getTopOverlayKeys()).toEqual([]);
await render(true);
expect(getTopOverlayKeys()).toEqual(["Escape"]);
} finally {
await act(async () => root.unmount());
container.remove();
}
});
@@ -4,7 +4,6 @@ import { useKeyboardAnimation } from "react-native-keyboard-controller";
import { useSafeAreaInsets } from "react-native-safe-area-context";
import { KeyboardTranslationContext } from "./context";
import { useKeyboardTranslationScope } from "./measure";
import { useRetainedPanelActive } from "@/components/retained-panel";
interface KeyboardTranslateViewProps extends ViewProps {
children: ReactNode;
@@ -26,7 +25,6 @@ export function KeyboardTranslateView({
style,
...props
}: KeyboardTranslateViewProps) {
const active = useRetainedPanelActive();
const insets = useSafeAreaInsets();
const { height, progress } = useKeyboardAnimation();
// Mirrors resolveKeyboardLift on the native driver: `overlap` is the negated shift.
@@ -52,9 +50,7 @@ export function KeyboardTranslateView({
// setValue during the React commit gets overwritten by the resize. A rebuilt
// graph (a new bottomClearance after rotation) starts from JS-side keyboard
// values, so run it on the native frame too or it stays stale until the
// keyboard next moves. Reactivating a retained panel also reapplies Fabric's
// last transform, including keyboard motion that happened while it was hidden.
// Refresh the native graph when panel activity changes as well.
// keyboard next moves.
const enabledValue = useAnimatedValue(enabled ? 1 : 0);
useEffect(() => {
const animation = Animated.timing(enabledValue, {
@@ -64,7 +60,7 @@ export function KeyboardTranslateView({
});
animation.start();
return () => animation.stop();
}, [active, enabled, enabledValue, translateY]);
}, [enabled, enabledValue, translateY]);
const keyboardStyle = useMemo(
() => ({ transform: [{ translateY: Animated.multiply(translateY, enabledValue) }] }),
[enabledValue, translateY],
@@ -30,24 +30,15 @@ function retainedWorkspaceIds(
}
describe("reconcileRetainedWorkspaceSelections", () => {
it("keeps recent native workspaces warm and evicts the least recently used workspace", () => {
let entries = [retained("A", null)];
const visit = (workspaceId: string, now: number) => {
entries = reconcileRetainedWorkspaceSelections({
currentEntries: entries,
activeSelection: workspace(workspaceId),
now,
maxMountedWorkspaces: resolveWorkspaceDeckRetentionLimit({ isNative: true }),
});
return retainedWorkspaceIds(entries);
};
it("retains only the active workspace on native", () => {
const entries = reconcileRetainedWorkspaceSelections({
currentEntries: [retained("A", null)],
activeSelection: workspace("B"),
now: 2,
maxMountedWorkspaces: resolveWorkspaceDeckRetentionLimit({ isNative: true }),
});
expect(visit("B", 1)).toEqual(["B", "A"]);
expect(visit("C", 2)).toEqual(["C", "B", "A"]);
expect(visit("A", 3)).toEqual(["A", "C", "B"]);
expect(visit("D", 4)).toEqual(["D", "A", "C"]);
expect(visit("A", 5)).toEqual(["A", "D", "C"]);
expect(visit("E", 6)).toEqual(["E", "A", "D"]);
expect(retainedWorkspaceIds(entries)).toEqual(["B"]);
});
it("retains the desktop deck limit on web", () => {
@@ -188,23 +179,9 @@ describe("resolveWorkspaceDeckEntries", () => {
});
describe("shouldKeepWorkspaceDeckEntryMounted", () => {
it("tears down native sheet owners when leaving, while keeping the active sheet mounted", () => {
for (const isActive of [true, false]) {
expect(
shouldKeepWorkspaceDeckEntryMounted({
isActive,
hasOpenNativeSheets: true,
hasHydratedWorkspaces: true,
workspaceExists: true,
}),
).toBe(isActive);
}
});
it("keeps the active workspace mounted even when it is missing from hydrated workspaces", () => {
expect(
shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets: false,
isActive: true,
hasHydratedWorkspaces: true,
workspaceExists: false,
@@ -215,7 +192,6 @@ describe("shouldKeepWorkspaceDeckEntryMounted", () => {
it("keeps inactive workspaces mounted until workspace hydration finishes", () => {
expect(
shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets: false,
isActive: false,
hasHydratedWorkspaces: false,
workspaceExists: false,
@@ -226,7 +202,6 @@ describe("shouldKeepWorkspaceDeckEntryMounted", () => {
it("unmounts inactive workspaces that are gone after hydration", () => {
expect(
shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets: false,
isActive: false,
hasHydratedWorkspaces: true,
workspaceExists: false,
@@ -237,7 +212,6 @@ describe("shouldKeepWorkspaceDeckEntryMounted", () => {
it("keeps inactive workspaces that still exist after hydration", () => {
expect(
shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets: false,
isActive: false,
hasHydratedWorkspaces: true,
workspaceExists: true,
@@ -9,9 +9,7 @@ export interface RetainedWorkspaceSelection {
}
export function resolveWorkspaceDeckRetentionLimit(input: { isNative: boolean }): number {
// Keep recent switches warm without retaining the desktop-sized set of
// native chat trees. Reconciliation evicts the least recently used entry.
return input.isNative ? 3 : WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES;
return input.isNative ? 1 : WORKSPACE_DECK_MAX_MOUNTED_WORKSPACES;
}
interface ReconcileRetainedWorkspaceSelectionsInput {
@@ -30,7 +28,6 @@ interface GetNextWorkspaceDeckExpirationDelayInput {
}
interface WorkspaceDeckEntryMountInput {
hasOpenNativeSheets: boolean;
isActive: boolean;
hasHydratedWorkspaces: boolean;
workspaceExists: boolean;
@@ -162,7 +159,6 @@ export function resolveWorkspaceDeckEntries({
}
export function shouldKeepWorkspaceDeckEntryMounted({
hasOpenNativeSheets,
isActive,
hasHydratedWorkspaces,
workspaceExists,
@@ -170,9 +166,6 @@ export function shouldKeepWorkspaceDeckEntryMounted({
if (isActive) {
return true;
}
// Native sheets can present on the app-wide host. Preserve their existing
// teardown on navigation until the sheet stack supports inactive owners.
if (hasOpenNativeSheets) return false;
if (!hasHydratedWorkspaces) {
return true;
}
@@ -27,12 +27,8 @@ export const OverviewToolCallGroupView = memo(function OverviewToolCallGroupView
onExpandedChange,
children,
}: OverviewGroupProps) {
const scrollRef = useRef<ScrollView>(null);
const isCompact = useIsCompactFormFactor();
const aggregateSummary = useOverviewSummaryLabel(group.summary);
const scrollToLatest = useCallback(() => {
scrollRef.current?.scrollToEnd({ animated: false });
}, []);
const hold = useDisclosureHold();
const toggle = useCallback(() => {
const apply = () => onExpandedChange(group.run.id, !expanded);
@@ -44,19 +40,8 @@ export const OverviewToolCallGroupView = memo(function OverviewToolCallGroupView
onExpandedChange(group.run.id, false);
}, [group.run.id, onExpandedChange]);
const renderDetails = useCallback(
() => (
<ScrollView
ref={scrollRef}
style={styles.scroll}
contentContainerStyle={styles.content}
nestedScrollEnabled
showsVerticalScrollIndicator
onContentSizeChange={scrollToLatest}
>
<IndentRail>{children}</IndentRail>
</ScrollView>
),
[children, scrollToLatest],
() => <InlineGroupDetails latestCallId={group.run.latest.id}>{children}</InlineGroupDetails>,
[children, group.run.latest.id],
);
if (isCompact) {
@@ -93,6 +78,35 @@ export const OverviewToolCallGroupView = memo(function OverviewToolCallGroupView
);
});
function InlineGroupDetails({
latestCallId,
children,
}: {
latestCallId: string;
children: ReactNode;
}) {
const scrollRef = useRef<ScrollView>(null);
const lastRevealedCall = useRef<string | null>(null);
const revealLatestCall = useCallback(() => {
// A disclosure changes height without appending a call. Keep the reader's place then.
if (lastRevealedCall.current === latestCallId) return;
lastRevealedCall.current = latestCallId;
scrollRef.current?.scrollToEnd({ animated: false });
}, [latestCallId]);
return (
<ScrollView
ref={scrollRef}
style={styles.scroll}
contentContainerStyle={styles.content}
nestedScrollEnabled
showsVerticalScrollIndicator
onContentSizeChange={revealLatestCall}
>
<IndentRail>{children}</IndentRail>
</ScrollView>
);
}
const styles = StyleSheet.create((theme) => ({
scroll: {
maxHeight: TOOL_CALL_GROUP_MAX_HEIGHT,
@@ -13487,6 +13487,51 @@ test.each(["live", "history", "accepted"] as const)(
},
);
test("the last assistant message is the newest turn's reply, not joined to the previous turn's", async () => {
const session = new TestAgentSession({ provider: "codex", cwd: process.cwd() });
const workdir = mkdtempSync(join(tmpdir(), "agent-manager-last-reply-"));
const client = new (class extends TestAgentClient {
override async createSession(): Promise<AgentSession> {
return session;
}
})();
const manager = new AgentManager({ clients: { codex: client }, logger });
const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
workspaceId: undefined,
});
const reply = (turnId: string, messageId: string, text: string) =>
session.pushEvent({
type: "timeline",
provider: "codex",
turnId,
item: { type: "assistant_message", messageId, text },
});
try {
session.pushEvent({ type: "turn_started", provider: "codex", turnId: "turn-1" });
reply("turn-1", "message-1", "Earlier status, ");
reply("turn-1", "message-1", "streamed in two chunks.");
session.pushEvent({ type: "turn_completed", provider: "codex", turnId: "turn-1" });
await vi.waitFor(async () =>
expect(await manager.getLastAssistantMessage(agent.id)).toBe(
"Earlier status, streamed in two chunks.",
),
);
// A turn the provider starts on its own, such as a background task waking the agent,
// has no user message between its reply and the previous turn's.
session.pushEvent({ type: "turn_started", provider: "codex", turnId: "turn-2" });
reply("turn-2", "message-2", "New status.");
session.pushEvent({ type: "turn_completed", provider: "codex", turnId: "turn-2" });
await vi.waitFor(() =>
expect(manager.getTimeline(agent.id).at(-1)).toMatchObject({ messageId: "message-2" }),
);
expect(await manager.getLastAssistantMessage(agent.id)).toBe("New status.");
} finally {
await manager.closeAgent(agent.id);
rmSync(workdir, { recursive: true, force: true });
}
});
test("reads the last durable assistant response without loading a stored-only child", async () => {
const store = new RecordingTimelineStore();
await store.appendCommitted("stored-child", {
@@ -4049,23 +4049,33 @@ export class AgentManager {
private getLastAssistantMessageFromTimeline(
timeline: readonly AgentTimelineItem[],
): string | null {
return this.getLastAssistantMessageSegmentFromTimeline(timeline)?.text ?? null;
return (
this.getLastAssistantMessageSegmentFromTimeline(timeline.map((item) => ({ item })))?.text ??
null
);
}
private getLastAssistantMessageSegmentFromTimeline(
timeline: readonly AgentTimelineItem[],
timeline: readonly Pick<AgentTimelineRow, "item" | "turnId">[],
): { text: string; startsAtBeginning: boolean } | null {
// Collect the last contiguous assistant messages (Claude streams chunks)
// Collect the last contiguous assistant messages of one turn (Claude streams chunks).
// A turn the provider starts on its own has no user message before its reply.
const chunks: string[] = [];
let replyTurnId: string | undefined;
let startsAtBeginning = false;
for (let i = timeline.length - 1; i >= 0; i--) {
const item = timeline[i];
const { item, turnId } = timeline[i];
if (item.type !== "assistant_message") {
if (chunks.length) {
break;
}
continue;
}
if (chunks.length === 0) {
replyTurnId = turnId;
} else if (turnId !== replyTurnId) {
break;
}
chunks.push(item.text);
startsAtBeginning = i === 0;
}
@@ -4081,8 +4091,9 @@ export class AgentManager {
}
private async getLastAssistantMessageFromStores(agentId: string): Promise<string | null> {
const liveTimeline = this.timelineStore.getItems(agentId);
const liveSegment = this.getLastAssistantMessageSegmentFromTimeline(liveTimeline);
const liveSegment = this.getLastAssistantMessageSegmentFromTimeline(
this.timelineStore.getRows(agentId),
);
if (!this.durableTimelineStore) {
return liveSegment?.text ?? null;
}
@@ -345,7 +345,7 @@ export class DictationStreamManager {
}): Promise<void> {
const state = this.streams.get(params.dictationId);
if (!state) {
this.failDictationStream(params.dictationId, "Dictation stream not started", true);
this.emitUnknownStreamError(params.dictationId);
return;
}
@@ -528,7 +528,17 @@ export class DictationStreamManager {
return path;
}
// Chunks keep arriving for a stream the daemon already dropped, one error
// per chunk; the failure that dropped it is logged where it happened.
private emitUnknownStreamError(dictationId: string): void {
this.emit({
type: "dictation_stream_error",
payload: { dictationId, error: "Dictation stream not started", retryable: true },
});
}
private failDictationStream(dictationId: string, error: string, retryable: boolean): void {
this.logger.warn({ dictationId, error, retryable }, "Dictation stream failed");
this.emit({
type: "dictation_stream_error",
payload: { dictationId, error, retryable },
@@ -543,6 +553,10 @@ export class DictationStreamManager {
const state = this.streams.get(dictationId);
const debugRecordingPath = await this.maybePersistDictationStreamAudio(dictationId);
if (!state || this.streams.get(dictationId) !== state) return;
this.logger.warn(
{ dictationId, error, retryable, ackSeq: state.ackSeq },
"Dictation stream failed",
);
this.emit({
type: "dictation_stream_error",
payload: {