Files
archie/internal/gateway/chat_local.go
T
sam 3902b7ecbc feat(identity): attribute a task action to the identity that acted
The transport could carry an actor and nothing filled it. It does now, so a
dashboard approval is recorded as the person whose credential verified, and an
agent's token is recorded as the agent's action -- for an agent, agent_approved;
for a person, human_approved; and for a caller whose identity archie could not
verify, task_approved, which claims nothing about who did it.

The actor travels the path the action takes: webui reads it from the request
context the middleware resolved, carries it in the gateway request, the daemon
passes it through the in-process adapter, and the NATS request body carries it to
the service that records it. Scope stays separate from actor at every hop, because
scope is which task a caller may touch and the actor is who touched it.

A chat channel's bound identity is an actor too: a bot acting on its own channel's
task is recorded as an agent's action rather than a person's, via ActorFromScope,
whose empty kind is what keeps it out of human_approved. The agent-facing
task_action tool passes that identity and never input["identity"].

The UI process's credential check is now filled by endpoint references rather than
by configuration: -oidc-issuer and -oidc-audience on archie-ui, two URLs the
process already understands the shape of, with the verifier built in Run because
cmd/ parses flags and nothing else. The UI package still never reads config, and a
configured provider that cannot be reached fails boot rather than falling back to
the gate that names nobody.

Evidence for this change, stated as measured: go build ./... and go vet ./... are
clean, and every package this touches passes -- webui, domain/taskactions,
infrastructure/taskactions, infrastructure/gatewayrpc, gateway, app/archieui,
app/archied, domain/messaging, channels/telegram, cmd/archie-ui. task check could
not be run to completion: it fails in cmd/archie-messaging on an untracked
internal/buildinfo package another lane has in flight, which is not this change and
was left untouched. The end-to-end flip is covered in
internal/webui/api_tasks_actor_test.go: a person's credential produces a record
naming that person with human_approved, an agent's produces agent_approved, an
unverified request produces task_approved with no actor, and a request carrying
forged actor fields cannot name one.
2026-09-22 14:52:10 +10:00

224 lines
6.6 KiB
Go

package gateway
import (
"context"
"errors"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/taskactions"
"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
Personas *PersonaRegistry
TaskActor ChatTaskActor
}
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{}, Personas: []string{}, ModelsByProvider: map[string][]string{}, ActivePersonas: map[string]string{}, RestartAvailable: a.Router.Restart != nil, CancellationAvailable: a.Turns != nil, PersonasAvailable: a.Personas != nil, Version: a.Router.Version}
if a.Models != nil {
s.Models = slices.Clone(a.Models.Models())
s.ActiveModel = a.Models.ActiveModel()
if models, ok := a.Models.(ProviderModelManager); ok {
s.ActiveProvider = models.ActiveProvider()
s.Providers = slices.Clone(models.Providers())
for _, provider := range s.Providers {
s.ModelsByProvider[provider] = slices.Clone(models.ModelsForProvider(provider))
}
} else {
for _, model := range s.Models {
provider, _, ok := strings.Cut(model, "/")
if !ok {
provider = ""
}
s.ModelsByProvider[provider] = append(s.ModelsByProvider[provider], model)
}
}
}
if a.Personas != nil {
s.Personas = slices.Clone(a.Personas.List())
for _, session := range sessions {
s.ActivePersonas[session.SessionID] = a.Personas.ActiveName(session.SessionID)
}
}
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, err := a.Router.Route(ctx, in)
if err != nil {
return ChatReply{}, err
}
id, err := a.Router.ResolveSessionKey(ctx, in)
return ChatReply{Text: reply, SessionID: id}, 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) SetPersona(ctx context.Context, id, name string) (bool, error) {
if err := ctx.Err(); err != nil {
return false, err
}
if a.Personas == nil {
return false, ErrChatCapabilityUnavailable
}
return a.Personas.SetActive(id, strings.ToLower(name)), nil
}
func (a *LocalChatAdapter) ApplyTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action) (TaskActionResult, error) {
if a.TaskActor == nil {
return TaskActionResult{}, ErrChatCapabilityUnavailable
}
return a.TaskActor.ApplyChatTaskAction(ctx, &identity, taskactions.ActorFromScope(identity), taskID, action)
}
func (a *LocalChatAdapter) ApplyOperatorTaskAction(ctx context.Context, actor taskactions.Actor, taskID int64, action taskstate.Action) (TaskActionResult, error) {
if a.TaskActor == nil {
return TaskActionResult{}, ErrChatCapabilityUnavailable
}
return a.TaskActor.ApplyChatTaskAction(ctx, nil, actor, taskID, action)
}
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)
events <- ChatEvent{Kind: "started", SessionID: id}
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)
pending := make(chan ChatEvent, 32)
stream := localChatStream{done: ctx.Done(), events: pending, sessionID: id}
run := func(turnCtx context.Context) ChatEvent {
reply, err := a.Router.RouteStream(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) })
}
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
}
}
}
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})
}