fix: address business sends with the account-scoped peer

A reply on behalf of a business account failed with BUSINESS_PEER_INVALID
because the send re-resolved the chat through the bot's peer store, whose
access hash is invalid in the business context. Capture the input peer from
the update's entities during business-message conversion (Message.businessPeer)
and address replies through a PeerRef built from it, bypassing the store.
Context.Chat/Reply now target this peer, and Context.BusinessChat() exposes it
for explicit sends. Update the business example to use it.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

business_send_test.go

@@ -113,6 +113,39 @@ func TestContextReplyBusiness(t *testing.T) {
 	}
 }
 
+func TestBusinessReplyUsesEntitiesPeer(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.InvokeWithBusinessConnectionRequestTypeID, businessSendReply())
+
+	b := newMockBot(inv)
+	b.OnBusinessMessage(func(c *Context) error {
+		_, err := c.Reply("hi")
+
+		return err
+	})
+
+	// The update delivers the chat's access hash (555) in its entities; the reply
+	// must address the peer with that hash, not the bot's stored one.
+	e := tg.Entities{Users: map[int64]*tg.User{10: {ID: 10, AccessHash: 555}}}
+	msg := &tg.Message{ID: 7, PeerID: &tg.PeerUser{UserID: 10}}
+
+	b.dispatchBusinessMessage(context.Background(), e, "bc1", msg, false)
+
+	wrapper := tg.InvokeWithBusinessConnectionRequest{Query: &tg.MessagesSendMessageRequest{}}
+
+	inv.decode(t, tg.InvokeWithBusinessConnectionRequestTypeID, &wrapper)
+
+	sm, ok := wrapper.Query.(*tg.MessagesSendMessageRequest)
+	if !ok {
+		t.Fatalf("query = %#v", wrapper.Query)
+	}
+
+	peer, ok := sm.Peer.(*tg.InputPeerUser)
+	if !ok || peer.UserID != 10 || peer.AccessHash != 555 {
+		t.Fatalf("peer = %#v, want user 10 with access hash 555", sm.Peer)
+	}
+}
+
 func TestContextSendBusiness(t *testing.T) {
 	inv := newMockInvoker()
 	inv.reply(tg.InvokeWithBusinessConnectionRequestTypeID, businessSendReply())

business_updates.go

@@ -15,13 +15,13 @@ func (b *Bot) installBusinessHandlers() {
 
 		return nil
 	})
