archie-core-8cda.5.4 requires /api/tasks/{id}/action to go through
ChatContract rather than a task-action service the UI process composes
itself. The contract could not carry the request: ApplyTaskAction's identity
is a scope, and the daemon's action service distinguishes a named identity
from a nil one, which is the authenticated operator acting across
identities. Sending "" would not have expressed it either -- that is a real
identity in a single-identity deployment (chatTaskProfiles).
ApplyOperatorTaskAction is that case, additively: a separate RPC, so buf
sees no cardinality change on a shipped field, and no request that can carry
both an identity and operator authority. ChatTaskActor's identity becomes a
pointer end to end, from the Gateway's local adapter through the NATS hop to
taskactions.Service.Apply, which has always taken one.
The conformance test now covers both scopes through the local adapter and
the gRPC hop; the chat tool test pins that a chat action is never unscoped.
No caller passes nil yet -- the dashboard handler switches over with the
rest of the cutover.
223 lines
6.5 KiB
Go
223 lines
6.5 KiB
Go
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"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}
|
|
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, taskID, action)
|
|
}
|
|
|
|
func (a *LocalChatAdapter) ApplyOperatorTaskAction(ctx context.Context, taskID int64, action taskstate.Action) (TaskActionResult, error) {
|
|
if a.TaskActor == nil {
|
|
return TaskActionResult{}, ErrChatCapabilityUnavailable
|
|
}
|
|
return a.TaskActor.ApplyChatTaskAction(ctx, nil, 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})
|
|
}
|