Feishu markdown table rendering approaches and fixes

Fixes on record

Merged to main. A stamp counts the issues a fix is linked to.

• #20275 fix(feishu): force text mode for markdown tables (salvage #13723)

  merged to main

  files: gateway/platforms/feishu.py

  Show the diff

  • gateway/platforms/feishu.py

    @@ -153,6 +153,9 @@
         r"(^#{1,6}\s)|(^\s*[-*]\s)|(^\s*\d+\.\s)|(^\s*---+\s*$)|(```)|(`[^`\n]+`)|(\*\*[^*\n].+?\*\*)|(~~[^~\n].+?~~)|(<u>.+?</u>)|(\*[^*\n]+\*)|(\[[^\]]+\]\([^)]+\))|(^>\s)",
         re.MULTILINE,
     )
    +# Detect markdown tables: a line starting with | followed by a separator line.
    +# Feishu post-type 'md' elements do not render tables, so we force text mode.
    +_MARKDOWN_TABLE_RE = re.compile(r"^\|.*\|\n\|[-|: ]+\|", re.MULTILINE)
     _MARKDOWN_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
     _MARKDOWN_FENCE_OPEN_RE = re.compile(r"^```([^\n`]*)\s*$")
     _MARKDOWN_FENCE_CLOSE_RE = re.compile(r"^```\s*$")
    @@ -3995,6 +3998,12 @@ def _is_duplicate(self, message_id: str) -> bool:
         # =========================================================================
     
         def _build_outbound_payload(self, content: str) -> tuple[str, str]:
    +        # Feishu post-type 'md' elements do not render markdown tables; sending
    +        # table content as post causes the message to appear blank on the client.
    +        # Force plain text for anything that looks like a markdown table.
    +        if _MARKDOWN_TABLE_RE.search(content):
    +            text_payload = {"text": content}
    +            return "text", json.dumps(text_payload, ensure_ascii=False)
             if _MARKDOWN_HINT_RE.search(content):
                 return "post", _build_markdown_post_payload(content)
             text_payload = {"text": content}

