Files
archie/modules/chat/turn.go
T
samandCopilot cf6108ad14 feat(chat): conversations belong to their person and act with their access (#2065)
Sessions carry an owner; every chat route serves only the caller's own
conversations (others are 404). Each turn and each approved held action
acts as its owner's principal, checked against the access rules before
judgement, so an operator's chat can't do what the operator can't. Chat is
open to any signed-in person, and the stream sends chat updates only to
the owner.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-20 19:05:20 +11:00

392 lines
12 KiB
Go

package chat
import (
"context"
"encoding/json"
"encoding/json/jsontext"
"errors"
"fmt"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"github.com/samcharles93/ai-sdk/chat"
"github.com/samcharles93/ai-sdk/core"
"github.com/samcharles93/archie-core/internal/platform/hub"
"github.com/samcharles93/archie-core/internal/platform/prompts"
"github.com/samcharles93/archie-core/modules/chat/internal/store"
)
const (
// maxConcurrentTurns bounds the conversations answered at once.
maxConcurrentTurns = 4
// historyTurns is how many earlier turns a turn's model sees.
historyTurns = 20
// maxSteps bounds the model calls one turn makes.
maxSteps = 16
// turnTimeout ends a turn that never finishes.
turnTimeout = 10 * time.Minute
// flushEvery is how often streamed text is recorded while it arrives.
flushEvery = 150 * time.Millisecond
poll = 2 * time.Second
)
// Work answers queued turns and settles held actions until ctx ends. Turns a
// stopped process left running are failed first, visibly, since the reply they
// were streaming is gone.
func (m *Module) Work(ctx context.Context) {
m.recover(ctx)
slots := make(chan struct{}, maxConcurrentTurns)
tick := time.NewTicker(poll)
defer tick.Stop()
for {
m.settleActions(ctx)
m.startTurns(ctx, slots)
select {
case <-ctx.Done():
// Wait for the turns in flight to record how they ended.
for range maxConcurrentTurns {
slots <- struct{}{}
}
return
case <-m.wake:
case <-tick.C:
}
}
}
// startTurns starts queued turns while there are free slots.
func (m *Module) startTurns(ctx context.Context, slots chan struct{}) {
for {
select {
case slots <- struct{}{}:
default:
return
}
t, ok, err := m.store.Claim(ctx)
if err != nil || !ok {
<-slots
if err != nil && ctx.Err() == nil {
m.log.ErrorContext(ctx, "claim chat turn", "error", err)
}
return
}
go func() {
defer func() { <-slots; m.poke() }()
m.answer(ctx, t)
}()
}
}
func (m *Module) poke() {
select {
case m.wake <- struct{}{}:
default:
}
}
func (m *Module) recover(ctx context.Context) {
const reason = "Archie restarted before this turn finished. Send it again."
ids, err := m.store.Interrupted(ctx, reason)
if err != nil {
m.log.ErrorContext(ctx, "fail interrupted chat turns", "error", err)
return
}
for _, id := range ids {
m.record(ctx, id, kindError, map[string]any{"text": reason})
}
}
// record stores one streamed event and tells the turn's live readers.
func (m *Module) record(ctx context.Context, turnID uuid.UUID, kind string, data any) {
raw, err := json.Marshal(data)
if err != nil {
m.log.ErrorContext(ctx, "encode chat event", "turn", turnID, "kind", kind, "error", err)
return
}
seq, err := m.store.AddEvent(context.WithoutCancel(ctx), turnID, kind, raw)
if err != nil {
m.log.ErrorContext(ctx, "record chat event", "turn", turnID, "kind", kind, "error", err)
return
}
m.hub.Publish(hub.Note{Topic: topic(turnID), Seq: seq})
}
// answer runs one turn to its end and records how it ended.
func (m *Module) answer(parent context.Context, t store.Turn) {
ctx, cancel := context.WithTimeout(parent, turnTimeout)
defer cancel()
m.mu.Lock()
m.running[t.ID] = cancel
m.mu.Unlock()
defer func() {
m.mu.Lock()
delete(m.running, t.ID)
m.mu.Unlock()
}()
reply, reasoning, err := m.generate(ctx, t)
done := context.WithoutCancel(ctx)
cur, rerr := m.store.Turn(done, m.orgID, t.Owner, t.ID)
stopped := rerr == nil && cur.Cancel
switch {
case stopped:
m.finish(done, t.ID, stateCancelled, reply, reasoning, "")
m.record(done, t.ID, kindCancelled, map[string]any{"text": reply})
case err != nil:
msg := failure(ctx, err)
if parent.Err() != nil {
msg = "Archie stopped before this turn finished. Send it again."
}
m.log.ErrorContext(done, "chat turn failed", "turn", t.ID, "error", err)
m.finish(done, t.ID, stateFailed, reply, reasoning, msg)
m.record(done, t.ID, kindError, map[string]any{"text": msg})
default:
m.finish(done, t.ID, stateSucceeded, reply, reasoning, "")
m.record(done, t.ID, kindDone, map[string]any{"text": reply})
m.title(done, t, reply)
}
}
func (m *Module) finish(ctx context.Context, id uuid.UUID, state, reply, reasoning, failure string) {
if err := m.store.Finish(ctx, id, state, reply, reasoning, failure); err != nil {
m.log.ErrorContext(ctx, "finish chat turn", "turn", id, "error", err)
}
}
// failure is what the operator is told about a failed turn.
func failure(ctx context.Context, err error) string {
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
return fmt.Sprintf("The turn ran for %s without finishing and was stopped.", turnTimeout)
}
return err.Error()
}
// generate streams the model's answer to t, recording every part as it comes,
// and returns the reply and the thinking behind it.
func (m *Module) generate(ctx context.Context, t store.Turn) (string, string, error) {
d, ok := m.uses()
if !ok {
return "", "", errors.New("chat isn't ready yet")
}
ctx, err := m.actingAs(ctx, d, t.Owner)
if err != nil {
return "", "", err
}
model, err := d.Settings.AgentModelForAlias(ctx, "")
if err != nil {
return "", "", fmt.Errorf("no agent model is configured: %w", err)
}
provider, info, err := d.Settings.AgentProvider(ctx, model)
if err != nil {
return "", "", fmt.Errorf("agent model %s: %w", model.Model, err)
}
history, err := m.store.History(ctx, t.SessionID, t.Seq, historyTurns)
if err != nil {
return "", "", err
}
tools := m.tools(d, t)
system := prompts.ChatSystem(prompts.ChatContext{
Tools: toolSummaries(tools), Channel: "dashboard", Page: page(t), Model: model.Model,
SessionID: t.SessionID.String(), Memory: m.memoryBlock(ctx, d), Now: time.Now(),
})
stream, err := core.StreamText(ctx, provider, core.GenerateOptions{
Model: model.Model, ModelInfo: info, System: system, Messages: conversation(history, t),
Tools: tools, MaxSteps: maxSteps,
})
if err != nil {
return "", "", fmt.Errorf("start the reply: %w", err)
}
reply, reasoning, streamErr := m.drain(ctx, t.ID, stream.FullStream)
if _, err := stream.FinishReason(); err != nil && streamErr == nil {
streamErr = err
}
return reply, reasoning, streamErr
}
func page(t store.Turn) string {
switch {
case t.PageLabel != "" && t.Page != "":
return t.PageLabel + " (" + t.Page + ")"
default:
return t.Page
}
}
// conversation is the turns before t and t itself, as model messages.
func conversation(history []store.Turn, t store.Turn) []chat.Message {
out := make([]chat.Message, 0, 2*len(history)+1)
for _, h := range history {
out = append(out, chat.Message{Role: chat.RoleUser, Content: h.Text})
reply := h.Reply
switch {
case h.State == stateFailed && reply == "":
reply = "(this turn failed: " + h.Error + ")"
case h.State == stateCancelled && reply == "":
reply = "(the operator stopped this turn before a reply)"
}
if reply != "" {
out = append(out, chat.Message{Role: chat.RoleAssistant, Content: reply})
}
}
return append(out, chat.Message{Role: chat.RoleUser, Content: t.Text})
}
func (m *Module) memoryBlock(ctx context.Context, d Deps) string {
notes, err := d.Memory.Notes(ctx)
if err != nil {
m.log.WarnContext(ctx, "read memory for chat", "error", err)
return ""
}
lines := make([]string, 0, len(notes))
for _, n := range notes {
lines = append(lines, "- ["+n.ID.String()+"] "+n.Text)
}
return strings.Join(lines, "\n")
}
// pendingCall is a tool call waiting for its result.
type pendingCall struct {
name, parameters string
started time.Time
offset int
}
// drained is what a turn's stream has produced so far. Text and thinking are
// buffered between flushes, so a fast stream isn't one row per token.
type drained struct {
m *Module
turnID uuid.UUID
reply, reasoning strings.Builder
textBuf, thinkBuf strings.Builder
runes int
pending map[string]pendingCall
err error
}
func (s *drained) flush(ctx context.Context) {
if s.thinkBuf.Len() > 0 {
s.m.record(ctx, s.turnID, kindReasoning, map[string]any{"text": s.thinkBuf.String()})
s.thinkBuf.Reset()
}
if s.textBuf.Len() > 0 {
s.m.record(ctx, s.turnID, kindDelta, map[string]any{"text": s.textBuf.String()})
s.textBuf.Reset()
}
}
func (s *drained) take(ctx context.Context, part core.StreamPart) {
switch part.Type {
case core.StreamPartReasoningDelta:
s.reasoning.WriteString(part.ReasoningDelta)
s.thinkBuf.WriteString(part.ReasoningDelta)
case core.StreamPartTextDelta:
s.reply.WriteString(part.TextDelta)
s.textBuf.WriteString(part.TextDelta)
s.runes += utf8.RuneCountInString(part.TextDelta)
case core.StreamPartToolCall:
if c := part.ToolCall; c != nil {
s.pending[c.ToolCallID] = pendingCall{
name: c.ToolName, parameters: summarizeParameters(c.Input), started: time.Now(), offset: s.runes,
}
}
case core.StreamPartToolResult:
if r := part.ToolResult; r != nil {
s.flush(ctx)
call := s.pending[r.ToolCallID]
delete(s.pending, r.ToolCallID)
s.m.record(ctx, s.turnID, kindTool, toolCall(r, call))
}
case core.StreamPartError:
if part.Error != nil {
s.err = part.Error
}
case core.StreamPartAbort:
if s.err == nil {
s.err = context.Canceled
}
}
}
// drain consumes the whole stream, recording reasoning, reply text and each
// finished tool call. The stream's writes are synchronous, so it is read to
// its close whatever happens, or the producer stalls.
func (m *Module) drain(ctx context.Context, turnID uuid.UUID, parts <-chan core.StreamPart) (string, string, error) {
s := &drained{m: m, turnID: turnID, pending: map[string]pendingCall{}}
tick := time.NewTicker(flushEvery)
defer tick.Stop()
for {
select {
case <-tick.C:
s.flush(ctx)
case part, ok := <-parts:
if !ok {
s.flush(ctx)
return s.reply.String(), s.reasoning.String(), s.err
}
s.take(ctx, part)
}
}
}
func toolCall(r *core.ToolResult, call pendingCall) ToolCall {
name := r.ToolName
if name == "" {
name = call.name
}
out := ToolCall{
ID: r.ToolCallID, Name: name, Parameters: call.parameters, Output: truncateRunes(r.Output, outputMaxRunes),
TextOffset: call.offset,
}
if r.Error != "" {
out.Output, out.Failed = truncateRunes(r.Error, outputMaxRunes), true
}
if !call.started.IsZero() {
out.DurationMS = time.Since(call.started).Milliseconds()
}
return out
}
// title names an untitled conversation after its first answered exchange.
// It is a proposal: a failure leaves the conversation untitled.
func (m *Module) title(ctx context.Context, t store.Turn, reply string) {
s, err := m.store.Session(ctx, m.orgID, t.Owner, t.SessionID)
if err != nil || s.Title != "" {
return
}
d, ok := m.uses()
if !ok {
return
}
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
model, err := d.Settings.AgentModelForAlias(ctx, "")
if err != nil {
return
}
provider, info, err := d.Settings.AgentProvider(ctx, model)
if err != nil {
return
}
res, err := core.GenerateText(ctx, provider, core.GenerateOptions{
Model: model.Model, ModelInfo: info, System: prompts.SessionTitle(),
Prompt: "Operator: " + truncateRunes(t.Text, 2000) + "\n\nArchie: " + truncateRunes(reply, 2000),
})
if err != nil {
m.log.WarnContext(ctx, "title chat session", "session", t.SessionID, "error", err)
return
}
title := strings.Trim(strings.TrimSpace(res.Text), `"'.`)
if title == "" || strings.EqualFold(title, "NONE") || utf8.RuneCountInString(title) > 80 {
return
}
if err := m.store.TitleIfUntitled(ctx, m.orgID, t.SessionID, title); err != nil {
m.log.WarnContext(ctx, "title chat session", "session", t.SessionID, "error", err)
}
}
// decodeData reads an event's data into v.
func decodeData(raw jsontext.Value, v any) error { return json.Unmarshal(raw, v) }