Files
coder/coderd/x/chatd/runner.go
T
Mathias Fredriksson c0f7663e95 feat: support editing queued chat messages (#29215)
The owner of a chat can edit a queued message through
`PATCH /api/v2/chats/{chat}/queue/{queuedMessage}`. chatd never sends
a row under edit (`editing_since`): rows ahead of it still send in
order, and a turn that ends at it puts the chat in the new `paused`
status. Ending the head's edit, deleting it, or promoting a queued row
continues the chat. Interrupting sends still run ahead of the queue.

The chat state machine classifies a queue whose head is under edit as
its own sub-state (R1P, I1P, A1P, E1P, XE1P, P), so every path to
`paused` is in the transition matrix. A chat whose family has a paused
member cannot be archived, and auto-archive skips that family. Queue
edit and delete are owner-only, because both can send the next message
with the owner's credentials.

`ChatQueuedMessage` gains `editing_since` and `reasoning_effort`, and
`ChatStatus` gains `paused`.

Closes CODAGT-1028
Refs CODAGT-971
2026-10-30 15:52:22 +02:00

337 lines
9.0 KiB
Go

package chatd
import (
"context"
"errors"
"sync"
"github.com/google/uuid"
"golang.org/x/xerrors"
"github.com/coder/coder/v2/coderd/database"
coderdpubsub "github.com/coder/coder/v2/coderd/pubsub"
)
type taskKind string
const (
taskKindGeneration taskKind = "generation"
taskKindInterrupt taskKind = "interrupt"
taskKindRequiresActionTimeout taskKind = "requires_action_timeout"
taskKindAbandon taskKind = "abandon"
)
type taskInstanceID uuid.UUID
type localWorkKey struct {
historyVersion int64
status database.ChatStatus
}
type taskRecord struct {
cancel context.CancelFunc
done <-chan struct{}
}
type runner struct {
ctx context.Context
mgr *runnerManager
rec *runnerRecord
opts chatWorkerOptions
lastSnapshotVersion int64
hasAcceptedState bool
latestState runnerStateUpdate
activeTaskID taskInstanceID
activeTaskSet bool
tasks map[taskInstanceID]*taskRecord
localLocks *localLockSet
debugTurn *runnerDebugTurn
turnSpan *runnerTurnSpan
sessionStart sessionStartTracker
stopNudges stopNudgeTracker
}
func newRunner(ctx context.Context, mgr *runnerManager, rec *runnerRecord, opts chatWorkerOptions) *runner {
return &runner{
ctx: ctx,
mgr: mgr,
rec: rec,
opts: opts,
tasks: make(map[taskInstanceID]*taskRecord),
localLocks: newLocalLockSet(),
debugTurn: newRunnerDebugTurn(opts.Logger),
turnSpan: newRunnerTurnSpan(mgr.server.stages, rec.takenOver),
}
}
func (r *runner) run() {
if !r.bootstrap() {
return
}
for {
select {
case state := <-r.rec.stateCh:
r.processState(state)
case <-r.ctx.Done():
r.cancelActiveTask()
r.waitForTasks()
r.closeDebugTurn()
r.turnSpan.End(nil)
return
}
}
}
func (r *runner) bootstrap() bool {
channel := coderdpubsub.ChatStateUpdateChannel(r.rec.key.ChatID)
unsubscribe, err := r.opts.Pubsub.SubscribeWithErr(channel, coderdpubsub.HandleChatStateUpdate(
func(ctx context.Context, payload coderdpubsub.ChatStateUpdateMessage, err error) {
if err != nil {
r.opts.Logger.Warn(ctx, "chatworker state update decode failed", slogError(err))
return
}
r.mgr.RouteStateHint(ctx, stateUpdateFromPubsub(r.rec.key.ChatID, payload))
},
))
if err != nil {
r.mgr.requestCleanup(r.ctx, r.rec.key)
return false
}
if !r.rec.setUnsubscribe(unsubscribe) {
return false
}
chat, err := r.opts.Store.GetChatByID(r.ctx, r.rec.key.ChatID)
if err != nil {
r.opts.Logger.Warn(r.ctx, "chatworker runner bootstrap failed", slogError(err))
r.mgr.requestCleanup(r.ctx, r.rec.key)
return false
}
// Apply the database snapshot directly instead of routing it through
// the manager. Routing fans out through stateCh, where a stale hint
// (for example the pre-acquisition chat:update relayed by another
// runner's subscription) could be processed first while
// lastSnapshotVersion is still zero. A stale unowned hint would make
// the runner clean itself up without abandoning the chat, leaving the
// chat owned by a dead runner until its heartbeat goes stale.
// Processing the snapshot here seeds lastSnapshotVersion before the
// run loop drains stateCh, so the dedup in processState drops every
// hint at or below this version regardless of delivery path.
r.processState(stateUpdateFromChat(chat))
return true
}
func stateUpdateFromPubsub(chatID uuid.UUID, payload coderdpubsub.ChatStateUpdateMessage) runnerStateUpdate {
return runnerStateUpdate{
ChatID: chatID,
WorkerID: payload.WorkerID,
RunnerID: payload.RunnerID,
SnapshotVersion: payload.SnapshotVersion,
HistoryVersion: payload.HistoryVersion,
QueueVersion: payload.QueueVersion,
GenerationAttempt: payload.GenerationAttempt,
Status: database.ChatStatus(payload.Status),
Archived: payload.Archived,
}
}
func (r *runner) processState(state runnerStateUpdate) {
if state.SnapshotVersion <= r.lastSnapshotVersion {
return
}
r.removeFinishedTasks()
if !uuidPtrEqual(state.WorkerID, r.rec.workerID) || !uuidPtrEqual(state.RunnerID, r.rec.key.RunnerID) {
r.acceptState(state)
r.mgr.requestCleanup(r.ctx, r.rec.key)
return
}
changed := !r.hasAcceptedState ||
r.latestState.HistoryVersion != state.HistoryVersion ||
r.latestState.Status != state.Status ||
r.latestState.Archived != state.Archived
if !changed {
r.acceptState(state)
return
}
r.cancelActiveTask()
r.spawnForState(state)
r.acceptState(state)
}
func (r *runner) acceptState(state runnerStateUpdate) {
r.hasAcceptedState = true
r.latestState = state
r.lastSnapshotVersion = state.SnapshotVersion
}
func (r *runner) spawnForState(state runnerStateUpdate) {
if state.Archived {
r.spawnTask(taskKindAbandon, state)
return
}
switch state.Status {
case database.ChatStatusRunning:
r.spawnTask(taskKindGeneration, state)
case database.ChatStatusInterrupting:
r.spawnTask(taskKindInterrupt, state)
case database.ChatStatusRequiresAction:
r.spawnTask(taskKindRequiresActionTimeout, state)
case database.ChatStatusWaiting, database.ChatStatusError, database.ChatStatusPaused:
r.spawnTask(taskKindAbandon, state)
default:
r.spawnTask(taskKindAbandon, state)
}
}
func (r *runner) spawnTask(kind taskKind, state runnerStateUpdate) {
key := localWorkKey{historyVersion: state.HistoryVersion, status: state.Status}
id := taskInstanceID(uuid.New())
taskCtx, cancel := context.WithCancel(r.ctx)
done := make(chan struct{})
r.tasks[id] = &taskRecord{cancel: cancel, done: done}
r.activeTaskID = id
r.activeTaskSet = true
input := chatWorkerTaskStartInput{
TaskID: uuid.UUID(id),
ChatID: r.rec.key.ChatID,
WorkerID: r.rec.workerID,
RunnerID: r.rec.key.RunnerID,
HistoryVersion: state.HistoryVersion,
GenerationAttempt: state.GenerationAttempt,
Status: state.Status,
RequiresActionDeadlineAt: state.RequiresActionDeadlineAt,
DebugTurn: r.debugTurn,
TurnSpan: r.turnSpan,
SessionStart: &r.sessionStart,
StopNudges: &r.stopNudges,
}
go r.runTask(taskCtx, kind, key, input, done)
}
func (r *runner) runTask(
ctx context.Context,
kind taskKind,
key localWorkKey,
input chatWorkerTaskStartInput,
done chan<- struct{},
) {
defer close(done)
// Runs before close(done), after every stage the task started ended.
defer input.TurnSpan.Release(input.TaskID)
taskInfo := retryWrapperTaskInfo{
ChatID: input.ChatID,
WorkerID: input.WorkerID,
RunnerID: input.RunnerID,
}
err := runTaskWithRetry(ctx, r.opts.retryOptions(), kind, taskInfo, func(ctx context.Context) error {
unlock, ok := r.localLocks.acquire(ctx, key)
if !ok {
return errors.Join(errTaskExpectedExit, xerrors.Errorf("runTask acquire local lock: %w", ctx.Err()))
}
defer unlock()
if ctx.Err() != nil {
return errors.Join(errTaskExpectedExit, xerrors.Errorf("runTask context canceled: %w", ctx.Err()))
}
switch kind {
case taskKindGeneration:
return r.opts.TaskStarter.StartGeneration(ctx, input)
case taskKindInterrupt:
return r.opts.TaskStarter.StartInterrupt(ctx, input)
case taskKindRequiresActionTimeout:
return r.opts.TaskStarter.StartRequiresActionTimeout(ctx, input)
case taskKindAbandon:
return r.opts.TaskStarter.StartAbandon(ctx, input)
default:
return errors.Join(errTaskExpectedExit, xerrors.Errorf("unknown task kind %q", kind))
}
})
if err != nil && ctx.Err() == nil {
r.opts.Logger.Warn(ctx, "chatworker task failed", slogError(err))
}
}
func (r *runner) cancelActiveTask() {
if !r.activeTaskSet {
return
}
id := r.activeTaskID
r.activeTaskSet = false
if record := r.tasks[id]; record != nil {
record.cancel()
}
}
func (r *runner) waitForTasks() {
for _, record := range r.tasks {
<-record.done
}
}
func (r *runner) closeDebugTurn() {
if r.debugTurn == nil {
return
}
ctx, cancel := context.WithTimeout(context.WithoutCancel(r.ctx), debugFinalizeTimeout)
defer cancel()
r.debugTurn.Finalize(ctx)
}
func (r *runner) removeFinishedTasks() {
for id, record := range r.tasks {
select {
case <-record.done:
delete(r.tasks, id)
if r.activeTaskSet && r.activeTaskID == id {
r.activeTaskSet = false
}
default:
}
}
}
func uuidPtrEqual(got *uuid.UUID, want uuid.UUID) bool {
return got != nil && *got == want
}
type localLockSet struct {
mu sync.Mutex
locked map[localWorkKey]chan struct{}
}
func newLocalLockSet() *localLockSet {
return &localLockSet{locked: make(map[localWorkKey]chan struct{})}
}
func (l *localLockSet) acquire(ctx context.Context, key localWorkKey) (func(), bool) {
for {
l.mu.Lock()
wait, ok := l.locked[key]
if !ok {
released := make(chan struct{})
l.locked[key] = released
l.mu.Unlock()
return func() {
l.mu.Lock()
if l.locked[key] == released {
delete(l.locked, key)
close(released)
}
l.mu.Unlock()
}, true
}
l.mu.Unlock()
select {
case <-wait:
case <-ctx.Done():
return nil, false
}
}
}