diff --git a/nanobot/channels/feishu.py b/nanobot/channels/feishu.py index 17dac7c..f4f0708 100644 --- a/nanobot/channels/feishu.py +++ b/nanobot/channels/feishu.py @@ -243,6 +243,7 @@ class FeishuConfig(Base): allow_from: list[str] = Field(default_factory=list) react_emoji: str = "THUMBSUP" group_policy: Literal["open", "mention"] = "mention" + reply_to_message: bool = False # If True, bot replies quote the user's original message class FeishuChannel(BaseChannel): @@ -806,6 +807,77 @@ class FeishuChannel(BaseChannel): return None, f"[{msg_type}: download failed]" + _REPLY_CONTEXT_MAX_LEN = 200 + + def _get_message_content_sync(self, message_id: str) -> str | None: + """Fetch the text content of a Feishu message by ID (synchronous). + + Returns a "[Reply to: ...]" context string, or None on failure. + """ + from lark_oapi.api.im.v1 import GetMessageRequest + try: + request = GetMessageRequest.builder().message_id(message_id).build() + response = self._client.im.v1.message.get(request) + if not response.success(): + logger.debug( + "Feishu: could not fetch parent message {}: code={}, msg={}", + message_id, response.code, response.msg, + ) + return None + items = getattr(response.data, "items", None) + if not items: + return None + msg_obj = items[0] + raw_content = getattr(msg_obj, "body", None) + raw_content = getattr(raw_content, "content", None) if raw_content else None + if not raw_content: + return None + try: + content_json = json.loads(raw_content) + except (json.JSONDecodeError, TypeError): + return None + msg_type = getattr(msg_obj, "msg_type", "") + if msg_type == "text": + text = content_json.get("text", "").strip() + elif msg_type == "post": + text, _ = _extract_post_content(content_json) + text = text.strip() + else: + text = "" + if not text: + return None + if len(text) > self._REPLY_CONTEXT_MAX_LEN: + text = text[: self._REPLY_CONTEXT_MAX_LEN] + "..." + return f"[Reply to: {text}]" + except Exception as e: + logger.debug("Feishu: error fetching parent message {}: {}", message_id, e) + return None + + def _reply_message_sync(self, parent_message_id: str, msg_type: str, content: str) -> bool: + """Reply to an existing Feishu message using the Reply API (synchronous).""" + from lark_oapi.api.im.v1 import ReplyMessageRequest, ReplyMessageRequestBody + try: + request = ReplyMessageRequest.builder() \ + .message_id(parent_message_id) \ + .request_body( + ReplyMessageRequestBody.builder() + .msg_type(msg_type) + .content(content) + .build() + ).build() + response = self._client.im.v1.message.reply(request) + if not response.success(): + logger.error( + "Failed to reply to Feishu message {}: code={}, msg={}, log_id={}", + parent_message_id, response.code, response.msg, response.get_log_id() + ) + return False + logger.debug("Feishu reply sent to message {}", parent_message_id) + return True + except Exception as e: + logger.error("Error replying to Feishu message {}: {}", parent_message_id, e) + return False + def _send_message_sync(self, receive_id_type: str, receive_id: str, msg_type: str, content: str) -> bool: """Send a single message (text/image/file/interactive) synchronously.""" from lark_oapi.api.im.v1 import CreateMessageRequest, CreateMessageRequestBody @@ -842,6 +914,29 @@ class FeishuChannel(BaseChannel): receive_id_type = "chat_id" if msg.chat_id.startswith("oc_") else "open_id" loop = asyncio.get_running_loop() + # Determine whether the first message should quote the user's message. + # Only the very first send (media or text) in this call uses reply; subsequent + # chunks/media fall back to plain create to avoid redundant quote bubbles. + reply_message_id: str | None = None + if ( + self.config.reply_to_message + and not msg.metadata.get("_progress", False) + ): + reply_message_id = msg.metadata.get("message_id") or None + + first_send = True # tracks whether the reply has already been used + + def _do_send(m_type: str, content: str) -> None: + """Send via reply (first message) or create (subsequent).""" + nonlocal first_send + if reply_message_id and first_send: + first_send = False + ok = self._reply_message_sync(reply_message_id, m_type, content) + if ok: + return + # Fall back to regular send if reply fails + self._send_message_sync(receive_id_type, msg.chat_id, m_type, content) + for file_path in msg.media: if not os.path.isfile(file_path): logger.warning("Media file not found: {}", file_path) @@ -851,8 +946,8 @@ class FeishuChannel(BaseChannel): key = await loop.run_in_executor(None, self._upload_image_sync, file_path) if key: await loop.run_in_executor( - None, self._send_message_sync, - receive_id_type, msg.chat_id, "image", json.dumps({"image_key": key}, ensure_ascii=False), + None, _do_send, + "image", json.dumps({"image_key": key}, ensure_ascii=False), ) else: key = await loop.run_in_executor(None, self._upload_file_sync, file_path) @@ -864,8 +959,8 @@ class FeishuChannel(BaseChannel): else: media_type = "file" await loop.run_in_executor( - None, self._send_message_sync, - receive_id_type, msg.chat_id, media_type, json.dumps({"file_key": key}, ensure_ascii=False), + None, _do_send, + media_type, json.dumps({"file_key": key}, ensure_ascii=False), ) if msg.content and msg.content.strip(): @@ -874,18 +969,12 @@ class FeishuChannel(BaseChannel): if fmt == "text": # Short plain text – send as simple text message text_body = json.dumps({"text": msg.content.strip()}, ensure_ascii=False) - await loop.run_in_executor( - None, self._send_message_sync, - receive_id_type, msg.chat_id, "text", text_body, - ) + await loop.run_in_executor(None, _do_send, "text", text_body) elif fmt == "post": # Medium content with links – send as rich-text post post_body = self._markdown_to_post(msg.content) - await loop.run_in_executor( - None, self._send_message_sync, - receive_id_type, msg.chat_id, "post", post_body, - ) + await loop.run_in_executor(None, _do_send, "post", post_body) else: # Complex / long content – send as interactive card @@ -893,8 +982,8 @@ class FeishuChannel(BaseChannel): for chunk in self._split_elements_by_table_limit(elements): card = {"config": {"wide_screen_mode": True}, "elements": chunk} await loop.run_in_executor( - None, self._send_message_sync, - receive_id_type, msg.chat_id, "interactive", json.dumps(card, ensure_ascii=False), + None, _do_send, + "interactive", json.dumps(card, ensure_ascii=False), ) except Exception as e: @@ -989,6 +1078,19 @@ class FeishuChannel(BaseChannel): else: content_parts.append(MSG_TYPE_MAP.get(msg_type, f"[{msg_type}]")) + # Extract reply context (parent/root message IDs) + parent_id = getattr(message, "parent_id", None) or None + root_id = getattr(message, "root_id", None) or None + + # Prepend quoted message text when the user replied to another message + if parent_id and self._client: + loop = asyncio.get_running_loop() + reply_ctx = await loop.run_in_executor( + None, self._get_message_content_sync, parent_id + ) + if reply_ctx: + content_parts.insert(0, reply_ctx) + content = "\n".join(content_parts) if content_parts else "" if not content and not media_paths: @@ -1005,6 +1107,8 @@ class FeishuChannel(BaseChannel): "message_id": message_id, "chat_type": chat_type, "msg_type": msg_type, + "parent_id": parent_id, + "root_id": root_id, } ) diff --git a/tests/test_feishu_reply.py b/tests/test_feishu_reply.py new file mode 100644 index 0000000..65d7f86 --- /dev/null +++ b/tests/test_feishu_reply.py @@ -0,0 +1,392 @@ +"""Tests for Feishu message reply (quote) feature.""" +import asyncio +import json +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +import pytest + +from nanobot.bus.events import OutboundMessage +from nanobot.bus.queue import MessageBus +from nanobot.channels.feishu import FeishuChannel, FeishuConfig + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _make_feishu_channel(reply_to_message: bool = False) -> FeishuChannel: + config = FeishuConfig( + enabled=True, + app_id="cli_test", + app_secret="secret", + allow_from=["*"], + reply_to_message=reply_to_message, + ) + channel = FeishuChannel(config, MessageBus()) + channel._client = MagicMock() + # _loop is only used by the WebSocket thread bridge; not needed for unit tests + channel._loop = None + return channel + + +def _make_feishu_event( + *, + message_id: str = "om_001", + chat_id: str = "oc_abc", + chat_type: str = "p2p", + msg_type: str = "text", + content: str = '{"text": "hello"}', + sender_open_id: str = "ou_alice", + parent_id: str | None = None, + root_id: str | None = None, +): + message = SimpleNamespace( + message_id=message_id, + chat_id=chat_id, + chat_type=chat_type, + message_type=msg_type, + content=content, + parent_id=parent_id, + root_id=root_id, + mentions=[], + ) + sender = SimpleNamespace( + sender_type="user", + sender_id=SimpleNamespace(open_id=sender_open_id), + ) + return SimpleNamespace(event=SimpleNamespace(message=message, sender=sender)) + + +def _make_get_message_response(text: str, msg_type: str = "text", success: bool = True): + """Build a fake im.v1.message.get response object.""" + body = SimpleNamespace(content=json.dumps({"text": text})) + item = SimpleNamespace(msg_type=msg_type, body=body) + data = SimpleNamespace(items=[item]) + resp = MagicMock() + resp.success.return_value = success + resp.data = data + resp.code = 0 + resp.msg = "ok" + return resp + + +# --------------------------------------------------------------------------- +# Config tests +# --------------------------------------------------------------------------- + +def test_feishu_config_reply_to_message_defaults_false() -> None: + assert FeishuConfig().reply_to_message is False + + +def test_feishu_config_reply_to_message_can_be_enabled() -> None: + config = FeishuConfig(reply_to_message=True) + assert config.reply_to_message is True + + +# --------------------------------------------------------------------------- +# _get_message_content_sync tests +# --------------------------------------------------------------------------- + +def test_get_message_content_sync_returns_reply_prefix() -> None: + channel = _make_feishu_channel() + channel._client.im.v1.message.get.return_value = _make_get_message_response("what time is it?") + + result = channel._get_message_content_sync("om_parent") + + assert result == "[Reply to: what time is it?]" + + +def test_get_message_content_sync_truncates_long_text() -> None: + channel = _make_feishu_channel() + long_text = "x" * (FeishuChannel._REPLY_CONTEXT_MAX_LEN + 50) + channel._client.im.v1.message.get.return_value = _make_get_message_response(long_text) + + result = channel._get_message_content_sync("om_parent") + + assert result is not None + assert result.endswith("...]") + inner = result[len("[Reply to: ") : -1] + assert len(inner) == FeishuChannel._REPLY_CONTEXT_MAX_LEN + len("...") + + +def test_get_message_content_sync_returns_none_on_api_failure() -> None: + channel = _make_feishu_channel() + resp = MagicMock() + resp.success.return_value = False + resp.code = 230002 + resp.msg = "bot not in group" + channel._client.im.v1.message.get.return_value = resp + + result = channel._get_message_content_sync("om_parent") + + assert result is None + + +def test_get_message_content_sync_returns_none_for_non_text_type() -> None: + channel = _make_feishu_channel() + body = SimpleNamespace(content=json.dumps({"image_key": "img_1"})) + item = SimpleNamespace(msg_type="image", body=body) + data = SimpleNamespace(items=[item]) + resp = MagicMock() + resp.success.return_value = True + resp.data = data + channel._client.im.v1.message.get.return_value = resp + + result = channel._get_message_content_sync("om_parent") + + assert result is None + + +def test_get_message_content_sync_returns_none_when_empty_text() -> None: + channel = _make_feishu_channel() + channel._client.im.v1.message.get.return_value = _make_get_message_response(" ") + + result = channel._get_message_content_sync("om_parent") + + assert result is None + + +# --------------------------------------------------------------------------- +# _reply_message_sync tests +# --------------------------------------------------------------------------- + +def test_reply_message_sync_returns_true_on_success() -> None: + channel = _make_feishu_channel() + resp = MagicMock() + resp.success.return_value = True + channel._client.im.v1.message.reply.return_value = resp + + ok = channel._reply_message_sync("om_parent", "text", '{"text":"hi"}') + + assert ok is True + channel._client.im.v1.message.reply.assert_called_once() + + +def test_reply_message_sync_returns_false_on_api_error() -> None: + channel = _make_feishu_channel() + resp = MagicMock() + resp.success.return_value = False + resp.code = 400 + resp.msg = "bad request" + resp.get_log_id.return_value = "log_x" + channel._client.im.v1.message.reply.return_value = resp + + ok = channel._reply_message_sync("om_parent", "text", '{"text":"hi"}') + + assert ok is False + + +def test_reply_message_sync_returns_false_on_exception() -> None: + channel = _make_feishu_channel() + channel._client.im.v1.message.reply.side_effect = RuntimeError("network error") + + ok = channel._reply_message_sync("om_parent", "text", '{"text":"hi"}') + + assert ok is False + + +# --------------------------------------------------------------------------- +# send() — reply routing tests +# --------------------------------------------------------------------------- + +@pytest.mark.asyncio +async def test_send_uses_reply_api_when_configured() -> None: + channel = _make_feishu_channel(reply_to_message=True) + + reply_resp = MagicMock() + reply_resp.success.return_value = True + channel._client.im.v1.message.reply.return_value = reply_resp + + await channel.send(OutboundMessage( + channel="feishu", + chat_id="oc_abc", + content="hello", + metadata={"message_id": "om_001"}, + )) + + channel._client.im.v1.message.reply.assert_called_once() + channel._client.im.v1.message.create.assert_not_called() + + +@pytest.mark.asyncio +async def test_send_uses_create_api_when_reply_disabled() -> None: + channel = _make_feishu_channel(reply_to_message=False) + + create_resp = MagicMock() + create_resp.success.return_value = True + channel._client.im.v1.message.create.return_value = create_resp + + await channel.send(OutboundMessage( + channel="feishu", + chat_id="oc_abc", + content="hello", + metadata={"message_id": "om_001"}, + )) + + channel._client.im.v1.message.create.assert_called_once() + channel._client.im.v1.message.reply.assert_not_called() + + +@pytest.mark.asyncio +async def test_send_uses_create_api_when_no_message_id() -> None: + channel = _make_feishu_channel(reply_to_message=True) + + create_resp = MagicMock() + create_resp.success.return_value = True + channel._client.im.v1.message.create.return_value = create_resp + + await channel.send(OutboundMessage( + channel="feishu", + chat_id="oc_abc", + content="hello", + metadata={}, + )) + + channel._client.im.v1.message.create.assert_called_once() + channel._client.im.v1.message.reply.assert_not_called() + + +@pytest.mark.asyncio +async def test_send_skips_reply_for_progress_messages() -> None: + channel = _make_feishu_channel(reply_to_message=True) + + create_resp = MagicMock() + create_resp.success.return_value = True + channel._client.im.v1.message.create.return_value = create_resp + + await channel.send(OutboundMessage( + channel="feishu", + chat_id="oc_abc", + content="thinking...", + metadata={"message_id": "om_001", "_progress": True}, + )) + + channel._client.im.v1.message.create.assert_called_once() + channel._client.im.v1.message.reply.assert_not_called() + + +@pytest.mark.asyncio +async def test_send_fallback_to_create_when_reply_fails() -> None: + channel = _make_feishu_channel(reply_to_message=True) + + reply_resp = MagicMock() + reply_resp.success.return_value = False + reply_resp.code = 400 + reply_resp.msg = "error" + reply_resp.get_log_id.return_value = "log_x" + channel._client.im.v1.message.reply.return_value = reply_resp + + create_resp = MagicMock() + create_resp.success.return_value = True + channel._client.im.v1.message.create.return_value = create_resp + + await channel.send(OutboundMessage( + channel="feishu", + chat_id="oc_abc", + content="hello", + metadata={"message_id": "om_001"}, + )) + + # reply attempted first, then falls back to create + channel._client.im.v1.message.reply.assert_called_once() + channel._client.im.v1.message.create.assert_called_once() + + +# --------------------------------------------------------------------------- +# _on_message — parent_id / root_id metadata tests +# --------------------------------------------------------------------------- + +@pytest.mark.asyncio +async def test_on_message_captures_parent_and_root_id_in_metadata() -> None: + channel = _make_feishu_channel() + channel._processed_message_ids.clear() + channel._client.im.v1.message.react.return_value = MagicMock(success=lambda: True) + + captured = [] + + async def _capture(**kwargs): + captured.append(kwargs) + + channel._handle_message = _capture + + with patch.object(channel, "_add_reaction", return_value=None): + await channel._on_message( + _make_feishu_event( + parent_id="om_parent", + root_id="om_root", + ) + ) + + assert len(captured) == 1 + meta = captured[0]["metadata"] + assert meta["parent_id"] == "om_parent" + assert meta["root_id"] == "om_root" + assert meta["message_id"] == "om_001" + + +@pytest.mark.asyncio +async def test_on_message_parent_and_root_id_none_when_absent() -> None: + channel = _make_feishu_channel() + channel._processed_message_ids.clear() + + captured = [] + + async def _capture(**kwargs): + captured.append(kwargs) + + channel._handle_message = _capture + + with patch.object(channel, "_add_reaction", return_value=None): + await channel._on_message(_make_feishu_event()) + + assert len(captured) == 1 + meta = captured[0]["metadata"] + assert meta["parent_id"] is None + assert meta["root_id"] is None + + +@pytest.mark.asyncio +async def test_on_message_prepends_reply_context_when_parent_id_present() -> None: + channel = _make_feishu_channel() + channel._processed_message_ids.clear() + channel._client.im.v1.message.get.return_value = _make_get_message_response("original question") + + captured = [] + + async def _capture(**kwargs): + captured.append(kwargs) + + channel._handle_message = _capture + + with patch.object(channel, "_add_reaction", return_value=None): + await channel._on_message( + _make_feishu_event( + content='{"text": "my answer"}', + parent_id="om_parent", + ) + ) + + assert len(captured) == 1 + content = captured[0]["content"] + assert content.startswith("[Reply to: original question]") + assert "my answer" in content + + +@pytest.mark.asyncio +async def test_on_message_no_extra_api_call_when_no_parent_id() -> None: + channel = _make_feishu_channel() + channel._processed_message_ids.clear() + + captured = [] + + async def _capture(**kwargs): + captured.append(kwargs) + + channel._handle_message = _capture + + with patch.object(channel, "_add_reaction", return_value=None): + await channel._on_message(_make_feishu_event()) + + channel._client.im.v1.message.get.assert_not_called() + assert len(captured) == 1