fix(gateway): stamp the session platform from the channel that carried the message
One Router serves every channel and named itself "web", so Source.Platform -- the FIRST component of the session natural key, and the platform GetByChannel filters on -- was a constant, true of no channel but the dashboard. Two consequences followed: the per-user identity policy was real code that no production call site reached with a real channel name, and a curator pass's write to agent-user memory could not be read back by the turn that wrote it, because that turn resolved no UserID. The channel now travels with the message. Frontends name the channel they carry (pb.Message.platform: telegram, email, webhook, web), and the Gateway stamps the session from it, falling back to its own name when a sender names none -- which is what every existing row holds and what a frontend that does not participate keeps doing. Identity resolution reads the platform off the inbound rather than closing over a channel name, so carriesPersonIdentity finally decides something in production: telegram and email resolve a person, the dashboard and a webhook resolve nothing, and an unknown platform fails closed. Deliberately NOT changed, because it is where this could quietly widen scope: TurnRunnerConfig.Channel still keys tool availability, so no channel gains or loses a tool here. Only session lookup and identity follow the message's platform. Consequence the maintainer accepted: a chat whose active session came from /new or /branch re-resolves once, since GetByChannel now filters on the channel's name. A chat with no /new re-resolves onto the same deterministic session id and heals silently. Verified: gateway, archied, gatewayrpc, messaging, webui, channels and cmd suites, go vet ./..., go build ./..., golangci-lint run ./... (0 issues), docs:check. New contracts: TestResolveSessionKeyStampsTheMessagesPlatform, the per-platform identity table, and the transport-context wire round trip.
This commit is contained in:
18 files changed
+259
-108
No files matched your search
@@ -5,42 +5,45 @@ import (
|
||||
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
)
|
||||
|
||||
// userIdentityResolver returns the gateway.TurnRunnerConfig.UserIdentity
|
||||
// function for one channel, per docs/prds/memory-engine-unification.md §3:
|
||||
// resolution is supplied per channel by the composition, never inferred by
|
||||
// the engine or guessed from a channel-neutral "channel:SenderID"
|
||||
// concatenation.
|
||||
// carriesPersonIdentity reports whether a platform's SenderID names a person,
|
||||
// per docs/prds/memory-engine-unification.md §3: resolution is supplied per
|
||||
// channel by the composition, never inferred by the engine or guessed from a
|
||||
// channel-neutral "channel:SenderID" concatenation.
|
||||
//
|
||||
// Telegram and email carry a native per-person sender id (a Telegram numeric
|
||||
// user id, an SMTP from address). The dashboard ("web") has one bearer
|
||||
// token, not users, and a webhook carries no per-caller identity at all: its
|
||||
// route path is a source, not a person, and never enters SenderID
|
||||
// user id, an SMTP from address). The dashboard ("web") has one bearer token,
|
||||
// not users, and a webhook carries no per-caller identity at all: its route path
|
||||
// is a source, not a person, and never enters SenderID
|
||||
// (internal/channels/webhook/webhook.go -- it travels in the transport-only
|
||||
// Inbound.BudgetKey instead). Treating a URL or a shared token as an
|
||||
// identity would give it the same standing as a real user, which the read
|
||||
// path's isolation guarantee depends on never happening. Both resolve
|
||||
// nothing, so a turn on either channel gets global and agent scopes only
|
||||
// (Subject.WritableScopes' fail-closed behaviour).
|
||||
func userIdentityResolver(channel string) func(messaging.Message) (memory.IdentityID, bool) {
|
||||
switch channel {
|
||||
// Inbound.BudgetKey instead). Treating a URL or a shared token as an identity
|
||||
// would give it the same standing as a real user, which the read path's
|
||||
// isolation guarantee depends on never happening.
|
||||
//
|
||||
// An unknown platform fails closed, so a channel added later gets global and
|
||||
// agent scopes only until someone decides deliberately that it carries people.
|
||||
func carriesPersonIdentity(platform string) bool {
|
||||
switch platform {
|
||||
case "telegram", "email":
|
||||
return senderIDIdentity
|
||||
return true
|
||||
default:
|
||||
return noUserIdentity
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// senderIDIdentity resolves a channel's own SenderID as the user's identity.
|
||||
// Empty means the channel carries no per-person identity for this message.
|
||||
func senderIDIdentity(msg messaging.Message) (memory.IdentityID, bool) {
|
||||
if msg.SenderID == "" {
|
||||
return "", false
|
||||
// userIdentityResolver is the composition's identity policy for a turn, keyed on
|
||||
// the platform the message itself names rather than on the process that serves
|
||||
// it.
|
||||
//
|
||||
// It was closed over a single channel name, and one Gateway Router serves every
|
||||
// channel, so that name was "web" even for a Telegram turn: the allowlist above
|
||||
// was real code no production call site reached with a real channel name, and
|
||||
// Subject.UserID was always empty (archie-core-c1qx). Reading the platform off
|
||||
// the inbound is what makes the policy reachable.
|
||||
func userIdentityResolver() func(messaging.Inbound) (memory.IdentityID, bool) {
|
||||
return func(in messaging.Inbound) (memory.IdentityID, bool) {
|
||||
if !carriesPersonIdentity(in.Platform) || in.Message.SenderID == "" {
|
||||
return "", false
|
||||
}
|
||||
return memory.IdentityID(in.Message.SenderID), true
|
||||
}
|
||||
return memory.IdentityID(msg.SenderID), true
|
||||
}
|
||||
|
||||
// noUserIdentity resolves nothing: the channel it is wired to (the
|
||||
// dashboard, a webhook) carries no per-person identity at all.
|
||||
func noUserIdentity(messaging.Message) (memory.IdentityID, bool) {
|
||||
return "", false
|
||||
}
|
||||
@@ -8,23 +8,30 @@ import (
|
||||
|
||||
// TestWebhookUserIdentityNeverReturnsTheRoutePath guards
|
||||
// docs/prds/memory-engine-unification.md §3 and §4's specific webhook
|
||||
// requirement: internal/channels/webhook/webhook.go sets SenderID to the
|
||||
// configured route path (RouteConfig.Path), and that must never surface as
|
||||
// a user identity, however plausible it looks as one.
|
||||
// requirement: internal/channels/webhook/webhook.go carries the configured route
|
||||
// path in Inbound.BudgetKey, never in SenderID, and no platform may turn one into
|
||||
// a user identity however plausible it looks as one.
|
||||
func TestWebhookUserIdentityNeverReturnsTheRoutePath(t *testing.T) {
|
||||
resolver := userIdentityResolver("webhook")
|
||||
id, ok := resolver(messaging.Message{SenderID: "/github", Sender: "webhook"})
|
||||
resolver := userIdentityResolver()
|
||||
id, ok := resolver(messaging.Inbound{
|
||||
Platform: "webhook",
|
||||
Message: messaging.Message{SenderID: "/github", Sender: "webhook"},
|
||||
})
|
||||
if ok || id != "" {
|
||||
t.Fatalf("webhook resolver = (%q, %v), want (\"\", false)", id, ok)
|
||||
}
|
||||
}
|
||||
|
||||
// TestUserIdentityResolverPerChannel documents the composition's per-channel
|
||||
// choice: telegram and email carry a native sender id, the dashboard ("web")
|
||||
// and webhook do not.
|
||||
func TestUserIdentityResolverPerChannel(t *testing.T) {
|
||||
// TestUserIdentityResolverPerPlatform documents the composition's per-platform
|
||||
// choice: telegram and email carry a native sender id, the dashboard ("web") and
|
||||
// webhook do not, and a platform nobody has decided about fails closed.
|
||||
//
|
||||
// It is keyed on the message's platform rather than a resolver per channel,
|
||||
// because one Gateway Router serves every channel: closing over a channel name
|
||||
// resolved every turn as "web" (archie-core-c1qx).
|
||||
func TestUserIdentityResolverPerPlatform(t *testing.T) {
|
||||
tests := []struct {
|
||||
channel string
|
||||
platform string
|
||||
senderID string
|
||||
wantOK bool
|
||||
}{
|
||||
@@ -33,28 +40,30 @@ func TestUserIdentityResolverPerChannel(t *testing.T) {
|
||||
{"web", "anything", false},
|
||||
{"webhook", "/github", false},
|
||||
{"unknown-future-channel", "anything", false},
|
||||
{"", "anything", false},
|
||||
}
|
||||
resolver := userIdentityResolver()
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.channel, func(t *testing.T) {
|
||||
resolver := userIdentityResolver(tt.channel)
|
||||
id, ok := resolver(messaging.Message{SenderID: tt.senderID})
|
||||
t.Run(tt.platform, func(t *testing.T) {
|
||||
id, ok := resolver(messaging.Inbound{Platform: tt.platform, Message: messaging.Message{SenderID: tt.senderID}})
|
||||
if ok != tt.wantOK {
|
||||
t.Fatalf("%s resolver ok = %v, want %v", tt.channel, ok, tt.wantOK)
|
||||
t.Fatalf("%s resolver ok = %v, want %v", tt.platform, ok, tt.wantOK)
|
||||
}
|
||||
if ok && string(id) != tt.senderID {
|
||||
t.Fatalf("%s resolver id = %q, want %q", tt.channel, id, tt.senderID)
|
||||
t.Fatalf("%s resolver id = %q, want %q", tt.platform, id, tt.senderID)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestSenderIDIdentityFailsClosedOnEmptySenderID guards §3's "fail closed":
|
||||
// an empty SenderID (a channel that carries no per-caller id for this
|
||||
// particular message) must resolve to no identity, never an empty-string
|
||||
// identity that Subject would treat as present.
|
||||
func TestSenderIDIdentityFailsClosedOnEmptySenderID(t *testing.T) {
|
||||
id, ok := senderIDIdentity(messaging.Message{SenderID: ""})
|
||||
// TestUserIdentityResolverFailsClosedOnEmptySenderID guards §3's "fail closed":
|
||||
// an empty SenderID (a channel that carries no per-caller id for this particular
|
||||
// message) must resolve to no identity, never an empty-string identity that
|
||||
// Subject would treat as present.
|
||||
func TestUserIdentityResolverFailsClosedOnEmptySenderID(t *testing.T) {
|
||||
resolver := userIdentityResolver()
|
||||
id, ok := resolver(messaging.Inbound{Platform: "telegram", Message: messaging.Message{SenderID: ""}})
|
||||
if ok || id != "" {
|
||||
t.Fatalf("senderIDIdentity(empty) = (%q, %v), want (\"\", false)", id, ok)
|
||||
t.Fatalf("telegram resolver with no sender id = (%q, %v), want (\"\", false)", id, ok)
|
||||
}
|
||||
}
|
||||
@@ -196,7 +196,7 @@ func newChatTurnRunner(
|
||||
Repos: chatRepoEnv(cfg, s.DefaultChatIdentity),
|
||||
MemoryEngine: s.MemoryEngine,
|
||||
MemoryWriter: s.MemoryWriter,
|
||||
UserIdentity: userIdentityResolver(channel),
|
||||
UserIdentity: userIdentityResolver(),
|
||||
Log: s.Log,
|
||||
})
|
||||
if err := runner.Recover(ctx); err != nil && s.Log != nil {
|
||||
|
||||
@@ -201,13 +201,18 @@ func (g *Gateway) processMessage(ctx context.Context, from, to, raw string) {
|
||||
// following Content-Type or headers.
|
||||
text := extractBody(raw)
|
||||
|
||||
msg := messaging.Inbound{Message: messaging.Message{
|
||||
ConversationID: messaging.ConversationID{ChannelID: to},
|
||||
Sender: from,
|
||||
SenderID: from,
|
||||
Role: messaging.RoleUser,
|
||||
Text: text,
|
||||
}}
|
||||
msg := messaging.Inbound{
|
||||
Message: messaging.Message{
|
||||
ConversationID: messaging.ConversationID{ChannelID: to},
|
||||
Sender: from,
|
||||
SenderID: from,
|
||||
Role: messaging.RoleUser,
|
||||
Text: text,
|
||||
},
|
||||
// The frontend names the channel it carries, which is how the Gateway
|
||||
// learns it is serving email rather than whatever it calls itself.
|
||||
Platform: "email",
|
||||
}
|
||||
reply, err := client.Route(ctx, msg)
|
||||
if err != nil {
|
||||
g.log.Error("email route", "err", err, "from", from)
|
||||
|
||||
@@ -412,7 +412,7 @@ func (g *Gateway) resumeHandler(client messaging.ChatContract) bot.HandlerFunc {
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
reply, err := client.Route(ctx, messaging.Inbound{Message: messaging.Message{
|
||||
reply, err := client.Route(ctx, messaging.Inbound{Platform: "telegram", Message: messaging.Message{
|
||||
ConversationID: conversationID(msg),
|
||||
Sender: msg.From.Username,
|
||||
Role: messaging.RoleUser,
|
||||
@@ -434,7 +434,7 @@ func (g *Gateway) routeCmdHandler(client messaging.ChatContract, cmd string) bot
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
reply, err := client.Route(ctx, messaging.Inbound{Message: messaging.Message{
|
||||
reply, err := client.Route(ctx, messaging.Inbound{Platform: "telegram", Message: messaging.Message{
|
||||
ConversationID: conversationID(msg),
|
||||
Sender: msg.From.Username,
|
||||
Role: messaging.RoleUser,
|
||||
@@ -565,7 +565,7 @@ func (g *Gateway) handleCallback(ctx context.Context, b *bot.Bot, update *models
|
||||
// /stop meant to cancel it, which would sit unread until the turn it was
|
||||
// aimed at had already finished.
|
||||
func (g *Gateway) submitTurn(ctx context.Context, b *bot.Bot, msg *models.Message, client messaging.ChatContract) {
|
||||
gm := messaging.Inbound{Message: messaging.Message{
|
||||
gm := messaging.Inbound{Platform: "telegram", Message: messaging.Message{
|
||||
// Telegram's message ID makes persistence idempotent: the store
|
||||
// derives a canonical ID from it, so a redelivered update is a
|
||||
// no-op rather than appending a duplicate or overwriting the
|
||||
|
||||
@@ -186,6 +186,7 @@ func (g *Gateway) handleWebhook(route *RouteConfig) http.HandlerFunc {
|
||||
// limiting, so it travels in the transport-only BudgetKey
|
||||
// rather than borrowing the identity field.
|
||||
BudgetKey: route.Path,
|
||||
Platform: "webhook",
|
||||
}
|
||||
reply, err := client.Route(r.Context(), msg)
|
||||
if err != nil {
|
||||
|
||||
@@ -154,7 +154,14 @@ type Message struct {
|
||||
// -- a webhook's configured route path. Transport-only: a channel frontend
|
||||
// sets it on inbound and it is never persisted, exactly like page. Empty
|
||||
// means the message is not rate limited.
|
||||
BudgetKey string `protobuf:"bytes,9,opt,name=budget_key,json=budgetKey,proto3" json:"budget_key,omitempty"`
|
||||
BudgetKey string `protobuf:"bytes,9,opt,name=budget_key,json=budgetKey,proto3" json:"budget_key,omitempty"`
|
||||
// platform is the channel that carried this message ("telegram", "email",
|
||||
// "webhook", "web"), as the frontend that owns that channel knows it. It is
|
||||
// how the Gateway learns which channel it is serving: one Router serves every
|
||||
// channel, so its own name is "web" even for a Telegram turn, which made
|
||||
// Source.Platform -- the first component of the session natural key -- a
|
||||
// constant. Transport-only, never persisted: the session record keeps it.
|
||||
Platform string `protobuf:"bytes,10,opt,name=platform,proto3" json:"platform,omitempty"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
@@ -252,6 +259,13 @@ func (x *Message) GetBudgetKey() string {
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *Message) GetPlatform() string {
|
||||
if x != nil {
|
||||
return x.Platform
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type ToolCall struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
||||
@@ -2772,7 +2786,7 @@ const file_gateway_v1_chat_proto_rawDesc = "" +
|
||||
"\n" +
|
||||
"created_at\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x12@\n" +
|
||||
"\x0elast_active_at\x18\n" +
|
||||
" \x01(\v2\x1a.google.protobuf.TimestampR\flastActiveAt\"\x88\x02\n" +
|
||||
" \x01(\v2\x1a.google.protobuf.TimestampR\flastActiveAt\"\xa4\x02\n" +
|
||||
"\aMessage\x12\x1d\n" +
|
||||
"\n" +
|
||||
"message_id\x18\x01 \x01(\tR\tmessageId\x12\x1b\n" +
|
||||
@@ -2785,7 +2799,9 @@ const file_gateway_v1_chat_proto_rawDesc = "" +
|
||||
"\x04page\x18\a \x01(\tR\x04page\x12*\n" +
|
||||
"\x02at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x02at\x12\x1d\n" +
|
||||
"\n" +
|
||||
"budget_key\x18\t \x01(\tR\tbudgetKey\"|\n" +
|
||||
"budget_key\x18\t \x01(\tR\tbudgetKey\x12\x1a\n" +
|
||||
"\bplatform\x18\n" +
|
||||
" \x01(\tR\bplatform\"|\n" +
|
||||
"\bToolCall\x12\x0e\n" +
|
||||
"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
|
||||
"\x04name\x18\x02 \x01(\tR\x04name\x12\x1e\n" +
|
||||
|
||||
@@ -35,6 +35,17 @@ type Inbound struct {
|
||||
// rate limited, which is correct for a source with no stable key of
|
||||
// its own (the dashboard).
|
||||
BudgetKey string
|
||||
// Platform is the channel that carried this message ("telegram",
|
||||
// "email", "webhook", "web"), named by the frontend that owns that
|
||||
// channel. It is how the Gateway learns which channel it is serving:
|
||||
// one Router serves all of them, so its own name is "web" even for a
|
||||
// Telegram turn, which made SessionSource.Platform -- the first
|
||||
// component of the session natural key -- a constant, and left the
|
||||
// per-user identity policy unreachable with a real channel name
|
||||
// (archie-core-c1qx). Transport-only and never persisted: the session
|
||||
// record keeps the platform. Empty means the sender did not name its
|
||||
// channel, and the Gateway falls back to its own name.
|
||||
Platform string
|
||||
}
|
||||
|
||||
// SpawnRequest is a chat-originated task creation request. Repo and
|
||||
|
||||
@@ -282,7 +282,7 @@ func (r *Router) route(ctx context.Context, in Inbound) (string, error) {
|
||||
text := strings.TrimSpace(in.Message.Text)
|
||||
cmd, _ := parseCmd(text, r.gatewayName)
|
||||
|
||||
if reply, handled, err := r.dispatchLocal(ctx, in.Message, text, cmd); handled {
|
||||
if reply, handled, err := r.dispatchLocal(ctx, in.Message, r.sessionPlatform(in), text, cmd); handled {
|
||||
return reply, err
|
||||
}
|
||||
|
||||
@@ -301,7 +301,7 @@ func (r *Router) route(ctx context.Context, in Inbound) (string, error) {
|
||||
|
||||
// dispatchLocal handles recognized local commands. Returns (reply,
|
||||
// true) when the command was recognized and handled.
|
||||
func (r *Router) dispatchLocal(ctx context.Context, msg messaging.Message, text, cmd string) (string, bool, error) {
|
||||
func (r *Router) dispatchLocal(ctx context.Context, msg messaging.Message, platform, text, cmd string) (string, bool, error) {
|
||||
rest := restAfter(text, cmd, r.gatewayName)
|
||||
|
||||
switch cmd {
|
||||
@@ -336,13 +336,13 @@ func (r *Router) dispatchLocal(ctx context.Context, msg messaging.Message, text,
|
||||
reply, err := r.handleProfile()
|
||||
return reply, true, err
|
||||
}
|
||||
return r.dispatchLocalMisc(ctx, msg, cmd, rest)
|
||||
return r.dispatchLocalMisc(ctx, msg, platform, cmd, rest)
|
||||
}
|
||||
|
||||
// dispatchLocalMisc handles the remaining recognized local commands not
|
||||
// covered by dispatchLocal's first switch. Split out to keep cyclomatic
|
||||
// complexity down.
|
||||
func (r *Router) dispatchLocalMisc(ctx context.Context, msg messaging.Message, cmd, rest string) (string, bool, error) {
|
||||
func (r *Router) dispatchLocalMisc(ctx context.Context, msg messaging.Message, platform, cmd, rest string) (string, bool, error) {
|
||||
switch cmd {
|
||||
case "/sessions":
|
||||
reply, err := r.handleSessions(ctx, msg)
|
||||
@@ -365,7 +365,7 @@ func (r *Router) dispatchLocalMisc(ctx context.Context, msg messaging.Message, c
|
||||
case "/restart":
|
||||
return r.handleRestartAdapter(ctx), true, nil
|
||||
}
|
||||
return r.dispatchSessionCommand(ctx, msg, cmd, rest)
|
||||
return r.dispatchSessionCommand(ctx, msg, platform, cmd, rest)
|
||||
}
|
||||
|
||||
// handleVersion reports the configured build version.
|
||||
@@ -403,13 +403,13 @@ func (r *Router) handleRestartAdapter(ctx context.Context) string {
|
||||
// (/new, /topic, /retry, /undo, /title, /branch, /compress and their
|
||||
// aliases). Split out from dispatchLocal to keep cyclomatic complexity
|
||||
// down.
|
||||
func (r *Router) dispatchSessionCommand(ctx context.Context, msg messaging.Message, cmd, rest string) (string, bool, error) {
|
||||
func (r *Router) dispatchSessionCommand(ctx context.Context, msg messaging.Message, platform, cmd, rest string) (string, bool, error) {
|
||||
switch cmd {
|
||||
case "/new", "/reset":
|
||||
reply, err := r.handleNew(ctx, msg, rest)
|
||||
reply, err := r.handleNew(ctx, msg, platform, rest)
|
||||
return reply, true, err
|
||||
case "/topic":
|
||||
reply, err := r.handleTopic(ctx, msg, rest)
|
||||
reply, err := r.handleTopic(ctx, msg, platform, rest)
|
||||
return reply, true, err
|
||||
case "/retry":
|
||||
reply, err := r.handleRetry(ctx, msg)
|
||||
@@ -421,7 +421,7 @@ func (r *Router) dispatchSessionCommand(ctx context.Context, msg messaging.Messa
|
||||
reply, err := r.handleTitle(ctx, msg, rest)
|
||||
return reply, true, err
|
||||
case "/branch", "/fork":
|
||||
reply, err := r.handleBranch(ctx, msg, rest)
|
||||
reply, err := r.handleBranch(ctx, msg, platform, rest)
|
||||
return reply, true, err
|
||||
case "/compress", "/compact":
|
||||
reply, err := r.handleCompress(ctx, msg, rest)
|
||||
|
||||
@@ -264,6 +264,19 @@ func sessionTrackerKey(channelID, threadID string) string {
|
||||
return channelID + ":" + threadID
|
||||
}
|
||||
|
||||
// sessionPlatform is the platform a session for this inbound belongs to: the
|
||||
// channel that carried the message when the frontend named itself, else the
|
||||
// Gateway's own name. Naming it is what makes SessionSource.Platform truthful --
|
||||
// one Router serves every channel, so its own name is "web" even for a Telegram
|
||||
// turn, which made the platform a constant and left the per-user identity policy
|
||||
// unreachable with a real channel name (archie-core-c1qx).
|
||||
func (r *Router) sessionPlatform(in Inbound) string {
|
||||
if in.Platform != "" {
|
||||
return in.Platform
|
||||
}
|
||||
return r.gatewayName
|
||||
}
|
||||
|
||||
// ResolveSessionKey resolves or creates a session for a message and
|
||||
// returns the session ID. This is the entry point the LLM responder
|
||||
// in main.go should call instead of its inline sessionKey helper.
|
||||
@@ -272,7 +285,7 @@ func (r *Router) ResolveSessionKey(ctx context.Context, in Inbound) (string, err
|
||||
if r.sessionTracker == nil {
|
||||
return sessionKeyFromFields(conv.ChannelID, conv.ThreadID), nil
|
||||
}
|
||||
return r.sessionTracker.resolve(ctx, r.gatewayName, r.Identity, conv.ChannelID, conv.ThreadID)
|
||||
return r.sessionTracker.resolve(ctx, r.sessionPlatform(in), r.Identity, conv.ChannelID, conv.ThreadID)
|
||||
}
|
||||
|
||||
// ── Router session command handlers ────────────────────────────────────────
|
||||
@@ -284,7 +297,7 @@ func (r *Router) handleStart() (string, error) {
|
||||
|
||||
// handleNew creates a fresh session for the current channel+thread,
|
||||
// optionally setting a title.
|
||||
func (r *Router) handleNew(ctx context.Context, msg messaging.Message, rest string) (string, error) {
|
||||
func (r *Router) handleNew(ctx context.Context, msg messaging.Message, platform, rest string) (string, error) {
|
||||
if r.sessionTracker == nil {
|
||||
return "Session management is not configured.", nil
|
||||
}
|
||||
@@ -296,7 +309,7 @@ func (r *Router) handleNew(ctx context.Context, msg messaging.Message, rest stri
|
||||
sc := SessionContext{
|
||||
SessionID: id,
|
||||
Source: SessionSource{
|
||||
Platform: r.gatewayName,
|
||||
Platform: platform,
|
||||
BotUser: r.Identity,
|
||||
ChannelID: msg.ConversationID.ChannelID,
|
||||
ThreadID: msg.ConversationID.ThreadID,
|
||||
@@ -319,7 +332,7 @@ func (r *Router) handleNew(ctx context.Context, msg messaging.Message, rest stri
|
||||
// handleTopic manages topic/session switching for threaded conversations.
|
||||
// "off" disables topic routing (reverts to flat), "help" shows info,
|
||||
// and a session-id switches to that session.
|
||||
func (r *Router) handleTopic(ctx context.Context, msg messaging.Message, rest string) (string, error) {
|
||||
func (r *Router) handleTopic(ctx context.Context, msg messaging.Message, platform, rest string) (string, error) {
|
||||
if r.sessionTracker == nil {
|
||||
return "Session management is not configured.", nil
|
||||
}
|
||||
@@ -331,9 +344,9 @@ func (r *Router) handleTopic(ctx context.Context, msg messaging.Message, rest st
|
||||
case "help":
|
||||
return topicHelpText(), nil
|
||||
case "":
|
||||
return r.topicListSessions(ctx, msg)
|
||||
return r.topicListSessions(ctx, msg, platform)
|
||||
default:
|
||||
return r.topicSwitchSession(ctx, msg, rest)
|
||||
return r.topicSwitchSession(ctx, msg, platform, rest)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -344,9 +357,9 @@ func topicHelpText() string {
|
||||
" <session-id> — switch to a session by the ID shown in /topic"
|
||||
}
|
||||
|
||||
func (r *Router) topicListSessions(ctx context.Context, msg messaging.Message) (string, error) {
|
||||
func (r *Router) topicListSessions(ctx context.Context, msg messaging.Message, platform string) (string, error) {
|
||||
active := r.sessionTracker.getActive(msg.ConversationID.ChannelID, msg.ConversationID.ThreadID)
|
||||
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, r.gatewayName, msg.ConversationID.ChannelID)
|
||||
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, platform, msg.ConversationID.ChannelID)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("list sessions: %w", err)
|
||||
}
|
||||
@@ -367,8 +380,8 @@ func (r *Router) topicListSessions(ctx context.Context, msg messaging.Message) (
|
||||
return b.String(), nil
|
||||
}
|
||||
|
||||
func (r *Router) topicSwitchSession(ctx context.Context, msg messaging.Message, rest string) (string, error) {
|
||||
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, r.gatewayName, msg.ConversationID.ChannelID)
|
||||
func (r *Router) topicSwitchSession(ctx context.Context, msg messaging.Message, platform, rest string) (string, error) {
|
||||
sessions, err := r.sessionTracker.sessions.GetByChannel(ctx, platform, msg.ConversationID.ChannelID)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("list sessions: %w", err)
|
||||
}
|
||||
@@ -507,7 +520,7 @@ func (r *Router) handleTitle(ctx context.Context, msg messaging.Message, rest st
|
||||
|
||||
// handleBranch creates a new child session that inherits the current
|
||||
// session's history. The new session becomes the active session.
|
||||
func (r *Router) handleBranch(ctx context.Context, msg messaging.Message, rest string) (string, error) {
|
||||
func (r *Router) handleBranch(ctx context.Context, msg messaging.Message, platform, rest string) (string, error) {
|
||||
if r.sessionTracker == nil {
|
||||
return "Session management is not configured.", nil
|
||||
}
|
||||
@@ -545,7 +558,7 @@ func (r *Router) handleBranch(ctx context.Context, msg messaging.Message, rest s
|
||||
sc := SessionContext{
|
||||
SessionID: id,
|
||||
Source: SessionSource{
|
||||
Platform: r.gatewayName,
|
||||
Platform: platform,
|
||||
BotUser: r.Identity,
|
||||
ChannelID: channelID,
|
||||
ThreadID: threadID,
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
package gateway
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
)
|
||||
|
||||
// TestResolveSessionKeyStampsTheMessagesPlatform is archie-core-c1qx's contract:
|
||||
// a session's platform is the channel that carried the message, not the
|
||||
// Gateway's own name. One Router serves every channel, so its own name is "web"
|
||||
// even for a Telegram turn, which made Source.Platform -- the first component of
|
||||
// the session natural key -- a constant, and left the per-user identity policy
|
||||
// unreachable with a real channel name.
|
||||
func TestResolveSessionKeyStampsTheMessagesPlatform(t *testing.T) {
|
||||
store := NewSessionStoreMemory()
|
||||
t.Cleanup(func() { _ = store.Close() })
|
||||
router := NewRouter(nil, nil, "web")
|
||||
router.Identity = "archie"
|
||||
router.InitSessions(store)
|
||||
ctx := context.Background()
|
||||
|
||||
telegram := Inbound{Platform: "telegram", Message: messaging.Message{
|
||||
ConversationID: messaging.ConversationID{ChannelID: "-100123"},
|
||||
SenderID: "42",
|
||||
Role: messaging.RoleUser,
|
||||
Text: "hello",
|
||||
}}
|
||||
id, err := router.ResolveSessionKey(ctx, telegram)
|
||||
if err != nil {
|
||||
t.Fatalf("ResolveSessionKey: %v", err)
|
||||
}
|
||||
session, err := store.Get(ctx, id)
|
||||
if err != nil {
|
||||
t.Fatalf("Get: %v", err)
|
||||
}
|
||||
if session.Source.Platform != "telegram" {
|
||||
t.Errorf("Source.Platform = %q, want %q: the channel that carried the message, not the Gateway's own name",
|
||||
session.Source.Platform, "telegram")
|
||||
}
|
||||
// The platform is the first component of the session lookup key, so a lookup
|
||||
// under the channel's name is what a later message in the same chat resolves
|
||||
// through. Under the Gateway's name it would miss and start a second session.
|
||||
found, err := store.GetByChannel(ctx, "telegram", "-100123")
|
||||
if err != nil {
|
||||
t.Fatalf("GetByChannel: %v", err)
|
||||
}
|
||||
if len(found) != 1 || found[0].SessionID != id {
|
||||
t.Errorf("GetByChannel(telegram, -100123) = %+v, want the session just resolved", found)
|
||||
}
|
||||
|
||||
// A frontend that does not name its channel keeps the Gateway's own name,
|
||||
// which is the behaviour every existing session row has.
|
||||
plain := Inbound{Message: messaging.Message{
|
||||
ConversationID: messaging.ConversationID{ChannelID: "-100999"},
|
||||
Role: messaging.RoleUser,
|
||||
Text: "no platform",
|
||||
}}
|
||||
plainID, err := router.ResolveSessionKey(ctx, plain)
|
||||
if err != nil {
|
||||
t.Fatalf("ResolveSessionKey(no platform): %v", err)
|
||||
}
|
||||
plainSession, err := store.Get(ctx, plainID)
|
||||
if err != nil {
|
||||
t.Fatalf("Get: %v", err)
|
||||
}
|
||||
if plainSession.Source.Platform != "web" {
|
||||
t.Errorf("Source.Platform = %q, want the Gateway's own name %q when the sender names none",
|
||||
plainSession.Source.Platform, "web")
|
||||
}
|
||||
}
|
||||
@@ -110,12 +110,17 @@ type TurnRunnerConfig struct {
|
||||
// same as a subject with no writable scope: no tools registered).
|
||||
MemoryWriter MemoryWriteStore
|
||||
// UserIdentity resolves the initiating user's identity for one inbound
|
||||
// message, per channel. False (or a nil UserIdentity) means the channel
|
||||
// carries no per-person identity -- the dashboard's one bearer token, or a
|
||||
// webhook's route path, which must never be treated as a person -- and
|
||||
// the turn's memory Subject gets no UserID, so its read is agent and
|
||||
// global scope only (docs/prds/memory-engine-unification.md §3, §4).
|
||||
UserIdentity func(msg messaging.Message) (memory.IdentityID, bool)
|
||||
// message, per platform. It reads the platform off the inbound rather than
|
||||
// closing over one, because a single Router serves every channel: a resolver
|
||||
// bound to a channel name received "web" for a Telegram turn, which left
|
||||
// Subject.UserID always empty in production (archie-core-c1qx).
|
||||
//
|
||||
// False (or a nil UserIdentity) means the platform carries no per-person
|
||||
// identity -- the dashboard's one bearer token, or a webhook route path,
|
||||
// which must never be treated as a person -- and the turn's memory Subject
|
||||
// gets no UserID, so its read is agent and global scope only
|
||||
// (docs/prds/memory-engine-unification.md §3, §4).
|
||||
UserIdentity func(in Inbound) (memory.IdentityID, bool)
|
||||
}
|
||||
|
||||
// TurnRunner owns one chat turn from session resolution through model
|
||||
@@ -304,10 +309,10 @@ type preparedTurn struct {
|
||||
// runs the session-level compression trigger, since that needs the same
|
||||
// model-derived budget the view is built against.
|
||||
func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, in Inbound, history []messaging.Message) (preparedTurn, error) {
|
||||
subject := r.resolveSubject(in.Message)
|
||||
subject := r.resolveSubject(in)
|
||||
extraTools := append(
|
||||
TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity),
|
||||
SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, in.Message)...,
|
||||
SessionTools(r.Sessions, r.Router.SessionTracker(), r.Router.sessionPlatform(in), in.Message)...,
|
||||
)
|
||||
extraTools = append(extraTools, ReviewTools(r.PRReviewer, r.TaskIdentity)...)
|
||||
// The dashboard tools (page_index, dashboard_navigate) belong to the web
|
||||
|
||||
@@ -7,7 +7,6 @@ import (
|
||||
"strings"
|
||||
|
||||
domainmemory "github.com/samcharles93/archie-core/internal/domain/memory"
|
||||
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
||||
)
|
||||
|
||||
// memoryRecordsPerScope bounds how many records of each scope the read path
|
||||
@@ -113,16 +112,19 @@ func renderMemoryRecords(records []domainmemory.Record, log *slog.Logger) string
|
||||
|
||||
// resolveSubject builds a turn's memory Subject from the runner's agent
|
||||
// identity (BotUser, the closest thing to an Agent id the tree records today
|
||||
// -- see sessioncurator.Adapter) and the channel's UserIdentity resolver. A
|
||||
// -- see sessioncurator.Adapter) and the session's UserIdentity resolver. A
|
||||
// nil resolver, or one that returns false, yields UserID "" -- Subject.Scopes
|
||||
// then names only agent and global, never a wider fallback
|
||||
// (docs/prds/memory-engine-unification.md §3, "fail closed").
|
||||
func (r *TurnRunner) resolveSubject(msg messaging.Message) domainmemory.Subject {
|
||||
//
|
||||
// It takes the whole inbound rather than its message because the resolver needs
|
||||
// the platform the message arrived on (archie-core-c1qx).
|
||||
func (r *TurnRunner) resolveSubject(in Inbound) domainmemory.Subject {
|
||||
subject := domainmemory.Subject{AgentID: domainmemory.AgentID(r.BotUser)}
|
||||
if r.UserIdentity == nil {
|
||||
return subject
|
||||
}
|
||||
if id, ok := r.UserIdentity(msg); ok {
|
||||
if id, ok := r.UserIdentity(in); ok {
|
||||
subject.UserID = id
|
||||
}
|
||||
return subject
|
||||
|
||||
@@ -20,11 +20,11 @@ func newMemoryTestEngine(t *testing.T) *infraMemory.BuiltinEngine {
|
||||
return infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
}
|
||||
|
||||
func telegramIdentity(msg messaging.Message) (domainmemory.IdentityID, bool) {
|
||||
if msg.SenderID == "" {
|
||||
func telegramIdentity(in Inbound) (domainmemory.IdentityID, bool) {
|
||||
if in.Message.SenderID == "" {
|
||||
return "", false
|
||||
}
|
||||
return domainmemory.IdentityID(msg.SenderID), true
|
||||
return domainmemory.IdentityID(in.Message.SenderID), true
|
||||
}
|
||||
|
||||
func chatMsg(sourceID, channelID, senderID, text string) Inbound {
|
||||
@@ -38,7 +38,7 @@ func chatMsg(sourceID, channelID, senderID, text string) Inbound {
|
||||
}}
|
||||
}
|
||||
|
||||
func newMemoryTestRunner(t *testing.T, engine MemoryStore, userIdentity func(messaging.Message) (domainmemory.IdentityID, bool), botUser string) (*TurnRunner, *turnTestPreparedModel) {
|
||||
func newMemoryTestRunner(t *testing.T, engine MemoryStore, userIdentity func(Inbound) (domainmemory.IdentityID, bool), botUser string) (*TurnRunner, *turnTestPreparedModel) {
|
||||
t.Helper()
|
||||
store := NewSessionStoreMemory()
|
||||
router := NewRouter(nil, nil, "telegram")
|
||||
|
||||
@@ -117,13 +117,16 @@ func TestWireValuesPreserveHistoryAndMedia(t *testing.T) {
|
||||
t.Fatalf("event round trip: %+v", got)
|
||||
}
|
||||
// Transport-only inbound context rides alongside the record and must
|
||||
// survive the hop: Page reaches the system prompt, and BudgetKey is what
|
||||
// the Gateway charges the message against when the channel has no
|
||||
// per-person SenderID to charge (a webhook route).
|
||||
// survive the hop: Page reaches the system prompt, BudgetKey is what the
|
||||
// Gateway charges the message against when the channel has no per-person
|
||||
// SenderID to charge (a webhook route), and Platform is how the Gateway
|
||||
// learns which channel it is serving -- one Router serves all of them
|
||||
// (archie-core-c1qx).
|
||||
in := gateway.Inbound{
|
||||
Message: messaging.Message{ConversationID: messaging.ConversationID{ChannelID: "/hook"}, Role: messaging.RoleUser, Text: "hi"},
|
||||
Page: "/tasks",
|
||||
BudgetKey: "/hook",
|
||||
Platform: "webhook",
|
||||
}
|
||||
if got := inboundValue(inboundProto(in)); !reflect.DeepEqual(got, in) {
|
||||
t.Fatalf("inbound round trip = %+v, want %+v", got, in)
|
||||
|
||||
@@ -55,12 +55,13 @@ func storedValue(v *pb.Message) messaging.Message {
|
||||
}
|
||||
|
||||
// inboundProto renders a channel message and its transport context in wire
|
||||
// shape. Page and BudgetKey ride along; the record's role does not, for the
|
||||
// reason storedProto gives.
|
||||
// shape. Page, BudgetKey and Platform ride along; the record's role does not, for
|
||||
// the reason storedProto gives.
|
||||
func inboundProto(v messaging.Inbound) *pb.Message {
|
||||
m := storedProto(v.Message)
|
||||
m.Page = v.Page
|
||||
m.BudgetKey = v.BudgetKey
|
||||
m.Platform = v.Platform
|
||||
return m
|
||||
}
|
||||
|
||||
@@ -74,7 +75,7 @@ func inboundValue(v *pb.Message) messaging.Inbound {
|
||||
}
|
||||
msg := storedValue(v)
|
||||
msg.Role = messaging.RoleUser
|
||||
return messaging.Inbound{Message: msg, Page: v.Page, BudgetKey: v.BudgetKey}
|
||||
return messaging.Inbound{Message: msg, Page: v.Page, BudgetKey: v.BudgetKey, Platform: v.Platform}
|
||||
}
|
||||
|
||||
func toolProto(v messaging.ToolCallEvent) *pb.ToolCall {
|
||||
|
||||
@@ -258,6 +258,9 @@ func (s *Server) decodeChatMessage(w http.ResponseWriter, r *http.Request) (mess
|
||||
Text: req.Text,
|
||||
},
|
||||
Page: req.Page,
|
||||
// The dashboard names the channel it carries; see the platform field's
|
||||
// note in internal/domain/messaging/inbound.go.
|
||||
Platform: "web",
|
||||
}, true
|
||||
}
|
||||
|
||||
|
||||
@@ -56,6 +56,13 @@ message Message {
|
||||
// sets it on inbound and it is never persisted, exactly like page. Empty
|
||||
// means the message is not rate limited.
|
||||
string budget_key = 9;
|
||||
// platform is the channel that carried this message ("telegram", "email",
|
||||
// "webhook", "web"), as the frontend that owns that channel knows it. It is
|
||||
// how the Gateway learns which channel it is serving: one Router serves every
|
||||
// channel, so its own name is "web" even for a Telegram turn, which made
|
||||
// Source.Platform -- the first component of the session natural key -- a
|
||||
// constant. Transport-only, never persisted: the session record keeps it.
|
||||
string platform = 10;
|
||||
}
|
||||
message ToolCall {
|
||||
string id = 1;
|
||||
|
||||
Reference in new issue
Block a user