498c6f17a6
Persist three global ntfy switches in server_settings: run_finished (default on: auto-mode runs notify on success, read inside the transition transaction; on/off modes unchanged), chat_needs_you (default on: gates chat question/approval alerts) and chat_reply_finished (default off: one alert per finished assistant turn). Expose notification_settings / set_notification_settings over the websocket protocol, add a Phone notifications section with Material and Cupertino checkboxes in Settings, document the settings, and keep the cli, tui, stage and pipeline test packages from inheriting a real ntfy configuration.
609 lines
19 KiB
Go
609 lines
19 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
|
|
|
|
// chatShellLimit bounds how many running shells one session retains for replay
|
|
// to a client that reattaches, so a runaway turn cannot grow the retained state
|
|
// without limit. It matches the approval-replay bound.
|
|
const chatShellLimit = 16
|
|
|
|
// 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
|
|
// settings holds the operator's notification choices; nil means defaults.
|
|
settings notificationSettingsStore
|
|
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
|
|
// attentionSeen/attentionOrder are the bounded hub-wide record of forms and
|
|
// approval requests already considered for an ntfy attention notification;
|
|
// attentionWG tracks in-flight publications.
|
|
attentionSeen map[string]struct{}
|
|
attentionOrder []string
|
|
attentionWG sync.WaitGroup
|
|
}
|
|
|
|
// 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
|
|
operationID string
|
|
order []string
|
|
parts map[string]*chatPart
|
|
}
|
|
|
|
type chatTurn struct {
|
|
compaction *protocol.ChatCompaction
|
|
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
|
|
// shells holds the session's still-running shell commands, keyed by the
|
|
// shell id the stream gave them, so a client that reattaches can be re-synced
|
|
// the background processes it cannot have seen. shellOrder preserves start
|
|
// order and bounds the retained set to chatShellLimit; a turn that has
|
|
// finished retains nothing here, so a background process surviving the turn
|
|
// is never mistaken for the turn still running.
|
|
shells map[string]protocol.ChatShell
|
|
shellOrder []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 part (merging
|
|
// the fields it carries onto what is retained, and accounting for the whole
|
|
// size) so the latest lifecycle status, name, input, content, metadata, error and
|
|
// time are retained under the frame's message id and a later frame that omits a
|
|
// field never blanks it. 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()
|
|
h.applyLocked(frame)
|
|
}
|
|
|
|
func (h *chatHub) applyLocked(frame protocol.ChatEventFrame) {
|
|
if frame.SessionID == "" {
|
|
return
|
|
}
|
|
turn := h.turnLocked(frame.SessionID)
|
|
switch frame.Kind {
|
|
case protocol.ChatEventCompaction:
|
|
if frame.Compaction == nil {
|
|
return
|
|
}
|
|
if frame.Compaction.Status == "running" {
|
|
copy := *frame.Compaction
|
|
turn.compaction = ©
|
|
} else if turn.compaction != nil && (frame.Compaction.ID == "" || turn.compaction.ID == frame.Compaction.ID) {
|
|
turn.compaction = nil
|
|
}
|
|
return
|
|
case protocol.ChatEventStep:
|
|
if frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded && !frame.Step.Intermediate {
|
|
turn.compaction = nil
|
|
}
|
|
turn.step = frame.Step
|
|
return
|
|
case protocol.ChatEventUsage:
|
|
turn.usage = cloneChatUsage(frame.Usage)
|
|
return
|
|
case protocol.ChatEventShell:
|
|
// A shell frame carries no message id (it outlives the tool call that
|
|
// started it), so it is folded before the message-id gate below.
|
|
if room := h.rooms[frame.SessionID]; room != nil {
|
|
room.shellReadback.Record(frame.Shell)
|
|
}
|
|
turn.applyShell(frame.Shell)
|
|
return
|
|
case protocol.ChatEventForm:
|
|
// A form/question likewise carries no message id. Keep the pending form
|
|
// for a late subscriber; a resolved or cancelled form removes it.
|
|
if frame.Form == nil || frame.Form.ID == "" {
|
|
return
|
|
}
|
|
if room := h.rooms[frame.SessionID]; room != nil {
|
|
next := room.forms[:0]
|
|
for _, form := range room.forms {
|
|
if form.ID != frame.Form.ID {
|
|
next = append(next, form)
|
|
}
|
|
}
|
|
room.forms = next
|
|
if !frame.Form.Resolved && !frame.Form.Cancelled && len(room.forms) < 8 {
|
|
room.forms = append(room.forms, *frame.Form)
|
|
}
|
|
}
|
|
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, operationID: frame.OperationID, 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
|
|
}
|
|
if message.operationID == "" && frame.Kind == protocol.ChatEventUser {
|
|
message.operationID = frame.OperationID
|
|
}
|
|
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, merged part
|
|
// (input, content, metadata, error and time) and charge the difference
|
|
// against the cap on every upsert, not just the first-seen name.
|
|
part, ok := message.parts[frame.Part.ID]
|
|
if !ok {
|
|
merged := mergeChatToolPart(nil, frame.Part)
|
|
if !turn.retain(chatPartBytes(&merged)) {
|
|
return
|
|
}
|
|
message.order = append(message.order, frame.Part.ID)
|
|
message.parts[frame.Part.ID] = &chatPart{part: merged}
|
|
return
|
|
}
|
|
merged := mergeChatToolPart(&part.part, frame.Part)
|
|
incoming := chatPartBytes(&merged)
|
|
previous := chatPartBytes(&part.part)
|
|
if incoming > previous {
|
|
if !turn.retain(incoming - previous) {
|
|
return
|
|
}
|
|
} else {
|
|
turn.shrink(previous - incoming)
|
|
}
|
|
part.part = merged
|
|
}
|
|
}
|
|
|
|
func cloneChatUsage(usage *protocol.ChatUsage) *protocol.ChatUsage {
|
|
if usage == nil {
|
|
return nil
|
|
}
|
|
copy := *usage
|
|
if usage.TotalTokens != nil {
|
|
value := *usage.TotalTokens
|
|
copy.TotalTokens = &value
|
|
}
|
|
if usage.ContextTokens != nil {
|
|
value := *usage.ContextTokens
|
|
copy.ContextTokens = &value
|
|
}
|
|
if usage.ContextWindow != nil {
|
|
value := *usage.ContextWindow
|
|
copy.ContextWindow = &value
|
|
}
|
|
if usage.CostUSD != nil {
|
|
value := *usage.CostUSD
|
|
copy.CostUSD = &value
|
|
}
|
|
if usage.OutputTokensPerSecond != nil {
|
|
value := *usage.OutputTokensPerSecond
|
|
copy.OutputTokensPerSecond = &value
|
|
}
|
|
return ©
|
|
}
|
|
|
|
// Usage is session state, not an actor step. Replace even on native counter
|
|
// resets; never sum snapshots or derive admission/running state from counters.
|
|
// Enqueue replay under the fold lock, ordered with live usage (no I/O here).
|
|
func (h *chatHub) replayUsage(sub *chatSub) {
|
|
h.mu.Lock()
|
|
slow := false
|
|
if h.rooms[sub.room.sessionID] == sub.room && sub.room.subs[sub.clientID] == sub {
|
|
if turn := h.turns[sub.room.sessionID]; turn != nil && turn.usage != nil {
|
|
frame := protocol.ChatEventFrame{SessionID: sub.room.sessionID, Kind: protocol.ChatEventUsage, Usage: cloneChatUsage(turn.usage)}
|
|
slow = !enqueueChatLocked(sub, protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame})
|
|
}
|
|
}
|
|
h.mu.Unlock()
|
|
if slow {
|
|
sub.close()
|
|
}
|
|
}
|
|
|
|
// applyShell folds one shell frame into the session's retained shells. A running
|
|
// shell is upserted (keyed by its id) so a client that reattaches can be
|
|
// re-synced the processes still running; an exited shell is dropped, which is
|
|
// what clears the indicator. The retained set is bounded both by count
|
|
// (chatShellLimit) and by the same per-session byte cap the other retained state
|
|
// uses, so a long turn with many shells cannot grow it without limit. A shell
|
|
// exit for a shell the session never retained is ignored, so a frame that is not
|
|
// this session's cannot clear another session's process.
|
|
func (t *chatTurn) applyShell(shell *protocol.ChatShell) {
|
|
if shell == nil || shell.ID == "" {
|
|
return
|
|
}
|
|
if shell.Status != protocol.ChatShellRunning {
|
|
old, ok := t.shells[shell.ID]
|
|
if !ok {
|
|
return
|
|
}
|
|
t.shellOrder = removeShellID(t.shellOrder, shell.ID)
|
|
delete(t.shells, shell.ID)
|
|
t.shrink(len(old.Command))
|
|
return
|
|
}
|
|
if t.shells == nil {
|
|
t.shells = map[string]protocol.ChatShell{}
|
|
}
|
|
if _, ok := t.shells[shell.ID]; !ok {
|
|
if !t.retain(len(shell.Command)) {
|
|
return
|
|
}
|
|
t.shellOrder = append(t.shellOrder, shell.ID)
|
|
}
|
|
t.shells[shell.ID] = *shell
|
|
for len(t.shellOrder) > chatShellLimit {
|
|
id := t.shellOrder[0]
|
|
t.shellOrder = t.shellOrder[1:]
|
|
if dropped, ok := t.shells[id]; ok {
|
|
delete(t.shells, id)
|
|
t.shrink(len(dropped.Command))
|
|
}
|
|
}
|
|
}
|
|
|
|
// removeShellID drops id from order, preserving the order of the rest.
|
|
func removeShellID(order []string, id string) []string {
|
|
for i, existing := range order {
|
|
if existing == id {
|
|
return append(order[:i:i], order[i+1:]...)
|
|
}
|
|
}
|
|
return order
|
|
}
|
|
|
|
// mergeChatToolPart folds one tool frame onto the part retained from the frames
|
|
// before it. A tool call is reported across several frames that each carry only
|
|
// part of it — input.started the name, input.ended the arguments as text, called
|
|
// the parsed input, progress metadata, and success the output with no name and no
|
|
// input — so a field the broker already learned is never blanked by a later frame
|
|
// that omits it. A non-empty incoming field wins; otherwise the retained value is
|
|
// kept.
|
|
func mergeChatToolPart(previous, incoming *protocol.ChatPart) protocol.ChatPart {
|
|
if previous == nil {
|
|
return *incoming
|
|
}
|
|
merged := *incoming
|
|
if merged.Type == "" {
|
|
merged.Type = previous.Type
|
|
}
|
|
if merged.Name == "" {
|
|
merged.Name = previous.Name
|
|
}
|
|
merged.Executed = merged.Executed || previous.Executed
|
|
if merged.Time == nil {
|
|
merged.Time = previous.Time
|
|
}
|
|
switch {
|
|
case incoming.State == nil:
|
|
merged.State = previous.State
|
|
case previous.State == nil:
|
|
// The incoming state stands on its own; merged already carries it.
|
|
default:
|
|
state := *incoming.State
|
|
if state.Status == "" {
|
|
state.Status = previous.State.Status
|
|
}
|
|
if len(state.Input) == 0 {
|
|
state.Input = previous.State.Input
|
|
}
|
|
if len(state.Content) == 0 {
|
|
state.Content = previous.State.Content
|
|
}
|
|
if state.Metadata == nil {
|
|
state.Metadata = previous.State.Metadata
|
|
}
|
|
if state.Error == nil {
|
|
state.Error = previous.State.Error
|
|
}
|
|
merged.State = &state
|
|
}
|
|
return merged
|
|
}
|
|
|
|
// 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
|
|
out.OperationID = message.operationID
|
|
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
|
|
}
|
|
|
|
// reconcileHistory applies only the explicit native-id mapping established by a
|
|
// caller-supplied prompt. It never infers identity from text, timestamps,
|
|
// position, ordering or page boundaries.
|
|
func (h *chatHub) reconcileHistory(sessionID string, messages []protocol.ChatMessage) []protocol.ChatMessage {
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
turn := h.turns[sessionID]
|
|
if turn == nil {
|
|
return messages
|
|
}
|
|
byNativeID := make(map[string]*chatMessage)
|
|
for _, message := range turn.messages {
|
|
if message.role == protocol.ChatRoleUser && message.id != "" && message.operationID != "" {
|
|
byNativeID[message.id] = message
|
|
}
|
|
}
|
|
if len(byNativeID) == 0 {
|
|
return messages
|
|
}
|
|
out := make([]protocol.ChatMessage, len(messages))
|
|
copy(out, messages)
|
|
for i := range out {
|
|
if live := byNativeID[out[i].ID]; live != nil {
|
|
out[i].OperationID = live.operationID
|
|
if out[i].Client == "" {
|
|
out[i].Client = live.client
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// shellSnapshot returns the session's still-running shells, in the order they
|
|
// started, so a client attaching to the session's stream can be re-synced the
|
|
// background processes it cannot have seen. It is the shell half of the resume
|
|
// path — the message snapshot cannot carry a shell, because a shell is not a
|
|
// turn — and returns nil when the session has none running. A shell that has
|
|
// exited is not retained, so a stale process is never replayed.
|
|
func (h *chatHub) shellSnapshot(sessionID string) []protocol.ChatShell {
|
|
h.mu.Lock()
|
|
defer h.mu.Unlock()
|
|
turn := h.turns[sessionID]
|
|
if turn == nil || len(turn.shells) == 0 {
|
|
return nil
|
|
}
|
|
shells := make([]protocol.ChatShell, 0, len(turn.shells))
|
|
for _, id := range turn.shellOrder {
|
|
if shell, ok := turn.shells[id]; ok {
|
|
shells = append(shells, shell)
|
|
}
|
|
}
|
|
return shells
|
|
}
|