6cb61578de
A session was owned by one connection: the claim map in chat_claims.go let the
first client hold it, every other client saw the session Busy and read-only, and
a second client's prompt was rejected. Replace the claim with a per-session
"room" so the operator's phone, tablet and terminal all watch and write the same
conversation, and a pending approval is a shared, exactly-once object.
Server (internal/server, internal/protocol):
- New chat_room.go: one room per session holding the session's single broker
stream, its one bounded prompt queue (8) and the fan-out to every attached
client. A chat_subscribe frame attaches a connection to a session's shared
stream and replays the still-unresolved approval requests the room holds.
- chat_stream.go: handleChatPrompt accepts a prompt from any client. It attaches
the sender, either starts a turn or queues the prompt behind the in-flight turn
and acknowledges it with chat_queued:true ("queued" is the chosen behaviour,
stated on the wire and in docs/cli.md), and echoes the user turn to every other
client attributed to the sender's label. The prompt handler no longer owns the
stream; one turn runner per room drains the queue, so two turns never
interleave. Per-connection write serialisation is unchanged (each chatSub has
its own writer goroutine and bounded buffer).
- chat_permissions.go / chat_commands.go: an approval is reserved by the first
answer and confirmed once delivered; the first answer wins, is recorded with
the answering client's label, and the resolution is pushed to every watching
client as chat_permission with resolved/decision/resolved_by so their cards
clear. A later answer is refused with an error naming the client that answered,
and never reaches the agent twice; a reservation whose reply failed is
released.
- chat_hub.go / chat_sessions.go / chat.go: the hub now owns rooms and the
user-turn id sequence; the resulting user turns are retained (role and client
carried) so a reconnect re-syncs who said what. chat_sessions no longer marks a
session Busy and its clientID parameter is gone; the protocol keeps the Busy
field for wire compatibility only. websocket.go detaches a connection's chat
subscriptions when the read loop ends.
- chat_claims.go is removed, not left vestigial: the only exclusive thing left is
a turn, and the room's queue is that.
App (android):
- PipelinesRepository carries a stable per-device client label (Build.MODEL, with
a fallback) on prompts and replies, and adds chatSubscribe; AppViewModel
subscribes on opening a chat (best-effort, an older server's error frame does
not stop history loading) and records the queued ack.
- ChatStore folds a user frame from another client into the transcript once,
attributed by the sender's label, and never receives its own prompt back, so
the sender's own message is never duplicated. ChatThread.readOnly is gone:
canSend no longer depends on another client, the composer says "Queued - it
will send when the current turn finishes." instead of disabling input, and the
status label is Running/Idle only. Scroll/follow behaviour is untouched.
- Tests: ChatProtocolTest round-trips the new wire fields, ChatFormatTest asserts
the stale Busy flag cannot produce a read-only label, MultiChatStateTest asserts
a session another client watches stays writable.
Reflected where it belongs: no packaged template changes (no bundled starter
embeds the chat protocol). Checked the packaged authoring skill references: none
of them describes the chat wire beyond operations.md, and
internal/author/skill/references/operations.md is now stale - its "Brokered
OpenCode chat" section still says chat_sessions marks "busy" when another client
holds the session and that a second client's chat_prompt is rejected, and it does
not mention chat_subscribe, the per-session prompt queue/chat_queued, the
per-client label or the shared exactly-once approval (it also still describes the
per-subscription permission poller, which the room's single poller replaced). The
supported semantics are the ones in docs/cli.md, updated in this commit; the
operations.md section needs a rewrite to match. No README or other shared
document was edited here.
Checks run on the committed tree: gofmt -l internal cmd examples (nothing), go
build ./..., go vet ./internal/... ./cmd/..., go test ./internal/server
./internal/protocol ./internal/stage ./internal/pipeline.
327 lines
10 KiB
Go
327 lines
10 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"log"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/opencode"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// 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).
|
|
const chatRetainedLimit = opencode.MaxResponse
|
|
|
|
// chatMaxTurns bounds how many sessions retain turn state. A long-lived server
|
|
// cannot accumulate state for every session ever prompted, so the
|
|
// least-recently-updated turn is evicted once the cap is exceeded.
|
|
const chatMaxTurns = 128
|
|
|
|
// chatHub retains the accumulated turn state per session, independently of any
|
|
// single connection, so a reconnecting client can re-sync what it missed. State
|
|
// is keyed by session and then by message id (a session holds many turns), and
|
|
// is capped at chatRetainedLimit. It also owns the per-session live rooms: the
|
|
// one broker stream, the prompt queue and the fan-out to every attached client.
|
|
type chatHub struct {
|
|
mu sync.Mutex
|
|
turns map[string]*chatTurn
|
|
rooms map[string]*chatRoom
|
|
baseCtx context.Context
|
|
registry operatorRegistry
|
|
now func() time.Time
|
|
// userSeq is a monotonic source of ids for the user turns the server echoes
|
|
// to the other clients, so each retained user message has a stable id.
|
|
userSeq int
|
|
}
|
|
|
|
// chatPart is the retained form of one part. Text and reasoning deltas append to
|
|
// text (amortized O(1)); a tool frame replaces part outright.
|
|
type chatPart struct {
|
|
part protocol.ChatPart
|
|
text []byte
|
|
}
|
|
|
|
// chatMessage is one retained turn. Its parts keep the exact ids the supporting
|
|
// chat_event frames carried, so a resume preserves attribution. Role and client
|
|
// are carried for a user turn the server echoed (a prompt another client sent),
|
|
// so a resumed transcript still says who sent it.
|
|
type chatMessage struct {
|
|
id string
|
|
role string
|
|
client string
|
|
order []string
|
|
parts map[string]*chatPart
|
|
}
|
|
|
|
type chatTurn struct {
|
|
sessionID string
|
|
order []string
|
|
messages map[string]*chatMessage
|
|
step *protocol.ChatStep
|
|
usage *protocol.ChatUsage
|
|
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
|
|
// resolutions records the shared exactly-once answers to permission requests,
|
|
// keyed by request id, so a second answer is refused and the recorded outcome
|
|
// survives the clients that gave it; resolutionOrder bounds it to
|
|
// chatPermissionRetainedLimit like the dedup set above.
|
|
resolutions map[string]*chatResolution
|
|
resolutionOrder []string
|
|
}
|
|
|
|
// chatResolution is the shared answer to one permission request. answered is
|
|
// false while the first answer is still being delivered to the agent, so a
|
|
// concurrent second answer is refused without ever reaching the agent twice.
|
|
type chatResolution struct {
|
|
client string
|
|
decision string
|
|
answered bool
|
|
}
|
|
|
|
func newChatHub() *chatHub {
|
|
return &chatHub{turns: map[string]*chatTurn{}, rooms: map[string]*chatRoom{}, baseCtx: context.Background(), now: time.Now}
|
|
}
|
|
|
|
// nextUserMessageID mints a stable id for one echoed user turn.
|
|
func (h *chatHub) nextUserMessageID() string {
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
h.userSeq++
|
|
return "usr_" + strconv.Itoa(h.userSeq)
|
|
}
|
|
|
|
func (h *chatHub) clock() time.Time {
|
|
if h.now != nil {
|
|
return h.now()
|
|
}
|
|
return time.Now()
|
|
}
|
|
|
|
// apply folds one pushed frame into the retained state. Text and reasoning
|
|
// deltas append to their message's part; a tool frame upserts the full part
|
|
// (accounting for its whole size) so the latest lifecycle status, input,
|
|
// content, metadata, error and time are retained under the frame's message id.
|
|
// Step and usage frames update the session's latest progress.
|
|
func (h *chatHub) apply(frame protocol.ChatEventFrame) {
|
|
if frame.SessionID == "" {
|
|
return
|
|
}
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
turn := h.turnLocked(frame.SessionID)
|
|
switch frame.Kind {
|
|
case protocol.ChatEventStep:
|
|
turn.step = frame.Step
|
|
return
|
|
case protocol.ChatEventUsage:
|
|
turn.usage = frame.Usage
|
|
return
|
|
}
|
|
if frame.MessageID == "" {
|
|
return
|
|
}
|
|
message := turn.messages[frame.MessageID]
|
|
if message == nil {
|
|
role := protocol.ChatRoleAssistant
|
|
client := ""
|
|
if frame.Kind == protocol.ChatEventUser {
|
|
role = protocol.ChatRoleUser
|
|
client = frame.Client
|
|
}
|
|
message = &chatMessage{id: frame.MessageID, role: role, client: client, parts: map[string]*chatPart{}}
|
|
turn.order = append(turn.order, frame.MessageID)
|
|
turn.messages[frame.MessageID] = message
|
|
} else if message.client == "" && frame.Kind == protocol.ChatEventUser {
|
|
message.client = frame.Client
|
|
}
|
|
switch frame.Kind {
|
|
case protocol.ChatEventUser:
|
|
if frame.Part == nil || frame.Part.ID == "" || frame.Part.Text == "" || turn.overflow {
|
|
return
|
|
}
|
|
if !turn.retain(len(frame.Part.Text)) {
|
|
return
|
|
}
|
|
part, ok := message.parts[frame.Part.ID]
|
|
if !ok {
|
|
part = &chatPart{part: protocol.ChatPart{Type: protocol.ChatPartText, ID: frame.Part.ID}}
|
|
message.order = append(message.order, frame.Part.ID)
|
|
message.parts[frame.Part.ID] = part
|
|
}
|
|
part.text = append(part.text, frame.Part.Text...)
|
|
case protocol.ChatEventText, protocol.ChatEventReasoning:
|
|
id := ""
|
|
if frame.Part != nil {
|
|
id = frame.Part.ID
|
|
}
|
|
if id == "" || frame.Delta == "" {
|
|
return
|
|
}
|
|
if !turn.retain(len(frame.Delta)) {
|
|
return
|
|
}
|
|
part, ok := message.parts[id]
|
|
if !ok {
|
|
part = &chatPart{part: protocol.ChatPart{Type: frame.Kind, ID: id}}
|
|
message.order = append(message.order, id)
|
|
message.parts[id] = part
|
|
}
|
|
part.text = append(part.text, frame.Delta...)
|
|
case protocol.ChatEventTool:
|
|
if frame.Part == nil || frame.Part.ID == "" || turn.overflow {
|
|
return
|
|
}
|
|
// The tool part is retained whole, so size the complete part (input,
|
|
// content, metadata, error and time) and charge the difference against
|
|
// the cap on every upsert, not just the first-seen name.
|
|
incoming := chatPartBytes(frame.Part)
|
|
part, ok := message.parts[frame.Part.ID]
|
|
if !ok {
|
|
if !turn.retain(incoming) {
|
|
return
|
|
}
|
|
part = &chatPart{}
|
|
message.order = append(message.order, frame.Part.ID)
|
|
message.parts[frame.Part.ID] = part
|
|
} else if previous := chatPartBytes(&part.part); incoming > previous {
|
|
if !turn.retain(incoming - previous) {
|
|
return
|
|
}
|
|
} else {
|
|
turn.shrink(previous - incoming)
|
|
}
|
|
part.part = *frame.Part
|
|
}
|
|
}
|
|
|
|
// chatPartBytes estimates the retained size of a part so the per-session cap
|
|
// accounts for its whole state instead of only the first-seen name. It walks the
|
|
// fields rather than re-marshalling, so the cost matches the bytes it stores.
|
|
func chatPartBytes(part *protocol.ChatPart) int {
|
|
if part == nil {
|
|
return 0
|
|
}
|
|
n := len(part.Type) + len(part.ID) + len(part.Name)
|
|
if part.State == nil {
|
|
return n
|
|
}
|
|
n += len(part.State.Status) + len(part.State.Input)
|
|
for _, content := range part.State.Content {
|
|
n += len(content.Type) + len(content.Text) + len(content.URI) + len(content.Mime) + len(content.Name)
|
|
}
|
|
if part.State.Error != nil {
|
|
n += len(part.State.Error.Type) + len(part.State.Error.Message)
|
|
}
|
|
for key, value := range part.State.Metadata {
|
|
n += len(key)
|
|
if text, ok := value.(string); ok {
|
|
n += len(text)
|
|
} else {
|
|
n += 8
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
// evictLocked drops the least-recently-updated turn when the session cap is
|
|
// reached, keeping retained memory bounded across session churn.
|
|
func (h *chatHub) evictLocked() {
|
|
if len(h.turns) < chatMaxTurns {
|
|
return
|
|
}
|
|
oldestID := ""
|
|
var oldest time.Time
|
|
for id, turn := range h.turns {
|
|
if oldestID == "" || turn.updated.Before(oldest) {
|
|
oldestID, oldest = id, turn.updated
|
|
}
|
|
}
|
|
if oldestID != "" {
|
|
delete(h.turns, oldestID)
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
func (t *chatTurn) retain(n int) bool {
|
|
if t.overflow {
|
|
return false
|
|
}
|
|
if t.size+n > chatRetainedLimit {
|
|
t.overflow = true
|
|
log.Printf("chat session %s retained state exceeds %d bytes; dropping further state", t.sessionID, chatRetainedLimit)
|
|
return false
|
|
}
|
|
t.size += n
|
|
return true
|
|
}
|
|
|
|
// shrink releases n bytes when a tool upsert replaces a larger retained part.
|
|
func (t *chatTurn) shrink(n int) {
|
|
t.size -= n
|
|
if t.size < 0 {
|
|
t.size = 0
|
|
}
|
|
}
|
|
|
|
// snapshot returns the accumulated session as one assistant message per
|
|
// retained message id, with the same stable part ids, or nil when nothing is
|
|
// retained. It is the resume source: a reconnecting client re-syncs the whole
|
|
// session once instead of replaying deltas, and each turn keeps its own id.
|
|
func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage {
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
turn := h.turns[sessionID]
|
|
if turn == nil {
|
|
return nil
|
|
}
|
|
turn.updated = h.clock()
|
|
var messages []protocol.ChatMessage
|
|
for _, id := range turn.order {
|
|
message := turn.messages[id]
|
|
if message == nil || len(message.order) == 0 {
|
|
continue
|
|
}
|
|
out := protocol.ChatMessage{ID: id, SessionID: sessionID, Role: protocol.ChatRoleAssistant}
|
|
if message.role != "" {
|
|
out.Role = message.role
|
|
}
|
|
out.Client = message.client
|
|
for _, partID := range message.order {
|
|
if part, ok := message.parts[partID]; ok {
|
|
piece := part.part
|
|
piece.Text = string(part.text)
|
|
out.Parts = append(out.Parts, piece)
|
|
}
|
|
}
|
|
messages = append(messages, out)
|
|
}
|
|
return messages
|
|
}
|