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