Merge chat-turn-render: the chat transcript now folds one agent reply into one bubble, keeps reasoning and answer in separate parts and retains a tool call's name and input for its whole lifecycle

This commit is contained in:
2026-10-18 01:48:49 +01:00
14 changed files with 801 additions and 161 deletions
@@ -277,6 +277,16 @@ object ChatProtocol {
else -> false
}
/**
* The stable part id an incremental text/reasoning delta stream addresses,
* mirroring `ChatDeltaPartID` in `internal/protocol/chat.go`. OpenCode numbers
* one message's text and reasoning parts independently from 0, so the kind is
* part of the id: a message's first text delta and its first reasoning delta
* are distinct parts, and answer text can never be appended into the thinking
* block.
*/
fun deltaPartId(messageId: String, kind: String, ordinal: Int): String = "$messageId#$kind#$ordinal"
/**
* The `chat_prompt` frame the composer sends. [files] are the attached files'
* URIs, in the order they were attached, and are omitted when empty (the
@@ -102,10 +102,12 @@ internal fun ChatConversationPane(
// A turn blocked on an approval is not generating, so the running indicator
// (and its ticking clock) stands down while the card is unanswered.
val showRunning = thread.running && !awaiting
// The count of the transcript's items: the messages, the local command lines,
// the running indicator while a turn is in flight and a pending approval card,
// which is the last item the top bar's approval action jumps to.
val itemCount = thread.messages.size + thread.notices.size +
// The count of the transcript's items: its rows (the operator's messages and
// the folded agent replies), the local command lines, the running indicator
// while a turn is in flight and a pending approval card, which is the last
// item the top bar's approval action jumps to.
val rows = transcriptRows(thread.messages)
val itemCount = rows.size + thread.notices.size +
(if (showRunning) 1 else 0) + (if (approval != null) 1 else 0)
// The position the operator left this conversation at, read once: a
// conversation with none of its own opens at its newest message instead (see
@@ -219,6 +221,7 @@ internal fun ChatConversationPane(
)
else -> ChatTranscript(
thread = thread,
rows = rows,
listState = listState,
savedScroll = savedScroll,
itemCount = itemCount,
@@ -180,6 +180,53 @@ internal fun runningToolStamps(
return stamps
}
/**
* The id a text or reasoning delta must be applied to for [kind] within [parts].
* The broker gives the two kinds distinct ids (see `ChatDeltaPartID`), but a peer
* that still shares one id between them must never have answer text appended into
* a reasoning part (or the reverse): when another kind already holds the bare id,
* the delta is moved onto a suffixed id of its own so the two kinds stay in
* separate parts. Once a part of this kind exists under either id, that part is
* the one addressed, so a stream keeps growing the part it started.
*/
internal fun deltaPartId(parts: List<ChatPart>, kind: String, id: String): String {
if (parts.any { it.type == kind && it.id == id }) return id
val suffixed = "$id#$kind"
if (parts.any { it.type == kind && it.id == suffixed }) return suffixed
return if (parts.any { it.id == id }) suffixed else id
}
/**
* Folds one tool frame's part onto the part retained from earlier frames. A tool
* call is reported across several frames that each carry only part of it (the name
* in `input.started`, the arguments in `input.ended`'s text or `called`'s input,
* then `progress`/`success` carrying neither), so a field already learned is never
* blanked by a later frame that omits it. A non-empty incoming field wins;
* otherwise the retained value is kept.
*/
internal fun mergeToolPart(previous: ChatPart?, incoming: ChatPart): ChatPart {
if (previous == null) return incoming
val priorState = previous.state
val incomingState = incoming.state
return incoming.copy(
type = incoming.type.ifBlank { previous.type },
name = incoming.name.ifBlank { previous.name },
executed = incoming.executed || previous.executed,
time = incoming.time ?: previous.time,
state = when {
incomingState == null -> priorState
priorState == null -> incomingState
else -> incomingState.copy(
status = incomingState.status.ifBlank { priorState.status },
input = incomingState.input ?: priorState.input,
content = incomingState.content.ifEmpty { priorState.content },
metadata = incomingState.metadata ?: priorState.metadata,
error = incomingState.error ?: priorState.error,
)
},
)
}
/**
* The status a session row reports while a turn is in flight: it names the tool
* call it is parked on (or how many, when several run at once) so a working chat
@@ -378,6 +425,92 @@ internal fun turnReasoning(parts: List<ChatPart>): ReasoningTurn =
.map { it.text },
)
/**
* One agent reply: everything the agent produced between two of the operator's
* messages, however many model steps that took. OpenCode reports a turn as one
* assistant message per step, so this is the single fold the transcript uses to
* render a reply as one bubble — the turn's thinking block, then its tool-call
* chips, then its answer — instead of one bubble (and one thinking block) per
* step.
*/
internal data class ChatTurn(val key: String, val parts: List<ChatPart>) {
/** The turn's reasoning, folded into the one block the transcript shows first. */
val reasoning: ReasoningTurn get() = turnReasoning(parts)
/** The turn's tool calls, in the order the agent made them. */
val tools: List<ChatPart> get() = parts.filter { it.type == ChatProtocol.PART_TOOL }
/**
* The turn's answer: just its text parts, joined in order. Reasoning feeds the
* folded thinking block and a tool call its chip, so the answer block never
* carries thinking or a command.
*/
val answer: String
get() = parts
.filter {
it.type != ChatProtocol.PART_TOOL &&
(partRendering(it) == PartRendering.MARKDOWN || partRendering(it) == PartRendering.PLAIN)
}
.joinToString("\n\n") { it.text }
/** The turn's own timing, or null when its parts carry none. */
val elapsedMillis: Long? get() = turnElapsedMillis(parts)
/** Whether the turn has anything to draw; an empty turn renders no bubble. */
val visible: Boolean get() = reasoning.count > 0 || tools.isNotEmpty() || answer.isNotBlank()
}
/**
* One item of the transcript: an operator message, or one folded agent reply. The
* key is stable as a reply grows — an agent turn is keyed by its first message id
* — so the list is not rebuilt and an expanded thinking block keeps its state as
* new steps stream in.
*/
internal sealed interface TranscriptRow {
val key: String
data class User(val message: ChatMessage) : TranscriptRow {
override val key: String get() = message.id
}
data class Agent(val turn: ChatTurn) : TranscriptRow {
override val key: String get() = turn.key
}
}
/**
* The transcript's rows for [messages]: each run of consecutive assistant
* messages folds into one [TranscriptRow.Agent], and each of the operator's own
* messages is its own [TranscriptRow.User]. This is the one fold that makes a
* reply a single bubble, so the transcript and its tests cannot disagree about
* where one agent turn ends and the next begins.
*/
internal fun transcriptRows(messages: List<ChatMessage>): List<TranscriptRow> {
val rows = ArrayList<TranscriptRow>(messages.size)
var turnKey: String? = null
var parts = ArrayList<ChatPart>()
fun flush() {
val key = turnKey
if (key != null) {
val turn = ChatTurn(key, parts)
if (turn.visible) rows.add(TranscriptRow.Agent(turn))
}
turnKey = null
parts = ArrayList()
}
for (message in messages) {
if (message.role == ChatProtocol.ROLE_ASSISTANT) {
if (turnKey == null) turnKey = message.id
parts.addAll(message.parts)
} else {
flush()
rows.add(TranscriptRow.User(message))
}
}
flush()
return rows
}
/** The live label of a single-step turn's reasoning block while it streams. */
private const val REASONING_STREAMING_LABEL = "Thinking…"
@@ -938,45 +938,56 @@ class ChatStore(
}
private fun applyDelta(frame: ChatEventFrame) {
val partId = frame.part?.id.orEmpty()
if (partId.isEmpty() || frame.delta.isEmpty()) return
upsertPart(frame, partId) { existing ->
existing?.copy(text = existing.text + frame.delta)
?: ChatPart(type = frame.kind, id = partId, text = frame.delta)
val rawId = frame.part?.id.orEmpty()
if (rawId.isEmpty() || frame.delta.isEmpty()) return
val kind = frame.kind
upsertParts(frame) { parts ->
val id = deltaPartId(parts, kind, rawId)
val index = parts.indexOfFirst { it.id == id }
if (index < 0) {
parts + ChatPart(type = kind, id = id, text = frame.delta)
} else {
parts.toMutableList().also { it[index] = it[index].copy(text = it[index].text + frame.delta) }
}
}
}
private fun applyTool(frame: ChatEventFrame) {
val part = frame.part ?: return
if (part.id.isEmpty()) return
upsertPart(frame, part.id) { part }
val incoming = frame.part ?: return
if (incoming.id.isEmpty()) return
upsertParts(frame) { parts ->
val index = parts.indexOfFirst { it.id == incoming.id && it.type == ChatProtocol.PART_TOOL }
if (index < 0) {
parts + mergeToolPart(null, incoming)
} else {
parts.toMutableList().also { it[index] = mergeToolPart(it[index], incoming) }
}
}
}
/**
* Finds or creates the assistant message [frame] targets and the part [partId]
* inside it, replacing it via [upsert] (the old part when it exists, else
* null), then marks the thread running. The text/reasoning delta and the tool
* upsert share this so the two cannot drift.
* Finds or creates the assistant message [frame] targets and replaces its
* parts with [upsert]'s result, then marks the thread running. The text and
* reasoning delta fold and the tool upsert share this so the two cannot drift.
*/
private fun upsertPart(frame: ChatEventFrame, partId: String, upsert: (ChatPart?) -> ChatPart) {
private fun upsertParts(frame: ChatEventFrame, upsert: (List<ChatPart>) -> List<ChatPart>) {
update(frame.sessionId) { thread ->
val messages = thread.messages.toMutableList()
val index = messages.indexOfLast { it.id == frame.messageId }
val message = if (index >= 0) {
messages[index]
val resolvedIndex = if (index >= 0) {
index
} else {
ChatMessage(
id = frame.messageId,
sessionId = frame.sessionId,
role = ChatProtocol.ROLE_ASSISTANT,
).also { messages.add(it) }
messages.add(
ChatMessage(
id = frame.messageId,
sessionId = frame.sessionId,
role = ChatProtocol.ROLE_ASSISTANT,
),
)
messages.lastIndex
}
val resolvedIndex = if (index >= 0) index else messages.lastIndex
val parts = message.parts.toMutableList()
val partIndex = parts.indexOfFirst { it.id == partId }
val updated = upsert(if (partIndex >= 0) parts[partIndex] else null)
if (partIndex >= 0) parts[partIndex] = updated else parts.add(updated)
messages[resolvedIndex] = message.copy(parts = parts)
val message = messages[resolvedIndex]
messages[resolvedIndex] = message.copy(parts = upsert(message.parts))
val stamped = runningToolStamps(thread.toolStartedAt, messages, now())
setRunning(thread.copy(messages = messages, toolStartedAt = stamped), true)
}
@@ -85,6 +85,7 @@ private const val CHAT_ELAPSED_TICK_MILLIS = 1_000L
@Composable
internal fun ChatTranscript(
thread: ChatThread,
rows: List<TranscriptRow>,
listState: LazyListState,
savedScroll: ChatScrollPosition?,
itemCount: Int,
@@ -177,22 +178,26 @@ internal fun ChatTranscript(
}
Box(Modifier.fillMaxSize()) {
// Only the newest turn can be streaming, so its reasoning wears the live
// label; a settled turn's reasoning is labelled as settled.
val streamingMessageId = thread.messages.lastOrNull()?.id?.takeIf { thread.running }
// label; a settled turn's reasoning is labelled as settled. The turn is
// the transcript's last row only while it is the turn in flight.
val streamingTurnKey = (rows.lastOrNull() as? TranscriptRow.Agent)?.key?.takeIf { thread.running }
LazyColumn(
state = listState,
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP, Alignment.Bottom),
) {
items(thread.messages, key = { it.id }) { message ->
MessageItem(
message = message,
reasoning = reasoning,
streaming = message.id == streamingMessageId,
runningSince = thread.runningSince,
onToggleReasoning = onToggleReasoning,
)
items(rows, key = { it.key }) { row ->
when (row) {
is TranscriptRow.User -> UserMessageItem(row.message)
is TranscriptRow.Agent -> AgentTurnItem(
turn = row.turn,
reasoning = reasoning,
streaming = row.key == streamingTurnKey,
runningSince = thread.runningSince,
onToggleReasoning = onToggleReasoning,
)
}
}
// A slash command reports as its own line, after the turns it acted
// between and visually distinct from any message to the agent.
@@ -398,8 +403,45 @@ private fun rememberElapsedNow(runningSince: Long): Long {
}
@Composable
private fun MessageItem(
message: ChatMessage,
private fun UserMessageItem(message: ChatMessage) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.End,
) {
Surface(
shape = RoundedCornerShape(CHAT_GUTTER),
color = MaterialTheme.colorScheme.secondaryContainer,
modifier = Modifier.widthIn(max = CHAT_BUBBLE_MAX_WIDTH_DP),
) {
SelectionContainer {
Column(Modifier.padding(CHAT_GUTTER)) {
// A user turn another device sent is attributed to it, so the
// transcript says who sent the message. Our own messages carry
// no label.
if (message.client.isNotBlank()) {
Text(
text = message.client,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
UserParts(message.parts)
}
}
}
}
}
/**
* One agent reply as a single bubble: the turn's one collapsible thinking block
* first, then its tool-call chips in order, then its answer text. A turn's
* reasoning and answer are never mixed — the fold in [ChatTurn] keeps them
* separate, so the answer is never drawn inside the thinking block — and the
* whole reply is one item however many model steps produced it.
*/
@Composable
private fun AgentTurnItem(
turn: ChatTurn,
reasoning: ReasoningExpansion,
streaming: Boolean,
runningSince: Long,
@@ -414,46 +456,29 @@ private fun MessageItem(
val now = rememberElapsedNow(runningSince)
if (runningSince < now) now - runningSince else 0L
} else {
turnElapsedMillis(message.parts)
turn.elapsedMillis
}
val isUser = message.role == ChatProtocol.ROLE_USER
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = if (isUser) Arrangement.End else Arrangement.Start,
horizontalArrangement = Arrangement.Start,
) {
Surface(
shape = RoundedCornerShape(CHAT_GUTTER),
color = if (isUser) {
MaterialTheme.colorScheme.secondaryContainer
} else {
MaterialTheme.colorScheme.surfaceContainer
},
color = MaterialTheme.colorScheme.surfaceContainer,
modifier = Modifier.widthIn(max = CHAT_BUBBLE_MAX_WIDTH_DP),
) {
SelectionContainer {
Column(Modifier.padding(CHAT_GUTTER)) {
if (isUser) {
// A user turn another device sent is attributed to it, so
// the transcript says who sent the message. Our own
// messages carry no label.
if (message.client.isNotBlank()) {
Text(
text = message.client,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
UserParts(message.parts)
} else {
AssistantParts(
messageId = message.id,
parts = message.parts,
reasoning = reasoning,
streaming = streaming,
elapsedMillis = elapsedMillis,
onToggleReasoning = onToggleReasoning,
)
}
val turnKey = reasoningTurnKey(turn.key)
ReasoningBlock(
turn = turn.reasoning,
expanded = reasoning.isExpanded(turnKey),
streaming = streaming,
elapsedMillis = elapsedMillis,
onToggle = { onToggleReasoning(turnKey) },
)
if (turn.tools.isNotEmpty()) ToolCalls(turn.tools)
if (turn.answer.isNotBlank()) MarkdownText(turn.answer)
}
}
}
@@ -462,7 +487,7 @@ private fun MessageItem(
/**
* A user turn: its text, then the files that rode with it. The attachments are
* the same [ChatProtocol.PART_FILE] parts [MessageItem] already renders, so the
* the same [ChatProtocol.PART_FILE] parts the user bubble already renders, so the
* sent message shows its file in the transcript through the one display path
* rather than a second attachment list under the bubble.
*/
@@ -478,73 +503,6 @@ private fun UserParts(parts: List<ChatPart>) {
}
}
/**
* An assistant turn's parts in order, with each run of consecutive tool calls
* rendered as one wrapping chip group (mirroring the reference transcript's
* `_ToolCalls`, research §1.3): the calls of a turn sit together on as few lines
* as they fit, instead of each taking a row, so the transcript stays scannable.
*
* The turn's reasoning is folded into exactly one collapsible block, anchored
* where the turn's first reasoning part sits, so a turn that reasons several
* times is one entry rather than a stack of boxes and a streaming turn grows the
* block it has instead of gaining another.
*/
@Composable
private fun AssistantParts(
messageId: String,
parts: List<ChatPart>,
reasoning: ReasoningExpansion,
streaming: Boolean,
elapsedMillis: Long?,
onToggleReasoning: (String) -> Unit,
) {
val turn = turnReasoning(parts)
val turnKey = reasoningTurnKey(messageId)
var index = 0
var reasoningShown = false
while (index < parts.size) {
val part = parts[index]
when {
part.type == ChatProtocol.PART_TOOL -> {
var end = index
while (end < parts.size && parts[end].type == ChatProtocol.PART_TOOL) end++
ToolCalls(parts.subList(index, end))
index = end
}
partRendering(part) == PartRendering.REASONING -> {
if (!reasoningShown) {
reasoningShown = true
ReasoningBlock(
turn = turn,
expanded = reasoning.isExpanded(turnKey),
streaming = streaming,
elapsedMillis = elapsedMillis,
onToggle = { onToggleReasoning(turnKey) },
)
}
index++
}
else -> {
MessagePart(part)
index++
}
}
}
}
@Composable
private fun MessagePart(part: ChatPart) {
when (partRendering(part)) {
PartRendering.MARKDOWN -> MarkdownText(part.text)
// Reasoning is folded into the turn's one block by [AssistantParts]; a
// reasoning part never reaches here, but rendering nothing keeps this
// exhaustive and safe if one ever did.
PartRendering.REASONING -> Unit
PartRendering.PLAIN -> Text(part.text, style = MaterialTheme.typography.bodyMedium)
PartRendering.HIDDEN -> Unit
}
}
/**
* A turn's reasoning: one compact, muted line that names the block — its step
* count when it reasoned more than once, and its elapsed time when the turn's own
@@ -1,6 +1,7 @@
package net.awan.pipelines.ui.chat
import net.awan.pipelines.data.protocol.ChatEventFrame
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
@@ -117,6 +118,77 @@ class ChatReasoningTurnTest {
assertFalse(reasoning.isExpanded(reasoningTurnKey("m2")))
}
@Test
fun aTextDeltaAndAReasoningDeltaInOneMessageNeverShareAPart() {
val store = ChatStore()
store.open(ChatSession(id = "s", title = "s"))
store.history("s", emptyList())
// The broker numbers a message's text and reasoning independently from 0,
// so a peer that still keyed both off the bare ordinal addresses the same
// id for the two kinds: the client must keep them apart anyway, or the
// answer is appended into the thinking block.
store.event(reasoningDelta("s", "m1", "m1#0", "thinking"))
store.event(textDelta("s", "m1", "m1#0", "answer"))
val message = store.value.thread("s")!!.messages.single()
val reasoning = message.parts.single { it.type == ChatProtocol.PART_REASONING }
val answer = message.parts.single { it.type == ChatProtocol.PART_TEXT }
assertEquals("thinking", reasoning.text)
assertEquals("answer", answer.text)
// A later text delta on the same id keeps growing the answer part and
// never touches the reasoning part.
store.event(textDelta("s", "m1", "m1#0", "!"))
val grown = store.value.thread("s")!!.messages.single()
assertEquals("answer!", grown.parts.single { it.type == ChatProtocol.PART_TEXT }.text)
assertEquals("thinking", grown.parts.single { it.type == ChatProtocol.PART_REASONING }.text)
// The broker's own derivation gives the two kinds distinct ids, and the
// client's mirror produces the same ids.
assertEquals("m1#text#0", ChatProtocol.deltaPartId("m1", ChatProtocol.PART_TEXT, 0))
assertEquals("m1#reasoning#0", ChatProtocol.deltaPartId("m1", ChatProtocol.PART_REASONING, 0))
assertFalse(
ChatProtocol.deltaPartId("m1", ChatProtocol.PART_TEXT, 0) ==
ChatProtocol.deltaPartId("m1", ChatProtocol.PART_REASONING, 0),
)
}
@Test
fun agentStepsBetweenTwoUserMessagesFoldIntoOneTurn() {
// The step-by-step reply a live agent produces: several assistant messages,
// then the final one carrying the answer beside its reasoning. They are one
// turn — one bubble, one thinking block, one answer — and the operator's
// next message starts a new one.
val messages = listOf(
ChatMessage(id = "u1", role = ChatProtocol.ROLE_USER, parts = listOf(text("t", "do it"))),
ChatMessage(id = "m0", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(reasoning("r0", "thought 0"), ChatPart(type = ChatProtocol.PART_TOOL, id = "c0", name = "shell"))),
ChatMessage(id = "m1", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(reasoning("r1", "thought 1"), ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", name = "read"))),
ChatMessage(id = "m2", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(reasoning("r2", "thought 2"), text("t2", "the answer"))),
ChatMessage(id = "u2", role = ChatProtocol.ROLE_USER, parts = listOf(text("t", "again"))),
)
val rows = transcriptRows(messages)
assertEquals(listOf("u1", "m0", "u2"), rows.map { it.key })
val turn = (rows[1] as TranscriptRow.Agent).turn
// The turn is keyed by its first message id, so its expansion state and the
// list key survive the later steps.
assertEquals("m0", turn.key)
assertEquals(3, turn.reasoning.count)
assertEquals("thought 0\n\nthought 1\n\nthought 2", turn.reasoning.text)
assertEquals(listOf("c0", "c1"), turn.tools.map { it.id })
assertEquals("the answer", turn.answer)
}
private fun textDelta(sessionId: String, messageId: String, partId: String, delta: String) =
ChatEventFrame(
sessionId = sessionId,
messageId = messageId,
kind = ChatProtocol.PART_TEXT,
delta = delta,
part = ChatPart(type = ChatProtocol.PART_TEXT, id = partId),
)
private fun reasoningDelta(sessionId: String, messageId: String, partId: String, delta: String) =
ChatEventFrame(
sessionId = sessionId,
@@ -8,6 +8,7 @@ import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.ChatTime
import net.awan.pipelines.data.protocol.ChatToolContent
import net.awan.pipelines.data.protocol.ChatToolState
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
@@ -160,6 +161,50 @@ class ChatRunningWorkTest {
assertEquals(4_000L, store.value.thread("s")!!.toolElapsedMillis(call, clock))
}
@Test
fun aToolCallKeepsItsNameAndInputForItsWholeLifecycle() {
val store = ChatStore()
store.open(ChatSession(id = "s", title = "s"))
store.history("s", emptyList())
// The verified frame sequence: the name arrives only in input.started,
// the arguments in called's input, and progress/success carry neither.
store.event(toolFrame("s", "m1", ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", name = "shell", state = ChatToolState(status = ChatProtocol.TOOL_STREAMING))))
store.event(toolFrame("s", "m1", ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", state = ChatToolState(status = ChatProtocol.TOOL_RUNNING, input = input("command" to "ls")))))
store.event(toolFrame("s", "m1", ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", state = ChatToolState(status = ChatProtocol.TOOL_RUNNING, metadata = JsonObject(mapOf("exit" to JsonPrimitive(0)))))))
store.event(toolFrame("s", "m1", ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", state = ChatToolState(status = ChatProtocol.TOOL_COMPLETED, content = listOf(ChatToolContent(type = "text", text = "ok"))))))
val part = store.value.thread("s")!!.messages.single().parts.single()
// Nothing blanked the name or the input the earlier frames taught it.
assertEquals("shell", toolLabel(part))
assertEquals("ls", toolDetail(part))
assertEquals("ok", toolOutputText(part.state))
assertEquals(ChatProtocol.TOOL_COMPLETED, part.state?.status)
assertEquals(JsonPrimitive(0), part.state?.metadata?.get("exit"))
}
@Test
fun aStreamingArgumentStringIsShownWhileTheCallRuns() {
val store = ChatStore()
store.open(ChatSession(id = "s", title = "s"))
store.event(
toolFrame(
"s", "m1",
ChatPart(
type = ChatProtocol.PART_TOOL,
id = "c1",
name = "edit",
state = ChatToolState(status = ChatProtocol.TOOL_STREAMING, input = JsonPrimitive("{\"filePath\"")),
),
),
)
val call = store.value.thread("s")!!.messages.single().parts.single()
// A partial-JSON argument string is kept and shown verbatim; it has no
// object key to describe the call yet, so the detail stays absent.
assertEquals("{\"filePath\"", prettyToolInput(call.state?.input))
assertNull(toolDetail(call))
}
@Test
fun toolDetailPrefersDescriptionThenCommandAndIgnoresWhatItCannotRead() {
// A description wins over a command when both are present.
@@ -1,5 +1,6 @@
package net.awan.pipelines.ui.chat
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatProtocol
import org.junit.Assert.assertEquals
@@ -148,4 +149,42 @@ class ChatTranscriptTest {
// ...and a single open chat leaves nothing to switch to.
assertEquals(emptyList<ChatThread>(), openChatsBeside(listOf(a), "a"))
}
@Test
fun eachConversationalRunOfAgentStepsIsOneRowAndItsTextPartsJoinInOrder() {
// Two user messages with two agent steps between the first pair: the agent
// steps are one turn (one bubble), not one row each, and their text parts
// are one answer joined in order.
val messages = listOf(
ChatMessage(id = "u1", role = ChatProtocol.ROLE_USER, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = "one"))),
ChatMessage(id = "a1", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "p1", text = "first"))),
ChatMessage(id = "a2", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(ChatPart(type = ChatProtocol.PART_TOOL, id = "c1", name = "shell"), ChatPart(type = ChatProtocol.PART_TEXT, id = "p2", text = "second"))),
ChatMessage(id = "u2", role = ChatProtocol.ROLE_USER, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = "two"))),
ChatMessage(id = "a3", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "p3", text = "third"))),
)
val rows = transcriptRows(messages)
assertEquals(listOf("u1", "a1", "u2", "a3"), rows.map { it.key })
assertEquals(
listOf("u1", "u2"),
rows.filterIsInstance<TranscriptRow.User>().map { it.key },
)
val first = (rows[1] as TranscriptRow.Agent).turn
assertEquals("first\n\nsecond", first.answer)
assertEquals(listOf("c1"), first.tools.map { it.id })
assertEquals("third", (rows[3] as TranscriptRow.Agent).turn.answer)
}
@Test
fun anAgentMessageWithNothingToDrawAddsNoRow() {
// An assistant message whose parts are all empty (or reasoning without
// text) has nothing to draw, so it folds away instead of leaving a blank
// bubble; a following user message is still its own row.
val rows = transcriptRows(
listOf(
ChatMessage(id = "a1", role = ChatProtocol.ROLE_ASSISTANT, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "p1"))),
ChatMessage(id = "u1", role = ChatProtocol.ROLE_USER, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = "hi"))),
),
)
assertEquals(listOf("u1"), rows.map { it.key })
}
}
+79
View File
@@ -0,0 +1,79 @@
# Chat transcript: one agent reply is one bubble
## What this item changed
`internal/` and `android/`, the brokered chat transcript. Three defects measured
against the operator's own OpenCode (127.0.0.1:49374):
- **Server, delta part ids.** `internal/protocol/chat.go` adds
`ChatDeltaPartID(messageID, kind, ordinal)` (mirrored as
`ChatProtocol.deltaPartId` in `android/.../data/protocol/Chat.kt`), and
`internal/opencode/chat.go`'s `NormalizeChatEvent` keys a text or reasoning
delta on it. OpenCode numbers one message's text and reasoning parts
independently from 0, so the old `"%s#%d"` gave a message's first text delta and
its first reasoning part the same id — the client appended the answer into the
thinking block and the server's retained state re-collided on resume.
- **Server, tool fields.** `NormalizeChatEvent` now takes a tool call's arguments
from `session.tool.input.ended`'s `text` as well as `session.tool.called`'s
`input` object (`toolInput`), and `internal/server/chat_hub.go`'s new
`mergeChatToolPart` folds each tool frame onto the retained part so a later
`progress`/`success` frame that omits the name or the input never blanks it.
- **Android, transcript.** `ui/chat/ChatFormat.kt` adds the pure `ChatTurn` /
`TranscriptRow` / `transcriptRows` fold (each run of assistant messages between
two of the operator's messages is one agent turn), the kind-aware
`deltaPartId` net and `mergeToolPart`; `ChatStore` folds deltas and tool frames
through them; `ChatTranscript` renders one bubble per turn — one thinking block
over all the turn's reasoning, then its tool chips, then one answer block of
its text parts — replacing `AssistantParts`/`MessagePart` with
`AgentTurnItem`/`UserMessageItem`.
Tests: `internal/opencode/chat_v2_test.go` and `internal/server/chat_test.go` add
the id-collision and tool name+input retention cases; `ChatReasoningTurnTest`,
`ChatTranscriptTest` and `ChatRunningWorkTest` cover the turn fold, the
text/reasoning collision and the tool lifecycle on the client.
## Shared documents this change makes stale
`android/README.md` describes the surfaces this item changed. The note is written
here rather than edited in place; the `docs-fold` writer should update it.
- `android/README.md:6021` — the **Reasoning collapsed by default** bullet reads
"`ReasoningBlock` is now one compact, muted line per part". It should say one
block per *agent turn*: the transcript folds every consecutive assistant message
between two of the operator's messages into one `ChatTurn`, so all the turn's
reasoning is one collapsible block (labelled with its step count when it
reasoned more than once) and the reply is one bubble, not one per model step.
- `android/README.md:4669` — "`ChatScreen.MessagePart` now calls
`MarkdownText(part.text)` for `PART_TEXT`; the assistant message stays one
`SelectionContainer`". `MessagePart` no longer exists; the answer is
`MarkdownText(turn.answer)` inside `AgentTurnItem`, where `turn.answer` is the
turn's text parts joined in order. The one-`SelectionContainer`-per-bubble fact
is still true.
- `android/README.md:6040` — the test paragraph's "`ChatTranscriptTest`, 7 cases"
is now 9 (the fold tests); `ChatReasoningTurnTest` and `ChatRunningWorkTest`
gained the collision and tool-lifecycle cases.
- `android/README.md:4786` — the **Grouped chips** bullet says "a run of
consecutive `tool` parts in one assistant turn is now one `FlowRow`". The chips
still group in one `FlowRow`, but the calls shown are now the whole folded
turn's (`ChatTurn.tools`), across every step of the reply, not one assistant
message's parts.
Dates, counts and capture names in those dated records are past evidence and stay
as they are; only the behaviour statements above are now stale.
## Not stale
- `docs/cli.md`'s and `internal/author/skill/references/operations.md`'s brokered
chat sections describe the `chat_*` surface and its retained
per-session/per-message state and resync; that remains true. Neither documents
the delta part-id derivation or the tool-field retention, so neither gains a
wrong statement — the derivation now lives in the `internal/protocol/chat.go`
comment. The docs-fold writer may add one sentence to the reference's
retained-state paragraph if it documents part ids there, but nothing there is
now false.
- No packaged OpenCode skill reference documents the app's chat transcript, and no
packaged template or `internal/author/` managed file names it.
- `android/AGENTS.md` and `internal/server/AGENTS.md` list the files this item
touched (`ui/chat/`, `internal/server/chat_*.go`, `internal/protocol/`,
`internal/opencode/chat.go`); no file moved and no build/test step changed, so
both maps stay correct.
+29 -3
View File
@@ -388,6 +388,7 @@ type chatEvent struct {
Delta string `json:"delta"`
ID string `json:"id"`
Name string `json:"name"`
Text string `json:"text"`
Input json.RawMessage `json:"input"`
Content []protocol.ChatToolContent `json:"content"`
Metadata map[string]any `json:"metadata"`
@@ -451,11 +452,11 @@ func NormalizeChatEvent(payload []byte, sessionID string, lastMessageID *string)
case outer.Type == "session.text.delta":
frame.Kind = protocol.ChatEventText
frame.Delta = data.Delta
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartText, ID: fmt.Sprintf("%s#%d", messageID, data.Ordinal)}
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID(messageID, protocol.ChatPartText, data.Ordinal)}
case outer.Type == "session.reasoning.delta":
frame.Kind = protocol.ChatEventReasoning
frame.Delta = data.Delta
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartReasoning, ID: fmt.Sprintf("%s#%d", messageID, data.Ordinal)}
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartReasoning, ID: protocol.ChatDeltaPartID(messageID, protocol.ChatPartReasoning, data.Ordinal)}
case outer.Type == "session.step.started" || outer.Type == "session.step.streamed" || outer.Type == "session.step.ended":
frame.Kind = protocol.ChatEventStep
frame.Step = &protocol.ChatStep{Status: strings.TrimPrefix(outer.Type, "session.step."), Index: stepIndex(data)}
@@ -465,7 +466,7 @@ func NormalizeChatEvent(payload []byte, sessionID string, lastMessageID *string)
return protocol.ChatEventFrame{}, false, nil
}
frame.Kind = protocol.ChatEventTool
state := &protocol.ChatToolState{Status: status, Input: data.Input, Content: data.Content, Metadata: data.Metadata, Error: data.Error}
state := &protocol.ChatToolState{Status: status, Input: toolInput(data), Content: data.Content, Metadata: data.Metadata, Error: data.Error}
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartTool, ID: data.ID, Name: data.Name, State: state}
case outer.Type == "session.usage.updated":
frame.Kind = protocol.ChatEventUsage
@@ -480,6 +481,31 @@ func NormalizeChatEvent(payload []byte, sessionID string, lastMessageID *string)
return frame, true, nil
}
// toolInput picks a tool call's arguments from whichever frame carries them:
// session.tool.called carries the parsed `input` object, session.tool.input.ended
// carries the same arguments as a `text` JSON string, and progress/success carry
// neither. Text that already parses as JSON is kept as that value (so an object
// pretty-prints); a partial string is carried as a JSON string so the frame stays
// valid and the client can show it while streaming. It returns nil when the frame
// carries no arguments, so the consumer retains what it already learned.
func toolInput(data chatEvent) json.RawMessage {
if len(data.Input) > 0 && string(data.Input) != "null" {
return data.Input
}
text := strings.TrimSpace(data.Text)
if text == "" {
return nil
}
if json.Valid([]byte(text)) {
return json.RawMessage(text)
}
encoded, err := json.Marshal(text)
if err != nil {
return nil
}
return encoded
}
// toolStatus maps the verified tool event types onto the ToolState lifecycle.
func toolStatus(eventType string) (string, bool) {
switch eventType {
+145
View File
@@ -2,6 +2,8 @@ package opencode
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"path/filepath"
@@ -121,6 +123,149 @@ func TestChatStreamRealV2Shapes(t *testing.T) {
}
}
// TestChatDeltaPartIDsNeverCollide pins the broker's part-id namespace: OpenCode
// numbers one message's text and reasoning parts independently from 0, so a
// message's first text delta and its first reasoning delta share an ordinal. The
// two must still land on distinct part ids — otherwise the client appends the
// answer into the thinking block and the server's retained state re-collides on a
// resume. The id is the shared ChatDeltaPartID derivation, so it is deterministic
// across a reconnect.
func TestChatDeltaPartIDsNeverCollide(t *testing.T) {
payloads := map[string]string{
"text": `{"type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"answer"}}`,
"reasoning": `{"type":"session.reasoning.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"think"}}`,
}
ids := map[string]string{}
for kind, payload := range payloads {
last := ""
frame, ok, err := NormalizeChatEvent([]byte(payload), "ses_1", &last)
if err != nil || !ok {
t.Fatalf("%s delta: ok=%v err=%v", kind, ok, err)
}
if frame.Part == nil {
t.Fatalf("%s delta carried no part", kind)
}
if frame.Part.Type != kind {
t.Fatalf("%s delta part type = %q", kind, frame.Part.Type)
}
ids[kind] = frame.Part.ID
}
if ids["text"] == ids["reasoning"] {
t.Fatalf("text and reasoning share part id %q", ids["text"])
}
if ids["text"] != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0) {
t.Fatalf("text part id = %q, want the stable derivation", ids["text"])
}
if ids["reasoning"] != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartReasoning, 0) {
t.Fatalf("reasoning part id = %q, want the stable derivation", ids["reasoning"])
}
}
// TestChatToolLifecycleCarriesNameAndInput pins what the broker learns from each
// verified tool frame: input.started carries the name, input.ended carries the
// arguments as its `text` string, called carries the parsed input object, and
// progress/success carry neither — so those frames must surface no name and no
// input, leaving the retention to the consumer instead of blanking the field.
func TestChatToolLifecycleCarriesNameAndInput(t *testing.T) {
frames := []struct {
name string
payload string
wantStatus string
wantName string
wantInput string // the JSON encoding expected, "" for absent
}{
{
name: "input.started names the call",
payload: `{"type":"session.tool.input.started","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell"}}`,
wantStatus: protocol.ChatToolStreaming,
wantName: "shell",
},
{
name: "input.ended carries the arguments as text",
payload: `{"type":"session.tool.input.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","text":"{\"command\":\"ls\"}"}}`,
wantStatus: protocol.ChatToolStreaming,
wantInput: `{"command":"ls"}`,
},
{
name: "called carries the parsed input object",
payload: `{"type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","input":{"command":"ls"}}}`,
wantStatus: protocol.ChatToolRunning,
wantInput: `{"command":"ls"}`,
},
{
name: "progress carries metadata only",
payload: `{"type":"session.tool.progress","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","metadata":{"exit":0}}}`,
wantStatus: protocol.ChatToolRunning,
},
{
name: "success carries the output and neither name nor input",
payload: `{"type":"session.tool.success","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","content":[{"type":"text","text":"ok"}],"metadata":{"exit":0},"executed":true}}`,
wantStatus: protocol.ChatToolCompleted,
},
}
for _, tc := range frames {
t.Run(tc.name, func(t *testing.T) {
last := ""
frame, ok, err := NormalizeChatEvent([]byte(tc.payload), "ses_1", &last)
if err != nil || !ok {
t.Fatalf("ok=%v err=%v", ok, err)
}
if frame.Part == nil || frame.Part.State == nil {
t.Fatalf("tool frame = %+v", frame)
}
if frame.Part.State.Status != tc.wantStatus {
t.Fatalf("status = %q, want %q", frame.Part.State.Status, tc.wantStatus)
}
if frame.Part.Name != tc.wantName {
t.Fatalf("name = %q, want %q", frame.Part.Name, tc.wantName)
}
if tc.wantInput == "" {
if len(frame.Part.State.Input) != 0 {
t.Fatalf("input = %s, want absent", frame.Part.State.Input)
}
return
}
if !json.Valid(frame.Part.State.Input) {
t.Fatalf("input %s is not valid JSON", frame.Part.State.Input)
}
var want, got any
if err := json.Unmarshal([]byte(tc.wantInput), &want); err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(frame.Part.State.Input, &got); err != nil {
t.Fatalf("input %s: %v", frame.Part.State.Input, err)
}
if fmt.Sprintf("%v", want) != fmt.Sprintf("%v", got) {
t.Fatalf("input = %s, want %s", frame.Part.State.Input, tc.wantInput)
}
})
}
}
// TestChatToolInputFromPartialText pins the streaming case: input.ended's text
// that is not yet a complete JSON value must still surface, carried as a JSON
// string so the frame stays valid and the client can show the partial arguments.
func TestChatToolInputFromPartialText(t *testing.T) {
last := ""
frame, ok, err := NormalizeChatEvent([]byte(`{"type":"session.tool.input.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","text":"{\"command\":\"l"}}`), "ses_1", &last)
if err != nil || !ok {
t.Fatalf("ok=%v err=%v", ok, err)
}
if frame.Part == nil || frame.Part.State == nil {
t.Fatalf("frame = %+v", frame)
}
if !json.Valid(frame.Part.State.Input) {
t.Fatalf("partial input %s is not valid JSON", frame.Part.State.Input)
}
var got string
if err := json.Unmarshal(frame.Part.State.Input, &got); err != nil {
t.Fatalf("partial input is not a JSON string: %s (%v)", frame.Part.State.Input, err)
}
if got != `{"command":"l` {
t.Fatalf("partial input text = %q", got)
}
}
// TestOpenStreamRejectsUnknownBackend pins that the shared construction path
// validates the backend before any process is started, so OpenStream never
// launches a serve for an unknown backend.
+22 -2
View File
@@ -1,6 +1,9 @@
package protocol
import "encoding/json"
import (
"encoding/json"
"fmt"
)
// Chat requests and responses are brokered by the Pipelines server (route B in
// the OpenCode chat research): the phone keeps talking only to /connect and the
@@ -213,8 +216,21 @@ type ChatMessage struct {
Parts []ChatPart `json:"parts"`
}
// ChatDeltaPartID is the stable part id an incremental text or reasoning delta
// stream addresses. OpenCode numbers one message's text and reasoning parts
// independently from 0, so the kind is part of the id: for a single message its
// first text delta and its first reasoning delta are distinct ids and a delta can
// never be appended into the other kind's part. The derivation is deterministic,
// so a reconnect or a resume re-addresses the same part, and it is mirrored in
// the client's ChatProtocol.deltaPartId (data/protocol/Chat.kt).
func ChatDeltaPartID(messageID, kind string, ordinal int) string {
return fmt.Sprintf("%s#%s#%d", messageID, kind, ordinal)
}
// ChatPart is one element of a ChatMessage. Type selects the meaning: text and
// reasoning use Text and ID, tool uses ID, Name, Executed, State and Time.
// reasoning use Text and ID, tool uses ID, Name, Executed, State and Time. A text
// or reasoning part's ID is ChatDeltaPartID(message id, kind, ordinal), so the two
// kinds never share an id within a message.
type ChatPart struct {
Type string `json:"type"`
ID string `json:"id,omitempty"`
@@ -227,6 +243,10 @@ type ChatPart struct {
// ChatToolState is the lifecycle of a tool call. Input is a raw JSON value: a
// partial-JSON string while streaming, an object once running or completed.
// OpenCode spreads one call across several frames (name in input.started, the
// arguments in input.ended's text or called's input, then progress/success
// carrying neither), so Input is absent on the frames that do not carry it and
// every consumer retains the value it already learned instead of blanking it.
// Content is the tool's textual/file result, Metadata its provider stats,
// Error the structured failure for status "error".
type ChatToolState struct {
+68 -13
View File
@@ -108,10 +108,12 @@ func (h *chatHub) clock() time.Time {
}
// apply folds one pushed frame into the retained state. Text and reasoning
// deltas append to their message's part; a tool frame upserts the full part
// (accounting for its whole size) so the latest lifecycle status, input,
// content, metadata, error and time are retained under the frame's message id.
// Step and usage frames update the session's latest progress.
// deltas append to their message's part; a tool frame upserts the part (merging
// the fields it carries onto what is retained, and accounting for the whole
// size) so the latest lifecycle status, name, input, content, metadata, error and
// time are retained under the frame's message id and a later frame that omits a
// field never blanks it. Step and usage frames update the session's latest
// progress.
func (h *chatHub) apply(frame protocol.ChatEventFrame) {
if frame.SessionID == "" {
return
@@ -181,29 +183,82 @@ func (h *chatHub) apply(frame protocol.ChatEventFrame) {
if frame.Part == nil || frame.Part.ID == "" || turn.overflow {
return
}
// The tool part is retained whole, so size the complete part (input,
// content, metadata, error and time) and charge the difference against
// the cap on every upsert, not just the first-seen name.
incoming := chatPartBytes(frame.Part)
// The tool part is retained whole, so size the complete, merged part
// (input, content, metadata, error and time) and charge the difference
// against the cap on every upsert, not just the first-seen name.
part, ok := message.parts[frame.Part.ID]
if !ok {
if !turn.retain(incoming) {
merged := mergeChatToolPart(nil, frame.Part)
if !turn.retain(chatPartBytes(&merged)) {
return
}
part = &chatPart{}
message.order = append(message.order, frame.Part.ID)
message.parts[frame.Part.ID] = part
} else if previous := chatPartBytes(&part.part); incoming > previous {
message.parts[frame.Part.ID] = &chatPart{part: merged}
return
}
merged := mergeChatToolPart(&part.part, frame.Part)
incoming := chatPartBytes(&merged)
previous := chatPartBytes(&part.part)
if incoming > previous {
if !turn.retain(incoming - previous) {
return
}
} else {
turn.shrink(previous - incoming)
}
part.part = *frame.Part
part.part = merged
}
}
// mergeChatToolPart folds one tool frame onto the part retained from the frames
// before it. A tool call is reported across several frames that each carry only
// part of it — input.started the name, input.ended the arguments as text, called
// the parsed input, progress metadata, and success the output with no name and no
// input — so a field the broker already learned is never blanked by a later frame
// that omits it. A non-empty incoming field wins; otherwise the retained value is
// kept.
func mergeChatToolPart(previous, incoming *protocol.ChatPart) protocol.ChatPart {
if previous == nil {
return *incoming
}
merged := *incoming
if merged.Type == "" {
merged.Type = previous.Type
}
if merged.Name == "" {
merged.Name = previous.Name
}
merged.Executed = merged.Executed || previous.Executed
if merged.Time == nil {
merged.Time = previous.Time
}
switch {
case incoming.State == nil:
merged.State = previous.State
case previous.State == nil:
// The incoming state stands on its own; merged already carries it.
default:
state := *incoming.State
if state.Status == "" {
state.Status = previous.State.Status
}
if len(state.Input) == 0 {
state.Input = previous.State.Input
}
if len(state.Content) == 0 {
state.Content = previous.State.Content
}
if state.Metadata == nil {
state.Metadata = previous.State.Metadata
}
if state.Error == nil {
state.Error = previous.State.Error
}
merged.State = &state
}
return merged
}
// chatPartBytes estimates the retained size of a part so the per-session cap
// accounts for its whole state instead of only the first-seen name. It walks the
// fields rather than re-marshalling, so the cost matches the bytes it stores.
+47 -3
View File
@@ -267,8 +267,8 @@ func chatFrame(kind, delta string, part *protocol.ChatPart, step *protocol.ChatS
func scriptedChat() *fakeChat {
return &fakeChat{script: []protocol.ChatEventFrame{
chatFrame(protocol.ChatEventText, "hello ", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil),
chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil),
chatFrame(protocol.ChatEventText, "hello ", &protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0)}, nil),
chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0)}, nil),
chatFrame(protocol.ChatEventTool, "", &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: []byte(`{"command":"ls"}`)}}, nil),
chatFrame(protocol.ChatEventStep, "", nil, &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}),
}}
@@ -451,7 +451,7 @@ func TestChatMessagesResumesRetainedState(t *testing.T) {
if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 {
t.Fatalf("resumed message = %+v", message)
}
if message.Parts[0].Type != protocol.ChatPartText || message.Parts[0].ID != "msg_1#0" || message.Parts[0].Text != "hello world" {
if message.Parts[0].Type != protocol.ChatPartText || message.Parts[0].ID != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0) || message.Parts[0].Text != "hello world" {
t.Fatalf("resumed text part = %+v", message.Parts[0])
}
if message.Parts[1].Type != protocol.ChatPartTool || message.Parts[1].State == nil || message.Parts[1].State.Status != protocol.ChatToolCompleted {
@@ -895,6 +895,50 @@ func TestChatHubChargesToolStateBytes(t *testing.T) {
}
}
// TestChatHubRetainsToolNameAndInputAcrossLifecycle pins that a tool call keeps
// its name and its input for its whole lifecycle in the retained state a resume
// serves: the name arrives only in input.started, the arguments in input.ended's
// text or called's input, and then progress/success carry neither, so no later
// frame may blank a field the hub already learned.
func TestChatHubRetainsToolNameAndInputAcrossLifecycle(t *testing.T) {
hub := newChatHub()
apply := func(part *protocol.ChatPart) {
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: part})
}
// input.started: the name, no arguments yet.
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolStreaming}})
// input.ended/called: the arguments, no name.
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolRunning, Input: json.RawMessage(`{"command":"ls"}`)}})
// progress: metadata only.
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolRunning, Metadata: map[string]any{"exit": 0}}})
// success: the output, no name and no input.
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Content: []protocol.ChatToolContent{{Type: "text", Text: "ok"}}}})
messages := hub.snapshot("ses_1")
if len(messages) != 1 || len(messages[0].Parts) != 1 {
t.Fatalf("snapshot = %+v", messages)
}
part := messages[0].Parts[0]
if part.Name != "shell" {
t.Fatalf("tool name was blanked by a later frame: %+v", part)
}
if part.State == nil || part.State.Status != protocol.ChatToolCompleted {
t.Fatalf("tool state = %+v", part.State)
}
var input struct {
Command string `json:"command"`
}
if err := json.Unmarshal(part.State.Input, &input); err != nil || input.Command != "ls" {
t.Fatalf("tool input was blanked by a later frame: %s (err %v)", part.State.Input, err)
}
if len(part.State.Content) != 1 || part.State.Content[0].Text != "ok" {
t.Fatalf("tool content = %+v", part.State.Content)
}
if part.State.Metadata["exit"] == nil {
t.Fatalf("tool metadata was blanked by a later frame: %+v", part.State.Metadata)
}
}
// TestChatPromptSubscribesBeforePrompt pins the subscribe-before-prompt order:
// the firehose has no replay cursor, so the subscription must be attached before
// the prompt is posted or deltas emitted in between are lost.