refactor(app): remove the turn navigator

Removes the experimental turn navigator rail beside the session timeline, its Experimental setting, search entry and copy, and the message list `before` query the server and protocol added only for it. The persisted showTurnNavigator key stays as a retired optional preference so stored settings still decode and round-trip.
This commit is contained in:
Dax Raad
2026-10-21 10:57:40 -04:00
Unverified
parent 17332b6b3d
commit ee8221c5d1
21 changed files with 14 additions and 1101 deletions
+1 -53
View File
@@ -1,6 +1,6 @@
import { expect, test, type Page } from "@playwright/test"
import type { ConfigEntry, OpenCodeEvent, SessionMessageInfo, WorktreeDirectory } from "@opencode/client/promise"
import { NO_PROVIDER, REMOTE_SERVER, SERVER, holdRoute, pageMessagesFrom, project, seed, session } from "../utils/app"
import { NO_PROVIDER, REMOTE_SERVER, SERVER, holdRoute, project, seed, session } from "../utils/app"
import { mockMissingLocation, mockOpenCodeServer } from "../utils/mock-server"
import { mockRemoteServer, mockWorkspace, openSession, openSettings, type WorkspaceInput } from "../utils/workspace"
@@ -94,58 +94,6 @@ test("a settings page survives refresh", async ({ page }) => {
await expect(page).toHaveURL("/settings?tab=appearance")
})
test("the experimental turn navigator defaults off and can be enabled persistently", async ({ page }) => {
const id = "ses_navigator_settings"
const messages: SessionMessageInfo[] = Array.from({ length: 60 }, (_, index) => ({
id: `msg_navigator_${String(index).padStart(4, "0")}`,
type: "user",
text: `Prompt ${index}`,
time: { created: 1700000000000 + index },
}))
const indexes: string[] = []
page.on("request", (request) => {
const url = new URL(request.url())
if (url.pathname === `/api/session/${id}/message` && url.searchParams.get("type") === "user")
indexes.push(request.url())
})
await openSession(page, {
name: "Turn navigator settings",
sessions: [{ id, title: "Turn navigator settings" }],
pageMessages: pageMessagesFrom({ [id]: messages }),
})
const navigator = page.locator('[data-component="session-turn-navigator"]')
await page.clock.install()
await page.reload()
await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
await expect(page.locator("#message-msg_navigator_0059")).toBeVisible()
await page.clock.fastForward(1500)
await expect(navigator).toHaveCount(0)
expect(indexes).toHaveLength(0)
await page.keyboard.press("Control+,")
const settings = page.getByTestId("settings-screen")
await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
await expect(settings.getByRole("heading", { name: "Experimental", exact: true })).toBeVisible()
const toggle = settings.getByRole("switch", { name: "Turn navigator", exact: true })
await expect(toggle).not.toBeChecked()
await toggle.press("Space")
await expect(toggle).toBeChecked()
await settings.getByRole("button", { name: "Back to app", exact: true }).click()
await page.clock.fastForward(1500)
await expect(navigator.locator("[data-turn]")).toHaveCount(60)
expect(indexes).toHaveLength(1)
await expect
.poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.showTurnNavigator))
.toBe(true)
await page.reload()
await expect(page.locator("#message-msg_navigator_0059")).toBeVisible()
await page.clock.fastForward(1500)
await expect(navigator.locator("[data-turn]")).toHaveCount(60)
expect(indexes).toHaveLength(2)
})
for (const locale of ["en", "ar"]) {
test(`background activity alignment stays physical and persists (${locale})`, async ({ page }) => {
const id = "ses_activity_settings"
@@ -1,18 +1,16 @@
import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode/client/promise"
import { expect, test, type Page } from "@playwright/test"
import { pageMessagesFrom, sessionHref } from "../utils/app"
import { sessionHref } from "../utils/app"
import { trackPageErrors } from "../utils/errors"
import { fixture, installTimelineSettings, mockStressTimeline } from "../utils/session-fixture"
import {
assistantMessage,
messageUpdated,
renderedPartID,
sessionID,
setupTimeline,
status,
textPart,
userMessage,
userText,
} from "../utils/timeline"
import { expectSessionTitle } from "../utils/waits"
@@ -71,315 +69,6 @@ test.describe("timeline history", () => {
await expect.poll(positions).toEqual(before)
})
test("navigates every turn, highlights visible turns, and previews unloaded replies on hover", async ({ page }) => {
const replies = [
"Response number 0\n\nEarlier reply remains visible.\n\nMore of the same reply.",
["Response number 1", ...Array.from({ length: 45 }, () => "A long reply for the reading-only fallback.")].join(
"\n\n",
),
]
const messages = Array.from({ length: 40 }, (_, index) => {
const value = String(index).padStart(4, "0")
const id = `msg_0${value}_turn_a_user`
return [
userMessage(
[
userText(
index === 39
? ["Prompt number 39", ...Array.from({ length: 40 }, () => "Long tail prompt content.")].join("\n\n")
: `Prompt number ${index}`,
{ id: `prt_0${value}_turn_prompt` },
),
],
{ id, created: 1690000000000 + index * 10_000 },
),
assistantMessage(
[{ id: `prt_0${value}_turn_text`, type: "text", text: replies[index] ?? `Response number ${index}` }],
{
id: `msg_0${value}_turn_b_assistant`,
parentID: id,
created: 1690000001000 + index * 10_000,
},
),
]
}).flat()
const loads: (string | undefined)[] = []
await setupTimeline(page, {
sessionMessages: messages,
pageMessages: pageMessagesFrom({ [sessionID]: messages }),
settings: { showTurnNavigator: true },
inbox: [
{
id: "msg_99999_queued_user",
sessionID,
type: "user",
time: { created: 1690000500000 },
delivery: "queue",
payload: { text: "Queued prompt", files: [], agents: [] },
},
],
onMessages: (request) => {
if (request.phase === "start") loads.push(request.before)
},
})
const navigator = page.locator('[data-component="session-turn-navigator"]')
const turns = navigator.locator("[data-turn]")
const preview = navigator.locator('[data-slot="session-turn-navigator-preview"]')
// The index lists every transcript turn, not queued input, without paging the transcript.
await expect(turns).toHaveCount(40)
expect(loads).toEqual([undefined])
await turns.nth(39).hover()
await expect(preview).toContainText("Prompt number 39")
await expect(preview).toContainText("Response number 39")
// An unloaded turn fetches only its own latest reply, not the transcript around it.
await turns.nth(0).hover()
await expect(preview).toContainText("Prompt number 0")
await expect(preview).toContainText("Response number 0")
await expect(preview).not.toContainText("Response number 1")
expect(loads).toEqual([undefined])
const activeIndexes = () =>
navigator
.locator('[data-state="active"]')
.evaluateAll((elements) => elements.map((el) => Number(el.getAttribute("data-index"))))
await turns.nth(0).click()
await expect(page.locator("#message-msg_00000_turn_a_user")).toBeInViewport()
await timelineScroller(page).hover()
await expect(page.locator("#message-msg_00001_turn_a_user")).toBeInViewport()
await expect.poll(activeIndexes).toEqual([0, 1])
// A reply-only turn is not highlighted while a different prompt remains visible.
const replyID = renderedPartID("prt_00000_turn_text")
await timelineScroller(page).evaluate((scroller, id) => {
const reply = scroller.querySelector(`[data-timeline-part-id="${id}"]`)
if (!reply) throw new Error("Expected the first reply")
scroller.scrollTop += reply.getBoundingClientRect().top - scroller.getBoundingClientRect().top
}, replyID)
await expect(page.locator("#message-msg_00000_turn_a_user")).not.toBeInViewport()
await expect(page.locator(`[data-timeline-part-id="${replyID}"]`)).toBeInViewport()
await expect.poll(activeIndexes).toEqual([1])
// With no bubbles visible, the preceding turn alone stays highlighted.
const longReplyID = renderedPartID("prt_00001_turn_text")
const longReply = page.locator(`[data-timeline-part-id="${longReplyID}"]`)
await expect
.poll(() => longReply.evaluate((element) => element.getBoundingClientRect().height))
.toBeGreaterThan(await timelineScroller(page).evaluate((element) => element.clientHeight))
await timelineScroller(page).evaluate((scroller, id) => {
const reply = scroller.querySelector(`[data-timeline-part-id="${id}"]`)
if (!reply) throw new Error("Expected the long reply")
scroller.scrollTop += reply.getBoundingClientRect().top - scroller.getBoundingClientRect().top + 120
}, longReplyID)
await expect(page.locator("#message-msg_00001_turn_a_user")).not.toBeInViewport()
await expect(page.locator("#message-msg_00002_turn_a_user")).not.toBeInViewport()
await expect(longReply).toBeInViewport()
await expect.poll(activeIndexes).toEqual([1])
// Clicking a long prompt (>1024 chars, non-immediate render) keeps active emphasis while hovered.
await turns.nth(39).click()
await expect(page.locator("#message-msg_00039_turn_a_user")).toBeInViewport()
await expect(turns.nth(39)).toHaveAttribute("data-state", "active")
expect(loads.length).toBeGreaterThan(1)
})
test("keeps the turn rail in timeline order, with one preview of each turn's own reply", async ({ page }) => {
// Other clients mint IDs that do not sort by time, like the iOS app's uppercase UUIDs.
const turnID = (index: number) =>
[5, 30].includes(index) ? `msg_F${index}_ios_user` : `msg_0${String(index).padStart(4, "0")}_turn_a_user`
const messages = Array.from({ length: 40 }, (_, index) => [
userMessage([userText(`Prompt number ${index}`, { id: `prt_${index}_prompt` })], {
id: turnID(index),
created: 1690000000000 + index * 10_000,
}),
assistantMessage([{ id: `prt_${index}_reply`, type: "text", text: `Response number ${index}` }], {
id: `msg_0${String(index).padStart(4, "0")}_turn_b_assistant`,
parentID: turnID(index),
created: 1690000001000 + index * 10_000,
}),
]).flat()
await setupTimeline(page, {
sessionMessages: messages,
pageMessages: pageMessagesFrom({ [sessionID]: messages }),
settings: { showTurnNavigator: true },
})
const navigator = page.locator('[data-component="session-turn-navigator"]')
const turns = navigator.locator("[data-turn]")
const preview = navigator.locator('[data-slot="session-turn-navigator-preview"]')
await expect(turns).toHaveCount(40)
// An unloaded turn previews its prompt, then its own reply, once each.
await turns.nth(5).hover()
await expect(preview.locator("p")).toHaveText(["Prompt number 5", "Response number 5"])
await turns.nth(5).click()
await expect(page.locator(`#message-${turnID(5)}`)).toBeInViewport()
// Scrolling closes the preview; moving on opens a single one for the turn under the pointer.
await turns.nth(20).hover()
await expect(preview).toBeVisible()
await page.mouse.wheel(0, -300)
await expect(preview).toBeHidden()
await turns.nth(30).hover()
await expect(preview.locator("p")).toHaveText(["Prompt number 30", "Response number 30"])
await expect(page.locator('[data-slot="session-turn-navigator-preview"]')).toHaveCount(1)
// The last tick is the latest turn.
await turns.nth(39).hover()
await expect(preview.locator("p")).toHaveText(["Prompt number 39", "Response number 39"])
await turns.nth(39).click()
await expect(page.locator(`#message-${turnID(39)}`)).toBeInViewport()
await expect(page.locator(`#message-${turnID(5)}`)).not.toBeInViewport()
})
test("keeps navigator highlights inside the reading viewport and previews readable without fades", async ({
page,
}) => {
const prompt =
"Let's create a follow up here, and add a setting to the experimental tab that enables or disables it. It should be on by default. Do it in a separate branch based on the latest origin/beta."
const response =
"The setting is ready on a separate branch. It defaults to enabled and remembers your preference across reloads. Disabling it removes the navigator and stops its background requests. The existing navigation shortcuts remain available."
await setupTimeline(page, {
messages: Array.from({ length: 6 }, (_, index) => [
userMessage([userText(index === 2 ? prompt : `Prompt ${index}`)], { id: `msg_polish_${index}_user` }),
assistantMessage(
[
textPart(
`prt_polish_${index}`,
index === 2
? response
: [0, 5].includes(index)
? Array.from({ length: 30 }, () => `Reply ${index}. More context for scrolling.`).join("\n\n")
: `Reply ${index}.`,
),
],
{
id: `msg_polish_${index}_reply`,
parentID: `msg_polish_${index}_user`,
},
),
]).flat(),
settings: { showTurnNavigator: true },
reducedMotion: true,
viewport: { width: 820, height: 650 },
})
const navigator = page.locator('[data-component="session-turn-navigator"]')
const turns = navigator.locator("[data-turn]")
const preview = navigator.locator('[data-slot="session-turn-navigator-preview"]')
const scroller = timelineScroller(page)
await expect(turns).toHaveCount(6)
// Leave only the prompt's metadata below the sticky header, then move it behind the composer.
for (const edge of ["header", "composer"] as const) {
await turns.nth(2).click()
await expect
.poll(() =>
scroller.evaluate((root) => {
const prompt = root.querySelector<HTMLElement>('#message-msg_polish_2_user [data-slot="user-message-text"]')
if (!prompt) return false
const header = parseFloat(getComputedStyle(root).getPropertyValue("--sticky-accordion-top")) || 0
const offset = prompt.getBoundingClientRect().top - root.getBoundingClientRect().top - header
return offset >= 15 && offset <= 18
}),
)
.toBe(true)
await scroller.hover()
const delta = await scroller.evaluate((root, edge) => {
const prompt = root.querySelector<HTMLElement>('#message-msg_polish_2_user [data-slot="user-message-text"]')
if (!prompt) throw new Error("Expected the prompt bubble")
const view = root.getBoundingClientRect()
const box = prompt.getBoundingClientRect()
const header = parseFloat(getComputedStyle(root).getPropertyValue("--sticky-accordion-top")) || 0
const inset = parseFloat(getComputedStyle(root).getPropertyValue("--session-timeline-inset")) || 0
return edge === "header" ? box.bottom - view.top - header + 8 : box.top - view.bottom + inset - 8
}, edge)
await page.mouse.wheel(0, delta)
await expect
.poll(() =>
scroller.evaluate((root, edge) => {
const prompt = root.querySelector<HTMLElement>('#message-msg_polish_2_user [data-slot="user-message-text"]')
if (!prompt) return true
const box = prompt.getBoundingClientRect()
const view = root.getBoundingClientRect()
const header = parseFloat(getComputedStyle(root).getPropertyValue("--sticky-accordion-top")) || 0
const inset = parseFloat(getComputedStyle(root).getPropertyValue("--session-timeline-inset")) || 0
return edge === "header" ? box.bottom <= view.top + header : box.top >= view.bottom - inset
}, edge),
)
.toBe(true)
await expect
.poll(() =>
scroller.evaluate((root) => {
const view = root.getBoundingClientRect()
const header = parseFloat(getComputedStyle(root).getPropertyValue("--sticky-accordion-top")) || 0
const inset = parseFloat(getComputedStyle(root).getPropertyValue("--session-timeline-inset")) || 0
const visible = [...root.querySelectorAll<HTMLElement>('[data-timeline-row="UserMessage"]')]
.filter((row) =>
[...row.querySelectorAll<HTMLElement>('[data-slot="user-message-text"]')].some((bubble) => {
const box = bubble.getBoundingClientRect()
return box.height > 0 && box.bottom > view.top + header + 0.5 && box.top < view.bottom - inset - 0.5
}),
)
.map((row) => row.dataset.messageId)
const highlighted = [
...document.querySelectorAll<HTMLElement>(
'[data-component="session-turn-navigator"] [data-state="active"]',
),
].map((tick) => tick.dataset.turn)
return {
extra: highlighted.filter((id) => !visible.includes(id)),
missing: visible.filter((id) => !highlighted.includes(id)),
}
}),
)
.toEqual({ extra: [], missing: [] })
await expect
.poll(() =>
navigator
.locator('[data-state="active"]')
.evaluateAll((ticks) => ticks.map((tick) => tick.getAttribute("data-turn"))),
)
.not.toContain("msg_polish_2_user")
}
await turns.nth(2).hover()
await expect(preview).toContainText(prompt)
await expect(preview).toContainText(response)
await expect(preview).toHaveCSS("opacity", "1")
const texts = preview.locator("p")
await expect(texts.nth(0)).toHaveCSS("mask-image", "none")
await expect(texts.nth(1)).toHaveCSS("mask-image", "none")
await expect
.poll(() =>
texts.evaluateAll((elements) =>
elements.every((element) => {
const end = document.createRange()
end.selectNodeContents(element)
return [...end.getClientRects()].every(
(rect) => rect.bottom <= element.getBoundingClientRect().bottom + 0.5,
)
}),
),
)
.toBe(true)
})
test("mounts every part once and in order while paging to the start", async ({ page }) => {
test.setTimeout(240_000)
const errors = trackPageErrors(page)
@@ -466,8 +155,6 @@ test.describe("timeline history", () => {
const timeline = await setupTimeline(page, {
sessionMessages: messages,
sessionStatus: { [sessionID]: { type: "busy" } },
// The turn rail reads the transcript through its own index, which would land in the exact page log below.
settings: { showTurnNavigator: false },
viewport: { width: 646, height: 1385 },
beforeMessagesResponse: (request) => (request.before ? history.promise : Promise.resolve()),
onMessages: (request) => {
-1
View File
@@ -36,7 +36,6 @@ const Query = Schema.Struct({
path: Schema.optional(Schema.String),
query: Schema.optional(Schema.String),
type: Schema.optional(Schema.String),
before: Schema.optional(Schema.String),
mode: Schema.optional(Schema.String),
})
-28
View File
@@ -1438,34 +1438,6 @@ function mockHandlers(
}),
messageList: (ctx) => {
const token = ctx.query.cursor
const type = ctx.query.type
// Filter before pagination, matching the server's message index without paging the transcript. A `before`
// anchor reads back from a message the same way.
if (type || ctx.query.before) {
const [order, offset] = token?.startsWith("typed:")
? [token.split(":")[1], Number(token.split(":")[2])]
: [ctx.query.order ?? "desc", 0]
const transcript = config.pageMessages(ctx.params.sessionID, Number.MAX_SAFE_INTEGER).items
const end = ctx.query.before
? Math.max(
0,
transcript.findIndex((item) => item.id === ctx.query.before),
)
: transcript.length
const typed = transcript.slice(0, end).filter((item) => !type || item.type === type)
const ordered = order === "asc" ? typed : typed.toReversed()
const limit = ctx.query.limit ?? 50
return Effect.succeed({
data: ordered.slice(offset, offset + limit),
cursor: { next: offset + limit < ordered.length ? `typed:${order}:${offset + limit}` : undefined },
})
}
const before = token ? state.cursors.get(token) : undefined
if (token && !before) return Effect.fail(new MockBadRequest({ message: "Invalid cursor" }))
-3
View File
@@ -755,9 +755,6 @@ export const dict = {
"settings.experimental.description": "Try experimental features",
"settings.experimental.row.generatedUI.title": "Generated UI",
"settings.experimental.row.generatedUI.description": "Let agents show dashboards, charts and forms in the timeline",
"settings.experimental.row.turnNavigator.title": "Turn navigator",
"settings.experimental.row.turnNavigator.description":
"Show a rail beside the timeline to preview and jump between prompts",
"settings.guiExtensions.title": "Extensions",
"settings.guiExtensions.description": "Built-in GUI extensions in this window. Development builds only.",
"settings.guiExtensions.reload": "Reload",
-1
View File
@@ -249,7 +249,6 @@ function SessionScreenContent(props: {
setVisibleRef={timeline.view.setVisibleRef}
anchor={timeline.view.anchor}
setRevealMessage={timeline.view.setRevealMessage}
onRevealTurn={timeline.actions.revealTurn}
setRevealPart={timeline.view.setRevealPart}
reveal={timeline.view.reveal}
setScrollToEnd={timeline.view.setScrollToEnd}
@@ -3,16 +3,14 @@ import { createResizeObserver } from "@solid-primitives/resize-observer"
import { useLocation } from "@solidjs/router"
import { createEffect, on, onCleanup } from "solid-js"
import { createStore } from "solid-js/store"
import { frameLoop, prefersReducedMotion } from "@opencode/ui/motion"
import { frameLoop } from "@opencode/ui/motion"
import { useLayout } from "@/shell/state/layout"
import { useData } from "@/runtime/server/current"
import type { SessionModel } from "../model"
import { useSessionHashScroll } from "../use-session-hash-scroll"
import { createTimelineModel } from "./model"
export function createSessionTimelineInteraction(session: SessionModel) {
const layout = useLayout()
const data = useData()
const location = useLocation<{ reveal?: string }>()
const timeline = createTimelineModel({ session })
@@ -207,31 +205,6 @@ export function createSessionTimelineInteraction(session: SessionModel) {
scrollToMessage(messages[target], "auto")
}
// Loaded history is one contiguous tail, so an older turn pages history until it arrives.
const revealTurn = async (id: string) => {
const owner = session.ownership.capture()
const sessionID = session.identity.params.id
const loaded = () => visibleUserMessages().find((item) => item.id === id)
const load = async (): Promise<void> => {
if (loaded() || !sessionID || !owner.current() || !timeline.history.more()) return
await data.session.message.loadMore(sessionID)
return load()
}
await load()
const message = loaded()
if (!message || !owner.current()) return
const behavior = prefersReducedMotion() ? "auto" : "smooth"
// The latest turn is the bottom of the timeline, reached the way the jump-to-latest button reaches it.
if (message.id === visibleUserMessages().at(-1)?.id) return resume(behavior)
unpin()
scrollToMessage(message, behavior)
}
// A gesture inside a nested scrollable region scrolls that region, not the timeline.
const markUserScroll = (target?: EventTarget | null) => {
if (!scroller) return
@@ -416,7 +389,6 @@ export function createSessionTimelineInteraction(session: SessionModel) {
return {
actions: {
navigateMessage,
revealTurn,
revealMessage: (id: string, partID?: string) => revealMessage(id, partID),
revealPart: (target: string) => revealPart(target),
resume,
@@ -20,14 +20,12 @@ import { createSessionTimelineRowRenderer } from "@opencode/session-ui/timeline/
import { getReadyMarkdown, preloadMarkdown } from "@opencode/session-ui/markdown-cache"
import { createTimelineController, type TimelineController, type TimelineSessionSource } from "./controller"
import { createTimelineVirtualizer } from "./virtualizer"
import { TurnNavigator } from "./turn-navigator"
import { containsDirectory } from "@opencode/util/path"
import { isWorkspaceDirectory } from "@/workspaces/paths"
import { parseCommentNote, readPromptPresentation } from "@/composer/comment-note"
import { parseVoiceDelegation } from "./voice-delegation"
import { useCommand } from "@/shell/commands/command"
import { useExtensionScoped } from "@/runtime/extension/commands"
import { useSettings } from "@/settings/model"
import {
SessionAncestorTrail,
SessionHeaderLayout,
@@ -92,7 +90,6 @@ type MessageTimelineProps = {
setVisibleRef?: (el: HTMLDivElement | undefined) => void
anchor: (id: string) => string
setRevealMessage?: (fn: (id: string, partID?: string) => void) => void
onRevealTurn?: (id: string) => Promise<void>
setRevealPart?: (fn: (target: string) => boolean) => void
setScrollToEnd?: (fn: (behavior?: ScrollBehavior) => void) => void
reveal?: { target: () => string | undefined; done: () => void }
@@ -133,7 +130,6 @@ function MessageTimelineView(
const language = useLanguage()
const command = useCommand()
const extensionScoped = useExtensionScoped()
const settings = useSettings()
const server = useServer()
const data = server.ctx.data
const sdk = useWorkspaceLocation()
@@ -470,28 +466,8 @@ function MessageTimelineView(
</div>
)
const turnMessages = createMemo(() =>
props.session.history.messages().filter((message) => projection.messageRowIndex().has(message.id)),
)
return (
<VirtualizedTimeline
navigator={
<Show when={settings.general.showTurnNavigator() && props.onRevealTurn && sessionID()} keyed>
{(id) => (
<TurnNavigator
sessionID={id}
messages={turnMessages}
complete={() => !data.session.message.more(id)}
historyLoading={() => data.session.message.loading(id)}
assistantMessagesByParent={projection.assistantMessagesByParent}
revertMessageID={() => props.session.data.info()?.revert?.messageID}
visibleUserMessageIDs={virtualized.visibleUserMessageIDs}
onSelect={(turn) => void props.onRevealTurn?.(turn).catch(() => undefined)}
/>
)}
</Show>
}
bottomSpacer={<Show when={!activityRow()}>{activity()}</Show>}
deferred={(row) => {
if (!Predicate.isTagged(row, "AssistantPart") || row.group.type !== "part") return false
@@ -1,434 +0,0 @@
import type { SessionMessageAssistant, SessionMessageInfo, SessionMessageUser } from "@opencode/client/promise"
import { frameLoop, prefersReducedMotion, Spring } from "@opencode/ui/motion"
import { createEffect, createMemo, createSelector, For, onCleanup, Show, type Accessor } from "solid-js"
import { createStore } from "solid-js/store"
import { readPromptPresentation } from "@/composer/comment-note"
import { useServerSDK } from "@/runtime/server/client"
const turnPageLimit = 200
// Bound preview work without cutting short the text that fits in the card.
const previewLength = 800
// Keep index loading clear of session entry, tab switch rendering and the timeline's own history requests.
const railDelay = 1000
// The rail lists at most this many of the newest turns.
const indexLimit = 1000
// Resting on an unloaded turn fetches its reply; sweeping across the rail fetches nothing.
const replyHoverDelay = 150
const previewHoverDelay = 100
// Messages read back from the next turn to find an unloaded turn's reply.
const replyScanLimit = 20
// Ticks within this many pixels of the pointer swell towards it, like a dock.
const waveRadius = 48
const tickWidths = { default: 7, active: 12, peak: 22 }
// The prompt's first line sits level with its tick: 12px card padding, then half a 20px line.
const previewAnchor = 22
// The preview at its tallest, with both texts clamped. Clamping to it keeps the card still while a reply loads.
const previewMaxHeight = 212
type TurnNavigatorProps = {
sessionID: string
/** Loaded messages that have timeline rows; excludes queued inbox items. */
messages: Accessor<SessionMessageInfo[]>
/** Whether the loaded messages reach the start of the session, making the index redundant. */
complete: Accessor<boolean>
/** Whether the timeline is loading its own history; the index waits until it has been idle for a while. */
historyLoading: Accessor<boolean>
assistantMessagesByParent: Accessor<Map<string, SessionMessageAssistant[]>>
revertMessageID: Accessor<string | undefined>
visibleUserMessageIDs: Accessor<ReadonlySet<string>>
onSelect: (id: string) => void
}
/**
* A mouse rail beside the timeline. Older turns come from the user-message index; hovering one loads only its
* latest reply. Keyboard users already have the previous and next message commands.
*
* Loading is deferred, then the rail appears with every turn so it never grows under the pointer.
*/
export function TurnNavigator(props: TurnNavigatorProps) {
const sdk = useServerSDK()
const [state, setState] = createStore<{ engaged: boolean; index?: Map<string, string> }>({ engaged: false })
let root: HTMLDivElement | undefined
const abort = new AbortController()
onCleanup(() => abort.abort())
// Newest first, so a capped index still meets the loaded tail.
const loadIndex = async (cursor?: string, count = 0): Promise<[string, string][]> => {
const page = await sdk.api.message.list(
{ sessionID: props.sessionID, type: "user", limit: turnPageLimit, cursor },
{ signal: abort.signal },
)
const turns = page.data.flatMap((message): [string, string][] =>
message.type === "user" ? [[message.id, promptPreview(message)]] : [],
)
if (page.data.length < turnPageLimit || !page.cursor.next || count + turns.length >= indexLimit) return turns
return [...turns, ...(await loadIndex(page.cursor.next, count + turns.length))]
}
createEffect(() => {
if (state.engaged || props.historyLoading()) return
const timer = setTimeout(() => {
// Touch-only devices never load the rail.
if (!matchMedia("(hover: hover) and (pointer: fine)").matches) return
setState("engaged", true)
if (props.complete()) return
// Plain state rather than a resource: a pending resource would suspend the timeline it decorates.
// On failure the rail lists the loaded turns.
void loadIndex()
.catch(() => [])
.then((turns) => setState("index", new Map(turns.toReversed())))
}, railDelay)
onCleanup(() => clearTimeout(timer))
})
return (
<div
ref={root}
data-component="session-turn-navigator"
aria-hidden="true"
class="absolute start-0 top-[calc(var(--session-timeline-header-height,48px)+8px)] bottom-[calc(var(--session-timeline-inset,0px)+80px)] z-[50] flex w-8 flex-col justify-center pointer-events-none"
>
<Show when={state.engaged && (props.complete() || state.index)}>
<TurnRail {...props} index={state.index} root={root!} />
</Show>
</div>
)
}
function TurnRail(props: TurnNavigatorProps & { index?: Map<string, string>; root: HTMLDivElement }) {
const sdk = useServerSDK()
const [state, setState] = createStore<{
hover?: string
// The previewed turn, kept while the preview fades out.
shown?: string
open: boolean
// Fetched replies by user message ID; null while loading or when there is no reply text.
replies: Record<string, string | null>
}>({ open: false, replies: {} })
const loaded = createMemo(
() =>
new Map(props.messages().flatMap((message) => (message.type === "user" ? [[message.id, message] as const] : []))),
)
// Timeline order, as the server lists it. IDs from other clients do not sort chronologically, so neither the order
// nor the reverted boundary may compare them. Streaming replaces the loaded messages on every delta, so the list keeps
// its identity until the turns themselves change.
const turns = createMemo(
() => {
const tail = [...loaded().keys()]
// Turns paged in from beyond a capped index are older than all of it.
const join = tail.findIndex((id) => props.index?.has(id))
const ids = [...new Set([...tail.slice(0, Math.max(0, join)), ...(props.index?.keys() ?? []), ...tail])]
const revert = props.revertMessageID()
const reverted = revert ? ids.indexOf(revert) : -1
return reverted === -1 ? ids : ids.slice(0, reverted)
},
[],
{
equals: (previous, next) => previous.length === next.length && previous.every((id, index) => id === next[index]),
},
)
const abort = new AbortController()
onCleanup(() => abort.abort())
// The turn's latest reply is the newest assistant text between its prompt and the next turn.
const loadReply = async (id: string) => {
setState("replies", id, null)
const list = turns()
const page = await sdk.api.message.list(
{
sessionID: props.sessionID,
limit: replyScanLimit,
before: list[list.indexOf(id) + 1] ?? props.revertMessageID(),
},
{ signal: abort.signal },
)
const end = page.data.findIndex((message) => message.type === "user")
if (end !== -1 && page.data[end]!.id !== id) return
const replies = (end === -1 ? page.data : page.data.slice(0, end)).filter(
(message): message is SessionMessageAssistant => message.type === "assistant",
)
setState("replies", id, replyText(replies.toReversed()) ?? null)
}
createEffect(() => {
const id = state.hover
if (!id || loaded().has(id) || state.replies[id] !== undefined) return
const timer = setTimeout(() => void loadReply(id).catch(() => undefined), replyHoverDelay)
onCleanup(() => clearTimeout(timer))
})
const active = createSelector(props.visibleUserMessageIDs, (id: string, visible) => visible.has(id))
const hovered = createSelector(() => state.hover)
const hovering = createMemo(() => !!state.hover)
// Only the first preview waits; moving along an engaged rail switches it immediately.
createEffect(() => {
if (!hovering()) {
setState("open", false)
return
}
const timer = setTimeout(() => setState("open", true), previewHoverDelay)
onCleanup(() => clearTimeout(timer))
})
// A closed preview keeps its last content for the fade-out without following a streaming reply.
const preview = createMemo((previous?: { prompt?: string; response?: string }) => {
const id = state.shown
if (!id || !state.open) return previous
const message = loaded().get(id)
return {
prompt: message ? promptPreview(message) : props.index?.get(id),
response: message ? replyText(props.assistantMessagesByParent().get(id) ?? []) : (state.replies[id] ?? undefined),
}
})
let list: HTMLDivElement | undefined
let card: HTMLDivElement | undefined
// Each tick's element and the scale last written to it.
const ticks = new Map<string, { element: HTMLElement; scale: number }>()
// The pointer's clientY over the rail, and the rail's geometry from the last frame's read phase.
let pointer: number | undefined
const rail = { top: 0, height: 0, root: 0, rootHeight: 0 }
// `position` follows the pointer in tick units and `wave` swells the ticks around it, so one pair drives every tick.
const motion = {
wave: Spring.fromDuration(0, { duration: 0.2, bounce: 0 }),
position: Spring.fromDuration(0, { duration: 0.12, bounce: 0 }),
top: Spring.fromDuration(0, { duration: 0.25, bounce: 0 }),
opacity: Spring.fromDuration(0, { duration: 0.18, bounce: 0 }),
}
let frame: (() => void) | undefined
// Reduced motion drops travel but keeps the preview's fade.
const step = (spring: Spring, dt: number) =>
spring === motion.opacity || !prefersReducedMotion() ? spring.step(dt) : spring.snap(spring.target).value
const paint = (dt: number) => {
const ids = turns()
const pitch = rail.height / Math.max(1, ids.length)
if (pointer !== undefined && pitch > 0) {
const hit = railHit(pointer - rail.top, rail.height, ids.length)
const id = ids[hit.index]
const tick = rail.top - rail.root + (hit.index + 0.5) * pitch
// Entering the rail starts the wave under the pointer rather than sweeping in from where it left.
if (motion.wave.value === 0) motion.position.snap(hit.position)
motion.position.set(hit.position)
motion.wave.set(1)
motion.top.set(Math.max(0, Math.min(rail.rootHeight - previewMaxHeight, tick - previewAnchor)))
// Store writes re-render, so they wait until the frame's style writes are done.
if (id && id !== state.hover) queueMicrotask(() => pointer !== undefined && setState({ hover: id, shown: id }))
}
const position = step(motion.position, dt)
const wave = step(motion.wave, dt)
ids.forEach((id, index) => {
const distance = Math.abs(index - position) * pitch
const swell = distance < waveRadius ? (wave * (1 + Math.cos((distance / waveRadius) * Math.PI))) / 2 : 0
const rest = active(id) ? tickWidths.active : tickWidths.default
const scale = (rest + (tickWidths.peak - rest) * swell) / tickWidths.peak
const tick = ticks.get(id)
if (!tick || tick.scale === scale) return
tick.scale = scale
tick.element.style.transform = `scaleX(${scale})`
})
motion.opacity.set(state.open ? 1 : 0)
// A preview that opens from hidden appears in place; one already showing glides to the next turn.
if (motion.opacity.value === 0) motion.top.snap(motion.top.target)
const opacity = step(motion.opacity, dt)
if (card) {
card.style.transform = `translateY(${step(motion.top, dt)}px)`
card.style.opacity = String(opacity)
card.style.visibility = opacity === 0 ? "hidden" : "visible"
}
return Object.values(motion).some((spring) => !spring.resting)
}
const wake = () => {
frame ??= frameLoop.addMeasured(
() => {
// Only the pointer needs geometry; reading it otherwise would force a layout on every streamed frame.
if (!list || pointer === undefined) return
const box = list.getBoundingClientRect()
const root = props.root.getBoundingClientRect()
rail.top = box.top
rail.height = box.height
rail.root = root.top
rail.rootHeight = root.height
},
(dt) => {
if (paint(dt)) return true
frame = undefined
return false
},
)
}
const leave = () => {
pointer = undefined
motion.wave.set(0)
setState("hover", undefined)
wake()
}
// Resting widths follow the visible turns, and the preview follows its open state.
createEffect(() => {
turns().forEach((id) => active(id))
void state.open
wake()
})
onCleanup(() => frame?.())
return (
<Show when={turns().length > 1}>
<div
class="flex max-h-full min-h-0 w-full cursor-pointer flex-col py-6 pointer-events-auto animate-in fade-in [animation-duration:180ms] [animation-timing-function:ease-out] motion-reduce:animate-none"
onPointerMove={(event) => {
pointer = event.clientY
wake()
}}
onPointerLeave={leave}
// Scrolling over the rail closes the preview; the next pointer move reopens it on the turn below the pointer.
onWheel={leave}
onClick={(event) => {
if (!list) return
const box = list.getBoundingClientRect()
const ids = turns()
const id = ids[railHit(event.clientY - box.top, box.height, ids.length).index]
if (id) props.onSelect(id)
}}
>
<div ref={list} class="flex min-h-0 flex-col">
<For each={turns()}>
{(id, index) => (
<div
data-turn={id}
data-index={index()}
// Active state wins so a clicked or visible turn stays active under the pointer. The hovered tick is
// still the brightest: it lights at once and cools off as the pointer moves on.
data-state={active(id) ? "active" : hovered(id) ? "hovered" : "default"}
class="flex h-2.5 min-h-0 w-full shrink items-center ps-2.5 [--tick-color:var(--v2-background-bg-layer-04)] [--tick-opacity:1] [[data-color-scheme=dark]_&]:data-[state=default]:[--tick-opacity:0.7] data-[state=active]:[--tick-color:var(--v2-icon-icon-muted)]"
>
<span
ref={(element) => {
const scale = (active(id) ? tickWidths.active : tickWidths.default) / tickWidths.peak
element.style.transform = `scaleX(${scale})`
ticks.set(id, { element, scale })
onCleanup(() => ticks.delete(id))
}}
class="pointer-events-none block h-0.5 shrink-0 origin-left bg-(--tick-color) rtl:origin-right"
style={{
width: `${tickWidths.peak}px`,
opacity: hovered(id) ? 1 : "var(--tick-opacity)",
"background-color": hovered(id) ? "var(--v2-icon-icon-base)" : undefined,
transition: hovered(id) ? "none" : "background-color 180ms ease-out, opacity 180ms ease-out",
}}
/>
</div>
)}
</For>
</div>
</div>
<div
ref={card}
data-slot="session-turn-navigator-preview"
class="pointer-events-none invisible absolute start-12 top-0 w-[384px] max-w-[calc(100cqw-4rem)] rounded-lg bg-v2-background-bg-base p-3 opacity-0"
style={{ "box-shadow": "var(--v2-elevation-raised)" }}
>
<Show when={preview()}>
{(item) => (
<>
<p
dir="auto"
class="line-clamp-4 break-words text-[13px] font-medium leading-text-base text-v2-text-text-base"
>
{item().prompt}
</p>
<Show when={item().response}>
{(text) => (
<p
dir="auto"
class="mt-2 line-clamp-5 break-words text-[13px] leading-text-base text-v2-text-text-muted"
>
{text()}
</p>
)}
</Show>
</>
)}
</Show>
</div>
</Show>
)
}
function promptPreview(message: SessionMessageUser) {
return previewText(readPromptPresentation(message.metadata)?.displayText ?? message.text)
}
function replyText(messages: SessionMessageAssistant[]) {
const text = messages
.flatMap((message) => message.content)
.findLast((content) => content.type === "text" && content.text.trim())
return text?.type === "text" ? previewText(text.text) : undefined
}
function previewText(text: string) {
return text.replace(/\s+/g, " ").trim().slice(0, previewLength)
}
/**
* The tick nearest a pointer `offset` px down a rail of `count` evenly spaced ticks `height` px tall, and the pointer's
* position in tick units (0 is the first tick's centre). Offsets beyond either end clamp to that end's tick.
*/
function railHit(offset: number, height: number, count: number) {
const position = Math.min(count - 1, Math.max(0, (offset / height) * count - 0.5))
return { index: Math.round(position), position }
}
@@ -93,7 +93,6 @@ type Input = {
type ViewProps = {
header: JSX.Element
navigator?: JSX.Element
bottomSpacer?: JSX.Element
deferred: (row: TimelineRow.TimelineRow) => boolean
renderRow: (row: Accessor<TimelineRow.TimelineRow>, onSizeChange?: () => void) => JSX.Element
@@ -204,12 +203,7 @@ export function createTimelineVirtualizer(input: Input) {
let reportRect: ((rect: { width: number; height: number }) => void) | undefined
let batchingColdSizes = false
const [viewport, setViewport] = createStore({
top: 0,
height: 0,
headerHeight: 48,
visibleUserMessageIDs: new Set<string>(),
})
const [headerHeight, setHeaderHeight] = createSignal(48)
const virtualizer = createVirtualizer<HTMLDivElement, HTMLDivElement>({
get count() {
@@ -220,16 +214,13 @@ export function createTimelineVirtualizer(input: Input) {
// inset spacer below the rows keeps consistent with the native scroll range.
observeElementRect: (instance, callback) => {
reportRect = (rect) => {
const height = Math.max(0, rect.height - bottomInset())
const root = listRoot()
batch(() => {
// The container-responsive header can be 48px or 80px; the composer covers the viewport's bottom edge.
setViewport(
"headerHeight",
// The container-responsive header can be 48px or 80px.
setHeaderHeight(
root ? parseFloat(getComputedStyle(root).getPropertyValue("--session-header-height")) || 48 : 48,
)
setViewport("height", height)
callback({ width: rect.width, height })
callback({ width: rect.width, height: Math.max(0, rect.height - bottomInset()) })
})
}
@@ -245,9 +236,7 @@ export function createTimelineVirtualizer(input: Input) {
// scrolling keeps its own offset. Range selection uses the logical offset.
batch(() => {
const logicalOffset = offset + rendering.scrollAdjustment
const top = rendering.scrollAdjustment ? Math.max(0, logicalOffset) : offset
setViewport("top", top)
callback(top, scrolling)
callback(rendering.scrollAdjustment ? Math.max(0, logicalOffset) : offset, scrolling)
// Reconcile both start boundaries in one native write. Gradually
// clamping row translations lets the compositor paint between
// corrections and makes the content oscillate at the top.
@@ -325,7 +314,7 @@ export function createTimelineVirtualizer(input: Input) {
paddingEnd: tailSize,
// Revealed prompts sit below the solid header and its 16px fade.
get scrollPaddingStart() {
return input.showHeader() ? viewport.headerHeight + 16 : 0
return input.showHeader() ? headerHeight() + 16 : 0
},
get rangeExtractor() {
return rangeExtractor()
@@ -384,7 +373,6 @@ export function createTimelineVirtualizer(input: Input) {
})
batchingColdSizes = false
pinAnchor()
scheduleVisibleTurns()
if (coldPending) pinColdBottom()
settleColdBottom()
@@ -530,83 +518,6 @@ export function createTimelineVirtualizer(input: Input) {
const virtualRowKeys = createMemo(() => virtualizer.getVirtualItems().map((item) => String(item.key)))
const visibleUserMessageIDs = () => viewport.visibleUserMessageIDs
let visibleTurnsFrame: number | undefined
const updateVisibleTurns = () => {
if (!active()) return
const root = listRoot()
if (!root?.isConnected) return
const bounds = root.getBoundingClientRect()
const header = input.showHeader() ? viewport.headerHeight : 0
const top = bounds.top + header
const bottom = bounds.top + root.clientHeight - bottomInset()
const list = rows()
const visible = virtualizer.getVirtualItems().flatMap((item) => {
const row = list[item.index]
if (!row || Predicate.isTagged(row, "TurnGap") || Predicate.isTagged(row, "TurnDivider")) return []
const element = virtualizer.elementsCache.get(item.key)
if (!element?.isConnected) return []
const box = element.getBoundingClientRect()
if (box.bottom <= top || box.top >= bottom) return []
return [{ element, row }]
})
const prompts = visible.flatMap((entry) => {
if (!Predicate.isTagged(entry.row, "UserMessage")) return []
// Virtual measurements may still describe the previous layout after wrapping or resizing. Highlight the
// rendered bubbles, not estimated row bounds or the invisible copy controls beneath a prompt.
const bubbles = entry.element.querySelectorAll<HTMLElement>(
'[data-slot="user-message-text"], [data-slot="user-message-attachments"], [data-slot="user-message-comments"]',
)
return [...bubbles].some((bubble) => {
const box = bubble.getBoundingClientRect()
return box.height > 0 && box.bottom > top && box.top < bottom
})
? [entry.row.userMessageID]
: []
})
// A clipped prompt can leave only its invisible copy controls in view. The reply-only fallback must come from
// conversation content, not from that prompt's remaining row box.
const preceding = visible.find((entry) => !Predicate.isTagged(entry.row, "UserMessage"))?.row.userMessageID
const ids = new Set(prompts.length ? prompts : preceding ? [preceding] : [])
if (
viewport.visibleUserMessageIDs.size === ids.size &&
[...ids].every((id) => viewport.visibleUserMessageIDs.has(id))
)
return
setViewport("visibleUserMessageIDs", ids)
}
const scheduleVisibleTurns = () => {
if (visibleTurnsFrame !== undefined) return
visibleTurnsFrame = requestAnimationFrame(() => {
visibleTurnsFrame = undefined
updateVisibleTurns()
})
}
createEffect(() => {
if (!active()) return
viewport.top
viewport.height
viewport.headerHeight
input.showHeader()
virtualRowKeys()
scheduleVisibleTurns()
})
createEffect(() => {
if (!active()) return
const root = listRoot()
@@ -972,9 +883,7 @@ export function createTimelineVirtualizer(input: Input) {
contentMeasureFrame = requestAnimationFrame(() => {
contentMeasureFrame = undefined
if (!active() || !element.isConnected) return
virtualizer.measureElement(element)
scheduleVisibleTurns()
if (active() && element.isConnected) virtualizer.measureElement(element)
})
})}
</div>
@@ -988,7 +897,6 @@ export function createTimelineVirtualizer(input: Input) {
class="relative w-full h-full min-w-0"
style={{
"--session-timeline-inset": `${bottomInset()}px`,
"--session-timeline-header-height": `${input.showHeader() ? viewport.headerHeight : 0}px`,
}}
>
<div
@@ -1020,7 +928,6 @@ export function createTimelineVirtualizer(input: Input) {
</svg>
</button>
</div>
{props.navigator}
<ScrollView
data-slot="session-timeline-scroll"
viewportRef={bindListRoot}
@@ -1087,8 +994,6 @@ export function createTimelineVirtualizer(input: Input) {
})
while (cache.size > 16) cache.delete(cache.keys().next().value!)
if (visibleTurnsFrame !== undefined) cancelAnimationFrame(visibleTurnsFrame)
coldPending = false
contentObserver?.disconnect()
viewportObserver?.disconnect()
@@ -1102,7 +1007,6 @@ export function createTimelineVirtualizer(input: Input) {
})
return {
visibleUserMessageIDs,
disclosure: {
patchGroupKeys,
value: (key: string) => toolOpen[key],
@@ -39,20 +39,6 @@ export const SettingsExperimental: Component = () => {
/>
</div>
</SettingsRow>
<SettingsRow
title={language.t("settings.experimental.row.turnNavigator.title")}
description={language.t("settings.experimental.row.turnNavigator.description")}
>
<div data-action="settings-turn-navigator">
<Switch
checked={settings.general.showTurnNavigator()}
onChange={(checked) => settings.general.setShowTurnNavigator(checked)}
hideLabel
>
{language.t("settings.experimental.row.turnNavigator.title")}
</Switch>
</div>
</SettingsRow>
</SettingsList>
</div>
</div>
-1
View File
@@ -93,7 +93,6 @@ describe("settings schema", () => {
timelineDetail: timelinePresets[2].value,
showCustomAgents: false,
showTurnDiffs: false,
showTurnNavigator: false,
backgroundActivity: "left",
generatedUI: true,
mobileTitlebarPosition: "top",
+1 -9
View File
@@ -105,6 +105,7 @@ const generalSchema = Persistence.struct({
// Retired preferences without readers; kept so stored values still decode and round-trip.
autoSave: Persistence.optional(Schema.Boolean),
showFileTree: Persistence.optional(Schema.Boolean),
showTurnNavigator: Persistence.optional(Schema.Boolean),
// Owned by the updater extension, which copies it out once; kept so settings rewrites cannot drop it first.
releaseNotes: Persistence.optional(Schema.Boolean),
showNavigation: Persistence.optional(Schema.Boolean),
@@ -121,7 +122,6 @@ const generalSchema = Persistence.struct({
}),
showCustomAgents: Schema.Boolean,
showTurnDiffs: Schema.Boolean,
showTurnNavigator: Schema.Boolean,
backgroundActivity: Schema.Literals(["off", "left", "center", "right"]),
// Lets agents render generated UI in the timeline; an experiment users can turn off.
generatedUI: Schema.Boolean,
@@ -290,7 +290,6 @@ export const defaultSettings: Settings = {
timelineDetail: { ...timelinePresets[2].value },
showCustomAgents: false,
showTurnDiffs: false,
showTurnNavigator: false,
backgroundActivity: "left",
generatedUI: true,
mobileTitlebarPosition: "top",
@@ -375,13 +374,6 @@ export const { use: useSettings, provider: SettingsProvider } = createSimpleCont
setShowTurnDiffs(value: boolean) {
setStore("general", "showTurnDiffs", value)
},
showTurnNavigator: withFallback(
() => store.general?.showTurnNavigator,
defaultSettings.general.showTurnNavigator,
),
setShowTurnNavigator(value: boolean) {
setStore("general", "showTurnNavigator", value)
},
backgroundActivity: withFallback(
() => store.general?.backgroundActivity,
defaultSettings.general.backgroundActivity,
@@ -96,13 +96,6 @@ export const clientSettings: Entry<SettingsRootTab>[] = [
description: "settings.experimental.row.generatedUI.description",
keywords: "genui generative interface dashboards charts forms",
},
{
tab: "experimental",
label: "settings.experimental.row.turnNavigator.title",
target: "settings-turn-navigator",
description: "settings.experimental.row.turnNavigator.description",
keywords: "conversation prompts messages timeline navigation rail",
},
{
tab: "appearance",
label: "settings.general.row.colorScheme.title",
-1
View File
@@ -1386,7 +1386,6 @@ export type MessageListInput = {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: SessionMessage.ID | undefined
readonly type?:
| "agent-switched"
| "model-switched"
@@ -840,13 +840,7 @@ const EndpointMessageList = (raw: RawClient["server.message"]) => (input: Messag
preserveEffect<MessageListOutput>()(
raw["session.messages"]({
params: { sessionID: input["sessionID"] },
query: {
limit: input["limit"],
order: input["order"],
cursor: input["cursor"],
before: input["before"],
type: input["type"],
},
query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
}).pipe(Effect.mapError(mapClientError)),
)
@@ -1111,13 +1111,7 @@ export function make(options: ClientOptions) {
{
method: "GET",
path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
query: {
limit: input["limit"],
order: input["order"],
cursor: input["cursor"],
before: input["before"],
type: input["type"],
},
query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
successStatus: 200,
declaredStatuses: [400, 401, 404, 500],
empty: false,
@@ -5755,7 +5755,6 @@ export type MessageListInput = {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: string | undefined
readonly type?:
| "agent-switched"
| "model-switched"
@@ -5774,7 +5773,6 @@ export type MessageListInput = {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: string | undefined
readonly type?:
| "agent-switched"
| "model-switched"
@@ -5793,7 +5791,6 @@ export type MessageListInput = {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: string | undefined
readonly type?:
| "agent-switched"
| "model-switched"
@@ -5808,30 +5805,10 @@ export type MessageListInput = {
| "idle"
| undefined
}["cursor"]
readonly before?: {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: string | undefined
readonly type?:
| "agent-switched"
| "model-switched"
| "location-switched"
| "user"
| "synthetic"
| "system"
| "skill"
| "shell"
| "assistant"
| "compaction"
| "idle"
| undefined
}["before"]
readonly type?: {
readonly limit?: number | undefined
readonly order?: "asc" | "desc" | undefined
readonly cursor?: string | undefined
readonly before?: string | undefined
readonly type?:
| "agent-switched"
| "model-switched"
-4
View File
@@ -35,10 +35,6 @@ export const SessionMessagesQuery = Schema.Struct({
"Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response. Do not combine with order.",
}),
),
before: Schema.optional(SessionMessage.ID).annotate({
description:
"Return only messages that precede this message in the timeline, newest first. Cannot be combined with cursor or ascending order; the returned cursors continue from the page.",
}),
type: Schema.optional(Schema.Literals(Object.keys(MessageTypes) as ReadonlyArray<SessionMessage.Type>)).annotate({
description:
"Filter by message type before pagination. When omitted, all message types are returned. Pass the same type when following cursors.",
+1 -8
View File
@@ -34,8 +34,6 @@ export const MessageHandler = HttpApiBuilder.group(Api, "server.message", (handl
Effect.fn(function* (ctx) {
if (ctx.query.cursor && ctx.query.order !== undefined)
return yield* new InvalidCursorError({ message: "Cursor cannot be combined with order" })
if (ctx.query.before && (ctx.query.cursor || ctx.query.order === "asc"))
return yield* new InvalidCursorError({ message: "Before cannot be combined with cursor or ascending order" })
const decoded = yield* Effect.try({
try: () => (ctx.query.cursor ? cursor.decode(ctx.query.cursor) : undefined),
catch: () => new InvalidCursorError({ message: "Invalid cursor" }),
@@ -47,12 +45,7 @@ export const MessageHandler = HttpApiBuilder.group(Api, "server.message", (handl
limit: ctx.query.limit ?? DefaultMessagesLimit,
order,
type: ctx.query.type,
// Descending past an anchor yields exactly the messages before it.
cursor: decoded
? { id: decoded.id, direction: decoded.direction }
: ctx.query.before
? { id: ctx.query.before, direction: "next" }
: undefined,
cursor: decoded ? { id: decoded.id, direction: decoded.direction } : undefined,
})
.pipe(
Effect.catchTag("Session.NotFoundError", missingSession),
-30
View File
@@ -86,36 +86,6 @@ it.live("filters message types before paginating in either direction through the
messages[8],
])
expect((await fixture.api.message.list({ sessionID: fixture.sessionID, type: "shell" })).data).toEqual([])
// Before excludes its anchor; the returned cursor continues further back through matching messages.
const before = await fixture.api.message.list({ ...input, before: "msg_a" })
expect(before.data.map((message) => message.id)).toEqual(["msg_x", "msg_b"])
if (!before.cursor.next) throw new Error("Expected a next cursor")
expect(
(await fixture.api.message.list({ ...input, cursor: before.cursor.next })).data.map((message) => message.id),
).toEqual(["msg_z"])
expect(
(await fixture.api.message.list({ sessionID: fixture.sessionID, type: "assistant", before: "msg_b", limit: 1 }))
.data,
).toEqual([messages[1]])
expect(
(await fixture.api.message.list({ sessionID: fixture.sessionID, type: "assistant", before: "msg_z" })).data,
).toEqual([])
})
}),
)
it.live("rejects before combined with a cursor or ascending order", () =>
Effect.gen(function* () {
const fixture = yield* setup
yield* Effect.promise(async () => {
const first = await fixture.api.message.list({ sessionID: fixture.sessionID, limit: 1 })
for (const query of ["order=asc", `cursor=${first.cursor.next}`]) {
const response = await fixture.handler(
new Request(`http://opencode.local/api/session/${fixture.sessionID}/message?before=msg_a&${query}`),
)
expect(response.status).toBe(400)
expect(await response.json()).toMatchObject({ _tag: "InvalidCursorError" })
}
})
}),
)