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.
138 lines
4.5 KiB
Go
138 lines
4.5 KiB
Go
// Package gatewayrpc adapts the Gateway chat contract to gRPC.
|
|
package gatewayrpc
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
|
|
"google.golang.org/grpc"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/taskactions"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
var _ messaging.ChatContract = (*Client)(nil)
|
|
|
|
// Client implements messaging.ChatContract over the chat service. The proto
|
|
// is unchanged by the messaging migration, so history crosses without its
|
|
// role and is re-addressed from the owning session on arrival; StoreClient
|
|
// serves the SessionStore view over the same RPCs.
|
|
type Client struct{ client pb.ChatServiceClient }
|
|
|
|
func NewClient(conn grpc.ClientConnInterface) *Client {
|
|
return &Client{client: pb.NewChatServiceClient(conn)}
|
|
}
|
|
|
|
func (c *Client) Snapshot(ctx context.Context) (messaging.ChatSnapshot, error) {
|
|
v, err := c.client.Snapshot(ctx, &pb.SnapshotRequest{})
|
|
if err != nil {
|
|
return messaging.ChatSnapshot{}, err
|
|
}
|
|
return snapshotValue(v), nil
|
|
}
|
|
|
|
func (c *Client) GetSession(ctx context.Context, id string) (messaging.SessionContext, bool, error) {
|
|
v, err := c.client.GetSession(ctx, &pb.GetSessionRequest{SessionId: id})
|
|
if err != nil {
|
|
return messaging.SessionContext{}, false, err
|
|
}
|
|
return sessionValue(v.Session), v.Found, nil
|
|
}
|
|
|
|
func (c *Client) RecentMessages(ctx context.Context, id string, n int) ([]messaging.Message, error) {
|
|
v, err := c.client.RecentMessages(ctx, &pb.RecentMessagesRequest{SessionId: id, Limit: int64(n)})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return addressRecords(ctx, c.client, id, v.Messages)
|
|
}
|
|
|
|
func (c *Client) RecentTurns(ctx context.Context, id string, n int) ([]messaging.TurnRecord, error) {
|
|
v, err := c.client.RecentTurns(ctx, &pb.RecentTurnsRequest{SessionId: id, Limit: int64(n)})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return mapValues(v.Turns, turnValue), nil
|
|
}
|
|
|
|
func (c *Client) Route(ctx context.Context, in messaging.Inbound) (messaging.ChatReply, error) {
|
|
v, err := c.client.Route(ctx, &pb.RouteRequest{Message: inboundProto(in)})
|
|
if err != nil {
|
|
return messaging.ChatReply{}, err
|
|
}
|
|
return messaging.ChatReply{Text: v.Text, SessionID: v.SessionId}, nil
|
|
}
|
|
|
|
func (c *Client) Cancel(ctx context.Context, id string) (messaging.ChatCancellation, error) {
|
|
v, err := c.client.Cancel(ctx, &pb.CancelRequest{SessionId: id})
|
|
if err != nil {
|
|
return messaging.ChatCancellation{}, err
|
|
}
|
|
return messaging.ChatCancellation{Cancelled: v.Cancelled, Dropped: int(v.Dropped)}, nil
|
|
}
|
|
|
|
func (c *Client) SetPersona(ctx context.Context, id, name string) (bool, error) {
|
|
v, err := c.client.SetPersona(ctx, &pb.SetPersonaRequest{SessionId: id, Name: name})
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return v.Found, nil
|
|
}
|
|
|
|
func (c *Client) ApplyTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action) (messaging.TaskActionResult, error) {
|
|
v, err := c.client.ApplyTaskAction(ctx, &pb.ApplyTaskActionRequest{Identity: identity, TaskId: taskID, Action: string(action)})
|
|
if err != nil {
|
|
return messaging.TaskActionResult{}, taskActionError(err)
|
|
}
|
|
return messaging.TaskActionResult{TaskID: v.TaskId, Action: v.Action, Message: v.Message}, nil
|
|
}
|
|
|
|
func (c *Client) ApplyOperatorTaskAction(ctx context.Context, actor taskactions.Actor, taskID int64, action taskstate.Action) (messaging.TaskActionResult, error) {
|
|
v, err := c.client.ApplyOperatorTaskAction(ctx, &pb.ApplyOperatorTaskActionRequest{
|
|
TaskId: taskID,
|
|
Action: string(action),
|
|
ActorId: string(actor.Identity),
|
|
ActorKind: string(actor.Kind),
|
|
PrincipalId: string(actor.Principal),
|
|
})
|
|
if err != nil {
|
|
return messaging.TaskActionResult{}, taskActionError(err)
|
|
}
|
|
return messaging.TaskActionResult{TaskID: v.TaskId, Action: v.Action, Message: v.Message}, nil
|
|
}
|
|
|
|
func (c *Client) Stream(ctx context.Context, in messaging.Inbound) (<-chan messaging.ChatEvent, error) {
|
|
stream, err := c.client.Stream(ctx, &pb.StreamRequest{Message: inboundProto(in)})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make(chan messaging.ChatEvent)
|
|
go func() {
|
|
defer close(out)
|
|
for {
|
|
v, err := stream.Recv()
|
|
if errors.Is(err, io.EOF) {
|
|
return
|
|
}
|
|
var event messaging.ChatEvent
|
|
if err != nil {
|
|
event = messaging.ChatEvent{Kind: "error", Text: err.Error()}
|
|
} else {
|
|
event = eventValue(v)
|
|
}
|
|
select {
|
|
case out <- event:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
return out, nil
|
|
}
|