diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt index 04fbbd94..b4d84acd 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt @@ -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 diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt index e446ccc5..9789c597 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt @@ -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, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt index efa83de4..1df0166c 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt @@ -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, 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): 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) { + /** 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 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): List { + val rows = ArrayList(messages.size) + var turnKey: String? = null + var parts = ArrayList() + 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…" diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index d38d2d6b..7b109b34 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -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) -> List) { 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) } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt index 9b63b83d..0434bb23 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt @@ -85,6 +85,7 @@ private const val CHAT_ELAPSED_TICK_MILLIS = 1_000L @Composable internal fun ChatTranscript( thread: ChatThread, + rows: List, 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) { } } -/** - * 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, - 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 diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatReasoningTurnTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatReasoningTurnTest.kt index f1fd4d4d..806aee88 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatReasoningTurnTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatReasoningTurnTest.kt @@ -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, diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt index 3e82282d..f524c022 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt @@ -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. diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt index ce071d77..0a7c3d61 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt @@ -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(), 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().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 }) + } } diff --git a/docs/notes/chat-transcript-turn-fold.md b/docs/notes/chat-transcript-turn-fold.md new file mode 100644 index 00000000..02bc9ecc --- /dev/null +++ b/docs/notes/chat-transcript-turn-fold.md @@ -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. diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index 41a7b25c..eda1ec3a 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -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 { diff --git a/internal/opencode/chat_v2_test.go b/internal/opencode/chat_v2_test.go index cd5dbb7a..4e76d7d3 100644 --- a/internal/opencode/chat_v2_test.go +++ b/internal/opencode/chat_v2_test.go @@ -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. diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 9db719f7..2fdeaaf5 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -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 { diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index b04105b7..fdc14b3b 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -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. diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 1dd43b36..bf19de7f 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -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.