Add the Chat destination and hold several conversations at once

Entry point: the floating destination pill gains a Chat icon between Runs and
Settings; it stays a single non-wrapping Row of 48dp targets using the named
DESTINATION_ITEM_SIZE/DESTINATION_ITEM_GAP tokens, clear of the existing 88dp
reserve, so it stays narrow however many destinations it holds.

Protocol/transport: new data/protocol/Chat.kt mirrors the brokered chat wire
shapes; Message gains the optional chat_* payloads, PipelinesClient forwards
unsolicited frames (chat_event/chat_permission) to a new events flow instead of
dropping them, and PipelinesRepository exposes the typed chat calls (sessions,
create, messages, prompt, interrupt, reply).

State: ui/chat/ChatStore.kt is an Android-free multi-chat holder; every open
chat keeps its own conversation, running flag, composer draft and scroll
position, open/activate report when history must be re-synced so a running
session refreshes on return instead of showing a stale copy, and busy/read-only
sessions refuse writes.

Surface: ui/chat/ChatScreen.kt lists the server's sessions with running/busy/
read-only status and an open-chat strip to switch between conversations (chip X
closes only that chat); the conversation is a bottom-anchored transcript of user
bubbles, reasoning, assistant text and tool-call chips that expand to INPUT
(pretty JSON)/OUTPUT (monospace), edit-family calls render a diff card derived
from oldString/newString, and pending chat_permission frames surface an approval
bar answered via chat_reply. New chat creates and opens a session. The manifest
sets windowSoftInputMode=adjustResize for the composer.

