diff --git a/internal/app/archied/chat_identity.go b/internal/app/archied/chat_identity.go index c78e4fa11..ae58682dc 100644 --- a/internal/app/archied/chat_identity.go +++ b/internal/app/archied/chat_identity.go @@ -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 } diff --git a/internal/app/archied/chat_identity_test.go b/internal/app/archied/chat_identity_test.go index d5908621c..d7b415587 100644 --- a/internal/app/archied/chat_identity_test.go +++ b/internal/app/archied/chat_identity_test.go @@ -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) } } diff --git a/internal/app/archied/chat_setup.go b/internal/app/archied/chat_setup.go index 9eb882292..2777ff1ec 100644 --- a/internal/app/archied/chat_setup.go +++ b/internal/app/archied/chat_setup.go @@ -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 { diff --git a/internal/channels/email/email.go b/internal/channels/email/email.go index a3c17dcd1..d1437e99a 100644 --- a/internal/channels/email/email.go +++ b/internal/channels/email/email.go @@ -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) diff --git a/internal/channels/telegram/telegram.go b/internal/channels/telegram/telegram.go index 4bf5cc9a5..80340ad57 100644 --- a/internal/channels/telegram/telegram.go +++ b/internal/channels/telegram/telegram.go @@ -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 diff --git a/internal/channels/webhook/webhook.go b/internal/channels/webhook/webhook.go index 6062ac3c3..2725b0cba 100644 --- a/internal/channels/webhook/webhook.go +++ b/internal/channels/webhook/webhook.go @@ -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 { diff --git a/internal/contracts/gateway/v1/chat.pb.go b/internal/contracts/gateway/v1/chat.pb.go index 504314373..2ac2e202b 100644 --- a/internal/contracts/gateway/v1/chat.pb.go +++ b/internal/contracts/gateway/v1/chat.pb.go @@ -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" + diff --git a/internal/domain/messaging/inbound.go b/internal/domain/messaging/inbound.go index f1a9abb13..d56bdf884 100644 --- a/internal/domain/messaging/inbound.go +++ b/internal/domain/messaging/inbound.go @@ -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 diff --git a/internal/gateway/gateway.go b/internal/gateway/gateway.go index d38adcc87..75cf57c85 100644 --- a/internal/gateway/gateway.go +++ b/internal/gateway/gateway.go @@ -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) diff --git a/internal/gateway/session_commands.go b/internal/gateway/session_commands.go index c5a399f8a..fda76f36f 100644 --- a/internal/gateway/session_commands.go +++ b/internal/gateway/session_commands.go @@ -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 { " — 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, diff --git a/internal/gateway/session_platform_test.go b/internal/gateway/session_platform_test.go new file mode 100644 index 000000000..7d0efd331 --- /dev/null +++ b/internal/gateway/session_platform_test.go @@ -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") + } +} diff --git a/internal/gateway/turn.go b/internal/gateway/turn.go index 006a9cc8a..3f64c0d4a 100644 --- a/internal/gateway/turn.go +++ b/internal/gateway/turn.go @@ -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 diff --git a/internal/gateway/turn_memory.go b/internal/gateway/turn_memory.go index 7f680f590..b533a5184 100644 --- a/internal/gateway/turn_memory.go +++ b/internal/gateway/turn_memory.go @@ -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 diff --git a/internal/gateway/turn_memory_test.go b/internal/gateway/turn_memory_test.go index 2a5dce552..c6c5fdc14 100644 --- a/internal/gateway/turn_memory_test.go +++ b/internal/gateway/turn_memory_test.go @@ -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") diff --git a/internal/infrastructure/gatewayrpc/conformance_test.go b/internal/infrastructure/gatewayrpc/conformance_test.go index b23a80c10..fc472dae3 100644 --- a/internal/infrastructure/gatewayrpc/conformance_test.go +++ b/internal/infrastructure/gatewayrpc/conformance_test.go @@ -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) diff --git a/internal/infrastructure/gatewayrpc/values.go b/internal/infrastructure/gatewayrpc/values.go index cfd75f188..b519e5b69 100644 --- a/internal/infrastructure/gatewayrpc/values.go +++ b/internal/infrastructure/gatewayrpc/values.go @@ -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 { diff --git a/internal/webui/api_chat.go b/internal/webui/api_chat.go index 7ff8543e9..a8401ae40 100644 --- a/internal/webui/api_chat.go +++ b/internal/webui/api_chat.go @@ -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 } diff --git a/proto/gateway/v1/chat.proto b/proto/gateway/v1/chat.proto index 1d1499645..cc7406a1f 100644 --- a/proto/gateway/v1/chat.proto +++ b/proto/gateway/v1/chat.proto @@ -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;