Merge pull request #1313 from openabdev/feat/telegram-native-tables

feat(telegram): auto-disable table code-block wrapping for native rendering

Author: chaodu-agent

crates/openab-core/src/adapter.rs

@@ -407,7 +407,10 @@ pub trait ChatAdapter: Send + Sync + 'static {
     /// lets the platform render the raw Markdown table itself.
     /// Default: `false` (keep converting). Overridden by Slack (Block Kit
     /// `markdown` blocks / `markdown_text` stream chunks render tables natively).
-    fn renders_native_tables(&self) -> bool {
+    /// The `platform` parameter allows shared adapters (e.g. UnifiedGatewayAdapter)
+    /// to make per-platform decisions.
+    fn renders_native_tables(&self, platform: &str) -> bool {
+        let _ = platform;
         false
     }
 
@@ -697,7 +700,7 @@ impl AdapterRouter {
         // Platforms that render Markdown tables natively (e.g. Slack Block Kit
         // `markdown` blocks / `markdown_text` stream chunks) skip the
         // table→code/bullets pre-pass so the raw table renders natively.
-        let table_mode = if adapter.renders_native_tables() {
+        let table_mode = if adapter.renders_native_tables(&thread_channel.platform) {
             TableMode::Off
         } else {
             self.table_mode
@@ -1794,7 +1797,7 @@ mod tests {
         assert!(!adapter.use_streaming(false));
         // renders_native_tables defaults to false: platforms that don't override
         // it keep the table→code/bullets conversion (e.g. Discord, Gateway).
-        assert!(!adapter.renders_native_tables());
+        assert!(!adapter.renders_native_tables("discord"));
     }
 
     #[test]

crates/openab-core/src/config.rs

@@ -567,6 +567,11 @@ pub struct GatewayConfig {
     /// Show "…" placeholder at streaming start. Default: true. Set false for platforms using drafts.
     #[serde(default = "default_true")]
     pub streaming_placeholder: bool,
+    /// Whether the connected gateway renders tables natively (e.g. Telegram Rich Messages).
+    /// Default: true (matches Telegram default). Set false if Rich Messages is disabled
+    /// on the gateway daemon to preserve table code-block wrapping.
+    #[serde(default = "default_true")]
+    pub telegram_rich_messages: bool,
     /// Message dispatch mode. Default: per-message.
     #[serde(default)]
     pub message_processing_mode: MessageProcessingMode,

crates/openab-core/src/gateway.rs

@@ -233,6 +233,7 @@ pub struct GatewayAdapter {
     platform_name: &'static str,
     streaming: bool,
     streaming_placeholder: bool,
+    telegram_rich_messages: bool,
 }
 
 impl GatewayAdapter {
@@ -242,13 +243,15 @@ impl GatewayAdapter {
         platform_name: &'static str,
         streaming: bool,
         streaming_placeholder: bool,
+        telegram_rich_messages: bool,
     ) -> Self {
         Self {
             ws_tx,
             pending,
             platform_name,
             streaming,
             streaming_placeholder,
+            telegram_rich_messages,
         }
     }
 
@@ -730,6 +733,13 @@ impl ChatAdapter for GatewayAdapter {
     fn show_streaming_placeholder(&self) -> bool {
         self.streaming_placeholder
     }
+
+    fn renders_native_tables(&self, _platform: &str) -> bool {
+        // Telegram renders markdown tables natively via Rich Messages;
+        // skip the table→code-block pre-pass for that platform only when
+        // Rich Messages is confirmed enabled.
+        self.platform_name == "telegram" && self.telegram_rich_messages
+    }
 }
 
 // --- Run the gateway adapter (connects to gateway WS, routes events to AdapterRouter) ---
@@ -748,6 +758,7 @@ pub struct GatewayParams {
     pub trusted_bot_ids: Vec<String>,
     pub streaming: bool,
     pub streaming_placeholder: bool,
+    pub telegram_rich_messages: bool,
     pub stt: crate::config::SttConfig,
 }
 
@@ -782,6 +793,7 @@ pub async fn run_gateway_adapter(
         params.streaming
     };
     let streaming_placeholder = params.streaming_placeholder;
+    let telegram_rich_messages = params.telegram_rich_messages;
     let stt_config = params.stt;
 
     let connect_url = match &params.token {
@@ -832,6 +844,7 @@ pub async fn run_gateway_adapter(
             platform,
             streaming,
             streaming_placeholder,
+            telegram_rich_messages,
         ));
         let slash_ws_tx = ws_tx.clone(); // for fire-and-forget slash command responses
         let mut tasks: tokio::task::JoinSet<()> = tokio::task::JoinSet::new();

crates/openab-core/src/slack.rs

@@ -544,7 +544,7 @@ impl ChatAdapter for SlackAdapter {
         self.streaming && !other_bot_present
     }
 
-    fn renders_native_tables(&self) -> bool {
+    fn renders_native_tables(&self, _platform: &str) -> bool {
         true
     }
 
@@ -2307,7 +2307,7 @@ mod tests {
     fn slack_renders_native_tables() {
         let ttl = std::time::Duration::from_secs(300);
         let adapter = SlackAdapter::new("xoxb-test".into(), ttl, AllowBots::Mentions, true, crate::multibot_cache::MultibotCache::load("/dev/null".into()), true);
-        assert!(adapter.renders_native_tables());
+        assert!(adapter.renders_native_tables("slack"));
     }
 }
 

docs/telegram.md

@@ -40,16 +40,24 @@ Set environment variables:
 
 OAB config (`config.toml`):
 
-**Minimal** — just pass the API key to the agent:
+**Minimal** — bot token via env var, API key passed to agent:
 
 ```toml
+[telegram]
+bot_token = "${TELEGRAM_BOT_TOKEN}"
+allow_all_users = true
+
 [agent]
 env = { KIRO_API_KEY = "${KIRO_API_KEY}" }
 ```
 
-**Recommended** — with tuned pool, streaming, and native table rendering:
+**Recommended** — with access control, tuned pool, and streaming:
 
 ```toml
+[telegram]
+bot_token = "${TELEGRAM_BOT_TOKEN}"
+allowed_users = ["176096071"]
+
 [agent]
 env = { KIRO_API_KEY = "${KIRO_API_KEY}" }
 
@@ -59,9 +67,13 @@ session_ttl_hours = 1
 
 [reactions]
 tool_display = "compact"
+```
+
+Table rendering is automatically disabled for Telegram (tables pass through as native markdown for Rich Messages). To force code-block wrapping, set explicitly:
 
+```toml
 [markdown]
-tables = "off"
+tables = "code"
 ```
 
 Streaming is enabled by default when Rich Messages are active — replies are streamed live via `sendRichMessageDraft` with rich formatting, then finalized with `sendRichMessage`. If `TELEGRAM_RICH_MESSAGES=false`, streaming is also disabled by default. To override, set `TELEGRAM_STREAMING=true` or `TELEGRAM_STREAMING=false` explicitly.
@@ -356,11 +368,11 @@ Agent replies are rendered with Telegram Markdown: **bold**, `code`, and code bl
 
 With **Rich Messages** enabled (default, requires Bot API 10.1+), headings (`##`) and tables render with full formatting via `sendRichMessage`. Code blocks remain on the legacy path for syntax highlighting and copy-button support. Content exceeding 4096 characters is automatically handled via rich messages (up to 32768 chars).
 
-> **Important:** OAB's default table mode wraps markdown tables in code blocks before they reach the gateway. To allow native Telegram table rendering via Rich Messages, disable this conversion in your `config.toml`:
+> **Note:** As of v0.9.0, OAB automatically disables table code-block wrapping for Telegram adapters (both unified and standalone gateway) when Rich Messages are enabled. Tables pass through as raw markdown and render natively. No `[markdown]` config is needed. To override this and force code-block wrapping, add:
 >
 > ```toml
 > [markdown]
-> tables = "off"
+> tables = "code"
 > ```
 >
 > Rich Messages requires gateway version **v0.6.0-rc.1** or above (`ghcr.io/openabdev/openab-gateway:v0.6.0-rc.1`+).

src/main.rs

@@ -587,6 +587,7 @@ async fn main() -> anyhow::Result<()> {
             trusted_bot_ids: gw_cfg.trusted_bot_ids,
             streaming: gw_cfg.streaming,
             streaming_placeholder: gw_cfg.streaming_placeholder,
+            telegram_rich_messages: gw_cfg.telegram_rich_messages,
             stt: cfg.stt.clone(),
         };
         let gw_router = router.clone();

src/unified_adapter.rs

@@ -217,4 +217,11 @@ impl ChatAdapter for UnifiedGatewayAdapter {
         // The draft mechanism handles the "typing" indicator natively.
         false
     }
+
+    fn renders_native_tables(&self, platform: &str) -> bool {
+        // Telegram Rich Messages render markdown tables natively — skip the
+        // table→code-block pre-pass so tables display with proper formatting.
+        // Only applies to Telegram; other platforms in unified mode keep wrapping.
+        platform == "telegram" && self.gw_state.telegram_rich_messages
+    }
 }