feat(gateway): implement Telegram Rich Messages (Bot API 10.1)

- Add sendRichMessage() for structured content (tables, code, headings)
- Add sendRichMessageDraft() for future AI streaming support
- Add is_complex_markdown() classifier to route complex replies
- Feature-gated via TELEGRAM_RICH_MESSAGES=true env var (default: off)
- Falls back to sendMessage on sendRichMessage failure

When enabled, replies containing tables, fenced code blocks, headings,
or content >4096 chars will use sendRichMessage with InputRichMessage
markdown format. This passes agent markdown directly (GFM-compatible)
without needing any conversion layer.

Author: 超渡法師

gateway/src/adapters/line.rs

@@ -643,6 +643,7 @@ mod tests {
         let state = Arc::new(crate::AppState {
             telegram_bot_token: None,
             telegram_secret_token: None,
+            telegram_rich_messages: false,
             line_channel_secret: None,
             line_access_token: None,
             teams: None,

gateway/src/adapters/teams.rs

@@ -654,6 +654,7 @@ mod tests {
         Arc::new(crate::AppState {
             telegram_bot_token: None,
             telegram_secret_token: None,
+            telegram_rich_messages: false,
             line_channel_secret: None,
             line_access_token: None,
             teams: Some(TeamsAdapter::new(make_config(vec![]))),

gateway/src/adapters/telegram.rs

@@ -220,6 +220,66 @@ fn is_markdown_parse_error(description: &str) -> bool {
         || desc_lower.contains("parse entities")
 }
 
+/// Returns true if the content is complex enough to benefit from sendRichMessage.
+fn is_complex_markdown(text: &str) -> bool {
+    text.contains("|---|")
+        || text.contains("```")
+        || text.starts_with("# ")
+        || text.contains("\n# ")
+        || text.contains("\n## ")
+        || text.contains("\n### ")
+        || text.len() > 4096
+}
+
+/// Send a rich message via Bot API 10.1 sendRichMessage.
+async fn send_rich_message(
+    client: &reqwest::Client,
+    bot_token: &str,
+    chat_id: &str,
+    thread_id: &Option<String>,
+    text: &str,
+) -> Result<serde_json::Value, String> {
+    let url = format!("{TELEGRAM_API_BASE}/bot{bot_token}/sendRichMessage");
+    let body = serde_json::json!({
+        "chat_id": chat_id,
+        "message_thread_id": thread_id,
+        "rich_message": { "markdown": text },
+    });
+    let resp = client.post(&url).json(&body).send().await.map_err(|e| e.to_string())?;
+    let json: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
+    if json["ok"].as_bool() == Some(true) {
+        Ok(json)
+    } else {
+        Err(json["description"].as_str().unwrap_or("unknown error").to_string())
+    }
+}
+
+/// Stream a partial rich message via sendRichMessageDraft.
+#[allow(dead_code)]
+async fn send_rich_message_draft(
+    client: &reqwest::Client,
+    bot_token: &str,
+    chat_id: &str,
+    thread_id: &Option<String>,
+    draft_id: i64,
+    text: &str,
+) -> Result<(), String> {
+    let url = format!("{TELEGRAM_API_BASE}/bot{bot_token}/sendRichMessageDraft");
+    let body = serde_json::json!({
+        "chat_id": chat_id,
+        "message_thread_id": thread_id,
+        "draft_id": draft_id,
+        "rich_message": { "markdown": text },
+    });
+    let resp = client.post(&url).json(&body).send().await.map_err(|e| e.to_string())?;
+    let json: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
+    if json["ok"].as_bool() == Some(true) {
+        Ok(())
+    } else {
+        Err(json["description"].as_str().unwrap_or("unknown error").to_string())
+    }
+}
+
 // --- Reply handler ---
 
 pub async fn handle_reply(
@@ -228,6 +288,7 @@ pub async fn handle_reply(
     client: &reqwest::Client,
     event_tx: &tokio::sync::broadcast::Sender<String>,
     reaction_state: &Arc<Mutex<HashMap<String, Vec<String>>>>,
+    rich_messages: bool,
 ) {
     // Handle create_topic command
     if reply.command.as_deref() == Some("create_topic") {
@@ -338,6 +399,15 @@ pub async fn handle_reply(
         thread_id = ?reply.channel.thread_id,
         "gateway → telegram"
     );
+
+    // Try sendRichMessage for complex content when enabled
+    if rich_messages && is_complex_markdown(&reply.content.text) {
+        match send_rich_message(client, bot_token, &reply.channel.id, &reply.channel.thread_id, &reply.content.text).await {
+            Ok(_) => return,
+            Err(e) => warn!("sendRichMessage failed ({e}), falling back to sendMessage"),
+        }
+    }
+
     let url = format!("{TELEGRAM_API_BASE}/bot{bot_token}/sendMessage");
     let resp = client
         .post(&url)
@@ -541,4 +611,14 @@ mod tests {
         assert!(!is_markdown_parse_error("Unauthorized"));
         assert!(!is_markdown_parse_error("Bad Request: chat not found"));
     }
+
+    #[test]
+    fn test_is_complex_markdown() {
+        assert!(is_complex_markdown("| Col1 | Col2 |\n|---|---|\n| a | b |"));
+        assert!(is_complex_markdown("```rust\nfn main() {}\n```"));
+        assert!(is_complex_markdown("# Heading\n\nSome text"));
+        assert!(is_complex_markdown(&"x".repeat(4097)));
+        assert!(!is_complex_markdown("Hello world"));
+        assert!(!is_complex_markdown("*bold* and _italic_"));
+    }
 }

gateway/src/main.rs

@@ -45,6 +45,8 @@ pub struct AppState {
     pub telegram_bot_token: Option<String>,
     /// Telegram webhook secret token for request validation
     pub telegram_secret_token: Option<String>,
+    /// Use sendRichMessage for complex content (Bot API 10.1+)
+    pub telegram_rich_messages: bool,
     /// LINE channel secret for signature validation
     pub line_channel_secret: Option<String>,
     /// LINE channel access token for reply API
@@ -138,6 +140,7 @@ async fn handle_oab_connection(state: Arc<AppState>, socket: axum::extract::ws::
                                         &client,
                                         &state_for_recv.event_tx,
                                         &reaction_state,
+                                        state_for_recv.telegram_rich_messages,
                                     )
                                     .await;
                                 } else {
@@ -241,6 +244,9 @@ async fn main() -> Result<()> {
     // Telegram adapter
     let telegram_bot_token = std::env::var("TELEGRAM_BOT_TOKEN").ok();
     let telegram_secret_token = std::env::var("TELEGRAM_SECRET_TOKEN").ok();
+    let telegram_rich_messages = std::env::var("TELEGRAM_RICH_MESSAGES")
+        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+        .unwrap_or(false);
     if telegram_bot_token.is_some() {
         let webhook_path =
             std::env::var("TELEGRAM_WEBHOOK_PATH").unwrap_or_else(|_| "/webhook/telegram".into());
@@ -378,6 +384,7 @@ async fn main() -> Result<()> {
     let state = Arc::new(AppState {
         telegram_bot_token,
         telegram_secret_token,
+        telegram_rich_messages,
         line_channel_secret,
         line_access_token,
         teams,