Merge think-group: group a turn's reasoning into one collapsible block
A chat turn that reasoned several times now shows a single collapsible thinking block (with its step count and elapsed time) instead of one box per reasoning part, and a streaming turn grows that block rather than adding another.
This commit is contained in:
@@ -199,7 +199,7 @@ internal fun openChatsBeside(open: List<ChatThread>, activeSessionId: String): L
|
|||||||
/**
|
/**
|
||||||
* How the transcript renders one part. The decision is pure so the markdown
|
* How the transcript renders one part. The decision is pure so the markdown
|
||||||
* route out of the transcript can be tested without Compose: assistant text is
|
* route out of the transcript can be tested without Compose: assistant text is
|
||||||
* markdown, reasoning is its own collapsed presentation, any other part with
|
* markdown, reasoning feeds the turn's one folded block, any other part with
|
||||||
* text is plain, and an empty part renders nothing.
|
* text is plain, and an empty part renders nothing.
|
||||||
*/
|
*/
|
||||||
internal enum class PartRendering { MARKDOWN, REASONING, PLAIN, HIDDEN }
|
internal enum class PartRendering { MARKDOWN, REASONING, PLAIN, HIDDEN }
|
||||||
@@ -212,22 +212,81 @@ internal fun partRendering(part: ChatPart): PartRendering = when {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Which reasoning parts the operator has opened. A set keyed by the stable
|
* Which turns' reasoning the operator has opened. A set keyed by the turn's own
|
||||||
* per-part key, so a streaming part keeps its state as deltas arrive and every
|
* stable key, so a streaming turn keeps its state as deltas arrive — the block is
|
||||||
* part starts collapsed in a freshly opened conversation.
|
* not rebuilt when the turn grows — and every turn starts collapsed in a freshly
|
||||||
|
* opened conversation.
|
||||||
*/
|
*/
|
||||||
internal data class ReasoningExpansion(private val expanded: Set<String> = emptySet()) {
|
internal data class ReasoningExpansion(private val expanded: Set<String> = emptySet()) {
|
||||||
fun isExpanded(partKey: String): Boolean = partKey in expanded
|
fun isExpanded(turnKey: String): Boolean = turnKey in expanded
|
||||||
|
|
||||||
fun toggled(partKey: String): ReasoningExpansion {
|
fun toggled(turnKey: String): ReasoningExpansion {
|
||||||
if (partKey.isBlank()) return this
|
if (turnKey.isBlank()) return this
|
||||||
return copy(expanded = if (partKey in expanded) expanded - partKey else expanded + partKey)
|
return copy(expanded = if (turnKey in expanded) expanded - turnKey else expanded + turnKey)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** The stable key for one reasoning part, even when the server omitted its id. */
|
/** The stable key for one turn's single reasoning block: the turn's own message id. */
|
||||||
internal fun reasoningKey(messageId: String, part: ChatPart, index: Int): String =
|
internal fun reasoningTurnKey(messageId: String): String = messageId
|
||||||
messageId + ":" + part.id.ifBlank { index.toString() }
|
|
||||||
|
/**
|
||||||
|
* One assistant turn's reasoning, folded into the single collapsible block the
|
||||||
|
* transcript shows. [steps] are the reasoning parts that carry text, in the order
|
||||||
|
* the server sent them; a turn that reasons several times is therefore one entry
|
||||||
|
* rather than a stack of them.
|
||||||
|
*/
|
||||||
|
internal data class ReasoningTurn(val steps: List<String>) {
|
||||||
|
val count: Int get() = steps.size
|
||||||
|
val empty: Boolean get() = steps.isEmpty()
|
||||||
|
|
||||||
|
/** The turn's reasoning as the one expanded block reads it, steps in order. */
|
||||||
|
val text: String get() = steps.joinToString("\n\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The reasoning of a turn — every reasoning part with text, in order. The one
|
||||||
|
* fold the transcript and its tests share, so "one block per turn" is a single
|
||||||
|
* derivation rather than a rule each call site re-implements.
|
||||||
|
*/
|
||||||
|
internal fun turnReasoning(parts: List<ChatPart>): ReasoningTurn =
|
||||||
|
ReasoningTurn(
|
||||||
|
parts.filter { it.type == ChatProtocol.PART_REASONING && it.text.isNotBlank() }
|
||||||
|
.map { it.text },
|
||||||
|
)
|
||||||
|
|
||||||
|
/** The live label of a single-step turn's reasoning block while it streams. */
|
||||||
|
private const val REASONING_STREAMING_LABEL = "Thinking…"
|
||||||
|
|
||||||
|
/** The settled label of a single-step turn's reasoning block. */
|
||||||
|
private const val REASONING_SETTLED_LABEL = "Reasoning"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The collapsed thinking line's label. A turn that reasoned once keeps the plain
|
||||||
|
* one-block wording — a count of one is never shown — while a turn that reasoned
|
||||||
|
* several times reads as its step count, so the operator can tell before opening
|
||||||
|
* it how much thinking there is.
|
||||||
|
*/
|
||||||
|
internal fun reasoningLabel(count: Int, streaming: Boolean): String = when {
|
||||||
|
count > 1 && streaming -> "Thinking · $count steps"
|
||||||
|
count > 1 -> "Reasoning · $count steps"
|
||||||
|
streaming -> REASONING_STREAMING_LABEL
|
||||||
|
else -> REASONING_SETTLED_LABEL
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The elapsed time the server's own timing gives a settled turn: from the
|
||||||
|
* earliest start to the latest completion across the parts that carry a timing
|
||||||
|
* envelope (a tool call reports both). Null when the turn carries no usable
|
||||||
|
* timing, so the collapsed line shows a duration only when there is one to show
|
||||||
|
* rather than guessing one.
|
||||||
|
*/
|
||||||
|
internal fun turnElapsedMillis(parts: List<ChatPart>): Long? {
|
||||||
|
val start = parts.mapNotNull { part ->
|
||||||
|
part.time?.let { if (it.ran > 0) it.ran else it.created }?.takeIf { it > 0 }
|
||||||
|
}.minOrNull() ?: return null
|
||||||
|
val end = parts.mapNotNull { it.time?.completed?.takeIf { it > 0 } }.maxOrNull() ?: return null
|
||||||
|
return (end - start).takeIf { it > 0 }
|
||||||
|
}
|
||||||
|
|
||||||
/** Which action the composer's single primary control offers for a chat. */
|
/** Which action the composer's single primary control offers for a chat. */
|
||||||
enum class ComposerAction { Send, Stop }
|
enum class ComposerAction { Send, Stop }
|
||||||
|
|||||||
@@ -184,6 +184,7 @@ internal fun ChatTranscript(
|
|||||||
message = message,
|
message = message,
|
||||||
reasoning = reasoning,
|
reasoning = reasoning,
|
||||||
streaming = message.id == streamingMessageId,
|
streaming = message.id == streamingMessageId,
|
||||||
|
runningSince = thread.runningSince,
|
||||||
onToggleReasoning = onToggleReasoning,
|
onToggleReasoning = onToggleReasoning,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -320,8 +321,20 @@ private fun MessageItem(
|
|||||||
message: ChatMessage,
|
message: ChatMessage,
|
||||||
reasoning: ReasoningExpansion,
|
reasoning: ReasoningExpansion,
|
||||||
streaming: Boolean,
|
streaming: Boolean,
|
||||||
|
runningSince: Long,
|
||||||
onToggleReasoning: (String) -> Unit,
|
onToggleReasoning: (String) -> Unit,
|
||||||
) {
|
) {
|
||||||
|
// The turn's own timing for the collapsed thinking line: a streaming turn
|
||||||
|
// counts live from its own start (the same clock the running indicator uses,
|
||||||
|
// so the two never disagree), a settled turn shows the span its parts' timing
|
||||||
|
// envelopes report, and a turn with neither shows no duration rather than a
|
||||||
|
// guessed one.
|
||||||
|
val elapsedMillis: Long? = if (streaming && runningSince > 0) {
|
||||||
|
val now = rememberElapsedNow(runningSince)
|
||||||
|
if (runningSince < now) now - runningSince else 0L
|
||||||
|
} else {
|
||||||
|
turnElapsedMillis(message.parts)
|
||||||
|
}
|
||||||
val isUser = message.role == ChatProtocol.ROLE_USER
|
val isUser = message.role == ChatProtocol.ROLE_USER
|
||||||
Row(
|
Row(
|
||||||
modifier = Modifier.fillMaxWidth(),
|
modifier = Modifier.fillMaxWidth(),
|
||||||
@@ -346,6 +359,7 @@ private fun MessageItem(
|
|||||||
parts = message.parts,
|
parts = message.parts,
|
||||||
reasoning = reasoning,
|
reasoning = reasoning,
|
||||||
streaming = streaming,
|
streaming = streaming,
|
||||||
|
elapsedMillis = elapsedMillis,
|
||||||
onToggleReasoning = onToggleReasoning,
|
onToggleReasoning = onToggleReasoning,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -378,6 +392,11 @@ private fun UserParts(parts: List<ChatPart>) {
|
|||||||
* rendered as one wrapping chip group (mirroring the reference transcript's
|
* 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
|
* `_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.
|
* 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
|
@Composable
|
||||||
private fun AssistantParts(
|
private fun AssistantParts(
|
||||||
@@ -385,67 +404,75 @@ private fun AssistantParts(
|
|||||||
parts: List<ChatPart>,
|
parts: List<ChatPart>,
|
||||||
reasoning: ReasoningExpansion,
|
reasoning: ReasoningExpansion,
|
||||||
streaming: Boolean,
|
streaming: Boolean,
|
||||||
|
elapsedMillis: Long?,
|
||||||
onToggleReasoning: (String) -> Unit,
|
onToggleReasoning: (String) -> Unit,
|
||||||
) {
|
) {
|
||||||
|
val turn = turnReasoning(parts)
|
||||||
|
val turnKey = reasoningTurnKey(messageId)
|
||||||
var index = 0
|
var index = 0
|
||||||
|
var reasoningShown = false
|
||||||
while (index < parts.size) {
|
while (index < parts.size) {
|
||||||
if (parts[index].type == ChatProtocol.PART_TOOL) {
|
val part = parts[index]
|
||||||
var end = index
|
when {
|
||||||
while (end < parts.size && parts[end].type == ChatProtocol.PART_TOOL) end++
|
part.type == ChatProtocol.PART_TOOL -> {
|
||||||
ToolCalls(parts.subList(index, end))
|
var end = index
|
||||||
index = end
|
while (end < parts.size && parts[end].type == ChatProtocol.PART_TOOL) end++
|
||||||
} else {
|
ToolCalls(parts.subList(index, end))
|
||||||
val part = parts[index]
|
index = end
|
||||||
MessagePart(
|
}
|
||||||
part = part,
|
partRendering(part) == PartRendering.REASONING -> {
|
||||||
reasoningKey = reasoningKey(messageId, part, index),
|
if (!reasoningShown) {
|
||||||
reasoning = reasoning,
|
reasoningShown = true
|
||||||
streaming = streaming,
|
ReasoningBlock(
|
||||||
onToggleReasoning = onToggleReasoning,
|
turn = turn,
|
||||||
)
|
expanded = reasoning.isExpanded(turnKey),
|
||||||
index++
|
streaming = streaming,
|
||||||
|
elapsedMillis = elapsedMillis,
|
||||||
|
onToggle = { onToggleReasoning(turnKey) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
index++
|
||||||
|
}
|
||||||
|
else -> {
|
||||||
|
MessagePart(part)
|
||||||
|
index++
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Composable
|
@Composable
|
||||||
private fun MessagePart(
|
private fun MessagePart(part: ChatPart) {
|
||||||
part: ChatPart,
|
|
||||||
reasoningKey: String,
|
|
||||||
reasoning: ReasoningExpansion,
|
|
||||||
streaming: Boolean,
|
|
||||||
onToggleReasoning: (String) -> Unit,
|
|
||||||
) {
|
|
||||||
when (partRendering(part)) {
|
when (partRendering(part)) {
|
||||||
PartRendering.MARKDOWN -> MarkdownText(part.text)
|
PartRendering.MARKDOWN -> MarkdownText(part.text)
|
||||||
PartRendering.REASONING -> ReasoningBlock(
|
// Reasoning is folded into the turn's one block by [AssistantParts]; a
|
||||||
text = part.text,
|
// reasoning part never reaches here, but rendering nothing keeps this
|
||||||
expanded = reasoning.isExpanded(reasoningKey),
|
// exhaustive and safe if one ever did.
|
||||||
streaming = streaming,
|
PartRendering.REASONING -> Unit
|
||||||
onToggle = { onToggleReasoning(reasoningKey) },
|
|
||||||
)
|
|
||||||
PartRendering.PLAIN -> Text(part.text, style = MaterialTheme.typography.bodyMedium)
|
PartRendering.PLAIN -> Text(part.text, style = MaterialTheme.typography.bodyMedium)
|
||||||
PartRendering.HIDDEN -> Unit
|
PartRendering.HIDDEN -> Unit
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Reasoning is visually secondary and collapsed by default: one compact, muted
|
* A turn's reasoning: one compact, muted line that names the block — its step
|
||||||
* line per part (its spinner-free label names the state; the live label is
|
* count when it reasoned more than once, and its elapsed time when the turn's own
|
||||||
* `Thinking…`) that expands on tap to the full, still-muted text. The expansion
|
* timing is known — and expands on tap to the whole turn's reasoning in order,
|
||||||
* state lives on the conversation, so it survives the transcript disposing the
|
* still muted so it stays secondary to the answer. The expansion state lives on
|
||||||
* item while the operator scrolls and a streaming part keeps its state as
|
* the conversation keyed by the turn, so it survives the transcript disposing the
|
||||||
* deltas arrive.
|
* item while the operator scrolls and a streaming turn keeps it as deltas arrive.
|
||||||
*/
|
*/
|
||||||
@Composable
|
@Composable
|
||||||
private fun ReasoningBlock(
|
private fun ReasoningBlock(
|
||||||
text: String,
|
turn: ReasoningTurn,
|
||||||
expanded: Boolean,
|
expanded: Boolean,
|
||||||
streaming: Boolean,
|
streaming: Boolean,
|
||||||
|
elapsedMillis: Long?,
|
||||||
onToggle: () -> Unit,
|
onToggle: () -> Unit,
|
||||||
) {
|
) {
|
||||||
if (text.isBlank()) return
|
if (turn.empty) return
|
||||||
val label = if (streaming) REASONING_STREAMING_LABEL else REASONING_SETTLED_LABEL
|
val label = reasoningLabel(turn.count, streaming)
|
||||||
|
val duration = elapsedMillis?.let { formatDuration(it / 1_000) }
|
||||||
Column(Modifier.fillMaxWidth()) {
|
Column(Modifier.fillMaxWidth()) {
|
||||||
Row(
|
Row(
|
||||||
verticalAlignment = Alignment.CenterVertically,
|
verticalAlignment = Alignment.CenterVertically,
|
||||||
@@ -463,7 +490,7 @@ private fun ReasoningBlock(
|
|||||||
modifier = Modifier.size(ICON_INLINE_DP),
|
modifier = Modifier.size(ICON_INLINE_DP),
|
||||||
)
|
)
|
||||||
Text(
|
Text(
|
||||||
text = label,
|
text = if (duration != null) "$label · $duration" else label,
|
||||||
style = MaterialTheme.typography.bodySmall,
|
style = MaterialTheme.typography.bodySmall,
|
||||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||||
modifier = Modifier.weight(1f),
|
modifier = Modifier.weight(1f),
|
||||||
@@ -477,7 +504,7 @@ private fun ReasoningBlock(
|
|||||||
}
|
}
|
||||||
if (expanded) {
|
if (expanded) {
|
||||||
Text(
|
Text(
|
||||||
text = text,
|
text = turn.text,
|
||||||
style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Default),
|
style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Default),
|
||||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||||
modifier = Modifier.padding(start = ICON_INLINE_DP + CHAT_ITEM_GAP, bottom = CHAT_ITEM_GAP),
|
modifier = Modifier.padding(start = ICON_INLINE_DP + CHAT_ITEM_GAP, bottom = CHAT_ITEM_GAP),
|
||||||
@@ -485,7 +512,3 @@ private fun ReasoningBlock(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** The live and settled labels of a reasoning part's one collapsed line. */
|
|
||||||
private const val REASONING_STREAMING_LABEL = "Thinking…"
|
|
||||||
private const val REASONING_SETTLED_LABEL = "Reasoning"
|
|
||||||
|
|||||||
@@ -0,0 +1,128 @@
|
|||||||
|
package net.awan.pipelines.ui.chat
|
||||||
|
|
||||||
|
import net.awan.pipelines.data.protocol.ChatEventFrame
|
||||||
|
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 org.junit.Assert.assertEquals
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertNull
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A turn's reasoning is one collapsible entry, not one per part: the fold into a
|
||||||
|
* single block, its ordered contents, its collapsed wording, the elapsed time the
|
||||||
|
* turn's own timing supplies, and a streaming turn that grows the block it has
|
||||||
|
* rather than adding another. All pure (or driven straight against [ChatStore]
|
||||||
|
* with an injected clock), so no device, server or Compose runtime is needed.
|
||||||
|
*/
|
||||||
|
class ChatReasoningTurnTest {
|
||||||
|
|
||||||
|
private fun reasoning(id: String, text: String) =
|
||||||
|
ChatPart(type = ChatProtocol.PART_REASONING, id = id, text = text)
|
||||||
|
|
||||||
|
private fun text(id: String, value: String) = ChatPart(type = ChatProtocol.PART_TEXT, id = id, text = value)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun everyReasoningPartOfATurnFoldsIntoExactlyOneEntryInOrder() {
|
||||||
|
// Three reasoning parts with an answer and a tool call between them are
|
||||||
|
// still one entry: the fold yields a single [ReasoningTurn].
|
||||||
|
val parts = listOf(
|
||||||
|
reasoning("r1", "first thought"),
|
||||||
|
text("t1", "an answer"),
|
||||||
|
reasoning("r2", "second thought"),
|
||||||
|
ChatPart(type = ChatProtocol.PART_TOOL, id = "tool1", name = "read"),
|
||||||
|
reasoning("r3", "third thought"),
|
||||||
|
)
|
||||||
|
|
||||||
|
val turn = turnReasoning(parts)
|
||||||
|
assertFalse(turn.empty)
|
||||||
|
assertEquals(3, turn.count)
|
||||||
|
// The steps keep the server's order, regardless of the parts between them.
|
||||||
|
assertEquals(listOf("first thought", "second thought", "third thought"), turn.steps)
|
||||||
|
// Expanding shows them all, in order, as the one block's text.
|
||||||
|
assertEquals("first thought\n\nsecond thought\n\nthird thought", turn.text)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aTurnThatReasonedOnceOrNotAtAllIsNotACountedEntry() {
|
||||||
|
// One part is a block, not a count of one.
|
||||||
|
assertEquals(1, turnReasoning(listOf(reasoning("r1", "only thought"))).count)
|
||||||
|
assertEquals("Thinking…", reasoningLabel(1, streaming = true))
|
||||||
|
assertEquals("Reasoning", reasoningLabel(1, streaming = false))
|
||||||
|
|
||||||
|
// Several steps carry their count, live or settled.
|
||||||
|
assertEquals("Thinking · 6 steps", reasoningLabel(6, streaming = true))
|
||||||
|
assertEquals("Reasoning · 6 steps", reasoningLabel(6, streaming = false))
|
||||||
|
|
||||||
|
// A turn with no reasoning is empty, so nothing is rendered.
|
||||||
|
assertTrue(turnReasoning(listOf(text("t1", "just an answer"))).empty)
|
||||||
|
// A reasoning part without text is not a step either.
|
||||||
|
assertTrue(turnReasoning(listOf(reasoning("r1", " "))).empty)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun theElapsedTimeComesFromTheTurnsOwnPartTimingOrIsAbsent() {
|
||||||
|
// A turn whose parts report a timing envelope has an elapsed time.
|
||||||
|
val timed = listOf(
|
||||||
|
ChatPart(type = ChatProtocol.PART_TOOL, id = "a", time = ChatTime(created = 1_000, ran = 1_000, completed = 2_500)),
|
||||||
|
ChatPart(type = ChatProtocol.PART_TOOL, id = "b", time = ChatTime(created = 2_000, ran = 2_000, completed = 4_000)),
|
||||||
|
)
|
||||||
|
assertEquals(3_000L, turnElapsedMillis(timed))
|
||||||
|
|
||||||
|
// A turn with no timing at all shows no duration rather than a guessed one.
|
||||||
|
assertNull(turnElapsedMillis(listOf(reasoning("r1", "thought"))))
|
||||||
|
// A start but no completion is still unknown.
|
||||||
|
assertNull(turnElapsedMillis(listOf(ChatPart(type = ChatProtocol.PART_TOOL, id = "a", time = ChatTime(created = 1_000)))))
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun aStreamingTurnGrowsTheSameEntryInsteadOfAddingAnother() {
|
||||||
|
val store = ChatStore()
|
||||||
|
store.open(ChatSession(id = "s", title = "s"))
|
||||||
|
store.history("s", emptyList())
|
||||||
|
|
||||||
|
// Two reasoning deltas to one part grow that part's text...
|
||||||
|
store.event(reasoningDelta("s", "m1", "r1", "thin"))
|
||||||
|
store.event(reasoningDelta("s", "m1", "r1", "king"))
|
||||||
|
val message = store.value.thread("s")!!.messages.single()
|
||||||
|
assertEquals(1, message.parts.size)
|
||||||
|
assertEquals("thinking", message.parts.single().text)
|
||||||
|
|
||||||
|
// ...and a later reasoning part is folded into the same one entry, never a
|
||||||
|
// second. The turn still holds a single assistant message throughout.
|
||||||
|
store.event(reasoningDelta("s", "m1", "r2", "more"))
|
||||||
|
val threaded = store.value.thread("s")!!.messages.single()
|
||||||
|
assertEquals(2, threaded.parts.size)
|
||||||
|
val turn = turnReasoning(threaded.parts)
|
||||||
|
assertFalse(turn.empty)
|
||||||
|
assertEquals(2, turn.count)
|
||||||
|
assertEquals("thinking\n\nmore", turn.text)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun theExpandedStateIsKeyedByTheTurnAndSurvivesAsItGrows() {
|
||||||
|
// The expansion key is the turn, so a turn match survives the block
|
||||||
|
// growing: toggling before more parts arrive still reads as expanded after.
|
||||||
|
var reasoning = ReasoningExpansion()
|
||||||
|
val key = reasoningTurnKey("m1")
|
||||||
|
reasoning = reasoning.toggled(key)
|
||||||
|
assertTrue(reasoning.isExpanded(key))
|
||||||
|
|
||||||
|
// The same turn id used by the transcript for its message keeps that state.
|
||||||
|
assertTrue(reasoning.isExpanded(reasoningTurnKey("m1")))
|
||||||
|
// A different turn is untouched.
|
||||||
|
assertFalse(reasoning.isExpanded(reasoningTurnKey("m2")))
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun reasoningDelta(sessionId: String, messageId: String, partId: String, delta: String) =
|
||||||
|
ChatEventFrame(
|
||||||
|
sessionId = sessionId,
|
||||||
|
messageId = messageId,
|
||||||
|
kind = ChatProtocol.PART_REASONING,
|
||||||
|
delta = delta,
|
||||||
|
part = ChatPart(type = ChatProtocol.PART_REASONING, id = partId),
|
||||||
|
)
|
||||||
|
}
|
||||||
@@ -76,34 +76,33 @@ class ChatTranscriptTest {
|
|||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun reasoningStartsCollapsedAndKeepsItsExpansionPerPart() {
|
fun reasoningStartsCollapsedAndKeepsItsExpansionPerTurn() {
|
||||||
var reasoning = ReasoningExpansion()
|
var reasoning = ReasoningExpansion()
|
||||||
assertFalse(reasoning.isExpanded("m:r1"))
|
assertFalse(reasoning.isExpanded("m1"))
|
||||||
assertFalse(reasoning.isExpanded("m:r2"))
|
assertFalse(reasoning.isExpanded("m2"))
|
||||||
|
|
||||||
reasoning = reasoning.toggled("m:r1")
|
reasoning = reasoning.toggled("m1")
|
||||||
assertTrue(reasoning.isExpanded("m:r1"))
|
assertTrue(reasoning.isExpanded("m1"))
|
||||||
assertFalse(reasoning.isExpanded("m:r2"))
|
assertFalse(reasoning.isExpanded("m2"))
|
||||||
|
|
||||||
// Expanding a second part does not disturb the first.
|
// Expanding a second turn does not disturb the first.
|
||||||
reasoning = reasoning.toggled("m:r2")
|
reasoning = reasoning.toggled("m2")
|
||||||
assertTrue(reasoning.isExpanded("m:r1"))
|
assertTrue(reasoning.isExpanded("m1"))
|
||||||
assertTrue(reasoning.isExpanded("m:r2"))
|
assertTrue(reasoning.isExpanded("m2"))
|
||||||
|
|
||||||
// Collapsing brings only that part back.
|
// Collapsing brings only that turn back.
|
||||||
reasoning = reasoning.toggled("m:r1")
|
reasoning = reasoning.toggled("m1")
|
||||||
assertFalse(reasoning.isExpanded("m:r1"))
|
assertFalse(reasoning.isExpanded("m1"))
|
||||||
assertTrue(reasoning.isExpanded("m:r2"))
|
assertTrue(reasoning.isExpanded("m2"))
|
||||||
|
|
||||||
// A blank key is never a key: it can never expand every id-less part at once.
|
// A blank key is never a key: it can never expand every id-less turn at once.
|
||||||
val untouched = ReasoningExpansion().toggled("")
|
val untouched = ReasoningExpansion().toggled("")
|
||||||
assertFalse(untouched.isExpanded(""))
|
assertFalse(untouched.isExpanded(""))
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun reasoningKeyIsStableForAServerPartAndFallsBackToTheIndex() {
|
fun theReasoningKeyIsTheTurnItself() {
|
||||||
assertEquals("m:r1", reasoningKey("m", ChatPart(id = "r1"), 0))
|
assertEquals("m", reasoningTurnKey("m"))
|
||||||
assertEquals("m:2", reasoningKey("m", ChatPart(id = ""), 2))
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
|
|||||||
Reference in New Issue
Block a user