• #68121 fix(feishu): render markdown tables via post+md, remove force-text downgrade

  merged to main

  files: contributors/emails/[redacted:email], contributors/emails/[redacted:email], plugins/platforms/feishu/adapter.py, tests/gateway/test_feishu.py, tests/gateway/test_feishu_table_markdown.py

  Show the diff

  • contributors/emails/[redacted:email]

    @@ -0,0 +1 @@
    +M1racleShih

  • contributors/emails/[redacted:email]

    @@ -0,0 +1 @@
    +JasonFang1993

  • plugins/platforms/feishu/adapter.py

    @@ -152,11 +152,24 @@
     # ---------------------------------------------------------------------------
     
     _MARKDOWN_HINT_RE = re.compile(
    -    r"(^#{1,6}\s)|(^\s*[-*]\s)|(^\s*\d+\.\s)|(^\s*---+\s*$)|(```)|(`[^`\n]+`)|(\*\*[^*\n].+?\*\*)|(~~[^~\n].+?~~)|(<u>.+?</u>)|(\*[^*\n]+\*)|(\[[^\]]+\]\([^)]+\))|(^>\s)",
    +    # Pipe table: any header line + separator line both starting with '|'.
    +    r"(^\|.*\|\s*\n\|[-:|\s]+\|)"
    +    # Headings, lists, code, bold/italic/strike/underline, links, blockquotes.
    +    r"|(^#{1,6}\s)"
    +    r"|(^\s*[-*]\s)"
    +    r"|(^\s*\d+\.\s)"
    +    r"|(^\s*---+\s*$)"
    +    r"|(```)"
    +    r"|(`[^`\n]+`)"
    +    r"|(\*\*[^*\n].+?\*\*)"
    +    r"|(~~[^~\n].+?~~)"
    +    r"|(<u>.+?</u>)"
    +    r"|(\*[^*\n]+\*)"
    +    r"|(\[[^\]]+\]\([^)]+\))"
    +    r"|(^>\s)",
         re.MULTILINE,
     )
    -# Detect markdown tables: a line starting with | followed by a separator line.
    -# Feishu post-type 'md' elements do not render tables, so we force text mode.
    +# Backwards-compatible alias retained because external callers reference it.
     _MARKDOWN_TABLE_RE = re.compile(r"^\|.*\|\n\|[-|: ]+\|", re.MULTILINE)
     _MARKDOWN_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
     _MARKDOWN_FENCE_OPEN_RE = re.compile(r"^```([^\n`]*)\s*$")
    @@ -4533,12 +4546,12 @@ def _is_duplicate(self, message_id: str) -> bool:
         # =========================================================================
     
         def _build_outbound_payload(self, content: str) -> tuple[str, str]:
    -        # Feishu post-type 'md' elements do not render markdown tables; sending
    -        # table content as post causes the message to appear blank on the client.
    -        # Force plain text for anything that looks like a markdown table.
    -        if _MARKDOWN_TABLE_RE.search(content):
    -            text_payload = {"text": content}
    -            return "text", json.dumps(text_payload, ensure_ascii=False)
    +        # Empirically (issue #52786), current Feishu clients render markdown
    +        # tables inside ``post``-type ``md`` elements natively. The previous
    +        # table-downgrade branch forced any table-containing message to
    +        # ``text``, which left Feishu readers seeing the raw pipe-and-dash
    +        # source instead of a rendered table. Trust the common markdown path
    +        # for table content too.
             if _MARKDOWN_HINT_RE.search(content):
                 return "post", _build_markdown_post_payload(content)
             text_payload = {"text": content}

  • tests/gateway/test_feishu.py

    @@ -2690,6 +2690,23 @@ def test_build_post_payload_keeps_full_markdown_text(self):
                 [[{"tag": "md", "text": "---\n1. 第一项\n  2. 子项\n- 外层\n  - 内层\n<u>下划线</u> 和 ~~删除线~~"}]],
             )
     
    +    @patch.dict(os.environ, {}, clear=True)
    +    def test_build_outbound_payload_uses_post_for_markdown_table(self):
    +        from gateway.config import PlatformConfig
    +        from plugins.platforms.feishu.adapter import FeishuAdapter
    +
    +        adapter = FeishuAdapter(PlatformConfig())
    +        content = "| Name | Score |\n| --- | ---: |\n| Ada | 10 |"
    +
    +        msg_type, raw_payload = adapter._build_outbound_payload(content)
    +
    +        self.assertEqual(msg_type, "post")
    +        payload = json.loads(raw_payload)
    +        self.assertEqual(
    +            payload["zh_cn"]["content"],
    +            [[{"tag": "md", "text": content}]],
    +        )
    +
         @patch.dict(os.environ, {}, clear=True)
         def test_send_uses_post_for_inline_markdown(self):
             from gateway.config import PlatformConfig

  • tests/gateway/test_feishu_table_markdown.py

    @@ -0,0 +1,133 @@
    +"""Tests for Feishu adapter outbound markdown payload construction.
    +
    +Reproduces the bug tracked in hermes-agent issue #52786:
    +`_build_outbound_payload` was force-downgrading any message containing a
    +markdown pipe table to ``msg_type=text``, so Feishu clients rendered the raw
    +pipe-and-dash source instead of a table.  Empirically current Feishu clients
    +render ``post``+``md`` tables natively, so the downgrade branch must be removed.
    +
    +These tests guard the fix.  They invoke the real adapter via the project's
    +plugin-loader helper so that no ``sys.path`` / ``sys.modules`` games are
    +needed.
    +"""
    +
    +from __future__ import annotations
    +
    +import json
    +
    +from tests.gateway._plugin_adapter_loader import load_plugin_adapter
    +
    +_adapter = load_plugin_adapter("feishu")
    +
    +
    +def _call_build_outbound_payload(content: str) -> tuple[str, str]:
    +    """Invoke ``_build_outbound_payload`` on a bare adapter instance.
    +
    +    ``_build_outbound_payload`` is a method that only uses module-level
    +    helpers (``_MARKDOWN_TABLE_RE``, ``_MARKDOWN_HINT_RE``,
    +    ``_build_markdown_post_payload``) and never touches ``self.*``, so a bare
    +    object is sufficient.
    +    """
    +    inst = object.__new__(_adapter.FeishuAdapter)
    +    return inst._build_outbound_payload(content)
    +
    +
    +def _md_texts_from_post_payload(payload_str: str) -> list[str]:
    +    """Pull every ``{tag:'md', text:'...'}`` element out of a Feishu post payload.
    +
    +    Real payload shape::
    +
    +        {"zh_cn": {"content": [[{"tag": "md", "text": "..."}], ...]}}
    +
    +    Helpers and tests need to introspect the ``md`` blocks regardless of
    +    locale, so we walk the structure generically.
    +    """
    +    payload = json.loads(payload_str)
    +    if not isinstance(payload, dict):
    +        return []
    +    texts: list[str] = []
    +    for lang_val in payload.values():
    +        if not isinstance(lang_val, dict):
    +            continue
    +        content = lang_val.get("content", [])
    +        if not isinstance(content, list):
    +            continue
    +        for block in content:
    +            if isinstance(block, list):
    +                candidates = block
    +            else:
    +                candidates = [block]
    +            for el in candidates:
    +                if isinstance(el, dict) and el.get("tag") == "md":
    +                    texts.append(el.get("text", ""))
    +    return texts
    +
    +
    +def test_markdown_table_uses_post_not_text():
    +    """Regression test for issue #52786 (and its older sibling #23938).
    +
    +    A message whose only markdown is a table must take the ``post`` path,
    +    not be downgraded to plain text.
    +    """
    +    content = (
    +        "| col A | col B |\n"
    +        "| ----- | ----- |\n"
    +        "| 1     | 2     |"
    +    )
    +    msg_type, payload_str = _call_build_outbound_payload(content)
    +    assert msg_type == "post", (
    +        f"expected 'post' for a markdown table (issue #52786), got {msg_type!r}; "
    +        "the table-downgrade branch in _build_outbound_payload has been re-introduced"
    +    )
    +    md_texts = _md_texts_from_post_payload(payload_str)
    +    assert md_texts, f"post payload must include at least one md element; got {payload_str!r}"
    +    joined = "".join(md_texts)
    +    assert "col A" in joined and "|" in joined, (
    +        "table text was lost or reformatted when switching from text to post"
    +    )
    +
    +
    +def test_plain_text_without_markdown_still_uses_text():
    +    """Negative control: a message with no markdown hints and no table must
    +    still go to plain text.  Guards against accidentally promoting everything
    +    to ``post``."""
    +    msg_type, _ = _call_build_outbound_payload("just a plain sentence with no markup")
    +    assert msg_type == "text"
    +
    +
    +def test_existing_markdown_heading_still_uses_post():
    +    """Sanity: the existing ``post`` path (heading / list / code / bold /
    +    link) must still work after the table downgrade is removed."""
    +    msg_type, payload_str = _call_build_outbound_payload("# hello world\n")
    +    assert msg_type == "post"
    +    md_texts = _md_texts_from_post_payload(payload_str)
    +    assert md_texts, f"expected at least one md element; got {payload_str!r}"
    +    assert any("hello world" in t for t in md_texts), (
    +        f"expected 'hello world' in md elements; got {md_texts!r}"
    +    )
    +
    +
    +def test_table_combined_with_other_markdown_does_not_downgrade():
    +    """A message that mixes a table with surrounding markdown must also
    +    take the ``post`` path.
    +
    +    The old ``_MARKDOWN_TABLE_RE`` branch returned ``text`` unconditionally
    +    and stripped all the surrounding markdown formatting, so a Feishu
    +    reader saw literal pipes and lost the prose framing the table.
    +    """
    +    content = (
    +        "Here is the data:\n\n"
    +        "| col A | col B |\n"
    +        "| ----- | ----- |\n"
    +        "| 1     | 2     |\n\n"
    +        "Let me know."
    +    )
    +    msg_type, payload_str = _call_build_outbound_payload(content)
    +    assert msg_type == "post"
    +    md_texts = _md_texts_from_post_payload(payload_str)
    +    joined = "\n".join(md_texts)
    +    assert "Here is the data" in joined, (
    +        "leading prose was lost when downgrading a mixed-table message"
    +    )
    +    assert "col A" in joined, "table header was lost"
    +    assert "Let me know" in joined, "trailing prose was lost"

