Poll OpenCode permission requests and forward chat_reply

This commit is contained in:
2026-10-16 08:06:39 +01:00
parent 9d1676df0a
commit 3ff5cd8838
10 changed files with 889 additions and 40 deletions
+33 -11
View File
@@ -178,17 +178,39 @@ traversal, absolute paths, symlink escapes and unknown runs/steps.
## Brokered OpenCode chat (unshipped)
The protocol declares the brokered `chat_*` surface (`chat_sessions`,
`chat_create`, `chat_prompt`, `chat_messages`, `chat_interrupt`, `chat_reply`). The
server dispatches `chat_prompt`, `chat_messages`, `chat_interrupt` and `chat_reply`,
answers the declared `chat_sessions`/`chat_create` with an explicit protocol error
because they are not yet brokered, and pushes `chat_event` frames derived from
OpenCode's global `/api/event` firehose, with retained per-session/per-message state
so a reconnecting client re-syncs instead of replaying deltas. This is an internal, unshipped capability: no client consumes it,
and chat is enabled only when the OpenCode connection exposes a URL-bearing SSE
endpoint (the owned v1 serve process). On a V2 CLI (`opencode api`, no owned serve)
that endpoint is absent, so every dispatched `chat_*` request returns a protocol error
naming the missing configuration. Do not describe brokered chat as a finished or
user-facing feature.
`chat_create`, `chat_prompt`, `chat_messages`, `chat_interrupt`, `chat_permission`,
`chat_reply`). The server dispatches `chat_prompt`, `chat_messages`, `chat_interrupt`
and `chat_reply`, answers the declared `chat_sessions`/`chat_create` with an explicit
protocol error because they are not yet brokered, and pushes `chat_event` frames
derived from OpenCode's global `/api/event` firehose, with retained
per-session/per-message state so a reconnecting client re-syncs instead of replaying
deltas.
While a `chat_prompt` subscription is open the server also polls
`GET /api/permission/request` on a fixed small interval (first poll immediately) and
pushes one `chat_permission` frame per newly pending approval request, deduped by
request id so a repeated poll never re-pushes the same request. The app answers with
`chat_reply`, which the server forwards as
`POST /api/session/{id}/permission/{requestID}/reply` with
`{"decision":"once"|"always"|"reject"}`. A missing session/request id or an invalid
decision is rejected before any OpenCode call, and the poller stops when the stream
ends or the client disconnects.
The permission list and reply are implemented against the V2 HTTP API only: their
field names match the service's `Permission.Request`/`Permission.Reply` schemas
(verified against the installed service's `/openapi.json`), and the native v1 serve
translation rejects them explicitly instead of guessing an endpoint. Because this
build enables brokered chat only when the OpenCode connection exposes a URL-bearing
SSE endpoint (the owned v1 serve process), the approval flow is not reachable on the
backend that currently enables chat; on that backend the permission poller stops
quietly rather than reporting the documented limitation as a per-prompt error. This is
an internal, unshipped capability: no client consumes it, and on a V2 CLI
(`opencode api`, no owned serve) that endpoint is absent, so every dispatched `chat_*`
request returns a protocol error naming the missing configuration. The live
end-to-end approval flow has NOT been tested against a real OpenCode service; the wire
shapes and the exact reply path/body are covered by unit tests over an httptest
fixture, not against a live pending request. Do not describe brokered chat as a
finished or user-facing feature.
## Debug and retry
+126 -8
View File
@@ -5,13 +5,22 @@ import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"strings"
"sync"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// ErrPermissionUnsupported reports that the connected OpenCode backend does not
// expose the brokered approval surface. The native v1 serve translation returns
// it; callers treat it as a documented limitation rather than an operational
// failure, so a chat prompt does not emit a permission error frame on a backend
// that cannot answer one.
var ErrPermissionUnsupported = errors.New("OpenCode permission approval is not implemented for the native serve backend")
// Chat is the brokered OpenCode chat adapter (route B in the research): the
// Pipelines server owns the OpenCode endpoint and credentials and turns the v2
// HTTP API into protocol.ChatEventFrame frames. It reuses the owned-endpoint
@@ -19,6 +28,11 @@ import (
// no second transport or credential path is introduced.
type Chat struct {
conn *Connection
// mu serializes the adapter's HTTP calls. Connection records its last
// operation and status on the shared connection, so two calls must not
// overlap; the permission poller runs alongside the read loop's
// prompt/interrupt/reply calls.
mu sync.Mutex
}
// NewChat brokers chat for one owned OpenCode endpoint. The connection must be
@@ -31,6 +45,15 @@ func NewChat(conn *Connection) *Chat { return &Chat{conn: conn} }
// chat adapter and callers that must reject a request before any OpenCode call.
func ValidSessionID(id string) bool { return sessionID.MatchString(id) }
// call serializes the adapter's HTTP calls and forwards them through the shared
// Connection, so no second transport is introduced and Connection's recorded
// last operation/status is never written by two goroutines at once.
func (c *Chat) call(ctx context.Context, method, path string, body any) ([]byte, error) {
c.mu.Lock()
defer c.mu.Unlock()
return c.conn.Call(ctx, method, path, body)
}
// Prompt forwards one chat prompt through the existing Call translation
// (authenticated, bounded, directory-scoped). The endpoint returns the inbox
// envelope immediately; the reply arrives on Stream.
@@ -42,7 +65,7 @@ func (c *Chat) Prompt(ctx context.Context, id, text string) error {
return fmt.Errorf("empty chat prompt")
}
body := map[string]any{"parts": []map[string]string{{"type": "text", "text": text}}}
if _, err := c.conn.Call(ctx, "post", "/api/session/"+id+"/prompt", body); err != nil {
if _, err := c.call(ctx, "post", "/api/session/"+id+"/prompt", body); err != nil {
return err
}
return nil
@@ -53,7 +76,7 @@ func (c *Chat) Interrupt(ctx context.Context, id string) error {
if !sessionID.MatchString(id) {
return fmt.Errorf("invalid OpenCode session id")
}
if _, err := c.conn.Call(ctx, "post", "/api/session/"+id+"/interrupt", map[string]any{}); err != nil {
if _, err := c.call(ctx, "post", "/api/session/"+id+"/interrupt", map[string]any{}); err != nil {
return err
}
return nil
@@ -69,6 +92,7 @@ func (c *Chat) Messages(ctx context.Context, id string, limit int) ([]protocol.C
}
var data []byte
var err error
c.mu.Lock()
if c.conn.Backend == "v1" {
data, err = c.conn.Messages(ctx, id)
} else {
@@ -78,6 +102,7 @@ func (c *Chat) Messages(ctx context.Context, id string, limit int) ([]protocol.C
}
data, err = c.conn.Call(ctx, "get", path, nil)
}
c.mu.Unlock()
if err != nil {
return nil, err
}
@@ -101,12 +126,108 @@ func (c *Chat) Reply(ctx context.Context, request protocol.ChatReplyRequest) err
body["message"] = request.Message
}
path := "/api/session/" + request.SessionID + "/permission/" + request.RequestID + "/reply"
if _, err := c.conn.Call(ctx, "post", path, body); err != nil {
if _, err := c.call(ctx, "post", path, body); err != nil {
return err
}
return nil
}
// Permissions lists the session's pending OpenCode approval requests, mirroring
// GET /api/permission/request. The endpoint is global, so the decoded list is
// filtered to sessionID; a malformed response is an error, never an empty
// success. It reuses Connection.Call so the request keeps the shared bounds,
// auth and translation, and reuses ValidSessionID for the same rejection the
// other chat calls apply.
func (c *Chat) Permissions(ctx context.Context, id string) ([]protocol.ChatPermissionFrame, error) {
if !sessionID.MatchString(id) {
return nil, fmt.Errorf("invalid OpenCode session id")
}
data, err := c.call(ctx, "get", "/api/permission/request", nil)
if err != nil {
return nil, err
}
return decodeChatPermissions(id, data)
}
// nativeChatPermission is one pending approval request matching the V2
// Permission.Request schema verified against the service's /openapi.json: id,
// sessionID, action and resources are required; save, metadata, source and
// message are optional, so the decoder tolerates any of them being absent.
type nativeChatPermission struct {
ID string `json:"id"`
SessionID string `json:"sessionID"`
Action string `json:"action"`
Resources []string `json:"resources"`
Save []string `json:"save"`
Metadata map[string]any `json:"metadata"`
Source *nativeChatPermissionSource `json:"source"`
Message string `json:"message"`
}
// nativeChatPermissionSource is the incoming Permission.Source union; its single
// (tool) member carries type plus the message id and call id (the protocol frame
// renames messageID to message_id).
type nativeChatPermissionSource struct {
Type string `json:"type"`
MessageID string `json:"messageID"`
ID string `json:"id"`
}
// chatEnvelope unwraps the {"data":[...]} envelope the V2 HTTP API returns and
// reports whether the body was that envelope with a non-nil data array; a bare
// array or a malformed body returns ok=false. It is the single envelope rule the
// message and permission decoders share instead of each re-deriving it.
func chatEnvelope[T any](data []byte) ([]T, bool) {
var response struct {
Data []T `json:"data"`
}
if err := json.Unmarshal(data, &response); err != nil || response.Data == nil {
return nil, false
}
return response.Data, true
}
// chatPermissionRecords reads the {"data":[...]} envelope the V2 endpoint
// returns. An unparseable body or a missing data array is an error, never an
// empty list.
func chatPermissionRecords(data []byte) ([]nativeChatPermission, error) {
records, ok := chatEnvelope[nativeChatPermission](data)
if !ok {
return nil, fmt.Errorf("invalid OpenCode permission response")
}
return records, nil
}
// decodeChatPermissions maps the pending-request list onto protocol frames,
// keeping only the requested session's requests (a request with no id cannot be
// answered and is dropped).
func decodeChatPermissions(sessionID string, data []byte) ([]protocol.ChatPermissionFrame, error) {
records, err := chatPermissionRecords(data)
if err != nil {
return nil, err
}
frames := make([]protocol.ChatPermissionFrame, 0, len(records))
for _, record := range records {
if record.SessionID != sessionID || record.ID == "" {
continue
}
frame := protocol.ChatPermissionFrame{
SessionID: sessionID,
RequestID: record.ID,
Action: record.Action,
Resources: record.Resources,
Save: record.Save,
Metadata: record.Metadata,
Message: record.Message,
}
if record.Source != nil {
frame.Source = &protocol.ChatPermissionSource{Type: record.Source.Type, MessageID: record.Source.MessageID, ID: record.Source.ID}
}
frames = append(frames, frame)
}
return frames, nil
}
// Stream subscribes to the OpenCode event firehose and invokes emit for every
// frame belonging to sessionID. It reads one bounded SSE frame at a time and
// never polls the per-session message log; the global firehose is the only
@@ -388,11 +509,8 @@ func (m nativeChatMessage) contentParts() []nativeChatPart {
// the V2 HTTP API wraps them in {"data":[...]} while the native serve readback
// returns a bare array. An unrecognised body is an error, never empty history.
func chatMessageRecords(data []byte) ([]nativeChatMessage, error) {
var response struct {
Data []nativeChatMessage `json:"data"`
}
if err := json.Unmarshal(data, &response); err == nil && response.Data != nil {
return response.Data, nil
if records, ok := chatEnvelope[nativeChatMessage](data); ok {
return records, nil
}
var records []nativeChatMessage
if err := json.Unmarshal(data, &records); err != nil {
+148
View File
@@ -3,6 +3,7 @@ package opencode
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
@@ -161,11 +162,158 @@ func TestChatRejectsInvalidSessionWithoutCalling(t *testing.T) {
if err := chat.Interrupt(ctx, "bad id"); err == nil {
t.Fatal("invalid interrupt session id must be rejected")
}
if _, err := chat.Permissions(ctx, "not-a-session"); err == nil {
t.Fatal("invalid permission session id must be rejected")
}
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "not-a-session", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); err == nil {
t.Fatal("invalid reply session id must be rejected")
}
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "", Decision: protocol.ChatDecisionOnce}); err == nil {
t.Fatal("empty reply request id must be rejected")
}
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: "maybe"}); err == nil {
t.Fatal("invalid reply decision must be rejected")
}
if calls.Load() != 0 {
t.Fatalf("invalid requests reached the service: %d", calls.Load())
}
}
// TestChatPermissionsListsAndFilters loads a pending-request fixture in the
// verified V2 envelope (GET /api/permission/request) and asserts the adapter
// returns the requested session's request with its fields intact, filters out a
// foreign session's request, and reads the endpoint once.
func TestChatPermissionsListsAndFilters(t *testing.T) {
var reads atomic.Int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet || r.URL.Path != "/api/permission/request" {
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
return
}
reads.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[
{"id":"per_1","sessionID":"ses_1","action":"bash","resources":["rm -rf /tmp"],"save":["bash:rm -rf /tmp"],"metadata":{"command":"rm -rf /tmp"},"source":{"type":"tool","messageID":"msg_1","id":"call_1"},"message":"wants to run a command"},
{"id":"per_2","sessionID":"ses_other","action":"edit","resources":["/etc/hosts"]}
]}`))
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
frames, err := chat.Permissions(ctx, "ses_1")
if err != nil {
t.Fatalf("permissions: %v", err)
}
if reads.Load() != 1 {
t.Fatalf("permission endpoint read %d times, want 1", reads.Load())
}
if len(frames) != 1 {
t.Fatalf("frames = %+v, want the foreign request filtered", frames)
}
got := frames[0]
if got.SessionID != "ses_1" || got.RequestID != "per_1" || got.Action != "bash" {
t.Fatalf("frame = %+v", got)
}
if len(got.Resources) != 1 || got.Resources[0] != "rm -rf /tmp" || len(got.Save) != 1 || got.Message != "wants to run a command" {
t.Fatalf("frame detail = %+v", got)
}
if got.Metadata["command"] != "rm -rf /tmp" {
t.Fatalf("frame metadata = %+v", got.Metadata)
}
if got.Source == nil || got.Source.Type != "tool" || got.Source.MessageID != "msg_1" || got.Source.ID != "call_1" {
t.Fatalf("frame source = %+v", got.Source)
}
}
// TestChatPermissionsRejectsMalformedList pins that a response without the data
// array is an error, not an empty success.
func TestChatPermissionsRejectsMalformedList(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"location":{"directory":"/work"}}`))
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
if _, err := chat.Permissions(context.Background(), "ses_1"); err == nil {
t.Fatal("a malformed permission response must be an error, not empty success")
}
}
// TestChatPermissionReplyPostsReplyEndpoint pins the outbound approval reply: the
// adapter must POST exactly once to
// /api/session/{id}/permission/{requestID}/reply with the exact decision body,
// accept the documented 204 No Content success, and surface a non-2xx failure.
func TestChatPermissionReplyPostsReplyEndpoint(t *testing.T) {
for _, decision := range []string{protocol.ChatDecisionOnce, protocol.ChatDecisionAlways, protocol.ChatDecisionReject} {
t.Run(decision, func(t *testing.T) {
type request struct{ method, path, body string }
var mu sync.Mutex
var requests []request
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
data, _ := io.ReadAll(r.Body)
mu.Lock()
requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)})
mu.Unlock()
w.WriteHeader(http.StatusNoContent)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: decision}); err != nil {
t.Fatalf("reply: %v", err)
}
mu.Lock()
got := append([]request(nil), requests...)
mu.Unlock()
if len(got) != 1 {
t.Fatalf("reply requests = %d, want 1: %+v", len(got), got)
}
if got[0].method != http.MethodPost || got[0].path != "/api/session/ses_1/permission/req_1/reply" {
t.Fatalf("reply request = %+v", got[0])
}
if got[0].body != `{"decision":"`+decision+`"}` {
t.Fatalf("reply body = %q, want decision %q", got[0].body, decision)
}
})
}
t.Run("failure", func(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
if err := chat.Reply(context.Background(), protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); err == nil {
t.Fatal("a failing reply endpoint must return an error")
}
})
}
// TestChatPermissionV1TranslationGated pins the declared backend limitation: the
// permission list and reply are implemented against the V2 HTTP API, and the
// native serve translation rejects them explicitly (an actionable error, no
// guessed endpoint, no HTTP call) so the caller can see the limitation.
func TestChatPermissionV1TranslationGated(t *testing.T) {
var calls atomic.Int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
calls.Add(1)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v1", URL: srv.URL, Directory: "/repo", models: map[string]map[string]string{}, responses: map[string][]byte{}})
ctx := context.Background()
if _, err := chat.Permissions(ctx, "ses_1"); !errors.Is(err, ErrPermissionUnsupported) {
t.Fatalf("v1 permission list must return the gate sentinel, got %v", err)
}
if err := chat.Reply(ctx, protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}); !errors.Is(err, ErrPermissionUnsupported) {
t.Fatalf("v1 permission reply must return the gate sentinel, got %v", err)
}
if calls.Load() != 0 {
t.Fatalf("gated permission requests reached the service: %d", calls.Load())
}
}
// TestChatInterruptPostsInterruptEndpoint pins the outbound interrupt call: the
// adapter must POST an empty JSON body to /api/session/{id}/interrupt exactly
// once and return nil, and it must surface a non-nil error when the endpoint
+5
View File
@@ -262,6 +262,11 @@ func (c *Connection) Native(ctx context.Context, method, path string, body any)
evidence, _ := io.ReadAll(io.LimitReader(response.Body, 16<<10))
return evidence, fmt.Errorf("OpenCode %s %s failed (HTTP %d)", method, path, response.StatusCode)
}
// A successful no-content operation (the permission-reply endpoint returns
// 204) carries no JSON body to validate.
if response.StatusCode == http.StatusNoContent {
return nil, nil
}
if !strings.HasPrefix(response.Header.Get("Content-Type"), "application/json") {
return nil, fmt.Errorf("OpenCode %s %s returned a non-JSON API response", method, path)
}
+15
View File
@@ -116,6 +116,16 @@ func (c *Connection) Call(ctx context.Context, method, path string, body any) ([
return json.Marshal(map[string]any{"data": map[string]string{"id": session.ID}})
}
clean := strings.SplitN(path, "?", 2)[0]
// The brokered approval surface is implemented against the V2 HTTP API: the
// documented endpoints are GET /api/permission/request and POST
// /api/session/{id}/permission/{requestID}/reply. This native serve
// translation does not implement them, so answer with an actionable gate
// error instead of the generic unsupported-operation error; the permission
// poller surfaces that limitation rather than silently reporting no pending
// requests.
if clean == "/api/permission/request" {
return nil, fmt.Errorf("permission listing: %w", ErrPermissionUnsupported)
}
parts := strings.Split(strings.TrimPrefix(clean, "/api/session/"), "/")
if strings.HasPrefix(clean, "/api/experimental/session/") {
parts = strings.Split(strings.TrimPrefix(clean, "/api/experimental/session/"), "/")
@@ -124,6 +134,11 @@ func (c *Connection) Call(ctx context.Context, method, path string, body any) ([
return nil, fmt.Errorf("unsupported native OpenCode operation")
}
id := parts[0]
// The approval reply is V2-only in this translation (see the permission-list
// gate above); the V2 path has four trailing segments.
if len(parts) == 4 && parts[1] == "permission" && parts[3] == "reply" {
return nil, fmt.Errorf("permission reply: %w", ErrPermissionUnsupported)
}
if len(parts) == 1 && method == "delete" {
data, err := c.Native(ctx, "delete", "/session/"+id, nil)
if err != nil {
+34 -2
View File
@@ -22,9 +22,12 @@ const (
ChatMessages = "chat_messages"
ChatInterrupt = "chat_interrupt"
ChatReply = "chat_reply"
// ChatEvent is the server-pushed frame; it is the only type the server
// sends without a matching request.
// ChatEvent and ChatPermission are the server-pushed frames; they are the
// only types the server sends without a matching request.
ChatEvent = "chat_event"
// ChatPermission carries one pending OpenCode approval request the phone
// answers with chat_reply.
ChatPermission = "chat_permission"
)
// Content part types carried by ChatPart.Type and ChatEvent.Kind.
@@ -200,6 +203,35 @@ type ChatUsage struct {
Cost float64 `json:"cost,omitempty"`
}
// ChatPermissionFrame is the server-pushed chat_permission payload: one pending
// OpenCode permission request the phone must approve or reject. It is a distinct
// Message field (like ChatEvent) rather than a ChatEvent.Kind, so it does not
// overload the turn-progress kinds. Its field names match the service's
// Permission.Request schema, verified against the installed service's
// /openapi.json (id, sessionID, action and resources required; save, metadata,
// source and message optional), with id -> RequestID and sessionID -> SessionID.
// The wire shape is spec-verified; a live pending request has not been observed.
// Every optional field is omitempty so older peers ignore it.
type ChatPermissionFrame struct {
SessionID string `json:"session_id"`
RequestID string `json:"request_id"`
Action string `json:"action,omitempty"`
Resources []string `json:"resources,omitempty"`
Save []string `json:"save,omitempty"`
Metadata map[string]any `json:"metadata,omitempty"`
Source *ChatPermissionSource `json:"source,omitempty"`
Message string `json:"message,omitempty"`
}
// ChatPermissionSource identifies what raised a permission request, matching the
// Permission.Source union (currently only a tool call: type "tool" plus the
// message and call id) verified against the service's /openapi.json.
type ChatPermissionSource struct {
Type string `json:"type,omitempty"`
MessageID string `json:"message_id,omitempty"`
ID string `json:"id,omitempty"`
}
// ChatReplyRequest is the chat_reply request body: the phone's decision on a
// pending permission request, mirroring
// POST /api/session/{id}/permission/{requestID}/reply.
+39 -2
View File
@@ -55,6 +55,13 @@ func chatSamples() []struct {
}},
{"event_step", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventStep, Step: &ChatStep{Status: ChatStepEnded, Index: 2}}},
{"event_usage", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventUsage, Usage: &ChatUsage{InputTokens: 12, OutputTokens: 34, Cost: 0.001}}},
{"permission", ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"}, Save: []string{"bash:rm -rf /tmp"},
Metadata: map[string]any{"command": "rm -rf /tmp"},
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
Message: "wants to run a command",
}},
{"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok"}},
}
}
@@ -114,6 +121,32 @@ func TestChatEventGoldenJSON(t *testing.T) {
}
}
// TestChatPermissionGoldenJSON pins the exact wire shape of the pushed
// chat_permission frame so a JSON tag change cannot silently alter what the
// phone parses.
func TestChatPermissionGoldenJSON(t *testing.T) {
frame := ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"},
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
}
encoded, err := json.Marshal(frame)
if err != nil {
t.Fatal(err)
}
want := `{"session_id":"ses_1","request_id":"per_1","action":"bash","resources":["rm -rf /tmp"],"source":{"type":"tool","message_id":"msg_1","id":"call_1"}}`
if string(encoded) != want {
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
}
var decoded ChatPermissionFrame
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(decoded, frame) {
t.Fatalf("golden did not decode back: %+v", decoded)
}
}
func TestChatEnvelopeRoundTrip(t *testing.T) {
session := ChatSession{ID: "ses_1", Title: "demo"}
message := Message{
@@ -125,7 +158,10 @@ func TestChatEnvelopeRoundTrip(t *testing.T) {
ChatPrompt: &ChatPromptRequest{SessionID: "ses_1", Text: "hi"},
ChatMessages: []ChatMessage{{ID: "msg_1", SessionID: "ses_1", Role: ChatRoleUser, Parts: []ChatPart{{Type: ChatPartText, Text: "hi"}}}},
ChatEvent: &ChatEventFrame{SessionID: "ses_1", Kind: ChatEventText, Delta: "hi"},
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
ChatPermission: &ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash", Resources: []string{"rm -rf /"},
},
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
}
encoded, err := json.Marshal(message)
if err != nil {
@@ -145,6 +181,7 @@ func TestChatEnvelopeRoundTrip(t *testing.T) {
!reflect.DeepEqual(decoded.ChatPrompt, message.ChatPrompt) ||
!reflect.DeepEqual(decoded.ChatMessages, message.ChatMessages) ||
!reflect.DeepEqual(decoded.ChatEvent, message.ChatEvent) ||
!reflect.DeepEqual(decoded.ChatPermission, message.ChatPermission) ||
!reflect.DeepEqual(decoded.ChatReply, message.ChatReply) {
t.Fatalf("chat payloads lost: %+v", decoded)
}
@@ -155,7 +192,7 @@ func TestChatFieldsOmittedWhenUnused(t *testing.T) {
if err != nil {
t.Fatal(err)
}
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_reply"} {
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply"} {
if strings.Contains(string(minimal), absent) {
t.Fatalf("absent %q must be omitted: %s", absent, minimal)
}
+9 -8
View File
@@ -135,12 +135,13 @@ type Message struct {
Workspace string `json:"workspace,omitempty"`
// Chat is the brokered OpenCode chat traffic (route B). See chat.go for the
// per-type payload structs and the wire shapes they mirror.
ChatSessions []ChatSession `json:"chat_sessions,omitempty"`
ChatSession *ChatSession `json:"chat_session,omitempty"`
ChatCreate *ChatCreateRequest `json:"chat_create,omitempty"`
ChatQuery *ChatQuery `json:"chat_query,omitempty"`
ChatPrompt *ChatPromptRequest `json:"chat_prompt,omitempty"`
ChatMessages []ChatMessage `json:"chat_messages,omitempty"`
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
ChatSessions []ChatSession `json:"chat_sessions,omitempty"`
ChatSession *ChatSession `json:"chat_session,omitempty"`
ChatCreate *ChatCreateRequest `json:"chat_create,omitempty"`
ChatQuery *ChatQuery `json:"chat_query,omitempty"`
ChatPrompt *ChatPromptRequest `json:"chat_prompt,omitempty"`
ChatMessages []ChatMessage `json:"chat_messages,omitempty"`
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"`
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
}
+158 -7
View File
@@ -2,6 +2,7 @@ package server
import (
"context"
"errors"
"log"
"strings"
"sync"
@@ -22,9 +23,22 @@ type chatBroker interface {
Stream(ctx context.Context, sessionID string, ready func(), emit func(protocol.ChatEventFrame) error) error
Interrupt(ctx context.Context, sessionID string) error
Messages(ctx context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error)
// Permissions lists the session's pending OpenCode approval requests so the
// handler can push chat_permission frames.
Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error)
Reply(ctx context.Context, request protocol.ChatReplyRequest) error
}
// chatPermissionPollInterval is the fixed interval between permission polls: one
// GET per poll through the shared Connection bounds, never a busy loop. The first
// poll runs immediately so a request pending when the prompt is sent is surfaced
// without waiting a full interval.
const chatPermissionPollInterval = 2 * time.Second
// chatPermissionRetainedLimit bounds the dedup set of already-pushed permission
// request ids one session retains, so a long turn cannot grow it without limit.
const chatPermissionRetainedLimit = 256
// chatRetainedLimit bounds the state one session may retain so a stalled reader
// or a runaway turn cannot grow memory without limit. It matches the OpenCode
// response bound (1 MiB).
@@ -69,6 +83,11 @@ type chatTurn struct {
size int
overflow bool
updated time.Time
// permissions holds the request ids already pushed to the client so a
// repeated poll cannot push the same pending request twice; permissionOrder
// bounds it to chatPermissionRetainedLimit.
permissions map[string]struct{}
permissionOrder []string
}
func newChatHub() *chatHub {
@@ -93,13 +112,7 @@ func (h *chatHub) apply(frame protocol.ChatEventFrame) {
}
h.mu.Lock()
defer h.mu.Unlock()
turn := h.turns[frame.SessionID]
if turn == nil {
h.evictLocked()
turn = &chatTurn{sessionID: frame.SessionID, messages: map[string]*chatMessage{}}
h.turns[frame.SessionID] = turn
}
turn.updated = h.clock()
turn := h.turnLocked(frame.SessionID)
switch frame.Kind {
case protocol.ChatEventStep:
turn.step = frame.Step
@@ -210,6 +223,21 @@ func (h *chatHub) evictLocked() {
}
}
// turnLocked returns the session's retained turn, creating it (and evicting the
// least-recently-updated turn first when the cap is reached) and refreshing its
// update time. It is the shared turn-initialization path for apply and
// seenPermission, so the two cannot drift. Callers must hold h.mu.
func (h *chatHub) turnLocked(sessionID string) *chatTurn {
turn := h.turns[sessionID]
if turn == nil {
h.evictLocked()
turn = &chatTurn{sessionID: sessionID, messages: map[string]*chatMessage{}}
h.turns[sessionID] = turn
}
turn.updated = h.clock()
return turn
}
// retain records n more bytes and reports whether the turn is still within the
// bound. The first overflow records one diagnostic and then drops further state
// instead of growing without limit.
@@ -265,6 +293,55 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage {
return messages
}
// seenPermission records requestID as pushed for the session and reports whether
// it is newly seen (true) or a duplicate (false). The retained ids are bounded:
// the oldest is dropped once the session exceeds chatPermissionRetainedLimit, so
// the same pending request is pushed at most once while the state stays bounded.
func (h *chatHub) seenPermission(sessionID, requestID string) bool {
if sessionID == "" || requestID == "" {
return false
}
h.mu.Lock()
defer h.mu.Unlock()
turn := h.turnLocked(sessionID)
if turn.permissions == nil {
turn.permissions = map[string]struct{}{}
}
if _, ok := turn.permissions[requestID]; ok {
return false
}
turn.permissions[requestID] = struct{}{}
turn.permissionOrder = append(turn.permissionOrder, requestID)
if len(turn.permissionOrder) > chatPermissionRetainedLimit {
oldest := turn.permissionOrder[0]
turn.permissionOrder = turn.permissionOrder[1:]
delete(turn.permissions, oldest)
}
return true
}
// forgetPermission releases a request id reserved by seenPermission when its
// frame could not be written, so a later poll re-pushes it instead of the id
// staying "seen" while the phone never received the request.
func (h *chatHub) forgetPermission(sessionID, requestID string) {
if sessionID == "" || requestID == "" {
return
}
h.mu.Lock()
defer h.mu.Unlock()
turn := h.turns[sessionID]
if turn == nil {
return
}
delete(turn.permissions, requestID)
for i, id := range turn.permissionOrder {
if id == requestID {
turn.permissionOrder = append(turn.permissionOrder[:i], turn.permissionOrder[i+1:]...)
break
}
}
}
// handleChat dispatches one chat_* request. It returns true when the request was
// a chat type and has been fully answered (the caller must not fall through to
// the generic response). Frames are pushed after the ack, each through the
@@ -388,6 +465,70 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat
}
bufferMu.Unlock()
go drainChatStream(ctx, streamResult, streamCancel, sessionID, write)
// Poll for pending approval requests alongside the event stream, sharing
// streamCtx so the poller stops when the stream ends or the client
// disconnects. The first poll runs immediately.
go pollChatPermissions(streamCtx, broker, hub, sessionID, write)
}
// pollChatPermissions polls the broker's pending-approval list on a fixed
// interval, sharing the chat subscription's context so it stops on disconnect or
// when the turn's stream ends. The hub dedups the request ids, so each pending
// request is pushed at most once; a poll failure is surfaced once through the
// same write closure instead of staying silent. A backend that does not expose
// the approval surface (opencode.ErrPermissionUnsupported) stops the poller
// quietly, so the documented limitation is not reported as a per-prompt error.
func pollChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) {
ticker := time.NewTicker(chatPermissionPollInterval)
defer ticker.Stop()
reported := false
for {
if err := pushChatPermissions(ctx, broker, hub, sessionID, write); err != nil {
if ctx.Err() != nil {
return
}
if errors.Is(err, opencode.ErrPermissionUnsupported) {
log.Printf("chat permission poll session=%s: %v", sessionID, err)
return
}
if reported {
log.Printf("chat permission poll session=%s: %v", sessionID, err)
} else {
reported = true
_ = write(protocol.Message{Type: protocol.Error, Error: "chat permission poll: " + err.Error()})
}
}
select {
case <-ctx.Done():
return
case <-ticker.C:
}
}
}
// pushChatPermissions performs one poll and writes a chat_permission frame for
// every newly seen request of the session, through the same connection-scoped
// write closure as the chat stream. It never re-pushes a request id, and releases
// the reservation on a write failure so the frame is not silently dropped.
func pushChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) error {
pending, err := broker.Permissions(ctx, sessionID)
if err != nil {
return err
}
for _, request := range pending {
if request.SessionID != sessionID || request.RequestID == "" {
continue
}
if !hub.seenPermission(sessionID, request.RequestID) {
continue
}
frame := request
if err := write(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame}); err != nil {
hub.forgetPermission(sessionID, request.RequestID)
return err
}
}
return nil
}
// drainChatStream reports the terminal error of a chat subscription and releases
@@ -450,6 +591,16 @@ func handleChatSimple(ctx context.Context, request protocol.Message, broker chat
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
return
}
if strings.TrimSpace(reply.RequestID) == "" {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a permission request id is required"})
return
}
switch reply.Decision {
case protocol.ChatDecisionOnce, protocol.ChatDecisionAlways, protocol.ChatDecisionReject:
default:
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid permission decision is required"})
return
}
if err := broker.Reply(ctx, *reply); err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
+322 -2
View File
@@ -26,10 +26,19 @@ type fakeChat struct {
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{}
@@ -102,11 +111,49 @@ func (f *fakeChat) messageQuery() (int, string, int) {
return f.messageCalls, f.messageSessionID, f.messageLimit
}
func (f *fakeChat) Reply(context.Context, protocol.ChatReplyRequest) error {
func (f *fakeChat) Reply(_ context.Context, request protocol.ChatReplyRequest) error {
f.mu.Lock()
defer f.mu.Unlock()
f.replies++
return nil
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) {
@@ -508,6 +555,9 @@ func TestChatInterruptEndsRunningPrompt(t *testing.T) {
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 {
@@ -758,6 +808,9 @@ func realAdapterChat(t *testing.T, frames []string) []protocol.ChatEventFrame {
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")
@@ -894,3 +947,270 @@ func TestChatSessionsAndCreateAnswerExplicitly(t *testing.T) {
}
}
}
// 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)
}
}