Tests: ChatProtocolTest, ChatFormatTest and MultiChatStateTest cover the wire
shapes, formatting and the multi-chat model (switching preserves each
conversation, a running session re-syncs on return, per-chat drafts/scroll,
busy read-only, background events land on their chat). README documents the
slice and its evidence.
This commit is contained in:
2026-10-16 12:43:37 +01:00
parent e5bde981ee
commit 0718f5ba6f
14 changed files with 2392 additions and 5 deletions
+132
View File
@@ -2227,3 +2227,135 @@ native 2208x1840 @420 at the end.
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17928873`.
## Chat destination and multiple conversations (16 Oct 2026)
The first Chat slice: the destination, the server session list and several
conversations held open at once. `android/` only; no new dependency (the
`material-icons-extended` icon is the declared one), no Pipelines server/Go/
installer/Docker file touched, no run started from the app, and the operator's
physical device was never used (`emulator-5556` only).
- **Pill.** The floating destination pill gains a Chat icon between Runs and
Settings (icons only, 48dp targets via the named `DESTINATION_ITEM_SIZE`/
`DESTINATION_ITEM_GAP` tokens, one non-wrapping `Row`), so it stays narrow and
clear of the reserved 88dp bottom inset however many destinations it holds.
The Search destination is owned by another lane and is not present on this
base; the pill is built to take it.
- **Brokered protocol.** `data/protocol/Chat.kt` mirrors `internal/protocol/chat.go`
field-for-field (sessions, create, query, prompt, messages/parts, event frames,
permission, reply); `Message` gains the optional `chat_*` payloads and
`PipelinesClient` now forwards *unsolicited* frames (chat_event/chat_permission)
to `events` instead of dropping them. `PipelinesRepository` exposes the typed
chat calls.
- **Multi-chat model.** `ui/chat/ChatStore.kt` is an Android-free state holder:
every open chat keeps its own conversation, running flag, composer draft and
scroll position; `open`/`activate` report when history must be (re-)fetched so
a running session re-syncs on return instead of showing a stale copy; a
server frame is applied to its chat whether or not it is on screen. `busy`
sessions render read-only and the composer refuses to write to them.
- **Surface.** `ui/chat/ChatScreen.kt` reuses the shared adaptive
`SlidingPaneStack` (session list → conversation): the list shows each session's
running/busy/read-only status, an open-chat strip switches between several
conversations in one tap (with an optional X to close one), and the
conversation is a bottom-anchored transcript of user bubbles, secondary
reasoning, assistant text and tool-call chips that expand to INPUT
(pretty-printed JSON) / OUTPUT (monospace, via the shared `CodeBlock`).
"New chat" creates a server session and opens it. Closing a chat *is* provided
(the chip X); it removes only that chat.
- **Messages sent to a chat are optimistic** (the bubble shows immediately); the
live delta/streaming pass is the next slice.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks` →
`BUILD SUCCESSFUL`, **229 tests, 0 failures** (new `MultiChatStateTest`:
switching preserves each conversation, a running session re-syncs on return,
drafts and scroll are per chat, a busy session is read-only, background events
land on their own chat; new `ChatProtocolTest` for the wire shapes; new
`ChatFormatTest`).
- The debug APK was installed on `emulator-5556` (`FoldB_API_36`, narrow
`wm size 1080x2340` @420) and driven with `uiautomator dump`/`input tap`;
captures were validated with `android/scripts/capture_png.sh -s emulator-5556`:
the pill with the Chat destination (`01_pill_chat`), the session list
(`02_chat_list`, `05_chat_list_one_open`, `07_chat_list_two_open`), two chats
with different conversations (`03_chat_alpha` and `06_chat_beta`), a tool chip
expanded to INPUT/OUTPUT (`04_chat_alpha_tool_expanded`), a read-only busy
session with a disabled composer (`08_chat_readonly`) and a per-chat draft
preserved across a switch (`10_draft_preserved`). `adb -s emulator-5556 logcat
-d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **The deployed Pipelines server predates chat** (verified: a `chat_sessions`
request answers `unknown command: chat_sessions`), and the server-side chat
broker is a separate lane. The on-emulator sweep therefore drove the client
against `chat_stub.py`, a minimal `/connect` WebSocket double that speaks the
exact `internal/protocol/chat.go` JSON, so the screenshots show real client
rendering of the documented wire contract, not the production service.
- **APK publish.** `app-debug.apk` (18,261,008 bytes, sha256
`aa167617c830fd7249eedf457959ef7e99b553769ed4ab82a3af6b4e8cb98ed3`) copied to
`~/.local/share/pipelines/data/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`;
`curl -I http://10.0.0.249:8080/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18261008`; a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (not deployed and out of
this lane's scope), a genuinely running session's re-sync against OpenCode
(covered by the model test, not live), and streaming/stop/approval/attachments,
which are later slices.
### Review follow-ups (16 Oct 2026, implementer pass)
Addressing the reviewer's findings on the slice above, still `android/` only.
- **Shared part upsert (duplication blocker).** `ChatStore.applyDelta` and
`applyTool` were the same message/part upsert twice. Both now call one private
`upsertPart(frame, partId) { existing -> … }`; the delta appends to the existing
text, the tool replaces the part, and neither can drift. `event()` and the new
`permission()` share one `ensureThread()` placeholder creator.
- **Diff cards (task gap).** The research report's edit view (`_CodeRun` /
`_DiffView`, §1.3) is now reproduced: an `edit`-family tool call renders a diff
card. `ChatFormat.toolEditDiff` derives an LCS line diff from the arguments'
`oldString`/`newString` — the brokered protocol has **no** diff field (research
§2.5), so it is synthesised, never silently dropped. The collapsed chip shows
the file and the `+N -M` stat; expanding shows the green/red monospace lines
(the app's own success/failure hues, not new literals).
- **One read-only rule (divergent code).** `sessionReadOnly` was dead (only its
own test called it) and disagreed with the UI's `ChatThread.readOnly = busy` for
a locally-running busy session. The helper is deleted and `ChatThread.readOnly`
is now `busy && !running`, the same precedence `sessionStatusLabel` uses: a turn
we started is `Running` and writable, not read-only.
- **`chatReply` / approval now reachable (unused API).** `observeChatEvents`
forwards `chat_permission` into `ChatStore.permission` instead of dropping it,
the conversation shows an approval bar (action, resources, Allow once / Always /
Deny) and `AppViewModel.replyChatPermission` answers through `chatReply`.
- **Stop control fixed (found while tracing read-only).** While a turn ran the
composer's red stop button was wired to `onSend`, so it sent the draft instead
of interrupting; it now calls `stopChat`.
- **Evidence gap closed.** The previous checklist cited `09` (new chat) but no
`09_*` file existed; this pass captures `09_new_chat.png` (the New-chat
conversation), plus `11_diff_card.png` and `12_permission_bar.png` for the two
new surfaces.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **233 tests, 0 failures, 0 errors, 0
skipped** (new `toolEditDiffMarksOnlyChangedLinesAndCountsThem`,
`toolEditDiffIsNullForNonEdits`, `locallyRunningBusyChatStaysWritable`,
`permissionIsStoredUntilAnswered`).
- The debug APK was installed on `emulator-5556` only and driven with
`uiautomator dump`/`input tap`; captures validated with
`android/scripts/capture_png.sh -s emulator-5556`: the new-chat conversation
(`09_new_chat`), the derived diff (`11_diff_card`, showing
`context / - val gap = 4.dp / + val gap = 6.dp / + val inset = 2.dp` under a
`src/layout.kt +2 -1` chip) and the approval bar (`12_permission_bar`). Tapping
**Allow once** cleared the bar through `chat_reply`. `adb -s emulator-5556
logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime`. Driven against the
test-double stub (the deployed server still predates chat).
- **APK publish.** `app-debug.apk` (18,228,844 bytes, sha256
`db240fc2fc295c5ab50530f9d8cefae908f307a3115b54ce9f6d713e05643b87`) copied to
`~/.local/share/pipelines/data/artifacts/119/3/pipelines-debug-wip-e5bde98.apk`.
Still not verified: the live brokered server (separate lane), streaming against
real OpenCode, and attachments — unchanged from the pass above.
+1
View File
@@ -22,6 +22,7 @@
android:name=".MainActivity"
android:exported="true"
android:label="@string/app_name"
android:windowSoftInputMode="adjustResize"
android:theme="@style/Theme.Pipelines">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
@@ -2,8 +2,15 @@ package net.awan.pipelines.data
import java.util.UUID
import java.util.concurrent.ConcurrentHashMap
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.JsonElement
import net.awan.pipelines.data.protocol.ChatCreateRequest
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPromptRequest
import net.awan.pipelines.data.protocol.ChatQuery
import net.awan.pipelines.data.protocol.ChatReplyRequest
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.Message
import net.awan.pipelines.data.protocol.PipelineDetail
import net.awan.pipelines.data.protocol.PipelineSummary
@@ -31,6 +38,9 @@ class PipelinesRepository(
) {
val connectionState = client.state
/** Server-pushed chat frames (chat_event / chat_permission), with no request id. */
val events: SharedFlow<Message> = client.events
/** Opens the single shared connection to a validated server URL. */
fun connect(validated: ServerUrl.Validated) = client.connect(validated)
@@ -118,6 +128,72 @@ class PipelinesRepository(
Message(type = Protocol.RETRY_RUN, runId = id, requestKey = requestKey),
).runDetail ?: throw ProtocolException("The server returned no run detail.")
// ---- Brokered OpenCode chat (route B): the phone never speaks OpenCode
// directly and never holds its credentials. ----
/** Lists the sessions this server owns, with the `busy` flag the phone renders read-only. */
suspend fun chatSessions(): List<ChatSession> =
client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList()
/**
* Creates a session and returns it. The server currently answers this type
* with an explicit error when it does not broker creation; the caller
* surfaces that message rather than guessing at a session id.
*/
suspend fun chatCreate(title: String, directory: String): ChatSession {
val response = client.call(
Message(
type = Protocol.CHAT_CREATE,
chatCreate = ChatCreateRequest(title = title, directory = directory),
),
)
return response.chatSession
?: throw ProtocolException("The server did not return the new chat session.")
}
/** Loads a session's stored turns; the server prefers its retained live state. */
suspend fun chatMessages(sessionId: String, limit: Int = 0): List<ChatMessage> {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
return client.call(
Message(type = Protocol.CHAT_MESSAGES, chatQuery = ChatQuery(sessionId = sessionId, limit = limit)),
).chatMessages ?: emptyList()
}
/** Sends one prompt; the server echoes an ack and then pushes chat_event frames. */
suspend fun chatPrompt(sessionId: String, text: String) {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
val trimmed = text.trim()
if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.")
client.call(
Message(
type = Protocol.CHAT_PROMPT,
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = trimmed),
),
)
}
suspend fun chatInterrupt(sessionId: String) {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
client.call(Message(type = Protocol.CHAT_INTERRUPT, chatQuery = ChatQuery(sessionId = sessionId)))
}
suspend fun chatReply(sessionId: String, requestId: String, decision: String, message: String = "") {
if (sessionId.isBlank() || requestId.isBlank()) {
throw ProtocolException("A pending permission request is required.")
}
client.call(
Message(
type = Protocol.CHAT_REPLY,
chatReply = ChatReplyRequest(
sessionId = sessionId,
requestId = requestId,
decision = decision,
message = message,
),
),
)
}
private fun requireConfigured() {
if (settings.serverUrl.value.isBlank()) {
throw NotConnectedException("Set the Pipelines server URL in Settings first.")
@@ -0,0 +1,198 @@
package net.awan.pipelines.data.protocol
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
/**
* Brokered OpenCode chat wire types (route B in the research report): the phone
* talks only to `/connect` and the server holds the OpenCode credentials,
* translating each type below. The field names and JSON tags mirror
* `internal/protocol/chat.go` exactly so the two cannot drift.
*
* Every list/field is optional with a default, so an older peer or a partial
* envelope never crashes the client.
*/
@Serializable
data class ChatSession(
val id: String = "",
val title: String = "",
val agent: String = "",
val model: String = "",
val directory: String = "",
@SerialName("parent_id") val parentId: String = "",
@SerialName("created_at") val createdAt: Long = 0,
@SerialName("updated_at") val updatedAt: Long = 0,
// Another client holds the session, or the server itself owns it as an active
// run: the phone shows it read-only instead of letting two clients write the
// same conversation.
val busy: Boolean = false,
)
@Serializable
data class ChatCreateRequest(
val title: String = "",
val directory: String = "",
)
/** The session-scoped request body for chat_messages and chat_interrupt. */
@Serializable
data class ChatQuery(
@SerialName("session_id") val sessionId: String = "",
val limit: Int = 0,
)
@Serializable
data class ChatPromptRequest(
@SerialName("session_id") val sessionId: String = "",
val text: String = "",
val model: String = "",
val agent: String = "",
val files: List<String> = emptyList(),
)
/** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */
@Serializable
data class ChatMessage(
val id: String = "",
@SerialName("session_id") val sessionId: String = "",
val role: String = "",
val model: String = "",
val agent: String = "",
@SerialName("created_at") val createdAt: Long = 0,
val parts: List<ChatPart> = emptyList(),
)
/** One element of a [ChatMessage]; [type] selects which fields are meaningful. */
@Serializable
data class ChatPart(
val type: String = "",
val id: String = "",
val text: String = "",
val name: String = "",
val executed: Boolean = false,
val state: ChatToolState? = null,
val time: ChatTime? = null,
)
/** The lifecycle of a tool call; [input] is a partial-JSON string while streaming, an object afterwards. */
@Serializable
data class ChatToolState(
val status: String = "",
val input: JsonElement? = null,
val content: List<ChatToolContent> = emptyList(),
val metadata: JsonObject? = null,
val error: ChatError? = null,
)
@Serializable
data class ChatToolContent(
val type: String = "",
val text: String = "",
val uri: String = "",
val mime: String = "",
val name: String = "",
)
@Serializable
data class ChatError(
val type: String = "",
val message: String = "",
)
/** Epoch-millisecond timing envelope of a tool call. */
@Serializable
data class ChatTime(
val created: Long = 0,
val ran: Long = 0,
val completed: Long = 0,
)
/**
* A server-pushed chat_event frame. [kind] selects the payload: text/reasoning
* carry an incremental [delta] for the target [part], tool carries a full [part],
* step marks turn progress and usage reports the turn totals.
*/
@Serializable
data class ChatEventFrame(
@SerialName("session_id") val sessionId: String = "",
@SerialName("message_id") val messageId: String = "",
val kind: String = "",
val delta: String = "",
val part: ChatPart? = null,
val step: ChatStep? = null,
val usage: ChatUsage? = null,
)
@Serializable
data class ChatStep(
val status: String = "",
val index: Int = 0,
)
@Serializable
data class ChatUsage(
@SerialName("input_tokens") val inputTokens: Int = 0,
@SerialName("output_tokens") val outputTokens: Int = 0,
val cost: Double = 0.0,
)
/** One pending OpenCode approval request the phone answers with chat_reply. */
@Serializable
data class ChatPermissionFrame(
@SerialName("session_id") val sessionId: String = "",
@SerialName("request_id") val requestId: String = "",
val action: String = "",
val resources: List<String> = emptyList(),
val save: List<String> = emptyList(),
val metadata: JsonObject? = null,
val source: ChatPermissionSource? = null,
val message: String = "",
)
@Serializable
data class ChatPermissionSource(
val type: String = "",
@SerialName("message_id") val messageId: String = "",
val id: String = "",
)
@Serializable
data class ChatReplyRequest(
@SerialName("session_id") val sessionId: String = "",
@SerialName("request_id") val requestId: String = "",
val decision: String = "",
val message: String = "",
)
/** Chat part/kind/state/reply constants, mirroring `internal/protocol/chat.go`. */
object ChatProtocol {
const val PART_TEXT = "text"
const val PART_REASONING = "reasoning"
const val PART_TOOL = "tool"
const val EVENT_STEP = "step"
const val EVENT_USAGE = "usage"
const val STEP_STARTED = "started"
const val STEP_ENDED = "ended"
const val TOOL_STREAMING = "streaming"
const val TOOL_RUNNING = "running"
const val TOOL_COMPLETED = "completed"
const val TOOL_ERROR = "error"
const val ROLE_USER = "user"
const val ROLE_ASSISTANT = "assistant"
const val DECISION_ONCE = "once"
const val DECISION_ALWAYS = "always"
const val DECISION_REJECT = "reject"
/** A tool call still in flight (no result or error yet). */
fun toolRunning(state: ChatToolState?): Boolean = when (state?.status) {
TOOL_STREAMING, TOOL_RUNNING -> true
else -> false
}
}
@@ -41,6 +41,17 @@ object Protocol {
const val GET_STATUS = "get_status"
const val STATUS = "status"
// chat.go (brokered OpenCode chat)
const val CHAT_SESSIONS = "chat_sessions"
const val CHAT_CREATE = "chat_create"
const val CHAT_PROMPT = "chat_prompt"
const val CHAT_MESSAGES = "chat_messages"
const val CHAT_INTERRUPT = "chat_interrupt"
const val CHAT_REPLY = "chat_reply"
// Server-pushed frames with no matching request.
const val CHAT_EVENT = "chat_event"
const val CHAT_PERMISSION = "chat_permission"
// terminals.go
const val SUCCESS_END = "#success"
const val FAILURE_END = "#failure"
@@ -411,4 +422,15 @@ data class Message(
@SerialName("write_paths") val writePaths: List<String>? = null,
@SerialName("request_key") val requestKey: String? = null,
val workspace: String? = null,
// Brokered chat traffic (see Chat.kt). Optional so an older server never
// breaks the existing envelope.
@SerialName("chat_sessions") val chatSessions: List<ChatSession>? = null,
@SerialName("chat_session") val chatSession: ChatSession? = null,
@SerialName("chat_create") val chatCreate: ChatCreateRequest? = null,
@SerialName("chat_query") val chatQuery: ChatQuery? = null,
@SerialName("chat_prompt") val chatPrompt: ChatPromptRequest? = null,
@SerialName("chat_messages") val chatMessages: List<ChatMessage>? = null,
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
)
@@ -10,8 +10,11 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
@@ -53,6 +56,15 @@ class PipelinesClient(
private val _state = MutableStateFlow<ConnectionState>(ConnectionState.Idle)
val state: StateFlow<ConnectionState> = _state.asStateFlow()
// Unsolicited server frames (server-pushed chat_event / chat_permission /
// stream errors). Buffered and dropped-oldest so a slow collector can never
// block the socket read loop; chats re-sync from history after a gap anyway.
private val _events = MutableSharedFlow<Message>(
extraBufferCapacity = 256,
onBufferOverflow = kotlinx.coroutines.channels.BufferOverflow.DROP_OLDEST,
)
val events: SharedFlow<Message> = _events.asSharedFlow()
private val sendLock = Mutex()
private val pending = ConcurrentHashMap<String, CompletableDeferred<Message>>()
private val sequence = AtomicLong(0)
@@ -190,9 +202,12 @@ class PipelinesClient(
val deferred = if (id != null) pending.remove(id) else null
if (deferred != null) {
deferred.complete(message)
} else {
// Unsolicited envelopes (the connection's initial pipeline_list,
// server-pushed chat frames, stream errors) carry no matching id:
// hand them to the event stream instead of dropping them.
_events.tryEmit(message)
}
// Unsolicited envelopes (for example the connection's initial
// pipeline_list) have no matching id and are intentionally dropped.
}
override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
@@ -19,12 +19,15 @@ import net.awan.pipelines.data.PipelinesRepository
import net.awan.pipelines.data.RunHistory
import net.awan.pipelines.data.SettingsRepository
import net.awan.pipelines.data.protocol.BuildInfo
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.PipelineDetail
import net.awan.pipelines.data.protocol.PipelineSummary
import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.data.protocol.SessionEvidence
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.data.transport.ServerUrl
import net.awan.pipelines.ui.chat.ChatState
import net.awan.pipelines.ui.chat.ChatStore
/** Generic loading/empty/error/data state used by every screen. */
data class LoadState<T>(
@@ -95,6 +98,10 @@ class AppViewModel(
private val startKeys = ConcurrentHashMap<Long, String>()
private val retryKeys = ConcurrentHashMap<Long, String>()
/** The multi-chat screen state (sessions, open conversations, drafts, scroll). */
private val chatStore = ChatStore()
val chat: StateFlow<ChatState> = chatStore.state
init {
// Connect on launch when a server URL is already saved, reusing the shared
// client and its bounded backoff (no new client, DI or polling). init runs
@@ -105,6 +112,24 @@ class AppViewModel(
) {
reconnect()
}
observeChatEvents()
}
/**
* Routes server-pushed chat frames into the per-chat state, wherever the
* frame's session sits in the open order. Frames for a chat that is not open
* create a placeholder in [ChatStore.event] so a running background chat
* keeps its stream; the operator sees it re-synced from history on return.
*/
private fun observeChatEvents() {
viewModelScope.launch {
repository.events.collect { message ->
message.chatEvent?.let { chatStore.event(it) }
// Never silently drop an approval request: it is held per chat and
// answered with chat_reply from the conversation's approval bar.
message.chatPermission?.let { chatStore.permission(it) }
}
}
}
fun updateServerUrlDraft(value: String) {
@@ -284,6 +309,119 @@ class AppViewModel(
}
}
// ---- Brokered chat -------------------------------------------------------
/** Refreshes the server's session list; never clears open conversations. */
fun refreshChatSessions() {
viewModelScope.launch {
chatStore.sessionsLoading()
try {
chatStore.sessionsLoaded(repository.chatSessions())
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.sessionsFailed(ErrorMessages.describe(t))
}
}
}
/**
* Opens [session] and makes it active. A brand-new chat always loads its
* history; a running one re-syncs from the server so a stale copy is never
* shown on return.
*/
fun openChatSession(session: ChatSession) {
val needsHistory = chatStore.open(session)
if (needsHistory) loadChatHistory(session.id)
}
/** Switches to an already-open chat, re-syncing it when it is running. */
fun activateChat(sessionId: String) {
if (chatStore.activate(sessionId)) loadChatHistory(sessionId)
}
/** Shows the session list again while keeping every open conversation. */
fun showChatList() = chatStore.showList()
fun closeChat(sessionId: String) = chatStore.close(sessionId)
fun updateChatDraft(sessionId: String, text: String) = chatStore.draft(sessionId, text)
fun saveChatScroll(sessionId: String, index: Int, offset: Int) = chatStore.scroll(sessionId, index, offset)
/** Creates a session on the server and opens it. Reports the server's own error on failure. */
fun newChat() {
viewModelScope.launch {
try {
val created = repository.chatCreate(title = "New chat", directory = settings.workspace.value)
chatStore.sessionsLoaded(chatStore.value.sessions + created)
chatStore.open(created)
chatStore.history(created.id, emptyList())
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.sessionsFailed(ErrorMessages.describe(t))
}
}
}
fun loadChatHistory(sessionId: String) {
viewModelScope.launch {
chatStore.historyLoading(sessionId)
try {
chatStore.history(sessionId, repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT))
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
}
}
}
/** Sends the active chat's draft. Read-only chats are never written to. */
fun sendChatPrompt(sessionId: String) {
val thread = chatStore.value.thread(sessionId) ?: return
if (thread.readOnly) return
val text = thread.draft.trim()
if (text.isEmpty()) return
chatStore.appendLocalUserMessage(sessionId, text)
chatStore.clearDraft(sessionId)
chatStore.running(sessionId, true)
viewModelScope.launch {
try {
repository.chatPrompt(sessionId, text)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
chatStore.running(sessionId, false)
}
}
}
/** Answers a pending approval: optimistically clears it, then reports a failed reply. */
fun replyChatPermission(sessionId: String, requestId: String, decision: String) {
if (sessionId.isBlank() || requestId.isBlank()) return
viewModelScope.launch {
try {
repository.chatReply(sessionId, requestId, decision)
chatStore.clearPermission(sessionId)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
}
}
}
fun stopChat(sessionId: String) {
viewModelScope.launch {
try {
repository.chatInterrupt(sessionId)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
} finally {
chatStore.running(sessionId, false)
}
}
}
private fun <T> load(target: MutableStateFlow<LoadState<T>>, block: suspend () -> T) {
viewModelScope.launch {
target.value = target.value.copy(loading = true, error = null)
@@ -299,6 +437,9 @@ class AppViewModel(
companion object {
private const val CONNECT_TIMEOUT_MILLIS = 20_000L
/** Bounds one history fetch; the server applies its own cap too. */
private const val CHAT_HISTORY_LIMIT = 200
fun factory(app: PipelinesApplication) = viewModelFactory {
initializer { AppViewModel(app.repository, app.settings) }
}
@@ -18,6 +18,7 @@ import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.Chat
import androidx.compose.material.icons.filled.AccountTree
import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.Settings
@@ -57,12 +58,14 @@ import net.awan.pipelines.ui.screens.PipelineListScreen
import net.awan.pipelines.ui.screens.RunDetailScreen
import net.awan.pipelines.ui.screens.RunHistoryScreen
import net.awan.pipelines.ui.screens.SettingsScreen
import net.awan.pipelines.ui.chat.ChatScreen
private data class TopDestination(val route: String, val label: String, val icon: ImageVector)
private val destinations = listOf(
TopDestination("pipelines", "Pipelines", Icons.Default.AccountTree),
TopDestination("runs", "Runs", Icons.Default.History),
TopDestination("chat", "Chat", Icons.AutoMirrored.Filled.Chat),
TopDestination("settings", "Settings", Icons.Default.Settings),
)
@@ -166,6 +169,9 @@ fun PipelinesApp(vm: AppViewModel) {
onSelectionChange = { runSelection = it },
)
}
composable("chat") {
ChatScreen(vm = vm, wide = wide)
}
composable("settings") {
SettingsScreen(vm)
}
@@ -348,15 +354,15 @@ private fun DestinationPill(
shadowElevation = 6.dp,
) {
Row(
modifier = Modifier.padding(4.dp),
horizontalArrangement = Arrangement.spacedBy(4.dp),
modifier = Modifier.padding(DESTINATION_ITEM_GAP),
horizontalArrangement = Arrangement.spacedBy(DESTINATION_ITEM_GAP),
verticalAlignment = Alignment.CenterVertically,
) {
destinations.forEach { destination ->
val selected = destinationSelected(currentRoute, destination.route)
Box(
modifier = Modifier
.size(48.dp)
.size(DESTINATION_ITEM_SIZE)
.clip(CircleShape)
.background(
if (selected) {
@@ -390,3 +396,9 @@ private fun DestinationPill(
/** Bottom space reserved for the floating destination pill, so content is never
* permanently hidden behind it (pill height + its margins + a small gap). */
private val DESTINATION_PILL_RESERVE = 88.dp
/** The side of one destination's touch target, and the gap between them (also the
* pill's inner padding). Icons only, so the pill stays narrow however many
* destinations it holds. */
private val DESTINATION_ITEM_SIZE = 48.dp
private val DESTINATION_ITEM_GAP = 4.dp
@@ -0,0 +1,166 @@
package net.awan.pipelines.ui.chat
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.ChatToolState
/**
* Pure chat formatting helpers shared by the session list and the conversation,
* so the same value is never spelled differently in two places. Kept free of
* Compose and of the transport so they are unit-testable.
*/
private val PRETTY_JSON = Json { prettyPrint = true; isLenient = true }
/**
* The INPUT section of a tool call: pretty-printed JSON once the arguments are
* an object/array, a partial-JSON string while still streaming, or the raw text
* when it cannot be parsed. Blank when there is nothing.
*/
internal fun prettyToolInput(input: JsonElement?): String = when (input) {
null -> ""
is JsonObject, is JsonArray -> PRETTY_JSON.encodeToString(JsonElement.serializer(), input)
is JsonPrimitive -> input.content
else -> input.toString()
}
/**
* The OUTPUT section of a tool call: the concatenated textual content, or the
* literal `(no output)` when the call returned nothing (mirroring jarvis), and
* an empty string while the call is still running.
*/
internal fun toolOutputText(state: ChatToolState?): String {
if (state == null) return ""
val text = state.content
.filter { it.type == "text" && it.text.isNotBlank() }
.joinToString("\n") { it.text }
if (text.isNotBlank()) return text
if (state.error != null) return state.error.message
if (ChatProtocol.toolRunning(state)) return ""
return "(no output)"
}
/** Wall-clock duration of a tool call, or null while it has no completion time. */
internal fun toolDurationMillis(part: ChatPart): Long? {
val time = part.time ?: return null
val start = if (time.ran > 0) time.ran else time.created
if (start <= 0 || time.completed <= 0 || time.completed < start) return null
return time.completed - start
}
/** Compact millisecond duration, e.g. `340ms` / `1.2s` / `2m 3s`. */
internal fun formatToolDuration(millis: Long): String = when {
millis < 1_000 -> "${millis}ms"
millis < 60_000 -> String.format(java.util.Locale.US, "%.1fs", millis / 1000.0)
else -> "${millis / 60_000}m ${(millis % 60_000) / 1000}s"
}
/** The chip label for a tool call: its name, or a placeholder when unnamed. */
internal fun toolLabel(part: ChatPart): String = part.name.ifBlank { "tool" }
/**
* A session's short title: the server title, or a truncated id when untitled, so
* a row never renders as a blank line.
*/
internal fun sessionTitle(session: ChatSession): String =
session.title.ifBlank { session.id.take(18).ifBlank { "Untitled chat" } }
/**
* The status a session row shows. A locally-running turn is reported as
* `Running`; otherwise the server's `busy` flag is `Busy · read-only` (another
* client holds it, so the composer is disabled), else `Idle`.
*
* This is the same precedence [ChatThread.readOnly] applies: a turn we started is
* `Running` and writable, never the read-only the server's own `busy` flag alone
* would imply.
*/
internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String = when {
runningLocally -> "Running"
session.busy -> "Busy · read-only"
else -> "Idle"
}
/**
* One line of a derived unified diff. [CONTEXT] lines are unchanged, [ADD] came
* from the edit's `newString` and [REMOVE] from its `oldString`.
*/
enum class DiffKind { CONTEXT, ADD, REMOVE }
data class DiffLine(val kind: DiffKind, val text: String)
/** A synthesised edit diff: the file, the `+N -M` counts and the ordered lines. */
data class ToolDiff(val file: String, val added: Int, val removed: Int, val lines: List<DiffLine>)
/**
* Derives a unified diff for an `edit`-family tool call from its
* `oldString`/`newString` arguments. The brokered protocol carries no diff field
* (research report §2.5), so the +/- view is synthesised here instead. Returns
* null for any other tool, so non-edit calls keep the INPUT/OUTPUT panel.
*/
internal fun toolEditDiff(input: JsonElement?): ToolDiff? {
val obj = input as? JsonObject ?: return null
val old = obj.stringOrNull("oldString", "old_string") ?: return null
val new = obj.stringOrNull("newString", "new_string") ?: return null
if (old.isEmpty() && new.isEmpty()) return null
val lines = lineDiff(old.split("\n"), new.split("\n"))
return ToolDiff(
file = obj.stringOrNull("filePath", "file_path", "file").orEmpty(),
added = lines.count { it.kind == DiffKind.ADD },
removed = lines.count { it.kind == DiffKind.REMOVE },
lines = lines,
)
}
private fun JsonObject.stringOrNull(vararg keys: String): String? {
for (key in keys) {
val value = this[key]
if (value is JsonPrimitive && value.isString) return value.content
}
return null
}
/**
* A minimal line diff (LCS) so only the changed lines are marked, not the whole
* block. A pathologically large edit falls back to a plain remove-then-add block
* to bound the quadratic table.
*/
private fun lineDiff(old: List<String>, new: List<String>): List<DiffLine> {
if (old.size > MAX_DIFF_LINES || new.size > MAX_DIFF_LINES) {
return old.map { DiffLine(DiffKind.REMOVE, it) } + new.map { DiffLine(DiffKind.ADD, it) }
}
val m = old.size
val n = new.size
val lcs = Array(m + 1) { IntArray(n + 1) }
for (i in m - 1 downTo 0) {
for (j in n - 1 downTo 0) {
lcs[i][j] = if (old[i] == new[j]) lcs[i + 1][j + 1] + 1
else maxOf(lcs[i + 1][j], lcs[i][j + 1])
}
}
val result = ArrayList<DiffLine>(m + n)
var i = 0
var j = 0
while (i < m && j < n) {
when {
old[i] == new[j] -> {
result.add(DiffLine(DiffKind.CONTEXT, old[i])); i++; j++
}
lcs[i + 1][j] >= lcs[i][j + 1] -> {
result.add(DiffLine(DiffKind.REMOVE, old[i])); i++
}
else -> {
result.add(DiffLine(DiffKind.ADD, new[j])); j++
}
}
}
while (i < m) { result.add(DiffLine(DiffKind.REMOVE, old[i])); i++ }
while (j < n) { result.add(DiffLine(DiffKind.ADD, new[j])); j++ }
return result
}
private const val MAX_DIFF_LINES = 400
@@ -0,0 +1,747 @@
package net.awan.pipelines.ui.chat
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.horizontalScroll
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.selection.SelectionContainer
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.automirrored.filled.Send
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Build
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.KeyboardArrowDown
import androidx.compose.material.icons.filled.KeyboardArrowUp
import androidx.compose.material.icons.filled.Psychology
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material.icons.filled.Stop
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.foundation.selection.selectable
import androidx.activity.compose.PredictiveBackHandler
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatPermissionFrame
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.components.CODE_BLOCK_MAX_HEIGHT
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.EmptyState
import net.awan.pipelines.ui.components.ErrorState
import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.RunStatusPalette
import net.awan.pipelines.ui.components.SlidingPaneStack
import net.awan.pipelines.ui.theme.pipelinesText
/**
* Geometry tokens for the chat surface. Every value is a named constant so no
* screen body holds an ad-hoc number; Material's own minimum interactive size
* governs touch targets.
*/
private val CHAT_GUTTER = 16.dp
private val CHAT_ITEM_GAP = 8.dp
private val CHAT_COMPOSER_GAP = 12.dp
private val CHAT_STATUS_DOT = 8.dp
/**
* The Chat destination. It is the same adaptive [SlidingPaneStack] the Pipelines
* and Runs destinations use: pane 0 is the server's session list (the operator
* can hold several chats open at once) and pane 1 is the active conversation.
*
* Every open chat keeps its own messages, running flag, composer draft and
* scroll position in [ChatStore]; switching away and back never loses them, and
* returning to a running chat re-syncs it from the server instead of showing a
* stale copy.
*/
@Composable
fun ChatScreen(vm: AppViewModel, wide: Boolean, modifier: Modifier = Modifier) {
val state by vm.chat.collectAsStateWithLifecycle()
val connection by vm.connectionState.collectAsStateWithLifecycle()
val active = state.active
// Fetch the server's session list once when the Chat destination opens.
LaunchedEffect(Unit) { vm.refreshChatSessions() }
// Back inside a conversation returns to the session list before leaving the
// destination, exactly one level (the same rule the other destinations use).
PredictiveBackHandler(enabled = active != null) { progress ->
progress.collect { }
vm.showChatList()
}
SlidingPaneStack(
depth = if (active != null) 1 else 0,
wide = wide,
onPopTo = { vm.showChatList() },
backContentDescription = { "Back to chats" },
modifier = modifier,
) { level, covered, paneModifier ->
when (level) {
0 -> ChatListPane(
vm = vm,
state = state,
connected = connection is ConnectionState.Connected,
covered = covered,
modifier = paneModifier,
)
1 -> active?.let { thread ->
// Key by session so each conversation gets its own list state and
// disposes (saving its scroll) when the operator switches away.
key(thread.sessionId) {
ChatConversationPane(vm = vm, state = state, thread = thread, modifier = paneModifier)
}
}
}
}
}
// ---- Pane 0: the server's session list ---------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun ChatListPane(
vm: AppViewModel,
state: ChatState,
connected: Boolean,
covered: Boolean,
modifier: Modifier,
) {
if (covered) {
PaneIdentity(
title = "Chat",
subtitle = when {
state.open.isNotEmpty() -> "${state.open.size} open"
state.sessions.isNotEmpty() -> "${state.sessions.size} sessions"
else -> null
},
modifier = modifier.fillMaxSize(),
)
return
}
Scaffold(
modifier = modifier,
topBar = {
TopAppBar(
title = { Text("Chat") },
actions = {
IconButton(onClick = vm::refreshChatSessions) {
Icon(Icons.Default.Refresh, contentDescription = "Refresh chats")
}
IconButton(onClick = vm::newChat) {
Icon(Icons.Default.Add, contentDescription = "New chat")
}
},
)
},
) { padding ->
Column(Modifier.fillMaxSize().padding(padding)) {
if (state.open.isNotEmpty()) {
OpenChatStrip(
state = state,
onSelect = vm::activateChat,
onClose = vm::closeChat,
)
}
if (!connected) {
NotConnectedNotice()
}
when {
state.sessionsLoading && state.sessions.isEmpty() -> LoadingState("Loading chats…")
state.sessionsError != null && state.sessions.isEmpty() -> {
ErrorState(state.sessionsError, onRetry = vm::refreshChatSessions)
}
state.sessions.isEmpty() -> EmptyState(
message = "No chat sessions on this server yet.",
actionLabel = "New chat",
onAction = vm::newChat,
)
else -> LazyColumn(Modifier.fillMaxSize()) {
items(state.sessions, key = { it.id }) { session ->
val thread = state.thread(session.id)
SessionRow(
session = session,
open = thread != null,
running = thread?.running == true,
active = state.activeId == session.id,
onClick = { vm.openChatSession(session) },
)
}
if (state.sessionsError != null) {
item("error") {
Text(
text = state.sessionsError,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(CHAT_GUTTER),
)
}
}
}
}
}
}
}
@Composable
private fun SessionRow(
session: ChatSession,
open: Boolean,
running: Boolean,
active: Boolean,
onClick: () -> Unit,
) {
val texts = pipelinesText()
ListRow(selected = active, onClick = onClick) {
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
Text(
text = sessionTitle(session),
style = texts.cardTitle,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f, fill = false),
)
if (open) SessionBadge("Open", running)
}
val meta = buildList {
add(sessionStatusLabel(session, running))
if (session.directory.isNotBlank()) add(session.directory)
if (session.model.isNotBlank()) add(session.model)
}.joinToString(" · ")
Text(text = meta, style = texts.meta, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
}
/** A running/busy/open indicator: a coloured dot plus a word, never colour alone. */
@Composable
private fun SessionBadge(label: String, running: Boolean = false) {
val color = when {
running -> MaterialTheme.colorScheme.tertiary
label == "Open" -> MaterialTheme.colorScheme.primary
else -> MaterialTheme.colorScheme.outline
}
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) {
Box(Modifier.size(CHAT_STATUS_DOT).clip(CircleShape).background(color))
Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
}
}
@Composable
private fun NotConnectedNotice() {
Surface(
color = MaterialTheme.colorScheme.errorContainer,
modifier = Modifier.fillMaxWidth(),
) {
Text(
text = "Not connected. Chats are served by the Pipelines server; connect in Settings.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onErrorContainer,
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
)
}
}
/**
* The open-conversation switcher: one chip per conversation the operator has
* open, so several chats can be kept at once and switched between in one tap.
* A running chat carries a `Running` badge; the X closes that chat (optional
* close is provided).
*/
@Composable
private fun OpenChatStrip(
state: ChatState,
onSelect: (String) -> Unit,
onClose: (String) -> Unit,
) {
Row(
modifier = Modifier
.fillMaxWidth()
.horizontalScroll(rememberScrollState())
.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
) {
state.open.forEach { thread ->
val selected = state.activeId == thread.sessionId
Surface(
shape = RoundedCornerShape(50),
color = if (selected) {
MaterialTheme.colorScheme.secondaryContainer
} else {
MaterialTheme.colorScheme.surfaceContainerHigh
},
modifier = Modifier
.selectable(selected = selected, role = Role.Tab, onClick = { onSelect(thread.sessionId) }),
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(6.dp),
modifier = Modifier.padding(start = CHAT_ITEM_GAP + 4.dp, end = 2.dp, top = 4.dp, bottom = 4.dp),
) {
if (thread.running) {
Box(
Modifier.size(CHAT_STATUS_DOT).clip(CircleShape)
.background(MaterialTheme.colorScheme.tertiary),
)
}
Text(
text = thread.title.ifBlank { thread.sessionId.take(12) },
style = MaterialTheme.typography.labelMedium,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.widthIn(max = 160.dp),
)
IconButton(onClick = { onClose(thread.sessionId) }, modifier = Modifier.size(28.dp)) {
Icon(
Icons.Default.Close,
contentDescription = "Close chat ${thread.title}",
modifier = Modifier.size(16.dp),
)
}
}
}
}
}
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
}
// ---- Pane 1: the active conversation -----------------------------------------
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun ChatConversationPane(
vm: AppViewModel,
state: ChatState,
thread: ChatThread,
modifier: Modifier,
) {
val listState = rememberLazyListState(
initialFirstVisibleItemIndex = thread.scroll.index,
initialFirstVisibleItemScrollOffset = thread.scroll.offset,
)
// Persist the scroll position when the operator leaves this chat, so switching
// away and back returns them exactly where they were.
DisposableEffect(thread.sessionId) {
onDispose { vm.saveChatScroll(thread.sessionId, listState.firstVisibleItemIndex, listState.firstVisibleItemScrollOffset) }
}
Scaffold(
modifier = modifier,
topBar = {
TopAppBar(
title = {
Text(
text = thread.title.ifBlank { sessionTitle(ChatSession(id = thread.sessionId)) },
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
},
navigationIcon = {
IconButton(onClick = vm::showChatList) {
Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back to chats")
}
},
actions = {
if (thread.running) {
IconButton(onClick = { vm.stopChat(thread.sessionId) }) {
Icon(Icons.Default.Stop, contentDescription = "Stop")
}
}
},
)
},
) { padding ->
Column(Modifier.fillMaxSize().padding(padding).imePadding()) {
OpenChatStrip(state = state, onSelect = vm::activateChat, onClose = vm::closeChat)
Box(Modifier.weight(1f).fillMaxWidth()) {
when {
thread.loading && !thread.loaded -> LoadingState("Loading conversation…")
thread.error != null && !thread.loaded -> ErrorState(
message = thread.error,
onRetry = { vm.loadChatHistory(thread.sessionId) },
)
thread.messages.isEmpty() && !thread.running -> EmptyState(
message = if (thread.readOnly) {
"This chat is read-only while another client holds the session."
} else {
"This chat has no messages yet. Ask something below."
},
)
else -> ChatTranscript(thread = thread, listState = listState)
}
}
if (thread.error != null && thread.loaded) {
Text(
text = thread.error,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = 4.dp),
)
}
thread.permission?.let { permission ->
PermissionBar(
permission = permission,
onDecision = { decision ->
vm.replyChatPermission(thread.sessionId, permission.requestId, decision)
},
)
}
ChatComposer(
thread = thread,
onDraft = { vm.updateChatDraft(thread.sessionId, it) },
onSend = { vm.sendChatPrompt(thread.sessionId) },
onStop = { vm.stopChat(thread.sessionId) },
)
}
}
}
/**
* The bottom-anchored transcript: content is packed to the bottom (so a short or
* freshly opened chat sits against the composer) and the running indicator sits
* at the newest end while a turn is in flight.
*/
@Composable
private fun ChatTranscript(thread: ChatThread, listState: androidx.compose.foundation.lazy.LazyListState) {
LazyColumn(
state = listState,
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP, Alignment.Bottom),
) {
items(thread.messages, key = { it.id }) { message ->
MessageItem(message)
}
if (thread.running) {
item(key = "pending") { RunningIndicator() }
}
}
}
@Composable
private fun RunningIndicator() {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
) {
CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
Text("Working…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
}
}
@Composable
private fun MessageItem(message: ChatMessage) {
val isUser = message.role == ChatProtocol.ROLE_USER
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = if (isUser) Arrangement.End else Arrangement.Start,
) {
Surface(
shape = RoundedCornerShape(CHAT_GUTTER),
color = if (isUser) {
MaterialTheme.colorScheme.secondaryContainer
} else {
MaterialTheme.colorScheme.surfaceContainer
},
modifier = Modifier.widthIn(max = 560.dp),
) {
SelectionContainer {
Column(Modifier.padding(CHAT_GUTTER)) {
if (isUser) {
Text(
text = message.parts.joinToString("\n") { it.text }.trim(),
style = MaterialTheme.typography.bodyMedium,
)
} else {
message.parts.forEach { part -> MessagePart(part) }
}
}
}
}
}
}
@Composable
private fun MessagePart(part: ChatPart) {
when (part.type) {
ChatProtocol.PART_TEXT -> if (part.text.isNotBlank()) {
Text(part.text, style = MaterialTheme.typography.bodyMedium)
}
ChatProtocol.PART_REASONING -> ReasoningBlock(part.text)
ChatProtocol.PART_TOOL -> ToolCallCard(part)
else -> if (part.text.isNotBlank()) Text(part.text, style = MaterialTheme.typography.bodyMedium)
}
}
/** Reasoning is visually secondary: a muted, bordered block, never body weight. */
@Composable
private fun ReasoningBlock(text: String) {
if (text.isBlank()) return
Row(horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), modifier = Modifier.padding(vertical = 4.dp)) {
Icon(
Icons.Default.Psychology,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(16.dp),
)
Text(
text = text,
style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Default),
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
/**
* A tool call as a compact chip that expands to INPUT (pretty JSON) and OUTPUT
* (monospace) sections, mirroring the reference chat: the transcript stays
* scannable and the arguments/result appear only on demand.
*
* An `edit`-family call instead renders a diff card (research §1.3 `_CodeRun` /
* `_DiffView`): the `+N -M` stat on the chip and a green/red unified diff derived
* from the arguments, since the brokered protocol carries no diff field.
*/
@Composable
private fun ToolCallCard(part: ChatPart) {
var expanded by remember(part.id) { mutableStateOf(false) }
val running = ChatProtocol.toolRunning(part.state)
val diff = toolEditDiff(part.state?.input)
Column(Modifier.fillMaxWidth().padding(vertical = 4.dp)) {
Surface(
shape = RoundedCornerShape(CHAT_ITEM_GAP + 2.dp),
color = MaterialTheme.colorScheme.surfaceContainerHigh,
modifier = Modifier.clickable { expanded = !expanded },
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
modifier = Modifier.padding(horizontal = CHAT_ITEM_GAP + 2.dp, vertical = CHAT_ITEM_GAP),
) {
if (running) {
CircularProgressIndicator(Modifier.size(14.dp), strokeWidth = 2.dp)
} else {
Icon(
if (diff != null) Icons.Default.Edit else Icons.Default.Build,
contentDescription = null,
modifier = Modifier.size(16.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Text(
text = diff?.file?.takeIf { it.isNotBlank() } ?: toolLabel(part),
style = MaterialTheme.typography.labelMedium,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f, fill = false),
)
diff?.let { DiffStat(it) }
toolDurationMillis(part)?.let {
Text(formatToolDuration(it), style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
}
Icon(
imageVector = if (expanded) Icons.Default.KeyboardArrowUp else Icons.Default.KeyboardArrowDown,
contentDescription = if (expanded) "Collapse tool call" else "Expand tool call",
modifier = Modifier.size(18.dp),
)
}
}
if (expanded) {
Column(verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), modifier = Modifier.padding(top = CHAT_ITEM_GAP)) {
if (diff != null) {
DiffView(diff)
} else {
CodeBlock(label = "INPUT", text = prettyToolInput(part.state?.input))
CodeBlock(label = "OUTPUT", text = toolOutputText(part.state))
}
}
}
}
}
/** The `+N -M` counts, green/red monospace, exactly as the reference diff stat. */
@Composable
private fun DiffStat(diff: ToolDiff) {
Row(horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
Text(
text = "+${diff.added}",
style = MaterialTheme.typography.labelMedium.copy(fontFamily = FontFamily.Monospace),
color = RunStatusPalette.of(RunState.Succeeded).color,
)
Text(
text = "-${diff.removed}",
style = MaterialTheme.typography.labelMedium.copy(fontFamily = FontFamily.Monospace),
color = RunStatusPalette.of(RunState.Failed).color,
)
}
}
/**
* The unified diff body of an edit card: line-by-line monospace with `+`/`-`
* gutter symbols and the app's success/failure hues, bounded so a long diff
* scrolls inside the card instead of pushing the transcript down.
*/
@Composable
private fun DiffView(diff: ToolDiff) {
val added = RunStatusPalette.of(RunState.Succeeded).color
val removed = RunStatusPalette.of(RunState.Failed).color
val context = MaterialTheme.colorScheme.onSurfaceVariant
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer),
elevation = CardDefaults.cardElevation(defaultElevation = 0.dp),
) {
Column(
modifier = Modifier
.fillMaxWidth()
.heightIn(max = CODE_BLOCK_MAX_HEIGHT)
.verticalScroll(rememberScrollState())
.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
) {
diff.lines.forEach { line ->
val (symbol, color) = when (line.kind) {
DiffKind.ADD -> "+" to added
DiffKind.REMOVE -> "-" to removed
DiffKind.CONTEXT -> " " to context
}
Text(
text = "$symbol ${line.text}",
style = pipelinesText().mono,
color = color,
)
}
}
}
}
@Composable
private fun ChatComposer(
thread: ChatThread,
onDraft: (String) -> Unit,
onSend: () -> Unit,
onStop: () -> Unit,
) {
Surface(color = MaterialTheme.colorScheme.surfaceContainer) {
Column(Modifier.fillMaxWidth().padding(CHAT_GUTTER)) {
if (thread.readOnly) {
Text(
text = "Another client holds this session; it is read-only here.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(bottom = CHAT_ITEM_GAP),
)
}
Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP)) {
OutlinedTextField(
value = thread.draft,
onValueChange = onDraft,
enabled = !thread.readOnly,
placeholder = { Text("Message the agent…") },
minLines = 1,
maxLines = 6,
keyboardActions = KeyboardActions(onSend = { if (thread.canSend) onSend() }),
modifier = Modifier.weight(1f),
)
if (thread.running) {
// While a turn is in flight the send control becomes the stop
// control, so it must interrupt rather than send the draft.
IconButton(onClick = onStop) {
Icon(Icons.Default.Stop, contentDescription = "Stop", tint = MaterialTheme.colorScheme.error)
}
} else {
IconButton(onClick = onSend, enabled = thread.canSend) {
Icon(Icons.AutoMirrored.Filled.Send, contentDescription = "Send")
}
}
}
}
}
}
/**
* The approval bar for a pending tool-call permission: the request's action and
* resources, with Allow-once / Always / Deny. A decision is answered through
* `chat_reply`, so the server-held credentials and the tool never leave it.
*/
@Composable
private fun PermissionBar(permission: ChatPermissionFrame, onDecision: (String) -> Unit) {
Surface(color = MaterialTheme.colorScheme.tertiaryContainer, modifier = Modifier.fillMaxWidth()) {
Column(
modifier = Modifier.fillMaxWidth().padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
) {
Text(
text = "Approve: ${permission.action.ifBlank { "tool call" }}",
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onTertiaryContainer,
)
if (permission.resources.isNotEmpty()) {
Text(
text = permission.resources.joinToString("\n"),
style = pipelinesText().mono,
color = MaterialTheme.colorScheme.onTertiaryContainer,
maxLines = 3,
overflow = TextOverflow.Ellipsis,
)
}
Row(horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
TextButton(onClick = { onDecision(ChatProtocol.DECISION_ONCE) }) { Text("Allow once") }
TextButton(onClick = { onDecision(ChatProtocol.DECISION_ALWAYS) }) { Text("Always") }
TextButton(onClick = { onDecision(ChatProtocol.DECISION_REJECT) }) { Text("Deny") }
}
}
}
}
@@ -0,0 +1,336 @@
package net.awan.pipelines.ui.chat
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import net.awan.pipelines.data.protocol.ChatEventFrame
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatPermissionFrame
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
/**
* A saved scroll position inside one conversation. Kept as Android-free
* primitives so it is part of the pure model and can survive a chat switch (the
* caller feeds it back into the list's state).
*/
data class ChatScrollPosition(val index: Int = 0, val offset: Int = 0)
/**
* One open conversation. The conversation itself, whether it is running, its
* unsent composer draft and its scroll position all live here, so switching to
* another chat and back can never lose any of them.
*/
data class ChatThread(
val sessionId: String,
val title: String = "",
val directory: String = "",
val model: String = "",
val agent: String = "",
val updatedAt: Long = 0,
/** The server reports another client (or an active run) holds this session. */
val busy: Boolean = false,
val messages: List<ChatMessage> = emptyList(),
val loading: Boolean = false,
val loaded: Boolean = false,
val error: String? = null,
/** A turn is in flight for this session; it keeps running when we switch away. */
val running: Boolean = false,
/** The unsent composer text for this chat. */
val draft: String = "",
val scroll: ChatScrollPosition = ChatScrollPosition(),
/** The server's pending approval for this session, answered with chat_reply. */
val permission: ChatPermissionFrame? = null,
) {
/**
* Read-only while another client holds the session: the composer must never
* write to it. A turn we started ourselves keeps the session writable even
* though the server reports it busy (the server owns it as our active run),
* so the one rule here agrees with [sessionStatusLabel]'s `Running` case.
*/
val readOnly: Boolean get() = busy && !running
/** Whether the composer's send action is allowed. */
val canSend: Boolean get() = !readOnly && draft.isNotBlank()
}
/**
* The multi-chat screen state. [sessions] is the server's list; [open] is the
* ordered set of conversations the operator has opened, each preserved
* independently; [activeId] is the one currently on screen.
*/
data class ChatState(
val sessions: List<ChatSession> = emptyList(),
val sessionsLoading: Boolean = false,
val sessionsLoaded: Boolean = false,
val sessionsError: String? = null,
val open: List<ChatThread> = emptyList(),
val activeId: String? = null,
) {
val active: ChatThread? get() = open.firstOrNull { it.sessionId == activeId }
fun thread(sessionId: String): ChatThread? = open.firstOrNull { it.sessionId == sessionId }
}
/**
* The multi-chat state model: a small, Android-free holder of [ChatState] with
* the transitions the chat surface needs. Keeping it free of Compose and of the
* transport makes the multi-chat guarantees (per-chat draft/scroll/conversation,
* running survives a switch and re-syncs on return) unit-testable without a
* device or a server.
*
* Method contracts that matter:
* - [open] and [activate] return true when the caller must (re-)fetch history;
* a running session must re-sync on return so a stale copy is never shown.
* - [event] applies a server frame to its session's thread whether or not that
* thread is on screen, so a background chat never loses its stream.
*/
class ChatStore {
private val _state = MutableStateFlow(ChatState())
val state: StateFlow<ChatState> = _state.asStateFlow()
val value: ChatState get() = _state.value
// ---- Session list --------------------------------------------------------
fun sessionsLoading() {
_state.value = _state.value.copy(sessionsLoading = true, sessionsError = null)
}
fun sessionsFailed(message: String) {
_state.value = _state.value.copy(sessionsLoading = false, sessionsError = message)
}
/**
* Replaces the server's session list and folds its title/busy flags into any
* already-open thread, so a status change is reflected without dropping the
* conversation. An open thread the server no longer lists is kept (its
* conversation is still the operator's).
*/
fun sessionsLoaded(sessions: List<ChatSession>) {
val byId = sessions.associateBy { it.id }
val open = _state.value.open.map { thread ->
val session = byId[thread.sessionId] ?: return@map thread
thread.copy(
title = session.title.ifBlank { thread.title },
directory = session.directory.ifBlank { thread.directory },
busy = session.busy,
)
}
_state.value = _state.value.copy(
sessions = sessions,
open = open,
sessionsLoading = false,
sessionsLoaded = true,
sessionsError = null,
)
}
// ---- Opening / switching -------------------------------------------------
/**
* Opens [session] (idempotently) and makes it active. Returns true when its
* history must be fetched: a brand-new thread always, and a re-opened one
* whose state may have moved on (it is running, or was never loaded).
*/
fun open(session: ChatSession): Boolean {
val existing = _state.value.thread(session.id)
if (existing == null) {
val thread = ChatThread(
sessionId = session.id,
title = session.title,
directory = session.directory,
model = session.model,
agent = session.agent,
updatedAt = session.updatedAt,
busy = session.busy,
)
_state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id)
return true
}
val merged = existing.copy(
title = session.title.ifBlank { existing.title },
directory = session.directory.ifBlank { existing.directory },
busy = session.busy,
)
_state.value = _state.value.copy(
open = _state.value.open.map { if (it.sessionId == session.id) merged else it },
activeId = session.id,
)
return needsResync(merged)
}
/**
* Makes an already-open thread active. Returns true when its history must be
* re-fetched first: a running session is re-synced from the server on return
* so the operator never sees a stale conversation.
*/
fun activate(sessionId: String): Boolean {
val thread = _state.value.thread(sessionId) ?: return false
_state.value = _state.value.copy(activeId = sessionId)
return needsResync(thread)
}
fun close(sessionId: String) {
val open = _state.value.open.filterNot { it.sessionId == sessionId }
val active = if (_state.value.activeId == sessionId) open.lastOrNull()?.sessionId else _state.value.activeId
_state.value = _state.value.copy(open = open, activeId = active)
}
/**
* Returns to the session list without closing any conversation: [activeId]
* becomes null while [ChatState.open] is untouched, so every open chat keeps
* its messages, draft and scroll.
*/
fun showList() {
if (_state.value.activeId != null) {
_state.value = _state.value.copy(activeId = null)
}
}
private fun needsResync(thread: ChatThread): Boolean = thread.running || !thread.loaded
// ---- Per-thread edits ----------------------------------------------------
fun draft(sessionId: String, text: String) = update(sessionId) { it.copy(draft = text) }
fun clearDraft(sessionId: String) = update(sessionId) { it.copy(draft = "") }
fun scroll(sessionId: String, index: Int, offset: Int) =
update(sessionId) { it.copy(scroll = ChatScrollPosition(index, offset)) }
fun historyLoading(sessionId: String) = update(sessionId) { it.copy(loading = true, error = null) }
fun failed(sessionId: String, message: String) =
update(sessionId) { it.copy(loading = false, error = message) }
/**
* Replaces a thread's conversation with the server's authoritative history.
* The running flag is left as-is: history alone cannot say whether a turn is
* still in flight.
*/
fun history(sessionId: String, messages: List<ChatMessage>) = update(sessionId) {
it.copy(messages = messages, loading = false, loaded = true, error = null)
}
fun running(sessionId: String, running: Boolean) = update(sessionId) { it.copy(running = running) }
/** The server pushed an approval request for this session; the composer answers it. */
fun permission(frame: ChatPermissionFrame) {
if (frame.sessionId.isBlank()) return
ensureThread(frame.sessionId)
update(frame.sessionId) { it.copy(permission = frame) }
}
/** Drops the pending approval once it has been answered or is no longer valid. */
fun clearPermission(sessionId: String) = update(sessionId) { it.copy(permission = null) }
/**
* Appends the operator's just-sent prompt optimistically, so the bubble is
* visible before the ack and history round-trip. History later reconciles it.
*/
fun appendLocalUserMessage(sessionId: String, text: String) = update(sessionId) {
val message = ChatMessage(
id = LOCAL_MESSAGE_PREFIX + (it.messages.count { m -> m.id.startsWith(LOCAL_MESSAGE_PREFIX) } + 1),
sessionId = sessionId,
role = ChatProtocol.ROLE_USER,
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)),
)
it.copy(messages = it.messages + message)
}
// ---- Streaming events ----------------------------------------------------
/**
* Folds one pushed [frame] into its session's thread, creating a placeholder
* thread when the frame arrives for a chat that is not open, so a background
* chat keeps its stream instead of dropping it.
*/
fun event(frame: ChatEventFrame) {
if (frame.sessionId.isBlank()) return
ensureThread(frame.sessionId)
when (frame.kind) {
ChatProtocol.PART_TEXT, ChatProtocol.PART_REASONING -> applyDelta(frame)
ChatProtocol.PART_TOOL -> applyTool(frame)
ChatProtocol.EVENT_STEP -> {
val started = frame.step?.status != ChatProtocol.STEP_ENDED
update(frame.sessionId) { it.copy(running = started) }
}
else -> Unit
}
}
/**
* Creates a placeholder thread for a session that is not open, so a frame for
* a background chat is kept instead of dropped. A no-op when it already exists.
*/
private fun ensureThread(sessionId: String) {
if (_state.value.thread(sessionId) != null) return
val session = _state.value.sessions.firstOrNull { it.id == sessionId }
val placeholder = ChatThread(
sessionId = sessionId,
title = session?.title ?: "",
directory = session?.directory ?: "",
busy = session?.busy ?: false,
)
_state.value = _state.value.copy(open = _state.value.open + placeholder)
}
private fun applyDelta(frame: ChatEventFrame) {
val partId = frame.part?.id.orEmpty()
if (partId.isEmpty() || frame.delta.isEmpty()) return
upsertPart(frame, partId) { existing ->
existing?.copy(text = existing.text + frame.delta)
?: ChatPart(type = frame.kind, id = partId, text = frame.delta)
}
}
private fun applyTool(frame: ChatEventFrame) {
val part = frame.part ?: return
if (part.id.isEmpty()) return
upsertPart(frame, part.id) { part }
}
/**
* Finds or creates the assistant message [frame] targets and the part [partId]
* inside it, replacing it via [upsert] (the old part when it exists, else
* null), then marks the thread running. The text/reasoning delta and the tool
* upsert share this so the two cannot drift.
*/
private fun upsertPart(frame: ChatEventFrame, partId: String, upsert: (ChatPart?) -> ChatPart) {
update(frame.sessionId) { thread ->
val messages = thread.messages.toMutableList()
val index = messages.indexOfLast { it.id == frame.messageId }
val message = if (index >= 0) {
messages[index]
} else {
ChatMessage(
id = frame.messageId,
sessionId = frame.sessionId,
role = ChatProtocol.ROLE_ASSISTANT,
).also { messages.add(it) }
}
val resolvedIndex = if (index >= 0) index else messages.lastIndex
val parts = message.parts.toMutableList()
val partIndex = parts.indexOfFirst { it.id == partId }
val updated = upsert(if (partIndex >= 0) parts[partIndex] else null)
if (partIndex >= 0) parts[partIndex] = updated else parts.add(updated)
messages[resolvedIndex] = message.copy(parts = parts)
thread.copy(messages = messages, running = true)
}
}
private fun update(sessionId: String, block: (ChatThread) -> ChatThread) {
val current = _state.value
if (current.open.none { it.sessionId == sessionId }) return
_state.value = current.copy(
open = current.open.map { if (it.sessionId == sessionId) block(it) else it },
)
}
companion object {
const val LOCAL_MESSAGE_PREFIX = "local-"
}
}
@@ -0,0 +1,221 @@
package net.awan.pipelines.data.protocol
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class ChatProtocolTest {
@Test
fun chatSessionsParseWithBusyFlagAndFlattenedFields() {
val json = """
{
"type": "chat_sessions",
"id": "android-1",
"chat_sessions": [
{
"id": "ses_abc",
"title": "Fix the parser",
"agent": "build",
"model": "deepseek-v4.1-flash",
"directory": "/Users/alan/repos/pipelines",
"parent_id": "",
"created_at": 1792112366711,
"updated_at": 1792112367036,
"busy": true
},
{"id": "ses_def", "title": "Second chat"}
]
}
""".trimIndent()
val message = PipelinesJson.decodeFromString(Message.serializer(), json)
assertEquals(Protocol.CHAT_SESSIONS, message.type)
val sessions = message.chatSessions!!
assertEquals(2, sessions.size)
val first = sessions.first()
assertEquals("ses_abc", first.id)
assertEquals("Fix the parser", first.title)
assertEquals("/Users/alan/repos/pipelines", first.directory)
assertEquals(1792112366711L, first.createdAt)
assertTrue(first.busy)
// An absent busy key defaults to false, never a crash.
assertTrue(!sessions[1].busy)
}
@Test
fun chatMessagesParseTextReasoningAndToolParts() {
val json = """
{
"type": "chat_messages",
"chat_messages": [
{
"id": "msg_user",
"session_id": "ses_abc",
"role": "user",
"parts": [{"type": "text", "id": "p1", "text": "hello"}]
},
{
"id": "msg_asst",
"session_id": "ses_abc",
"role": "assistant",
"parts": [
{"type": "reasoning", "id": "r1", "text": "thinking"},
{"type": "text", "id": "t1", "text": "done"},
{
"type": "tool",
"id": "call_1",
"name": "shell",
"executed": false,
"state": {
"status": "completed",
"input": {"command": "ls"},
"content": [{"type": "text", "text": "a.txt"}],
"metadata": {"exit": 0},
"error": null
},
"time": {"created": 10, "ran": 12, "completed": 20}
}
]
}
]
}
""".trimIndent()
val messages = PipelinesJson.decodeFromString(Message.serializer(), json).chatMessages!!
assertEquals(2, messages.size)
assertEquals(ChatProtocol.ROLE_USER, messages[0].role)
assertEquals("hello", messages[0].parts.single().text)
val assistant = messages[1]
assertEquals(ChatProtocol.PART_REASONING, assistant.parts[0].type)
val tool = assistant.parts.first { it.type == ChatProtocol.PART_TOOL }
assertEquals("shell", tool.name)
assertEquals(ChatProtocol.TOOL_COMPLETED, tool.state!!.status)
assertTrue(tool.state!!.input is JsonObject)
assertEquals("a.txt", tool.state!!.content.single().text)
assertEquals(8L, toolDuration(tool))
}
/** The tool input is a partial-JSON string while streaming and an object afterwards. */
@Test
fun streamingToolInputIsAStringAndCompletedInputIsAnObject() {
val streaming = """
{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"m1","kind":"tool",
"part":{"type":"tool","id":"c1","name":"edit","state":{"status":"streaming","input":"{\"old"}}}}
""".trimIndent()
val frame = PipelinesJson.decodeFromString(Message.serializer(), streaming).chatEvent!!
assertEquals(ChatProtocol.TOOL_STREAMING, frame.part!!.state!!.status)
assertEquals("{\"old", (frame.part!!.state!!.input as JsonPrimitive).content)
assertTrue(ChatProtocol.toolRunning(frame.part!!.state))
}
@Test
fun chatEventDeltaCarriesTheTargetPartAndText() {
val json = """
{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"m1","kind":"text",
"delta":"wor","part":{"type":"text","id":"t1"}}}
""".trimIndent()
val frame = PipelinesJson.decodeFromString(Message.serializer(), json).chatEvent!!
assertEquals("ses_1", frame.sessionId)
assertEquals("m1", frame.messageId)
assertEquals(ChatProtocol.PART_TEXT, frame.kind)
assertEquals("wor", frame.delta)
assertEquals("t1", frame.part!!.id)
}
@Test
fun stepAndUsageFramesDecode() {
val step = """
{"type":"chat_event","chat_event":{"session_id":"s","kind":"step","step":{"status":"ended","index":3}}}
""".trimIndent()
val decodedStep = PipelinesJson.decodeFromString(Message.serializer(), step).chatEvent!!
assertEquals(ChatProtocol.EVENT_STEP, decodedStep.kind)
assertEquals(ChatProtocol.STEP_ENDED, decodedStep.step!!.status)
val usage = """
{"type":"chat_event","chat_event":{"session_id":"s","kind":"usage",
"usage":{"input_tokens":12,"output_tokens":34,"cost":0.002}}}
""".trimIndent()
val decodedUsage = PipelinesJson.decodeFromString(Message.serializer(), usage).chatEvent!!
assertEquals(12, decodedUsage.usage!!.inputTokens)
assertEquals(34, decodedUsage.usage!!.outputTokens)
assertEquals(0.002, decodedUsage.usage!!.cost, 0.0)
}
@Test
fun chatPermissionFrameDecodesTheRequestShape() {
val json = """
{"type":"chat_permission","chat_permission":{"session_id":"ses_1","request_id":"req_9",
"action":"edit","resources":["src/a.kt"],
"source":{"type":"tool","message_id":"m1","id":"c1"},
"message":"Allow this edit?"}}
""".trimIndent()
val permission = PipelinesJson.decodeFromString(Message.serializer(), json).chatPermission!!
assertEquals("req_9", permission.requestId)
assertEquals("edit", permission.action)
assertEquals("src/a.kt", permission.resources.single())
assertEquals("c1", permission.source!!.id)
}
@Test
fun chatRequestsRoundTripTheirBodies() {
val create = Message(
type = Protocol.CHAT_CREATE,
id = "android-1",
chatCreate = ChatCreateRequest(title = "New chat", directory = "/work"),
)
val createJson = PipelinesJson.encodeToString(Message.serializer(), create)
assertTrue(createJson.contains("\"chat_create\""))
val decodedCreate = PipelinesJson.decodeFromString(Message.serializer(), createJson)
assertEquals("New chat", decodedCreate.chatCreate!!.title)
val prompt = Message(
type = Protocol.CHAT_PROMPT,
id = "android-2",
chatPrompt = ChatPromptRequest(sessionId = "ses_1", text = "hi"),
)
val decodedPrompt = PipelinesJson.decodeFromString(
Message.serializer(),
PipelinesJson.encodeToString(Message.serializer(), prompt),
)
assertEquals("ses_1", decodedPrompt.chatPrompt!!.sessionId)
assertEquals("hi", decodedPrompt.chatPrompt!!.text)
val query = Message(type = Protocol.CHAT_MESSAGES, id = "android-3", chatQuery = ChatQuery("ses_1", 50))
val decodedQuery = PipelinesJson.decodeFromString(
Message.serializer(),
PipelinesJson.encodeToString(Message.serializer(), query),
)
assertEquals("ses_1", decodedQuery.chatQuery!!.sessionId)
assertEquals(50, decodedQuery.chatQuery!!.limit)
val reply = Message(
type = Protocol.CHAT_REPLY,
id = "android-4",
chatReply = ChatReplyRequest("ses_1", "req_9", ChatProtocol.DECISION_ONCE),
)
val decodedReply = PipelinesJson.decodeFromString(
Message.serializer(),
PipelinesJson.encodeToString(Message.serializer(), reply),
)
assertEquals(ChatProtocol.DECISION_ONCE, decodedReply.chatReply!!.decision)
}
/** A non-chat envelope leaves every chat field null, so the two never cross-talk. */
@Test
fun nonChatEnvelopeHasNoChatPayload() {
val message = PipelinesJson.decodeFromString(
Message.serializer(),
"""{"type":"pong"}""",
)
assertNull(message.chatEvent)
assertNull(message.chatSessions)
assertNull(message.chatPermission)
}
private fun toolDuration(part: ChatPart): Long? {
val time = part.time ?: return null
return time.completed - time.ran
}
}
@@ -0,0 +1,103 @@
package net.awan.pipelines.ui.chat
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.ChatTime
import net.awan.pipelines.data.protocol.ChatToolContent
import net.awan.pipelines.data.protocol.ChatToolState
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
class ChatFormatTest {
@Test
fun prettyToolInputPrintsObjectsAndPassesThroughPartialStrings() {
val obj = prettyToolInput(JsonObject(mapOf("command" to JsonPrimitive("ls"))))
assertTrue(obj.contains("\"command\""))
assertTrue(obj.contains("\n"))
assertEquals("{\"old", prettyToolInput(JsonPrimitive("{\"old")))
assertEquals("", prettyToolInput(null))
}
@Test
fun toolOutputFallsBackToNoOutputOrError() {
val completed = ChatToolState(
status = ChatProtocol.TOOL_COMPLETED,
content = listOf(ChatToolContent(type = "text", text = "hello")),
)
assertEquals("hello", toolOutputText(completed))
assertEquals(
"(no output)",
toolOutputText(ChatToolState(status = ChatProtocol.TOOL_COMPLETED)),
)
val failed = ChatToolState(
status = ChatProtocol.TOOL_ERROR,
error = net.awan.pipelines.data.protocol.ChatError(type = "boom", message = "exploded"),
)
assertEquals("exploded", toolOutputText(failed))
// Still streaming -> nothing yet, never the "(no output)" claim.
assertEquals("", toolOutputText(ChatToolState(status = ChatProtocol.TOOL_RUNNING)))
}
@Test
fun toolDurationUsesRanToCompletedAndIsNullWhileRunning() {
val done = ChatPart(name = "shell", time = ChatTime(created = 5, ran = 10, completed = 35))
assertEquals(25L, toolDurationMillis(done))
assertNull(toolDurationMillis(ChatPart(name = "shell", time = ChatTime(created = 5))))
assertEquals("340ms", formatToolDuration(340))
assertEquals("1.5s", formatToolDuration(1500))
}
@Test
fun sessionStatusReportsRunningBusyAndIdle() {
assertEquals("Running", sessionStatusLabel(ChatSession(id = "s"), runningLocally = true))
assertEquals(
"Busy · read-only",
sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false),
)
assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s"), runningLocally = false))
}
@Test
fun toolEditDiffMarksOnlyChangedLinesAndCountsThem() {
val input = JsonObject(
mapOf(
"filePath" to JsonPrimitive("/tmp/a.txt"),
"oldString" to JsonPrimitive("one\ntwo\nthree"),
"newString" to JsonPrimitive("one\nTWO\nthree\nfour"),
),
)
val diff = toolEditDiff(input)!!
assertEquals("/tmp/a.txt", diff.file)
assertEquals(2, diff.added)
assertEquals(1, diff.removed)
assertEquals(
listOf(
DiffLine(DiffKind.CONTEXT, "one"),
DiffLine(DiffKind.REMOVE, "two"),
DiffLine(DiffKind.ADD, "TWO"),
DiffLine(DiffKind.CONTEXT, "three"),
DiffLine(DiffKind.ADD, "four"),
),
diff.lines,
)
}
@Test
fun toolEditDiffIsNullForNonEdits() {
assertNull(toolEditDiff(null))
assertNull(toolEditDiff(JsonObject(mapOf("command" to JsonPrimitive("ls")))))
}
@Test
fun sessionTitleNeverBlank() {
assertEquals("Named", sessionTitle(ChatSession(id = "ses_1", title = "Named")))
assertEquals("ses_abcdefghijklmn", sessionTitle(ChatSession(id = "ses_abcdefghijklmnop")))
}
}
@@ -0,0 +1,217 @@
package net.awan.pipelines.ui.chat
import net.awan.pipelines.data.protocol.ChatEventFrame
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatPermissionFrame
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* The multi-chat state guarantees: each open chat preserves its own conversation,
* a running session re-syncs when the operator returns to it, and the draft and
* scroll position are per chat. Driven directly against [ChatStore], with no
* device, server or Compose runtime.
*/
class MultiChatStateTest {
private fun session(id: String, title: String = id, busy: Boolean = false) =
ChatSession(id = id, title = title, busy = busy)
private fun text(id: String, role: String, body: String) = ChatMessage(
id = id,
sessionId = "",
role = role,
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "$id-p", text = body)),
)
@Test
fun switchingPreservesEachConversation() {
val store = ChatStore()
assertTrue(store.open(session("a", "Chat A")))
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "first"), text("a2", ChatProtocol.ROLE_ASSISTANT, "reply A")))
assertTrue(store.open(session("b", "Chat B")))
store.history("b", listOf(text("b1", ChatProtocol.ROLE_USER, "different")))
// Returning to A shows A's conversation, untouched by B. A loaded,
// settled chat needs no re-sync.
assertFalse(store.activate("a"))
assertEquals(listOf("a1", "a2"), store.value.thread("a")!!.messages.map { it.id })
assertEquals("a", store.value.activeId)
assertFalse(store.activate("b"))
assertEquals(listOf("b1"), store.value.thread("b")!!.messages.map { it.id })
}
@Test
fun runningSessionResyncsOnReturn() {
val store = ChatStore()
store.open(session("a"))
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "prompt")))
store.running("a", true)
store.open(session("b"))
store.history("b", emptyList())
// Switching to B must not cancel A's running turn.
store.activate("b")
assertTrue(store.value.thread("a")!!.running)
// Returning to the running chat reports that it must be re-synced.
assertTrue(store.activate("a"))
// The re-sync replaces the conversation with the server's copy and keeps running.
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "prompt"), text("a2", ChatProtocol.ROLE_ASSISTANT, "live")))
val resynced = store.value.thread("a")!!
assertTrue(resynced.running)
assertEquals("live", resynced.messages.last().parts.single().text)
// Once it settles, a later return does not force another re-sync.
store.running("a", false)
store.activate("b")
assertFalse(store.activate("a"))
}
@Test
fun draftsArePerChat() {
val store = ChatStore()
store.open(session("a"))
store.open(session("b"))
store.draft("a", "hello from A")
store.draft("b", "typed in B")
store.activate("a")
assertEquals("hello from A", store.value.thread("a")!!.draft)
store.activate("b")
assertEquals("typed in B", store.value.thread("b")!!.draft)
// Clearing one chat's draft never touches the other's.
store.clearDraft("b")
assertEquals("", store.value.thread("b")!!.draft)
assertEquals("hello from A", store.value.thread("a")!!.draft)
}
@Test
fun scrollPositionIsPerChat() {
val store = ChatStore()
store.open(session("a"))
store.open(session("b"))
store.scroll("a", 7, 12)
store.scroll("b", 1, 0)
assertEquals(ChatScrollPosition(7, 12), store.value.thread("a")!!.scroll)
assertEquals(ChatScrollPosition(1, 0), store.value.thread("b")!!.scroll)
}
@Test
fun busySessionIsReadOnlyAndCannotSend() {
val store = ChatStore()
store.open(session("a", busy = true))
store.draft("a", "unsent")
val thread = store.value.thread("a")!!
assertTrue(thread.readOnly)
assertFalse(thread.canSend)
// The server can clear busy later; the chat then becomes writable again.
store.sessionsLoaded(listOf(session("a", busy = false)))
store.draft("a", "unsent")
assertFalse(store.value.thread("a")!!.readOnly)
assertTrue(store.value.thread("a")!!.canSend)
}
@Test
fun sessionsLoadedMergesStatusWithoutDroppingOpenConversations() {
val store = ChatStore()
store.open(session("a", "Chat A"))
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "keep me")))
// The server now reports A busy and adds a new session B.
store.sessionsLoaded(listOf(session("a", "Chat A renamed", busy = true), session("b", "Chat B")))
val thread = store.value.thread("a")!!
assertEquals("Chat A renamed", thread.title)
assertTrue(thread.busy)
assertEquals(listOf("a1"), thread.messages.map { it.id })
assertEquals(2, store.value.sessions.size)
}
@Test
fun backgroundEventsApplyToTheirChatAndCreateAPlaceholder() {
val store = ChatStore()
store.open(session("a"))
store.history("a", listOf(text("a1", ChatProtocol.ROLE_USER, "go")))
store.open(session("b")) // B is active
// A delta for the background chat A lands on A, not on B, and B stays active.
store.event(
ChatEventFrame(
sessionId = "a",
messageId = "a2",
kind = ChatProtocol.PART_TEXT,
delta = "streaming",
part = ChatPart(type = ChatProtocol.PART_TEXT, id = "a2-p"),
),
)
assertEquals("streaming", store.value.thread("a")!!.messages.last().parts.single().text)
assertEquals("b", store.value.activeId)
// A frame for a chat that was never opened creates a placeholder thread.
store.event(
ChatEventFrame(
sessionId = "c",
messageId = "c1",
kind = ChatProtocol.PART_TEXT,
delta = "hi",
part = ChatPart(type = ChatProtocol.PART_TEXT, id = "c1-p"),
),
)
assertNotNull(store.value.thread("c"))
assertEquals("hi", store.value.thread("c")!!.messages.single().parts.single().text)
}
@Test
fun stepFramesTrackRunningState() {
val store = ChatStore()
store.open(session("a"))
store.event(ChatEventFrame(sessionId = "a", kind = ChatProtocol.EVENT_STEP, step = net.awan.pipelines.data.protocol.ChatStep(status = ChatProtocol.STEP_STARTED)))
assertTrue(store.value.thread("a")!!.running)
store.event(ChatEventFrame(sessionId = "a", kind = ChatProtocol.EVENT_STEP, step = net.awan.pipelines.data.protocol.ChatStep(status = ChatProtocol.STEP_ENDED)))
assertFalse(store.value.thread("a")!!.running)
}
@Test
fun locallyRunningBusyChatStaysWritable() {
val store = ChatStore()
store.open(session("a", busy = true))
store.running("a", true)
// Our own turn keeps the session writable even though the server reports it busy.
store.draft("a", "next prompt")
val thread = store.value.thread("a")!!
assertFalse(thread.readOnly)
assertTrue(thread.canSend)
}
@Test
fun permissionIsStoredUntilAnswered() {
val store = ChatStore()
store.open(session("a"))
store.permission(ChatPermissionFrame(sessionId = "a", requestId = "r1", action = "edit"))
assertEquals("r1", store.value.thread("a")!!.permission!!.requestId)
store.clearPermission("a")
assertNull(store.value.thread("a")!!.permission)
}
@Test
fun closeRemovesOnlyThatChat() {
val store = ChatStore()
store.open(session("a"))
store.open(session("b"))
store.close("a")
assertFalse(store.value.open.any { it.sessionId == "a" })
assertTrue(store.value.open.any { it.sessionId == "b" })
}
}