fix(line): don't post duplicate messages when streaming to LINE (#1292)

LINE's Messaging API has no message-edit endpoint (reply/push only). When
streaming is enabled, core posts a placeholder then repeatedly calls
edit_message with the growing text; on LINE each edit is delivered as a
brand-new message, so the reply is posted several times, each copy longer
than the last (the reported bug).

In the 0.9.x unified webhook server, streaming is decided globally by the
UnifiedGatewayAdapter (driven by the Telegram streaming flag) and is not
platform-aware, so LINE turns stream too. Fix in two layers:

- gateway adapter (crates/openab-gateway/.../line.rs): dispatch_line_reply
  now drops edit_message/delete_message commands. The unified adapter uses a
  "draft" placeholder, so the final content is delivered via send_message —
  dropping the cosmetic edits removes the duplicates without losing content.
  This is the primary fix for the unified/in-process path.
- core (crates/openab-core/src/gateway.rs): the WebSocket GatewayAdapter path
  force-disables streaming for platforms that cannot edit messages
  (NON_EDITABLE_PLATFORMS, incl. "line"), so a split-gateway deployment with
  a real placeholder never finalizes via an edit that the adapter would drop.

Adds unit tests for both layers and a note in config.toml.example.

Co-authored-by: luffy-aiagent <luffy-aiagent@users.noreply.github.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: luffy-aiagent

config.toml.example

@@ -57,6 +57,9 @@ allowed_channels = ["1234567890"]       # ↑ omitted + non-empty list → auto-
 #                                       # omitted = auto-detect from list (non-empty → false, empty → true)
 # allowed_users = ["U5678"]             # only checked when allow_all_users = false
 # streaming = true                      # enable streaming (typewriter) mode
+#                                       # note: LINE has no message-edit API, so it is always
+#                                       #       send-once (streaming is forced off to avoid
+#                                       #       posting duplicate, growing messages)
 # streaming_placeholder = false         # set false for draft-based platforms (e.g. Telegram Rich Messages)
 
 # --- Telegram (first-class section; alternative to TELEGRAM_* env vars) ---

crates/openab-core/src/gateway.rs

@@ -40,6 +40,31 @@ fn platform_acks_writes(platform: &str) -> bool {
     EDIT_RESPONSE_PLATFORMS.contains(&platform)
 }
 
+/// Gateway platforms whose messaging API cannot edit a message after it is sent.
+///
+/// Cosmetic (typewriter) streaming works by posting a placeholder and then
+/// repeatedly editing it in place with the growing text. On a platform with no
+/// edit endpoint, each of those "edits" is delivered as a brand-new message
+/// instead — so the user sees the same reply posted several times, each copy
+/// longer than the last. Streaming is therefore force-disabled (send-once) for
+/// these platforms regardless of the configured `streaming` flag.
+///
+/// LINE's Messaging API only exposes reply/push (no edit), so it lives here.
+/// (The in-process unified adapter additionally hard-drops stray edit_message
+/// commands in the LINE adapter itself — see `dispatch_line_reply`.)
+///
+/// NOTE: like `EDIT_RESPONSE_PLATFORMS`, this is platform-identity standing in
+/// for a *capability*. The right long-term model is a capability handshake at
+/// gateway-connect time ("can this adapter edit messages?"); until that exists,
+/// any new gateway platform that lacks a message-edit API MUST be added here.
+const NON_EDITABLE_PLATFORMS: &[&str] = &["line"];
+
+/// Whether cosmetic streaming (placeholder + in-place edits) is possible on
+/// `platform`. See `NON_EDITABLE_PLATFORMS`.
+fn platform_supports_streaming(platform: &str) -> bool {
+    !NON_EDITABLE_PLATFORMS.contains(&platform)
+}
+
 /// Shared filter parameters for gateway event gating.
 /// Used by both `run_gateway_adapter` (WebSocket) and `process_gateway_event` (unified).
 struct EventFilterParams<'a> {
