825 lines
36 KiB
Go
825 lines
36 KiB
Go
package opencode
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
func TestNormalizeChatEvent(t *testing.T) {
|
|
prior := &ChatStreamState{LastMessageID: "msg_prev"}
|
|
cases := []struct {
|
|
name string
|
|
payload string
|
|
state *ChatStreamState
|
|
wantOK bool
|
|
wantKind string
|
|
wantMsg string
|
|
wantDelta string
|
|
wantStatus string
|
|
wantStep string
|
|
wantUsage *protocol.ChatUsage
|
|
}{
|
|
{name: "text delta", payload: `{"type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"hel"}}`, wantOK: true, wantKind: protocol.ChatEventText, wantMsg: "msg_1", wantDelta: "hel"},
|
|
{name: "reasoning delta", payload: `{"type":"session.reasoning.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":1,"delta":"hmm"}}`, wantOK: true, wantKind: protocol.ChatEventReasoning, wantMsg: "msg_1", wantDelta: "hmm"},
|
|
{name: "step ended", payload: `{"type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":2}}`, wantOK: true, wantKind: protocol.ChatEventStep, wantStep: protocol.ChatStepEnded},
|
|
{name: "tool streaming", payload: `{"type":"session.tool.input.started","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":"{\"command\""}}`, wantOK: true, wantKind: protocol.ChatEventTool, wantStatus: protocol.ChatToolStreaming},
|
|
{name: "tool running", payload: `{"type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`, wantOK: true, wantKind: protocol.ChatEventTool, wantStatus: protocol.ChatToolRunning},
|
|
{name: "tool completed", payload: `{"type":"session.tool.success","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","content":[{"type":"text","text":"ok"}]}}`, wantOK: true, wantKind: protocol.ChatEventTool, wantStatus: protocol.ChatToolCompleted},
|
|
{name: "tool failed", payload: `{"type":"session.tool.failed","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","error":{"type":"tool","message":"boom"}}}`, wantOK: true, wantKind: protocol.ChatEventTool, wantStatus: protocol.ChatToolError},
|
|
{name: "usage", payload: `{"type":"session.usage.updated","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","tokens":{"input":12,"output":34},"cost":0.001}}`, wantOK: true, wantKind: protocol.ChatEventUsage, wantUsage: &protocol.ChatUsage{InputTokens: 12, OutputTokens: 34, Cost: 0.001}},
|
|
{name: "message id fallback", payload: `{"type":"session.step.started","data":{"sessionID":"ses_1","index":1}}`, state: prior, wantOK: true, wantKind: protocol.ChatEventStep, wantMsg: "msg_prev", wantStep: protocol.ChatStepStarted},
|
|
{name: "foreign session skipped", payload: `{"type":"session.text.delta","data":{"sessionID":"ses_other","delta":"x"}}`, wantOK: false},
|
|
{name: "unknown type skipped", payload: `{"type":"session.created","data":{"sessionID":"ses_1"}}`, wantOK: false},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
frame, ok, err := NormalizeChatEvent([]byte(tc.payload), "ses_1", tc.state)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if ok != tc.wantOK {
|
|
t.Fatalf("ok = %v, want %v", ok, tc.wantOK)
|
|
}
|
|
if !ok {
|
|
return
|
|
}
|
|
if frame.SessionID != "ses_1" || frame.Kind != tc.wantKind {
|
|
t.Fatalf("frame = %+v", frame)
|
|
}
|
|
if tc.wantMsg != "" && frame.MessageID != tc.wantMsg {
|
|
t.Fatalf("messageID = %q, want %q", frame.MessageID, tc.wantMsg)
|
|
}
|
|
if tc.wantDelta != "" && frame.Delta != tc.wantDelta {
|
|
t.Fatalf("delta = %q, want %q", frame.Delta, tc.wantDelta)
|
|
}
|
|
if tc.wantStatus != "" && (frame.Part == nil || frame.Part.State == nil || frame.Part.State.Status != tc.wantStatus) {
|
|
t.Fatalf("tool state = %+v, want status %q", frame.Part, tc.wantStatus)
|
|
}
|
|
if tc.wantStep != "" && (frame.Step == nil || frame.Step.Status != tc.wantStep) {
|
|
t.Fatalf("step = %+v, want %q", frame.Step, tc.wantStep)
|
|
}
|
|
if tc.wantUsage != nil && (frame.Usage == nil || *frame.Usage != *tc.wantUsage) {
|
|
t.Fatalf("usage = %+v, want %+v", frame.Usage, tc.wantUsage)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalizeChatEventRejectsMalformedJSON(t *testing.T) {
|
|
if _, _, err := NormalizeChatEvent([]byte(`{"type":`), "ses_1", nil); err == nil {
|
|
t.Fatal("malformed event must return an error, not a frame")
|
|
}
|
|
}
|
|
|
|
func TestChatStreamFiltersFrames(t *testing.T) {
|
|
var prompts atomic.Int32
|
|
frames := []string{
|
|
`{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"hello "}}`,
|
|
`{"id":"evt_2","type":"session.text.delta","data":{"sessionID":"ses_other","assistantMessageID":"msg_x","ordinal":0,"delta":"ignore"}}`,
|
|
`{"id":"evt_3","type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`,
|
|
`{"id":"evt_4","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`,
|
|
}
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/prompt":
|
|
prompts.Add(1)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/event":
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
for _, frame := range frames {
|
|
_, _ = w.Write([]byte("data: " + frame + "\n\n"))
|
|
}
|
|
default:
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
var got []protocol.ChatEventFrame
|
|
err := chat.Stream(ctx, "ses_1", nil, func(frame protocol.ChatEventFrame) error {
|
|
got = append(got, frame)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("stream: %v", err)
|
|
}
|
|
if len(got) != 3 {
|
|
t.Fatalf("got %d frames, want 3 (foreign session filtered): %+v", len(got), got)
|
|
}
|
|
if got[0].Kind != protocol.ChatEventText || got[0].Delta != "hello " || got[0].MessageID != "msg_1" || got[0].Part == nil || got[0].Part.ID == "" {
|
|
t.Fatalf("text frame = %+v", got[0])
|
|
}
|
|
if got[1].Kind != protocol.ChatEventTool || got[1].Part == nil || got[1].Part.State == nil || got[1].Part.State.Status != protocol.ChatToolRunning {
|
|
t.Fatalf("tool frame = %+v", got[1])
|
|
}
|
|
if got[2].Kind != protocol.ChatEventStep || got[2].Step == nil || got[2].Step.Status != protocol.ChatStepEnded {
|
|
t.Fatalf("step frame = %+v", got[2])
|
|
}
|
|
for _, frame := range got {
|
|
if frame.SessionID != "ses_1" || frame.MessageID == "" {
|
|
t.Fatalf("frame missing stable ids: %+v", frame)
|
|
}
|
|
}
|
|
|
|
if err := chat.Prompt(ctx, "ses_1", "hello"); err != nil {
|
|
t.Fatalf("prompt: %v", err)
|
|
}
|
|
if prompts.Load() != 1 {
|
|
t.Fatalf("prompt posts = %d, want 1", prompts.Load())
|
|
}
|
|
}
|
|
|
|
func TestChatRejectsInvalidSessionWithoutCalling(t *testing.T) {
|
|
var calls atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
calls.Add(1)
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx := context.Background()
|
|
if err := chat.Prompt(ctx, "not-a-session", "hi"); err == nil {
|
|
t.Fatal("invalid session id must be rejected")
|
|
}
|
|
if err := chat.Stream(ctx, "", nil, func(protocol.ChatEventFrame) error { return nil }); err == nil {
|
|
t.Fatal("empty session id must be rejected")
|
|
}
|
|
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")
|
|
}
|
|
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "not-a-session", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); err == nil {
|
|
t.Fatal("invalid reply session id must be rejected")
|
|
}
|
|
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "", Decision: protocol.ChatDecisionOnce}); err == nil {
|
|
t.Fatal("empty reply request id must be rejected")
|
|
}
|
|
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: "maybe"}); err == nil {
|
|
t.Fatal("invalid reply decision must be rejected")
|
|
}
|
|
if calls.Load() != 0 {
|
|
t.Fatalf("invalid requests reached the service: %d", calls.Load())
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionsListsAndFilters loads a pending-request fixture in the
|
|
// verified V2 envelope (GET /api/permission/request) and asserts the adapter
|
|
// returns the requested session's request with its fields intact, filters out a
|
|
// foreign session's request, and reads the endpoint once.
|
|
func TestChatPermissionsListsAndFilters(t *testing.T) {
|
|
var reads atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet || r.URL.Path != "/api/permission/request" {
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
return
|
|
}
|
|
reads.Add(1)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[
|
|
{"id":"per_1","sessionID":"ses_1","action":"bash","resources":["rm -rf /tmp"],"save":["bash:rm -rf /tmp"],"metadata":{"command":"rm -rf /tmp"},"source":{"type":"tool","messageID":"msg_1","id":"call_1"},"message":"wants to run a command"},
|
|
{"id":"per_2","sessionID":"ses_other","action":"edit","resources":["/etc/hosts"]}
|
|
]}`))
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
frames, err := chat.Permissions(ctx, "ses_1")
|
|
if err != nil {
|
|
t.Fatalf("permissions: %v", err)
|
|
}
|
|
if reads.Load() != 1 {
|
|
t.Fatalf("permission endpoint read %d times, want 1", reads.Load())
|
|
}
|
|
if len(frames) != 1 {
|
|
t.Fatalf("frames = %+v, want the foreign request filtered", frames)
|
|
}
|
|
got := frames[0]
|
|
if got.SessionID != "ses_1" || got.RequestID != "per_1" || got.Action != "bash" {
|
|
t.Fatalf("frame = %+v", got)
|
|
}
|
|
if len(got.Resources) != 1 || got.Resources[0] != "rm -rf /tmp" || len(got.Save) != 1 || got.Message != "wants to run a command" {
|
|
t.Fatalf("frame detail = %+v", got)
|
|
}
|
|
if got.Metadata["command"] != "rm -rf /tmp" {
|
|
t.Fatalf("frame metadata = %+v", got.Metadata)
|
|
}
|
|
if got.Source == nil || got.Source.Type != "tool" || got.Source.MessageID != "msg_1" || got.Source.ID != "call_1" {
|
|
t.Fatalf("frame source = %+v", got.Source)
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionsRejectsMalformedList pins that a response without the data
|
|
// array is an error, not an empty success.
|
|
func TestChatPermissionsRejectsMalformedList(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"location":{"directory":"/work"}}`))
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
if _, err := chat.Permissions(context.Background(), "ses_1"); err == nil {
|
|
t.Fatal("a malformed permission response must be an error, not empty success")
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionReplyPostsReplyEndpoint pins the outbound approval reply: the
|
|
// adapter must POST exactly once to
|
|
// /api/session/{id}/permission/{requestID}/reply with the exact decision body,
|
|
// accept the documented 204 No Content success, and surface a non-2xx failure.
|
|
func TestChatPermissionReplyPostsReplyEndpoint(t *testing.T) {
|
|
for _, decision := range []string{protocol.ChatDecisionOnce, protocol.ChatDecisionAlways, protocol.ChatDecisionReject} {
|
|
t.Run(decision, func(t *testing.T) {
|
|
type request struct{ method, path, body string }
|
|
var mu sync.Mutex
|
|
var requests []request
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
data, _ := io.ReadAll(r.Body)
|
|
mu.Lock()
|
|
requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)})
|
|
mu.Unlock()
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: decision}); err != nil {
|
|
t.Fatalf("reply: %v", err)
|
|
}
|
|
mu.Lock()
|
|
got := append([]request(nil), requests...)
|
|
mu.Unlock()
|
|
if len(got) != 1 {
|
|
t.Fatalf("reply requests = %d, want 1: %+v", len(got), got)
|
|
}
|
|
if got[0].method != http.MethodPost || got[0].path != "/api/session/ses_1/permission/req_1/reply" {
|
|
t.Fatalf("reply request = %+v", got[0])
|
|
}
|
|
if got[0].body != `{"decision":"`+decision+`"}` {
|
|
t.Fatalf("reply body = %q, want decision %q", got[0].body, decision)
|
|
}
|
|
})
|
|
}
|
|
|
|
t.Run("failure", func(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
if err := chat.Reply(context.Background(), protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); err == nil {
|
|
t.Fatal("a failing reply endpoint must return an error")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestChatPermissionV1TranslationGated pins the declared backend limitation: the
|
|
// permission list and reply are implemented against the V2 HTTP API, and the
|
|
// native serve translation rejects them explicitly (an actionable error, no
|
|
// guessed endpoint, no HTTP call) so the caller can see the limitation.
|
|
func TestChatPermissionV1TranslationGated(t *testing.T) {
|
|
var calls atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
calls.Add(1)
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v1", URL: srv.URL, Directory: "/repo", models: map[string]map[string]string{}, responses: map[string][]byte{}})
|
|
ctx := context.Background()
|
|
if _, err := chat.Permissions(ctx, "ses_1"); !errors.Is(err, ErrPermissionUnsupported) {
|
|
t.Fatalf("v1 permission list must return the gate sentinel, got %v", err)
|
|
}
|
|
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); !errors.Is(err, ErrPermissionUnsupported) {
|
|
t.Fatalf("v1 permission reply must return the gate sentinel, got %v", err)
|
|
}
|
|
if calls.Load() != 0 {
|
|
t.Fatalf("gated permission requests reached the service: %d", calls.Load())
|
|
}
|
|
}
|
|
|
|
// TestChatInterruptPostsInterruptEndpoint pins the outbound interrupt call: the
|
|
// adapter must POST an empty JSON body to /api/session/{id}/interrupt exactly
|
|
// once and return nil, and it must surface a non-nil error when the endpoint
|
|
// fails. One interrupter request, no probing beyond what the call needs.
|
|
func TestChatInterruptPostsInterruptEndpoint(t *testing.T) {
|
|
t.Run("success", func(t *testing.T) {
|
|
type request struct{ method, path, body string }
|
|
var mu sync.Mutex
|
|
var requests []request
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
data, _ := io.ReadAll(r.Body)
|
|
mu.Lock()
|
|
requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)})
|
|
mu.Unlock()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := chat.Interrupt(ctx, "ses_1"); err != nil {
|
|
t.Fatalf("interrupt: %v", err)
|
|
}
|
|
mu.Lock()
|
|
got := append([]request(nil), requests...)
|
|
mu.Unlock()
|
|
if len(got) != 1 {
|
|
t.Fatalf("interrupt requests = %d, want 1: %+v", len(got), got)
|
|
}
|
|
if got[0].method != http.MethodPost || got[0].path != "/api/session/ses_1/interrupt" {
|
|
t.Fatalf("interrupt request = %+v", got[0])
|
|
}
|
|
if got[0].body != "{}" {
|
|
t.Fatalf("interrupt body = %q, want {}", got[0].body)
|
|
}
|
|
})
|
|
|
|
t.Run("failure", func(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := chat.Interrupt(ctx, "ses_1"); err == nil {
|
|
t.Fatal("a failing interrupt endpoint must return an error")
|
|
}
|
|
})
|
|
}
|
|
|
|
// 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) {
|
|
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) != 2 {
|
|
t.Fatalf("got %d messages, want the system turn skipped: %+v", len(messages), messages)
|
|
}
|
|
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")
|
|
}
|
|
}
|
|
|
|
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
|
|
// directory/time onto protocol.ChatSession, orders newest-updated first, and does
|
|
// not scope the list to the connection's own directory (so operator sessions in
|
|
// other directories are returned for the caller to filter).
|
|
func TestChatSessionsListsAndLiftsShape(t *testing.T) {
|
|
var reads atomic.Int32
|
|
var scoped bool
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet || r.URL.Path != "/api/session" {
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
return
|
|
}
|
|
reads.Add(1)
|
|
if r.URL.Query().Get("directory") != "" {
|
|
scoped = true
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[
|
|
{"id":"ses_old","title":"older","agent":"build","model":{"id":"m1"},"parentID":"ses_new","location":{"directory":"/proj"},"time":{"created":10,"updated":20}},
|
|
{"id":"ses_new","title":"newer","agent":"general","model":{"id":"m2"},"location":{"directory":"/proj"},"time":{"created":30,"updated":50}}
|
|
],"cursor":{"next":null}}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL, Directory: "/repo"})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
sessions, err := chat.Sessions(ctx)
|
|
if err != nil {
|
|
t.Fatalf("sessions: %v", err)
|
|
}
|
|
if reads.Load() != 1 {
|
|
t.Fatalf("session endpoint read %d times, want 1", reads.Load())
|
|
}
|
|
if scoped {
|
|
t.Fatal("session list was scoped to the connection directory; it must list every directory")
|
|
}
|
|
if len(sessions) != 2 {
|
|
t.Fatalf("sessions = %+v, want 2", sessions)
|
|
}
|
|
newer, older := sessions[0], sessions[1]
|
|
if newer.ID != "ses_new" || older.ID != "ses_old" {
|
|
t.Fatalf("not ordered newest-updated first: %+v", sessions)
|
|
}
|
|
if newer.Title != "newer" || newer.Agent != "general" || newer.Model != "m2" || newer.Directory != "/proj" || newer.CreatedAt != 30 || newer.UpdatedAt != 50 {
|
|
t.Fatalf("lifted fields wrong: %+v", newer)
|
|
}
|
|
if older.ParentID != "ses_new" || older.UpdatedAt != 20 || older.Title != "older" || older.Model != "m1" {
|
|
t.Fatalf("older session fields wrong: %+v", older)
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsTolerantEnvelopes pins the decoder's edge cases: a bare array
|
|
// (the native serve readback) is accepted, records without a valid session id
|
|
// are dropped, and an unparseable body or a data:null envelope is an error, not
|
|
// a silent empty success.
|
|
func TestChatSessionsTolerantEnvelopes(t *testing.T) {
|
|
sessions, err := decodeChatSessions([]byte(`[
|
|
{"id":"ses_1","title":"kept","time":{"updated":5}},
|
|
{"id":"","title":"dropped empty"},
|
|
{"id":"msg_not_a_session","title":"dropped invalid"}
|
|
]`))
|
|
if err != nil {
|
|
t.Fatalf("bare array decode: %v", err)
|
|
}
|
|
if len(sessions) != 1 || sessions[0].ID != "ses_1" || sessions[0].Title != "kept" {
|
|
t.Fatalf("bare array mapping wrong: %+v", sessions)
|
|
}
|
|
if sessions, err := decodeChatSessions([]byte(`{"data":[]}`)); err != nil || len(sessions) != 0 {
|
|
t.Fatalf("empty data array must decode to no sessions: %+v %v", sessions, err)
|
|
}
|
|
for _, raw := range []string{`{"data":null}`, `not json`, `{"location":{"directory":"/work"}}`} {
|
|
if _, err := decodeChatSessions([]byte(raw)); err == nil {
|
|
t.Fatalf("body %q must be an error, not empty success", raw)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsV1Translation pins the native serve path: GET /api/session is
|
|
// translated to the native GET /session (a bare array), so chat_sessions works
|
|
// on the backend that currently enables brokered chat. The native list shape is
|
|
// not covered by the research; this asserts the translated endpoint and the
|
|
// shared tolerant decode, not an unverified service shape.
|
|
func TestChatSessionsV1Translation(t *testing.T) {
|
|
var sawList bool
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet || r.URL.Path != "/session" {
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
return
|
|
}
|
|
sawList = true
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`[{"id":"ses_1","title":"native","time":{"created":1,"updated":2}}]`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
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()
|
|
sessions, err := chat.Sessions(ctx)
|
|
if err != nil {
|
|
t.Fatalf("sessions: %v", err)
|
|
}
|
|
if !sawList {
|
|
t.Fatal("GET /api/session was not translated to the native GET /session")
|
|
}
|
|
if len(sessions) != 1 || sessions[0].ID != "ses_1" || sessions[0].Title != "native" || sessions[0].UpdatedAt != 2 {
|
|
t.Fatalf("native session list mapped wrong: %+v", sessions)
|
|
}
|
|
}
|
|
|
|
func TestChatStreamRejectsMalformedEvent(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = w.Write([]byte("data: {\"type\":\"session.text.delta\",\"data\":{\"sessionID\":\"ses_1\"\n\n"))
|
|
}))
|
|
defer srv.Close()
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
emitted := 0
|
|
err := chat.Stream(context.Background(), "ses_1", nil, func(protocol.ChatEventFrame) error {
|
|
emitted++
|
|
return nil
|
|
})
|
|
if err == nil {
|
|
t.Fatal("malformed event JSON must fail the stream")
|
|
}
|
|
if emitted != 0 {
|
|
t.Fatalf("malformed event produced %d frames", emitted)
|
|
}
|
|
}
|
|
|
|
func TestChatStreamRequiresEndpoint(t *testing.T) {
|
|
chat := NewChat(&Connection{Backend: "v2"})
|
|
err := chat.Stream(context.Background(), "ses_1", nil, func(protocol.ChatEventFrame) error { return nil })
|
|
if err == nil || !strings.Contains(err.Error(), "event-stream endpoint") {
|
|
t.Fatalf("expected endpoint error, got %v", err)
|
|
}
|
|
}
|
|
|
|
// TestChatCreatePostsSessionEndpoint pins the outbound create call: the adapter
|
|
// must POST exactly once to /api/session with the verified V2 body
|
|
// {"title":...,"location":{"directory":...}} (no invented mechanism, no model or
|
|
// permission override), read exactly that one path, and lift the nested
|
|
// location.directory from the {"data":{...}} response.
|
|
func TestChatCreatePostsSessionEndpoint(t *testing.T) {
|
|
type request struct{ method, path, body string }
|
|
var mu sync.Mutex
|
|
var requests []request
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
data, _ := io.ReadAll(r.Body)
|
|
mu.Lock()
|
|
requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)})
|
|
mu.Unlock()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"data":{"id":"ses_new","title":"demo","location":{"directory":"/work/proj"},"time":{"created":11,"updated":22}}}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
session, err := chat.Create(ctx, "demo", "/work/proj")
|
|
if err != nil {
|
|
t.Fatalf("create: %v", err)
|
|
}
|
|
mu.Lock()
|
|
got := append([]request(nil), requests...)
|
|
mu.Unlock()
|
|
if len(got) != 1 {
|
|
t.Fatalf("create requests = %d, want 1: %+v", len(got), got)
|
|
}
|
|
if got[0].method != http.MethodPost || got[0].path != "/api/session" {
|
|
t.Fatalf("create request = %+v", got[0])
|
|
}
|
|
if got[0].body != `{"title":"demo","location":{"directory":"/work/proj"}}` {
|
|
t.Fatalf("create body = %q", got[0].body)
|
|
}
|
|
if session.ID != "ses_new" || session.Title != "demo" || session.Directory != "/work/proj" || session.CreatedAt != 11 || session.UpdatedAt != 22 {
|
|
t.Fatalf("created session = %+v", session)
|
|
}
|
|
}
|
|
|
|
// TestChatCreateRejectsMalformedSession pins that a response without a valid
|
|
// session id is an error, not a silent empty success.
|
|
func TestChatCreateRejectsMalformedSession(t *testing.T) {
|
|
for _, raw := range []string{`{"data":{}}`, `{"data":{"id":""}}`, `{"data":{"id":"msg_not_a_session"}}`, `not json`} {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(raw))
|
|
}))
|
|
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
|
|
if _, err := chat.Create(context.Background(), "demo", "/work"); err == nil {
|
|
t.Fatalf("response %q must be an error, not empty success", raw)
|
|
}
|
|
srv.Close()
|
|
}
|
|
}
|
|
|
|
func TestNormalizeChatEventWithoutMessageID(t *testing.T) {
|
|
for _, payload := range []string{
|
|
`{"type":"session.text.delta","data":{"sessionID":"ses_1","ordinal":0,"delta":"x"}}`,
|
|
`{"type":"session.tool.called","data":{"sessionID":"ses_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`,
|
|
`{"type":"session.usage.updated","data":{"sessionID":"ses_1","tokens":{"input":1,"output":2}}}`,
|
|
} {
|
|
if _, ok, err := NormalizeChatEvent([]byte(payload), "ses_1", nil); err != nil || ok {
|
|
t.Fatalf("event without a message id produced a frame: ok=%v err=%v", ok, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatV1ConnectionDrivesThroughCall drives the adapter through a real
|
|
// (serve-shaped) Connection so the /api -> native translation and the owned
|
|
// endpoint are exercised, not a direct v2 URL shortcut.
|
|
func TestChatV1ConnectionDrivesThroughCall(t *testing.T) {
|
|
var sawPrompt, sawMessages bool
|
|
var promptBody string
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodPost && r.URL.Path == "/session/ses_1/message":
|
|
// Call must have translated /api/session/{id}/prompt to this path.
|
|
sawPrompt = true
|
|
body, _ := io.ReadAll(r.Body)
|
|
promptBody = string(body)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"ok":true}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/session/ses_1/message":
|
|
sawMessages = true
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`[{"info":{"id":"msg_1","role":"assistant","modelID":"m","agent":"build","created":10},"parts":[{"type":"text","id":"p1","text":"hi"}]}]`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/event":
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = w.Write([]byte("data: {\"type\":\"session.text.delta\",\"data\":{\"sessionID\":\"ses_1\",\"assistantMessageID\":\"msg_1\",\"ordinal\":0,\"delta\":\"hi\"}}\n\n"))
|
|
default:
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
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.PromptWithMessageID(ctx, "ses_1", "hello", "msg_canonical"); err != nil {
|
|
t.Fatalf("prompt: %v", err)
|
|
}
|
|
if !sawPrompt {
|
|
t.Fatal("prompt was not translated to the native path")
|
|
}
|
|
// The translated body must carry the prompt text: the chat adapter sends the
|
|
// 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"`
|
|
} `json:"parts"`
|
|
}
|
|
if err := json.Unmarshal([]byte(promptBody), &sent); err != nil {
|
|
t.Fatalf("prompt body: %v (%s)", err, promptBody)
|
|
}
|
|
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
|
|
if err := chat.Stream(ctx, "ses_1", nil, func(frame protocol.ChatEventFrame) error {
|
|
got = append(got, frame)
|
|
return nil
|
|
}); err != nil {
|
|
t.Fatalf("stream: %v", err)
|
|
}
|
|
if len(got) != 1 || got[0].Kind != protocol.ChatEventText || got[0].MessageID != "msg_1" {
|
|
t.Fatalf("stream frames = %+v", got)
|
|
}
|
|
page, err := chat.Messages(ctx, "ses_1", 0, "")
|
|
if err != nil {
|
|
t.Fatalf("messages: %v", err)
|
|
}
|
|
if !sawMessages || len(page.Messages) != 1 || page.Messages[0].ID != "msg_1" {
|
|
t.Fatalf("messages = %+v", page.Messages)
|
|
}
|
|
}
|