@@ -0,0 +1,1723 @@
1+package soy.iko.opencode.ui.chat
2+
3+import android.app.Activity
4+import android.content.Intent
5+import android.net.Uri
6+import android.speech.RecognizerIntent
7+import androidx.activity.compose.BackHandler
8+import androidx.activity.compose.rememberLauncherForActivityResult
9+import androidx.activity.result.PickVisualMediaRequest
10+import androidx.activity.result.contract.ActivityResultContracts
11+import androidx.compose.animation.AnimatedVisibility
12+import androidx.compose.foundation.clickable
13+import androidx.compose.foundation.layout.Arrangement
14+import androidx.compose.foundation.layout.Box
15+import androidx.compose.foundation.layout.Column
16+import androidx.compose.foundation.layout.FlowRow
17+import androidx.compose.foundation.layout.PaddingValues
18+import androidx.compose.foundation.layout.Row
19+import androidx.compose.foundation.layout.Spacer
20+import androidx.compose.foundation.layout.WindowInsets
21+import androidx.compose.foundation.layout.fillMaxSize
22+import androidx.compose.foundation.layout.fillMaxWidth
23+import androidx.compose.foundation.layout.imePadding
24+import androidx.compose.foundation.layout.navigationBars
25+import androidx.compose.foundation.layout.padding
26+import androidx.compose.foundation.layout.size
27+import androidx.compose.foundation.layout.union
28+import androidx.compose.foundation.layout.windowInsetsPadding
29+import androidx.compose.foundation.lazy.LazyColumn
30+import androidx.compose.foundation.lazy.items
31+import androidx.compose.foundation.lazy.rememberLazyListState
32+import androidx.compose.material.icons.Icons
33+import androidx.compose.material.icons.automirrored.filled.ArrowBack
34+import androidx.compose.material.icons.automirrored.filled.Send
35+import androidx.compose.material.icons.filled.Add
36+import androidx.compose.material.icons.filled.AutoAwesome
37+import androidx.compose.material.icons.filled.Delete
38+import androidx.compose.material.icons.filled.Description
39+import androidx.compose.material.icons.filled.Edit
40+import androidx.compose.material.icons.filled.KeyboardArrowDown
41+import androidx.compose.material.icons.filled.Mic
42+import androidx.compose.material.icons.filled.MoreVert
43+import androidx.compose.material.icons.filled.PhotoCamera
44+import androidx.compose.material.icons.filled.PhotoLibrary
45+import androidx.compose.material.icons.filled.Refresh
46+import androidx.compose.material.icons.filled.Restore
47+import androidx.compose.material.icons.filled.Stop
48+import androidx.compose.material3.AlertDialog
49+import androidx.compose.material3.Button
50+import androidx.compose.material3.CircularProgressIndicator
51+import androidx.compose.material3.DropdownMenu
52+import androidx.compose.material3.DropdownMenuItem
53+import androidx.compose.material3.ExperimentalMaterial3Api
54+import androidx.compose.material3.ExtendedFloatingActionButton
55+import androidx.compose.material3.FloatingActionButton
56+import androidx.compose.material3.Icon
57+import androidx.compose.material3.IconButton
58+import androidx.compose.material3.MaterialTheme
59+import androidx.compose.material3.OutlinedTextField
60+import androidx.compose.material3.Scaffold
61+import androidx.compose.material3.SnackbarHost
62+import androidx.compose.material3.SnackbarHostState
63+import androidx.compose.material3.Surface
64+import androidx.compose.material3.Text
65+import androidx.compose.material3.TextButton
66+import androidx.compose.material3.TopAppBar
67+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
68+import androidx.compose.runtime.Composable
69+import androidx.compose.runtime.CompositionLocalProvider
70+import androidx.compose.runtime.DisposableEffect
71+import androidx.compose.runtime.LaunchedEffect
72+import androidx.compose.runtime.derivedStateOf
73+import androidx.compose.runtime.getValue
74+import androidx.compose.runtime.mutableStateOf
75+import androidx.compose.runtime.remember
76+import androidx.compose.runtime.rememberCoroutineScope
77+import androidx.compose.runtime.rememberUpdatedState
78+import androidx.compose.runtime.saveable.rememberSaveable
79+import androidx.compose.runtime.setValue
80+import androidx.compose.runtime.snapshotFlow
81+import androidx.compose.foundation.text.KeyboardActions
82+import androidx.compose.foundation.text.KeyboardOptions
83+import androidx.compose.ui.text.input.KeyboardCapitalization
84+import androidx.compose.ui.Alignment
85+import androidx.compose.ui.Modifier
86+import androidx.compose.ui.focus.focusRequester
87+import androidx.compose.ui.input.key.Key
88+import androidx.compose.ui.input.key.KeyEventType
89+import androidx.compose.ui.input.key.isCtrlPressed
90+import androidx.compose.ui.input.key.isShiftPressed
91+import androidx.compose.ui.input.key.key
92+import androidx.compose.ui.input.key.onPreviewKeyEvent
93+import androidx.compose.ui.input.key.type
94+import androidx.compose.ui.platform.LocalContext
95+import androidx.compose.ui.platform.LocalHapticFeedback
96+import androidx.compose.ui.platform.LocalView
97+import androidx.compose.ui.platform.testTag
98+import androidx.compose.ui.res.stringResource
99+import androidx.compose.ui.semantics.Role
100+import androidx.compose.ui.semantics.contentDescription
101+import androidx.compose.ui.semantics.semantics
102+import androidx.compose.ui.text.input.ImeAction
103+import androidx.compose.ui.text.style.TextOverflow
104+import androidx.compose.ui.unit.dp
105+import androidx.lifecycle.compose.collectAsStateWithLifecycle
106+import androidx.lifecycle.viewmodel.compose.viewModel
107+import kotlinx.coroutines.Dispatchers
108+import kotlinx.coroutines.launch
109+import kotlinx.coroutines.withContext
110+import soy.iko.opencode.data.model.Part
111+import soy.iko.opencode.data.model.MessageWithParts
112+import soy.iko.opencode.data.model.ReasoningPart
113+import soy.iko.opencode.data.model.TextPart
114+import soy.iko.opencode.data.model.ToolCompleted
115+import soy.iko.opencode.data.model.ToolError
116+import soy.iko.opencode.data.model.ToolPart
117+import soy.iko.opencode.data.model.ToolRunning
118+import soy.iko.opencode.data.network.EventStreamClient
119+import soy.iko.opencode.data.network.NetworkConfig
120+import soy.iko.opencode.di.AppContainer
121+import soy.iko.opencode.R
122+import soy.iko.opencode.ui.components.CommandPalette
123+import soy.iko.opencode.ui.components.ConnectionBanner
124+import soy.iko.opencode.ui.components.PaletteAction
125+import soy.iko.opencode.ui.components.copyToClipboard
126+import soy.iko.opencode.ui.components.LocalRelativeTimeTick
127+import soy.iko.opencode.ui.components.rememberRelativeTimeTick
128+import soy.iko.opencode.ui.components.showToast
129+import soy.iko.opencode.ui.components.toImageContext
130+import soy.iko.opencode.ui.vmFactory
131+import soy.iko.opencode.util.runCatchingCancellable
132+
133+@OptIn(ExperimentalMaterial3Api::class)
134+@Composable
135+fun ChatScreen(
136+ container: AppContainer,
137+ sessionId: String,
138+ onBack: () -> Unit,
139+ onOpenFile: ((String) -> Unit)? = null,
140+ onOpenSession: ((String) -> Unit)? = null,
141+) {
142+ val vm: ChatViewModel = viewModel(key = sessionId, factory = vmFactory { ChatViewModel(container, sessionId) })
143+ val hasMessages by vm.hasMessages.collectAsStateWithLifecycle()
144+ val running by vm.running.collectAsStateWithLifecycle()
145+ val aborting by vm.aborting.collectAsStateWithLifecycle()
146+ val loading by vm.loading.collectAsStateWithLifecycle()
147+ val loadError by vm.loadError.collectAsStateWithLifecycle()
148+ val refreshing by vm.refreshing.collectAsStateWithLifecycle()
149+ val models by vm.models.collectAsStateWithLifecycle()
150+ val modelsLoading by vm.modelsLoading.collectAsStateWithLifecycle()
151+ val modelsError by vm.modelsError.collectAsStateWithLifecycle()
152+ val selectedModel by vm.selectedModel.collectAsStateWithLifecycle()
153+ val connectionState by vm.connectionState.collectAsStateWithLifecycle()
154+ val pendingPermission by vm.pendingPermission.collectAsStateWithLifecycle()
155+ val agents by vm.agents.collectAsStateWithLifecycle()
156+ val agentsLoading by vm.agentsLoading.collectAsStateWithLifecycle()
157+ val agentsError by vm.agentsError.collectAsStateWithLifecycle()
158+ val selectedAgent by vm.selectedAgent.collectAsStateWithLifecycle()
159+ val commands by vm.commands.collectAsStateWithLifecycle()
160+ val commandsLoading by vm.commandsLoading.collectAsStateWithLifecycle()
161+ val commandsError by vm.commandsError.collectAsStateWithLifecycle()
162+ val sessionTitle by vm.sessionTitle.collectAsStateWithLifecycle()
163+ val sessionDeleted by vm.sessionDeleted.collectAsStateWithLifecycle()
164+ val draft by vm.draft.collectAsStateWithLifecycle()
165+ val attachments by vm.attachments.collectAsStateWithLifecycle()
166+ val reverted by vm.reverted.collectAsStateWithLifecycle()
167+ val shareUrl by vm.shareUrl.collectAsStateWithLifecycle()
168+ val reconnecting by vm.reconnecting.collectAsStateWithLifecycle()
169+ val sendOnEnter by container.settingsStore.sendOnEnter.collectAsStateWithLifecycle(initialValue = true)
170+ val isOnline by container.isOnline.collectAsStateWithLifecycle()
171+ val haptics = LocalHapticFeedback.current
172+ val scope = rememberCoroutineScope()
173+ val shareContext = LocalContext.current
174+ val defaultShareSubject = stringResource(R.string.share_subject)
175+ val sessionLabel = stringResource(R.string.session)
176+ val defaultModelLabel = stringResource(R.string.default_model)
177+ val subtitle = remember(selectedModel?.modelLabel, selectedAgent, defaultModelLabel) {
178+ buildString {
179+ append(selectedModel?.modelLabel ?: defaultModelLabel)
180+ selectedAgent?.let { append(" · $it") }
181+ }
182+ }
183+
184+ // Connection profile (with auth) for rendering inline image attachments.
185+ // Collect as state so a server switch recomposes the image context.
186+ val activeConnection by container.activeConnection.collectAsStateWithLifecycle()
187+ val imageContext = remember(activeConnection?.profile) {
188+ activeConnection?.profile?.toImageContext()
189+ }
190+
191+ // Mark this session as read while the user is viewing it; clear on leave so new
192+ // background activity can badge it again.
193+ DisposableEffect(sessionId) {
194+ container.setCurrentSession(sessionId)
195+ onDispose { if (container.currentSession.value == sessionId) container.setCurrentSession(null) }
196+ }
197+
198+ // Navigate away when the session is deleted via SSE so the user isn't left
199+ // on a zombie screen showing a conversation that no longer exists. Surface a
200+ // toast (not a snackbar) because the screen is about to be popped — a snackbar
201+ // would be torn down before the user could read it, while a toast survives.
202+ // Covers both SSE-driven deletion (deleted on another device) and a user-
203+ // initiated delete from the chat overflow menu (deleteSession in ChatViewModel
204+ // sets the same flag on success).
205+ val deletedContext = LocalContext.current
206+ LaunchedEffect(sessionDeleted) {
207+ if (sessionDeleted) {
208+ showToast(deletedContext, deletedContext.getString(R.string.session_deleted_chat))
209+ onBack()
210+ }
211+ }
212+
213+ val snackbar = remember { SnackbarHostState() }
214+ val retryLabel = stringResource(R.string.retry)
215+ val inputFocusRequester = remember { androidx.compose.ui.focus.FocusRequester() }
216+ var showModelPicker by rememberSaveable { mutableStateOf(false) }
217+ var showAgentPicker by rememberSaveable { mutableStateOf(false) }
218+ var showCommandPicker by rememberSaveable { mutableStateOf(false) }
219+ var showExitConfirm by rememberSaveable { mutableStateOf(false) }
220+ var showStopConfirm by rememberSaveable { mutableStateOf(false) }
221+ var showOverflowMenu by rememberSaveable { mutableStateOf(false) }
222+ var showRenameDialog by rememberSaveable { mutableStateOf(false) }
223+ var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
224+ var showShellDialog by rememberSaveable { mutableStateOf(false) }
225+ var showPalette by rememberSaveable { mutableStateOf(false) }
226+
227+ // Command-palette entries (keyboard-first: Ctrl+K). Labels resolved here so the remembered
228+ // action list doesn't need a Composable context. Actions map to the same handlers the
229+ // overflow menu drives, so the palette is a keyboard shortcut to them, not a parallel path.
230+ val paletteModelLabel = stringResource(R.string.palette_switch_model)
231+ val paletteAgentLabel = stringResource(R.string.palette_choose_agent)
232+ val paletteCommandLabel = stringResource(R.string.palette_run_command)
233+ val paletteSummarizeLabel = stringResource(R.string.palette_summarize)
234+ val paletteRenameLabel = stringResource(R.string.rename_session_chat)
235+ val paletteShellLabel = stringResource(R.string.run_shell_command)
236+ val paletteActions = remember(
237+ paletteModelLabel, paletteAgentLabel, paletteCommandLabel,
238+ paletteSummarizeLabel, paletteRenameLabel, paletteShellLabel, hasMessages, running,
239+ ) {
240+ buildList {
241+ add(PaletteAction("model", paletteModelLabel) { showModelPicker = true })
242+ add(PaletteAction("agent", paletteAgentLabel) { showAgentPicker = true })
243+ add(PaletteAction("command", paletteCommandLabel) { showCommandPicker = true })
244+ if (hasMessages && !running) add(PaletteAction("summarize", paletteSummarizeLabel) { vm.summarize() })
245+ if (!running) add(PaletteAction("shell", paletteShellLabel) { showShellDialog = true })
246+ add(PaletteAction("rename", paletteRenameLabel) { showRenameDialog = true })
247+ }
248+ }
249+
250+ // Keep the screen awake while the agent is working in *this* session. The foreground
251+ // service that holds process priority during a run is managed app-wide off
252+ // container.anyRunActive (see OpencodeApp) so it survives navigating away from the chat
253+ // mid-run — otherwise leaving the screen would drop priority and Doze could choke the
254+ // SSE stream before the completion notification fires.
255+ val currentView = LocalView.current
256+ val appContext = LocalContext.current.applicationContext
257+ DisposableEffect(running) {
258+ currentView.keepScreenOn = running
259+ onDispose { currentView.keepScreenOn = false }
260+ }
261+
262+ LaunchedEffect(Unit) {
263+ vm.errorEvents.collect { event ->
264+ // Only a failed *send* is retryable; attaching Retry to any other error (e.g. a
265+ // message-load failure) would silently re-submit the last prompt on tap.
266+ val result = if (event.retryable) {
267+ snackbar.showSnackbar(message = event.message, actionLabel = retryLabel)
268+ } else {
269+ snackbar.showSnackbar(event.message)
270+ }
271+ if (result == androidx.compose.material3.SnackbarResult.ActionPerformed) vm.retryFailed()
272+ }
273+ }
274+
275+ // --- Attachments, voice, and share-link plumbing ---
276+ val attachTooLargeMsg = stringResource(R.string.attachment_too_large)
277+ val attachFailedMsg = stringResource(R.string.attachment_failed)
278+ val attachLimitMsg = stringResource(R.string.attachment_limit)
279+ val noCameraMsg = stringResource(R.string.no_camera_app)
280+ val noVoiceMsg = stringResource(R.string.no_voice_app)
281+ val voicePrompt = stringResource(R.string.voice_prompt)
282+ val linkCopiedMsg = stringResource(R.string.link_copied)
283+
284+ // Convert each picked Uri to a base64 attachment off the main thread, honoring the
285+ // per-prompt count cap and surfacing per-file errors without aborting the batch.
286+ fun stageUris(uris: List<Uri>) {
287+ if (uris.isEmpty()) return
288+ scope.launch {
289+ for (uri in uris) {
290+ if (vm.attachments.value.size >= NetworkConfig.maxAttachments) {
291+ snackbar.showSnackbar(attachLimitMsg)
292+ break
293+ }
294+ when (val result = uri.toAttachmentResult(appContext)) {
295+ is AttachmentResult.Ok -> vm.addAttachment(result.attachment)
296+ AttachmentResult.TooLarge -> snackbar.showSnackbar(attachTooLargeMsg)
297+ AttachmentResult.Failed -> snackbar.showSnackbar(attachFailedMsg)
298+ }
299+ }
300+ }
301+ }
302+
303+ val photoPicker = rememberLauncherForActivityResult(
304+ ActivityResultContracts.PickMultipleVisualMedia(NetworkConfig.maxAttachments),
305+ ) { uris -> stageUris(uris) }
306+
307+ val filePicker = rememberLauncherForActivityResult(
308+ ActivityResultContracts.GetMultipleContents(),
309+ ) { uris -> stageUris(uris) }
310+
311+ // Uri survives a config change mid-capture so the TakePicture result still resolves.
312+ var pendingCaptureUri by rememberSaveable { mutableStateOf<Uri?>(null) }
313+ val cameraLauncher = rememberLauncherForActivityResult(
314+ ActivityResultContracts.TakePicture(),
315+ ) { success ->
316+ val uri = pendingCaptureUri
317+ pendingCaptureUri = null
318+ if (success && uri != null) stageUris(listOf(uri))
319+ }
320+
321+ val voiceLauncher = rememberLauncherForActivityResult(
322+ ActivityResultContracts.StartActivityForResult(),
323+ ) { result ->
324+ if (result.resultCode == Activity.RESULT_OK) {
325+ val spoken = result.data
326+ ?.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)
327+ ?.firstOrNull()
328+ ?.takeIf { it.isNotBlank() }
329+ if (spoken != null) {
330+ // Append to the existing draft rather than replacing, so dictation adds to
331+ // whatever the user already typed.
332+ val current = vm.draft.value
333+ val combined = if (current.isBlank()) spoken else "$current $spoken"
334+ vm.updateDraft(combined.take(NetworkConfig.maxDraftLengthChars))
335+ }
336+ }
337+ }
338+
339+ fun launchCamera() {
340+ val uri = newCameraCaptureUri(appContext)
341+ if (uri == null) {
342+ scope.launch { snackbar.showSnackbar(attachFailedMsg) }
343+ return
344+ }
345+ pendingCaptureUri = uri
346+ runCatching { cameraLauncher.launch(uri) }
347+ .onFailure { pendingCaptureUri = null; scope.launch { snackbar.showSnackbar(noCameraMsg) } }
348+ }
349+
350+ fun launchVoice() {
351+ val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
352+ putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
353+ putExtra(RecognizerIntent.EXTRA_PROMPT, voicePrompt)
354+ }
355+ runCatching { voiceLauncher.launch(intent) }
356+ .onFailure { scope.launch { snackbar.showSnackbar(noVoiceMsg) } }
357+ }
358+
359+ // A freshly-created share link is copied to the clipboard so the user can paste it right away.
360+ LaunchedEffect(Unit) {
361+ vm.shareLinkEvents.collect { url ->
362+ copyToClipboard(shareContext, "share", url)
363+ snackbar.showSnackbar(linkCopiedMsg)
364+ }
365+ }
366+
367+ // Navigate to a session freshly branched from a message (branchFrom), once it's created.
368+ // Keyed on Unit (like the sibling one-shot collectors above): keying on the onOpenSession
369+ // lambda would cancel/restart this collector whenever the lambda's identity changes, risking
370+ // a dropped branch-navigation event in the gap.
371+ val branchedMsg = stringResource(R.string.branch_created)
372+ LaunchedEffect(Unit) {
373+ vm.branchEvents.collect { newId ->
374+ showToast(shareContext, branchedMsg)
375+ onOpenSession?.invoke(newId)
376+ }
377+ }
378+
379+ // Stage images shared into the app (via the system share sheet) as attachments.
380+ // Keyed on pendingSharedMedia (not Unit) so the effect re-fires when new media arrives
381+ // while this ChatScreen is already composed — which happens in two-pane mode, where the
382+ // detail ChatScreen is persistent (keyed on sessionId) and a LaunchedEffect(Unit) would
383+ // only fire on first composition. consumePendingSharedMedia() atomically drains the
384+ // pending list (compareAndSet to empty), so re-firing on the now-empty value is a no-op.
385+ val pendingSharedMedia by container.pendingSharedMedia.collectAsStateWithLifecycle()
386+ LaunchedEffect(pendingSharedMedia) {
387+ val shared = container.consumePendingSharedMedia()
388+ if (shared.isNotEmpty()) stageUris(shared.map { Uri.parse(it) })
389+ }
390+
391+ fun doSend() {
392+ if (vm.send(draft)) {
393+ // TextHandleMove (a light tick) is semantically right for a send commit;
394+ // LongPress is reserved for long-press/swipe gestures.
395+ haptics.performHapticFeedback(androidx.compose.ui.hapticfeedback.HapticFeedbackType.TextHandleMove)
396+ }
397+ }
398+
399+ BackHandler(enabled = running && !showModelPicker && !showAgentPicker && !showCommandPicker) { showExitConfirm = true }
400+
401+ Scaffold(
402+ // Hardware-keyboard shortcuts (tablets / DeX / Chromebooks): Ctrl+K opens the command
403+ // palette; Escape closes it, or stops a run. onPreviewKeyEvent on the Scaffold root sees
404+ // events before the focused text field, but only Ctrl+K / Escape are consumed so normal
405+ // typing (and the composer's own Enter-to-send handling) is untouched.
406+ modifier = Modifier.onPreviewKeyEvent { ev ->
407+ if (ev.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
408+ when {
409+ ev.isCtrlPressed && ev.key == Key.K -> { showPalette = true; true }
410+ ev.key == Key.Escape && showPalette -> { showPalette = false; true }
411+ ev.key == Key.Escape && running && !showStopConfirm && !showExitConfirm -> {
412+ showStopConfirm = true; true
413+ }
414+ else -> false
415+ }
416+ },
417+ topBar = {
418+ TopAppBar(
419+ title = {
420+ val changeLabel = stringResource(R.string.change_model_agent)
421+ Row(
422+ modifier = Modifier
423+ .clickable(enabled = models.isNotEmpty(), role = Role.Button) { showModelPicker = true }
424+ .semantics(mergeDescendants = true) { contentDescription = changeLabel },
425+ verticalAlignment = Alignment.CenterVertically,
426+ ) {
427+ Column(modifier = Modifier.weight(1f, fill = false)) {
428+ // maxLines=1 + Ellipsis so a long session title can't wrap and
429+ // push the top bar to multiple lines, shifting the whole layout.
430+ Text(
431+ sessionTitle ?: sessionLabel,
432+ maxLines = 1,
433+ overflow = TextOverflow.Ellipsis,
434+ )
435+ Text(
436+ subtitle,
437+ style = MaterialTheme.typography.labelSmall,
438+ color = MaterialTheme.colorScheme.onSurfaceVariant,
439+ maxLines = 1,
440+ overflow = TextOverflow.Ellipsis,
441+ )
442+ }
443+ // Visual affordance that the title opens the model picker;
444+ // without it the tappable title is indistinguishable from plain
445+ // text and the picker is effectively undiscoverable.
446+ if (models.isNotEmpty()) {
447+ Icon(
448+ Icons.Filled.KeyboardArrowDown,
449+ contentDescription = null,
450+ tint = MaterialTheme.colorScheme.onSurfaceVariant,
451+ modifier = Modifier.size(20.dp),
452+ )
453+ }
454+ }
455+ },
456+ navigationIcon = {
457+ IconButton(onClick = {
458+ if (running) showExitConfirm = true else onBack()
459+ }) {
460+ Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = stringResource(R.string.back))
461+ }
462+ },
463+ actions = {
464+ // At-a-glance run status in the top bar. When the user is scrolled
465+ // up (jump-to-latest FAB visible), the input-bar Stop button and the
466+ // trailing "working…" row are off-screen, so a top-bar spinner is the
467+ // only signal the agent is still working.
468+ if (running) {
469+ val workingLabel = stringResource(R.string.working)
470+ CircularProgressIndicator(
471+ Modifier.size(18.dp).semantics { contentDescription = workingLabel },
472+ strokeWidth = 2.dp,
473+ )
474+ }
475+ // Manual refresh: forces an SSE reconnect, which re-seeds messages
476+ // from REST. A recovery path when the stream silently drops and the
477+ // auto-reconnect re-seed is slow or fails. Shows a brief spinner as
478+ // immediate tap feedback — the SSE reconnect may not visibly change
479+ // the connection state when already Connected, so without it the tap
480+ // appears to do nothing.
481+ val refreshLabel = stringResource(R.string.refresh)
482+ IconButton(
483+ onClick = { vm.refreshMessages() },
484+ enabled = activeConnection != null && !refreshing,
485+ ) {
486+ if (refreshing) {
487+ CircularProgressIndicator(
488+ Modifier.size(18.dp).semantics { contentDescription = refreshLabel },
489+ strokeWidth = 2.dp,
490+ )
491+ } else {
492+ Icon(Icons.Filled.Refresh, contentDescription = refreshLabel)
493+ }
494+ }
495+ // Overflow menu consolidates the less-frequent actions (share,
496+ // commands, agent, model, rename, delete) so the top bar stays
497+ // scannable on narrow phones — previously 5 icons crowded the bar
498+ // alongside the back button and tappable title. Catalog-loading
499+ // spinners stay inline (next to the overflow) so a load state is
500+ // visible without opening the menu.
501+ val moreLabel = stringResource(R.string.more)
502+ val loadingLabel = stringResource(R.string.loading)
503+ val shareLabel = stringResource(R.string.share_conversation)
504+ val commandsLabel = stringResource(R.string.commands)
505+ val agentLabel = stringResource(R.string.choose_agent)
506+ val modelLabel = stringResource(R.string.choose_model)
507+ val renameLabel = stringResource(R.string.rename_session_chat)
508+ val deleteLabel = stringResource(R.string.delete_session_chat)
509+ val createShareLabel = stringResource(R.string.create_share_link)
510+ val copyShareLabel = stringResource(R.string.copy_share_link)
511+ val stopShareLabel = stringResource(R.string.stop_sharing)
512+ val summarizeLabel = stringResource(R.string.summarize_conversation)
513+ val initLabel = stringResource(R.string.generate_agents_md)
514+ val shellLabel = stringResource(R.string.run_shell_command)
515+ Box {
516+ IconButton(onClick = { showOverflowMenu = true }) {
517+ Icon(Icons.Filled.MoreVert, contentDescription = moreLabel)
518+ }
519+ DropdownMenu(
520+ expanded = showOverflowMenu,
521+ onDismissRequest = { showOverflowMenu = false },
522+ ) {
523+ DropdownMenuItem(
524+ text = { Text(shareLabel) },
525+ enabled = hasMessages,
526+ onClick = {
527+ showOverflowMenu = false
528+ scope.launch {
529+ val md = withContext(Dispatchers.Default) {
530+ buildConversationMarkdown(vm.messages.value, sessionTitle)
531+ }
532+ val send = android.content.Intent(android.content.Intent.ACTION_SEND).apply {
533+ type = "text/markdown"
534+ putExtra(android.content.Intent.EXTRA_SUBJECT, sessionTitle ?: defaultShareSubject)
535+ putExtra(android.content.Intent.EXTRA_TEXT, md)
536+ }
537+ runCatchingCancellable { shareContext.startActivity(android.content.Intent.createChooser(send, shareLabel)) }
538+ .onFailure { showToast(shareContext, shareContext.getString(R.string.no_share_app)) }
539+ }
540+ },
541+ )
542+ DropdownMenuItem(
543+ text = { Text(commandsLabel) },
544+ enabled = !commandsLoading || commands.isNotEmpty(),
545+ onClick = { showOverflowMenu = false; showCommandPicker = true },
546+ )
547+ DropdownMenuItem(
548+ text = { Text(agentLabel) },
549+ enabled = !agentsLoading || agents.isNotEmpty(),
550+ onClick = { showOverflowMenu = false; showAgentPicker = true },
551+ )
552+ DropdownMenuItem(
553+ text = { Text(modelLabel) },
554+ enabled = !modelsLoading || models.isNotEmpty(),
555+ onClick = { showOverflowMenu = false; showModelPicker = true },
556+ )
557+ androidx.compose.material3.HorizontalDivider()
558+ // Session sharing: create a public link, copy an existing one, or revoke it.
559+ if (shareUrl == null) {
560+ DropdownMenuItem(
561+ text = { Text(createShareLabel) },
562+ enabled = hasMessages,
563+ onClick = { showOverflowMenu = false; vm.shareSession() },
564+ )
565+ } else {
566+ DropdownMenuItem(
567+ text = { Text(copyShareLabel) },
568+ onClick = {
569+ showOverflowMenu = false
570+ shareUrl?.let {
571+ copyToClipboard(shareContext, "share", it)
572+ scope.launch { snackbar.showSnackbar(linkCopiedMsg) }
573+ }
574+ },
575+ )
576+ DropdownMenuItem(
577+ text = { Text(stopShareLabel) },
578+ onClick = { showOverflowMenu = false; vm.unshareSession() },
579+ )
580+ }
581+ DropdownMenuItem(
582+ text = { Text(summarizeLabel) },
583+ enabled = hasMessages && !running,
584+ onClick = { showOverflowMenu = false; vm.summarize() },
585+ )
586+ DropdownMenuItem(
587+ text = { Text(initLabel) },
588+ enabled = !running,
589+ onClick = { showOverflowMenu = false; vm.initProject() },
590+ )
591+ DropdownMenuItem(
592+ text = { Text(shellLabel) },
593+ enabled = !running,
594+ onClick = { showOverflowMenu = false; showShellDialog = true },
595+ )
596+ androidx.compose.material3.HorizontalDivider()
597+ DropdownMenuItem(
598+ text = { Text(renameLabel) },
599+ onClick = { showOverflowMenu = false; showRenameDialog = true },
600+ )
601+ DropdownMenuItem(
602+ text = { Text(deleteLabel, color = MaterialTheme.colorScheme.error) },
603+ onClick = { showOverflowMenu = false; showDeleteDialog = true },
604+ )
605+ }
606+ // While a catalog is initially loading (empty list + loading flag),
607+ // show a tiny inline spinner beside the overflow so the user can see
608+ // a load is in progress without opening the menu. Once loaded the
609+ // spinner disappears; the menu items are always enabled (tapping a
610+ // picker with no items shows the "no models/agents/commands" state).
611+ val catalogLoading = (commandsLoading && commands.isEmpty()) ||
612+ (agentsLoading && agents.isEmpty()) ||
613+ (modelsLoading && models.isEmpty())
614+ if (catalogLoading) {
615+ CircularProgressIndicator(
616+ Modifier
617+ .align(Alignment.TopEnd)
618+ .size(10.dp)
619+ .semantics { contentDescription = loadingLabel },
620+ strokeWidth = 1.dp,
621+ )
622+ }
623+ }
624+ },
625+ )
626+ },
627+ snackbarHost = { SnackbarHost(snackbar) },
628+ bottomBar = {
629+ val queuedFollowUp by vm.queuedFollowUp.collectAsStateWithLifecycle()
630+ val todoPlan by vm.todoPlan.collectAsStateWithLifecycle()
631+ val queuedOffline by vm.outbox.collectAsStateWithLifecycle()
632+ val outboxSending by container.outboxSending.collectAsStateWithLifecycle()
633+ Column {
634+ // Pinned above the composer so the agent's plan and progress stay visible
635+ // while scrolled up mid-run; renders nothing when there's no plan.
636+ TodoPlanBar(todoPlan)
637+ AnimatedVisibility(visible = reverted) {
638+ RevertBanner(onUndo = { vm.unrevert() })
639+ }
640+ AnimatedVisibility(visible = queuedOffline.isNotEmpty()) {
641+ OutboxBanner(
642+ count = queuedOffline.size,
643+ sending = outboxSending,
644+ onFlush = { vm.flushQueued() },
645+ onDiscard = { vm.discardAllQueued() },
646+ )
647+ }
648+ ChatInputBar(
649+ value = draft,
650+ onValueChange = vm::updateDraft,
651+ running = running,
652+ aborting = aborting,
653+ enabled = activeConnection != null,
654+ sendOnEnter = sendOnEnter,
655+ onSend = ::doSend,
656+ onAbort = { showStopConfirm = true },
657+ queuedFollowUp = queuedFollowUp,
658+ onQueueFollowUp = vm::queueFollowUp,
659+ onCancelQueue = { vm.queueFollowUp("") },
660+ focusRequester = inputFocusRequester,
661+ attachments = attachments,
662+ onRemoveAttachment = vm::removeAttachment,
663+ onPickPhoto = {
664+ photoPicker.launch(
665+ PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly),
666+ )
667+ },
668+ onPickFile = { filePicker.launch("*/*") },
669+ onCamera = { launchCamera() },
670+ onVoice = { launchVoice() },
671+ )
672+ }
673+ },
674+ ) { padding ->
675+ // Collect messages inside the content lambda so streaming token updates
676+ // recompose only this subtree, not the top bar / input bar / 20+ other
677+ // state reads in the ChatScreen body.
678+ val messages by vm.messages.collectAsStateWithLifecycle()
679+ val listState = rememberLazyListState()
680+ val contentScope = rememberCoroutineScope()
681+ val timeTick = rememberRelativeTimeTick()
682+ // Group messages by day and interleave date separators so a long conversation
683+ // has visual "Today"/"Yesterday"/date breaks. Computed once per messages
684+ // emission (memoized) so a scroll-induced recomposition doesn't re-scan. Lives
685+ // outside the PullToRefreshBox so the auto-scroll effects below can reference
686+ // the same list the LazyColumn renders (separators shift the indices vs. the
687+ // raw messages list, so scroll targets must be in listItems space).
688+ val todayLabel = stringResource(R.string.today)
689+ val yesterdayLabel = stringResource(R.string.yesterday)
690+ val listItems = remember(messages, todayLabel, yesterdayLabel) {
691+ buildMessageListItems(messages, todayLabel, yesterdayLabel)
692+ }
693+ // listItems is a plain (non-snapshot) local, rebuilt each recomposition. The
694+ // derivedStateOf and snapshotFlow lambdas below are created once (keyless
695+ // remember / LaunchedEffect(Unit)); reading `listItems` directly inside them
696+ // would capture the first composition's list — which is empty, since `messages`
697+ // starts empty — freezing it forever. That pinned isPinnedToBottom at true and
698+ // AutoScrollSignal.size at 0, breaking streaming auto-scroll and the
699+ // jump-to-latest FAB. rememberUpdatedState hands those lambdas a stable State
700+ // whose value tracks the latest list.
701+ val currentListItems by rememberUpdatedState(listItems)
702+
703+ val isPinnedToBottom by remember {
704+ derivedStateOf {
705+ val lastVisible = listState.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: -1
706+ // When a run is active, the LazyColumn has one trailing "__typing"
707+ // item after the last list item. Account for it so "pinned to bottom"
708+ // includes the working indicator — otherwise the pin check targets
709+ // listItems.lastIndex, the typing row sits just below the viewport,
710+ // and the user never sees the progress indicator even when pinned.
711+ val items = currentListItems
712+ val effectiveLast = if (running) items.size else items.lastIndex
713+ lastVisible >= effectiveLast || items.isEmpty()
714+ }
715+ }
716+
717+ // Jump to the newest message once, when the conversation first loads. Guarded by a
718+ // saveable one-shot flag so it doesn't re-fire on recomposition after a config change
719+ // (rotation) — rememberLazyListState restores the user's scroll offset, and an
720+ // unconditional scrollToItem here would clobber it, snapping them back to the bottom.
721+ var didInitialScroll by rememberSaveable { mutableStateOf(false) }
722+ LaunchedEffect(listItems.isNotEmpty()) {
723+ if (listItems.isNotEmpty() && !didInitialScroll) {
724+ // When a run is active the LazyColumn has a trailing "__typing" row at
725+ // listItems.size; target it (not listItems.lastIndex) so deep-linking into a
726+ // running session lands truly pinned to bottom and streaming auto-scroll engages.
727+ listState.scrollToItem(if (running) listItems.size else listItems.lastIndex)
728+ didInitialScroll = true
729+ }
730+ }
731+
732+ // When a run starts, the LazyColumn gains a trailing "__typing" row, so
733+ // effectiveLast jumps from listItems.lastIndex to listItems.size and the
734+ // isPinnedToBottom check flips to false the instant you send — freezing
735+ // auto-scroll. If the user was pinned to the last item just before the run
736+ // began, bring the typing row into view so the pin (and streaming follow) is
737+ // preserved. Guard on the raw last-visible index (isPinnedToBottom has already
738+ // recomputed to false by now) so we don't scroll when the user had scrolled up.
739+ LaunchedEffect(running) {
740+ if (running && listItems.isNotEmpty()) {
741+ val lastVisible = listState.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: -1
742+ if (lastVisible >= listItems.lastIndex) {
743+ runCatchingCancellable { listState.animateScrollToItem(listItems.size) }
744+ }
745+ }
746+ }
747+
748+ LaunchedEffect(Unit) {
749+ snapshotFlow {
750+ // Track list size + the streaming length of the last part so we auto-scroll
751+ // as content arrives, plus the pinned flag. A small data class with primitive
752+ // fields avoids the per-frame boxing that Triple<Int,Int,Boolean> pays
753+ // (snapshotFlow re-evaluates this lambda every snapshot), and reading only the
754+ // last part's length is O(1) vs. a sumOf over every part. Covering reasoning
755+ // and tool output — not just TextPart — keeps a pinned view following a long
756+ // reasoning/tool block while it streams (previously it stalled at 0).
757+ val lastLen = streamingContentLength(messages.lastOrNull()?.parts?.lastOrNull())
758+ AutoScrollSignal(currentListItems.size, lastLen, isPinnedToBottom)
759+ }.collect { signal ->
760+ if (signal.size > 0 && signal.pinned) {
761+ // Scroll to the effective last index, including the trailing
762+ // "__typing" row when a run is active so the working indicator
763+ // is brought into view (not just the last message).
764+ val items = currentListItems
765+ val target = if (running) items.size else items.lastIndex
766+ listState.scrollToItem(target)
767+ }
768+ }
769+ }
770+
771+ CompositionLocalProvider(LocalRelativeTimeTick provides timeTick) {
772+ // The bottomBar (ChatInputBar) already has imePadding, and the Scaffold's
773+ // content padding accounts for the bottomBar's raised height, so the message
774+ // list is already above the keyboard. Adding imePadding here would double-apply
775+ // the IME inset and push messages too far up.
776+ Box(modifier = Modifier.fillMaxSize().padding(padding)) {
777+ if (activeConnection == null) {
778+ Column(
779+ modifier = Modifier.align(Alignment.Center).padding(24.dp),
780+ horizontalAlignment = Alignment.CenterHorizontally,
781+ ) {
782+ Text(
783+ stringResource(R.string.not_connected),
784+ color = MaterialTheme.colorScheme.error,
785+ )
786+ Spacer(Modifier.size(12.dp))
787+ Button(onClick = { vm.reconnect() }, enabled = !reconnecting) {
788+ if (reconnecting) {
789+ CircularProgressIndicator(
790+ Modifier.size(20.dp),
791+ color = MaterialTheme.colorScheme.onPrimary,
792+ strokeWidth = 2.dp,
793+ )
794+ } else {
795+ Text(stringResource(R.string.reconnect))
796+ }
797+ }
798+ }
799+ } else {
800+ ConnectionBanner(
801+ state = connectionState,
802+ modifier = Modifier.align(Alignment.TopCenter),
803+ isOnline = isOnline,
804+ // On a hard failure, retry by forcing an SSE reconnect (which
805+ // re-seeds from REST). refreshMessages is the right recovery path
806+ // when the connection is present but the stream died; reconnect()
807+ // is the path when the whole connection is gone (handled by the
808+ // separate "Not connected" state below).
809+ onRetry = { vm.refreshMessages() },
810+ )
811+ if (loading && messages.isEmpty()) {
812+ val loadingLabel = stringResource(R.string.loading)
813+ CircularProgressIndicator(
814+ Modifier
815+ .align(Alignment.Center)
816+ .semantics { contentDescription = loadingLabel },
817+ )
818+ } else if (loadError && messages.isEmpty()) {
819+ // A failed load with nothing to show. Distinct from the empty
820+ // conversation state below — the conversation isn't empty, it
821+ // failed to load, and offering "Start a conversation" here is
822+ // misleading. Offer a Retry instead, mirroring SessionListScreen.
823+ Column(
824+ modifier = Modifier.align(Alignment.Center).padding(24.dp),
825+ horizontalAlignment = Alignment.CenterHorizontally,
826+ ) {
827+ Text(
828+ stringResource(R.string.load_messages_failed),
829+ color = MaterialTheme.colorScheme.error,
830+ )
831+ Spacer(Modifier.size(12.dp))
832+ Button(onClick = { vm.refreshMessages() }) {
833+ Text(stringResource(R.string.retry))
834+ }
835+ }
836+ } else if (messages.isEmpty() && running) {
837+ // A run just started but no parts have arrived yet — the empty
838+ // list with only the trailing "working…" row looks broken, so
839+ // surface a clear starting state until the first part streams in.
840+ val workingText = stringResource(R.string.working)
841+ Column(
842+ modifier = Modifier.align(Alignment.Center).padding(24.dp),
843+ horizontalAlignment = Alignment.CenterHorizontally,
844+ ) {
845+ CircularProgressIndicator(Modifier.size(28.dp), strokeWidth = 3.dp)
846+ Spacer(Modifier.size(12.dp))
847+ Text(workingText, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
848+ }
849+ } else if (messages.isEmpty()) {
850+ EmptyConversation(
851+ onSuggestion = {
852+ vm.updateDraft(it)
853+ // Focus the input so the user can edit the suggestion before
854+ // sending, instead of having to manually tap the field.
855+ runCatching { inputFocusRequester.requestFocus() }
856+ },
857+ modifier = Modifier.align(Alignment.Center),
858+ )
859+ } else {
860+ // Pull-to-refresh wraps the message list so the user can force an SSE
861+ // reconnect + re-seed with the same gesture they use on the session and
862+ // file lists, instead of hunting for the top-bar refresh icon. The empty
863+ // / loading / error states above stay outside the PTR box since there's
864+ // no list content to pull against.
865+ PullToRefreshBox(
866+ isRefreshing = refreshing,
867+ onRefresh = { vm.refreshMessages() },
868+ modifier = Modifier.fillMaxSize(),
869+ ) {
870+ val lastMessageId = messages.lastOrNull()?.info?.id
871+ // Text-to-speech for reading assistant replies aloud; shuts down when the
872+ // message list leaves composition.
873+ val tts = rememberTtsController()
874+ val speakingMessageId by tts.speakingId
875+ LazyColumn(
876+ state = listState,
877+ modifier = Modifier.fillMaxSize(),
878+ contentPadding = PaddingValues(16.dp),
879+ verticalArrangement = Arrangement.spacedBy(16.dp),
880+ ) {
881+ items(
882+ items = listItems,
883+ key = { it.key },
884+ contentType = { it.contentType },
885+ ) { item ->
886+ when (item) {
887+ is MessageListItem.Separator -> DateSeparator(item.label)
888+ is MessageListItem.Message -> {
889+ val message = item.message
890+ // Only the last (streaming) message needs isRunning — it drives the
891+ // reasoning-block spinner. Passing the live flag to every bubble
892+ // makes all visible messages recompose whenever a run starts or stops.
893+ val modelLabel = remember(message.info, models) {
894+ (message.info as? soy.iko.opencode.data.model.AssistantMessage)
895+ ?.let { resolveModelLabel(it, models) }
896+ }
897+ MessageBubble(
898+ message,
899+ isRunning = running && message.info.id == lastMessageId,
900+ imageContext = imageContext,
901+ modelLabel = modelLabel,
902+ onOpenFile = onOpenFile,
903+ onRevert = { vm.revertTo(message.info.id) },
904+ onEdit = { text -> vm.editMessage(message.info.id, text) },
905+ onSpeak = { text -> tts.toggle(message.info.id, text) },
906+ isSpeaking = message.info.id == speakingMessageId,
907+ onQuote = { text ->
908+ vm.quoteReply(text)
909+ runCatching { inputFocusRequester.requestFocus() }
910+ },
911+ onBranch = { text -> vm.branchFrom(text) },
912+ )
913+ }
914+ }
915+ }
916+ if (running) {
917+ item(key = "__typing") {
918+ val workingText = stringResource(R.string.working)
919+ Row(
920+ verticalAlignment = Alignment.CenterVertically,
921+ modifier = Modifier.semantics {
922+ contentDescription = workingText
923+ },
924+ ) {
925+ CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
926+ Text(workingText, style = MaterialTheme.typography.labelMedium, modifier = Modifier.padding(start = 6.dp))
927+ }
928+ }
929+ }
930+ }
931+ }
932+ // Jump-to-latest affordance when the user has scrolled away during a stream.
933+ AnimatedVisibility(
934+ visible = !isPinnedToBottom && listItems.isNotEmpty(),
935+ modifier = Modifier.align(Alignment.BottomEnd),
936+ ) {
937+ ExtendedFloatingActionButton(
938+ onClick = {
939+ if (listItems.isNotEmpty()) {
940+ // Scroll to the effective last index, including the
941+ // trailing "__typing" row when a run is active.
942+ val target = if (running) listItems.size else listItems.lastIndex
943+ contentScope.launch { runCatchingCancellable { listState.animateScrollToItem(target) } }
944+ }
945+ },
946+ icon = { Icon(Icons.Filled.KeyboardArrowDown, contentDescription = stringResource(R.string.latest)) },
947+ text = { Text(stringResource(R.string.latest)) },
948+ modifier = Modifier.padding(end = 16.dp, bottom = 16.dp),
949+ )
950+ }
951+ }
952+ }
953+ }
954+ }
955+ }
956+
957+ if (showExitConfirm) {
958+ AlertDialog(
959+ onDismissRequest = { showExitConfirm = false },
960+ title = { Text(stringResource(R.string.stop_and_exit_title)) },
961+ text = { Text(stringResource(R.string.stop_and_exit_text)) },
962+ confirmButton = {
963+ TextButton(onClick = {
964+ showExitConfirm = false
965+ haptics.performHapticFeedback(androidx.compose.ui.hapticfeedback.HapticFeedbackType.TextHandleMove)
966+ vm.abort()
967+ onBack()
968+ }) { Text(stringResource(R.string.stop_and_exit)) }
969+ },
970+ dismissButton = {
971+ TextButton(onClick = { showExitConfirm = false }) { Text(stringResource(R.string.stay)) }
972+ },
973+ )
974+ }
975+
976+ if (showStopConfirm) {
977+ AlertDialog(
978+ onDismissRequest = { showStopConfirm = false },
979+ title = { Text(stringResource(R.string.stop_run_title)) },
980+ text = { Text(stringResource(R.string.stop_run_text)) },
981+ confirmButton = {
982+ TextButton(onClick = {
983+ showStopConfirm = false
984+ haptics.performHapticFeedback(androidx.compose.ui.hapticfeedback.HapticFeedbackType.TextHandleMove)
985+ vm.abort()
986+ }) { Text(stringResource(R.string.stop), color = MaterialTheme.colorScheme.error) }
987+ },
988+ dismissButton = {
989+ TextButton(onClick = { showStopConfirm = false }) { Text(stringResource(R.string.cancel)) }
990+ },
991+ )
992+ }
993+
994+ if (showRenameDialog) {
995+ RenameSessionChatDialog(
996+ initialTitle = sessionTitle ?: "",
997+ onDismiss = { showRenameDialog = false },
998+ onConfirm = { newName ->
999+ showRenameDialog = false
1000+ vm.renameSession(newName)
1001+ },
1002+ )
1003+ }
1004+
1005+ if (showDeleteDialog) {
1006+ AlertDialog(
1007+ onDismissRequest = { showDeleteDialog = false },
1008+ title = { Text(stringResource(R.string.delete_session_chat_title)) },
1009+ text = { Text(stringResource(R.string.delete_session_chat_text, sessionTitle ?: sessionLabel)) },
1010+ confirmButton = {
1011+ TextButton(onClick = {
1012+ showDeleteDialog = false
1013+ haptics.performHapticFeedback(androidx.compose.ui.hapticfeedback.HapticFeedbackType.LongPress)
1014+ vm.deleteSession()
1015+ }) { Text(stringResource(R.string.delete), color = MaterialTheme.colorScheme.error) }
1016+ },
1017+ dismissButton = {
1018+ TextButton(onClick = { showDeleteDialog = false }) { Text(stringResource(R.string.cancel)) }
1019+ },
1020+ )
1021+ }
1022+
1023+ if (showShellDialog) {
1024+ ShellCommandDialog(
1025+ onDismiss = { showShellDialog = false },
1026+ onRun = { cmd ->
1027+ showShellDialog = false
1028+ vm.runShell(cmd)
1029+ },
1030+ )
1031+ }
1032+
1033+ if (showModelPicker) {
1034+ ModelPickerSheet(
1035+ options = models,
1036+ selected = selectedModel,
1037+ loading = modelsLoading,
1038+ error = modelsError,
1039+ onSelect = { vm.selectModel(it) },
1040+ onRetry = { vm.reloadModels() },
1041+ onDismiss = { showModelPicker = false },
1042+ )
1043+ }
1044+
1045+ if (showAgentPicker) {
1046+ AgentPickerSheet(
1047+ agents = agents,
1048+ selected = selectedAgent,
1049+ loading = agentsLoading,
1050+ error = agentsError,
1051+ onSelect = { vm.selectAgent(it?.name) },
1052+ onRetry = { vm.reloadAgents() },
1053+ onDismiss = { showAgentPicker = false },
1054+ )
1055+ }
1056+
1057+ if (showCommandPicker) {
1058+ CommandPickerSheet(
1059+ commands = commands,
1060+ loading = commandsLoading,
1061+ error = commandsError,
1062+ onSelect = { vm.runCommand(it) },
1063+ onRetry = { vm.reloadCommands() },
1064+ onDismiss = { showCommandPicker = false },
1065+ )
1066+ }
1067+
1068+ pendingPermission?.let { permission ->
1069+ PermissionDialog(
1070+ permission = permission,
1071+ onRespond = { response -> vm.respondPermission(permission, response) },
1072+ )
1073+ }
1074+
1075+ if (showPalette) {
1076+ CommandPalette(actions = paletteActions, onDismiss = { showPalette = false })
1077+ }
1078+}
1079+
1080+@Composable
1081+private fun ChatInputBar(
1082+ value: String,
1083+ onValueChange: (String) -> Unit,
1084+ running: Boolean,
1085+ aborting: Boolean,
1086+ enabled: Boolean,
1087+ sendOnEnter: Boolean,
1088+ onSend: () -> Unit,
1089+ onAbort: () -> Unit,
1090+ queuedFollowUp: String?,
1091+ onQueueFollowUp: (String) -> Unit,
1092+ onCancelQueue: () -> Unit,
1093+ focusRequester: androidx.compose.ui.focus.FocusRequester,
1094+ attachments: List<PendingAttachment>,
1095+ onRemoveAttachment: (String) -> Unit,
1096+ onPickPhoto: () -> Unit,
1097+ onPickFile: () -> Unit,
1098+ onCamera: () -> Unit,
1099+ onVoice: () -> Unit,
1100+) {
1101+ // Sendable when there's text OR at least one attachment (an image-only prompt is valid).
1102+ val hasContent = value.isNotBlank() || attachments.isNotEmpty()
1103+ Surface(tonalElevation = 3.dp, modifier = Modifier.imePadding()) {
1104+ Column(modifier = Modifier.fillMaxWidth().windowInsetsPadding(WindowInsets.navigationBars)) {
1105+ // A queued follow-up replaces the Stop button with a "queued" chip so the
1106+ // user sees their message will be sent when the run finishes, and can cancel.
1107+ if (queuedFollowUp != null) {
1108+ Row(
1109+ modifier = Modifier
1110+ .fillMaxWidth()
1111+ .padding(start = 12.dp, top = 6.dp, end = 4.dp),
1112+ verticalAlignment = Alignment.CenterVertically,
1113+ ) {
1114+ Column(modifier = Modifier.weight(1f)) {
1115+ Text(
1116+ stringResource(R.string.queued),
1117+ style = MaterialTheme.typography.labelSmall,
1118+ color = MaterialTheme.colorScheme.onSurfaceVariant,
1119+ )
1120+ Text(
1121+ queuedFollowUp,
1122+ style = MaterialTheme.typography.bodySmall,
1123+ color = MaterialTheme.colorScheme.onSurfaceVariant,
1124+ maxLines = 1,
1125+ overflow = TextOverflow.Ellipsis,
1126+ )
1127+ }
1128+ TextButton(onClick = onCancelQueue, contentPadding = androidx.compose.foundation.layout.PaddingValues(horizontal = 8.dp)) {
1129+ Text(stringResource(R.string.cancel))
1130+ }
1131+ }
1132+ }
1133+ // Staged attachments: horizontally-scrollable thumbnails/chips, each removable.
1134+ AttachmentStrip(attachments, onRemove = onRemoveAttachment)
1135+ Row(
1136+ modifier = Modifier.fillMaxWidth().padding(8.dp),
1137+ verticalAlignment = Alignment.Bottom,
1138+ ) {
1139+ // Attach menu: photo picker, camera, or any file.
1140+ var showAttachMenu by remember { mutableStateOf(false) }
1141+ Box {
1142+ IconButton(onClick = { showAttachMenu = true }, enabled = enabled) {
1143+ Icon(Icons.Filled.Add, contentDescription = stringResource(R.string.add_attachment))
1144+ }
1145+ DropdownMenu(expanded = showAttachMenu, onDismissRequest = { showAttachMenu = false }) {
1146+ DropdownMenuItem(
1147+ leadingIcon = { Icon(Icons.Filled.PhotoLibrary, contentDescription = null) },
1148+ text = { Text(stringResource(R.string.attach_photo)) },
1149+ onClick = { showAttachMenu = false; onPickPhoto() },
1150+ )
1151+ DropdownMenuItem(
1152+ leadingIcon = { Icon(Icons.Filled.PhotoCamera, contentDescription = null) },
1153+ text = { Text(stringResource(R.string.attach_camera)) },
1154+ onClick = { showAttachMenu = false; onCamera() },
1155+ )
1156+ DropdownMenuItem(
1157+ leadingIcon = { Icon(Icons.Filled.Description, contentDescription = null) },
1158+ text = { Text(stringResource(R.string.attach_file)) },
1159+ onClick = { showAttachMenu = false; onPickFile() },
1160+ )
1161+ }
1162+ }
1163+ // Voice dictation: appends recognized speech to the draft.
1164+ IconButton(onClick = onVoice, enabled = enabled) {
1165+ Icon(Icons.Filled.Mic, contentDescription = stringResource(R.string.voice_input))
1166+ }
1167+ OutlinedTextField(
1168+ value = value,
1169+ onValueChange = { v ->
1170+ // Cap input length so a huge paste can't stall the UI. Shares are
1171+ // capped separately in MainActivity; this guards typed/pasted drafts.
1172+ onValueChange(v.take(NetworkConfig.maxDraftLengthChars))
1173+ },
1174+ modifier = Modifier
1175+ .weight(1f)
1176+ .focusRequester(focusRequester)
1177+ .testTag("chat_input")
1178+ .onPreviewKeyEvent { event ->
1179+ if (event.type != KeyEventType.KeyDown || event.key != Key.Enter) return@onPreviewKeyEvent false
1180+ // With "Send on Enter" on, Enter sends (Shift+Enter newlines).
1181+ // With it off, Enter inserts a newline and Ctrl+Enter sends.
1182+ val send = enterShouldSend(
1183+ enabled = enabled,
1184+ hasContent = hasContent,
1185+ sendOnEnter = sendOnEnter,
1186+ shift = event.isShiftPressed,
1187+ ctrl = event.isCtrlPressed,
1188+ )
1189+ if (send) {
1190+ if (running) onQueueFollowUp(value) else onSend()
1191+ true
1192+ } else {
1193+ false
1194+ }
1195+ },
1196+ placeholder = { Text(stringResource(R.string.message_placeholder)) },
1197+ enabled = enabled,
1198+ maxLines = 6,
1199+ // Show a "N / max" countdown once the draft crosses a high fraction of
1200+ // the cap, so the user knows a paste is about to be truncated instead
1201+ // of being silently cut off. Hidden for normal short prompts to avoid
1202+ // clutter under a typical one-line message.
1203+ supportingText = {
1204+ val threshold = (NetworkConfig.maxDraftLengthChars * NetworkConfig.draftCountdownThresholdFraction).toInt()
1205+ if (value.length >= threshold) {
1206+ Text(
1207+ stringResource(
1208+ R.string.draft_chars_remaining,
1209+ NetworkConfig.maxDraftLengthChars - value.length,
1210+ NetworkConfig.maxDraftLengthChars,
1211+ ),
1212+ style = MaterialTheme.typography.labelSmall,
1213+ color = if (value.length >= NetworkConfig.maxDraftLengthChars) MaterialTheme.colorScheme.error
1214+ else MaterialTheme.colorScheme.onSurfaceVariant,
1215+ )
1216+ }
1217+ },
1218+ keyboardOptions = KeyboardOptions(
1219+ // With send-on-Enter off, expose the platform default action so the soft
1220+ // keyboard shows a newline key (this is a multi-line field) instead of a
1221+ // Send action — otherwise the setting has no effect on soft keyboards and
1222+ // there's no way to type a newline. Hardware Enter is handled separately.
1223+ imeAction = if (sendOnEnter) ImeAction.Send else ImeAction.Default,
1224+ capitalization = KeyboardCapitalization.Sentences,
1225+ ),
1226+ keyboardActions = KeyboardActions(onSend = {
1227+ if (enabled) {
1228+ // During a run the Send IME action queues a follow-up, but only when
1229+ // there's typed text — queuing "" would cancel an existing queued
1230+ // follow-up (see the Queue button gate). When not running, an
1231+ // attachment-only send is valid, so gate that path on hasContent.
1232+ if (running) {
1233+ if (value.isNotBlank()) onQueueFollowUp(value)
1234+ } else if (hasContent) {
1235+ onSend()
1236+ }
1237+ }
1238+ }),
1239+ )
1240+ ComposerTrailingButton(
1241+ running = running,
1242+ aborting = aborting,
1243+ canSend = enabled && hasContent,
1244+ canQueue = enabled && value.isNotBlank(),
1245+ onSend = onSend,
1246+ onAbort = onAbort,
1247+ onQueue = { onQueueFollowUp(value) },
1248+ )
1249+ }
1250+ }
1251+ }
1252+}
1253+
1254+/** Whether a hardware Enter keypress should send: never when disabled/empty; otherwise
1255+ * Enter sends (unless Shift) when send-on-Enter is on, else only Ctrl+Enter sends. */
1256+private fun enterShouldSend(
1257+ enabled: Boolean,
1258+ hasContent: Boolean,
1259+ sendOnEnter: Boolean,
1260+ shift: Boolean,
1261+ ctrl: Boolean,
1262+): Boolean = when {
1263+ !enabled || !hasContent -> false
1264+ sendOnEnter -> !shift
1265+ else -> ctrl
1266+}
1267+
1268+/** The composer's trailing button: while a run is active a Stop (with in-flight spinner),
1269+ * preceded by a Queue button when the user has typed a follow-up; otherwise Send. Extracted so
1270+ * [ChatInputBar] stays under the complexity threshold. */
1271+@Composable
1272+private fun ComposerTrailingButton(
1273+ running: Boolean,
1274+ aborting: Boolean,
1275+ canSend: Boolean,
1276+ canQueue: Boolean,
1277+ onSend: () -> Unit,
1278+ onAbort: () -> Unit,
1279+ onQueue: () -> Unit,
1280+) {
1281+ if (running) {
1282+ Row(verticalAlignment = Alignment.CenterVertically) {
1283+ // While a run is active the trailing action is Stop, so the only send affordance is
1284+ // the keyboard's IME action — which is a plain newline when "Send on Enter" is off.
1285+ // That leaves a touch-only user with the setting off no way to queue a follow-up
1286+ // (Ctrl+Enter needs a hardware keyboard). Surface an explicit Queue button whenever
1287+ // there's typed TEXT so queuing is always reachable, without changing the user's
1288+ // Enter-inserts-a-newline preference. Gate on typed text — not the send-oriented
1289+ // canSend, which is also true for an attachment-only composer — because queuing "" just
1290+ // calls setQueuedFollowUp(null), silently cancelling any already-queued follow-up and
1291+ // dropping the staged attachment (queued follow-ups don't carry attachments anyway).
1292+ if (canQueue) {
1293+ IconButton(
1294+ onClick = onQueue,
1295+ modifier = Modifier.testTag("queue_button"),
1296+ ) {
1297+ Icon(
1298+ Icons.AutoMirrored.Filled.Send,
1299+ contentDescription = stringResource(R.string.queue_followup),
1300+ )
1301+ }
1302+ }
1303+ // Show a spinner while the abort REST call is in flight so the user sees the stop
1304+ // was sent, and disable to prevent a double-tap.
1305+ IconButton(
1306+ onClick = onAbort,
1307+ enabled = !aborting,
1308+ modifier = Modifier.padding(start = 4.dp).testTag("stop_button"),
1309+ ) {
1310+ if (aborting) {
1311+ val stopLabel = stringResource(R.string.stop)
1312+ CircularProgressIndicator(
1313+ Modifier.size(18.dp).semantics { contentDescription = stopLabel },
1314+ strokeWidth = 2.dp,
1315+ )
1316+ } else {
1317+ Icon(Icons.Filled.Stop, contentDescription = stringResource(R.string.stop))
1318+ }
1319+ }
1320+ }
1321+ } else {
1322+ IconButton(
1323+ onClick = onSend,
1324+ enabled = canSend,
1325+ modifier = Modifier.padding(start = 4.dp).testTag("send_button"),
1326+ ) {
1327+ Icon(Icons.AutoMirrored.Filled.Send, contentDescription = stringResource(R.string.send))
1328+ }
1329+ }
1330+}
1331+
1332+@OptIn(androidx.compose.foundation.layout.ExperimentalLayoutApi::class)
1333+@Composable
1334+private fun EmptyConversation(
1335+ onSuggestion: (String) -> Unit,
1336+ modifier: Modifier = Modifier,
1337+) {
1338+ // A few example prompts so a first-time user has a one-tap path to their first
1339+ // message instead of staring at a blank input. Tapping a chip fills the draft
1340+ // (without sending) so the user can edit it before sending.
1341+ val suggestions = remember {
1342+ listOf(
1343+ R.string.empty_chat_suggest_1,
1344+ R.string.empty_chat_suggest_2,
1345+ R.string.empty_chat_suggest_3,
1346+ )
1347+ }
1348+ Column(
1349+ modifier = modifier.padding(32.dp),
1350+ horizontalAlignment = Alignment.CenterHorizontally,
1351+ ) {
1352+ Icon(
1353+ Icons.Filled.AutoAwesome,
1354+ contentDescription = null,
1355+ modifier = Modifier.size(48.dp),
1356+ tint = MaterialTheme.colorScheme.onSurfaceVariant,
1357+ )
1358+ Spacer(Modifier.size(16.dp))
1359+ Text(
1360+ stringResource(R.string.empty_chat_title),
1361+ style = MaterialTheme.typography.titleMedium,
1362+ )
1363+ Spacer(Modifier.size(8.dp))
1364+ Text(
1365+ stringResource(R.string.empty_chat_hint),
1366+ style = MaterialTheme.typography.bodyMedium,
1367+ color = MaterialTheme.colorScheme.onSurfaceVariant,
1368+ )
1369+ Spacer(Modifier.size(20.dp))
1370+ // Suggestion chips wrap across rows on narrow screens instead of stacking full-width,
1371+ // so a longer localized prompt doesn't push the chips off-screen on a phone.
1372+ FlowRow(
1373+ modifier = Modifier.fillMaxWidth(),
1374+ horizontalArrangement = Arrangement.spacedBy(8.dp),
1375+ verticalArrangement = Arrangement.spacedBy(8.dp),
1376+ ) {
1377+ suggestions.forEach { resId ->
1378+ val text = stringResource(resId)
1379+ androidx.compose.material3.AssistChip(
1380+ onClick = { onSuggestion(text) },
1381+ label = { Text(text, style = MaterialTheme.typography.bodyMedium) },
1382+ )
1383+ }
1384+ }
1385+ }
1386+}
1387+
1388+/** A banner shown while a revert checkpoint is active, offering an Undo (unrevert). */
1389+@Composable
1390+private fun RevertBanner(onUndo: () -> Unit) {
1391+ Surface(
1392+ color = MaterialTheme.colorScheme.tertiaryContainer,
1393+ tonalElevation = 2.dp,
1394+ modifier = Modifier.fillMaxWidth(),
1395+ ) {
1396+ Row(
1397+ modifier = Modifier.fillMaxWidth().padding(start = 12.dp, end = 4.dp, top = 4.dp, bottom = 4.dp),
1398+ verticalAlignment = Alignment.CenterVertically,
1399+ horizontalArrangement = Arrangement.SpaceBetween,
1400+ ) {
1401+ Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.weight(1f)) {
1402+ Icon(
1403+ Icons.Filled.Restore,
1404+ contentDescription = null,
1405+ tint = MaterialTheme.colorScheme.onTertiaryContainer,
1406+ modifier = Modifier.size(18.dp),
1407+ )
1408+ Text(
1409+ stringResource(R.string.reverted_banner),
1410+ style = MaterialTheme.typography.bodySmall,
1411+ color = MaterialTheme.colorScheme.onTertiaryContainer,
1412+ modifier = Modifier.padding(start = 8.dp),
1413+ )
1414+ }
1415+ TextButton(onClick = onUndo) { Text(stringResource(R.string.undo)) }
1416+ }
1417+ }
1418+}
1419+
1420+/** A banner shown while messages composed offline are queued in the outbox, with a
1421+ * "Send now" nudge and a discard. Shows a spinner while the queue is flushing. */
1422+@Composable
1423+private fun OutboxBanner(
1424+ count: Int,
1425+ sending: Boolean,
1426+ onFlush: () -> Unit,
1427+ onDiscard: () -> Unit,
1428+) {
1429+ Surface(
1430+ color = MaterialTheme.colorScheme.secondaryContainer,
1431+ tonalElevation = 2.dp,
1432+ modifier = Modifier.fillMaxWidth(),
1433+ ) {
1434+ Row(
1435+ modifier = Modifier.fillMaxWidth().padding(start = 12.dp, end = 4.dp, top = 4.dp, bottom = 4.dp),
1436+ verticalAlignment = Alignment.CenterVertically,
1437+ horizontalArrangement = Arrangement.SpaceBetween,
1438+ ) {
1439+ Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.weight(1f)) {
1440+ if (sending) {
1441+ CircularProgressIndicator(
1442+ Modifier.size(16.dp),
1443+ strokeWidth = 2.dp,
1444+ color = MaterialTheme.colorScheme.onSecondaryContainer,
1445+ )
1446+ Spacer(Modifier.size(8.dp))
1447+ }
1448+ Text(
1449+ if (sending) {
1450+ stringResource(R.string.outbox_sending)
1451+ } else {
1452+ val res = if (count == 1) R.string.outbox_pending_one else R.string.outbox_pending_many
1453+ stringResource(res, count)
1454+ },
1455+ style = MaterialTheme.typography.bodySmall,
1456+ color = MaterialTheme.colorScheme.onSecondaryContainer,
1457+ )
1458+ }
1459+ if (!sending) {
1460+ TextButton(onClick = onFlush) { Text(stringResource(R.string.outbox_flush)) }
1461+ TextButton(onClick = onDiscard) {
1462+ Text(stringResource(R.string.outbox_discard_all), color = MaterialTheme.colorScheme.error)
1463+ }
1464+ }
1465+ }
1466+ }
1467+}
1468+
1469+/** Prompt for a one-off shell command to run in the session's worktree. */
1470+@Composable
1471+private fun ShellCommandDialog(onDismiss: () -> Unit, onRun: (String) -> Unit) {
1472+ var command by rememberSaveable { mutableStateOf("") }
1473+ AlertDialog(
1474+ onDismissRequest = onDismiss,
1475+ title = { Text(stringResource(R.string.run_shell_command)) },
1476+ text = {
1477+ OutlinedTextField(
1478+ value = command,
1479+ onValueChange = { command = it },
1480+ modifier = Modifier.fillMaxWidth(),
1481+ placeholder = { Text(stringResource(R.string.shell_command_hint)) },
1482+ label = { Text(stringResource(R.string.shell_command_label)) },
1483+ singleLine = true,
1484+ keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
1485+ keyboardActions = KeyboardActions(onDone = { if (command.isNotBlank()) onRun(command.trim()) }),
1486+ )
1487+ },
1488+ confirmButton = {
1489+ TextButton(
1490+ onClick = { if (command.isNotBlank()) onRun(command.trim()) },
1491+ enabled = command.isNotBlank(),
1492+ ) { Text(stringResource(R.string.run)) }
1493+ },
1494+ dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.cancel)) } },
1495+ )
1496+}
1497+
1498+/**
1499+ * Change signal for the auto-scroll-on-stream watcher. Primitive fields avoid the
1500+ * boxing `Triple<Int, Int, Boolean>` would impose on every snapshot evaluation, and
1501+ * equality is structural so `snapshotFlow` emits only when something relevant changes.
1502+ */
1503+private data class AutoScrollSignal(val size: Int, val lastTextLength: Int, val pinned: Boolean)
1504+
1505+/** Length of the streaming content carried by [part], driving auto-scroll as it grows.
1506+ * Covers text, reasoning, and tool output so a pinned view keeps following non-text
1507+ * streaming, not just plain assistant text. O(1). */
1508+private fun streamingContentLength(part: Part?): Int = when (part) {
1509+ is TextPart -> part.text.length
1510+ is ReasoningPart -> part.text.length
1511+ is ToolPart -> when (val st = part.state) {
1512+ is ToolCompleted -> st.output?.length ?: 0
1513+ is ToolError -> st.error?.length ?: 0
1514+ is ToolRunning -> st.title?.length ?: 0
1515+ else -> 0
1516+ }
1517+ else -> 0
1518+}
1519+
1520+/** Rename dialog for the currently-open session. Mirrors the SessionListScreen rename
1521+ * dialog but lives in the chat screen so the user can rename without backing out to
1522+ * the list. Pre-filled with the current title; the cap matches the list dialog. */
1523+@Composable
1524+private fun RenameSessionChatDialog(
1525+ initialTitle: String,
1526+ onDismiss: () -> Unit,
1527+ onConfirm: (String) -> Unit,
1528+) {
1529+ // Seed the field once (no key input) so a later external title change — e.g. opencode
1530+ // auto-generating a session title after the first prompt, arriving via SessionUpdated —
1531+ // doesn't re-initialize the box and discard the user's in-progress edit.
1532+ var title by rememberSaveable { mutableStateOf(initialTitle) }
1533+ AlertDialog(
1534+ onDismissRequest = onDismiss,
1535+ title = { Text(stringResource(R.string.rename_session_chat)) },
1536+ text = {
1537+ OutlinedTextField(
1538+ value = title,
1539+ onValueChange = { v -> title = v.take(NetworkConfig.maxSessionTitleChars) },
1540+ modifier = Modifier.fillMaxWidth(),
1541+ placeholder = { Text(stringResource(R.string.session_title_hint)) },
1542+ label = { Text(stringResource(R.string.rename_session_chat)) },
1543+ singleLine = true,
1544+ keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
1545+ keyboardActions = KeyboardActions(onDone = { if (title.isNotBlank()) onConfirm(title.trim()) }),
1546+ )
1547+ },
1548+ confirmButton = {
1549+ TextButton(onClick = { if (title.isNotBlank()) onConfirm(title.trim()) }, enabled = title.isNotBlank()) {
1550+ Text(stringResource(R.string.save))
1551+ }
1552+ },
1553+ dismissButton = {
1554+ TextButton(onClick = onDismiss) { Text(stringResource(R.string.cancel)) }
1555+ },
1556+ )
1557+}
1558+
1559+/**
1560+ * A single item in the chat message list — either a [Message] bubble or a day
1561+ * [Separator] inserted before the first message of a new day. The separator shifts
1562+ * the LazyColumn indices vs. the raw messages list, so scroll-target math must use
1563+ * the [List] of these items (not `messages.size`/`lastIndex`).
1564+ */
1565+private sealed interface MessageListItem {
1566+ val key: Any
1567+ val contentType: Any
1568+
1569+ data class Message(val message: MessageWithParts, override val key: Any) : MessageListItem {
1570+ override val contentType: Any get() = message.info::class
1571+ }
1572+
1573+ data class Separator(val label: String, val ordinal: Int) : MessageListItem {
1574+ // Key on the day-occurrence ordinal, not the label: two non-contiguous groups
1575+ // can share a label (e.g. an untimestamped message — empty label — between two
1576+ // same-day messages, or two untimestamped groups), and a label-only key would
1577+ // then collide, which makes LazyColumn throw on duplicate keys. The ordinal is
1578+ // stable for a given message ordering so slots aren't needlessly recreated.
1579+ override val key: Any get() = "sep_${ordinal}_$label"
1580+ // Separators share a contentType so the LazyColumn can recycle their slots.
1581+ override val contentType: Any get() = "separator"
1582+ }
1583+}
1584+
1585+/**
1586+ * Build the interleaved list of [MessageListItem]s for the message list, inserting a
1587+ * [MessageListItem.Separator] before the first message of each new calendar day. Uses
1588+ * the message's `time.created` (falling back to `updated` then `completed`) to bucket.
1589+ * Messages with no timestamp are grouped under an empty-label separator only if they
1590+ * start the list, so a server that omits timestamps doesn't suppress the first divider.
1591+ *
1592+ * [todayLabel]/[yesterdayLabel] are resolved by the caller (a @Composable can't call
1593+ * stringResource from inside this plain function) and used for the "Today"/"Yesterday"
1594+ * labels; older days fall back to a locale-stable medium-date format.
1595+ */
1596+private fun buildMessageListItems(
1597+ messages: List<MessageWithParts>,
1598+ todayLabel: String,
1599+ yesterdayLabel: String,
1600+): List<MessageListItem> {
1601+ if (messages.isEmpty()) return emptyList()
1602+ val today = java.time.LocalDate.now(java.time.ZoneId.systemDefault())
1603+ val dateFmt = mediumDateFormat()
1604+ val result = ArrayList<MessageListItem>(messages.size + 4)
1605+ val seenKeys = HashSet<String>(messages.size * 2)
1606+ var lastDayKey: String? = null
1607+ var sepOrdinal = 0
1608+ var emptyIdOrdinal = 0
1609+ var first = true
1610+ for (message in messages) {
1611+ val ts = message.info.time?.created ?: message.info.time?.updated ?: message.info.time?.completed
1612+ val dayKey = ts?.let { dayKey(it) } ?: ""
1613+ // Emit a separator before the very first message (so a leading un-timestamped message
1614+ // still gets the first divider, empty label and all), and thereafter only when crossing
1615+ // into a new NON-empty calendar day. An un-timestamped message mid-list (empty key)
1616+ // neither emits its own separator nor resets the day — otherwise a following same-day
1617+ // message would see a "" -> "<today>" transition and emit a duplicate "Today" header.
1618+ if (first || (dayKey.isNotEmpty() && dayKey != lastDayKey)) {
1619+ result.add(MessageListItem.Separator(dayLabel(dayKey, ts ?: 0L, today, todayLabel, yesterdayLabel, dateFmt), sepOrdinal++))
1620+ }
1621+ if (dayKey.isNotEmpty()) lastDayKey = dayKey
1622+ first = false
1623+ // Most messages have a unique non-empty id. An unrecognized-role message can carry an
1624+ // empty id — and the reducer intentionally keeps several such messages as distinct
1625+ // holders — so give each a stable synthetic key and defensively de-collide any remaining
1626+ // duplicate; otherwise LazyColumn throws on a duplicate key and the whole screen crashes.
1627+ var key = message.info.id.ifEmpty { "msg-empty-${emptyIdOrdinal++}" }
1628+ if (!seenKeys.add(key)) {
1629+ var suffix = 1
1630+ while (!seenKeys.add("$key#$suffix")) suffix++
1631+ key = "$key#$suffix"
1632+ }
1633+ result.add(MessageListItem.Message(message, key))
1634+ }
1635+ return result
1636+}
1637+
1638+/**
1639+ * A stable bucket key for a timestamp's calendar day (epoch-days as a string).
1640+ *
1641+ * [buildMessageListItems] re-runs on every streaming snapshot (the memo is keyed on the
1642+ * whole `messages` list, which must stay so the live message's fresh parts render), so a
1643+ * naive implementation would re-allocate an `Instant`/`ZonedDateTime`/`LocalDate` for
1644+ * every message on every token. Message timestamps are immutable once assigned, so we
1645+ * memoize the parse per epoch-millis: after the first snapshot, each unchanged message is
1646+ * a cheap hash lookup. Bounded LRU (access-order) caps memory; only touched on the main
1647+ * thread during composition, so the coarse lock is uncontended.
1648+ */
1649+private val dayKeyCache = object : LinkedHashMap<Long, String>(128, 0.75f, true) {
1650+ override fun removeEldestEntry(eldest: MutableMap.MutableEntry<Long, String>): Boolean = size > 1024
1651+}
1652+
1653+private fun dayKey(epochMillis: Long): String = synchronized(dayKeyCache) {
1654+ dayKeyCache.getOrPut(epochMillis) {
1655+ java.time.Instant.ofEpochMilli(epochMillis)
1656+ .atZone(java.time.ZoneId.systemDefault()).toLocalDate().toEpochDay().toString()
1657+ }
1658+}
1659+
1660+// The medium-date formatter is an ICU locale lookup; cache one instance instead of
1661+// allocating a fresh one per buildMessageListItems call, rebuilding only if the default
1662+// locale changes at runtime. Main-thread-only, so no synchronization is needed.
1663+private var cachedDateFmt: java.text.DateFormat? = null
1664+private var cachedDateFmtLocale: java.util.Locale? = null
1665+
1666+private fun mediumDateFormat(): java.text.DateFormat {
1667+ val locale = java.util.Locale.getDefault()
1668+ val existing = cachedDateFmt
1669+ if (existing != null && cachedDateFmtLocale == locale) return existing
1670+ return java.text.DateFormat.getDateInstance(java.text.DateFormat.MEDIUM).also {
1671+ cachedDateFmt = it
1672+ cachedDateFmtLocale = locale
1673+ }
1674+}
1675+
1676+/**
1677+ * Resolve a day-key back to a human-readable label. "Today" / "Yesterday" for the
1678+ * recent days, otherwise a locale-stable medium-date format. Returns an empty string
1679+ * when [dayKey] is empty (no timestamp) so no separator is rendered for un-timestamped
1680+ * messages.
1681+ */
1682+private fun dayLabel(
1683+ dayKey: String,
1684+ ts: Long,
1685+ today: java.time.LocalDate,
1686+ todayLabel: String,
1687+ yesterdayLabel: String,
1688+ dateFmt: java.text.DateFormat,
1689+): String {
1690+ if (dayKey.isEmpty()) return ""
1691+ val epochDay = dayKey.toLongOrNull() ?: return ""
1692+ val date = java.time.LocalDate.ofEpochDay(epochDay)
1693+ return when {
1694+ date == today -> todayLabel
1695+ date == today.minusDays(1) -> yesterdayLabel
1696+ else -> dateFmt.format(java.util.Date(ts))
1697+ }
1698+}
1699+
1700+/**
1701+ * A centered day divider in the message list. Renders nothing for an empty label
1702+ * (the no-timestamp case) so un-timestamped messages don't get a stray blank divider.
1703+ */
1704+@Composable
1705+private fun DateSeparator(label: String) {
1706+ if (label.isBlank()) return
1707+ Row(
1708+ modifier = Modifier.fillMaxWidth(),
1709+ horizontalArrangement = Arrangement.Center,
1710+ ) {
1711+ Surface(
1712+ color = MaterialTheme.colorScheme.surfaceVariant,
1713+ shape = MaterialTheme.shapes.small,
1714+ ) {
1715+ Text(
1716+ label,
1717+ style = MaterialTheme.typography.labelSmall,
1718+ color = MaterialTheme.colorScheme.onSurfaceVariant,
1719+ modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp),
1720+ )
1721+ }
1722+ }
1723+}