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 57c6db98..b01f4ad8 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 @@ -349,11 +349,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, nativeMessageId(operationId))).chatQueued } suspend fun chatInterrupt(sessionId: String) { @@ -408,5 +408,12 @@ class PipelinesRepository( /** A durable key for one chat-create intent; retain it when retrying. */ fun newChatCreateOperationId(): String = "android-chat-" + UUID.randomUUID().toString() + + /** OpenCode's optional caller id is the canonical bridge to history. */ + fun nativeMessageId(operationId: String): String = + operationId.filter { character -> character.isLetterOrDigit() }.take(120) + .takeIf { it.isNotEmpty() } + ?.let { "msg_" + it } + .orEmpty() } } 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 560e765b..954543ee 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 @@ -83,6 +83,8 @@ 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 = "", + @SerialName("native_message_id") val nativeMessageId: String = "", ) /** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */ @@ -97,6 +99,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(), ) @@ -185,6 +188,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 = "", ) /** @@ -358,10 +362,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 = "", nativeMessageId: 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, nativeMessageId = nativeMessageId), ) /** 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 bf2c7dbd..42cfce92 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 @@ -1224,11 +1224,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 52bb70b7..5dc66002 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 @@ -894,15 +894,45 @@ class ChatStore( fun history(sessionId: String, messages: List, nextCursor: String = "", hasMore: Boolean = false) { update(sessionId) { val existing = it.messages.associateBy { message -> message.id } + // Operation identity remains valid after a live user event replaces + // local-* with the server's synthetic id. Index every user turn, + // not only optimistic records, so a later history read can replace + // that synthetic id with the provider's authoritative id. + val existingUserByOperation = it.messages + .asSequence() + .filter { message -> message.role == ChatProtocol.ROLE_USER && message.operationId.isNotBlank() } + .associateBy { message -> message.operationId } + val reconciledIds = messages.asSequence() + .mapNotNull { message -> existingUserByOperation[message.operationId]?.id } + .toSet() + val authoritativeMessages = messages.map { message -> + val local = existingUserByOperation[message.operationId] + if (local == 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 { local.client }, + parts = message.parts + local.parts.filter { localPart -> + message.parts.none { it.type == localPart.type && it.id == localPart.id } && + (localPart.type == ChatProtocol.PART_FILE || localPart.type == ChatProtocol.PART_TEXT || localPart.type == ChatProtocol.PART_REASONING) + }, + ) + } + } 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. @@ -1071,6 +1101,7 @@ class ChatStore( sessionId: String, text: String, attachments: List = emptyList(), + operationId: String = "", ): String? { var id: String? = null update(sessionId) { thread -> @@ -1079,6 +1110,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) }, ) @@ -1156,12 +1188,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/main/java/net/awan/pipelines/ui/components/DetailTabs.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/DetailTabs.kt index 832fa45a..f4e0fa3f 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/DetailTabs.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/DetailTabs.kt @@ -12,7 +12,6 @@ import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width -import androidx.compose.foundation.layout.widthIn import androidx.compose.foundation.selection.selectable import androidx.compose.foundation.selection.selectableGroup import androidx.compose.material.icons.Icons @@ -41,7 +40,6 @@ import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.semantics.Role import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp -import net.awan.pipelines.ui.theme.DETAIL_MAX_WIDTH_DP import net.awan.pipelines.ui.theme.ICON_RAIL_DP import net.awan.pipelines.ui.theme.SPACING_L import net.awan.pipelines.ui.theme.SPACING_M @@ -229,9 +227,9 @@ private fun RailTab(tab: DetailTab, selected: Boolean, onClick: () -> Unit) { } /** - * Constrains a text tab's single scroll container to a comfortable reading width - * on a wide window (centred) instead of letting lines run edge to edge; on a - * narrow window the content simply fills the tab. + * Gives a tab body the complete safe-area width supplied by its page container. + * Internal content remains responsible for any narrower, purpose-specific layout + * such as chat bubbles. */ @Composable fun DetailTabBody( @@ -239,18 +237,7 @@ fun DetailTabBody( modifier: Modifier = Modifier, content: @Composable (Modifier) -> Unit, ) { - if (wide) { - Box(modifier.fillMaxSize(), contentAlignment = Alignment.TopCenter) { - content( - Modifier - .fillMaxHeight() - .widthIn(max = DETAIL_MAX_WIDTH_DP.dp) - .fillMaxWidth(), - ) - } - } else { - content(modifier.fillMaxSize()) - } + content(modifier.fillMaxSize()) } /** diff --git a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt index 92472bd0..88e1da46 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt @@ -84,14 +84,11 @@ internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp */ internal val DESTINATION_PILL_RESERVE = 88.dp -// ---- Detail rail and max content width (ui/components/DetailTabs.kt) ------- +// ---- Detail rail (ui/components/DetailTabs.kt) ------------------------------ /** The always-visible wide section rail's width (icons with labels). */ internal const val WIDE_RAIL_WIDTH_DP = 200 -/** Comfortable max text width for a tab body on a wide window. */ -const val DETAIL_MAX_WIDTH_DP = 840 - // ---- Workflow graph geometry (ui/graph/WorkflowGraph.kt) ------------------- // The graph's node, edge and legend geometry. These are named here like every // other app dimension so the graph file imports them instead of writing raw dp 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..194dd4a5 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 @@ -1,6 +1,7 @@ package net.awan.pipelines.ui.chat import net.awan.pipelines.data.protocol.ChatEventFrame +import net.awan.pipelines.data.PipelinesRepository import net.awan.pipelines.data.protocol.ChatMessage import net.awan.pipelines.data.protocol.ChatPart import net.awan.pipelines.data.protocol.ChatPermissionFrame @@ -317,6 +318,97 @@ 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") + // The sender sees the live event before the provider history catches up. + 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"), + )) + // History replaces the synthetic event id, but must keep the same turn + // (including its attachment) rather than appending a second X. + store.history("a", listOf(ChatMessage( + id = "native-history-x", sessionId = "a", role = ChatProtocol.ROLE_USER, + operationId = "op-x", client = "Phone", + parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = "X")), + ))) + // A different client sends Y after the history read. + 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"), + )) + // The delayed original 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-history-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 emptyOperationDoesNotInventASharedNativeMessageId() { + assertEquals("", PipelinesRepository.nativeMessageId("")) + assertEquals("", PipelinesRepository.nativeMessageId(" ")) + assertEquals("msg_opx", PipelinesRepository.nativeMessageId("op-x")) + } + + @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/android/app/src/test/java/net/awan/pipelines/ui/components/DetailTabsTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/DetailTabsTest.kt index 068fb4d1..38b5e40d 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/components/DetailTabsTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/DetailTabsTest.kt @@ -1,6 +1,7 @@ package net.awan.pipelines.ui.components import androidx.compose.runtime.mutableStateOf +import java.io.File import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -75,4 +76,17 @@ class DetailTabsTest { state.toggle("evidence-4") assertFalse(state.isExpanded("evidence-4")) } + + @Test + fun detailTabBodyUsesThePageSafeAreaWithoutAnArtificialWideCap() { + val source = File( + System.getProperty("user.dir"), + "src/main/java/net/awan/pipelines/ui/components/DetailTabs.kt", + ).readText() + + assertTrue(source.contains("content(modifier.fillMaxSize())")) + assertFalse(source.contains("DETAIL_MAX_WIDTH_DP")) + assertFalse(source.contains("widthIn(max")) + assertFalse(source.contains("contentAlignment = Alignment.TopCenter")) + } } 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/docs/notes/fullwidth-page-body.md b/docs/notes/fullwidth-page-body.md new file mode 100644 index 00000000..42f97c85 --- /dev/null +++ b/docs/notes/fullwidth-page-body.md @@ -0,0 +1,24 @@ +# Full-width shared page body + +## What changed + +`android/app/src/main/java/net/awan/pipelines/ui/components/DetailTabs.kt` no longer +centres wide `DetailTabBody` content inside the artificial `DETAIL_MAX_WIDTH_DP` cap. +The body now passes its page modifier through at the available safe-area width for +Runs, Pipelines, Chats and Settings. Insets, scroll padding and narrower internal +layouts (including chat bubbles) remain owned by their respective callers. + +The wide navigation rail and pane-stack policy were not changed. The obsolete +`DETAIL_MAX_WIDTH_DP` token was removed from `ui/theme/Dimens.kt`; no dependency or +server change is involved. + +`DetailTabsTest` pins the full-width body implementation and guards against restoring +the centered cap. Device rendering on compact and wide windows remains for the UI +review stage. + +## Documentation now stale (for `docs-fold`) + +- `android/README.md` near the detail-tabs geometry/token description still names + `DETAIL_MAX_WIDTH_DP` as the wide page-body cap. Remove that token from the + description and state that shared page bodies use the available safe-area width; + keep any separate navigation-rail width description unchanged. diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index 6342f772..0f38d5df 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -82,6 +82,13 @@ func (c *Chat) call(ctx context.Context, method, path string, body any) ([]byte, // (authenticated, bounded, directory-scoped). The endpoint returns the inbox // envelope immediately; the reply arrives on Stream. func (c *Chat) Prompt(ctx context.Context, id, text string) error { + return c.PromptWithMessageID(ctx, id, text, "") +} + +// PromptWithMessageID forwards the caller's canonical message id to OpenCode. +// OpenCode persists this id in history, which is the only safe bridge between +// the live user echo and an authoritative history page. +func (c *Chat) PromptWithMessageID(ctx context.Context, id, text, messageID string) error { if !sessionID.MatchString(id) { return fmt.Errorf("invalid OpenCode session id") } @@ -92,6 +99,9 @@ func (c *Chat) Prompt(ctx context.Context, id, text string) error { // the same "text" field, so one shape works on both backends without a // second request format. body := map[string]any{"text": text} + if messageID != "" { + body["id"] = messageID + } if _, err := c.call(ctx, "post", "/api/session/"+id+"/prompt", body); err != nil { return err } diff --git a/internal/opencode/chat_test.go b/internal/opencode/chat_test.go index b00ebcf5..c9acff88 100644 --- a/internal/opencode/chat_test.go +++ b/internal/opencode/chat_test.go @@ -782,7 +782,7 @@ func TestChatV1ConnectionDrivesThroughCall(t *testing.T) { chat := NewChat(&Connection{Backend: "v1", URL: srv.URL, Directory: "/repo", models: map[string]map[string]string{}, responses: map[string][]byte{}}) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() - if err := chat.Prompt(ctx, "ses_1", "hello"); err != nil { + if err := chat.PromptWithMessageID(ctx, "ses_1", "hello", "msg_canonical"); err != nil { t.Fatalf("prompt: %v", err) } if !sawPrompt { @@ -792,6 +792,7 @@ func TestChatV1ConnectionDrivesThroughCall(t *testing.T) { // V2 `parts` shape and the v1 translation has to preserve it, or the native // serve process receives an empty prompt. var sent struct { + ID string `json:"id"` Parts []struct { Type string `json:"type"` Text string `json:"text"` @@ -800,7 +801,7 @@ func TestChatV1ConnectionDrivesThroughCall(t *testing.T) { if err := json.Unmarshal([]byte(promptBody), &sent); err != nil { t.Fatalf("prompt body: %v (%s)", err, promptBody) } - if len(sent.Parts) != 1 || sent.Parts[0].Type != protocol.ChatPartText || sent.Parts[0].Text != "hello" { + if sent.ID != "msg_canonical" || len(sent.Parts) != 1 || sent.Parts[0].Type != protocol.ChatPartText || sent.Parts[0].Text != "hello" { t.Fatalf("prompt text not carried through the v1 translation: %s", promptBody) } var got []protocol.ChatEventFrame diff --git a/internal/opencode/chat_v2_test.go b/internal/opencode/chat_v2_test.go index dfcb3973..805d3892 100644 --- a/internal/opencode/chat_v2_test.go +++ b/internal/opencode/chat_v2_test.go @@ -64,6 +64,25 @@ func TestChatV2PromptShapeAndAuth(t *testing.T) { } } +func TestChatV2PromptWithMessageID(t *testing.T) { + var body map[string]string + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + t.Fatal(err) + } + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"data":{"id":"msg_canonical","sessionID":"ses_1","type":"user"}}`)) + })) + defer srv.Close() + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + if err := chat.PromptWithMessageID(context.Background(), "ses_1", "same text", "msg_canonical"); err != nil { + t.Fatal(err) + } + if body["id"] != "msg_canonical" || body["text"] != "same text" { + t.Fatalf("prompt body = %+v", body) + } +} + // TestChatStreamRealV2Shapes replays the exact event frames the installed 2.0.20 // service emitted on /api/event during a live turn (captured, not documented): // a step start, token text delta, usage and a step end whose data carries no diff --git a/internal/opencode/native.go b/internal/opencode/native.go index d3646fc4..e5d7fa3a 100644 --- a/internal/opencode/native.go +++ b/internal/opencode/native.go @@ -195,6 +195,7 @@ func (c *Connection) Call(ctx context.Context, method, path string, body any) ([ var request struct { Prompt string `json:"prompt"` Text string `json:"text"` + ID string `json:"id"` Format json.RawMessage `json:"format"` Parts []struct { Text string `json:"text"` @@ -219,6 +220,9 @@ func (c *Connection) Call(ctx context.Context, method, path string, body any) ([ } } payload := map[string]any{"model": c.models[id], "parts": []map[string]string{{"type": "text", "text": text}}} + if request.ID != "" { + payload["id"] = request.ID + } if len(request.Format) > 0 { supported, err := c.supportsFormat(ctx, request.Format) if err != nil { diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 755c8dae..c9f9f4ed 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -224,12 +224,17 @@ 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"` + // NativeMessageID is the caller-supplied OpenCode message identity. It is + // sent with the prompt so history can be reconciled without guessing from + // text, time, order or page boundaries. + NativeMessageID string `json:"native_message_id,omitempty"` } // ChatMessage is one stored turn returned by chat_messages. A user turn is a @@ -245,8 +250,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 @@ -334,7 +340,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.go b/internal/server/chat.go index 3d4ddf5c..c0da3f30 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -42,6 +42,10 @@ type chatBroker interface { Reply(ctx context.Context, request protocol.ChatReplyRequest) error } +type chatPromptWithMessageID interface { + PromptWithMessageID(context.Context, string, string, string) error +} + type chatShellOutputReader interface { ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, error) } 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..f761decc 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,38 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage { return messages } +// reconcileHistory applies only the explicit native-id mapping established by a +// caller-supplied prompt. It never infers identity from text, timestamps, +// position, ordering or page boundaries. +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 + } + byNativeID := make(map[string]*chatMessage) + for _, message := range turn.messages { + if message.role == protocol.ChatRoleUser && message.id != "" && message.operationID != "" { + byNativeID[message.id] = message + } + } + if len(byNativeID) == 0 { + return messages + } + out := make([]protocol.ChatMessage, len(messages)) + copy(out, messages) + for i := range out { + if live := byNativeID[out[i].ID]; live != nil { + out[i].OperationID = live.operationID + if out[i].Client == "" { + out[i].Client = live.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..0fbb54d6 100644 --- a/internal/server/chat_room.go +++ b/internal/server/chat_room.go @@ -100,10 +100,12 @@ 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 + nativeID string + requestID string + write func(protocol.Message) error + acked bool } type chatObservation struct { @@ -658,8 +660,14 @@ func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{ return } } - if err := broker.Prompt(room.ctx, room.sessionID, p.text); err != nil { - h.failPrompt(room, p, err) + var promptErr error + if withID, ok := broker.(chatPromptWithMessageID); ok { + promptErr = withID.PromptWithMessageID(room.ctx, room.sessionID, p.text, p.nativeID) + } else { + promptErr = broker.Prompt(room.ctx, room.sessionID, p.text) + } + if promptErr != nil { + h.failPrompt(room, p, promptErr) h.endRoomTurn(room) return } diff --git a/internal/server/chat_stream.go b/internal/server/chat_stream.go index 89ba6404..91370f56 100644 --- a/internal/server/chat_stream.go +++ b/internal/server/chat_stream.go @@ -54,16 +54,22 @@ 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: prompt.NativeMessageID, + Kind: protocol.ChatEventUser, + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, + Client: sub.label, + OperationID: prompt.OperationID, + } + if userFrame.MessageID == "" { + userFrame.MessageID = hub.nextUserMessageID() } queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ - text: prompt.Text, - requestID: request.ID, - write: write, + text: prompt.Text, + operationID: prompt.OperationID, + nativeID: userFrame.MessageID, + 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"}) diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 33d7b4d0..312bc221 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -948,6 +948,104 @@ func TestChatHubKeepsMessagesSeparate(t *testing.T) { } } +// OpenCode history exposes native message ids but no prompt operation id. The +// broker must therefore leave partial, reordered, older and overlapping pages +// untouched rather than inventing a positional identity mapping. +func TestChatHubHistoryDoesNotInventOperationIdentity(t *testing.T) { + hub := newChatHub() + page := []protocol.ChatMessage{ + {ID: "history-y", Role: protocol.ChatRoleUser, OperationID: "provider-value"}, + {ID: "history-x", Role: protocol.ChatRoleUser}, + } + got := hub.reconcileHistory("ses_1", page) + if len(got) != len(page) || got[0].ID != "history-y" || got[0].OperationID != "provider-value" || got[1].OperationID != "" { + t.Fatalf("history changed without a canonical provider mapping: %+v", got) + } +} + +func TestChatHubHistoryMapsOnlyCanonicalNativeIdentity(t *testing.T) { + hub := newChatHub() + hub.apply(protocol.ChatEventFrame{ + SessionID: "ses_1", MessageID: "msg_x", Kind: protocol.ChatEventUser, + Client: "Phone", OperationID: "op_x", + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: "same"}, + }) + hub.apply(protocol.ChatEventFrame{ + SessionID: "ses_1", MessageID: "msg_y", Kind: protocol.ChatEventUser, + Client: "Laptop", OperationID: "op_y", + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: "same"}, + }) + got := hub.reconcileHistory("ses_1", []protocol.ChatMessage{ + {ID: "msg_y", Role: protocol.ChatRoleUser}, + {ID: "unrelated", Role: protocol.ChatRoleUser, Parts: []protocol.ChatPart{{Text: "same"}}}, + {ID: "msg_x", Role: protocol.ChatRoleUser}, + }) + if got[0].OperationID != "op_y" || got[2].OperationID != "op_x" || got[1].OperationID != "" { + t.Fatalf("history identity mapping = %+v", got) + } +} + +// TestChatMessagesReconcilesProviderPagesThroughTheHandler exercises the normal +// history path, rather than calling reconcileHistory alone. The provider fixture +// deliberately returns partial, reordered, older and overlapping pages (including +// equal timestamps); only the explicit native ids may restore operation identity. +func TestChatMessagesReconcilesProviderPagesThroughTheHandler(t *testing.T) { + hub := newChatHub() + for _, turn := range []struct { + id, operation, client string + }{ + {"msg_x", "op_x", "Phone"}, + {"msg_y", "op_y", "Computer"}, + } { + hub.apply(protocol.ChatEventFrame{ + SessionID: "ses_1", MessageID: turn.id, Kind: protocol.ChatEventUser, + OperationID: turn.operation, Client: turn.client, + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: turn.operation}, + }) + } + + pages := []struct { + name string + messages []protocol.ChatMessage + }{ + {"partial-reordered", []protocol.ChatMessage{ + {ID: "msg_y", Role: protocol.ChatRoleUser, CreatedAt: 10}, + {ID: "msg_x", Role: protocol.ChatRoleUser, CreatedAt: 10}, + }}, + {"older", []protocol.ChatMessage{ + {ID: "msg_x", Role: protocol.ChatRoleUser, CreatedAt: 10}, + }}, + {"overlap-reconnect", []protocol.ChatMessage{ + {ID: "msg_y", Role: protocol.ChatRoleUser, CreatedAt: 10}, + {ID: "unrelated", Role: protocol.ChatRoleUser, CreatedAt: 10}, + }}, + } + for _, page := range pages { + broker := scriptedChat() + broker.messages = page.messages + var response protocol.Message + handleChatMessages(context.Background(), protocol.Message{ + Type: protocol.ChatMessages, ID: page.name, + ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}, + }, broker, hub, func(message protocol.Message) error { + response = message + return nil + }) + if response.Type != protocol.ChatMessages || response.ChatHistory == nil { + t.Fatalf("%s response = %+v", page.name, response) + } + for _, message := range response.ChatHistory.Messages { + want := map[string]string{"msg_x": "op_x", "msg_y": "op_y"}[message.ID] + if want != "" && message.OperationID != want { + t.Fatalf("%s message %q operation = %q, want %q", page.name, message.ID, message.OperationID, want) + } + if message.ID == "unrelated" && message.OperationID != "" { + t.Fatalf("%s invented identity for unrelated message: %+v", page.name, message) + } + } + } +} + // TestChatHubChargesToolStateBytes pins the retained-state cap: a tool part's // input/content bytes count against it, and an upsert that would exceed the cap // is dropped with the overflow diagnostic rather than growing memory.