Keep observing chats with an in-flight turn after the last client leaves

Chat attention notifications (questions, approvals, finished replies) come
from a session's event stream, which the hub only read while a room existed;
detach destroyed the room when the last client left, so a turn that finished
or asked with the app closed notified nobody.

A room whose last client leaves now stays observing, unattended, while its
turn is in flight or it holds an unanswered question/approval, and is torn
down when the turn ends (or after 6h for a stuck turn); at most 16 such rooms.
At server start, recently used open sessions whose harness reports a running
turn (OpenCode /api/session/active, Codex thread/turns/list) are observed
again so their reply still notifies. Settings, dedupe and app_notifications
recording are unchanged.
This commit is contained in:
2026-11-02 16:07:42 +00:00
parent 467f3eafa7
commit 80022ea41a
13 changed files with 820 additions and 25 deletions
+22
View File
@@ -1863,3 +1863,25 @@ func decodeChatSession(data []byte) (protocol.ChatSession, error) {
}
return chatSessionFields(record), nil
}
// ProbeTurn reports whether OpenCode is running a turn for the session, read
// from the same /api/session/active list Stream polls. The server uses it once
// at start to resume observing turns a previous process left running. A failed
// read is an error, never "idle".
func (c *Chat) ProbeTurn(ctx context.Context, id string) (bool, error) {
if !sessionID.MatchString(id) {
return false, fmt.Errorf("invalid OpenCode session id")
}
data, err := c.call(ctx, "get", "/api/session/active", nil)
if err != nil {
return false, err
}
var response struct {
Data *map[string]json.RawMessage `json:"data"`
}
if err := json.Unmarshal(data, &response); err != nil || response.Data == nil {
return false, fmt.Errorf("invalid OpenCode active-session readback")
}
_, active := (*response.Data)[id]
return active, nil
}
+44
View File
@@ -0,0 +1,44 @@
package opencode
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"sync/atomic"
"testing"
)
// ProbeTurn reads the active-session list; a failed or malformed read is an
// error, never "idle".
func TestChatProbeTurn(t *testing.T) {
var malformed atomic.Bool
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/session/active" {
http.NotFound(w, r)
return
}
w.Header().Set("Content-Type", "application/json")
if malformed.Load() {
fmt.Fprint(w, `{"data":null}`)
return
}
fmt.Fprint(w, `{"data":{"ses_1":{"type":"running"}}}`)
}))
defer srv.Close()
chat := NewChat(&Connection{Backend: "v2", URL: srv.URL})
ctx := context.Background()
if running, err := chat.ProbeTurn(ctx, "ses_1"); err != nil || !running {
t.Fatalf("active session: %v %v", running, err)
}
if running, err := chat.ProbeTurn(ctx, "ses_2"); err != nil || running {
t.Fatalf("idle session: %v %v", running, err)
}
malformed.Store(true)
if _, err := chat.ProbeTurn(ctx, "ses_1"); err == nil {
t.Fatal("malformed readback treated as idle")
}
if _, err := chat.ProbeTurn(ctx, "bad id"); err == nil {
t.Fatal("invalid id accepted")
}
}