From 36d1c8ea7aef06d4669a163271902caa569d6513 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 21:45:56 +0100 Subject: [PATCH] chat: preserve cross-client reconciliation work --- .../pipelines/data/PipelinesRepository.kt | 4 +- .../net/awan/pipelines/data/protocol/Chat.kt | 7 +- .../net/awan/pipelines/ui/AppViewModel.kt | 5 +- .../net/awan/pipelines/ui/chat/ChatStore.kt | 47 +++++++++++- .../pipelines/ui/chat/MultiChatStateTest.kt | 75 +++++++++++++++++++ .../cross-client-message-reconciliation.md | 7 ++ internal/protocol/chat.go | 21 +++--- internal/server/chat_commands.go | 1 + internal/server/chat_hub.go | 54 +++++++++++-- internal/server/chat_room.go | 9 ++- internal/server/chat_stream.go | 18 +++-- 11 files changed, 213 insertions(+), 35 deletions(-) create mode 100644 docs/notes/cross-client-message-reconciliation.md diff --git a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt index bb59e9e5..ab08e775 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt @@ -331,11 +331,11 @@ class PipelinesRepository( * prompt the operator actually sent — never on their own. Returns true when the * server queued the prompt behind an in-flight turn. */ - suspend fun chatPrompt(sessionId: String, text: String, files: List = emptyList()): Boolean { + suspend fun chatPrompt(sessionId: String, text: String, files: List = emptyList(), operationId: String = newRequestKey()): Boolean { if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.") val trimmed = text.trim() if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.") - return client.call(ChatProtocol.promptRequest(sessionId, trimmed, files, clientLabel)).chatQueued + return client.call(ChatProtocol.promptRequest(sessionId, trimmed, files, clientLabel, operationId)).chatQueued } suspend fun chatInterrupt(sessionId: String) { diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt index d76fc86c..0390de90 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt @@ -81,6 +81,7 @@ data class ChatPromptRequest( // client can attribute the message; the server sanitises it and falls back to // a generic label when it is blank. val client: String = "", + @SerialName("operation_id") val operationId: String = "", ) /** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */ @@ -95,6 +96,7 @@ data class ChatMessage( // The sending device's label on a user turn the server echoed, so a resumed // transcript still says who sent the message. Empty on an assistant turn. val client: String = "", + @SerialName("operation_id") val operationId: String = "", val parts: List = emptyList(), ) @@ -183,6 +185,7 @@ data class ChatEventFrame( // The sending device's label on a `user` frame (another client's prompt), so // the transcript can say who sent it. Empty on the agent's own frames. val client: String = "", + @SerialName("operation_id") val operationId: String = "", ) /** @@ -334,10 +337,10 @@ object ChatProtocol { * shape a text-only prompt has always sent). Built here (not inline in the * repository) so production and its unit test share the one wire shape. */ - fun promptRequest(sessionId: String, text: String, files: List = emptyList(), client: String = ""): Message = + fun promptRequest(sessionId: String, text: String, files: List = emptyList(), client: String = "", operationId: String = ""): Message = Message( type = Protocol.CHAT_PROMPT, - chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files, client = client), + chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files, client = client, operationId = operationId), ) /** diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 1309d46b..67158648 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -1173,11 +1173,12 @@ class AppViewModel( private fun postChatPrompt(sessionId: String, text: String, attachments: List) { val body = text.trim() if (body.isEmpty()) return - val localId = chatStore.appendLocalUserMessage(sessionId, body, attachments) ?: return + val operationId = PipelinesRepository.newRequestKey() + val localId = chatStore.appendLocalUserMessage(sessionId, body, attachments, operationId) ?: return chatStore.running(sessionId, true) viewModelScope.launch { try { - val queued = repository.chatPrompt(sessionId, body, attachmentFiles(attachments)) + val queued = repository.chatPrompt(sessionId, body, attachmentFiles(attachments), operationId) // The server accepted the prompt (queued or sent); a queued prompt // is one waiting behind an in-flight turn, and the composer says so // instead of blocking input. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index cb0d241e..98e6501a 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -845,15 +845,40 @@ class ChatStore( fun history(sessionId: String, messages: List, nextCursor: String = "", hasMore: Boolean = false) { update(sessionId) { val existing = it.messages.associateBy { message -> message.id } + val optimisticByOperation = it.messages + .asSequence() + .filter { message -> message.id.startsWith(LOCAL_MESSAGE_PREFIX) && message.operationId.isNotBlank() } + .associateBy { message -> message.operationId } + val reconciledIds = messages.asSequence() + .mapNotNull { message -> optimisticByOperation[message.operationId]?.id } + .toSet() + val authoritativeMessages = messages.map { message -> + val optimistic = optimisticByOperation[message.operationId] + if (optimistic == null || message.role != ChatProtocol.ROLE_USER) { + message + } else { + // History is authoritative for identity and ordering, but it + // does not carry the phone's local attachment parts or live + // fields. Keep those fields on the same turn while replacing + // the temporary local id. + message.copy( + client = message.client.ifBlank { optimistic.client }, + parts = message.parts + optimistic.parts.filter { localPart -> + localPart.type == ChatProtocol.PART_FILE && message.parts.none { it.type == ChatProtocol.PART_FILE && it.uri == localPart.uri } + }, + ) + } + } val baseline = it.historyBeforeLoad?.associateBy { message -> message.id } - val pageIds = messages.mapTo(mutableSetOf()) { message -> message.id } + val pageIds = authoritativeMessages.mapTo(mutableSetOf()) { message -> message.id } val firstOverlap = it.messages.indexOfFirst { message -> message.id in pageIds } val olderPrefix = when { firstOverlap >= 0 -> it.messages.take(firstOverlap) it.historyBeforeLoad != null && !it.historyLoadOlder -> it.messages else -> emptyList() } - val merged = (olderPrefix + messages + it.messages).fold(LinkedHashMap()) { result, message -> + val merged = (olderPrefix + authoritativeMessages + it.messages.filterNot { message -> message.id in reconciledIds }) + .fold(LinkedHashMap()) { result, message -> // A live event may have extended this message while the read was // in flight. Preserve only that fold, not stale pre-request cache // which would otherwise hide text missed during a disconnect. @@ -988,6 +1013,7 @@ class ChatStore( sessionId: String, text: String, attachments: List = emptyList(), + operationId: String = "", ): String? { var id: String? = null update(sessionId) { thread -> @@ -996,6 +1022,7 @@ class ChatStore( id = id!!, sessionId = sessionId, role = ChatProtocol.ROLE_USER, + operationId = operationId, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)) + attachments.map { attachmentPart(it) }, ) @@ -1068,12 +1095,28 @@ class ChatStore( val text = frame.part?.text.orEmpty() if (frame.messageId.isEmpty() || text.isEmpty()) return update(frame.sessionId) { thread -> + val optimistic = thread.messages.firstOrNull { + it.role == ChatProtocol.ROLE_USER && + it.id.startsWith(LOCAL_MESSAGE_PREFIX) && + frame.operationId.isNotBlank() && it.operationId == frame.operationId + } + if (optimistic != null) { + val replacement = optimistic.copy(id = frame.messageId, client = frame.client.ifBlank { optimistic.client }) + return@update thread.copy(messages = thread.messages.map { if (it.id == optimistic.id) replacement else it }) + } + // A replay can arrive after authoritative history has already + // replaced the optimistic id. Operation identity is a correlation + // key, not a second message id. + if (frame.operationId.isNotBlank() && thread.messages.any { + it.role == ChatProtocol.ROLE_USER && it.operationId == frame.operationId + }) return@update thread if (thread.messages.any { it.id == frame.messageId }) return@update thread val message = ChatMessage( id = frame.messageId, sessionId = frame.sessionId, role = ChatProtocol.ROLE_USER, client = frame.client, + operationId = frame.operationId, parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)), ) thread.copy(messages = thread.messages + message) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt index b6f6666e..9b07c3d1 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt @@ -317,6 +317,81 @@ class MultiChatStateTest { assertEquals(2, store.value.thread("a")!!.messages.size) } + @Test + fun canonicalUserEventReplacesOptimisticTurnByOperationIdentity() { + val store = ChatStore() + store.open(session("a")) + val local = store.appendLocalUserMessage("a", "X", operationId = "op-x")!! + store.event(ChatEventFrame( + sessionId = "a", + messageId = "native-x", + kind = ChatProtocol.EVENT_USER, + operationId = "op-x", + client = "Phone", + part = ChatPart(type = ChatProtocol.PART_TEXT, text = "X"), + )) + + val messages = store.value.thread("a")!!.messages + assertEquals(listOf("native-x"), messages.map { it.id }) + assertEquals("Phone", messages.single().client) + assertEquals("op-x", messages.single().operationId) + assertFalse(messages.any { it.id == local }) + } + + @Test + fun delayedHistoryReconcilesOptimisticTurnAndKeepsDistinctRepeatedText() { + val store = ChatStore() + store.open(session("a")) + val attachmentUri = "content://x" + store.appendLocalUserMessage("a", "X", listOf(ChatAttachment(uri = attachmentUri, name = "x.txt", mime = "text/plain")), "op-x") + store.event(ChatEventFrame( + sessionId = "a", messageId = "native-x", kind = ChatProtocol.EVENT_USER, + operationId = "op-x", client = "Phone", part = ChatPart(type = ChatProtocol.PART_TEXT, text = "X"), + )) + store.event(ChatEventFrame( + sessionId = "a", messageId = "native-y", kind = ChatProtocol.EVENT_USER, + operationId = "op-y", client = "Computer", part = ChatPart(type = ChatProtocol.PART_TEXT, text = "Y"), + )) + // A replayed X is an idempotent delivery, not another turn. + store.event(ChatEventFrame( + sessionId = "a", messageId = "native-x", kind = ChatProtocol.EVENT_USER, + operationId = "op-x", client = "Phone", part = ChatPart(type = ChatProtocol.PART_TEXT, text = "X"), + )) + // A later, genuinely different X remains a separate message. + store.event(ChatEventFrame( + sessionId = "a", messageId = "native-x-2", kind = ChatProtocol.EVENT_USER, + operationId = "op-x-2", client = "Phone", part = ChatPart(type = ChatProtocol.PART_TEXT, text = "X"), + )) + + val messages = store.value.thread("a")!!.messages + assertEquals(listOf("native-x", "native-y", "native-x-2"), messages.map { it.id }) + assertEquals(listOf("X", "Y", "X"), messages.map { it.parts.first().text }) + assertEquals(listOf("Phone", "Computer", "Phone"), messages.map { it.client }) + assertEquals(listOf("op-x", "op-y", "op-x-2"), messages.map { it.operationId }) + assertEquals(attachmentUri, messages.first().parts.firstOrNull { it.type == ChatProtocol.PART_FILE }?.uri) + } + + @Test + fun historyOperationIdentityReplacesLocalIdWithoutDroppingAttachment() { + val store = ChatStore() + store.open(session("a")) + store.appendLocalUserMessage( + "a", "X", + listOf(ChatAttachment(uri = "content://x", name = "x.txt", mime = "text/plain")), + "op-x", + ) + store.history("a", listOf(ChatMessage( + id = "native-x", sessionId = "a", role = ChatProtocol.ROLE_USER, + client = "Phone", operationId = "op-x", + parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = "X")), + ))) + + val message = store.value.thread("a")!!.messages.single() + assertEquals("native-x", message.id) + assertEquals("op-x", message.operationId) + assertTrue(message.parts.any { it.type == ChatProtocol.PART_FILE && it.uri == "content://x" }) + } + @Test fun remoteAnswerClearsTheApprovalCard() { val store = ChatStore() diff --git a/docs/notes/cross-client-message-reconciliation.md b/docs/notes/cross-client-message-reconciliation.md new file mode 100644 index 00000000..97562676 --- /dev/null +++ b/docs/notes/cross-client-message-reconciliation.md @@ -0,0 +1,7 @@ +# Cross-client message reconciliation + +The chat wire contract now carries a durable prompt operation identity through the +optimistic Android message and the server's cross-client user event. Existing +shared README/topic and packaged skill references that describe user echoes as +connection-local are stale; `docs-fold` should update them. This item does not +edit shared documentation. diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 2355560f..8d0cc609 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -218,12 +218,13 @@ type ChatHistoryPage struct { // message; the server sanitises it and falls back to a generic label when it is // blank. type ChatPromptRequest struct { - SessionID string `json:"session_id"` - Text string `json:"text"` - Model string `json:"model,omitempty"` - Agent string `json:"agent,omitempty"` - Files []string `json:"files,omitempty"` - Client string `json:"client,omitempty"` + SessionID string `json:"session_id"` + Text string `json:"text"` + Model string `json:"model,omitempty"` + Agent string `json:"agent,omitempty"` + Files []string `json:"files,omitempty"` + Client string `json:"client,omitempty"` + OperationID string `json:"operation_id,omitempty"` } // ChatMessage is one stored turn returned by chat_messages. A user turn is a @@ -239,8 +240,9 @@ type ChatMessage struct { // Client is the sending device's label on a user turn the server echoed, so a // resumed transcript still says who sent the message. It is empty on an // assistant turn. - Client string `json:"client,omitempty"` - Parts []ChatPart `json:"parts"` + Client string `json:"client,omitempty"` + OperationID string `json:"operation_id,omitempty"` + Parts []ChatPart `json:"parts"` } // ChatDeltaPartID is the stable part id an incremental text or reasoning delta @@ -328,7 +330,8 @@ type ChatEventFrame struct { Shell *ChatShell `json:"shell,omitempty"` // Client is the sending device's label on a user frame (ChatEventUser), so a // transcript can say who sent the message. It is empty on assistant frames. - Client string `json:"client,omitempty"` + Client string `json:"client,omitempty"` + OperationID string `json:"operation_id,omitempty"` } // ChatStep is a progress marker for the current step of a turn. diff --git a/internal/server/chat_commands.go b/internal/server/chat_commands.go index d9efa1f9..766ec885 100644 --- a/internal/server/chat_commands.go +++ b/internal/server/chat_commands.go @@ -26,6 +26,7 @@ func handleChatMessages(ctx context.Context, request protocol.Message, broker ch _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } + page.Messages = hub.reconcileHistory(query.SessionID, page.Messages) response.ChatMessages = page.Messages // legacy peers keep working. response.ChatHistory = &page _ = write(response) diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index 9bd7e32e..e2ea42d0 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -55,11 +55,12 @@ type chatPart struct { // are carried for a user turn the server echoed (a prompt another client sent), // so a resumed transcript still says who sent it. type chatMessage struct { - id string - role string - client string - order []string - parts map[string]*chatPart + id string + role string + client string + operationID string + order []string + parts map[string]*chatPart } type chatTurn struct { @@ -168,12 +169,15 @@ func (h *chatHub) applyLocked(frame protocol.ChatEventFrame) { role = protocol.ChatRoleUser client = frame.Client } - message = &chatMessage{id: frame.MessageID, role: role, client: client, parts: map[string]*chatPart{}} + message = &chatMessage{id: frame.MessageID, role: role, client: client, operationID: frame.OperationID, parts: map[string]*chatPart{}} turn.order = append(turn.order, frame.MessageID) turn.messages[frame.MessageID] = message } else if message.client == "" && frame.Kind == protocol.ChatEventUser { message.client = frame.Client } + if message.operationID == "" && frame.Kind == protocol.ChatEventUser { + message.operationID = frame.OperationID + } switch frame.Kind { case protocol.ChatEventUser: if frame.Part == nil || frame.Part.ID == "" || frame.Part.Text == "" || turn.overflow { @@ -448,6 +452,7 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage { out.Role = message.role } out.Client = message.client + out.OperationID = message.operationID for _, partID := range message.order { if part, ok := message.parts[partID]; ok { piece := part.part @@ -460,6 +465,43 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage { return messages } +// reconcileHistory annotates an authoritative page with operation identities +// from the retained live user turns. Pairing is by the backend's message order, +// never by text, timestamps, or a connection/request id. It is deliberately +// conservative: a partial page cannot establish a safe one-to-one mapping. +func (h *chatHub) reconcileHistory(sessionID string, messages []protocol.ChatMessage) []protocol.ChatMessage { + h.mu.Lock() + defer h.mu.Unlock() + turn := h.turns[sessionID] + if turn == nil { + return messages + } + var live []*chatMessage + for _, id := range turn.order { + message := turn.messages[id] + if message != nil && message.role == protocol.ChatRoleUser && message.operationID != "" { + live = append(live, message) + } + } + var users []int + for i := range messages { + if messages[i].Role == protocol.ChatRoleUser { + users = append(users, i) + } + } + if len(users) == 0 || len(users) != len(live) { + return messages + } + out := append([]protocol.ChatMessage(nil), messages...) + for i, index := range users { + out[index].OperationID = live[i].operationID + if out[index].Client == "" { + out[index].Client = live[i].client + } + } + return out +} + // shellSnapshot returns the session's still-running shells, in the order they // started, so a client attaching to the session's stream can be re-synced the // background processes it cannot have seen. It is the shell half of the resume diff --git a/internal/server/chat_room.go b/internal/server/chat_room.go index a8d0ecc5..e9ec97fb 100644 --- a/internal/server/chat_room.go +++ b/internal/server/chat_room.go @@ -100,10 +100,11 @@ func (s *chatSub) close() { // request id; write is kept either way so a later broker failure is still // reported to the client that sent it. type chatQueuedPrompt struct { - text string - requestID string - write func(protocol.Message) error - acked bool + text string + operationID string + requestID string + write func(protocol.Message) error + acked bool } type chatObservation struct { diff --git a/internal/server/chat_stream.go b/internal/server/chat_stream.go index 89ba6404..e6433b0b 100644 --- a/internal/server/chat_stream.go +++ b/internal/server/chat_stream.go @@ -54,16 +54,18 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat // The user turn every *other* client sees, carrying the sender's label. The // sender's own client appended it locally, so it is excluded below. userFrame := protocol.ChatEventFrame{ - SessionID: sessionID, - MessageID: hub.nextUserMessageID(), - Kind: protocol.ChatEventUser, - Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, - Client: sub.label, + SessionID: sessionID, + MessageID: hub.nextUserMessageID(), + Kind: protocol.ChatEventUser, + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, + Client: sub.label, + OperationID: prompt.OperationID, } queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ - text: prompt.Text, - requestID: request.ID, - write: write, + text: prompt.Text, + operationID: prompt.OperationID, + requestID: request.ID, + write: write, }) if refused { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"})