Completes the objective deletion gate for the UI Service (archie-core-8cda.5.6): go list -deps ./cmd/archie-ui now links zero banned packages -- no modernc.org/sqlite, no internal/store, gateway, channels, memory, secret, agentexec, tools, skill, yaegiutil, curator, or the workflow engine. The closure shrinks from 68 to 26 archie-core packages. Each cut is a producer-side move; no consumer-side defensive shims. - Store contracts (TaskStore family, value types, sentinels) moved from internal/store to internal/domain/storecontract -- the approved contract location per state-store-contract rev. 2d, and NOT internal/contracts: that tree is buf generate output and tools/proto.sh check deletes hand-written files there. internal/store keeps aliases; sentinel message strings are byte-identical and remain the wire contract. - Chat contracts (ChatContract, sessions, turns, streaming, commands) moved from internal/gateway to internal/domain/messaging; gateway keeps aliases. ToolCallEvent rendering helpers become gateway functions (methods cannot live on alias types). - Task vocabulary (Task, statuses, mid-run Store, Definition) split into internal/domain/workflow/task; the pipeline engine stays in package workflow with aliases, so daemon-side callers are unchanged. - overlay.DeniedKeys moved to internal/infrastructure/configuration: webui referenced the constant and that dragged the overlay SQLite store in. - webui.Server's concrete runtime handles become webui-owned view interfaces with daemon-side bootstrap adapters: channel lifecycle (internal/channels/status), MemoryStatus, CuratorStatus, and a SkillCatalog seam replacing the direct skill.DefaultRoots/CatalogRoots calls. Each degrades to an empty page when unwired. - config.SecretRef moved into internal/config (config vocabulary); internal/secret keeps an alias and Registry.Resolve absorbs the zero-value short-circuit. Docs: state-store-contract rev. 2d relocation record; ui-service-boundary deletion gate marked satisfied; ARCHITECTURE.md package map rows.
131 lines
4.3 KiB
Go
131 lines
4.3 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/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, taskID int64, action taskstate.Action) (messaging.TaskActionResult, error) {
|
|
v, err := c.client.ApplyOperatorTaskAction(ctx, &pb.ApplyOperatorTaskActionRequest{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) 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
|
|
}
|