feat(feishu): implement Feishu typing indicator via reactions

[simiwe]

What does this PR do?

Implements a visual typing indicator for the Feishu platform by repurposing message reactions.

Feishu does not provide a native typing API. The base adapter's _keep_typing loop calls send_typing() periodically while a response is being generated, and the processing path calls stop_typing() when the response finishes. In FeishuAdapter, those hooks were effectively no-ops, so Feishu users had no visual feedback that their message was being processed.

This patch adds a minimal reaction-based implementation for Feishu. When processing starts, the adapter adds a Typing reaction to the user's inbound message and stores the returned reaction_id. When processing completes, it deletes that tracked reaction by ID. The patch also records the source message_id only for real inbound message events, so synthetic reaction/card events do not overwrite the typing target.

Related Issue

No existing issue — this is a gap in the Feishu adapter confirmed through production testing.

This PR is the slimmed-down resubmission of #6890. It keeps the same core reaction-tracking approach, but removes the extra env/config surface and narrows the tests to the minimal typing lifecycle and inbound-message tracking behavior.

Related upstream context:

• [Bug]: Matrix typing indicator lingers for up to 30 seconds after response is sent #6016 — Matrix typing indicator lingers after completion
• fix(matrix): add stop_typing to clear typing indicator after response #6020 — Matrix stop_typing fix
• fix: pause typing indicator during approval waits #5893 — pause typing during approval waits

Type of Change

• ✨ New feature (non-breaking change that adds functionality)

Changes Made

• gateway/platforms/feishu.py

  • add _typing_state to track the source message_id and created reaction_id
  • implement send_typing() by creating a Typing reaction on the tracked inbound message
  • implement stop_typing() by deleting the tracked reaction and clearing state
  • update _handle_message_with_guards() so only real inbound messages seed typing state

• tests/gateway/test_feishu.py

  • add a focused lifecycle test covering create-and-delete behavior on the source message
  • add a guard test ensuring synthetic events do not overwrite the tracked inbound message

How to Test

1. Send a message to the bot in Feishu.
2. Observe a Typing reaction appear on the inbound message while the agent is processing.
3. When the agent replies, observe that the Typing reaction is removed.
4. Run:
   • python -m pytest tests/gateway/test_feishu.py -v -o addopts=
   • python -m pytest tests/gateway/test_feishu.py -k "typing or guards or ack_reaction" -v -o addopts=
   • python -m py_compile gateway/platforms/feishu.py tests/gateway/test_feishu.py

Checklist

• My commit messages follow the repository's conventional style
• I searched for existing PRs to make sure this is not a duplicate
• This PR contains only changes related to the Feishu typing indicator
• I added tests for the changed behavior
• I ran the targeted Feishu test coverage listed above

Design Notes

Why reactions?
Feishu's bot API does not expose a native typing endpoint. Reactions are the available in-product feedback mechanism for a bot message workflow.

Why track reaction_id?
Deleting the exact created reaction is simpler and more reliable than listing reactions and trying to rediscover the right entry later.

Why guard against synthetic events?
Feishu reaction and card callbacks are routed as synthetic events in the adapter. Those events should not change the source message used by the typing lifecycle.

[teknium1]

This looks implemented on current main by the newer Feishu processing-reaction lifecycle.

Automated hermes-sweeper review evidence:

• gateway/platforms/feishu.py:233 defines the Feishu processing reaction behavior: Typing for start, no success badge because the reply is the success signal.
• gateway/platforms/feishu.py:1473 caches created reaction IDs by message_id, so the exact Feishu reaction can be deleted later.
• gateway/platforms/feishu.py:3029 adds the Typing reaction in on_processing_start() and stores the returned reaction_id.
• gateway/platforms/feishu.py:3039 removes the cached reaction in on_processing_complete() and only adds CrossMark for failures.
• gateway/platforms/base.py:4085 and gateway/platforms/base.py:4388 show those hooks are called around the actual message-processing path.
• tests/gateway/test_feishu.py:3632 covers the lifecycle: start, success removal, failure replacement, cancellation, delete-failure handling, and cache bounds.

The implementation shape differs from this PR's send_typing() / stop_typing() approach, but the requested Feishu visual typing indicator via reactions is present on main. The relevant implementation blames to 413990c94537e9c9da973bb21a6afcd332400b91 and is contained in release tag v2026.5.16.