Files
archie/internal/infrastructure/gatewayrpc/client.go
T
sam c265b07ec7 refactor(workflow): stop assuming a human decides
An approval, ask or park can be resolved by an operator, a rule, a
classifier or automatically, so the vocabulary stops naming a person:

- step type human.approve -> workflow.approve
- park class needs_human -> needs_decision (ParkNeedsDecision)
- event kinds human_* -> operator_*
- alert kind task.needs_human -> task.needs_decision
- status grouping "needs you" -> "needs attention"

0061 rewrites the stored values, including the approval step type in the
workflow-definitions resource and each task's pinned definition, with the
digest recomputed so resumed tasks still match.
2026-10-25 17:31:16 +11:00

243 lines
8.4 KiB
Go

// Package gatewayrpc adapts the Gateway chat contract to gRPC.
package gatewayrpc
import (
"context"
"encoding/json"
"errors"
"io"
"time"
"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/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.
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, RateLimited: v.RateLimited}, 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) StopTasks(ctx context.Context, origin string, taskID int64) ([]int64, error) {
v, err := c.client.StopTasks(ctx, &pb.StopTasksRequest{Origin: origin, TaskId: taskID})
if err != nil {
return nil, err
}
if v.Error != "" {
return v.Stopped, errors.New(v.Error)
}
return v.Stopped, nil
}
func (c *Client) ApplyTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action, res taskactions.ActionPayload) (messaging.TaskActionResult, error) {
v, err := c.client.ApplyTaskAction(ctx, &pb.ApplyTaskActionRequest{
Identity: identity, TaskId: taskID, Action: string(action),
Instructions: res.Instructions, Findings: res.Findings,
})
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, res taskactions.ActionPayload) (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),
Instructions: res.Instructions,
Findings: res.Findings,
RetryMode: string(res.RetryMode),
ResumeFrom: res.ResumeFrom,
CurrentDefinition: res.CurrentDefinition,
})
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) {
approver := messaging.ApprovalFromContext(ctx)
interactive := messaging.InteractiveFromContext(ctx)
stream, err := c.client.Stream(ctx, &pb.StreamRequest{
Message: inboundProto(in),
CanApprove: approver != nil,
CanClarify: interactive.Clarifier != nil,
CanPick: interactive.Picker != nil,
CanQuestion: interactive.Questioner != nil,
})
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
}
if err == nil && v.GetAsk() != nil {
// The turn blocks on this; keep receiving while the user answers.
go c.answer(ctx, v.GetAsk(), approver, interactive)
continue
}
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
}
// answer puts ask to the channel's own requester and returns its reply. A
// failed or abandoned ask answers deny or empty, which the turn reads as no.
func (c *Client) answer(ctx context.Context, ask *pb.Ask, approver messaging.ApprovalRequester, interactive messaging.Interactive) {
var reply string
switch ask.GetKind() {
case "approval":
if approver != nil {
decision, err := approver.RequestApproval(ctx, ask.GetPrompt(), ask.GetDetail())
switch {
case err != nil || decision == messaging.ApprovalDenied:
reply = "deny"
case decision == messaging.ApprovalPermanentlyApproved:
reply = "always"
default:
reply = "approve"
}
}
case "clarify":
if interactive.Clarifier != nil {
reply, _ = interactive.Clarifier.RequestClarification(ctx, messaging.ClarifyRequest{Question: ask.GetPrompt(), Suggestions: choicesValue(ask.GetChoices())})
}
case "questionnaire":
reply = answerQuestionnaire(ctx, ask, interactive.Questioner)
case "picker":
if interactive.Picker != nil {
choice, err := interactive.Picker.RequestChoice(ctx, messaging.PickerRequest{Prompt: ask.GetPrompt(), Options: choicesValue(ask.GetChoices())})
if err == nil {
reply = choice.ID
}
}
}
_, _ = c.client.Answer(ctx, &pb.AnswerRequest{AskId: ask.GetId(), Answer: reply})
}
// answerQuestionnaire poses ask's questions and returns the answers as a JSON
// object, or nothing when the channel cannot ask or the user gave none.
func answerQuestionnaire(ctx context.Context, ask *pb.Ask, questioner messaging.QuestionnaireRequester) string {
if questioner == nil {
return ""
}
answers, err := questioner.RequestAnswers(ctx, messaging.QuestionnaireRequest{Questions: questionsValue(ask.GetQuestions())})
if err != nil {
return ""
}
encoded, err := json.Marshal(answers)
if err != nil {
return ""
}
return string(encoded)
}
func choicesValue(choices []*pb.Choice) []messaging.InteractiveChoice {
out := make([]messaging.InteractiveChoice, 0, len(choices))
for _, c := range choices {
out = append(out, messaging.InteractiveChoice{ID: c.GetId(), Label: c.GetLabel()})
}
return out
}
// PostToConversation appends text as an assistant message to the newest
// session for the conversation. NotFound when no session holds it.
func (c *Client) PostToConversation(ctx context.Context, platform string, conversation messaging.ConversationID, text string) error {
v, err := c.client.GetSessionsByChannel(ctx, &pb.GetSessionsByChannelRequest{Platform: platform, ChannelId: conversation.ChannelID})
if err != nil {
return err
}
for _, s := range v.Sessions {
session := sessionValue(s)
if session.Source.ThreadID != conversation.ThreadID {
continue
}
msg := messaging.Message{ConversationID: conversation, Sender: session.Source.BotUser, Text: text, At: time.Now()}
_, err := c.client.SaveMessage(ctx, &pb.SaveMessageRequest{SessionId: session.SessionID, Message: storedProto(msg)})
return err
}
return status.Errorf(codes.NotFound, "no session for %s:%s", platform, conversation)
}