Files
pipelines/internal/codex/readback.go
T
alan 80022ea41a 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.
2026-11-02 16:07:42 +00:00

135 lines
3.8 KiB
Go

package codex
import (
"context"
"crypto/sha256"
"encoding/json"
"errors"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
type turnReadback struct {
turn turn
digest [32]byte
}
func (c *Chat) latestTurn(ctx context.Context, id string) (turnReadback, error) {
read, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
raw, err := c.call(read, "thread/turns/list", map[string]any{"threadId": id, "limit": 1, "sortDirection": "desc", "itemsView": "full"})
if err != nil {
return turnReadback{}, err
}
var page struct {
Data []json.RawMessage `json:"data"`
}
if json.Unmarshal(raw, &page) != nil || page.Data == nil {
return turnReadback{}, errors.New("invalid Codex turn readback")
}
if len(page.Data) == 0 {
return turnReadback{}, nil
}
var current turn
if json.Unmarshal(page.Data[0], &current) != nil {
return turnReadback{}, errors.New("invalid Codex turn readback")
}
return turnReadback{turn: current, digest: sha256.Sum256(page.Data[0])}, nil
}
func activeTurn(t turn) bool { return t.ID != "" && t.Status == "inProgress" }
func terminalTurn(t turn) bool {
return t.ID != "" && (t.Status == "completed" || t.Status == "failed" || t.Status == "interrupted")
}
// A fresh App Server connection may accept turn/start without sending thread
// notifications. Reconcile read-only history instead of thread/resume, which
// can awaken queued goals. Resync requests replace history, never fake deltas.
func (c *Chat) streamWithReadback(ctx context.Context, id string, ready func(), emit func(protocol.ChatEventFrame) error) error {
ch := c.subscribe(id)
defer c.unsubscribe(id, ch)
last, _ := c.latestTurn(ctx, id)
if ready != nil {
ready()
}
if activeTurn(last.turn) {
c.mu.Lock()
c.turns[id] = last.turn.ID
c.mu.Unlock()
c.emit(stepFrame(id, protocol.ChatStepStarted, last.turn.ID))
}
// ThreadItem.contextCompaction has no running/completed field in history;
// never infer running from its presence. A terminal turn can, however,
// authoritatively settle a retained live compaction after a stream reattach.
if terminalTurn(last.turn) {
c.mu.Lock()
matching := c.turns[id] == last.turn.ID
if matching {
delete(c.turns, id)
}
c.mu.Unlock()
if matching {
c.emit(stepFrame(id, protocol.ChatStepEnded, last.turn.ID))
}
}
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return ctx.Err()
case frame, ok := <-ch:
if !ok {
return errors.New("Codex connection closed")
}
if err := emit(frame); err != nil {
return err
}
case <-ticker.C:
current, err := c.latestTurn(ctx, id)
if err != nil {
return err
}
if current.digest == last.digest {
continue
}
c.mu.Lock()
pending := c.starting[id]
expected := c.turns[id]
if pending || (expected != "" && current.turn.ID != "" && expected != current.turn.ID) {
c.mu.Unlock()
continue
}
started := activeTurn(current.turn) && !activeTurn(last.turn)
if activeTurn(current.turn) {
c.turns[id] = current.turn.ID
}
ended := terminalTurn(current.turn) && expected == current.turn.ID
if ended {
delete(c.turns, id)
}
c.mu.Unlock()
last = current
if started {
c.emit(stepFrame(id, protocol.ChatStepStarted, current.turn.ID))
}
c.emit(protocol.ChatEventFrame{SessionID: id, Kind: protocol.ChatEventResync})
if ended {
c.emit(stepFrame(id, protocol.ChatStepEnded, current.turn.ID))
}
}
}
}
// ProbeTurn reports whether the thread's latest turn is still in progress in
// the App Server, which outlives a Pipelines restart. The server uses it once
// at start to resume observing a turn a previous process left running.
func (c *Chat) ProbeTurn(ctx context.Context, id string) (bool, error) {
last, err := c.latestTurn(ctx, id)
if err != nil {
return false, err
}
return activeTurn(last.turn), nil
}