package server import ( "context" "encoding/json" "fmt" "net/http" "net/http/httptest" "strings" "sync" "sync/atomic" "testing" "time" "github.com/coder/websocket" "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/opencode" "git.a-wan.net/alan/pipelines/internal/protocol" ) // fakeChat is a scripted chatBroker. It counts calls and either emits a fixed // frame sequence or blocks until the caller's context is canceled. type fakeChat struct { mu sync.Mutex promptCalls int interrupts int replies int messages []protocol.ChatMessage script []protocol.ChatEventFrame started chan struct{} done chan struct{} startOnce sync.Once block bool subscribed bool promptBeforeSubscribe bool } func (f *fakeChat) Prompt(context.Context, string, string) error { f.mu.Lock() defer f.mu.Unlock() f.promptCalls++ if !f.subscribed { f.promptBeforeSubscribe = true } return nil } func (f *fakeChat) Stream(ctx context.Context, _ string, ready func(), emit func(protocol.ChatEventFrame) error) error { f.mu.Lock() f.subscribed = true f.mu.Unlock() if ready != nil { ready() } if f.started != nil { f.startOnce.Do(func() { close(f.started) }) } if f.block { <-ctx.Done() if f.done != nil { close(f.done) } return ctx.Err() } for _, frame := range f.script { if err := ctx.Err(); err != nil { return err } if err := emit(frame); err != nil { return err } } return nil } func (f *fakeChat) Interrupt(context.Context, string) error { f.mu.Lock() defer f.mu.Unlock() f.interrupts++ return nil } func (f *fakeChat) Messages(context.Context, string, int) ([]protocol.ChatMessage, error) { return f.messages, nil } func (f *fakeChat) Reply(context.Context, protocol.ChatReplyRequest) error { f.mu.Lock() defer f.mu.Unlock() f.replies++ return nil } func (f *fakeChat) counts() (int, int, int) { f.mu.Lock() defer f.mu.Unlock() return f.promptCalls, f.interrupts, f.replies } func chatFrame(kind, delta string, part *protocol.ChatPart, step *protocol.ChatStep) protocol.ChatEventFrame { return protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: kind, Delta: delta, Part: part, Step: step} } func scriptedChat() *fakeChat { return &fakeChat{script: []protocol.ChatEventFrame{ chatFrame(protocol.ChatEventText, "hello ", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil), chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil), chatFrame(protocol.ChatEventTool, "", &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: []byte(`{"command":"ls"}`)}}, nil), chatFrame(protocol.ChatEventStep, "", nil, &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}), }} } func dialChat(t *testing.T, broker chatBroker) (context.Context, context.CancelFunc, *websocket.Conn) { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) srv := httptest.NewServer(HandlerWithOptions(ctx, Options{Chat: broker})) t.Cleanup(func() { srv.Close(); cancel() }) conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) if err != nil { t.Fatal(err) } t.Cleanup(func() { conn.CloseNow() }) return ctx, cancel, conn } func readChatTurn(t *testing.T, ctx context.Context, conn *websocket.Conn) []protocol.ChatEventFrame { t.Helper() var frames []protocol.ChatEventFrame for { var message protocol.Message if err := wsjson.Read(ctx, conn, &message); err != nil { t.Fatal(err) } if message.Type == protocol.Error { t.Fatalf("unexpected error frame: %s", message.Error) } if message.ChatEvent == nil { continue } frames = append(frames, *message.ChatEvent) if message.ChatEvent.Kind == protocol.ChatEventStep && message.ChatEvent.Step != nil && message.ChatEvent.Step.Status == protocol.ChatStepEnded { return frames } } } func TestChatPromptStreamsEvents(t *testing.T) { broker := scriptedChat() 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) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("ack = %+v", ack) } frames := readChatTurn(t, ctx, conn) if len(frames) != 4 { t.Fatalf("got %d frames, want 4", len(frames)) } sawText, sawStep := false, false for _, frame := range frames { if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" { t.Fatalf("frame missing stable ids: %+v", frame) } switch frame.Kind { case protocol.ChatEventText: sawText = true case protocol.ChatEventStep: sawStep = true if frame.Step == nil || frame.Step.Status != protocol.ChatStepEnded { t.Fatalf("step frame = %+v", frame) } } } if !sawText || !sawStep { t.Fatalf("missing text or step frame: %+v", frames) } if prompts, _, _ := broker.counts(); prompts != 1 { t.Fatalf("prompt forwarded %d times, want 1", prompts) } } func TestChatPromptRejectsInvalidSession(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, id := range []string{"", "not-a-session", "msg_1"} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "bad", ChatPrompt: &protocol.ChatPromptRequest{SessionID: id, Text: "hi"}}); 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("session %q not rejected: %+v", id, response) } } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("invalid sessions reached OpenCode: %d", prompts) } } func TestChatPromptRejectsOversizedText(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) oversized := strings.Repeat("x", opencode.MaxRequest+1) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "big", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: oversized}}); 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 || !strings.Contains(response.Error, "64 KiB") { t.Fatalf("oversized prompt not rejected: %+v", response) } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("oversized prompt reached OpenCode: %d", prompts) } } func TestChatPromptWithoutBroker(t *testing.T) { ctx, _, conn := dialChat(t, nil) 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) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { t.Fatalf("unconfigured chat not rejected: %+v", response) } } func TestChatMessagesResumesRetainedState(t *testing.T) { broker := scriptedChat() 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) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) 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" || len(response.ChatMessages) != 1 { t.Fatalf("resume response = %+v", response) } message := response.ChatMessages[0] 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 != "msg_1#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]) } } func TestChatDisconnectCancelsStream(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.done = make(chan struct{}) 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) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } select { case <-broker.started: case <-time.After(2 * time.Second): t.Fatal("stream never started") } conn.CloseNow() // The server's read loop returns on disconnect, canceling the connection // context the subscription observes; no goroutine may keep running. select { case <-broker.done: case <-time.After(3 * time.Second): t.Fatal("chat stream was not canceled on disconnect") } if prompts, _, _ := broker.counts(); prompts != 1 { t.Fatalf("prompt forwarded %d times, want 1", prompts) } } func TestChatInterruptAndReply(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", 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.ChatInterrupt || response.ID != "i1" { t.Fatalf("interrupt response = %+v", response) } if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil { t.Fatal(err) } if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReply || response.ID != "p1" { t.Fatalf("reply response = %+v", response) } if _, interrupts, replies := broker.counts(); interrupts != 1 || replies != 1 { t.Fatalf("interrupts=%d replies=%d, want 1/1", interrupts, replies) } } func TestChatHubAccumulatesAndEvicts(t *testing.T) { tick := 0 hub := newChatHub() hub.now = func() time.Time { tick++; return time.Unix(int64(tick), 0) } for _, delta := range []string{"a", "b", "c"} { hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: delta, Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) } messages := hub.snapshot("ses_1") if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].Text != "abc" { t.Fatalf("snapshot = %+v", messages) } for i := 0; i < chatMaxTurns+5; i++ { id := fmt.Sprintf("ses_%d", i) hub.apply(protocol.ChatEventFrame{SessionID: id, MessageID: "m", Kind: protocol.ChatEventText, Delta: "x", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#0"}}) } if len(hub.turns) != chatMaxTurns { t.Fatalf("retained %d turns, want %d", len(hub.turns), chatMaxTurns) } } // TestChatHubKeepsMessagesSeparate pins per-message retention: a second prompt // in one session must not fold its parts onto the first turn's message id. func TestChatHubKeepsMessagesSeparate(t *testing.T) { hub := newChatHub() hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "one", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_2", Kind: protocol.ChatEventText, Delta: "two", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_2#0"}}) messages := hub.snapshot("ses_1") if len(messages) != 2 { t.Fatalf("messages = %+v", messages) } if messages[0].ID != "msg_1" || messages[0].Parts[0].ID != "msg_1#0" || messages[0].Parts[0].Text != "one" { t.Fatalf("first message = %+v", messages[0]) } if messages[1].ID != "msg_2" || messages[1].Parts[0].ID != "msg_2#0" || messages[1].Parts[0].Text != "two" { t.Fatalf("second message = %+v", messages[1]) } } // TestChatHubChargesToolStateBytes pins the retained-state cap: a tool part's // input/content bytes count against it, and an upsert that would exceed the cap // is dropped with the overflow diagnostic rather than growing memory. func TestChatHubChargesToolStateBytes(t *testing.T) { hub := newChatHub() big := strings.Repeat("x", chatRetainedLimit/2) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolStreaming, Input: json.RawMessage(`"` + big + `"`)}}}) hub.mu.Lock() size := hub.turns["ses_1"].size hub.mu.Unlock() if size < len(big) { t.Fatalf("tool input not charged: size=%d want >= %d", size, len(big)) } huge := strings.Repeat("y", chatRetainedLimit) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`"` + huge + `"`)}}}) messages := hub.snapshot("ses_1") if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].State == nil || messages[0].Parts[0].State.Status != protocol.ChatToolStreaming { t.Fatalf("overflowing tool state was retained: %+v", messages) } } // TestChatPromptSubscribesBeforePrompt pins the subscribe-before-prompt order: // the firehose has no replay cursor, so the subscription must be attached before // the prompt is posted or deltas emitted in between are lost. func TestChatPromptSubscribesBeforePrompt(t *testing.T) { broker := scriptedChat() 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) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) broker.mu.Lock() before := broker.promptBeforeSubscribe broker.mu.Unlock() if before { t.Fatal("prompt was posted before the event subscription was attached") } } // realAdapterChat posts a chat_prompt through the real opencode.Chat broker and // HandlerWithOptions against a v2 HTTP fixture that replays frames, so the // acceptance path forwards to an actual OpenCode-shaped stream (not a scripted // fake) and returns the chat_event frames the server pushed. It pins exactly one // prompt POST and one event subscription per chat_prompt, then asserts the ack // echoes the request id; callers assert the frames themselves. func realAdapterChat(t *testing.T, frames []string) []protocol.ChatEventFrame { t.Helper() var prompts, streams atomic.Int32 fixture := 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": streams.Add(1) 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 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.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "ping"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("ack = %+v", ack) } framesIn := readChatTurn(t, ctx, conn) if prompts.Load() != 1 || streams.Load() != 1 { t.Fatalf("prompts=%d streams=%d, want 1/1", prompts.Load(), streams.Load()) } return framesIn } // assertStableFrameIDs fails unless every frame carries the fixture's session // and message ids: a client cannot attribute a frame without them. func assertStableFrameIDs(t *testing.T, frames []protocol.ChatEventFrame) { t.Helper() for _, frame := range frames { if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" { t.Fatalf("frame missing stable ids: %+v", frame) } } } // TestChatPromptThroughRealAdapter drives a text, tool and step turn end to end. func TestChatPromptThroughRealAdapter(t *testing.T) { framesIn := realAdapterChat(t, []string{ `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`, `{"id":"evt_2","type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`, `{"id":"evt_3","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`, }) assertStableFrameIDs(t, framesIn) sawText, sawTool := false, false for _, frame := range framesIn { if frame.Kind == protocol.ChatEventText && frame.Delta == "pong" { sawText = true } if frame.Kind == protocol.ChatEventTool && frame.Part != nil && frame.Part.Name == "shell" { sawTool = true } } if !sawText || !sawTool { t.Fatalf("missing text or tool frame: %+v", framesIn) } } // TestChatPromptNoToolThroughRealAdapter is the task's evidence harness: it posts // a trivial no-tool prompt to the real opencode.Chat adapter over a v2 SSE // fixture that emits only a text delta and a step, and asserts both arrive as // chat_event frames with stable session/message ids. It reuses dialChat, // readChatTurn and realAdapterChat so it pins the same ack/stream contract as the // other chat tests, and it pins exactly one prompt POST and one event subscription. func TestChatPromptNoToolThroughRealAdapter(t *testing.T) { framesIn := realAdapterChat(t, []string{ `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`, `{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`, }) assertStableFrameIDs(t, framesIn) sawText, sawStep, sawTool := false, false, false for _, frame := range framesIn { switch frame.Kind { case protocol.ChatEventText: sawText = frame.Delta == "pong" case protocol.ChatEventStep: sawStep = frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded case protocol.ChatEventTool: sawTool = true } } if !sawText || !sawStep { t.Fatalf("missing text or step frame: %+v", framesIn) } if sawTool { t.Fatalf("a trivial no-tool prompt produced a tool frame: %+v", framesIn) } } // TestChatPromptRejectsEmptyText pins the whitespace guard: an empty or // whitespace-only prompt is rejected before any OpenCode call. func TestChatPromptRejectsEmptyText(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, text := range []string{"", " ", "\t\n"} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "empty", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: text}}); 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 != "empty" { t.Fatalf("empty text %q not rejected: %+v", text, response) } } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("empty prompts reached OpenCode: %d", prompts) } } // TestChatSessionsAndCreateAnswerExplicitly pins the declared-but-unbrokered // boundary: chat_sessions and chat_create are answered with a protocol error // rather than falling through to the generic Pong. func TestChatSessionsAndCreateAnswerExplicitly(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, typ := range []string{protocol.ChatSessions, protocol.ChatCreate} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: typ, ID: "c1"}); 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 != "c1" { t.Fatalf("%s did not answer with an explicit error: %+v", typ, response) } } }