chat: preserve cross-client reconciliation work

This commit is contained in:
2026-10-18 21:45:56 +01:00
parent 5946f1abc8
commit 36d1c8ea7a
11 changed files with 213 additions and 35 deletions
@@ -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<String> = emptyList()): Boolean {
suspend fun chatPrompt(sessionId: String, text: String, files: List<String> = 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) {
@@ -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<ChatPart> = 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<String> = emptyList(), client: String = ""): Message =
fun promptRequest(sessionId: String, text: String, files: List<String> = 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),
)
/**
@@ -1173,11 +1173,12 @@ class AppViewModel(
private fun postChatPrompt(sessionId: String, text: String, attachments: List<ChatAttachment>) {
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.
@@ -845,15 +845,40 @@ class ChatStore(
fun history(sessionId: String, messages: List<ChatMessage>, 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<String, ChatMessage>()) { result, message ->
val merged = (olderPrefix + authoritativeMessages + it.messages.filterNot { message -> message.id in reconciledIds })
.fold(LinkedHashMap<String, ChatMessage>()) { 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<ChatAttachment> = 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)
@@ -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()