Summary

• Problem: When multiple Feishu messages arrive rapidly in the same group chat, the agent may only process the latest message and silently skip earlier ones. This happens because fireAndForget: true dispatches all messages concurrently — when message B arrives while message A is still being processed, they race through handleFeishuMessage and the agent may only respond to B.
• Why it matters: Users in group chats lose messages without any indication. The agent appears to randomly ignore questions.
• What changed: extensions/feishu/src/monitor.account.ts — added a createChatQueue() utility that creates a per-chat serial queue. Messages from the same chat_id are now processed in FIFO order (each waits for the previous one to complete). Messages from different chats still run concurrently for performance.
• What did NOT change: Reaction handling, card action handling, bot-added events, and the dedup logic in bot.ts are all untouched. The fireAndForget pattern is preserved — the queue just serializes within a chat.

Change Type (select all)

• Bug fix
• Feature
• Refactor
• Docs
• Security hardening
• Chore/infra

Scope (select all touched areas)

• Gateway / orchestration
• Skills / tool execution
• Auth / tokens
• Memory / storage
• Integrations
• API / contracts
• UI / DX
• CI/CD / infra

Linked Issue/PR

• Closes [Bug]: Feishu群聊中多条消息快速进入时，旧消息可能被跳过不处理 #31727

User-visible / Behavior Changes

• Feishu group chat messages are now processed in order per chat — no more silently skipped messages when users send rapidly

Security Impact (required)

• New permissions/capabilities? No
• Secrets/tokens handling changed? No
• New/changed network calls? No
• Command/tool execution surface changed? No
• Data access scope changed? No

Repro + Verification

Environment

• OS: Any
• Runtime: Node.js
• Integration/channel: Feishu (group chat)

Steps

1. Send message A in a Feishu group chat at 17:14
2. Immediately send message B at 17:14 (within seconds)
3. Wait for agent to finish processing

Expected

• Both messages A and B are processed in order

Actual

• Before fix: Agent only processes message B, message A is silently skipped
• After fix: Agent processes message A first, then message B (FIFO per chat)

Evidence

// Before: all messages dispatched concurrently
const promise = handleFeishuMessage({ event, ... });
if (fireAndForget) {
  promise.catch(...); // fire and forget — no ordering guarantee
}

// After: per-chat serial queue
const chatId = event.message?.chat_id ?? "unknown";
const task = () => handleFeishuMessage({ event, ... });
if (fireAndForget) {
  enqueue(chatId, task).catch(...); // serialized within same chat
}

The queue cleans up automatically when the chain for a chat_id completes.

Human Verification (required)

• Verified scenarios: TypeScript compilation passes (npx tsc --noEmit)
• Edge cases checked: Unknown chat_id defaults to "unknown" (serialized as a single queue), queue map cleanup on chain completion prevents memory leaks, error in one task does not block the next (.then(task, task) pattern)
• What I did not verify: End-to-end Feishu group chat test with rapid messages

Compatibility / Migration

• Backward compatible? Yes
• Config/env changes? No
• Migration needed? No

Failure Recovery (if this breaks)

• How to disable/revert: Revert the single commit. Messages will go back to concurrent processing.
• Files/config to restore: extensions/feishu/src/monitor.account.ts
• Known bad symptoms: If the queue serialization causes a slow message to block subsequent ones — but this is the correct behavior (processing in order)

Risks and Mitigations

• Risk: A slow-processing message blocks subsequent messages in the same chat. Mitigation: This is the intended behavior — messages should be processed in order. Cross-chat concurrency is preserved.