Merge branch 'main' into pill-run-decision

This commit is contained in:
2026-10-18 15:23:16 +01:00
21 changed files with 1115 additions and 76 deletions
@@ -7,6 +7,7 @@ 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.ChatHistoryPage
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatPromptRequest
import net.awan.pipelines.data.protocol.ChatProtocol
@@ -297,12 +298,14 @@ class PipelinesRepository(
?: 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> {
/** Loads a bounded chronological page; [cursor] is an opaque older-history continuation. */
suspend fun chatMessages(sessionId: String, limit: Int = 0, cursor: String = ""): ChatHistoryPage {
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()
val response = client.call(
Message(type = Protocol.CHAT_MESSAGES, chatQuery = ChatQuery(sessionId = sessionId, limit = limit, cursor = cursor)),
)
// Old servers only have chat_messages and therefore honestly expose no continuation.
return response.chatHistory ?: ChatHistoryPage(messages = response.chatMessages ?: emptyList())
}
/**
@@ -66,6 +66,7 @@ data class ChatCreateRequest(
data class ChatQuery(
@SerialName("session_id") val sessionId: String = "",
val limit: Int = 0,
val cursor: String = "",
)
@Serializable
@@ -126,6 +127,15 @@ data class ChatToolState(
val content: List<ChatToolContent> = emptyList(),
val metadata: JsonObject? = null,
val error: ChatError? = null,
// A bounded history preview is not the complete tool result.
val truncated: Boolean = false,
)
@Serializable
data class ChatHistoryPage(
val messages: List<ChatMessage> = emptyList(),
@SerialName("next_cursor") val nextCursor: String = "",
@SerialName("has_more") val hasMore: Boolean = false,
)
@Serializable
@@ -704,6 +704,7 @@ data class Message(
@SerialName("chat_queued") val chatQueued: Boolean = false,
@SerialName("chat_subscribe") val chatSubscribe: ChatQuery? = null,
@SerialName("chat_messages") val chatMessages: List<ChatMessage>? = null,
@SerialName("chat_history") val chatHistory: ChatHistoryPage? = null,
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
@@ -1105,14 +1105,36 @@ class AppViewModel(
fun undoRemoveChat() = chatStore.undoRemove()
fun loadChatHistory(sessionId: String) {
if (chatStore.value.thread(sessionId)?.loading == true) return
// Set the gate before launching so repeated taps/events cannot queue two
// reads before the coroutine gets a chance to start.
chatStore.historyLoading(sessionId)
viewModelScope.launch {
// Watch the session's shared stream so frames from any client's turn
// arrive live. Best-effort: an older server answers an error frame,
// which must not stop the history from loading.
runCatching { repository.chatSubscribe(sessionId) }
chatStore.historyLoading(sessionId)
try {
chatStore.history(sessionId, repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT))
val page = repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT)
chatStore.history(sessionId, page.messages, page.nextCursor, page.hasMore)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
}
}
}
/** Fetches the next opaque older-history page without replacing live state. */
fun loadOlderChatHistory(sessionId: String) {
val thread = chatStore.value.thread(sessionId) ?: return
if (!thread.hasMore || thread.loading) return
// Capture both the request-start snapshot and cursor before launch; this
// makes the per-thread loading gate effective for repeated requests.
chatStore.historyLoading(sessionId, older = true)
viewModelScope.launch {
try {
val page = repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT, thread.nextCursor)
chatStore.history(sessionId, page.messages, page.nextCursor, page.hasMore)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.failed(sessionId, ErrorMessages.describe(t))
@@ -12,6 +12,7 @@ import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.PanTool
import androidx.compose.material.icons.filled.KeyboardArrowUp
import androidx.compose.material.icons.filled.Stop
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
@@ -173,6 +174,13 @@ internal fun ChatConversationPane(
}
},
actions = {
if (thread.hasMore) {
IconButton(
onClick = { vm.loadOlderChatHistory(thread.sessionId) },
) {
Icon(Icons.Default.KeyboardArrowUp, contentDescription = "Load older messages")
}
}
if (awaiting) {
IconButton(
onClick = {
@@ -79,6 +79,12 @@ data class ChatThread(
*/
val closed: Boolean = false,
val messages: List<ChatMessage> = emptyList(),
/** Opaque continuation for older messages returned by the server. */
val nextCursor: String = "",
val hasMore: Boolean = false,
/** Immutable snapshot at request start distinguishes stale cache from new live frames. */
val historyBeforeLoad: List<ChatMessage>? = null,
val historyLoadOlder: Boolean = false,
val loading: Boolean = false,
val loaded: Boolean = false,
val error: String? = null,
@@ -755,27 +761,121 @@ class ChatStore(
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 historyLoading(sessionId: String, older: Boolean = false) = update(sessionId) {
it.copy(loading = true, error = null, historyBeforeLoad = it.messages, historyLoadOlder = older)
}
fun failed(sessionId: String, message: String) =
update(sessionId) { it.copy(loading = false, error = message) }
update(sessionId) { it.copy(loading = false, error = message, historyBeforeLoad = null) }
/** Linear-time suffix/prefix overlap: a history snapshot may include part of a live delta. */
private fun appendHistoryDelta(stored: String, delta: String): String {
if (delta.isEmpty()) return stored
val prefix = IntArray(delta.length)
for (index in 1 until delta.length) {
var matched = prefix[index - 1]
while (matched > 0 && delta[index] != delta[matched]) matched = prefix[matched - 1]
if (delta[index] == delta[matched]) matched++
prefix[index] = matched
}
var overlap = 0
for (char in stored) {
while (overlap > 0 && (overlap == delta.length || char != delta[overlap])) overlap = prefix[overlap - 1]
if (overlap < delta.length && char == delta[overlap]) overlap++
}
return stored + delta.substring(overlap)
}
/** Keep the full stored answer when a live-only suffix arrived during its first read. */
private fun mergeHistoryDuringRead(history: ChatMessage, live: ChatMessage, before: ChatMessage?): ChatMessage {
val parts = history.parts.toMutableList()
val partIndices = HashMap<String, Int>(parts.size)
val textIndices = HashMap<String, MutableList<Int>>()
for ((index, part) in parts.withIndex()) {
if (part.id.isNotBlank()) partIndices[part.id] = index
if (part.type == ChatProtocol.PART_TEXT || part.type == ChatProtocol.PART_REASONING) {
textIndices.getOrPut(part.type) { mutableListOf() }.add(index)
}
}
val beforeText = HashMap<String, MutableList<ChatPart>>()
before?.parts?.forEach { part ->
if (part.type == ChatProtocol.PART_TEXT || part.type == ChatProtocol.PART_REASONING) {
beforeText.getOrPut(part.type) { mutableListOf() }.add(part)
}
}
val ordinals = mutableMapOf<String, Int>()
for (part in live.parts) {
val ordinal = ordinals.getOrDefault(part.type, 0)
ordinals[part.type] = ordinal + 1
val textPart = part.type == ChatProtocol.PART_TEXT || part.type == ChatProtocol.PART_REASONING
val byId = partIndices[part.id]
// V2 stored text has no id; deltas have a stable generated ordinal id.
val index = byId ?: if (textPart) textIndices[part.type]?.getOrNull(ordinal) ?: -1 else -1
if (index < 0) {
parts += part
val appendedIndex = parts.lastIndex
if (part.id.isNotBlank()) partIndices[part.id] = appendedIndex
if (textPart) textIndices.getOrPut(part.type) { mutableListOf() }.add(appendedIndex)
} else if (textPart) {
val stored = parts[index].text
val previous = beforeText[part.type]?.getOrNull(ordinal)?.text
val delta = if (previous != null && part.text.startsWith(previous)) part.text.removePrefix(previous) else part.text
val text = when {
part.text.isEmpty() || stored.endsWith(part.text) -> stored
part.text.startsWith(stored) -> part.text
previous != null && !stored.startsWith(previous) -> part.text
delta.isEmpty() || stored.endsWith(delta) -> stored
else -> appendHistoryDelta(stored, delta)
}
parts[index] = part.copy(text = text)
} else {
parts[index] = part
}
}
return history.copy(parts = parts, client = live.client.ifBlank { history.client })
}
/**
* Replaces a thread's conversation with the server's authoritative history.
* Merges an authoritative page with older cached turns and in-flight events.
* 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>) {
fun history(sessionId: String, messages: List<ChatMessage>, nextCursor: String = "", hasMore: Boolean = false) {
update(sessionId) {
val existing = it.messages.associateBy { message -> message.id }
val baseline = it.historyBeforeLoad?.associateBy { message -> message.id }
val pageIds = messages.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 ->
// 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.
val local = existing[message.id]
val changedDuringRead = local != null && (baseline == null || baseline[message.id] != local)
if (message.id !in result) result[message.id] = when {
changedDuringRead && baseline != null -> mergeHistoryDuringRead(message, local!!, baseline[message.id])
changedDuringRead -> local!!
else -> message
}
result
}.values.toList()
it.copy(
messages = messages,
messages = merged,
nextCursor = nextCursor,
hasMore = hasMore,
loading = false,
loaded = true,
historyBeforeLoad = null,
error = null,
// A running call the history reports (a turn that started before
// this fetch) is stamped now, the best local measurement there is;
// a call that already settled drops its stamp.
toolStartedAt = runningToolStamps(it.toolStartedAt, messages, now()),
toolStartedAt = runningToolStamps(it.toolStartedAt, merged, now()),
)
}
// A conversation on screen is read as its history arrives: its recency
@@ -112,6 +112,71 @@ class MultiChatStateTest {
assertEquals(ChatScrollPosition(1, 0), store.value.thread("b")!!.scroll)
}
@Test
fun olderHistoryPrependsOnceAndKeepsLiveMessage() {
val store = ChatStore()
store.open(session("a"))
store.history("a", listOf(ChatMessage(
id = "new",
sessionId = "",
role = ChatProtocol.ROLE_ASSISTANT,
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "0", text = "live")),
)), "cursor-1", true)
store.historyLoading("a")
store.event(ChatEventFrame(
sessionId = "a",
messageId = "new",
kind = ChatProtocol.PART_TEXT,
delta = " update",
part = ChatPart(type = ChatProtocol.PART_TEXT, id = "0"),
))
store.history(
"a",
listOf(text("old", ChatProtocol.ROLE_USER, "older"), text("new", ChatProtocol.ROLE_ASSISTANT, "stale")),
"",
false,
)
val messages = store.value.thread("a")!!.messages
assertEquals(listOf("old", "new"), messages.map { it.id })
assertEquals("live update", messages.last().parts.single().text)
assertFalse(store.value.thread("a")!!.hasMore)
}
@Test
fun reconnectHistoryRepairsMissedTextWithoutDroppingOlderPagesOrDuplicatingIds() {
val store = ChatStore()
store.open(session("a"))
store.history("a", listOf(text("old", ChatProtocol.ROLE_USER, "older"), text("new", ChatProtocol.ROLE_ASSISTANT, "partial")))
store.streamResumed()
store.historyLoading("a")
store.history("a", listOf(text("new", ChatProtocol.ROLE_ASSISTANT, "partial and missed final answer")), "older", true)
val messages = store.value.thread("a")!!.messages
assertEquals(listOf("old", "new"), messages.map { it.id })
assertEquals("partial and missed final answer", messages.last().parts.single().text)
}
@Test
fun firstHistoryReadDoesNotReplaceFullAnswerWithLiveOnlySuffix() {
for (snapshot in listOf("full answer", "full answer ta", "full answer tail")) {
val store = ChatStore()
store.open(session("a"))
store.historyLoading("a")
store.event(ChatEventFrame(
sessionId = "a", messageId = "new", kind = ChatProtocol.PART_TEXT,
delta = " tail", part = ChatPart(type = ChatProtocol.PART_TEXT, id = "delta-0"),
))
store.history("a", listOf(ChatMessage(
id = "new", sessionId = "a", role = ChatProtocol.ROLE_ASSISTANT,
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = snapshot)),
)))
val messages = store.value.thread("a")!!.messages
assertEquals(1, messages.size)
assertEquals("full answer tail", messages.single().parts.single().text)
}
}
@Test
fun busySessionStaysWritable() {
val store = ChatStore()
+43
View File
@@ -0,0 +1,43 @@
# Large chat history
The chat broker reads OpenCode V2 history in cursor pages and represents an
oversized tool result as an explicitly labelled omission rather than failing the
transcript. The native bare-array HTTP history path uses the same projector;
its existing OutputFormat read-only export fallback is unchanged and retains its
separate evidence limit. A retained hub tail is never authoritative history.
History-specific HTTP reads retain shared auth, directory scoping, validation and
request cancellation. They do not use the generic Call 1 MiB safeguard (which is
unchanged). A fixed 32 KiB reader validates JSON incrementally, including discarded
strings/escapes. Each complete tool state (input, output, metadata, file data and
many small fields together) has a 64 KiB encoded budget. Oversized states become
valid omission cards, not raw JSON prefixes. Projection happens before ordinary
JSON decoding, one message at a time, never by buffering the raw page or string.
Memory is O(returned conversation + largest projected message), with fixed reader,
64 KiB state and depth-bounded scanner workspace (128 levels). User/final-answer
text is not capped. This is not a lazy full-detail API: omitted tool details are
not currently retrievable in the chat UI.
Android's retained cursor/load-older controls merge pages by message id. A
request-start snapshot distinguishes stale cached messages (replace on reconnect)
from live updates received during the read (preserve). Cached older pages survive
newest-page refreshes.
2026-10-18 verification is fixture evidence, not a live model or production
deployment claim. `go test ./internal/opencode -run 'History|ChatMessages' -v`
measured approximately 175 KiB allocated for both generated 2 MiB and 32 MiB
single-tool strings, with maximum source reads of 32 KiB. Tests cover malformed
discarded detail, UTF-16 escapes, cancellation during huge strings and HTTP reads,
auth refusal, legacy arrays, uncapped answer text, and the generic Call safeguard.
`TestChatHistoryLargeFixtureWebsocketTraversalAndReconnect` exercises a scratch
HTTP fixture through the real broker and /connect websocket, including a >1 MiB
page of many tools, one >1 MiB output, opaque cursors, equal-timestamp ordering,
full traversal and reconnect between pages. No production history was seeded.
`internal/author/skill/references/` has no history-pagination guidance; any chat
reference added there should document that older history remains reachable through
the opaque continuation and that a truncated tool preview is not full output.
`docs/cli.md` is stale for `chat_query.cursor`, `chat_history` (messages,
next_cursor, has_more), and tool-state `truncated`; fold those wire fields there
with the compatibility `chat_messages` list through the docs-fold writer only.
No deployment, installation, device interaction or production mutation was done.
+66 -14
View File
@@ -8,6 +8,7 @@ import (
"errors"
"fmt"
"io"
"net/url"
"sort"
"strings"
"sync"
@@ -25,8 +26,9 @@ var ErrPermissionUnsupported = errors.New("OpenCode permission approval is not i
// Chat is the brokered OpenCode chat adapter (route B in the research): the
// Pipelines server owns the OpenCode endpoint and credentials and turns the v2
// HTTP API into protocol.ChatEventFrame frames. It reuses the owned-endpoint
// semantics, the session-id shape and the 64 KiB / 1 MiB bounds of Connection so
// no second transport or credential path is introduced.
// semantics and session-id shape of Connection, with its normal 64 KiB / 1 MiB
// call guards. History alone streams/project tool details before decoding; it
// does not introduce a total-history cap or a second credential path.
type Chat struct {
conn *Connection
shellMu sync.Mutex
@@ -92,27 +94,63 @@ func (c *Chat) Interrupt(ctx context.Context, id string) error {
// reuses Connection.Messages, including its read-only OutputFormat readback
// fallback, instead of duplicating that path. It maps the verified assistant
// content parts (text | reasoning | tool) onto protocol.ChatMessage.
func (c *Chat) Messages(ctx context.Context, id string, limit int) ([]protocol.ChatMessage, error) {
func (c *Chat) Messages(ctx context.Context, id string, limit int, cursor string) (protocol.ChatHistoryPage, error) {
if !sessionID.MatchString(id) {
return nil, fmt.Errorf("invalid OpenCode session id")
return protocol.ChatHistoryPage{}, fmt.Errorf("invalid OpenCode session id")
}
var data []byte
var err error
c.mu.Lock()
defer c.mu.Unlock()
var reader io.Reader
if c.conn.Backend == "v1" {
data, err = c.conn.Messages(ctx, id)
} else {
path := "/api/session/" + id + "/message"
if limit > 0 {
path += fmt.Sprintf("?limit=%d", limit)
var body io.ReadCloser
body, err = c.conn.HistoryNative(ctx, "/session/"+id+"/message")
if err == nil {
defer body.Close()
reader = body
} else if c.conn.LastHTTPStatus == 400 {
// Preserve the existing OutputFormat/read-only export recovery on
// native serve. Ordinary history is streamed, never Call-buffered.
data, err = c.conn.Messages(ctx, id)
reader = bytes.NewReader(data)
}
} else {
if limit <= 0 {
limit = 100 // bounded newest-page request, including legacy clients
}
path := "/api/session/" + id + "/message"
values := make([]string, 0, 2)
if limit > 0 {
values = append(values, fmt.Sprintf("limit=%d", limit))
}
if cursor != "" {
values = append(values, "cursor="+url.QueryEscape(cursor))
}
if len(values) > 0 {
path += "?" + strings.Join(values, "&")
}
var body io.ReadCloser
body, err = c.conn.HistoryNative(ctx, path)
if err == nil {
defer body.Close()
reader = body
}
data, err = c.conn.Call(ctx, "get", path, nil)
}
c.mu.Unlock()
if err != nil {
return nil, err
return protocol.ChatHistoryPage{}, err
}
return decodeChatMessages(id, data)
messages, next, descending, err := decodeChatHistoryPage(ctx, id, reader)
if err != nil {
return protocol.ChatHistoryPage{}, err
}
// The verified API returns newest first. The transcript is chronological.
if descending {
for left, right := 0, len(messages)-1; left < right; left, right = left+1, right-1 {
messages[left], messages[right] = messages[right], messages[left]
}
}
return protocol.ChatHistoryPage{Messages: messages, NextCursor: next, HasMore: next != ""}, nil
}
// Sessions lists the OpenCode sessions on the endpoint. On the V2 HTTP API that
@@ -980,6 +1018,10 @@ func decodeChatMessages(sessionID string, data []byte) ([]protocol.ChatMessage,
if err != nil {
return nil, err
}
return mapChatMessages(sessionID, records), nil
}
func mapChatMessages(sessionID string, records []nativeChatMessage) []protocol.ChatMessage {
messages := make([]protocol.ChatMessage, 0, len(records))
for _, record := range records {
role := record.role()
@@ -1002,9 +1044,19 @@ func decodeChatMessages(sessionID string, data []byte) ([]protocol.ChatMessage,
}
messages = append(messages, out)
}
return messages, nil
return messages
}
// decodeChatHistoryPage reads the V2 cursor envelope while retaining the older
// bare-array decoder for native serve. Tool output is intentionally previewed:
// one command's unbounded stdout must not make the entire transcript or its final
// answer unavailable over the websocket.
func decodeChatHistoryPage(ctx context.Context, sessionID string, reader io.Reader) ([]protocol.ChatMessage, string, bool, error) {
return readHistoryPage(ctx, sessionID, reader)
}
const historyToolPreviewBytes = 64 << 10
// nativeChatSession is one listed session in the verified V2 shape
// ({id,title,agent,model,cost,tokens,outcome,time,title,location.directory,
// parentID,permissions}); only the fields the protocol surfaces are read. The
+44 -3
View File
@@ -161,6 +161,9 @@ func TestChatRejectsInvalidSessionWithoutCalling(t *testing.T) {
if err := chat.Interrupt(ctx, "bad id"); err == nil {
t.Fatal("invalid interrupt session id must be rejected")
}
if _, err := chat.Messages(ctx, "bad id", 1, ""); err == nil {
t.Fatal("invalid history session id must be rejected")
}
if _, err := chat.Permissions(ctx, "not-a-session"); err == nil {
t.Fatal("invalid permission session id must be rejected")
}
@@ -498,6 +501,44 @@ func TestDecodeChatMessagesSkipsUnknownPartsAndRoles(t *testing.T) {
}
}
func TestChatMessagesPagesLargeToolHistoryWithoutGlobalResponseLimit(t *testing.T) {
large := strings.Repeat("x", MaxResponse+1)
var paths []string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
paths = append(paths, r.URL.String())
w.Header().Set("Content-Type", "application/json")
if r.URL.Query().Get("cursor") == "older-token" {
_, _ = io.WriteString(w, `{"data":[{"id":"old","type":"user","time":{"created":1},"text":"older"}],"cursor":{"next":null}}`)
return
}
_, _ = io.WriteString(w, `{"data":[{"id":"new","type":"assistant","time":{"created":2},"content":[{"type":"tool","id":"tool","state":{"status":"completed","content":[{"type":"text","text":"`+large+`"}]}},{"type":"text","text":"final answer"}]}],"cursor":{"next":"older-token"}}`)
}))
defer srv.Close()
conn := &Connection{Backend: "v2", URL: srv.URL}
chat := NewChat(conn)
page, err := chat.Messages(context.Background(), "ses_1", 1, "")
if err != nil {
t.Fatal(err)
}
if !page.HasMore || page.NextCursor != "older-token" || len(page.Messages) != 1 {
t.Fatalf("page = %+v", page)
}
parts := page.Messages[0].Parts
if len(parts) != 2 || parts[0].State == nil || !parts[0].State.Truncated || parts[1].Text != "final answer" {
t.Fatalf("parts = %+v", parts)
}
older, err := chat.Messages(context.Background(), "ses_1", 1, page.NextCursor)
if err != nil || older.HasMore || len(older.Messages) != 1 || older.Messages[0].ID != "old" {
t.Fatalf("older = %+v, %v", older, err)
}
if len(paths) != 2 || !strings.Contains(paths[1], "cursor=older-token") {
t.Fatalf("requests = %v", paths)
}
if _, err := conn.Call(context.Background(), "get", "/api/session/ses_1/message", nil); err == nil || !strings.Contains(err.Error(), "1 MiB") {
t.Fatalf("generic Call safeguard changed: %v", err)
}
}
// TestChatSessionsListsAndLiftsShape loads the verified V2 session list
// (GET /api/session: {"data":[{id,...,location.directory,time{created,updated},
// parentID}]}) and asserts the adapter reads it exactly once, lifts the nested
@@ -772,11 +813,11 @@ func TestChatV1ConnectionDrivesThroughCall(t *testing.T) {
if len(got) != 1 || got[0].Kind != protocol.ChatEventText || got[0].MessageID != "msg_1" {
t.Fatalf("stream frames = %+v", got)
}
messages, err := chat.Messages(ctx, "ses_1", 0)
page, err := chat.Messages(ctx, "ses_1", 0, "")
if err != nil {
t.Fatalf("messages: %v", err)
}
if !sawMessages || len(messages) != 1 || messages[0].ID != "msg_1" {
t.Fatalf("messages = %+v", messages)
if !sawMessages || len(page.Messages) != 1 || page.Messages[0].ID != "msg_1" {
t.Fatalf("messages = %+v", page.Messages)
}
}
+45
View File
@@ -321,6 +321,51 @@ func (c *Connection) Native(ctx context.Context, method, path string, body any)
return c.nativeRequest(ctx, method, path, body, c.Directory)
}
// HistoryNative performs an authenticated history read without Connection.Call's
// general 1 MiB response guard. Chat history is paged and projected before it is
// sent to a client; ordinary API calls keep their existing safeguard.
func (c *Connection) HistoryNative(ctx context.Context, path string) (io.ReadCloser, error) {
c.LastHTTPStatus = 0
c.LastHTTPOperation = "GET " + path
u, err := url.Parse(c.URL + path)
if err != nil {
return nil, err
}
if c.Directory != "" {
query := u.Query()
query.Set("directory", c.Directory)
u.RawQuery = query.Encode()
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
req.SetBasicAuth(c.serverUser(), c.password)
resp, err := http.DefaultClient.Do(req)
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("OpenCode history request failed")
}
c.LastHTTPStatus = resp.StatusCode
c.LastHTTPOperation = "GET " + path
if resp.StatusCode == http.StatusUnauthorized {
c.unauthorized = true
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
defer resp.Body.Close()
_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 16<<10))
return nil, fmt.Errorf("OpenCode GET %s failed (HTTP %d)", path, resp.StatusCode)
}
if !strings.HasPrefix(resp.Header.Get("Content-Type"), "application/json") {
resp.Body.Close()
return nil, fmt.Errorf("OpenCode GET %s returned a non-JSON API response", path)
}
return resp.Body, nil
}
// nativeRequest is the shared Native request path. An empty directory omits the
// ?directory= query parameter; the V2 session list then returns sessions across
// every directory instead of only the connection's own.
+326
View File
@@ -0,0 +1,326 @@
package opencode
import (
"bufio"
"context"
"encoding/json"
"fmt"
"io"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// historyJSON projects tool state BEFORE encoding/json sees it. Decoder.Token
// alone is not sufficient: it allocates an entire JSON string, even when the
// caller immediately discards it. This scanner consumes strings byte by byte
// through a fixed 32 KiB reader, including escapes and discarded detail.
//
// Workspace is O(32 KiB + 64 KiB + depth*256), depth <= 128. Retained memory is
// O(returned messages + largest projected message): answer text is never capped; each tool state
// contributes at most 64 KiB. An oversized state (including input, metadata,
// binary content or many small fields) is replaced by an honest omission card,
// NOT a raw JSON prefix. Neither wire size nor a single string size is a cap on
// history. No temporary disk copy or unbounded raw message/page is retained.
type historyJSON struct {
ctx context.Context
r *bufio.Reader
}
// Negative limits are used only for a projected message (output-proportional).
// State, cursor and key captures reuse the existing bounded output helper.
type historyBuffer = boundedOutput
func (b *boundedOutput) put(c byte) {
if b == nil {
return
}
b.WriteByte(c)
}
func readHistoryPage(ctx context.Context, sessionID string, r io.Reader) ([]protocol.ChatMessage, string, bool, error) {
p := historyJSON{ctx: ctx, r: bufio.NewReaderSize(r, 32<<10)}
messages := make([]protocol.ChatMessage, 0)
var next string
readMessages := func() error {
if err := p.take(nil, '['); err != nil {
return err
}
c, err := p.peek()
if err != nil {
return err
}
if c == ']' {
return p.take(nil, ']')
}
for {
out := &historyBuffer{limit: -1}
if err := p.value(out, 1, true); err != nil {
return err
}
var record nativeChatMessage
if err := json.Unmarshal(out.Bytes(), &record); err != nil {
return err
}
messages = append(messages, mapChatMessages(sessionID, []nativeChatMessage{record})...)
c, err := p.peek()
if err != nil {
return err
}
if c == ']' {
return p.take(nil, ']')
}
if err := p.take(nil, ','); err != nil {
return err
}
}
}
c, err := p.peek()
if err != nil {
return nil, "", false, err
}
descending := c == '{'
if c == '[' {
err = readMessages()
} else if descending {
p.take(nil, '{')
found := false
fields := make(map[string]struct{})
for err == nil {
key := &historyBuffer{limit: 256}
if err = p.str(key, nil); err != nil {
break
}
var name string
if key.overflow || json.Unmarshal(key.Bytes(), &name) != nil {
err = fmt.Errorf("invalid history envelope field")
break
}
if _, duplicate := fields[name]; duplicate {
err = fmt.Errorf("duplicate history envelope field %q", name)
break
}
fields[name] = struct{}{}
if err = p.take(nil, ':'); err != nil {
break
}
switch name {
case "data":
found = true
err = readMessages()
case "cursor":
cursor := &historyBuffer{limit: 64 << 10}
err = p.value(cursor, 1, false)
if err == nil {
var decoded struct {
Next string `json:"next"`
}
if cursor.overflow {
err = fmt.Errorf("history cursor exceeds 64 KiB")
} else {
err = json.Unmarshal(cursor.Bytes(), &decoded)
next = decoded.Next
}
}
default:
err = p.value(nil, 1, false)
}
if err != nil {
break
}
c, err = p.peek()
if err != nil || c == '}' {
if err == nil {
err = p.take(nil, '}')
}
break
}
err = p.take(nil, ',')
}
if err == nil && !found {
err = fmt.Errorf("missing history data")
}
} else {
err = fmt.Errorf("invalid history envelope")
}
if err != nil {
return nil, "", false, fmt.Errorf("invalid OpenCode history: %w", err)
}
if _, err := p.peek(); err != io.EOF {
if err == nil {
err = fmt.Errorf("trailing JSON data")
}
return nil, "", false, err
}
return messages, next, descending, nil
}
func (p *historyJSON) peek() (byte, error) {
for {
if err := p.ctx.Err(); err != nil {
return 0, err
}
b, err := p.r.Peek(1)
if err != nil {
return 0, err
}
switch b[0] {
case ' ', '\n', '\r', '\t':
p.r.ReadByte()
default:
return b[0], nil
}
}
}
func (p *historyJSON) take(out *historyBuffer, want byte) error {
c, err := p.peek()
if err != nil {
return err
}
if c != want {
return fmt.Errorf("expected JSON delimiter")
}
p.r.ReadByte()
out.put(c)
return nil
}
func (p *historyJSON) str(out, key *historyBuffer) error {
if err := p.take(out, '"'); err != nil {
return err
}
key.put('"')
escape, unicode := false, 0
for {
// Check cancellation even within a multi-gigabyte discarded string.
if err := p.ctx.Err(); err != nil {
return err
}
c, err := p.r.ReadByte()
if err != nil {
return err
}
out.put(c)
key.put(c)
if unicode > 0 {
if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') {
return fmt.Errorf("invalid Unicode escape")
}
unicode--
} else if escape {
escape = false
switch c {
case 'u':
unicode = 4
case '"', '\\', '/', 'b', 'f', 'n', 'r', 't':
default:
return fmt.Errorf("invalid string escape")
}
} else {
switch {
case c == '"':
return nil
case c == '\\':
escape = true
case c < 0x20:
return fmt.Errorf("invalid string control character")
}
}
}
}
func (p *historyJSON) value(out *historyBuffer, depth int, project bool) error {
if depth > 128 {
return fmt.Errorf("history JSON nesting exceeds 128")
}
c, err := p.peek()
if err != nil {
return err
}
switch c {
case '"':
return p.str(out, nil)
case '{', '[':
open, close := c, byte('}')
if open == '[' {
close = ']'
}
p.take(out, open)
c, err = p.peek()
if err != nil {
return err
}
if c == close {
return p.take(out, close)
}
for {
var name string
if open == '{' {
key := &historyBuffer{limit: 256}
if err := p.str(out, key); err != nil {
return err
}
if !key.overflow {
_ = json.Unmarshal(key.Bytes(), &name)
}
if err := p.take(out, ':'); err != nil {
return err
}
}
if project && name == "state" {
state := &historyBuffer{limit: historyToolPreviewBytes}
if err := p.value(state, depth+1, false); err != nil {
return err
}
data := state.Bytes()
if state.overflow {
data = []byte(`{"truncated":true,"content":[{"type":"text","text":"Tool details omitted: stored result exceeds the 64 KiB history preview budget."}]}`)
}
for _, b := range data {
out.put(b)
}
} else if err := p.value(out, depth+1, project); err != nil {
return err
}
c, err = p.peek()
if err != nil {
return err
}
if c == close {
return p.take(out, close)
}
if err := p.take(out, ','); err != nil {
return err
}
}
default:
// JSON numbers/literals are small in this schema. Validate without ever
// accumulating an attacker-controlled unbounded primitive.
token := &historyBuffer{limit: 128}
for {
b, err := p.r.Peek(1)
if err == io.EOF {
break
}
if err != nil {
return err
}
c = b[0]
if c == ',' || c == ']' || c == '}' || c == ' ' || c == '\n' || c == '\r' || c == '\t' {
break
}
p.r.ReadByte()
token.put(c)
if token.overflow {
return fmt.Errorf("invalid history primitive")
}
}
if !json.Valid(token.Bytes()) {
return fmt.Errorf("invalid history primitive")
}
for _, b := range token.Bytes() {
out.put(b)
}
return nil
}
}
+204
View File
@@ -0,0 +1,204 @@
package opencode
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"runtime"
"strings"
"testing"
)
func mustHistoryJSON(t *testing.T, value any) string {
t.Helper()
data, err := json.Marshal(value)
if err != nil {
t.Fatal(err)
}
return string(data)
}
// A generated fixture, not a live-model history. No allocation proportional to
// the oversized string exists on either side of the allocation measurement.
type historyRepeatReader struct {
remaining int
read int
maxRead int
cancel context.CancelFunc
}
func (r *historyRepeatReader) Read(b []byte) (int, error) {
if len(b) > r.maxRead {
r.maxRead = len(b)
}
n := min(len(b), r.remaining)
for i := range b[:n] {
b[i] = 'x'
}
r.remaining -= n
r.read += n
if r.cancel != nil && r.read > 1<<20 {
r.cancel()
}
if n == 0 {
return 0, io.EOF
}
return n, nil
}
func historyLargeFixture(detail io.Reader) io.Reader {
return io.MultiReader(
strings.NewReader(`{"data":[{"id":"new","type":"assistant","content":[{"type":"tool","state":{"status":"completed","content":[{"type":"text","text":"`),
detail,
strings.NewReader(`"}]}},{"type":"text","text":"Newest answer: \uD83C\uDF19"}]}],"cursor":{"next":"opaque+/=&"}}`),
)
}
func TestHistoryStreamingAllocationBound(t *testing.T) {
for _, size := range []int{2 << 20, 32 << 20} {
t.Run(fmt.Sprint(size), func(t *testing.T) {
r := &historyRepeatReader{remaining: size}
reader := historyLargeFixture(r)
runtime.GC()
var before, after runtime.MemStats
runtime.ReadMemStats(&before)
messages, next, _, err := decodeChatHistoryPage(context.Background(), "ses_1", reader)
runtime.ReadMemStats(&after)
allocated := after.TotalAlloc - before.TotalAlloc
t.Logf("wire detail=%d allocated=%d max read=%d", size, allocated, r.maxRead)
if err != nil {
t.Fatal(err)
}
if allocated > 1<<20 || r.maxRead > 32<<10 || r.read != size {
t.Fatalf("unbounded reader: alloc=%d read=%d chunk=%d", allocated, r.read, r.maxRead)
}
if next != "opaque+/=&" || len(messages) != 1 || messages[0].Parts[1].Text != "Newest answer: 🌙" || !messages[0].Parts[0].State.Truncated {
t.Fatalf("projection lost answer/cursor: %+v", messages)
}
})
}
}
func TestHistoryStreamingCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
r := &historyRepeatReader{remaining: 32 << 20, cancel: cancel}
_, _, _, err := decodeChatHistoryPage(ctx, "ses_1", historyLargeFixture(r))
if !errors.Is(err, context.Canceled) || r.read >= 2<<20 {
t.Fatalf("cancellation did not interrupt discarded string: read=%d err=%v", r.read, err)
}
}
func TestHistoryBoundsAllToolDetails(t *testing.T) {
for _, detail := range []string{
`"input":{"text":"` + strings.Repeat("x", 2<<20) + `"}`,
`"metadata":{"blob":"` + strings.Repeat("x", 2<<20) + `"}`,
`"content":[{"type":"file","data":"` + strings.Repeat("x", 2<<20) + `"}]`,
`"content":[` + strings.Repeat(`{"type":"text","text":"small"},`, 10000) + `{"type":"text","text":"last"}]`,
} {
raw := `{"data":[{"type":"assistant","content":[{"type":"tool","state":{` + detail + `}},{"type":"text","text":"answer"}]}]}`
messages, _, _, err := decodeChatHistoryPage(context.Background(), "ses_1", strings.NewReader(raw))
if err != nil || len(messages) != 1 || !messages[0].Parts[0].State.Truncated || messages[0].Parts[1].Text != "answer" {
t.Fatalf("detail prevented answer: %v", err)
}
}
}
func TestHistoryLegacyLargeToolAndNonJSON(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/session/ses_1/message" {
t.Errorf("wrong legacy path: %s", r.URL)
}
if r.URL.Query().Get("directory") == "not-json" {
io.WriteString(w, "not JSON")
return
}
w.Header().Set("Content-Type", "application/json")
io.WriteString(w, `[{"info":{"id":"msg_1","role":"assistant"},"parts":[{"type":"tool","state":{"content":[{"text":"`)
io.Copy(w, &historyRepeatReader{remaining: 2 << 20})
io.WriteString(w, `"}]}},{"type":"text","text":"legacy answer"}]}]`)
}))
defer srv.Close()
conn := &Connection{Backend: "v1", URL: srv.URL}
chat := NewChat(conn)
page, err := chat.Messages(context.Background(), "ses_1", 1, "")
if err != nil || page.HasMore || len(page.Messages) != 1 || !page.Messages[0].Parts[0].State.Truncated || page.Messages[0].Parts[1].Text != "legacy answer" {
t.Fatalf("legacy history: %+v %v", page, err)
}
conn.Directory = "not-json"
if _, err := chat.Messages(context.Background(), "ses_1", 1, ""); err == nil || !strings.Contains(err.Error(), "non-JSON") {
t.Fatalf("accepted non-JSON history: %v", err)
}
}
func TestHistoryRejectsMalformedIncludingDiscardedDetail(t *testing.T) {
for _, raw := range []string{
`null`, `{"data":null}`, `{"data":{}}`, `{"data":[],"cursor":{"next":42}}`,
`{"data":[],"data":[]}`, `{"data":[],"cursor":{"next":"one"},"cursor":{"next":"two"}}`,
`{"data":[]} {}`, `{"data":[}`, `{"data":[],}`, `{"data":[],"x":01}`, `{"data":[],"x":1,"x":2}`,
`{"data":[],"state":{"text":"` + strings.Repeat("x", 1<<20) + `\q"}}`,
`{"data":[],"state":{"text":"` + strings.Repeat("x", 1<<20) + `\u12G4"}}`,
`{"data":[],"state":{"text":"` + strings.Repeat("x", 1<<20),
strings.Repeat("[", 130) + strings.Repeat("]", 130),
} {
if _, _, _, err := decodeChatHistoryPage(context.Background(), "ses_1", strings.NewReader(raw)); err == nil {
t.Fatalf("accepted malformed fixture (length %d)", len(raw))
}
}
}
func TestHistoryDoesNotCapConversationTextOrSmallToolState(t *testing.T) {
answer := strings.Repeat("answer 🌙\n", 150000)
raw := mustHistoryJSON(t, map[string]any{"data": []any{
map[string]any{"id": "new", "type": "assistant", "text": "", "content": []any{
map[string]any{"type": "text", "text": answer},
map[string]any{"type": "tool", "state": map[string]any{"status": "completed", "input": map[string]any{"x": "y"}, "metadata": map[string]any{"exit": 0}}},
}},
}})
messages, _, _, err := decodeChatHistoryPage(context.Background(), "ses_1", strings.NewReader(raw))
if err != nil || len(messages) != 1 || messages[0].Parts[0].Text != answer {
t.Fatalf("conversation text capped: %v", err)
}
state := messages[0].Parts[1].State
if state.Truncated || state.Status != "completed" || string(state.Input) != `{"x":"y"}` || state.Metadata["exit"] != float64(0) {
t.Fatalf("small state changed: %+v", state)
}
}
func TestHistoryHTTPAuthenticationAndCancellation(t *testing.T) {
started := make(chan struct{})
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
user, pass, _ := r.BasicAuth()
if user != "operator" || pass != "fixture-password" {
w.WriteHeader(http.StatusUnauthorized)
return
}
if r.URL.Query().Get("directory") != "/fixture dir" {
t.Errorf("missing directory scope: %s", r.URL)
}
w.Header().Set("Content-Type", "application/json")
io.WriteString(w, `{"data":[`)
w.(http.Flusher).Flush()
close(started)
<-r.Context().Done()
}))
defer srv.Close()
conn := &Connection{Backend: "v2", URL: srv.URL, username: "operator", Directory: "/fixture dir"}
chat := NewChat(conn)
if _, err := chat.Messages(context.Background(), "ses_1", 1, ""); err == nil || !conn.unauthorized || conn.LastHTTPStatus != 401 {
t.Fatalf("auth refusal not recorded: %v %+v", err, conn)
}
conn.password = "fixture-password"
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { _, err := chat.Messages(ctx, "ses_1", 1, ""); done <- err }()
<-started
cancel()
if err := <-done; !errors.Is(err, context.Canceled) {
t.Fatalf("HTTP cancellation = %v", err)
}
}
+13
View File
@@ -16,6 +16,9 @@ type boundedOutput struct {
}
func (b *boundedOutput) Write(p []byte) (int, error) {
if b.limit < 0 {
return b.Buffer.Write(p)
}
n := len(p)
remaining := b.limit - b.Len()
if n > remaining {
@@ -26,6 +29,16 @@ func (b *boundedOutput) Write(p []byte) (int, error) {
return n, nil
}
// WriteByte keeps byte-oriented history scanning under the same bound as Write;
// the embedded Buffer's promoted WriteByte would otherwise bypass the cap.
func (b *boundedOutput) WriteByte(c byte) error {
if b.limit >= 0 && b.Len() >= b.limit {
b.overflow = true
return nil
}
return b.Buffer.WriteByte(c)
}
// ReadFrom reads through the bounded Write so the cap applies even when
// os/exec's io.Copy selects a ReadFrom on the destination: without this the
// embedded bytes.Buffer's promoted ReadFrom would bypass Write and buffer the
+15
View File
@@ -193,6 +193,18 @@ type ChatAdoptRequest struct {
type ChatQuery struct {
SessionID string `json:"session_id"`
Limit int `json:"limit,omitempty"`
// Cursor is the opaque continuation returned by OpenCode's descending
// message listing. It is deliberately not interpreted by the broker.
Cursor string `json:"cursor,omitempty"`
}
// ChatHistoryPage describes the bounded slice returned by chat_messages. The
// newest page has an empty Cursor request; NextCursor remains opaque and is
// supplied unchanged to fetch older turns.
type ChatHistoryPage struct {
Messages []ChatMessage `json:"messages"`
NextCursor string `json:"next_cursor,omitempty"`
HasMore bool `json:"has_more,omitempty"`
}
// ChatPromptRequest is the chat_prompt request body: the text to send, with an
@@ -266,6 +278,9 @@ type ChatToolState struct {
Content []ChatToolContent `json:"content,omitempty"`
Metadata map[string]any `json:"metadata,omitempty"`
Error *ChatError `json:"error,omitempty"`
// Truncated says Content is a bounded preview of a larger stored result.
// The turn remains usable; callers must not present the preview as complete.
Truncated bool `json:"truncated,omitempty"`
}
// ChatToolContent is one returned tool result: either text or a file/uri pair
+1
View File
@@ -169,6 +169,7 @@ type Message struct {
ChatQuery *ChatQuery `json:"chat_query,omitempty"`
ChatPrompt *ChatPromptRequest `json:"chat_prompt,omitempty"`
ChatMessages []ChatMessage `json:"chat_messages,omitempty"`
ChatHistory *ChatHistoryPage `json:"chat_history,omitempty"`
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"`
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
+1 -1
View File
@@ -19,7 +19,7 @@ type chatBroker interface {
// can order the prompt after the subscription.
Stream(ctx context.Context, sessionID string, ready func(), emit func(protocol.ChatEventFrame) error) error
Interrupt(ctx context.Context, sessionID string) error
Messages(ctx context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error)
Messages(ctx context.Context, sessionID string, limit int, cursor string) (protocol.ChatHistoryPage, error)
// Sessions lists the endpoint's OpenCode sessions so the handler can
// restrict them to the operator's own recorded sessions.
Sessions(ctx context.Context) ([]protocol.ChatSession, error)
+5 -9
View File
@@ -15,23 +15,19 @@ func handleChatMessages(ctx context.Context, request protocol.Message, broker ch
return
}
response := protocol.Message{Type: protocol.ChatMessages, ID: request.ID}
// Resume from retained server state first: a reconnecting client gets the
// accumulated turns with the same stable ids without re-reading OpenCode.
if messages := hub.snapshot(query.SessionID); len(messages) > 0 {
response.ChatMessages = messages
_ = write(response)
return
}
// A hub snapshot is only the live tail. It is never authoritative history:
// serving it here used to make older turns unreachable after a reconnect.
if broker == nil {
_ = write(response)
return
}
messages, err := broker.Messages(ctx, query.SessionID, query.Limit)
page, err := broker.Messages(ctx, query.SessionID, query.Limit, query.Cursor)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
response.ChatMessages = messages
response.ChatMessages = page.Messages // legacy peers keep working.
response.ChatHistory = &page
_ = write(response)
}
+107
View File
@@ -0,0 +1,107 @@
package server
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Scratch HTTP + real /connect websocket fixture, NOT a live-model/production
// claim. Covers both >1 MiB total (many tools) and one >1 MiB tool string.
func TestChatHistoryLargeFixtureWebsocketTraversalAndReconnect(t *testing.T) {
fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/session/ses_1/message" || r.URL.Query().Get("limit") != "2" {
t.Errorf("unexpected history query %s", r.URL)
}
w.Header().Set("Content-Type", "application/json")
page := 0
switch r.URL.Query().Get("cursor") {
case "":
case "older+/=&":
page = 1
case "last":
page = 2
default:
t.Errorf("cursor not passed opaquely: %s", r.URL)
}
io.WriteString(w, `{"data":[`)
for i := 0; i < 2; i++ {
if i != 0 {
io.WriteString(w, ",")
}
id := 6 - page*2 - i
// Equal timestamps deliberately: order comes from the verified V2
// descending sequence, not a guessed timestamp comparison.
fmt.Fprintf(w, `{"id":"msg_%d","type":"assistant","time":{"created":1},"content":[`, id)
if page == 0 && i == 0 {
io.WriteString(w, `{"type":"tool","id":"huge","state":{"content":[{"type":"text","text":"`)
chunk := strings.Repeat("x", 32<<10)
for n := 0; n < 65; n++ {
io.WriteString(w, chunk)
}
io.WriteString(w, `"}]}},`)
}
if page == 1 && i == 0 {
for n := 0; n < 25; n++ {
fmt.Fprintf(w, `{"type":"tool","id":"tool_%d","state":{"status":"completed","content":[{"type":"text","text":%q}]}},`, n, strings.Repeat("y", 48<<10))
}
}
fmt.Fprintf(w, `{"type":"text","text":"answer %d"}]}`, id)
}
next := []any{"older+/=&", "last", nil}[page]
encoded, _ := json.Marshal(next)
fmt.Fprintf(w, `],"cursor":{"next":%s}}`, encoded)
}))
defer fixture.Close()
broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL})
ctx, _, srv, conns := dialChatServer(t, Options{Chat: broker}, 1)
conn := conns[0]
conn.SetReadLimit(8 << 20)
cursor := ""
var ids []string
seen := map[string]bool{}
for page := 0; page < 3; page++ {
writeChat(t, ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "history", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1", Limit: 2, Cursor: cursor}})
response := readUntil(t, ctx, conn, protocol.ChatMessages)
if response.ChatHistory == nil || len(response.ChatHistory.Messages) != 2 {
t.Fatalf("missing page: %+v", response)
}
history := response.ChatHistory
if !reflect.DeepEqual(response.ChatMessages, history.Messages) {
t.Fatal("legacy/page views differ")
}
for _, message := range history.Messages {
if seen[message.ID] {
t.Fatalf("duplicate %s", message.ID)
}
seen[message.ID] = true
}
pageIDs := []string{history.Messages[0].ID, history.Messages[1].ID}
ids = append(pageIDs, ids...)
if page == 0 {
newest := history.Messages[1]
if newest.Parts[len(newest.Parts)-1].Text != "answer 6" || !newest.Parts[0].State.Truncated {
t.Fatal("huge tool prevented newest answer")
}
}
cursor = history.NextCursor
if history.HasMore != (page < 2) {
t.Fatal("incorrect continuation")
}
// Reconnect between pages: continuation is server-owned, not a hub tail.
conn.CloseNow()
conn = dialChatConn(t, ctx, srv)
conn.SetReadLimit(8 << 20)
}
if cursor != "" || !reflect.DeepEqual(ids, []string{"msg_1", "msg_2", "msg_3", "msg_4", "msg_5", "msg_6"}) {
t.Fatalf("incomplete traversal: %v cursor=%q", ids, cursor)
}
}
+12 -14
View File
@@ -68,8 +68,8 @@ func (c *channelChat) Stream(ctx context.Context, _ string, ready func(), emit f
func (c *channelChat) Interrupt(context.Context, string) error { return nil }
func (c *channelChat) Messages(context.Context, string, int) ([]protocol.ChatMessage, error) {
return nil, nil
func (c *channelChat) Messages(context.Context, string, int, string) (protocol.ChatHistoryPage, error) {
return protocol.ChatHistoryPage{}, nil
}
func (c *channelChat) Sessions(context.Context) ([]protocol.ChatSession, error) { return nil, nil }
@@ -442,10 +442,11 @@ func TestChatPendingApprovalsAllReplayed(t *testing.T) {
}
// TestChatResyncAfterReconnect is the resync acceptance test: a client that drops
// and reconnects re-syncs the whole conversation from retained state, including
// the user turn and who sent it.
// and reconnects reads authoritative history rather than mistaking a retained
// live tail for the whole conversation.
func TestChatResyncAfterReconnect(t *testing.T) {
broker := scriptedChat()
broker.messages = seededChatMessages()
ctx, _, srv, conns := dialChatServer(t, Options{Chat: broker}, 1)
phone := conns[0]
@@ -456,19 +457,16 @@ func TestChatResyncAfterReconnect(t *testing.T) {
// The phone's socket drops.
phone.CloseNow()
// A fresh connection re-syncs from retained state.
// A fresh connection reads the authoritative history rather than treating the
// retained live tail as a complete transcript.
reconnected := dialChatConn(t, ctx, srv)
writeChat(t, ctx, reconnected, protocol.Message{Type: protocol.ChatMessages, ID: "m1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}})
response := readUntil(t, ctx, reconnected, protocol.ChatMessages)
if len(response.ChatMessages) != 2 {
t.Fatalf("resync returned %d messages, want user+assistant: %+v", len(response.ChatMessages), response.ChatMessages)
if response.ChatHistory == nil {
t.Fatalf("resync did not return a history page: %+v", response)
}
user := response.ChatMessages[0]
if user.Role != protocol.ChatRoleUser || user.Client != "Pixel 9" || len(user.Parts) != 1 || user.Parts[0].Text != "hi" {
t.Fatalf("resynced user turn = %+v", user)
}
assistant := response.ChatMessages[1]
if assistant.Role != protocol.ChatRoleAssistant || assistant.ID != "msg_1" {
t.Fatalf("resynced assistant turn = %+v", assistant)
assertSeededChatMessages(t, response.ChatHistory.Messages)
if calls, _, _ := broker.messageQuery(); calls != 1 {
t.Fatalf("reconnect skipped authoritative history: %d calls", calls)
}
}
+11 -22
View File
@@ -48,6 +48,7 @@ type fakeChat struct {
messageCalls int
messageSessionID string
messageLimit int
messageCursor string
messages []protocol.ChatMessage
permissionCalls int
permissionSessionID string
@@ -169,13 +170,14 @@ func (f *fakeChat) Interrupt(context.Context, string) error {
return f.interruptErr
}
func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) {
func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int, cursor string) (protocol.ChatHistoryPage, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.messageCalls++
f.messageSessionID = sessionID
f.messageLimit = limit
return f.messages, nil
f.messageCursor = cursor
return protocol.ChatHistoryPage{Messages: f.messages}, nil
}
// messageQuery reports the recorded chat_messages call count, session id and
@@ -472,6 +474,7 @@ func TestChatPromptWithoutBroker(t *testing.T) {
func TestChatMessagesResumesRetainedState(t *testing.T) {
broker := scriptedChat()
broker.messages = seededChatMessages()
ctx, _, conn := dialChat(t, broker)
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
t.Fatal(err)
@@ -488,27 +491,13 @@ func TestChatMessagesResumesRetainedState(t *testing.T) {
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 2 {
if response.Type != protocol.ChatMessages || response.ID != "r2" || response.ChatHistory == nil {
t.Fatalf("resume response = %+v", response)
}
// The prompt is retained as a user turn and the assistant reply beside it, so
// a reconnecting client re-syncs a conversation that still says who sent
// what. The user turn carries the sending client's label (the generic
// fallback when the prompt did not name one).
user := response.ChatMessages[0]
if user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "hi" || user.Client != chatClientLabelFallback {
t.Fatalf("resumed user turn = %+v", user)
}
message := response.ChatMessages[1]
if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 {
t.Fatalf("resumed message = %+v", message)
}
if message.Parts[0].Type != protocol.ChatPartText || message.Parts[0].ID != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0) || message.Parts[0].Text != "hello world" {
t.Fatalf("resumed text part = %+v", message.Parts[0])
}
if message.Parts[1].Type != protocol.ChatPartTool || message.Parts[1].State == nil || message.Parts[1].State.Status != protocol.ChatToolCompleted {
t.Fatalf("resumed tool part = %+v", message.Parts[1])
if calls, _, _ := broker.messageQuery(); calls != 1 {
t.Fatalf("authoritative history was not read: %d calls", calls)
}
assertSeededChatMessages(t, response.ChatMessages)
}
// seededChatMessages is the stored user + assistant + tool session the
@@ -599,12 +588,12 @@ func TestChatMessagesThroughRealAdapter(t *testing.T) {
messageReads.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[
{"id":"msg_user","time":{"created":10},"type":"user","text":"list the files"},
{"id":"msg_assistant","time":{"created":20,"completed":30},"type":"assistant","agent":"build","model":{"id":"deepseek-v4.1-flash","providerID":"opencode-go"},"content":[
{"type":"text","text":"here you go"},
{"type":"reasoning","text":"thinking"},
{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"completed","input":{"command":"ls"},"content":[{"type":"text","text":"ok"}]},"time":{"created":1,"ran":2,"completed":3}}
]}
]},
{"id":"msg_user","time":{"created":10},"type":"user","text":"list the files"}
],"cursor":{"next":null}}`))
}))
defer fixture.Close()