287 lines
9.5 KiB
Go
287 lines
9.5 KiB
Go
package gatewayrpc
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
pb "github.com/samcharles93/archie-core/internal/contracts/gateway/v1"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/taskactions"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
type server struct {
|
|
pb.UnimplementedChatServiceServer
|
|
chat messaging.ChatContract
|
|
sessions messaging.SessionStore
|
|
catalog Catalog
|
|
asks pendingAsks
|
|
}
|
|
|
|
// RegisterServer serves the Gateway chat contract. catalog supplies the
|
|
// process-owned runtime surfaces (skill catalogue, curator registry, channel
|
|
// reload) the dashboard reads over the same contract; a zero Catalog answers
|
|
// empty lists and an Unavailable reload.
|
|
func RegisterServer(registrar grpc.ServiceRegistrar, chat messaging.ChatContract, sessions messaging.SessionStore, catalog Catalog) {
|
|
pb.RegisterChatServiceServer(registrar, &server{chat: chat, sessions: sessions, catalog: catalog})
|
|
}
|
|
|
|
func (s *server) sessionStore() (messaging.SessionStore, error) {
|
|
if s.sessions == nil {
|
|
return nil, status.Error(codes.Unavailable, "session store unavailable")
|
|
}
|
|
return s.sessions, nil
|
|
}
|
|
|
|
func (s *server) Snapshot(ctx context.Context, _ *pb.SnapshotRequest) (*pb.SnapshotResponse, error) {
|
|
v, err := s.chat.Snapshot(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return snapshotProto(v), nil
|
|
}
|
|
|
|
func (s *server) GetSession(ctx context.Context, r *pb.GetSessionRequest) (*pb.GetSessionResponse, error) {
|
|
v, found, err := s.chat.GetSession(ctx, r.SessionId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.GetSessionResponse{Session: sessionProto(v), Found: found}, nil
|
|
}
|
|
|
|
func (s *server) RecentMessages(ctx context.Context, r *pb.RecentMessagesRequest) (*pb.RecentMessagesResponse, error) {
|
|
v, err := s.chat.RecentMessages(ctx, r.SessionId, int(r.Limit))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.RecentMessagesResponse{Messages: mapValues(v, storedProto)}, nil
|
|
}
|
|
|
|
func (s *server) RecentTurns(ctx context.Context, r *pb.RecentTurnsRequest) (*pb.RecentTurnsResponse, error) {
|
|
v, err := s.chat.RecentTurns(ctx, r.SessionId, int(r.Limit))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.RecentTurnsResponse{Turns: mapValues(v, turnProto)}, nil
|
|
}
|
|
|
|
func (s *server) Route(ctx context.Context, r *pb.RouteRequest) (*pb.RouteResponse, error) {
|
|
v, err := s.chat.Route(ctx, inboundValue(r.Message))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.RouteResponse{Text: v.Text, SessionId: v.SessionID, RateLimited: v.RateLimited}, nil
|
|
}
|
|
|
|
func (s *server) Cancel(ctx context.Context, r *pb.CancelRequest) (*pb.CancelResponse, error) {
|
|
v, err := s.chat.Cancel(ctx, r.SessionId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &pb.CancelResponse{Cancelled: v.Cancelled, Dropped: int64(v.Dropped)}, nil
|
|
}
|
|
|
|
func (s *server) StopTasks(ctx context.Context, r *pb.StopTasksRequest) (*pb.StopTasksResponse, error) {
|
|
stopped, err := s.chat.StopTasks(ctx, r.Origin, r.TaskId)
|
|
if err != nil && len(stopped) == 0 {
|
|
return nil, err
|
|
}
|
|
out := &pb.StopTasksResponse{Stopped: stopped}
|
|
if err != nil {
|
|
out.Error = err.Error()
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *server) ApplyTaskAction(ctx context.Context, r *pb.ApplyTaskActionRequest) (*pb.ApplyTaskActionResponse, error) {
|
|
v, err := s.chat.ApplyTaskAction(ctx, r.Identity, r.TaskId, taskstate.Action(r.Action), taskactions.ActionPayload{
|
|
Instructions: r.Instructions,
|
|
Findings: r.Findings,
|
|
})
|
|
if err != nil {
|
|
return nil, taskActionStatus(err)
|
|
}
|
|
return &pb.ApplyTaskActionResponse{TaskId: v.TaskID, Action: v.Action, Message: v.Message}, nil
|
|
}
|
|
|
|
func (s *server) ApplyOperatorTaskAction(ctx context.Context, r *pb.ApplyOperatorTaskActionRequest) (*pb.ApplyOperatorTaskActionResponse, error) {
|
|
actor := taskactions.Actor{
|
|
Identity: identity.IdentityID(r.ActorId),
|
|
Kind: identity.Kind(r.ActorKind),
|
|
Principal: identity.IdentityID(r.PrincipalId),
|
|
}
|
|
v, err := s.chat.ApplyOperatorTaskAction(ctx, actor, r.TaskId, taskstate.Action(r.Action), taskactions.ActionPayload{
|
|
Instructions: r.Instructions,
|
|
Findings: r.Findings,
|
|
RetryMode: taskstate.RetryMode(r.RetryMode),
|
|
ResumeFrom: r.ResumeFrom,
|
|
CurrentDefinition: r.CurrentDefinition,
|
|
})
|
|
if err != nil {
|
|
return nil, taskActionStatus(err)
|
|
}
|
|
return &pb.ApplyOperatorTaskActionResponse{TaskId: v.TaskID, Action: v.Action, Message: v.Message}, nil
|
|
}
|
|
|
|
func (s *server) SaveSession(ctx context.Context, r *pb.SaveSessionRequest) (*pb.SaveSessionResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.SaveSessionResponse{}, ss.Save(ctx, sessionValue(r.Session))
|
|
}
|
|
|
|
func (s *server) GetSessionsByChannel(ctx context.Context, r *pb.GetSessionsByChannelRequest) (*pb.GetSessionsByChannelResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
v, e := ss.GetByChannel(ctx, r.Platform, r.ChannelId)
|
|
return &pb.GetSessionsByChannelResponse{Sessions: mapValues(v, sessionProto)}, e
|
|
}
|
|
|
|
func (s *server) DeleteSession(ctx context.Context, r *pb.DeleteSessionRequest) (*pb.DeleteSessionResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.DeleteSessionResponse{}, ss.Delete(ctx, r.SessionId)
|
|
}
|
|
|
|
func (s *server) TouchSession(ctx context.Context, r *pb.TouchSessionRequest) (*pb.TouchSessionResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.TouchSessionResponse{}, ss.Touch(ctx, r.SessionId)
|
|
}
|
|
|
|
func (s *server) ListSessions(ctx context.Context, _ *pb.ListSessionsRequest) (*pb.ListSessionsResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
v, e := ss.List(ctx)
|
|
return &pb.ListSessionsResponse{Sessions: mapValues(v, sessionProto)}, e
|
|
}
|
|
|
|
// storedMessages converts wire messages to canonical records, deriving
|
|
// roles from the owning session's bot identity (see
|
|
// messaging.RoleForSender). The wire carries no role; both sides derive from
|
|
// the same session, so they agree.
|
|
func (s *server) storedMessages(ctx context.Context, ss messaging.SessionStore, sessionID string, msgs []*pb.Message) ([]messaging.Message, error) {
|
|
var botUser string
|
|
if sc, err := ss.Get(ctx, sessionID); err != nil {
|
|
return nil, err
|
|
} else if sc != nil {
|
|
botUser = sc.Source.BotUser
|
|
}
|
|
out := make([]messaging.Message, 0, len(msgs))
|
|
for _, m := range msgs {
|
|
stored := storedValue(m)
|
|
stored.Role = messaging.RoleForSender(stored.Sender, botUser)
|
|
out = append(out, stored)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *server) SaveMessage(ctx context.Context, r *pb.SaveMessageRequest) (*pb.SaveMessageResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
msgs, e := s.storedMessages(ctx, ss, r.SessionId, []*pb.Message{r.Message})
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.SaveMessageResponse{}, ss.SaveMessage(ctx, r.SessionId, msgs[0])
|
|
}
|
|
|
|
func (s *server) DeleteRecentMessages(ctx context.Context, r *pb.DeleteRecentMessagesRequest) (*pb.DeleteRecentMessagesResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
v, e := ss.DeleteRecentMessages(ctx, r.SessionId, int(r.Limit))
|
|
return &pb.DeleteRecentMessagesResponse{Deleted: int64(v)}, e
|
|
}
|
|
|
|
func (s *server) MessageCount(ctx context.Context, r *pb.MessageCountRequest) (*pb.MessageCountResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
v, e := ss.MessageCount(ctx, r.SessionId)
|
|
return &pb.MessageCountResponse{Count: int64(v)}, e
|
|
}
|
|
|
|
func (s *server) SaveMessages(ctx context.Context, r *pb.SaveMessagesRequest) (*pb.SaveMessagesResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
msgs, e := s.storedMessages(ctx, ss, r.SessionId, r.Messages)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.SaveMessagesResponse{}, ss.SaveMessages(ctx, r.SessionId, msgs)
|
|
}
|
|
|
|
func (s *server) ReplaceMessages(ctx context.Context, r *pb.ReplaceMessagesRequest) (*pb.ReplaceMessagesResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
msgs, e := s.storedMessages(ctx, ss, r.SessionId, r.Messages)
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
return &pb.ReplaceMessagesResponse{}, ss.ReplaceMessages(ctx, r.SessionId, msgs, r.Superseded)
|
|
}
|
|
|
|
func (s *server) SearchMessages(ctx context.Context, r *pb.SearchMessagesRequest) (*pb.SearchMessagesResponse, error) {
|
|
ss, e := s.sessionStore()
|
|
if e != nil {
|
|
return nil, e
|
|
}
|
|
v, e := ss.SearchMessages(ctx, r.SessionId, messaging.MessageQuery{Query: r.Query, Limit: int(r.Limit), Offset: int(r.Offset)})
|
|
return &pb.SearchMessagesResponse{Messages: mapValues(v.Messages, storedProto), NextOffset: int64(v.NextOffset), HasMore: v.HasMore, Truncated: v.Truncated}, e
|
|
}
|
|
|
|
func (s *server) Stream(r *pb.StreamRequest, out grpc.ServerStreamingServer[pb.StreamResponse]) error {
|
|
// An ask is sent from the turn's goroutine while this one sends events.
|
|
var sendMu sync.Mutex
|
|
send := func(v *pb.StreamResponse) error {
|
|
sendMu.Lock()
|
|
defer sendMu.Unlock()
|
|
return out.Send(v)
|
|
}
|
|
ctx := withAsks(out.Context(), r, remoteAsker{pending: &s.asks, send: send})
|
|
events, err := s.chat.Stream(ctx, inboundValue(r.Message))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for {
|
|
select {
|
|
case <-out.Context().Done():
|
|
return out.Context().Err()
|
|
case event, ok := <-events:
|
|
if !ok {
|
|
return nil
|
|
}
|
|
if err := send(eventProto(event)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *server) Answer(_ context.Context, r *pb.AnswerRequest) (*pb.AnswerResponse, error) {
|
|
return &pb.AnswerResponse{Found: s.asks.answer(r.AskId, r.Answer)}, nil
|
|
}
|