package acp import ( "context" "encoding/json" "errors" "fmt" "slices" "strconv" "strings" "sync" "time" "albedo/cli/internal/app" "albedo/cli/internal/daemon" "albedo/cli/internal/daemon/protocol" ) // streamFunc subscribes to one session's events and calls subscribed once the // response is accepted. type streamFunc func(context.Context, func(daemon.StreamEvent) error, func()) error type session struct { sessionState reconciler bufferFailure error ctx context.Context client *daemon.ChatClient watch streamFunc replayCancel context.CancelFunc ready <-chan struct{} adapter *adapter stop context.CancelFunc settings app.ACPSettings compactionEnabled bool id string cursor protocol.Cursor buffered []daemon.StreamEvent lease protocol.ACPLease historyCutoff int64 bufferedBytes int mu sync.Mutex usage usageState } func newSession(a *adapter, attachment protocol.ACPAttachment) *session { ctx, cancel := context.WithCancel(a.ctx) current := &session{ adapter: a, ctx: ctx, stop: cancel, id: attachment.SessionID, cursor: attachment.Cursor, client: a.backend.Observer(attachment.SessionID, attachment.Cursor), lease: attachment.Lease, historyCutoff: attachment.HistoryCutoff, reconciler: newReconciler(), watch: a.watch, } if current.watch == nil { current.watch = current.client.StreamSubscribed } current.inherited = slices.Clone(attachment.PendingInputIDs) if attachment.ActiveTurn != nil { current.turn = attachment.ActiveTurn.TurnID if attachment.ActiveTurn.AcpInputID != nil { current.inherited = append(current.inherited, *attachment.ActiveTurn.AcpInputID) } } for _, boundary := range attachment.OutputBoundaries { if len(boundary.LiveID) > maxReconciliationIDBytes { current.fail("Output identity exceeds reconciliation limit") break } current.boundaries[boundary.LiveID] = boundary.UTF8Bytes current.limitReconciliation() if current.observation == lost { break } } current.limitReconciliation() return current } func (s *session) start() { ready := make(chan struct{}) s.ready = ready subscribed := sync.OnceFunc(func() { close(ready) }) go func() { err := s.watch(s.ctx, func(event daemon.StreamEvent) error { s.mu.Lock() defer s.mu.Unlock() return s.consumeLocked(event) }, subscribed) if s.ctx.Err() == nil { s.mu.Lock() s.fail(fmt.Sprintf("Session stream ended: %v", err)) s.mu.Unlock() } // A load waits for this stream; a stream that failed before it was // accepted must answer that wait with the failure instead of nothing. subscribed() }() go func() { interval := time.Duration(s.lease.HeartbeatMs) * time.Millisecond if interval <= 0 { interval = 5 * time.Second } lease := time.Duration(s.lease.LeaseMs) * time.Millisecond renewed := time.Now() timer := time.NewTicker(interval) defer timer.Stop() for { select { case <-s.ctx.Done(): return case <-timer.C: err := s.adapter.backend.Renew(s.ctx, s.id) if err == nil { renewed = time.Now() continue } api, refused := errors.AsType[*daemon.APIError](err) if (refused && api.Code == "attachment_lost") || time.Since(renewed) >= lease { s.mu.Lock() s.fail("The attachment was lost; resume the session") s.mu.Unlock() return } } } }() } func (s *session) prompt(message request, blocks []json.RawMessage) { s.mu.Lock() defer s.mu.Unlock() if isCompactPrompt(blocks) { effects, refusal := s.sessionState.acceptCompact(message) s.runOrRefuse(message, effects, refusal) return } effects, refusal := s.sessionState.acceptPrompt(message, blocks) s.runOrRefuse(message, effects, refusal) } func (s *session) runOrRefuse(message request, effects []effect, refusal *rpcError) { if refusal != nil { s.adapter.respond(message.ID, nil, refusal) return } s.runEffects(effects) } func (s *session) admit(a *activity) { handle, err := s.adapter.backend.Prepare(s.id, a.blocks) if err != nil { s.runEffects(s.sessionState.submitted(a, err)) return } a.handle = handle s.runEffects([]effect{submitEffect{activity: a}}) } func (s *session) cancelPrompt() { s.mu.Lock() defer s.mu.Unlock() s.runEffects(s.sessionState.cancel()) } func (s *session) cancelInput(id string, a *activity) { go func() { receipt, err := s.adapter.backend.Cancel(s.ctx, s.id, id) s.mu.Lock() defer s.mu.Unlock() s.runEffects(s.sessionState.cancelled(id, a, err, receipt)) }() } func removeID(ids []string, id string) []string { return slices.DeleteFunc(ids, func(value string) bool { return value == id }) } func (s *session) fail(message string) { s.runEffects(s.sessionState.markLost("observation_uncertain", message)) } func (s *session) turnPendingLocked() bool { return s.sessionState.turnPending() } func (s *session) compact(a *activity) { ctx, cancel := context.WithTimeout(s.ctx, 195*time.Second) defer cancel() result, err := s.adapter.backend.Compact(ctx, s.id) s.mu.Lock() defer s.mu.Unlock() enabled := s.compactionEnabled s.runEffects(s.sessionState.completeCompact(a, result, err, s.id, enabled)) } func (s *session) advertiseCommands() { s.update(commandsUpdate{ Kind: updateCommands, Commands: []command{{ Name: compactCommand, Description: "Compact this session's context and keep a summary", }}, }) } func (s *session) usageLocked(info *daemon.Usage) { generation, fetch := s.usage.add(info) if s.usage.window.phase == windowKnown { s.emitUsage(s.usage.take()) } if fetch { s.runEffects([]effect{fetchWindowEffect{generation: generation}}) } } func (s *session) fetchContextWindow(generation int) { ctx, cancel := context.WithTimeout(s.ctx, 10*time.Second) defer cancel() window, err := s.client.ContextWindow(ctx) s.mu.Lock() defer s.mu.Unlock() if s.ctx.Err() != nil { return } var tokens *int if err == nil { tokens = window } s.emitUsage(s.usage.resolve(tokens, generation)) } func (s *session) emitUsage(pending []*daemon.Usage) { for _, info := range pending { s.update(usageOf(info, s.usage.window.tokens)) } } func usageOf(info *daemon.Usage, window int) usageUpdate { update := usageUpdate{Kind: updateUsage, Size: window, Used: usedTokens(info)} if window > 0 && update.Used > window { update.Used = window } if info.Spent != nil && info.Spent.Usd >= 0 { currency := currencyUSD if info.Spent.Basis == daemon.BasisCounted { currency = currencyCredits } update.Cost = &cost{Amount: info.Spent.Usd, Currency: currency} } return update } func usedTokens(info *daemon.Usage) int { switch { case info.PromptTokens != nil && *info.PromptTokens >= 0: return *info.PromptTokens case info.TotalTokens != nil && *info.TotalTokens >= 0: return *info.TotalTokens case info.Size != nil && info.Size.Tokens >= 0: return info.Size.Tokens } return 0 } func (s *session) compacted(event daemon.StreamEvent) { if !s.compactionEnabled || !event.Replayed && event.Sequence == 0 { return } update := compactionUpdate{Kind: updateCompaction, ID: s.compactionID(event), Status: compactionCompleted} if summary := strings.TrimSpace(event.Summary); summary != "" { const maxSummary = 128 * 1024 if len(summary) > maxSummary { summary = boundedText(summary, maxSummary) + "\n[albedo: compaction summary truncated]" } update.Summary = []textBlock{textContent(summary)} } s.update(update) } func (s *session) runEffects(effects []effect) { for _, item := range effects { item.apply(s) } } func (s *session) compactionID(event daemon.StreamEvent) string { if event.Replayed { if event.EntryID != "" { return "acp-compaction-entry-" + event.EntryID } return "acp-compaction-position-" + strconv.FormatInt(event.Position, 10) } id := "acp-compaction-" if s.cursor.Generation != "" { id += s.cursor.Generation + "-" } return id + strconv.FormatInt(event.Sequence, 10) } func (s *session) finishWithBarrier(item finishEffect) { barrier, err := s.adapter.writer.enqueue(s.adapter.response(item.request.ID, item.result, item.failure), true) if err != nil { s.adapter.cancel() return } a := item.activity go func() { select { case <-barrier: case <-s.ctx.Done(): return case <-s.adapter.writer.done: return } s.mu.Lock() defer s.mu.Unlock() s.runEffects(s.sessionState.responseWritten(a)) }() } func (s *session) submit(a *activity) { go func() { select { case <-s.ready: case <-s.ctx.Done(): return } err := s.adapter.backend.Submit(s.ctx, a.handle) s.mu.Lock() defer s.mu.Unlock() s.runEffects(s.sessionState.submitted(a, err)) }() } func (s *session) observe(event daemon.StreamEvent) { if s.ctx.Err() != nil || s.observation == lost || event.Replayed { return } for _, id := range []string{event.MessageID, event.EntryID, event.ProgressCallID} { if len(id) > maxReconciliationIDBytes { s.fail("Output identity exceeds reconciliation limit") return } } defer s.limitReconciliation() if event.Type == daemon.EventReset { if s.reconcileReset(event.Snapshot) { return } s.fail("The session stream reset; resume required") return } if event.Sequence > 0 { s.cursor.Sequence = event.Sequence } if event.SnapshotOrigin { return } if event.Type == daemon.EventUsage { s.usageLocked(event.Usage) return } if event.Type == daemon.EventCompacted { s.compacted(event) return } if s.active != nil && s.active.phase == activityFinishing { return } if s.active != nil && s.active.handle != nil && event.OperationID == s.active.handle.ID() && event.Receipt != nil && event.Receipt.Admission == admissionAccepted { s.runEffects(s.sessionState.admitted(s.active)) } if event.Type == daemon.EventTurnMembership { s.runEffects(s.sessionState.turnMembership(event.TurnID, event.SubmissionIDs)) } if s.turn == "" || event.TurnID != "" && event.TurnID != s.turn { return } switch event.Type { case daemon.EventText, daemon.EventThinking: if event.EntryID != "" { s.durableMessage(event) return } s.live[event.MessageID] = appendPrefix(s.live[event.MessageID], event.Text) if len(s.withheld) > 0 { s.withheld[event.MessageID] = true return } kind := updateAgentChunk if event.Type == daemon.EventThinking { kind = updateThoughtChunk } s.chunk(kind, event.MessageID, event.Text) case daemon.EventMessage: s.durableMessage(event) case daemon.EventToolProgress: if event.Progress == nil { return } id := event.Progress.CallID switch s.tools[id] { case toolUnseen: s.announceTool(id, event.Progress.Name, event.Progress.Title) case toolAnnounced: s.update(progressedTool(id)) case toolCompleted: } case daemon.EventTool: if event.ProgressCallID == "" || !settled(event.ToolStatus) { s.fail("Missing durable tool outcome") return } s.finishTool(event) case daemon.EventError: reason := event.Code if reason == "" { reason = "turn_failed" } s.failure = problem(-32603, reason, event.Text) case daemon.EventRetry: s.failure = nil case daemon.EventCommitted: for _, id := range event.ReplacesLiveIDs { delete(s.live, id) delete(s.boundaries, id) delete(s.withheld, id) } if event.ReplacesAllLive { clear(s.live) clear(s.boundaries) clear(s.withheld) } case daemon.EventTurnCompleted: s.runEffects(s.sessionState.turnCompleted(event.TurnID, event.SubmissionIDs, event.Outcome)) } } const admissionAccepted = "accepted" // subscribeTimeout bounds how long session/load waits for its event stream to // be accepted. A stream that neither subscribes nor fails would otherwise leave // the request unanswered for as long as the editor stays connected. const subscribeTimeout = 30 * time.Second