Expose OpenCode conversation history in chat_messages

decodeChatMessages only understood the native-serve {info,parts} envelope,
so records from the V2 HTTP API (GET /api/session/{id}/message) decoded
with an empty role and were silently dropped, leaving chat_messages with
empty history. Teach nativeChatMessage to read the V2 top-level shape
(id/type/agent/model/time, parts under "content", user prompt as a bare
string) while keeping the native {info,parts} path via role/id/model/agent/
created accessors and a contentParts fallback.

Add seeded-session evidence: a decoder table test covering both envelopes
(user + assistant with text, reasoning and a completed tool part carrying
input, content and status) plus handler tests that drive chat_messages
through the broker fallthrough and through the real adapter.
This commit is contained in:
2026-10-16 05:24:00 +01:00
parent 315788b3cb
commit 915016df0b
3 changed files with 374 additions and 25 deletions
+94 -17
View File
@@ -290,26 +290,98 @@ func stepIndex(data chatEvent) int {
return data.Index
}
// decodeChatMessages maps the native /message response onto the protocol chat
// history shape. Assistant content parts are text, reasoning and tool; a user
// turn is the prompt text. It never re-derives provider shapes.
// nativeChatMessage is one stored turn. The two surfaces return different
// envelopes for the same session and both decode into this one struct, so the
// mapping below reads whichever fields a record populated:
//
// - the V2 HTTP API (GET /api/session/{id}/message) puts id/type/agent/model,
// the timing and the parts array at the message top level, with the parts
// under "content" and a user turn's text as a bare string;
// - the native serve readback nests the same fields under "info" (role as
// "role", model as "modelID", timing as "created") with the parts under
// "parts".
type nativeChatMessage struct {
Info struct {
ID string `json:"id"`
Type string `json:"type"`
Agent string `json:"agent"`
Model nativeChatModel `json:"model"`
Time *protocol.ChatTime `json:"time"`
Text string `json:"text"`
Content []nativeChatPart `json:"content"`
Info struct {
ID string `json:"id"`
Role string `json:"role"`
ModelID string `json:"modelID"`
Agent string `json:"agent"`
CreatedAt int64 `json:"created"`
} `json:"info"`
Parts []struct {
Type string `json:"type"`
ID string `json:"id"`
Text string `json:"text"`
Name string `json:"name"`
Executed bool `json:"executed"`
State *protocol.ChatToolState `json:"state"`
Time *protocol.ChatTime `json:"time"`
} `json:"parts"`
Parts []nativeChatPart `json:"parts"`
}
// nativeChatModel is the nested Model.Ref a V2 turn carries ({id, providerID,
// variant}); only the model id is surfaced in the protocol message.
type nativeChatModel struct {
ID string `json:"id"`
}
// nativeChatPart is one content element shared by both message envelopes.
type nativeChatPart struct {
Type string `json:"type"`
ID string `json:"id"`
Text string `json:"text"`
Name string `json:"name"`
Executed bool `json:"executed"`
State *protocol.ChatToolState `json:"state"`
Time *protocol.ChatTime `json:"time"`
}
// role, parts and the accessor methods below read the V2 top-level fields first
// and fall back to the native serve "info"/"parts" fields, so one record maps
// regardless of which surface produced it.
func (m nativeChatMessage) role() string {
if m.Info.Role != "" {
return m.Info.Role
}
return m.Type
}
func (m nativeChatMessage) messageID() string {
if m.Info.ID != "" {
return m.Info.ID
}
return m.ID
}
func (m nativeChatMessage) modelID() string {
if m.Info.ModelID != "" {
return m.Info.ModelID
}
return m.Model.ID
}
func (m nativeChatMessage) agent() string {
if m.Info.Agent != "" {
return m.Info.Agent
}
return m.Agent
}
func (m nativeChatMessage) createdAt() int64 {
if m.Info.CreatedAt != 0 {
return m.Info.CreatedAt
}
if m.Time != nil {
return m.Time.Created
}
return 0
}
func (m nativeChatMessage) contentParts() []nativeChatPart {
if m.Parts != nil {
return m.Parts
}
return m.Content
}
// chatMessageRecords accepts both message envelopes the two surfaces return:
@@ -335,13 +407,13 @@ func decodeChatMessages(sessionID string, data []byte) ([]protocol.ChatMessage,
return nil, err
}
messages := make([]protocol.ChatMessage, 0, len(records))
for _, message := range records {
role := message.Info.Role
for _, record := range records {
role := record.role()
if role != protocol.ChatRoleUser && role != protocol.ChatRoleAssistant {
continue
}
out := protocol.ChatMessage{ID: message.Info.ID, SessionID: sessionID, Role: role, Model: message.Info.ModelID, Agent: message.Info.Agent, CreatedAt: message.Info.CreatedAt}
for _, part := range message.Parts {
out := protocol.ChatMessage{ID: record.messageID(), SessionID: sessionID, Role: role, Model: record.modelID(), Agent: record.agent(), CreatedAt: record.createdAt()}
for _, part := range record.contentParts() {
switch part.Type {
case protocol.ChatPartText, protocol.ChatPartReasoning:
out.Parts = append(out.Parts, protocol.ChatPart{Type: part.Type, ID: part.ID, Text: part.Text})
@@ -349,6 +421,11 @@ func decodeChatMessages(sessionID string, data []byte) ([]protocol.ChatMessage,
out.Parts = append(out.Parts, protocol.ChatPart{Type: protocol.ChatPartTool, ID: part.ID, Name: part.Name, Executed: part.Executed, State: part.State, Time: part.Time})
}
}
// A V2 user turn carries its prompt text as a message-level string rather
// than a content array, so surface it as the turn's single text part.
if len(out.Parts) == 0 && role == protocol.ChatRoleUser && record.Text != "" {
out.Parts = append(out.Parts, protocol.ChatPart{Type: protocol.ChatPartText, Text: record.Text})
}
messages = append(messages, out)
}
return messages, nil
+124 -7
View File
@@ -165,18 +165,135 @@ func TestChatRejectsInvalidSessionWithoutCalling(t *testing.T) {
}
}
// TestDecodeChatMessages loads a seeded user + assistant session in both
// response envelopes the two surfaces return and asserts the turns come back
// with role, id, part order, part ids and the completed tool's input, content
// and status intact. The V2 HTTP API (GET /api/session/{id}/message) wraps the
// messages in {"data":[...]} with the fields at the message top level and the
// parts under "content"; the native serve readback returns a bare array with the
// fields under "info" and the parts under "parts".
func TestDecodeChatMessages(t *testing.T) {
raw := []byte(`{"data":[{"info":{"id":"msg_1","role":"assistant","modelID":"m","agent":"build","created":10},"parts":[{"type":"text","id":"p1","text":"hi"},{"type":"reasoning","id":"p2","text":"hmm"},{"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}}]}]}`)
messages, err := decodeChatMessages("ses_1", raw)
cases := []struct {
name string
raw string
wantUserPartID string
wantUserPartTxt string
wantTextPartID string
wantReasonPartID string
}{
{
name: "v2 data envelope",
raw: `{"data":[
{"id":"msg_user","time":{"created":10},"type":"user","text":"list the files"},
{"id":"msg_assistant","time":{"created":20,"streamed":25,"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"}],"metadata":{"exit":0}},"time":{"created":1,"ran":2,"completed":3}}
]}
],"cursor":{"next":null}}`,
wantUserPartID: "",
wantUserPartTxt: "list the files",
wantTextPartID: "",
wantReasonPartID: "",
},
{
name: "v1 bare array",
raw: `[
{"info":{"id":"msg_user","role":"user","created":10},"parts":[{"type":"text","id":"p0","text":"list the files"}]},
{"info":{"id":"msg_assistant","role":"assistant","modelID":"deepseek-v4.1-flash","agent":"build","created":20},"parts":[
{"type":"text","id":"p1","text":"here you go"},
{"type":"reasoning","id":"p2","text":"thinking"},
{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"completed","input":{"command":"ls"},"content":[{"type":"text","text":"ok"}],"metadata":{"exit":0}},"time":{"created":1,"ran":2,"completed":3}}
]}
]`,
wantUserPartID: "p0",
wantUserPartTxt: "list the files",
wantTextPartID: "p1",
wantReasonPartID: "p2",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
messages, err := decodeChatMessages("ses_1", []byte(tc.raw))
if err != nil {
t.Fatalf("decode: %v", err)
}
if len(messages) != 2 {
t.Fatalf("got %d messages, want user+assistant: %+v", len(messages), messages)
}
user, assistant := messages[0], messages[1]
if user.ID != "msg_user" || user.Role != protocol.ChatRoleUser || user.SessionID != "ses_1" {
t.Fatalf("user turn = %+v", user)
}
if len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].ID != tc.wantUserPartID || user.Parts[0].Text != tc.wantUserPartTxt {
t.Fatalf("user parts = %+v", user.Parts)
}
if assistant.ID != "msg_assistant" || assistant.Role != protocol.ChatRoleAssistant || assistant.SessionID != "ses_1" {
t.Fatalf("assistant turn = %+v", assistant)
}
if assistant.Model != "deepseek-v4.1-flash" || assistant.Agent != "build" {
t.Fatalf("assistant model/agent = %q/%q", assistant.Model, assistant.Agent)
}
if len(assistant.Parts) != 3 {
t.Fatalf("got %d assistant parts, want text+reasoning+tool: %+v", len(assistant.Parts), assistant.Parts)
}
if p := assistant.Parts[0]; p.Type != protocol.ChatPartText || p.ID != tc.wantTextPartID || p.Text != "here you go" {
t.Fatalf("text part = %+v", p)
}
if p := assistant.Parts[1]; p.Type != protocol.ChatPartReasoning || p.ID != tc.wantReasonPartID || p.Text != "thinking" {
t.Fatalf("reasoning part = %+v", p)
}
tool := assistant.Parts[2]
if tool.Type != protocol.ChatPartTool || tool.ID != "call_1" || tool.Name != "shell" || !tool.Executed {
t.Fatalf("tool part = %+v", tool)
}
if tool.State == nil || tool.State.Status != protocol.ChatToolCompleted {
t.Fatalf("tool state = %+v", tool.State)
}
var input struct {
Command string `json:"command"`
}
if err := json.Unmarshal(tool.State.Input, &input); err != nil || input.Command != "ls" {
t.Fatalf("tool input = %s (err %v)", tool.State.Input, err)
}
if len(tool.State.Content) != 1 || tool.State.Content[0].Type != "text" || tool.State.Content[0].Text != "ok" {
t.Fatalf("tool content = %+v", tool.State.Content)
}
if tool.Time == nil || tool.Time.Completed != 3 {
t.Fatalf("tool time = %+v", tool.Time)
}
})
}
}
// TestDecodeChatMessagesSkipsUnknownPartsAndRoles pins that a non user/assistant
// turn and an unrecognised part type are skipped instead of failing the whole
// history, and that an unparseable body is an error rather than empty history.
func TestDecodeChatMessagesSkipsUnknownPartsAndRoles(t *testing.T) {
raw := `{"data":[
{"id":"msg_system","type":"system","content":[{"type":"text","text":"ignore me"}]},
{"id":"msg_user","time":{"created":1},"type":"user","text":"hi"},
{"id":"msg_assistant","time":{"created":2},"type":"assistant","content":[
{"type":"text","text":"ok"},
{"type":"file","text":"ignored"},
{"type":"step","text":"ignored"}
]}
]}`
messages, err := decodeChatMessages("ses_1", []byte(raw))
if err != nil {
t.Fatal(err)
}
if len(messages) != 1 || messages[0].Role != protocol.ChatRoleAssistant || len(messages[0].Parts) != 3 {
t.Fatalf("messages = %+v", messages)
if len(messages) != 2 {
t.Fatalf("got %d messages, want the system turn skipped: %+v", len(messages), messages)
}
tool := messages[0].Parts[2]
if tool.Type != protocol.ChatPartTool || tool.Name != "shell" || tool.State == nil || tool.State.Status != protocol.ChatToolCompleted || tool.Time == nil {
t.Fatalf("tool part = %+v", tool)
if messages[0].Role != protocol.ChatRoleUser || len(messages[0].Parts) != 1 || messages[0].Parts[0].Text != "hi" {
t.Fatalf("user turn = %+v", messages[0])
}
if messages[1].Role != protocol.ChatRoleAssistant || len(messages[1].Parts) != 1 || messages[1].Parts[0].Text != "ok" {
t.Fatalf("assistant turn = %+v", messages[1])
}
if _, err := decodeChatMessages("ses_1", []byte("not json")); err == nil {
t.Fatal("an unparseable body must be an error, not empty history")
}
}
+156 -1
View File
@@ -26,6 +26,9 @@ type fakeChat struct {
promptCalls int
interrupts int
replies int
messageCalls int
messageSessionID string
messageLimit int
messages []protocol.ChatMessage
script []protocol.ChatEventFrame
started chan struct{}
@@ -81,10 +84,23 @@ func (f *fakeChat) Interrupt(context.Context, string) error {
return nil
}
func (f *fakeChat) Messages(context.Context, string, int) ([]protocol.ChatMessage, error) {
func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.messageCalls++
f.messageSessionID = sessionID
f.messageLimit = limit
return f.messages, nil
}
// messageQuery reports the recorded chat_messages call count, session id and
// limit so a test can assert the handler forwarded the query.
func (f *fakeChat) messageQuery() (int, string, int) {
f.mu.Lock()
defer f.mu.Unlock()
return f.messageCalls, f.messageSessionID, f.messageLimit
}
func (f *fakeChat) Reply(context.Context, protocol.ChatReplyRequest) error {
f.mu.Lock()
defer f.mu.Unlock()
@@ -271,6 +287,145 @@ func TestChatMessagesResumesRetainedState(t *testing.T) {
}
}
// seededChatMessages is the stored user + assistant + tool session the
// chat_messages evidence tests assert on, mirroring the OpenCode V2 shape of an
// assistant turn's completed tool part (input object, text content, status).
func seededChatMessages() []protocol.ChatMessage {
return []protocol.ChatMessage{
{ID: "msg_user", SessionID: "ses_1", Role: protocol.ChatRoleUser,
Parts: []protocol.ChatPart{{Type: protocol.ChatPartText, Text: "list the files"}}},
{ID: "msg_assistant", SessionID: "ses_1", Role: protocol.ChatRoleAssistant, Model: "deepseek-v4.1-flash", Agent: "build",
Parts: []protocol.ChatPart{
{Type: protocol.ChatPartText, ID: "p1", Text: "here you go"},
{Type: protocol.ChatPartReasoning, ID: "p2", Text: "thinking"},
{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`{"command":"ls"}`), Content: []protocol.ChatToolContent{{Type: "text", Text: "ok"}}},
Time: &protocol.ChatTime{Created: 1, Ran: 2, Completed: 3}},
}},
}
}
// assertSeededChatMessages fails unless the user + assistant + tool session came
// back with both roles and the completed tool part's input, content and status.
func assertSeededChatMessages(t *testing.T, messages []protocol.ChatMessage) {
t.Helper()
if len(messages) != 2 {
t.Fatalf("got %d messages, want user+assistant: %+v", len(messages), messages)
}
user, assistant := messages[0], messages[1]
if user.ID != "msg_user" || user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "list the files" {
t.Fatalf("user turn = %+v", user)
}
if assistant.ID != "msg_assistant" || assistant.Role != protocol.ChatRoleAssistant || len(assistant.Parts) != 3 {
t.Fatalf("assistant turn = %+v", assistant)
}
if p := assistant.Parts[0]; p.Type != protocol.ChatPartText || p.Text != "here you go" {
t.Fatalf("assistant text part = %+v", p)
}
tool := assistant.Parts[2]
if tool.Type != protocol.ChatPartTool || tool.ID != "call_1" || tool.Name != "shell" || tool.State == nil || tool.State.Status != protocol.ChatToolCompleted {
t.Fatalf("assistant tool part = %+v", tool)
}
var input struct {
Command string `json:"command"`
}
if err := json.Unmarshal(tool.State.Input, &input); err != nil || input.Command != "ls" {
t.Fatalf("tool input = %s (err %v)", tool.State.Input, err)
}
if len(tool.State.Content) != 1 || tool.State.Content[0].Text != "ok" {
t.Fatalf("tool content = %+v", tool.State.Content)
}
}
// TestChatMessagesReturnsBrokerHistory drives chat_messages through the handler
// with an empty hub, so it must fall through to broker.Messages and return the
// seeded user + assistant + tool session, forwarding the query limit unchanged.
func TestChatMessagesReturnsBrokerHistory(t *testing.T) {
broker := scriptedChat()
broker.messages = seededChatMessages()
ctx, _, conn := dialChat(t, broker)
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1", Limit: 7}}); err != nil {
t.Fatal(err)
}
var response protocol.Message
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.Type != protocol.ChatMessages || response.ID != "r2" {
t.Fatalf("response = %+v", response)
}
assertSeededChatMessages(t, response.ChatMessages)
if calls, sessionID, limit := broker.messageQuery(); calls != 1 || sessionID != "ses_1" || limit != 7 {
t.Fatalf("broker query = %d/%q/%d, want 1/ses_1/7", calls, sessionID, limit)
}
}
// TestChatMessagesThroughRealAdapter loads a seeded session through the real
// opencode.Chat broker: the chat_messages handler reads the V2
// GET /api/session/{id}/message fixture once and returns the user + assistant +
// tool turns decoded from it, exercising the full handler -> adapter -> decode
// path with no scripted broker.
func TestChatMessagesThroughRealAdapter(t *testing.T) {
var messageReads atomic.Int32
fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet || r.URL.Path != "/api/session/ses_1/message" {
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
return
}
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}}
]}
],"cursor":{"next":null}}`))
}))
defer fixture.Close()
broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL})
ctx, _, conn := dialChat(t, broker)
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
t.Fatal(err)
}
var response protocol.Message
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.Type != protocol.ChatMessages || response.ID != "r2" {
t.Fatalf("response = %+v", response)
}
assertSeededChatMessages(t, response.ChatMessages)
if messageReads.Load() != 1 {
t.Fatalf("message endpoint read %d times, want 1", messageReads.Load())
}
}
// TestChatMessagesRejectsInvalidSession pins that a missing or malformed session
// id is rejected before any broker call.
func TestChatMessagesRejectsInvalidSession(t *testing.T) {
broker := scriptedChat()
broker.messages = seededChatMessages()
ctx, _, conn := dialChat(t, broker)
for _, query := range []*protocol.ChatQuery{nil, {SessionID: ""}, {SessionID: "not-a-session"}} {
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "bad", ChatQuery: query}); err != nil {
t.Fatal(err)
}
var response protocol.Message
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.Type != protocol.Error || response.ID != "bad" {
t.Fatalf("query %+v not rejected: %+v", query, response)
}
}
if calls, _, _ := broker.messageQuery(); calls != 0 {
t.Fatalf("invalid chat_messages reached the broker: %d", calls)
}
}
func TestChatDisconnectCancelsStream(t *testing.T) {
broker := scriptedChat()
broker.block = true