Files
archie/internal/gateway/chat_local.go
T
sam ff5c27ba72 refactor: remove personas
Personas were a misread requirement: SOUL is the chat identity and
identities are per action. The selected persona's prompt never reached the
model. Drops the resource, /personality, the chat selector, the settings
page and ChatService.SetPersona, and deletes stored persona documents.
2026-10-16 03:57:08 +11:00

340 lines
11 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/taskactions"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/taskstate"
)
// LocalChatAdapter connects the chat boundary to the existing gateway owners.
// Composition configures the Router, including updates and dangerous actions,
// before publishing this adapter to consumers.
type LocalChatAdapter struct {
Router *Router
Sessions SessionStore
Turns *Turns
Models ModelManager
TaskActor ChatTaskActor
// Tasks reads the tasks /stop acts on.
Tasks TaskReader
// VoiceAvailable reports that voice clips are transcribed.
VoiceAvailable bool
}
// TaskReader is the task reads /stop needs.
type TaskReader interface {
TaskByID(ctx context.Context, taskID int64) (*task.Task, error)
ActiveTasksByOrigin(ctx context.Context, origin string) ([]*task.Task, error)
}
var _ ChatContract = (*LocalChatAdapter)(nil)
var ErrChatCapabilityUnavailable = errors.New("chat capability is not configured")
func (a *LocalChatAdapter) Snapshot(ctx context.Context) (ChatSnapshot, error) {
sessions, err := a.Sessions.List(ctx)
if err != nil {
return ChatSnapshot{}, err
}
s := ChatSnapshot{Sessions: sessions, Models: []string{}, Providers: []string{}, ModelsByProvider: map[string][]string{}, CancellationAvailable: a.Turns != nil, VoiceAvailable: a.VoiceAvailable, Version: a.Router.Version}
if a.Models != nil {
s.Models, err = a.Models.ModelsFor(ctx)
if err != nil {
return ChatSnapshot{}, err
}
// Keep the picker available when a previous selection was revoked.
s.ActiveModel, _ = a.Models.ModelFor(ctx)
}
s.ActiveProvider, _, _ = strings.Cut(s.ActiveModel, "/")
for _, model := range s.Models {
provider, _, ok := strings.Cut(model, "/")
if !ok {
continue
}
s.ModelsByProvider[provider] = append(s.ModelsByProvider[provider], model)
}
for provider := range s.ModelsByProvider {
s.Providers = append(s.Providers, provider)
}
slices.Sort(s.Providers)
return s, nil
}
func (a *LocalChatAdapter) GetSession(ctx context.Context, id string) (SessionContext, bool, error) {
session, err := a.Sessions.Get(ctx, id)
if err != nil || session == nil {
return SessionContext{}, false, err
}
return *session, true, nil
}
func (a *LocalChatAdapter) RecentMessages(ctx context.Context, id string, n int) ([]messaging.Message, error) {
stored, err := a.Sessions.RecentMessages(ctx, id, n)
if err != nil {
return nil, err
}
// A snapshot, and non-nil even when the session is empty: the contract
// promises callers a slice they own, and an empty history renders as []
// rather than null.
out := make([]messaging.Message, 0, len(stored))
return append(out, stored...), nil
}
func (a *LocalChatAdapter) RecentTurns(ctx context.Context, id string, n int) ([]TurnRecord, error) {
if history, ok := a.Sessions.(TurnHistory); ok {
return history.RecentTurns(ctx, id, n)
}
return []TurnRecord{}, nil
}
func (a *LocalChatAdapter) Route(ctx context.Context, in Inbound) (ChatReply, error) {
reply, rateLimited, err := a.Router.RouteResult(ctx, in)
if err != nil {
return ChatReply{}, err
}
id, err := a.Router.ResolveSessionKey(ctx, in)
return ChatReply{Text: reply, SessionID: id, RateLimited: rateLimited}, err
}
func (a *LocalChatAdapter) Cancel(ctx context.Context, id string) (ChatCancellation, error) {
if err := ctx.Err(); err != nil {
return ChatCancellation{}, err
}
if a.Turns == nil {
return ChatCancellation{}, ErrChatCapabilityUnavailable
}
cancelled, dropped := a.Turns.Stop(id)
return ChatCancellation{Cancelled: cancelled, Dropped: dropped}, nil
}
func (a *LocalChatAdapter) StopTasks(ctx context.Context, origin string, taskID int64) ([]int64, error) {
if a.TaskActor == nil || a.Tasks == nil {
return nil, ErrChatCapabilityUnavailable
}
var targets []*task.Task
if taskID != 0 {
t, err := a.Tasks.TaskByID(ctx, taskID)
if err != nil {
return nil, err
}
if t == nil {
return nil, fmt.Errorf("task %d not found", taskID)
}
targets = []*task.Task{t}
} else {
active, err := a.Tasks.ActiveTasksByOrigin(ctx, origin)
if err != nil {
return nil, err
}
targets = active
}
identity := a.Router.Identity
var stopped []int64
var errs []error
for _, t := range targets {
action, ok := haltAction(t.Status)
if !ok {
errs = append(errs, fmt.Errorf("task %d is %s, not running or queued", t.ID, t.Status))
continue
}
if _, err := a.TaskActor.ApplyChatTaskAction(ctx, &identity, taskactions.ActorFromScope(identity), t.ID, action, taskactions.ActionPayload{}); err != nil {
errs = append(errs, fmt.Errorf("task %d: %w", t.ID, err))
continue
}
stopped = append(stopped, t.ID)
}
return stopped, errors.Join(errs...)
}
// haltAction is how /stop ends a task: a running one is stopped, keeping its
// recoverable work parked; a queued one is cancelled before it starts.
func haltAction(status string) (taskstate.Action, bool) {
switch status {
case taskstate.Running:
return taskstate.ActionStop, true
case taskstate.Queued:
return taskstate.ActionCancel, true
default:
return "", false
}
}
func (a *LocalChatAdapter) ApplyTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action, res taskactions.ActionPayload) (TaskActionResult, error) {
if a.TaskActor == nil {
return TaskActionResult{}, ErrChatCapabilityUnavailable
}
return a.TaskActor.ApplyChatTaskAction(ctx, &identity, taskactions.ActorFromScope(identity), taskID, action, res)
}
func (a *LocalChatAdapter) ApplyOperatorTaskAction(ctx context.Context, actor taskactions.Actor, taskID int64, action taskstate.Action, res taskactions.ActionPayload) (TaskActionResult, error) {
if a.TaskActor == nil {
return TaskActionResult{}, ErrChatCapabilityUnavailable
}
return a.TaskActor.ApplyChatTaskAction(ctx, nil, actor, taskID, action, res)
}
func (a *LocalChatAdapter) Stream(ctx context.Context, in Inbound) (<-chan ChatEvent, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
id, err := a.Router.ResolveSessionKey(ctx, in)
if err != nil {
return nil, err
}
events := make(chan ChatEvent, 32)
go a.stream(ctx, in, id, events)
return events, nil
}
func (a *LocalChatAdapter) stream(ctx context.Context, in Inbound, id string, events chan ChatEvent) {
defer close(events)
started := a.prelude(ctx, in, id)
if started.event != nil {
events <- *started.event
return
}
if !started.proceeds {
// A covered fragment: the batch's turn runs on the call that
// dispatched it. This caller contributes its text to that turn and
// renders nothing of its own -- not even the started event, which
// announces a turn that does not exist here.
return
}
in = started.ready
// started announces the turn that runs; it comes after the gates and
// the batch, and always before the first delta or the terminal event.
events <- ChatEvent{Kind: "started", SessionID: id}
a.runStreamedTurn(ctx, in, id, events)
}
// runStreamedTurn runs one prepared turn on its session lane and pumps its
// events to the caller. The terminal event comes after every queued event.
func (a *LocalChatAdapter) runStreamedTurn(ctx context.Context, in Inbound, id string, events chan ChatEvent) {
pending := make(chan ChatEvent, 32)
stream := localChatStream{done: ctx.Done(), events: pending, sessionID: id}
run := func(turnCtx context.Context) ChatEvent {
reply, err := a.Router.streamTurn(turnCtx, in, stream)
if err != nil {
return ChatEvent{Kind: "error", Text: err.Error(), SessionID: id}
}
resolvedID := id
if resolved, err := a.Router.ResolveSessionKey(ctx, in); err == nil {
resolvedID = resolved
}
return ChatEvent{Kind: "done", Text: reply, SessionID: resolvedID}
}
result := make(chan ChatEvent, 1)
if a.Turns == nil {
go func() { result <- run(ctx) }()
} else {
a.Turns.Submit(ctx, id, func(turnCtx context.Context) { result <- run(turnCtx) })
}
a.pumpTurnEvents(ctx, id, events, pending, result)
}
// pumpTurnEvents streams one turn's events into its caller's channel: every
// delta and tool event as it arrives, then the terminal event after them.
// A caller whose context ends mid-stream has stopped the turn, and the lane
// it occupies is stopped so the turn cannot keep running unobserved.
func (a *LocalChatAdapter) pumpTurnEvents(ctx context.Context, id string, events chan ChatEvent, pending, result <-chan ChatEvent) {
emit := func(event ChatEvent) {
select {
case events <- event:
case <-ctx.Done():
}
}
for {
select {
case event := <-pending:
emit(event)
case terminal := <-result:
for {
select {
case event := <-pending:
emit(event)
default:
emit(terminal)
return
}
}
case <-ctx.Done():
if a.Turns != nil {
a.Turns.Stop(id)
}
return
}
}
}
// streamPrelude is what one streamed caller's turn is before any turn
// exists: render a terminal event and stop, render nothing, or dispatch.
type streamPrelude struct {
// event is the terminal event the caller's stream renders when no turn
// exists for it: a gate's prose or the batch's collection error. nil on
// every path that proceeds.
event *ChatEvent
// ready is the payload the turn dispatches, and stays zero for every
// caller whose stream renders no turn.
ready Inbound
// proceeds reports whether this caller dispatches the turn. A covered
// fragment does not: it contributes only text to the dispatcher's turn,
// so it renders nothing -- not even the started event, which announces
// a turn that does not exist here.
proceeds bool
}
// prelude runs the per-message gates and the text batcher for one streamed
// fragment, before the session lane, and returns what this stream does next.
func (a *LocalChatAdapter) prelude(ctx context.Context, in Inbound, id string) streamPrelude {
if a.Router.duplicateDelivery(in) {
return streamPrelude{event: &ChatEvent{Kind: "done", Text: dedupReply, SessionID: id}}
}
if a.Router.checkRateLimit(in) {
return streamPrelude{event: &ChatEvent{Kind: "done", Text: rateLimitReply, SessionID: id}}
}
ready, mine, err := a.Router.CollectTurn(ctx, in)
if err != nil {
return streamPrelude{event: &ChatEvent{Kind: "error", Text: err.Error(), SessionID: id}}
}
return streamPrelude{ready: ready, proceeds: mine}
}
// localChatStream is the TurnStream piped into the router for one streamed
// turn; its events move to the caller's channel below.
type localChatStream struct {
done <-chan struct{}
events chan<- ChatEvent
sessionID string
}
func (s localChatStream) send(event ChatEvent) {
event.SessionID = s.sessionID
select {
case s.events <- event:
case <-s.done:
}
}
func (s localChatStream) Delta(text string) {
s.send(ChatEvent{Kind: "delta", Text: text})
}
func (s localChatStream) ToolCall(event ToolCallEvent) {
s.send(ChatEvent{Kind: "tool", Tool: event})
}
func (s localChatStream) Media(event MediaEvent) {
s.send(ChatEvent{Kind: "media", Media: event})
}