• #68122 fix(feishu): keep msg_type=post consistent across chunks of long markdown replies

  merged to main

  files: plugins/platforms/feishu/adapter.py, tests/gateway/test_feishu.py

  Show the diff

  • plugins/platforms/feishu/adapter.py

    @@ -1910,11 +1910,21 @@ async def send(
     
             formatted = self.format_message(content)
             chunks = self.truncate_message(formatted, self.MAX_MESSAGE_LENGTH)
    +        # When chunking splits a long markdown response, an individual chunk
    +        # can end up as plain prose that doesn't match the per-chunk hint
    +        # regex — so it would be sent as ``msg_type=text`` and the user would
    +        # see literal ``**bold``/``## heading``/code fences in the Feishu
    +        # client while other chunks render correctly. Lock the markdown
    +        # decision at the whole-message level so every chunk consistently
    +        # uses ``post``. See #26841.
    +        prefer_post = bool(_MARKDOWN_HINT_RE.search(formatted))
             last_response = None
     
             try:
                 for chunk in chunks:
    -                msg_type, payload = self._build_outbound_payload(chunk)
    +                msg_type, payload = self._build_outbound_payload(
    +                    chunk, prefer_post=prefer_post,
    +                )
                     try:
                         response = await self._feishu_send_with_retry(
                             chat_id=chat_id,
    @@ -4545,14 +4555,21 @@ def _is_duplicate(self, message_id: str) -> bool:
         # Outbound payload construction and send pipeline
         # =========================================================================
     
    -    def _build_outbound_payload(self, content: str) -> tuple[str, str]:
    +    def _build_outbound_payload(
    +        self, content: str, *, prefer_post: bool = False,
    +    ) -> tuple[str, str]:
             # Empirically (issue #52786), current Feishu clients render markdown
             # tables inside ``post``-type ``md`` elements natively. The previous
             # table-downgrade branch forced any table-containing message to
             # ``text``, which left Feishu readers seeing the raw pipe-and-dash
             # source instead of a rendered table. Trust the common markdown path
             # for table content too.
    -        if _MARKDOWN_HINT_RE.search(content):
    +        #
    +        # ``prefer_post`` lets ``send`` treat the chunk as part of a larger
    +        # markdown document: when a long markdown reply is split at
    +        # MAX_MESSAGE_LENGTH, the per-chunk regex would otherwise
    +        # mis-classify a plain-prose chunk as ``text``. See #26841.
    +        if prefer_post or _MARKDOWN_HINT_RE.search(content):
                 return "post", _build_markdown_post_payload(content)
             text_payload = {"text": content}
             return "text", json.dumps(text_payload, ensure_ascii=False)

  • tests/gateway/test_feishu.py

    @@ -2707,6 +2707,110 @@ def test_build_outbound_payload_uses_post_for_markdown_table(self):
                 [[{"tag": "md", "text": content}]],
             )
     
    +    @patch.dict(os.environ, {}, clear=True)
    +    def test_send_uses_post_for_every_chunk_of_multi_chunk_markdown(self):
    +        """Regression for #26841: when a long Markdown message is split
    +        across multiple chunks, every chunk must go out as
    +        ``msg_type=post`` — including chunk 1.  The bug was that the
    +        first chunk often had only plain prose (the per-chunk regex
    +        didn't match) and was sent as ``text``, so users saw literal
    +        ``**bold``/``## heading``/code fences while later chunks
    +        rendered correctly.
    +        """
    +        from gateway.config import PlatformConfig
    +        from plugins.platforms.feishu.adapter import FeishuAdapter
    +
    +        adapter = FeishuAdapter(PlatformConfig())
    +        captured = []
    +
    +        class _MessageAPI:
    +            def create(self, request):
    +                captured.append(request)
    +                return SimpleNamespace(
    +                    success=lambda: True,
    +                    data=SimpleNamespace(
    +                        message_id=f"om_chunk_{len(captured)}",
    +                    ),
    +                )
    +
    +        adapter._client = SimpleNamespace(
    +            im=SimpleNamespace(
    +                v1=SimpleNamespace(
    +                    message=_MessageAPI(),
    +                )
    +            )
    +        )
    +
    +        async def _direct(func, *args, **kwargs):
    +            return func(*args, **kwargs)
    +
    +        # Force a deterministic split so the test doesn't depend on the
    +        # exact 8000-char limit.  Chunk 1 is plain prose; chunk 2 has
    +        # the markdown markers.  Without the fix, chunk 1 went out as
    +        # ``msg_type=text``.
    +        first_chunk = "Here is a short intro that has no markdown markers at all."
    +        second_chunk = "## Heading\nAnd then some **bold** text."
    +
    +        with patch.object(
    +            adapter, "truncate_message", return_value=[first_chunk, second_chunk],
    +        ), patch("plugins.platforms.feishu.adapter.asyncio.to_thread", side_effect=_direct):
    +            result = asyncio.run(
    +                adapter.send(
    +                    chat_id="oc_chat",
    +                    content=first_chunk + "\n" + second_chunk,
    +                )
    +            )
    +
    +        self.assertTrue(result.success)
    +        self.assertEqual(len(captured), 2)
    +        msg_types = [r.request_body.msg_type for r in captured]
    +        self.assertEqual(msg_types, ["post", "post"])
    +
    +    @patch.dict(os.environ, {}, clear=True)
    +    def test_send_plain_text_message_not_upgraded_by_prefer_post(self):
    +        """A message with no markdown at all must still go out as plain
    +        ``msg_type=text`` — the whole-message ``prefer_post`` decision
    +        only flips on when the formatted message matches the hint regex.
    +        """
    +        from gateway.config import PlatformConfig
    +        from plugins.platforms.feishu.adapter import FeishuAdapter
    +
    +        adapter = FeishuAdapter(PlatformConfig())
    +        captured = []
    +
    +        class _MessageAPI:
    +            def create(self, request):
    +                captured.append(request)
    +                return SimpleNamespace(
    +                    success=lambda: True,
    +                    data=SimpleNamespace(
    +                        message_id=f"om_chunk_{len(captured)}",
    +                    ),
    +                )
    +
    +        adapter._client = SimpleNamespace(
    +            im=SimpleNamespace(
    +                v1=SimpleNamespace(
    +                    message=_MessageAPI(),
    +                )
    +            )
    +        )
    +
    +        async def _direct(func, *args, **kwargs):
    +            return func(*args, **kwargs)
    +
    +        with patch("plugins.platforms.feishu.adapter.asyncio.to_thread", side_effect=_direct):
    +            result = asyncio.run(
    +                adapter.send(
    +                    chat_id="oc_chat",
    +                    content="just a plain sentence",
    +                )
    +            )
    +
    +        self.assertTrue(result.success)
    +        self.assertEqual(len(captured), 1)
    +        self.assertEqual(captured[0].request_body.msg_type, "text")
    +
         @patch.dict(os.environ, {}, clear=True)
         def test_send_uses_post_for_inline_markdown(self):
             from gateway.config import PlatformConfig

• #109140 Feishu inbound post text is no longer markdown-escaped (#9816, salvage #9991)

  merged to main

  files: plugins/platforms/feishu/adapter.py, tests/gateway/test_feishu.py