package opencode import ( "context" "encoding/json" "fmt" "net/http" "net/http/httptest" "path/filepath" "strings" "testing" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // TestConnectionServerUser pins the owned serve basic-auth user per backend: the // native serve authenticates "pipelines", the V2 API server authenticates // "opencode" (verified against the installed 2.0.20 binary, which ignores // OPENCODE_SERVER_USERNAME). A wrong user is an unauthenticated endpoint, so it // is asserted rather than assumed. func TestConnectionServerUser(t *testing.T) { if got := (&Connection{Backend: "v1"}).serverUser(); got != "pipelines" { t.Fatalf("v1 server user = %q, want pipelines", got) } if got := (&Connection{Backend: "v2"}).serverUser(); got != "opencode" { t.Fatalf("v2 server user = %q, want opencode", got) } } // TestChatV2PromptShapeAndAuth pins the outbound V2 prompt: a single "text" // field (the installed service's PromptInput schema requires "text" and rejects // a bare "parts" array) sent with the "opencode" basic-auth user. The same body // also drives the v1 translation, so no second request format exists. func TestChatV2PromptShapeAndAuth(t *testing.T) { type request struct { method, path, user, pass, body string } var got request srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { data := make([]byte, r.ContentLength) _, _ = r.Body.Read(data) user, pass, _ := r.BasicAuth() got = request{method: r.Method, path: r.URL.Path, user: user, pass: pass, body: string(data)} w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`)) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL, password: "deadbeef"}) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := chat.Prompt(ctx, "ses_1", "hello"); err != nil { t.Fatalf("prompt: %v", err) } if got.method != http.MethodPost || got.path != "/api/session/ses_1/prompt" { t.Fatalf("prompt request = %+v", got) } if got.body != `{"text":"hello"}` { t.Fatalf("prompt body = %q, want the V2 text shape", got.body) } if got.user != "opencode" || got.pass != "deadbeef" { t.Fatalf("prompt auth = %q/%q, want opencode/deadbeef", got.user, got.pass) } } func TestChatV2PromptWithMessageID(t *testing.T) { var body map[string]string srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if err := json.NewDecoder(r.Body).Decode(&body); err != nil { t.Fatal(err) } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":{"id":"msg_canonical","sessionID":"ses_1","type":"user"}}`)) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) if err := chat.PromptWithMessageID(context.Background(), "ses_1", "same text", "msg_canonical"); err != nil { t.Fatal(err) } if body["id"] != "msg_canonical" || body["text"] != "same text" { t.Fatalf("prompt body = %+v", body) } } func TestChatSetInstructionShape(t *testing.T) { var path string var body map[string]any srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { path = r.URL.Path if r.Method != http.MethodPut { t.Errorf("method = %s", r.Method) } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { t.Fatal(err) } w.WriteHeader(http.StatusNoContent) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) if err := chat.SetInstruction(context.Background(), "ses_1", "pipelines.behavior", "be careful"); err != nil { t.Fatal(err) } if path != "/api/experimental/session/ses_1/instructions/entries/pipelines.behavior" { t.Fatalf("path = %q", path) } if body["value"] != "be careful" { t.Fatalf("body = %+v", body) } } func TestChatModelsListsEnabledModels(t *testing.T) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet || r.URL.Path != "/api/model" { t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) return } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":[ {"modelID":"b-model","providerID":"prov-b","name":"B Model","enabled":true,"status":"active"}, {"modelID":"a-model","providerID":"prov-a","name":"A Model","enabled":true,"status":"active"}, {"modelID":"off","providerID":"prov-a","name":"Off","enabled":false,"status":"active"}, {"modelID":"old","providerID":"prov-a","name":"Old","enabled":true,"status":"deprecated"} ]}`)) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) models, err := chat.Models(context.Background(), "ses_1") if err != nil { t.Fatal(err) } if len(models) != 2 || models[0].Provider != "prov-a" || models[0].ID != "a-model" || models[1].ID != "b-model" { t.Fatalf("models = %+v", models) } } func TestChatSwitchModelShape(t *testing.T) { var body struct { Model struct { ID string `json:"id"` ProviderID string `json:"providerID"` } `json:"model"` } srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost || r.URL.Path != "/api/session/ses_1/model" { t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) return } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { t.Fatal(err) } w.WriteHeader(http.StatusNoContent) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) if err := chat.SwitchModel(context.Background(), "ses_1", "opencode-go", "deepseek-v4.1-flash"); err != nil { t.Fatal(err) } if body.Model.ID != "deepseek-v4.1-flash" || body.Model.ProviderID != "opencode-go" { t.Fatalf("model body = %+v", body) } } func TestChatV2PromptWithFiles(t *testing.T) { var body struct { Text string `json:"text"` Files []map[string]string `json:"files"` } srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if err := json.NewDecoder(r.Body).Decode(&body); err != nil { t.Fatal(err) } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":{"id":"msg_files","sessionID":"ses_1","type":"user"}}`)) })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) err := chat.PromptWithMessageIDFiles(context.Background(), "ses_1", "read this", "msg_files", []PromptFile{ {URI: "file:///tmp/note.txt", Name: "note.txt"}, }) if err != nil { t.Fatal(err) } if body.Text != "read this" || len(body.Files) != 1 { t.Fatalf("prompt body = %+v", body) } if body.Files[0]["uri"] != "file:///tmp/note.txt" || body.Files[0]["name"] != "note.txt" { t.Fatalf("file = %+v", body.Files[0]) } } // TestChatStreamRealV2Shapes replays the exact event frames the installed 2.0.20 // service emitted on /api/event during a live turn (captured, not documented): // a step start, token text delta, usage and a step end whose data carries no // step index. It asserts the existing firehose mapper surfaces them with stable // session/message ids and that the usage frame inherits the retained message id. func TestChatStreamRealV2Shapes(t *testing.T) { frames := []string{ `{"id":"evt_0","created":0,"type":"session.instructions.updated","data":{"sessionID":"ses_1","delta":{"core/instructions":"abc","core/date":"def"}}}`, `{"id":"evt_1","created":1,"type":"session.step.started","data":{"sessionID":"ses_1","agent":"build","model":{"id":"deepseek-v4.1-flash","providerID":"opencode-go","variant":"default"},"assistantMessageID":"msg_1","started":1}}`, `{"id":"evt_2","created":2,"type":"session.text.started","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0}}`, `{"id":"evt_3","created":3,"type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"Where granite meets"}}`, `{"id":"evt_4","created":4,"type":"session.usage.updated","data":{"sessionID":"ses_1","cost":0.0005,"tokens":{"input":94,"output":304}}}`, `{"id":"evt_5","created":5,"type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","finish":"stop","tokens":{"input":94,"output":304},"cost":0.0005}}`, } srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/api/session/ses_1/message" { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":[]}`)) return } if r.URL.Path == "/api/session/ses_1" { w.WriteHeader(http.StatusNotFound) return } if r.Method != http.MethodGet || r.URL.Path != "/api/event" { t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) return } w.Header().Set("Content-Type", "text/event-stream") for _, frame := range frames { _, _ = w.Write([]byte("data: " + frame + "\n\n")) } })) 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 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) } // text.started carries no delta and is skipped; the four remaining frames // (step start, text delta, usage, step end) must all surface. if len(got) != 4 { t.Fatalf("frames = %d, want 4: %+v", len(got), got) } for _, frame := range got { if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" { t.Fatalf("frame missing stable ids: %+v", frame) } } if got[0].Kind != protocol.ChatEventStep || got[0].Step == nil || got[0].Step.Status != protocol.ChatStepStarted { t.Fatalf("step start frame = %+v", got[0]) } if got[1].Kind != protocol.ChatEventText || got[1].Delta != "Where granite meets" { t.Fatalf("text frame = %+v", got[1]) } if got[2].Kind != protocol.ChatEventUsage || got[2].Usage == nil || got[2].Usage.InputTokens != 94 || got[2].Usage.OutputTokens != 304 { t.Fatalf("usage frame = %+v", got[2]) } if got[3].Kind != protocol.ChatEventStep || got[3].Step == nil || got[3].Step.Status != protocol.ChatStepEnded { t.Fatalf("step end frame = %+v", got[3]) } } // TestChatDeltaPartIDsNeverCollide pins the broker's part-id namespace: OpenCode // numbers one message's text and reasoning parts independently from 0, so a // message's first text delta and its first reasoning delta share an ordinal. The // two must still land on distinct part ids — otherwise the client appends the // answer into the thinking block and the server's retained state re-collides on a // resume. The id is the shared ChatDeltaPartID derivation, so it is deterministic // across a reconnect. func TestChatDeltaPartIDsNeverCollide(t *testing.T) { payloads := map[string]string{ "text": `{"type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"answer"}}`, "reasoning": `{"type":"session.reasoning.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"think"}}`, } ids := map[string]string{} for kind, payload := range payloads { frame, ok, err := NormalizeChatEvent([]byte(payload), "ses_1", &ChatStreamState{}) if err != nil || !ok { t.Fatalf("%s delta: ok=%v err=%v", kind, ok, err) } if frame.Part == nil { t.Fatalf("%s delta carried no part", kind) } if frame.Part.Type != kind { t.Fatalf("%s delta part type = %q", kind, frame.Part.Type) } ids[kind] = frame.Part.ID } if ids["text"] == ids["reasoning"] { t.Fatalf("text and reasoning share part id %q", ids["text"]) } if ids["text"] != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0) { t.Fatalf("text part id = %q, want the stable derivation", ids["text"]) } if ids["reasoning"] != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartReasoning, 0) { t.Fatalf("reasoning part id = %q, want the stable derivation", ids["reasoning"]) } } // TestChatToolLifecycleCarriesNameAndInput pins what the broker learns from each // verified tool frame: input.started carries the name, input.ended carries the // arguments as its `text` string, called carries the parsed input object, and // progress/success carry neither — so those frames must surface no name and no // input, leaving the retention to the consumer instead of blanking the field. func TestChatToolLifecycleCarriesNameAndInput(t *testing.T) { frames := []struct { name string payload string wantStatus string wantName string wantInput string // the JSON encoding expected, "" for absent }{ { name: "input.started names the call", payload: `{"type":"session.tool.input.started","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell"}}`, wantStatus: protocol.ChatToolStreaming, wantName: "shell", }, { name: "input.ended carries the arguments as text", payload: `{"type":"session.tool.input.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","text":"{\"command\":\"ls\"}"}}`, wantStatus: protocol.ChatToolStreaming, wantInput: `{"command":"ls"}`, }, { name: "called carries the parsed input object", payload: `{"type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","input":{"command":"ls"}}}`, wantStatus: protocol.ChatToolRunning, wantInput: `{"command":"ls"}`, }, { name: "progress carries metadata only", payload: `{"type":"session.tool.progress","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","metadata":{"exit":0}}}`, wantStatus: protocol.ChatToolRunning, }, { name: "success carries the output and neither name nor input", payload: `{"type":"session.tool.success","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","content":[{"type":"text","text":"ok"}],"metadata":{"exit":0},"executed":true}}`, wantStatus: protocol.ChatToolCompleted, }, } for _, tc := range frames { t.Run(tc.name, func(t *testing.T) { frame, ok, err := NormalizeChatEvent([]byte(tc.payload), "ses_1", &ChatStreamState{}) if err != nil || !ok { t.Fatalf("ok=%v err=%v", ok, err) } if frame.Part == nil || frame.Part.State == nil { t.Fatalf("tool frame = %+v", frame) } if frame.Part.State.Status != tc.wantStatus { t.Fatalf("status = %q, want %q", frame.Part.State.Status, tc.wantStatus) } if frame.Part.Name != tc.wantName { t.Fatalf("name = %q, want %q", frame.Part.Name, tc.wantName) } if tc.wantInput == "" { if len(frame.Part.State.Input) != 0 { t.Fatalf("input = %s, want absent", frame.Part.State.Input) } return } if !json.Valid(frame.Part.State.Input) { t.Fatalf("input %s is not valid JSON", frame.Part.State.Input) } var want, got any if err := json.Unmarshal([]byte(tc.wantInput), &want); err != nil { t.Fatal(err) } if err := json.Unmarshal(frame.Part.State.Input, &got); err != nil { t.Fatalf("input %s: %v", frame.Part.State.Input, err) } if fmt.Sprintf("%v", want) != fmt.Sprintf("%v", got) { t.Fatalf("input = %s, want %s", frame.Part.State.Input, tc.wantInput) } }) } } // TestChatToolInputFromPartialText pins the streaming case: input.ended's text // that is not yet a complete JSON value must still surface, carried as a JSON // string so the frame stays valid and the client can show the partial arguments. func TestChatToolInputFromPartialText(t *testing.T) { frame, ok, err := NormalizeChatEvent([]byte(`{"type":"session.tool.input.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","text":"{\"command\":\"l"}}`), "ses_1", &ChatStreamState{}) if err != nil || !ok { t.Fatalf("ok=%v err=%v", ok, err) } if frame.Part == nil || frame.Part.State == nil { t.Fatalf("frame = %+v", frame) } if !json.Valid(frame.Part.State.Input) { t.Fatalf("partial input %s is not valid JSON", frame.Part.State.Input) } var got string if err := json.Unmarshal(frame.Part.State.Input, &got); err != nil { t.Fatalf("partial input is not a JSON string: %s (%v)", frame.Part.State.Input, err) } if got != `{"command":"l` { t.Fatalf("partial input text = %q", got) } } // TestChatShellEventMapping pins the shell mapping: a shell.created belonging to // the session surfaces a ChatEventShell frame carrying the shell's id, status and // command, and the matching shell.exited carries its id, status and exit code. // The frames carry no message id (a shell outlives the tool call that started // it), and the exit is a pointer so an exit of 0 is not mistaken for "absent". func TestChatShellEventMapping(t *testing.T) { state := &ChatStreamState{} created, ok, err := NormalizeChatEvent([]byte(`{"type":"shell.created","data":{"info":{"id":"sh_1","status":"running","command":"npm run dev","cwd":"/work","metadata":{"sessionID":"ses_1"}}}}`), "ses_1", state) if err != nil || !ok { t.Fatalf("shell.created: ok=%v err=%v", ok, err) } if created.Kind != protocol.ChatEventShell || created.Shell == nil { t.Fatalf("created frame = %+v", created) } if created.MessageID != "" { t.Fatalf("shell frame carried a message id: %q", created.MessageID) } if created.Shell.ID != "sh_1" || created.Shell.Status != protocol.ChatShellRunning || created.Shell.Command != "npm run dev" { t.Fatalf("created shell = %+v", created.Shell) } exited, ok, err := NormalizeChatEvent([]byte(`{"type":"shell.exited","data":{"id":"sh_1","exit":0,"status":"exited"}}`), "ses_1", state) if err != nil || !ok { t.Fatalf("shell.exited: ok=%v err=%v", ok, err) } if exited.Shell == nil || exited.Shell.ID != "sh_1" || exited.Shell.Status != protocol.ChatShellExited { t.Fatalf("exited shell = %+v", exited.Shell) } if exited.Shell.Exit == nil || *exited.Shell.Exit != 0 { t.Fatalf("exit code = %v, want a present 0", exited.Shell.Exit) } // A second exit for the same shell is not this session's any more: the id was // forgotten once its exit surfaced. if _, ok, err := NormalizeChatEvent([]byte(`{"type":"shell.exited","data":{"id":"sh_1","exit":0,"status":"exited"}}`), "ses_1", state); err != nil || ok { t.Fatalf("repeated exit produced a frame: ok=%v err=%v", ok, err) } } // TestChatShellEventForeignSessionIgnored pins the session scoping the shell // events need: they are location-scoped, so the session that started a shell is // named only in the created event's metadata. A shell started by another session // is ignored, and its exit — which names no session at all — is ignored too, // because the id was never remembered for this session. func TestChatShellEventForeignSessionIgnored(t *testing.T) { state := &ChatStreamState{} foreign := `{"type":"shell.created","data":{"info":{"id":"sh_foreign","status":"running","command":"sleep 120","metadata":{"sessionID":"ses_other"}}}}` if frame, ok, err := NormalizeChatEvent([]byte(foreign), "ses_1", state); err != nil || ok { t.Fatalf("another session's shell produced a frame: %+v ok=%v err=%v", frame, ok, err) } if _, ok, err := NormalizeChatEvent([]byte(`{"type":"shell.exited","data":{"id":"sh_foreign","exit":0,"status":"exited"}}`), "ses_1", state); err != nil || ok { t.Fatalf("another session's shell exit produced a frame: ok=%v err=%v", ok, err) } // An unattributed shell (no metadata.sessionID) is not this session's either. unattributed := `{"type":"shell.created","data":{"info":{"id":"sh_anon","status":"running","command":"ls","metadata":{}}}}` if _, ok, err := NormalizeChatEvent([]byte(unattributed), "ses_1", state); err != nil || ok { t.Fatalf("unattributed shell produced a frame: ok=%v err=%v", ok, err) } } // TestChatMalformedShellEventFailsStream pins that a shell event which cannot be // keyed (no shell id) fails the stream instead of producing a frame the client // cannot attribute. func TestChatMalformedShellEventFailsStream(t *testing.T) { cases := []string{ `{"type":"shell.created","data":{"info":{"status":"running","metadata":{"sessionID":"ses_1"}}}}`, `{"type":"shell.exited","data":{"exit":0,"status":"exited"}}`, } for _, payload := range cases { if _, ok, err := NormalizeChatEvent([]byte(payload), "ses_1", &ChatStreamState{}); err == nil || ok { t.Fatalf("malformed shell event %s: ok=%v err=%v", payload, ok, err) } } } // TestChatStreamSurfacesShellLifecycle drives the whole mapping through the SSE // read loop: a shell started for the session surfaces as a shell frame, a shell // started by another session is dropped, and the matching exit is surfaced only // for the session's own shell. It pins that the shell context the exit needs is // carried across frames by the stream's retained state, not by one payload. func TestChatStreamSurfacesShellLifecycle(t *testing.T) { frames := []string{ `{"id":"evt_1","type":"shell.created","data":{"info":{"id":"sh_1","status":"running","command":"npm run dev","metadata":{"sessionID":"ses_1"}}}}`, `{"id":"evt_2","type":"shell.created","data":{"info":{"id":"sh_other","status":"running","command":"sleep 120","metadata":{"sessionID":"ses_other"}}}}`, `{"id":"evt_3","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"hi"}}`, `{"id":"evt_4","type":"shell.exited","data":{"id":"sh_other","exit":0,"status":"exited"}}`, `{"id":"evt_5","type":"shell.exited","data":{"id":"sh_1","exit":0,"status":"exited"}}`, } srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") for _, frame := range frames { _, _ = w.Write([]byte("data: " + frame + "\n\n")) } })) 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 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) } var shellIDs []string for _, frame := range got { if frame.Kind == protocol.ChatEventShell && frame.Shell != nil { shellIDs = append(shellIDs, frame.Shell.ID+":"+frame.Shell.Status) } } if len(shellIDs) != 2 || shellIDs[0] != "sh_1:running" || shellIDs[1] != "sh_1:exited" { t.Fatalf("shell frames = %v, want only this session's created and exited", shellIDs) } } // TestOpenStreamRejectsUnknownBackend pins that the shared construction path // validates the backend before any process is started, so OpenStream never // launches a serve for an unknown backend. func TestOpenStreamRejectsUnknownBackend(t *testing.T) { if _, err := OpenStream(context.Background(), "opencode", t.TempDir(), "v3"); err == nil { t.Fatal("an unknown backend must be rejected") } } // TestOpenChatRejectsUnrunnableCLI pins that OpenChat surfaces detection failure // (an executable that cannot run) instead of opening a half-configured endpoint. func TestOpenChatRejectsUnrunnableCLI(t *testing.T) { missing := filepath.Join(t.TempDir(), "no-such-opencode") if _, err := OpenChat(context.Background(), missing, ""); err == nil { t.Fatal("a missing CLI must fail detection, not open an endpoint") } } // TestChatShellReadbackSeedsReplacementStream proves an authoritative shell // readback survives a later stream replacement: shell.exited has no session id, // so it must still clear the verified shell after reconnect. func TestChatShellReadbackSeedsReplacementStream(t *testing.T) { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case "/api/shell": w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":[{"id":"sh_1","status":"running","command":"sleep 30","metadata":{"sessionID":"ses_1"}},{"id":"sh_other","status":"running","command":"sleep 30","metadata":{"sessionID":"ses_other"}}]}`)) case "/api/event": w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"shell.exited\",\"data\":{\"id\":\"sh_1\",\"status\":\"exited\",\"exit\":0}}\n\n")) } })) defer srv.Close() chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) shells, err := chat.Shells(context.Background(), "ses_1") if err != nil || len(shells) != 1 || shells[0].ID != "sh_1" { t.Fatalf("Shells = %+v, %v", shells, err) } var got []protocol.ChatEventFrame if err := chat.Stream(context.Background(), "ses_1", nil, func(frame protocol.ChatEventFrame) error { got = append(got, frame); return nil }); err != nil { t.Fatal(err) } if len(got) != 1 || got[0].Shell == nil || got[0].Shell.ID != "sh_1" || got[0].Shell.Status != protocol.ChatShellExited { t.Fatalf("exit after readback = %+v", got) } } func TestChatShellOutputVerifiesOwnerAndBoundsPage(t *testing.T) { var outputPath string srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") switch r.URL.Path { case "/api/shell/sh_1": _, _ = w.Write([]byte(`{"data":{"id":"sh_1","status":"exited","command":"job","metadata":{"sessionID":"ses_1"}}}`)) case "/api/shell/sh_1/output": outputPath = r.URL.RawQuery _, _ = w.Write([]byte(`{"data":{"output":"marker","cursor":6,"size":6,"truncated":false}}`)) default: http.NotFound(w, r) } })) defer srv.Close() page, err := NewChat(&Connection{Backend: "v2", URL: srv.URL}).ShellOutput(context.Background(), protocol.ChatShellOutputQuery{SessionID: "ses_1", ShellID: "sh_1", Limit: 64 << 10}) if err != nil || page.Output != "marker" || page.Shell.Status != protocol.ChatShellExited { t.Fatalf("ShellOutput = %+v, %v", page, err) } if !strings.Contains(outputPath, "cursor=0") || !strings.Contains(outputPath, "limit=65536") { t.Fatalf("output query = %q", outputPath) } } func TestChatShellOutputRejectsMissingRequiredPageFields(t *testing.T) { for _, body := range []string{ `{"data":{}}`, `{"data":{"output":"","cursor":0,"size":0}}`, `{"data":{"output":"","size":0,"truncated":false}}`, `{"data":{"output":"","cursor":0,"truncated":false}}`, } { srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") switch r.URL.Path { case "/api/shell/sh_1": _, _ = w.Write([]byte(`{"data":{"id":"sh_1","status":"running","metadata":{"sessionID":"ses_1"}}}`)) case "/api/shell/sh_1/output": _, _ = w.Write([]byte(body)) default: http.NotFound(w, r) } })) chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) _, err := chat.ShellOutput(context.Background(), protocol.ChatShellOutputQuery{SessionID: "ses_1", ShellID: "sh_1", Limit: 1}) srv.Close() if err == nil { t.Fatalf("response %s was accepted", body) } } } func TestChatReleaseShellsBoundsDisconnectedState(t *testing.T) { chat := NewChat(&Connection{}) state := chat.streamState("ses_1") state.markShell("sh_1") chat.ReleaseShells("ses_1") chat.shellMu.Lock() _, retained := chat.shells["ses_1"] chat.shellMu.Unlock() if retained { t.Fatal("released session shell state was retained") } } func TestChatActivateSkillV2Shape(t *testing.T) { var path, body string srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { path = r.URL.Path data := make([]byte, r.ContentLength) _, _ = r.Body.Read(data) body = string(data) w.WriteHeader(http.StatusNoContent) })) defer srv.Close() if err := NewChat(&Connection{Backend: "v2", URL: srv.URL}).ActivateSkill(context.Background(), "ses_1", "pipelines-manager"); err != nil { t.Fatal(err) } if path != "/api/experimental/session/ses_1/skill" || body != `{"id":"pipelines-manager","resume":false}` { t.Fatalf("activate request = %s %s", path, body) } }