feat: SendRichMessageDraft via native page blocks

The HTTP Bot API only takes a rich message as an HTML/Markdown string and parses
it server-side; the MTProto sendMessageTypingActionRichMessageDraft carries a
blocks-based tg.RichMessage directly. botapi is MTProto-native, so it accepts the
page-block tree (RichMessage{Blocks,Photos,Documents,RTL,Part}) without any
content parser — more expressive than the string interface. Build blocks with the
tg.PageBlock* types.

This was the last deferred method; deferredMethods is now empty and conformance
enforces the entire Bot API 10.1 surface (bar the 6 transport notApplicable).
Hermetic test; lint clean.

Author: ernado

conformance_test.go

@@ -20,9 +20,10 @@ var coveredByOtherMeans = map[string]string{
 // deferredMethods lists published methods that are feasible in principle but not
 // yet implemented, each blocked on a missing gotd/td RPC or unclear MTProto
 // mapping. They should move to an implementation as td gains support.
-var deferredMethods = map[string]string{
-	"sendRichMessageDraft": "needs a tg.RichMessage PageBlock tree built from HTML/markdown, a content parser TDLib runs server-side",
-}
+//
+// Empty: every published method is implemented, covered by other means, or
+// not-applicable below.
+var deferredMethods = map[string]string{}
 
 // notApplicableMethods lists published methods that do not apply to the
 // MTProto-native model and are intentionally not implemented.

send_draft.go

@@ -67,3 +67,76 @@ func (b *Bot) SendMessageDraft(ctx context.Context, chat ChatID, draftID int64,
 
 	return nil
 }
+
+// RichMessage is the structured content of a rich message, expressed as native
+// MTProto page blocks.
+//
+// The HTTP Bot API accepts a rich message only as an HTML or Markdown string and
+// parses it into this structure server-side. botapi is MTProto-native, so it
+// takes the page-block tree directly: no content parser is needed and the full
+// block vocabulary (paragraphs, headers, lists, embedded media, …) is available.
+// Build blocks with the tg.PageBlock* types; Bot.Raw exposes the same client.
+type RichMessage struct {
+	// Blocks are the page blocks that make up the message body.
+	Blocks []tg.PageBlockClass
+	// Photos are photos referenced by the blocks.
+	Photos []tg.PhotoClass
+	// Documents are documents referenced by the blocks.
+	Documents []tg.DocumentClass
+	// RTL renders the message right-to-left.
+	RTL bool
+	// Part marks this as a partial segment of a longer streamed message.
+	Part bool
+}
+
+// toTg converts the rich message into its MTProto representation.
+func (r RichMessage) toTg() tg.RichMessage {
+	out := tg.RichMessage{
+		Blocks:    r.Blocks,
+		Photos:    r.Photos,
+		Documents: r.Documents,
+	}
+	if r.RTL {
+		out.SetRtl(true)
+	}
+
+	if r.Part {
+		out.SetPart(true)
+	}
+
+	return out
+}
+
+// SendRichMessageDraft streams a partial rich message to a chat while the message
+// is being generated, so its members see an ephemeral preview. draftID is a
+// unique client-side identifier for the draft. Once generation finishes, persist
+// the result with a regular send.
+func (b *Bot) SendRichMessageDraft(ctx context.Context, chat ChatID, draftID int64, message RichMessage, opts ...DraftOption) error {
+	var cfg draftConfig
+
+	for _, o := range opts {
+		o(&cfg)
+	}
+
+	peer, err := b.resolveInputPeer(ctx, chat)
+	if err != nil {
+		return err
+	}
+
+	req := &tg.MessagesSetTypingRequest{
+		Peer: peer,
+		Action: &tg.SendMessageRichMessageDraftAction{
+			RandomID:    draftID,
+			RichMessage: message.toTg(),
+		},
+	}
+	if cfg.messageThreadID != 0 {
+		req.SetTopMsgID(cfg.messageThreadID)
+	}
+
+	if _, err := b.raw.MessagesSetTyping(ctx, req); err != nil {
+		return asAPIError(err)
+	}
+
+	return nil
+}

send_draft_test.go

@@ -33,3 +33,39 @@ func TestSendMessageDraft(t *testing.T) {
 		t.Fatalf("action = %#v", action)
 	}
 }
+
+func TestSendRichMessageDraft(t *testing.T) {
+	inv := newMockInvoker()
+	inv.reply(tg.MessagesSetTypingRequestTypeID, &tg.BoolTrue{})
+
+	message := RichMessage{
+		Blocks: []tg.PageBlockClass{&tg.PageBlockParagraph{Text: &tg.TextPlain{Text: "partial"}}},
+		RTL:    true,
+		Part:   true,
+	}
+
+	if err := newMockBot(inv).SendRichMessageDraft(context.Background(), userRef(10, 20), 1000, message); err != nil {
+		t.Fatalf("SendRichMessageDraft: %v", err)
+	}
+
+	var req tg.MessagesSetTypingRequest
+
+	inv.decode(t, tg.MessagesSetTypingRequestTypeID, &req)
+
+	action, ok := req.Action.(*tg.SendMessageRichMessageDraftAction)
+	if !ok {
+		t.Fatalf("action = %#v, want rich draft", req.Action)
+	}
+
+	if action.RandomID != 1000 || len(action.RichMessage.Blocks) != 1 {
+		t.Fatalf("action = %#v", action)
+	}
+
+	if !action.RichMessage.GetRtl() {
+		t.Fatal("rtl flag should be set")
+	}
+
+	if _, ok := action.RichMessage.Blocks[0].(*tg.PageBlockParagraph); !ok {
+		t.Fatalf("block 0 = %#v, want paragraph", action.RichMessage.Blocks[0])
+	}
+}