iris-aiandClaude Opus 5
bb5ac1a242
A llama.cpp session's `reasoning_content` becomes `Event::Thinking` deltas closed by an `Event::ThinkingDone` carrying the span the driver measured, and the phone draws it as a card of its own: "Thinking" with the spinner a running command has, then "Thought for 12.4s". Deliberately not a tool call, so a run of calls cannot collapse the reasoning into "Called 6 tools"; the reasoning is also kept out of the next prompt, which `conversation` already ignored. `UsageDelta` gains `tokensPerSecond`, the provider's own figure or nothing -- llama.cpp reports `timings.predicted_per_second` and the coding CLIs report no such thing -- and a finished reply carries a small line under it saying when it was sent and, where there is one, how fast it came out: "3:00 PM · 149 tok/s". The compact usage bar drops the provider's name for the window and puts its length after the time left instead: "42% · 3h 20m left / 5h". Three things that had to come with it: the transcript coalesces runs of thinking deltas as it does reply deltas, so one block is one row of a page rather than a page of its own; `joinPages` welds a block cut by a page boundary (`healSplitThinking`), since the half with no ending spun for ever; and `UsageDelta` now reaches the fold, which is what carries the rate to the reply. Verified on the emulator against a real Qwen3-0.6B session and the echo rig's new `/think [seconds]`: the spinner while it runs, "Thought for 1.4s" and "2:54 PM · 149 tok/s" after, the reasoning on tapping the card, and the usage bar reading "42% · 3h 19m left / 5h". Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
80 lines
3.2 KiB
Kotlin
80 lines
3.2 KiB
Kotlin
package com.example.aiapp
|
|
|
|
import androidx.compose.foundation.clickable
|
|
import androidx.compose.foundation.layout.Column
|
|
import androidx.compose.foundation.layout.Row
|
|
import androidx.compose.foundation.layout.Spacer
|
|
import androidx.compose.foundation.layout.fillMaxWidth
|
|
import androidx.compose.foundation.layout.height
|
|
import androidx.compose.foundation.layout.padding
|
|
import androidx.compose.foundation.layout.width
|
|
import androidx.compose.material3.Card
|
|
import androidx.compose.material3.CircularProgressIndicator
|
|
import androidx.compose.material3.MaterialTheme
|
|
import androidx.compose.material3.Text
|
|
import androidx.compose.runtime.Composable
|
|
import androidx.compose.ui.Alignment
|
|
import androidx.compose.ui.Modifier
|
|
import androidx.compose.ui.unit.dp
|
|
|
|
/**
|
|
* A model's working, shut until somebody asks for it.
|
|
*
|
|
* Shut by default, like a tool call and a memory note and for the same reason: it is not what the
|
|
* session said, and left open it puts the reasoning between the question and the answer -- which on
|
|
* a small model is most of the conversation.
|
|
*
|
|
* The heading is the whole of what the reader gets for free, so it carries the one thing worth
|
|
* knowing without opening anything: whether this is still going, and if not how long it took. A
|
|
* spinner while it runs, because that is the same fact a running command reports and it is drawn
|
|
* the same way here.
|
|
*/
|
|
@Composable
|
|
fun ThinkingCard(
|
|
item: TranscriptItem.ThinkingRow,
|
|
expanded: Boolean,
|
|
onToggle: () -> Unit,
|
|
modifier: Modifier = Modifier,
|
|
) {
|
|
Card(modifier.fillMaxWidth().clickable(onClick = onToggle)) {
|
|
Column(Modifier.padding(12.dp)) {
|
|
Row(verticalAlignment = Alignment.CenterVertically) {
|
|
Text(thinkingHeadline(item), style = MaterialTheme.typography.titleSmall)
|
|
Spacer(Modifier.width(8.dp))
|
|
if (item.open) {
|
|
CircularProgressIndicator(
|
|
modifier = Modifier.width(16.dp).height(16.dp),
|
|
strokeWidth = 2.dp,
|
|
)
|
|
}
|
|
}
|
|
if (expanded) {
|
|
// Plain text rather than markdown: this is a model talking to itself, so its
|
|
// half-finished lists and stray backticks are not markup it meant to write, and
|
|
// rendering them as such makes the working look like an answer.
|
|
Text(
|
|
item.text,
|
|
style = MaterialTheme.typography.bodySmall,
|
|
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
|
modifier = Modifier.padding(top = 6.dp),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* "Thinking", "Thought for 12.4s", or "Thought".
|
|
*
|
|
* The third is the one worth keeping: a block whose turn ended before the model said anything --
|
|
* interrupted, stopped, a process that exited -- was thought about for a length of time nobody
|
|
* measured. Naming a span there would be this screen inventing one, and the reader has no way to
|
|
* tell an invented one from the rest.
|
|
*/
|
|
fun thinkingHeadline(item: TranscriptItem.ThinkingRow): String =
|
|
when {
|
|
item.open -> "Thinking"
|
|
item.ms != null -> "Thought for ${formatMillis(item.ms)}"
|
|
else -> "Thought"
|
|
}
|