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.
224 lines
6.6 KiB
Go
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})
|
|
}
|