@@ -743,7 +768,19 @@ pub async fn run_gateway_adapter(
     let allowed_users: HashSet<String> = params.allowed_users.into_iter().collect();
     let allow_bot_messages = params.allow_bot_messages;
     let trusted_bot_ids: HashSet<String> = params.trusted_bot_ids.into_iter().collect();
-    let streaming = params.streaming;
+    // Cosmetic streaming edits a placeholder in place. On platforms without an
+    // edit API (e.g. LINE) every edit lands as a new message — growing
+    // duplicates — so force send-once mode there regardless of config.
+    let streaming = if params.streaming && !platform_supports_streaming(platform) {
+        warn!(
+            platform,
+            "streaming is enabled but this platform cannot edit messages; \
+             forcing send-once mode to avoid duplicate messages"
+        );
+        false
+    } else {
+        params.streaming
+    };
     let streaming_placeholder = params.streaming_placeholder;
     let stt_config = params.stt;
 
@@ -1473,6 +1510,30 @@ mod tests {
     use super::*;
     use std::collections::HashSet;
 
+    #[test]
+    fn line_cannot_stream_and_is_forced_send_once() {
+        // LINE has no message-edit API, so cosmetic streaming is impossible.
+        assert!(!platform_supports_streaming("line"));
+    }
+
+    #[test]
+    fn editable_platforms_still_allow_streaming() {
+        for platform in [
+            "telegram",
+            "slack",
+            "discord",
+            "feishu",
+            "teams",
+            "googlechat",
+            "wecom",
+        ] {
+            assert!(
+                platform_supports_streaming(platform),
+                "{platform} should still support streaming",
+            );
+        }
+    }
+
     #[test]
     fn echo_allowed_throttles_repeat_within_window() {
         // Unique key so we don't collide with other tests touching the global map.

crates/openab-gateway/src/adapters/line.rs

@@ -658,6 +658,22 @@ pub async fn dispatch_line_reply(
         return false;
     }
 
+    // LINE's Messaging API cannot edit or delete a message once it is sent.
+    // In streaming mode the core posts a placeholder then repeatedly calls
+    // edit_message with the growing text; on an editable platform this updates in
+    // place, but on LINE every edit_message would be delivered as a *new* message
+    // — the reply gets reposted several times, each copy longer than the last.
+    // Because the unified adapter uses a "draft" placeholder (no real message), the
+    // final content is delivered separately via send_message, so dropping these
+    // cosmetic edit/delete commands removes the duplicates without losing content.
+    if matches!(
+        reply.command.as_deref(),
+        Some("edit_message") | Some("delete_message")
+    ) {
+        info!(command = ?reply.command.as_deref(), "line: ignoring edit/delete command (LINE cannot edit messages)");
+        return false;
+    }
+
     // Extract token from cache (drop lock before HTTP call)
     let cached_token = {
         let mut cache = reply_cache.lock().unwrap_or_else(|e| e.into_inner());
@@ -1266,4 +1282,52 @@ mod tests {
         .await;
         assert!(result.is_some());
     }
+
+    #[tokio::test]
+    async fn edit_message_command_is_ignored_not_forwarded() {
+        // LINE cannot edit messages. A streaming `edit_message` reply must be
+        // dropped, never forwarded as a new Reply/Push message — otherwise each
+        // edit posts the growing text as a separate message (duplicate replies).
+        let server = MockServer::start().await;
+        // If the guard fails and the command falls through, the empty reply-token
+        // cache forces the Push API. This expectation forbids that call.
+        let _push = Mock::given(method("POST"))
+            .and(path("/v2/bot/message/push"))
+            .respond_with(ResponseTemplate::new(200))
+            .expect(0)
+            .mount_as_scoped(&server)
+            .await;
+
+        let cache: crate::ReplyTokenCache =
+            Arc::new(std::sync::Mutex::new(std::collections::HashMap::new()));
+        let reply = GatewayReply {
+            schema: "openab.gateway.reply.v1".into(),
+            reply_to: "evt1".into(),
+            platform: "line".into(),
+            channel: ReplyChannel {
+                id: "U123".into(),
+                thread_id: None,
+            },
+            content: Content {
+                content_type: "text".into(),
+                text: "partial streamed text".into(),
+                attachments: vec![],
+            },
+            command: Some("edit_message".into()),
+            request_id: None,
+            quote_message_id: None,
+        };
+
+        let used_reply = dispatch_line_reply(
+            &reqwest::Client::new(),
+            "line_token",
+            &cache,
+            &reply,
+            &server.uri(),
+        )
+        .await;
+
+        assert!(!used_reply, "edit_message must not use the Reply API");
+        // `_push` expect(0) is verified on drop: no push request was sent.
+    }
 }