fix(gateway): prevent feishu bot self-echo message loop (#705)

* fix(gateway): prevent feishu bot self-echo message loop

Feishu WebSocket pushes the bot's own sent messages back as
im.message.receive_v1 events with sender_type='user', bypassing all
existing filters. This causes an infinite reply loop.

Fix: send_text_message now returns the message_id from the API response
and inserts it into the dedupe cache. When the echo event arrives via
WebSocket, the dedupe check catches it.

Discord Discussion: https://discord.com/channels/1491295327620169908/1500160821567684660

* fix(gateway): add warn log for invalid JSON on feishu 200 response

Replace silent unwrap_or_default() with explicit match that logs a
warning when the Feishu API returns 200 but the response body is not
valid JSON. This makes the self-echo dedupe skip visible in production
logs.

* test(gateway): add tests for invalid JSON and missing message_id in feishu send

- send_text_message_invalid_json_returns_none: 200 + garbage body → None
- send_text_message_missing_message_id_returns_none: 200 + valid JSON but no data.message_id → None

---------

Co-authored-by: wangyuyan-agent <265828726+wangyuyan-agent@users.noreply.github.com>
Co-authored-by: 超渡法師 <chaodu@openab.dev>

Author: wangyuyan-agent

gateway/src/adapters/feishu.rs

@@ -831,14 +831,14 @@ async fn resolve_user_name(
 // ---------------------------------------------------------------------------
 
 /// Send a text message to a feishu chat_id.
-/// Returns true on success.
+/// Returns the sent message_id on success (for self-echo dedupe), None on failure.
 pub async fn send_text_message(
     client: &reqwest::Client,
     api_base: &str,
     token: &str,
     chat_id: &str,
     text: &str,
-) -> bool {
+) -> Option<String> {
     let url = format!(
         "{}/open-apis/im/v1/messages?receive_id_type=chat_id",
         api_base
@@ -860,18 +860,28 @@ pub async fn send_text_message(
     {
         Ok(resp) => {
             if resp.status().is_success() {
-                info!(chat_id = %chat_id, "feishu message sent");
-                true
+                let msg_id = match resp.json::<serde_json::Value>().await {
+                    Ok(body) => body
+                        .pointer("/data/message_id")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string()),
+                    Err(e) => {
+                        warn!(chat_id = %chat_id, err = %e, "feishu 200 response not valid JSON, self-echo dedupe will be skipped");
+                        None
+                    }
+                };
+                info!(chat_id = %chat_id, message_id = ?msg_id, "feishu message sent");
+                msg_id
             } else {
                 let status = resp.status();
                 let text = resp.text().await.unwrap_or_default();
                 tracing::error!(status = %status, body = %text, "feishu send message failed");
-                false
+                None
             }
         }
         Err(e) => {
             tracing::error!(err = %e, "feishu send message request failed");
-            false
+            None
         }
     }
 }
@@ -1002,12 +1012,17 @@ pub async fn handle_reply(
     let text = &reply.content.text;
     let limit = adapter.config.message_limit;
 
-    // Split long messages
+    // Split long messages; store sent message_ids in dedupe to prevent
+    // self-echo (Feishu pushes bot's own messages back via WebSocket)
     if text.len() <= limit {
-        send_text_message(&adapter.client, &api_base, &token, &reply.channel.id, text).await;
+        if let Some(msg_id) = send_text_message(&adapter.client, &api_base, &token, &reply.channel.id, text).await {
+            adapter.dedupe.is_duplicate(&msg_id);
+        }
     } else {
         for chunk in split_text(text, limit) {
-            send_text_message(&adapter.client, &api_base, &token, &reply.channel.id, chunk).await;
+            if let Some(msg_id) = send_text_message(&adapter.client, &api_base, &token, &reply.channel.id, chunk).await {
+                adapter.dedupe.is_duplicate(&msg_id);
+            }
         }
     }
 }
@@ -1400,14 +1415,15 @@ mod tests {
             .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                 "code": 0,
                 "msg": "success",
+                "data": {"message_id": "om_test123"}
             })))
             .expect(1)
             .mount(&server)
             .await;
 
         let client = reqwest::Client::new();
-        let ok = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
-        assert!(ok);
+        let msg_id = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
+        assert_eq!(msg_id.as_deref(), Some("om_test123"));
     }
 
     #[tokio::test]
@@ -1421,8 +1437,41 @@ mod tests {
             .await;
 
         let client = reqwest::Client::new();
-        let ok = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
-        assert!(!ok);
+        let msg_id = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
+        assert!(msg_id.is_none());
+    }
+
+    #[tokio::test]
+    async fn send_text_message_invalid_json_returns_none() {
+        let server = MockServer::start().await;
+        Mock::given(method("POST"))
+            .and(path("/open-apis/im/v1/messages"))
+            .respond_with(ResponseTemplate::new(200).set_body_string("not json"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let client = reqwest::Client::new();
+        let msg_id = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
+        assert!(msg_id.is_none());
+    }
+
+    #[tokio::test]
+    async fn send_text_message_missing_message_id_returns_none() {
+        let server = MockServer::start().await;
+        Mock::given(method("POST"))
+            .and(path("/open-apis/im/v1/messages"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "code": 0,
+                "msg": "success",
+            })))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let client = reqwest::Client::new();
+        let msg_id = send_text_message(&client, &server.uri(), "t-tok", "oc_chat1", "hello").await;
+        assert!(msg_id.is_none());
     }
 
     // --- Split text tests ---