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 }