PR #19751: fix(wecom): split long outbound markdown instead of silent truncation

• Repository: NousResearch/hermes-agent
• Author: luyao618
• State: open | merged: False
• Link: https://github.com/NousResearch/hermes-agent/pull/19751

Description (problem / solution / changelog)

Summary

Fixes #19689 — WeCom outbound markdown responses were silently truncated at 4000 characters. Everything beyond MAX_MESSAGE_LENGTH was dropped with no indication to the user.

Changes

• gateway/platforms/wecom.py: Replace content[:self.MAX_MESSAGE_LENGTH] with self.truncate_message() (inherited from BasePlatformAdapter) which splits long content into multiple chunks preserving code block boundaries and adding chunk indicators (e.g. (1/2)).
  • In send(): iterate over chunks — first chunk uses passive reply path if available, remaining chunks use proactive APP_CMD_SEND.
  • In _send_reply_markdown(): remove inline truncation (caller now pre-chunks).
• tests/gateway/test_wecom.py: Add TestSendLongMessageSplitting with 3 tests:
  • Long message is split into multiple API calls, each within limit
  • Short message is sent as single call (no regression)
  • Reply path: first chunk uses reply, overflow uses proactive send

Testing

All 44 existing WeCom tests pass + 3 new tests pass.

Root Cause

Both _send_reply_markdown() and the proactive path in send() used content[:self.MAX_MESSAGE_LENGTH] to enforce the WeCom 4000-char limit. Since the WeCom API accepts truncated payloads without error, Hermes reported success while the user lost all content beyond 4000 chars.

Changed files

• gateway/platforms/wecom.py (modified, +24/-15)
• tests/gateway/test_wecom.py (modified, +60/-0)

PR #19811: fix(wecom): split long markdown into multiple messages instead of silently truncating

• Repository: NousResearch/hermes-agent
• Author: briandevans
• State: closed | merged: False
• Link: https://github.com/NousResearch/hermes-agent/pull/19811

Description (problem / solution / changelog)

Summary

• WeCom outbound markdown is silently truncated at 4000 characters: both the proactive send path and the passive _send_reply_markdown path slice with content[:self.MAX_MESSAGE_LENGTH] before sending. The WeCom API accepts the request, so Hermes reports success while everything past 4000 chars is dropped from the user's view.
• Switch send() to chunk via BasePlatformAdapter.truncate_message (already used by Discord, Telegram, Feishu, Matrix). The first chunk rides the inbound reply context when present; subsequent chunks fall back to proactive APP_CMD_SEND since the WeCom reply_req_id is single-use.

The bug

gateway/platforms/wecom.py:1214 and gateway/platforms/wecom.py:1359 (pre-fix line numbers):

"markdown": {"content": content[:self.MAX_MESSAGE_LENGTH]},

A 6000-character agent response sends one 4000-char message; the remaining 2000 chars are silently discarded. SendResult still reports success=True. The user has no signal that content was lost.

Reported in #19689.

The fix

In WeComAdapter.send:

chunks = self.truncate_message(content, self.MAX_MESSAGE_LENGTH)

response: Dict[str, Any] = {}
for index, chunk in enumerate(chunks):
    # WeCom reply_req_id is single-use: only the first chunk can ride
    # the inbound reply context. Subsequent chunks fall back to the
    # proactive APP_CMD_SEND path, which is stateless.
    if index == 0 and reply_req_id:
        response = await self._send_reply_markdown(reply_req_id, chunk)
    else:
        response = await self._send_request(
            APP_CMD_SEND,
            {
                "chatid": chat_id,
                "msgtype": "markdown",
                "markdown": {"content": chunk},
            },
        )
    error = self._response_error(response)
    if error:
        return SendResult(success=False, error=error)

truncate_message already preserves code-block fences across chunk boundaries and adds (1/N) indicators within MAX_MESSAGE_LENGTH. The redundant content[:self.MAX_MESSAGE_LENGTH] slice in _send_reply_markdown is dropped as well: the only caller (send) pre-chunks now, and the slice read like an ongoing truncation contract that no longer applies.

If a chunk fails (e.g. WeCom errcode), send() aborts and returns the failure rather than continuing to fire follow-ups against an already-rejecting endpoint.

Test plan

• Focused regression: tests/gateway/test_wecom.py::TestSend — 4 new tests cover (a) long proactive markdown splits into multiple APP_CMD_SEND calls, each ≤ MAX_MESSAGE_LENGTH; (b) long content with reply context uses passive reply for chunk 1 and proactive APP_CMD_SEND for chunks 2+; (c) short messages still produce exactly one send with content unchanged; (d) early-chunk failure aborts the send loop.
• Adjacent suite: tests/gateway/test_wecom.py (45 passed), tests/gateway/test_wecom_callback.py + tests/gateway/test_text_batching.py (31 passed).
• Regression guard: with the production change reverted, test_send_splits_long_proactive_markdown_into_multiple_messages and test_send_long_message_first_chunk_uses_reply_then_proactive both fail (await_count == 1 instead of >= 2) — confirming the silent-truncation behavior the fix removes.

Related

Fixes #19689.

Sibling code paths that may need the same fix: gateway/platforms/dingtalk.py (lines around the two content[: self.MAX_MESSAGE_LENGTH] slices, with limit 20000) and gateway/platforms/homeassistant.py:405 (limit 4096) both still slice instead of chunking. Intentionally left out of this PR's scope to keep the diff small and focused on the reported WeCom bug — happy to widen if preferred.

Changed files

• gateway/platforms/wecom.py (modified, +22/-16)
• tests/gateway/test_wecom.py (modified, +93/-0)

PR #20006: fix(wecom): split long markdown sends

• Repository: NousResearch/hermes-agent
• Author: LeonSGP43
• State: open | merged: False
• Link: https://github.com/NousResearch/hermes-agent/pull/20006

Description (problem / solution / changelog)

Summary

• split long WeCom markdown replies instead of slicing to 4000 characters
• split proactive WeCom markdown sends with the same shared chunking behavior
• keep single-chunk responses backward-compatible while exposing chunk raw responses for split sends

Fixes #19689

Tests

• scripts/run_tests.sh tests/gateway/test_wecom.py
• git diff --check

Changed files

• gateway/platforms/wecom.py (modified, +41/-17)
• tests/gateway/test_wecom.py (modified, +48/-1)