From 1fe4691bd62302ff3e65f579a263a295146ee21d Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Tue, 22 Sep 2026 03:18:59 +1000 Subject: [PATCH] fix(webhook): keep a route path out of the sender identity A webhook set SenderID to its configured route path. The turn path reads that field through a per-channel resolver which refuses webhook, but the session curator derives its participant from the raw field with no channel filter, so a webhook session with exactly one distinct sender and one extracted fact wrote agent-user memory addressed to User: "/hooks/...". Nothing reads it, and every pass added more, because the facts are identical strings with no dedup. docs/prds/memory-engine-unification.md criterion 7 requires that a route path never become a user identity. Clear it at the producer rather than teaching every consumer which channels are lying: a route path is a source, not a person, so it no longer enters SenderID. It still keys the inbound rate limit, where it is the documented per-source budget for webhooks (config.RateLimitConfig), so it travels in the new transport-only Inbound.BudgetKey -- carried on the wire beside Page, never persisted, and never read as an identity. pb.Message gains budget_key (field 9) for the same reason page (field 7) exists: transport context that rides with an inbound message and is deliberately absent from storedProto's rendering of a canonical record. The curator needs no change. An empty SenderID already fails closed as an unidentified user message, which is the path a dashboard session takes, and sessionParticipant's existing skip covers it; the test name now says so. --- config.example.toml | 5 +- docs/prds/memory-engine-unification.md | 21 ++++---- internal/app/archied/chat_identity.go | 14 ++--- internal/channels/webhook/webhook.go | 27 ++++++---- internal/channels/webhook/webhook_test.go | 25 ++++++--- internal/config/config.go | 7 ++- internal/contracts/gateway/v1/chat.pb.go | 38 ++++++++++---- internal/domain/memory/contract.go | 4 +- internal/domain/messaging/inbound.go | 13 +++++ internal/domain/messaging/message.go | 14 +++-- internal/gateway/gateway.go | 41 ++++++++++----- internal/gateway/gateway_ratelimit_test.go | 52 +++++++++++++++++-- .../gatewayrpc/conformance_test.go | 12 +++++ internal/infrastructure/gatewayrpc/values.go | 7 +-- .../sessioncurator/sessioncurator_test.go | 7 ++- proto/gateway/v1/chat.proto | 7 +++ 16 files changed, 220 insertions(+), 74 deletions(-) diff --git a/config.example.toml b/config.example.toml index 25a9c2ae3..4ac131ea1 100644 --- a/config.example.toml +++ b/config.example.toml @@ -186,8 +186,9 @@ class = "ollama" # Per-(channel, sender) inbound rate limiting, shared by every chat channel: # Telegram keys by numeric user ID, email by SMTP from address, webhook by -# its configured route path. Off by default -- both fields must be set to a -# positive value. +# its configured route path -- a source, not a person, so it reaches the +# limiter as a transport-only budget key rather than as an identity. Off by +# default -- both fields must be set to a positive value. # [chat.rate_limit] # window = "1m" # max_requests = 20 diff --git a/docs/prds/memory-engine-unification.md b/docs/prds/memory-engine-unification.md index 23a47ecda..89ecaee07 100644 --- a/docs/prds/memory-engine-unification.md +++ b/docs/prds/memory-engine-unification.md @@ -36,11 +36,13 @@ Three further defects fall out of the same split: string`, and the curator fills it with a **session id** (`sessioncurator.go`) — which is none of the four scopes `docs/architecture/agent-system.md` requires, and stops meaning anything when the session ends. -3. **The chat turn has no user identity on half the channels.** `SenderID` is - populated by Telegram and email (a person) and by webhook (a **route path**, - `webhook.go`), and not at all by the dashboard, whose gateway wire message - carries no sender field. It is also never persisted: `sender_id` appears - nowhere in `session_store_sqlite.go`. +3. **The chat turn has no user identity on half the channels.** Telegram and + email populate `SenderID` with a person; the dashboard populates it with + nothing, and a webhook populates it with nothing either — a route path names + a source, not a person, so `webhook.go` leaves `SenderID` empty and carries + the route in `Inbound.BudgetKey` for rate limiting. `sender_id` is persisted + (`session_store_sqlite.go`), so whatever a channel puts there reaches the + consumers that read it. `agent-system.md` says the write-scope selection and cross-scope sharing rules "require a focused memory design decision". This is that decision. @@ -149,10 +151,11 @@ UserIdentity func(msg messaging.Message) (IdentityID, bool) ``` This must be injectable rather than a blanket `channel + ":" + SenderID` -concatenation, because a **webhook's `SenderID` is a route path** -(`webhook.go`), not a person; treating it as one would give a URL an -identity. Telegram and email supply their sender id; the dashboard and webhook -resolve nothing. +concatenation, because a channel's sender id is not necessarily a person: a +webhook's route path names a source, and treating it as an identity would give +a URL one -- which is why `webhook.go` leaves `SenderID` empty and carries the +route in `Inbound.BudgetKey` instead. Telegram and email supply their sender +id; the dashboard and webhook resolve nothing. **Fail closed.** When `UserID` is empty the turn proceeds with global and agent scopes only, and a write targeting `user` or `agent-user` fails with a clear diff --git a/internal/app/archied/chat_identity.go b/internal/app/archied/chat_identity.go index 96611c345..c78e4fa11 100644 --- a/internal/app/archied/chat_identity.go +++ b/internal/app/archied/chat_identity.go @@ -13,12 +13,14 @@ import ( // // 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's SenderID is the configured route path -// (internal/channels/webhook/webhook.go), not a person -- treating either as -// an identity would give a URL or a shared token 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). +// 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 { case "telegram", "email": diff --git a/internal/channels/webhook/webhook.go b/internal/channels/webhook/webhook.go index c3b3fe22b..6062ac3c3 100644 --- a/internal/channels/webhook/webhook.go +++ b/internal/channels/webhook/webhook.go @@ -170,16 +170,23 @@ func (g *Gateway) handleWebhook(route *RouteConfig) http.HandlerFunc { return } - msg := messaging.Inbound{Message: messaging.Message{ - ConversationID: messaging.ConversationID{ChannelID: route.Path}, - Sender: "webhook", - // Webhooks have no per-caller identity; the configured route - // is the closest thing to one, since it corresponds to a - // single external source. - SenderID: route.Path, - Role: messaging.RoleUser, - Text: text, - }} + msg := messaging.Inbound{ + Message: messaging.Message{ + ConversationID: messaging.ConversationID{ChannelID: route.Path}, + Sender: "webhook", + // A webhook has no per-caller identity, so SenderID stays + // empty: consumers read it as a person + // (internal/app/archied/chat_identity.go, sessioncurator), + // and a route path must never become a user identity + // (docs/prds/memory-engine-unification.md criterion 7). + Role: messaging.RoleUser, + Text: text, + }, + // The route is still this message's source for inbound rate + // limiting, so it travels in the transport-only BudgetKey + // rather than borrowing the identity field. + BudgetKey: route.Path, + } reply, err := client.Route(r.Context(), msg) if err != nil { g.log.Error("webhook route", "err", err, "path", route.Path) diff --git a/internal/channels/webhook/webhook_test.go b/internal/channels/webhook/webhook_test.go index 920ed5d43..71f31e1a1 100644 --- a/internal/channels/webhook/webhook_test.go +++ b/internal/channels/webhook/webhook_test.go @@ -87,10 +87,10 @@ func TestWebhookHandlerNotStarted(t *testing.T) { func TestWebhookHandlerRoute(t *testing.T) { log := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})) g := New("", 0, []RouteConfig{{Path: "/hook"}}, log) - var gotSenderID string + var got messaging.Inbound g.client = &fakeChatContract{ - routeFunc: func(ctx context.Context, in messaging.Inbound) (messaging.ChatReply, error) { - gotSenderID = in.Message.SenderID + routeFunc: func(_ context.Context, in messaging.Inbound) (messaging.ChatReply, error) { + got = in return messaging.ChatReply{Text: "ok"}, nil }, } @@ -102,10 +102,21 @@ func TestWebhookHandlerRoute(t *testing.T) { if rec.Code != http.StatusAccepted { t.Errorf("status = %d, want 202", rec.Code) } - // Webhook has no native per-caller identity, so the configured route - // path is used to key rate limiting instead (see internal/ratelimit). - if gotSenderID != "/hook" { - t.Errorf("SenderID = %q, want the route path", gotSenderID) + // A webhook has no per-caller identity, and the route path is not one: + // several consumers read SenderID as a person + // (internal/app/archied/chat_identity.go, sessioncurator), and criterion + // 7 of docs/prds/memory-engine-unification.md says a route path must + // never become one. It still keys this message's inbound rate limit, so + // it travels in the transport-only BudgetKey instead -- see + // internal/ratelimit and config.RateLimitConfig. + if got.Message.SenderID != "" { + t.Errorf("SenderID = %q, want empty: a route path is not a person", got.Message.SenderID) + } + if got.BudgetKey != "/hook" { + t.Errorf("BudgetKey = %q, want the route path", got.BudgetKey) + } + if got.Message.ConversationID.ChannelID != "/hook" { + t.Errorf("ConversationID.ChannelID = %q, want the route path", got.Message.ConversationID.ChannelID) } } diff --git a/internal/config/config.go b/internal/config/config.go index 99a1d3bbc..f51770a47 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -975,8 +975,11 @@ type ChatConfig struct { // RateLimitConfig configures the sliding-window inbound rate limiter // (internal/ratelimit) shared by every chat channel. A sender is // identified per channel: Telegram by numeric user ID, email by the SMTP -// from address, webhook by the configured route path. Disabled unless -// both fields are set to a positive value. +// from address, webhook by the configured route path -- which is a source, +// not a person, so it reaches the limiter through the transport-only +// Inbound.BudgetKey rather than through SenderID (see +// docs/prds/memory-engine-unification.md §3). Disabled unless both fields +// are set to a positive value. type RateLimitConfig struct { // Window is the rolling interval MaxRequests is budgeted over. Window time.Duration `toml:"window" yaml:"window"` diff --git a/internal/contracts/gateway/v1/chat.pb.go b/internal/contracts/gateway/v1/chat.pb.go index 2c34c8a05..504314373 100644 --- a/internal/contracts/gateway/v1/chat.pb.go +++ b/internal/contracts/gateway/v1/chat.pb.go @@ -139,15 +139,22 @@ func (x *Session) GetLastActiveAt() *timestamppb.Timestamp { } type Message struct { - state protoimpl.MessageState `protogen:"open.v1"` - MessageId string `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"` - SourceId string `protobuf:"bytes,2,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"` - ChannelId string `protobuf:"bytes,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` - ThreadId string `protobuf:"bytes,4,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"` - From string `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"` - Text string `protobuf:"bytes,6,opt,name=text,proto3" json:"text,omitempty"` - Page string `protobuf:"bytes,7,opt,name=page,proto3" json:"page,omitempty"` - At *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=at,proto3" json:"at,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + MessageId string `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"` + SourceId string `protobuf:"bytes,2,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"` + ChannelId string `protobuf:"bytes,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` + ThreadId string `protobuf:"bytes,4,opt,name=thread_id,json=threadId,proto3" json:"thread_id,omitempty"` + From string `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"` + Text string `protobuf:"bytes,6,opt,name=text,proto3" json:"text,omitempty"` + Page string `protobuf:"bytes,7,opt,name=page,proto3" json:"page,omitempty"` + At *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=at,proto3" json:"at,omitempty"` + // budget_key is the source an inbound message is charged against by the + // Gateway's inbound rate limiter, for a channel that has no per-person + // sender id but does have a stable, operator-controlled source of its own + // -- 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"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -238,6 +245,13 @@ func (x *Message) GetAt() *timestamppb.Timestamp { return nil } +func (x *Message) GetBudgetKey() string { + if x != nil { + return x.BudgetKey + } + return "" +} + type ToolCall struct { state protoimpl.MessageState `protogen:"open.v1"` Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` @@ -2758,7 +2772,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\"\xe9\x01\n" + + " \x01(\v2\x1a.google.protobuf.TimestampR\flastActiveAt\"\x88\x02\n" + "\aMessage\x12\x1d\n" + "\n" + "message_id\x18\x01 \x01(\tR\tmessageId\x12\x1b\n" + @@ -2769,7 +2783,9 @@ const file_gateway_v1_chat_proto_rawDesc = "" + "\x04from\x18\x05 \x01(\tR\x04from\x12\x12\n" + "\x04text\x18\x06 \x01(\tR\x04text\x12\x12\n" + "\x04page\x18\a \x01(\tR\x04page\x12*\n" + - "\x02at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x02at\"|\n" + + "\x02at\x18\b \x01(\v2\x1a.google.protobuf.TimestampR\x02at\x12\x1d\n" + + "\n" + + "budget_key\x18\t \x01(\tR\tbudgetKey\"|\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/memory/contract.go b/internal/domain/memory/contract.go index 2f62aae25..447c6b97e 100644 --- a/internal/domain/memory/contract.go +++ b/internal/domain/memory/contract.go @@ -90,8 +90,8 @@ const ( // AgentID and IdentityID are opaque. This package never resolves them, // canonicalises them, or invents one from a channel: resolution happens // where the channel's native identity is in hand (the gateway turn path), -// because a webhook's sender id is a route path and treating it as a person -// would give a URL an identity. +// because a channel's sender id is not necessarily a person -- treating one +// as a person would give a URL an identity. type ( AgentID string IdentityID string diff --git a/internal/domain/messaging/inbound.go b/internal/domain/messaging/inbound.go index 16aca807b..f1a9abb13 100644 --- a/internal/domain/messaging/inbound.go +++ b/internal/domain/messaging/inbound.go @@ -22,6 +22,19 @@ type Inbound struct { // this message. Transport-only: it reaches the system prompt and // is never persisted. Empty for non-web channels. Page string + // BudgetKey is what the Gateway charges this message against in its + // inbound rate limiter (internal/ratelimit), for a channel whose + // Message.SenderID is empty because it carries no per-person + // identity but still has a stable, operator-controlled source to + // budget -- a webhook's configured route path, today. It is + // deliberately not SenderID: SenderID means "this is who sent it", + // and several consumers (internal/app/archied/chat_identity.go, + // sessioncurator) read it as a person, so a route path in that field + // becomes a user identity. BudgetKey is transport-only and never + // persisted, exactly like Page. Empty means the message is not + // rate limited, which is correct for a source with no stable key of + // its own (the dashboard). + BudgetKey string } // SpawnRequest is a chat-originated task creation request. Repo and diff --git a/internal/domain/messaging/message.go b/internal/domain/messaging/message.go index a75e00943..5a6b47161 100644 --- a/internal/domain/messaging/message.go +++ b/internal/domain/messaging/message.go @@ -91,11 +91,15 @@ type Message struct { Sender string // SenderID is the channel-native stable identifier for the party that - // sent this message (e.g. a Telegram numeric user ID, an SMTP from - // address, or a webhook route path), distinct from Sender's - // human-readable display form. Empty when the channel has no stable - // per-sender identity to offer. Used to key per-identity inbound - // controls such as rate limiting. + // sent this message (e.g. a Telegram numeric user ID or an SMTP from + // address), distinct from Sender's human-readable display form. Empty + // when the channel has no stable per-person identity to offer -- which + // includes a webhook, whose configured route path is a source rather + // than a person and travels in the transport-only Inbound.BudgetKey + // instead (see docs/prds/memory-engine-unification.md §3). Used to key + // per-identity inbound controls and to derive a memory participant, so + // a non-person value here becomes a user identity to every consumer + // that reads it. SenderID string Role Role diff --git a/internal/gateway/gateway.go b/internal/gateway/gateway.go index 5626ed244..d38adcc87 100644 --- a/internal/gateway/gateway.go +++ b/internal/gateway/gateway.go @@ -203,10 +203,12 @@ type Router struct { // path. Nil drops those diagnostics silently; nothing on this path is // important enough to fail the turn over. Log *slog.Logger - // Limiter enforces a per-(gateway, sender) inbound budget when set. - // Nil disables rate limiting entirely. Messages with no SenderID - // (channels that cannot supply a stable per-sender identity) are - // never limited, since there is no key to charge them against. + // Limiter enforces a per-(gateway, source) inbound budget when set. + // Nil disables rate limiting entirely. A message is charged against + // Inbound.BudgetKey when the channel set one (a webhook route, which + // has a stable source but no person), else against Message.SenderID. + // A message with neither is never limited: there is no key to charge + // it against. Limiter *ratelimit.Limiter sessionTracker *sessionTracker gatewayName string @@ -240,21 +242,34 @@ func (r *Router) SessionTracker() *sessionTracker { // budget, in place of normal dispatch. const rateLimitReply = "You're sending messages too quickly. Please wait a moment and try again." -// checkRateLimit reports whether msg is over its sender's inbound budget. -// A nil Limiter (rate limiting not configured) or an empty SenderID -// (the channel has no stable per-sender identity to charge) always -// allows. -func (r *Router) checkRateLimit(msg messaging.Message) (blocked bool) { - if r.Limiter == nil || msg.SenderID == "" { +// checkRateLimit reports whether in is over its source's inbound budget. +// A nil Limiter (rate limiting not configured) or no key to charge the +// message against (see inboundBudgetKey) always allows. +func (r *Router) checkRateLimit(in Inbound) (blocked bool) { + key := inboundBudgetKey(in) + if r.Limiter == nil || key == "" { return false } - return !r.Limiter.Allow(r.gatewayName, msg.SenderID) + return !r.Limiter.Allow(r.gatewayName, key) +} + +// inboundBudgetKey returns the key this message's inbound budget is charged +// against: the channel's own transport budget key when it set one, else the +// per-person SenderID. The two are deliberately distinct -- SenderID means +// "who sent this", and a channel whose SenderID is not a person (a webhook +// route path) must not put it there, because several consumers read that +// field as a user identity (docs/prds/memory-engine-unification.md §3). +func inboundBudgetKey(in Inbound) string { + if in.BudgetKey != "" { + return in.BudgetKey + } + return in.Message.SenderID } // Route dispatches msg and returns the reply. Gateway-local commands // are handled directly; everything else goes to the LLM responder. func (r *Router) Route(ctx context.Context, in Inbound) (string, error) { - if r.checkRateLimit(in.Message) { + if r.checkRateLimit(in) { return rateLimitReply, nil } return r.route(ctx, in) @@ -433,7 +448,7 @@ func (r *Router) RouteStream(ctx context.Context, in Inbound, stream TurnStream) if r.LLMStream == nil || stream == nil { return r.Route(ctx, in) } - if r.checkRateLimit(in.Message) { + if r.checkRateLimit(in) { return rateLimitReply, nil } cmd, _ := parseCmd(strings.TrimSpace(in.Message.Text), r.gatewayName) diff --git a/internal/gateway/gateway_ratelimit_test.go b/internal/gateway/gateway_ratelimit_test.go index a0cf4261a..be127d6b1 100644 --- a/internal/gateway/gateway_ratelimit_test.go +++ b/internal/gateway/gateway_ratelimit_test.go @@ -68,9 +68,11 @@ func TestRouteNoLimiterConfiguredNeverBlocks(t *testing.T) { } // TestRouteEmptySenderIDNeverLimited pins the deliberate fail-open for -// channels (webhook routes with no configured path identity, e.g.) that -// have no stable per-sender identity to charge: there is no shared key to -// throttle everyone under, so they are left unlimited rather than blocked. +// channels that have no stable per-sender identity to charge and no key of +// their own to budget against: there is no shared key to throttle everyone +// under, so they are left unlimited rather than blocked. A channel that has +// a stable source but no per-person identity (a webhook route) sets +// Inbound.BudgetKey instead -- see TestRouteBudgetKeyLimitsWithoutSenderID. func TestRouteEmptySenderIDNeverLimited(t *testing.T) { r := NewRouter(nil, fakeLLM, "test") r.Limiter = ratelimit.New(time.Minute, 1) @@ -86,6 +88,50 @@ func TestRouteEmptySenderIDNeverLimited(t *testing.T) { } } +// TestRouteBudgetKeyLimitsWithoutSenderID pins the split between a message's +// per-person identity and the key it is rate limited against. A webhook has +// no person to identify, so SenderID stays empty, but its route is still a +// bounded, operator-controlled source that must keep its budget -- otherwise +// clearing SenderID would silently exempt every webhook route from the +// limiter config.RateLimitConfig documents. +func TestRouteBudgetKeyLimitsWithoutSenderID(t *testing.T) { + r := NewRouter(nil, fakeLLM, "test") + r.Limiter = ratelimit.New(time.Minute, 1) + + budgeted := func(budgetKey, text string) Inbound { + in := inbound("chat-1", text) + in.BudgetKey = budgetKey + return in + } + + reply, err := r.Route(context.Background(), budgeted("/hook", "hello")) + if err != nil { + t.Fatalf("Route: %v", err) + } + if reply != "llm: hello" { + t.Fatalf("first message reply = %q, want it to reach the LLM", reply) + } + + reply, err = r.Route(context.Background(), budgeted("/hook", "hello again")) + if err != nil { + t.Fatalf("Route: %v", err) + } + if reply != rateLimitReply { + t.Fatalf("second message reply = %q, want the rate-limit reply", reply) + } + + // A different route is a different source, so it is unaffected by the + // first route's spent budget -- the same per-source property + // TestRouteRateLimitIsPerSender pins for real senders. + reply, err = r.Route(context.Background(), budgeted("/other", "hello")) + if err != nil { + t.Fatalf("Route: %v", err) + } + if reply != "llm: hello" { + t.Fatalf("other route reply = %q, want it unaffected by /hook's budget", reply) + } +} + // TestRouteStreamLocalCommandChargesExactlyOnce pins RouteStream's local // command fallthrough (into route, not Route) against double-charging the // budget: a status query must consume the same one unit whether it goes diff --git a/internal/infrastructure/gatewayrpc/conformance_test.go b/internal/infrastructure/gatewayrpc/conformance_test.go index 2c6052651..b23a80c10 100644 --- a/internal/infrastructure/gatewayrpc/conformance_test.go +++ b/internal/infrastructure/gatewayrpc/conformance_test.go @@ -116,6 +116,18 @@ func TestWireValuesPreserveHistoryAndMedia(t *testing.T) { if got := eventValue(eventProto(event)); !reflect.DeepEqual(got, event) { 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). + in := gateway.Inbound{ + Message: messaging.Message{ConversationID: messaging.ConversationID{ChannelID: "/hook"}, Role: messaging.RoleUser, Text: "hi"}, + Page: "/tasks", + BudgetKey: "/hook", + } + if got := inboundValue(inboundProto(in)); !reflect.DeepEqual(got, in) { + t.Fatalf("inbound round trip = %+v, want %+v", got, in) + } if got := inboundValue(inboundProto(gateway.Inbound{})); !got.Message.At.IsZero() { t.Fatalf("zero time became %v", got.Message.At) } diff --git a/internal/infrastructure/gatewayrpc/values.go b/internal/infrastructure/gatewayrpc/values.go index bcec10a4b..cfd75f188 100644 --- a/internal/infrastructure/gatewayrpc/values.go +++ b/internal/infrastructure/gatewayrpc/values.go @@ -55,11 +55,12 @@ func storedValue(v *pb.Message) messaging.Message { } // inboundProto renders a channel message and its transport context in wire -// shape. Page rides along; the record's role does not, for the reason -// storedProto gives. +// shape. Page and BudgetKey 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 return m } @@ -73,7 +74,7 @@ func inboundValue(v *pb.Message) messaging.Inbound { } msg := storedValue(v) msg.Role = messaging.RoleUser - return messaging.Inbound{Message: msg, Page: v.Page} + return messaging.Inbound{Message: msg, Page: v.Page, BudgetKey: v.BudgetKey} } func toolProto(v messaging.ToolCallEvent) *pb.ToolCall { diff --git a/internal/infrastructure/sessioncurator/sessioncurator_test.go b/internal/infrastructure/sessioncurator/sessioncurator_test.go index 8b3391411..df30604f9 100644 --- a/internal/infrastructure/sessioncurator/sessioncurator_test.go +++ b/internal/infrastructure/sessioncurator/sessioncurator_test.go @@ -358,7 +358,12 @@ func TestPassSkipsSessionsWithoutASingleParticipant(t *testing.T) { wantReason string }{ { - name: "zero senders: a dashboard session carries no per-person identity", + // Both producers are pinned by their own packages: the webhook + // clears SenderID and carries the route in Inbound.BudgetKey + // (internal/channels/webhook), the dashboard never sets one. + // Either way the session arrives here with nothing that names a + // person, which is the input this case pins. + name: "zero senders: a dashboard or webhook session carries no per-person identity", messages: []curator.ConversationMessage{{Role: "user", Content: "hello"}}, wantReason: "no single participant: 0 distinct sender(s), 1 unidentified user message(s)", }, diff --git a/proto/gateway/v1/chat.proto b/proto/gateway/v1/chat.proto index a0762082b..1d1499645 100644 --- a/proto/gateway/v1/chat.proto +++ b/proto/gateway/v1/chat.proto @@ -49,6 +49,13 @@ message Message { string text = 6; string page = 7; google.protobuf.Timestamp at = 8; + // budget_key is the source an inbound message is charged against by the + // Gateway's inbound rate limiter, for a channel that has no per-person + // sender id but does have a stable, operator-controlled source of its own + // -- 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. + string budget_key = 9; } message ToolCall { string id = 1;