Files
pipelines/internal/server/chat_test.go
T

1217 lines
47 KiB
Go

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
replyRequest protocol.ChatReplyRequest
replyErr error
messageCalls int
messageSessionID string
messageLimit int
messages []protocol.ChatMessage
permissionCalls int
permissionSessionID string
permissions []protocol.ChatPermissionFrame
permissionErr error
permBlock bool
permDone chan struct{}
permOnce sync.Once
script []protocol.ChatEventFrame
started chan struct{}
done chan struct{}
startOnce sync.Once
block bool
subscribed bool
promptBeforeSubscribe bool
interruptErr error
}
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 f.interruptErr
}
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, request protocol.ChatReplyRequest) error {
f.mu.Lock()
defer f.mu.Unlock()
f.replies++
f.replyRequest = request
return f.replyErr
}
// Permissions returns the seeded pending requests, or blocks until the caller's
// context is canceled when permBlock is set (used to prove the poller stops on
// disconnect). Every call is counted so a test can assert polling happened.
func (f *fakeChat) Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) {
f.mu.Lock()
f.permissionCalls++
f.permissionSessionID = sessionID
frames := append([]protocol.ChatPermissionFrame(nil), f.permissions...)
err := f.permissionErr
block := f.permBlock
done := f.permDone
f.mu.Unlock()
if block {
<-ctx.Done()
if done != nil {
f.permOnce.Do(func() { close(done) })
}
return nil, ctx.Err()
}
return frames, err
}
// permissionQuery reports the recorded permission poll count and session id.
func (f *fakeChat) permissionQuery() (int, string) {
f.mu.Lock()
defer f.mu.Unlock()
return f.permissionCalls, f.permissionSessionID
}
// replyQuery reports the recorded chat_reply count and the last forwarded
// request, so a test can assert the exact session/request/decision.
func (f *fakeChat) replyQuery() (int, protocol.ChatReplyRequest) {
f.mu.Lock()
defer f.mu.Unlock()
return f.replies, f.replyRequest
}
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])
}
}
// 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
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)
}
}
// TestChatInterruptEndsRunningPrompt is the task evidence: it starts a
// long-running turn through the real opencode.Chat adapter over an httptest SSE
// fixture, sends chat_interrupt, and asserts the run ends. The fixture records
// the actual POST /api/session/ses_1/interrupt and only closes the SSE
// subscription once that request arrives, so the run genuinely terminates rather
// than completing on its own.
func TestChatInterruptEndsRunningPrompt(t *testing.T) {
var (
mu sync.Mutex
prompts int
interrupts int
interruptPath string
)
interrupted := make(chan struct{})
var interruptOnce sync.Once
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":
mu.Lock()
prompts++
mu.Unlock()
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/permission/request":
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`))
case r.Method == http.MethodGet && r.URL.Path == "/api/event":
flusher, ok := w.(http.Flusher)
if !ok {
t.Errorf("event stream response is not flushable")
return
}
w.Header().Set("Content-Type", "text/event-stream")
_, _ = w.Write([]byte("data: " + `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"working"}}` + "\n\n"))
flusher.Flush()
// Hold the turn open until the interrupt arrives so the test exercises
// a running run, not a stream that already completed.
select {
case <-interrupted:
case <-r.Context().Done():
return
}
_, _ = w.Write([]byte("data: " + `{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}` + "\n\n"))
flusher.Flush()
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/interrupt":
mu.Lock()
interrupts++
interruptPath = r.URL.Path
mu.Unlock()
interruptOnce.Do(func() { close(interrupted) })
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{}`))
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)
// Start a long-running turn.
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "start a long-running task"}}); 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("prompt ack = %+v", ack)
}
// The first text delta proves the turn is live and the subscription attached.
var first protocol.Message
if err := wsjson.Read(ctx, conn, &first); err != nil {
t.Fatal(err)
}
if first.Type != protocol.ChatEvent || first.ChatEvent == nil || first.ChatEvent.Kind != protocol.ChatEventText || first.ChatEvent.Delta != "working" {
t.Fatalf("expected a live text delta, got %+v", first)
}
// Stop the running turn.
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
t.Fatal(err)
}
// Read until both the interrupt ack and the step.ended frame arrive, in
// whichever order the server emits them; any error frame fails the test.
var acked, ended bool
for !acked || !ended {
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.Type == protocol.ChatInterrupt {
if message.ID != "i1" {
t.Fatalf("interrupt ack id = %q, want i1", message.ID)
}
acked = true
}
if event := message.ChatEvent; event != nil && event.SessionID == "ses_1" && event.Kind == protocol.ChatEventStep && event.Step != nil && event.Step.Status == protocol.ChatStepEnded {
ended = true
}
}
mu.Lock()
gotPrompts, gotInterrupts, gotPath := prompts, interrupts, interruptPath
mu.Unlock()
if gotPrompts != 1 {
t.Fatalf("prompt posts = %d, want 1", gotPrompts)
}
if gotInterrupts != 1 {
t.Fatalf("interrupt posts = %d, want 1", gotInterrupts)
}
if gotPath != "/api/session/ses_1/interrupt" {
t.Fatalf("interrupt path = %q, want /api/session/ses_1/interrupt", gotPath)
}
}
// TestChatInterruptRejectsInvalidSession pins that a missing, empty or malformed
// session id is rejected with a protocol.Error before any broker call.
func TestChatInterruptRejectsInvalidSession(t *testing.T) {
broker := scriptedChat()
ctx, _, conn := dialChat(t, broker)
for _, query := range []*protocol.ChatQuery{nil, {}, {SessionID: "not-a-session"}} {
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, 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 _, interrupts, _ := broker.counts(); interrupts != 0 {
t.Fatalf("invalid interrupts reached the broker: %d", interrupts)
}
}
// TestChatInterruptWithoutBroker pins that an unconfigured server answers
// chat_interrupt with the existing "not configured" error.
func TestChatInterruptWithoutBroker(t *testing.T) {
ctx, _, conn := dialChat(t, nil)
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.Error || !strings.Contains(response.Error, "not configured") {
t.Fatalf("unconfigured interrupt not rejected: %+v", response)
}
}
// TestChatInterruptErrorReported pins that a broker failure is surfaced to the
// client as a protocol.Error frame carrying the echoed request id.
func TestChatInterruptErrorReported(t *testing.T) {
broker := scriptedChat()
broker.interruptErr = fmt.Errorf("run is already finished")
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.Error || response.ID != "i1" || !strings.Contains(response.Error, "already finished") {
t.Fatalf("interrupt failure not reported: %+v", response)
}
if _, interrupts, _ := broker.counts(); interrupts != 1 {
t.Fatalf("interrupts = %d, want 1", interrupts)
}
}
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/permission/request":
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`))
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)
}
}
}
// TestChatPromptPushesPermissionAndForwardsReply is the task evidence: with a
// blocking scripted stream keeping the subscription open, a seeded pending
// approval request is pushed as a chat_permission frame carrying the seeded
// session/request id after the prompt ack, and a chat_reply with Decision "once"
// is forwarded to the broker with the matching SessionID/RequestID/Decision.
//
// The live end-to-end approval flow against the real OpenCode service is NOT
// tested: this broker is the same interface seam the production handler uses, and
// the adapter's exact reply path/body are covered by the opencode package tests
// over an httptest fixture.
func TestChatPromptPushesPermissionAndForwardsReply(t *testing.T) {
broker := scriptedChat()
broker.block = true
broker.started = make(chan struct{})
broker.permissions = []protocol.ChatPermissionFrame{{
SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"},
}}
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: "run it"}}); 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("prompt ack = %+v", ack)
}
var permission protocol.Message
if err := wsjson.Read(ctx, conn, &permission); err != nil {
t.Fatal(err)
}
if permission.Type == protocol.Error {
t.Fatalf("unexpected error frame: %s", permission.Error)
}
if permission.Type != protocol.ChatPermission || permission.ChatPermission == nil {
t.Fatalf("expected a chat_permission frame, got %+v", permission)
}
if permission.ChatPermission.SessionID != "ses_1" || permission.ChatPermission.RequestID != "req_1" || permission.ChatPermission.Action != "bash" {
t.Fatalf("permission frame = %+v", permission.ChatPermission)
}
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)
}
var response protocol.Message
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)
}
count, forwarded := broker.replyQuery()
if count != 1 {
t.Fatalf("reply forwarded %d times, want 1", count)
}
if forwarded.SessionID != "ses_1" || forwarded.RequestID != "req_1" || forwarded.Decision != protocol.ChatDecisionOnce {
t.Fatalf("forwarded reply = %+v", forwarded)
}
}
// TestChatPermissionDedupesRepeatedPolls pins that the poller pushes each
// pending request at most once even though it re-reads the same list, and that a
// foreign session's request is never surfaced.
func TestChatPermissionDedupesRepeatedPolls(t *testing.T) {
broker := scriptedChat()
broker.permissions = []protocol.ChatPermissionFrame{
{SessionID: "ses_1", RequestID: "req_1", Action: "bash"},
{SessionID: "ses_other", RequestID: "req_x", Action: "edit"},
}
hub := newChatHub()
var mu sync.Mutex
var pushed []protocol.Message
write := func(message protocol.Message) error {
mu.Lock()
pushed = append(pushed, message)
mu.Unlock()
return nil
}
for i := 0; i < 3; i++ {
if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil {
t.Fatal(err)
}
}
mu.Lock()
defer mu.Unlock()
if len(pushed) != 1 {
t.Fatalf("pushed %d permission frames, want 1: %+v", len(pushed), pushed)
}
if pushed[0].Type != protocol.ChatPermission || pushed[0].ChatPermission == nil || pushed[0].ChatPermission.RequestID != "req_1" {
t.Fatalf("pushed frame = %+v", pushed[0])
}
if calls, sessionID := broker.permissionQuery(); calls != 3 || sessionID != "ses_1" {
t.Fatalf("permission polls = %d/%q, want 3/ses_1", calls, sessionID)
}
}
// TestChatDisconnectCancelsPermissionPoller pins that the permission poller is
// canceled on disconnect (reusing the stream's context), so it cannot leak a
// goroutine after the client goes away.
func TestChatDisconnectCancelsPermissionPoller(t *testing.T) {
broker := scriptedChat()
broker.block = true
broker.started = make(chan struct{})
broker.done = make(chan struct{})
broker.permBlock = true
broker.permDone = 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")
}
select {
case <-broker.permDone:
t.Fatal("permission poller returned before disconnect")
default:
}
conn.CloseNow()
select {
case <-broker.permDone:
case <-time.After(3 * time.Second):
t.Fatal("permission poller was not canceled on disconnect")
}
select {
case <-broker.done:
case <-time.After(3 * time.Second):
t.Fatal("chat stream was not canceled on disconnect")
}
}
// TestChatPermissionPollErrorSurfaced pins that a malformed permission list is
// reported to the client as an error frame rather than silence.
func TestChatPermissionPollErrorSurfaced(t *testing.T) {
broker := scriptedChat()
broker.block = true
broker.started = make(chan struct{})
broker.permissionErr = fmt.Errorf("invalid OpenCode permission response")
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)
}
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, "permission poll") {
t.Fatalf("malformed permission list not surfaced: %+v", response)
}
}
// TestChatReplyRejectsInvalidInput pins that a missing session id, an empty
// request id and an invalid decision are rejected with a protocol.Error before
// any broker call.
func TestChatReplyRejectsInvalidInput(t *testing.T) {
broker := scriptedChat()
ctx, _, conn := dialChat(t, broker)
cases := []*protocol.ChatReplyRequest{
nil,
{SessionID: "", RequestID: "req_1", Decision: protocol.ChatDecisionOnce},
{SessionID: "not-a-session", RequestID: "req_1", Decision: protocol.ChatDecisionOnce},
{SessionID: "ses_1", RequestID: "", Decision: protocol.ChatDecisionOnce},
{SessionID: "ses_1", RequestID: "req_1", Decision: ""},
{SessionID: "ses_1", RequestID: "req_1", Decision: "maybe"},
}
for _, reply := range cases {
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "bad", ChatReply: reply}); 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("reply %+v not rejected: %+v", reply, response)
}
}
if count, _ := broker.replyQuery(); count != 0 {
t.Fatalf("invalid replies reached the broker: %d", count)
}
}
// TestChatReplyWithoutBroker pins that an unconfigured server answers chat_reply
// with the existing "not configured" error.
func TestChatReplyWithoutBroker(t *testing.T) {
ctx, _, conn := dialChat(t, nil)
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)
}
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 reply not rejected: %+v", response)
}
}
// TestChatPermissionUnsupportedBackendIsQuiet pins that a backend which does not
// expose the approval surface (the documented native v1 limitation, reported as
// opencode.ErrPermissionUnsupported) stops the poller without writing a
// per-prompt error frame, so a working prompt is not misread as a failure.
func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) {
broker := scriptedChat()
broker.block = true
broker.started = make(chan struct{})
broker.permissionErr = opencode.ErrPermissionUnsupported
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("prompt ack = %+v", ack)
}
// No error frame may follow: a read with a short deadline must time out.
readCtx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
defer cancel()
var unexpected protocol.Message
if err := wsjson.Read(readCtx, conn, &unexpected); err == nil {
t.Fatalf("unsupported permission surface must not write a frame, got %+v", unexpected)
}
if calls, _ := broker.permissionQuery(); calls != 1 {
t.Fatalf("permission polls = %d, want 1 (the poller must stop on the documented limitation)", calls)
}
}
// TestChatPermissionWriteFailureDoesNotDropRequest pins that a request id is not
// retained as "seen" when its frame could not be written, so the next poll
// re-pushes it instead of silently dropping the approval request.
func TestChatPermissionWriteFailureDoesNotDropRequest(t *testing.T) {
broker := scriptedChat()
broker.permissions = []protocol.ChatPermissionFrame{{SessionID: "ses_1", RequestID: "req_1", Action: "bash"}}
hub := newChatHub()
attempts := 0
write := func(protocol.Message) error {
attempts++
if attempts == 1 {
return fmt.Errorf("connection closed")
}
return nil
}
if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err == nil {
t.Fatal("a failed write must surface an error")
}
if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil {
t.Fatalf("retry after a failed write: %v", err)
}
if attempts != 2 {
t.Fatalf("push attempts = %d, want the request re-pushed after the failure", attempts)
}
}