feat(messages): return destination IDs for native forwards

Author: vsem-azamat

telegram_mcp/tools/messages.py

@@ -1468,6 +1468,10 @@ async def forward_message(
 
     Telegram validates sender and topic permissions; errors never fall back to
     another sender or topic. Discovery is opt-in and does not change defaults.
+
+    When topic_id, send_as, drop_author or silent is used, the result also lists
+    the destination message IDs Telegram returned for this request, or says
+    that none were returned.
     """
     try:
         if topic_id is not None and (type(topic_id) is not int or topic_id <= 0):
@@ -1497,30 +1501,47 @@ async def forward_message(
                     ids_to_forward = sibling_ids
                     expanded_from_album = True
 
+        destination_note = ""
         if topic_id is not None or send_as is not None or drop_author or silent:
             sender = await resolve_input_entity(send_as, cl) if send_as is not None else None
-            await cl(
-                functions.messages.ForwardMessagesRequest(
-                    from_peer=from_entity,
-                    id=ids_to_forward if isinstance(ids_to_forward, list) else [ids_to_forward],
-                    to_peer=to_entity,
-                    top_msg_id=topic_id,
-                    send_as=sender,
-                    drop_author=drop_author,
-                    silent=silent,
-                )
+            request = functions.messages.ForwardMessagesRequest(
+                from_peer=from_entity,
+                id=ids_to_forward if isinstance(ids_to_forward, list) else [ids_to_forward],
+                to_peer=to_entity,
+                top_msg_id=topic_id,
+                send_as=sender,
+                drop_author=drop_author,
+                silent=silent,
+            )
+            result = await cl(request)
+            # Correlate only this request's random IDs, in request order; never
+            # infer destination IDs from unrelated updates in the response.
+            returned_ids = {
+                update.random_id: update.id
+                for update in getattr(result, "updates", None) or []
+                if isinstance(update, types.UpdateMessageID)
+            }
+            destination_ids = [
+                returned_ids[random_id]
+                for random_id in request.random_id
+                if random_id in returned_ids
+            ]
+            destination_note = (
+                f" Destination message IDs: {destination_ids or 'not returned by Telegram'}."
             )
         else:
             await cl.forward_messages(to_entity, ids_to_forward, from_entity)
         count = len(ids_to_forward) if isinstance(ids_to_forward, list) else 1
         if count == 1:
-            return f"Message {message_id} forwarded from {from_chat_id} to {to_chat_id}."
-        if expanded_from_album:
-            return (
+            summary = f"Message {message_id} forwarded from {from_chat_id} to {to_chat_id}."
+        elif expanded_from_album:
+            summary = (
                 f"Album of {count} messages forwarded from {from_chat_id} "
                 f"to {to_chat_id} (auto-expanded from message {message_id})."
             )
-        return f"{count} messages forwarded from {from_chat_id} to {to_chat_id}."
+        else:
+            summary = f"{count} messages forwarded from {from_chat_id} to {to_chat_id}."
+        return summary + destination_note
     except Exception as e:
         return log_and_format_error(
             "forward_message",

tests/test_forward_message_routing.py

@@ -26,6 +26,7 @@ def __init__(self):
             "sender": types.InputPeerChannel(33, 303),
         }
         self.album = []
+        self.build_updates = None  # callable(request) -> updates echoing its random_ids
 
     async def resolve(self, identifier, client):
         assert client is self
@@ -39,6 +40,10 @@ async def __call__(self, request):
         bytes(request)  # Exercise the real SDK serializer, not a fake TL schema.
         if self.error:
             raise self.error
+        if self.build_updates:
+            return types.Updates(
+                self.build_updates(request), [], [], datetime.now(timezone.utc), 1
+            )
         return self.result
 
     async def forward_messages(self, *args, **kwargs):
@@ -91,7 +96,10 @@ async def test_legacy_album_and_explicit_batch_are_unchanged(client, message_id,
 )
 async def test_routed_forward_uses_native_request(client, route):
     result = await messages.forward_message("source", [10, 12], "destination", **route)
-    assert result == "2 messages forwarded from source to destination."
+    assert result == (
+        "2 messages forwarded from source to destination. "
+        "Destination message IDs: not returned by Telegram."
+    )
     assert client.legacy == []
     assert client.reads == []
     assert len(client.requests) == 1
@@ -252,3 +260,49 @@ async def test_discovery_readonly_account_fanout(client, monkeypatch):
     result = await messages.get_send_as("destination")
     assert "[first]" in result and "[second]" in result
     assert len(client.requests) == 2
+
+
+@pytest.mark.asyncio
+async def test_native_forward_reports_request_correlated_destination_ids(client):
+    def updates(request):
+        first, second = request.random_id
+        return [
+            types.UpdateMessageID(id=999, random_id=first ^ second ^ 1),  # unrelated request
+            types.UpdateMessageID(id=701, random_id=second),  # out of order
+            types.UpdateNewMessage(  # never inferred from
+                message=types.Message(id=555, peer_id=types.PeerUser(22), message="other"),
+                pts=1,
+                pts_count=1,
+            ),
+            types.UpdateMessageID(id=700, random_id=first),
+        ]
+
+    client.build_updates = updates
+    result = await messages.forward_message("source", [10, 12], "destination", topic_id=7)
+    assert result == (
+        "2 messages forwarded from source to destination. Destination message IDs: [700, 701]."
+    )
+    assert client.legacy == []
+
+
+@pytest.mark.asyncio
+async def test_native_forward_reports_only_ids_telegram_returned(client):
+    def updates(request):
+        return [types.UpdateMessageID(id=701, random_id=request.random_id[1])]
+
+    client.build_updates = updates
+    result = await messages.forward_message("source", [10, 12], "destination", silent=True)
+    assert result.endswith("Destination message IDs: [701].")
+
+
+@pytest.mark.asyncio
+async def test_native_forward_states_when_no_ids_were_returned(client):
+    def updates(request):
+        return [types.UpdateMessageID(id=999, random_id=request.random_id[0] ^ 1)]
+
+    client.build_updates = updates
+    result = await messages.forward_message("source", 10, "destination", drop_author=True)
+    assert result == (
+        "Message 10 forwarded from source to destination. "
+        "Destination message IDs: not returned by Telegram."
+    )