-	b.disp.OnBotNewBusinessMessage(func(ctx context.Context, _ tg.Entities, u *tg.UpdateBotNewBusinessMessage) error {
-		b.dispatchBusinessMessage(ctx, u.ConnectionID, u.Message, false)
+	b.disp.OnBotNewBusinessMessage(func(ctx context.Context, e tg.Entities, u *tg.UpdateBotNewBusinessMessage) error {
+		b.dispatchBusinessMessage(ctx, e, u.ConnectionID, u.Message, false)
 
 		return nil
 	})
-	b.disp.OnBotEditBusinessMessage(func(ctx context.Context, _ tg.Entities, u *tg.UpdateBotEditBusinessMessage) error {
-		b.dispatchBusinessMessage(ctx, u.ConnectionID, u.Message, true)
+	b.disp.OnBotEditBusinessMessage(func(ctx context.Context, e tg.Entities, u *tg.UpdateBotEditBusinessMessage) error {
+		b.dispatchBusinessMessage(ctx, e, u.ConnectionID, u.Message, true)
 
 		return nil
 	})
@@ -47,7 +47,7 @@ func (b *Bot) installBusinessHandlers() {
 // and routes it as a (edited) business message. Unlike dispatchMessage it keeps
 // outgoing messages: the Bot API delivers the whole business conversation,
 // including messages the account itself sent.
-func (b *Bot) dispatchBusinessMessage(ctx context.Context, connectionID string, msg tg.MessageClass, edited bool) {
+func (b *Bot) dispatchBusinessMessage(ctx context.Context, e tg.Entities, connectionID string, msg tg.MessageClass, edited bool) {
 	m, err := b.messageFromTg(ctx, msg)
 	if err != nil {
 		b.logger().Error(ctx, "Convert business message", log.Error(err))
@@ -60,6 +60,9 @@ func (b *Bot) dispatchBusinessMessage(ctx context.Context, connectionID string,
 	}
 
 	m.BusinessConnectionID = connectionID
+	if m.raw != nil {
+		m.businessPeer = inputPeerFromEntities(m.raw.PeerID, e)
+	}
 
 	u := &Update{}
 	if edited {
@@ -71,6 +74,41 @@ func (b *Bot) dispatchBusinessMessage(ctx context.Context, connectionID string,
 	b.route(ctx, u)
 }
 
+// inputPeerFromEntities builds the input peer for a message's chat from the
+// access hashes delivered with the update, so a business send addresses the chat
+// with the account's own access hash. Returns nil when the peer is absent.
+func inputPeerFromEntities(peer tg.PeerClass, e tg.Entities) tg.InputPeerClass {
+	switch p := peer.(type) {
+	case *tg.PeerUser:
+		if u, ok := e.Users[p.UserID]; ok {
+			return &tg.InputPeerUser{UserID: p.UserID, AccessHash: u.AccessHash}
+		}
+	case *tg.PeerChannel:
+		if ch, ok := e.Channels[p.ChannelID]; ok {
+			return &tg.InputPeerChannel{ChannelID: p.ChannelID, AccessHash: ch.AccessHash}
+		}
+	case *tg.PeerChat:
+		return &tg.InputPeerChat{ChatID: p.ChatID}
+	}
+
+	return nil
+}
+
+// businessChatID returns a send target for a business message's chat that carries
+// the account-scoped access hash, bypassing the bot's peer store.
+func businessChatID(m *Message) (ChatID, bool) {
+	if m == nil || m.businessPeer == nil {
+		return nil, false
+	}
+
+	ref, err := peerRefFromInputPeer(m.businessPeer)
+	if err != nil {
+		return nil, false
+	}
+
+	return Peer(ref), true
+}
+
 // businessConnectionID returns the connection id the update belongs to, or empty
 // when the update is not a business update.
 func (u *Update) businessConnectionID() string {
@@ -132,6 +170,14 @@ func (c *Context) BusinessMessage() *Message {
 	}
 }
 
+// BusinessChat returns a send target for the business message's chat that
+// carries the account-scoped access hash, and whether the update is a business
+// message. Use it to address sends on behalf of the connected account; the bot's
+// stored access hash is invalid in the business context.
+func (c *Context) BusinessChat() (ChatID, bool) {
+	return businessChatID(c.BusinessMessage())
+}
+
 // Business returns a BusinessContext scoped to the update's business connection,
 // and whether the update belongs to one. Use it to act on behalf of the
 // connected account from within a business update handler.

business_updates_test.go

@@ -46,7 +46,7 @@ func TestDispatchBusinessMessageKeepsOutgoing(t *testing.T) {
 
 	// Unlike a normal message, an outgoing business message is still delivered.
 	msg := &tg.Message{ID: 7, Out: true, Message: "hi", PeerID: &tg.PeerUser{UserID: 10}}
-	b.dispatchBusinessMessage(context.Background(), "bc1", msg, false)
+	b.dispatchBusinessMessage(context.Background(), tg.Entities{}, "bc1", msg, false)
 
 	if got == nil {
 		t.Fatal("outgoing business message should be dispatched")
@@ -67,7 +67,7 @@ func TestDispatchBusinessMessageEdited(t *testing.T) {
 	fired := false
 
 	b.OnEditedBusinessMessage(func(c *Context) error { fired = true; return nil })
-	b.dispatchBusinessMessage(context.Background(), "bc1", &tg.Message{ID: 8, PeerID: &tg.PeerUser{UserID: 10}}, true)
+	b.dispatchBusinessMessage(context.Background(), tg.Entities{}, "bc1", &tg.Message{ID: 8, PeerID: &tg.PeerUser{UserID: 10}}, true)
 
 	if !fired {
 		t.Fatal("edited business message handler did not fire")

context.go

@@ -30,6 +30,10 @@ func (c *Context) Chat() (ChatID, bool) {
 	}
 
 	if bm := c.BusinessMessage(); bm != nil {
+		if target, ok := businessChatID(bm); ok {
+			return target, true
+		}
+
 		return ID(bm.Chat.ID), true
 	}
 
@@ -64,7 +68,12 @@ func (c *Context) Reply(text string, opts ...SendOption) (*Message, error) {
 			WithBusinessConnection(bm.BusinessConnectionID),
 		}, opts...)
 
-		return c.Bot.SendMessage(c, ID(bm.Chat.ID), text, opts...)
+		target, ok := businessChatID(bm)
+		if !ok {
+			target = ID(bm.Chat.ID)
+		}
+
+		return c.Bot.SendMessage(c, target, text, opts...)
 	}
 
 	m := c.Message()

examples/business/main.go

@@ -155,7 +155,10 @@ func dispatchCommand(c *botapi.Context, bc *botapi.BusinessContext, fields []str
 	}
 
 	cmd, args := fields[0], fields[1:]
-	chat := botapi.ID(c.BusinessMessage().Chat.ID)
+
+	// Address sends with the account-scoped peer (carries the right access hash),
+	// not the bot's stored one.
+	chat, _ := c.BusinessChat()
 
 	switch cmd {
 	case "help":

types_message.go

@@ -132,6 +132,13 @@ type Message struct {
 	// nil for synthesized stubs (e.g. reply_to/pinned placeholders). It is not
 	// serialized; reach it through Raw.
 	raw *tg.Message
+
+	// businessPeer is the input peer of a business message's chat, built from the
+	// access hash delivered in the update's entities. A reply on behalf of a
+	// business account must use this peer (the account's own access hash for the
+	// chat) rather than the bot's stored one, which is invalid in the business
+	// context (BUSINESS_PEER_INVALID). Nil for non-business messages.
+	businessPeer tg.InputPeerClass
 }
 
 // Raw returns the original MTProto message this Message was converted from, for