@openclaw/feishu 2026.3.13 → 2026.5.2-beta.1

package/src/monitor.account.ts

@@ -1,7 +1,6 @@
-import * as crypto from "crypto";
-import * as Lark from "@larksuiteoapi/node-sdk";
-import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk/feishu";
-import { resolveFeishuAccount } from "./accounts.js";
+import * as crypto from "node:crypto";
+import type * as Lark from "@larksuiteoapi/node-sdk";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "../runtime-api.js";
 import { raceWithTimeoutAndAbort } from "./async.js";
 import {
   handleFeishuMessage,
@@ -11,33 +10,44 @@ import {
 } from "./bot.js";
 import { handleFeishuCardAction, type FeishuCardActionEvent } from "./card-action.js";
 import { createEventDispatcher } from "./client.js";
+import { isRecord, readString } from "./comment-shared.js";
 import {
   hasProcessedFeishuMessage,
   recordProcessedFeishuMessage,
-  releaseFeishuMessageProcessing,
-  tryBeginFeishuMessageProcessing,
   warmupDedupFromDisk,
 } from "./dedup.js";
-import { isMentionForwardRequest } from "./mention.js";
+import { applyBotIdentityState, startBotIdentityRecovery } from "./monitor.bot-identity.js";
+import { createFeishuBotMenuHandler } from "./monitor.bot-menu-handler.js";
+import { createFeishuDriveCommentNoticeHandler } from "./monitor.comment-notice-handler.js";
+import { createFeishuMessageReceiveHandler } from "./monitor.message-handler.js";
 import { fetchBotIdentityForMonitor } from "./monitor.startup.js";
 import { botNames, botOpenIds } from "./monitor.state.js";
+import { FeishuRetryableSyntheticEventError } from "./monitor.synthetic-error.js";
 import { monitorWebhook, monitorWebSocket } from "./monitor.transport.js";
 import { getFeishuRuntime } from "./runtime.js";
 import { getMessageFeishu } from "./send.js";
+import { getFeishuSequentialKey } from "./sequential-key.js";
+import { createFeishuThreadBindingManager } from "./thread-bindings.js";
 import type { FeishuChatType, ResolvedFeishuAccount } from "./types.js";
 
 const FEISHU_REACTION_VERIFY_TIMEOUT_MS = 1_500;
 
+export { FeishuRetryableSyntheticEventError };
+
 export type FeishuReactionCreatedEvent = {
   message_id: string;
   chat_id?: string;
   chat_type?: string;
   reaction_type?: { emoji_type?: string };
   operator_type?: string;
-  user_id?: { open_id?: string };
+  user_id?: { open_id?: string; user_id?: string };
   action_time?: string;
 };
 
+export type FeishuReactionDeletedEvent = FeishuReactionCreatedEvent & {
+  reaction_id?: string;
+};
+
 type ResolveReactionSyntheticEventParams = {
   cfg: ClawdbotConfig;
   accountId: string;
@@ -47,6 +57,7 @@ type ResolveReactionSyntheticEventParams = {
   verificationTimeoutMs?: number;
   logger?: (message: string) => void;
   uuid?: () => string;
+  action?: "created" | "deleted";
 };
 
 export async function resolveReactionSyntheticEvent(
@@ -61,15 +72,18 @@ export async function resolveReactionSyntheticEvent(
     verificationTimeoutMs = FEISHU_REACTION_VERIFY_TIMEOUT_MS,
     logger,
     uuid = () => crypto.randomUUID(),
+    action = "created",
   } = params;
 
   const emoji = event.reaction_type?.emoji_type;
   const messageId = event.message_id;
   const senderId = event.user_id?.open_id;
+  const senderUserId = event.user_id?.user_id;
   if (!emoji || !messageId || !senderId) {
     return null;
   }
 
+  const { resolveFeishuAccount } = await import("./accounts.js");
   const account = resolveFeishuAccount({ cfg, accountId });
   const reactionNotifications = account.config.reactionNotifications ?? "own";
   if (reactionNotifications === "off") {
@@ -120,7 +134,10 @@ export async function resolveReactionSyntheticEvent(
   const syntheticChatType: FeishuChatType = resolvedChatType;
   return {
     sender: {
-      sender_id: { open_id: senderId },
+      sender_id: {
+        open_id: senderId,
+        ...(senderUserId ? { user_id: senderUserId } : {}),
+      },
       sender_type: "user",
     },
     message: {
@@ -129,14 +146,19 @@ export async function resolveReactionSyntheticEvent(
       chat_type: syntheticChatType,
       message_type: "text",
       content: JSON.stringify({
-        text: `[reacted with ${emoji} to message ${messageId}]`,
+        text:
+          action === "deleted"
+            ? `[removed reaction ${emoji} from message ${messageId}]`
+            : `[reacted with ${emoji} to message ${messageId}]`,
       }),
     },
   };
 }
 
 function normalizeFeishuChatType(value: unknown): FeishuChatType | undefined {
-  return value === "group" || value === "private" || value === "p2p" ? value : undefined;
+  return value === "group" || value === "topic_group" || value === "private" || value === "p2p"
+    ? value
+    : undefined;
 }
 
 type RegisterEventHandlersContext = {
@@ -147,97 +169,73 @@ type RegisterEventHandlersContext = {
   fireAndForget?: boolean;
 };
 
-/**
- * Per-chat serial queue that ensures messages from the same chat are processed
- * in arrival order while allowing different chats to run concurrently.
- */
-function createChatQueue() {
-  const queues = new Map<string, Promise<void>>();
-  return (chatId: string, task: () => Promise<void>): Promise<void> => {
-    const prev = queues.get(chatId) ?? Promise.resolve();
-    const next = prev.then(task, task);
-    queues.set(chatId, next);
-    void next.finally(() => {
-      if (queues.get(chatId) === next) {
-        queues.delete(chatId);
-      }
-    });
-    return next;
-  };
+function parseFeishuBotAddedEventPayload(value: unknown): FeishuBotAddedEvent | null {
+  if (!isRecord(value) || !readString(value.chat_id) || !isRecord(value.operator_id)) {
+    return null;
+  }
+  return value as FeishuBotAddedEvent;
 }
 
-function mergeFeishuDebounceMentions(
-  entries: FeishuMessageEvent[],
-): FeishuMessageEvent["message"]["mentions"] | undefined {
-  const merged = new Map<string, NonNullable<FeishuMessageEvent["message"]["mentions"]>[number]>();
-  for (const entry of entries) {
-    for (const mention of entry.message.mentions ?? []) {
-      const stableId =
-        mention.id.open_id?.trim() || mention.id.user_id?.trim() || mention.id.union_id?.trim();
-      const mentionName = mention.name?.trim();
-      const mentionKey = mention.key?.trim();
-      const fallback =
-        mentionName && mentionKey ? `${mentionName}|${mentionKey}` : mentionName || mentionKey;
-      const key = stableId || fallback;
-      if (!key || merged.has(key)) {
-        continue;
-      }
-      merged.set(key, mention);
-    }
-  }
-  if (merged.size === 0) {
-    return undefined;
+function parseFeishuBotRemovedChatId(value: unknown): string | null {
+  if (!isRecord(value)) {
+    return null;
   }
-  return Array.from(merged.values());
+  return readString(value.chat_id) ?? null;
 }
 
-function dedupeFeishuDebounceEntriesByMessageId(
-  entries: FeishuMessageEvent[],
-): FeishuMessageEvent[] {
-  const seen = new Set<string>();
-  const deduped: FeishuMessageEvent[] = [];
-  for (const entry of entries) {
-    const messageId = entry.message.message_id?.trim();
-    if (!messageId) {
-      deduped.push(entry);
-      continue;
-    }
-    if (seen.has(messageId)) {
-      continue;
+function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    const stringValue = readString(value);
+    const trimmed = stringValue?.trim();
+    if (trimmed) {
+      return trimmed;
     }
-    seen.add(messageId);
-    deduped.push(entry);
   }
-  return deduped;
+  return undefined;
 }
 
-function resolveFeishuDebounceMentions(params: {
-  entries: FeishuMessageEvent[];
-  botOpenId?: string;
-}): FeishuMessageEvent["message"]["mentions"] | undefined {
-  const { entries, botOpenId } = params;
-  if (entries.length === 0) {
-    return undefined;
-  }
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (isMentionForwardRequest(entry, botOpenId)) {
-      // Keep mention-forward semantics scoped to a single source message.
-      return mergeFeishuDebounceMentions([entry]);
-    }
+function parseFeishuCardActionEventPayload(value: unknown): FeishuCardActionEvent | null {
+  if (!isRecord(value)) {
+    return null;
   }
-  const merged = mergeFeishuDebounceMentions(entries);
-  if (!merged) {
-    return undefined;
+  const operator = isRecord(value.operator) ? value.operator : {};
+  const action = value.action;
+  const context = isRecord(value.context) ? value.context : {};
+  if (!isRecord(action)) {
+    return null;
   }
-  const normalizedBotOpenId = botOpenId?.trim();
-  if (!normalizedBotOpenId) {
-    return undefined;
+  const token = readString(value.token);
+  const openId = firstString(operator.open_id, value.open_id, context.open_id);
+  const userId = firstString(operator.user_id, value.user_id, context.user_id);
+  const unionId = firstString(operator.union_id);
+  const tag = readString(action.tag);
+  const actionValue = action.value;
+  const openMessageId = firstString(value.open_message_id, context.open_message_id);
+  const contextOpenId = firstString(context.open_id, openId);
+  const contextUserId = firstString(context.user_id, userId);
+  const chatId = firstString(context.chat_id, context.open_chat_id);
+  if (!token || !openId || !tag || !isRecord(actionValue)) {
+    return null;
   }
-  const botMentions = merged.filter(
-    (mention) => mention.id.open_id?.trim() === normalizedBotOpenId,
-  );
-  return botMentions.length > 0 ? botMentions : undefined;
+  return {
+    operator: {
+      open_id: openId,
+      ...(userId ? { user_id: userId } : {}),
+      ...(unionId ? { union_id: unionId } : {}),
+    },
+    token,
+    action: {
+      value: actionValue,
+      tag,
+    },
+    ...(openMessageId ? { open_message_id: openMessageId } : {}),
+    context: {
+      ...(openMessageId ? { open_message_id: openMessageId } : {}),
+      ...(contextOpenId ? { open_id: contextOpenId } : {}),
+      ...(contextUserId ? { user_id: contextUserId } : {}),
+      ...(chatId ? { chat_id: chatId } : {}),
+    },
+  };
 }
 
 function registerEventHandlers(
@@ -245,175 +243,48 @@ function registerEventHandlers(
   context: RegisterEventHandlersContext,
 ): void {
   const { cfg, accountId, runtime, chatHistories, fireAndForget } = context;
-  const core = getFeishuRuntime();
-  const inboundDebounceMs = core.channel.debounce.resolveInboundDebounceMs({
-    cfg,
-    channel: "feishu",
-  });
   const log = runtime?.log ?? console.log;
   const error = runtime?.error ?? console.error;
-  const enqueue = createChatQueue();
-  const dispatchFeishuMessage = async (event: FeishuMessageEvent) => {
-    const chatId = event.message.chat_id?.trim() || "unknown";
-    const task = () =>
-      handleFeishuMessage({
-        cfg,
-        event,
-        botOpenId: botOpenIds.get(accountId),
-        botName: botNames.get(accountId),
-        runtime,
-        chatHistories,
-        accountId,
-        processingClaimHeld: true,
+  const runFeishuHandler = async (params: { task: () => Promise<void>; errorMessage: string }) => {
+    if (fireAndForget) {
+      void params.task().catch((err) => {
+        error(`${params.errorMessage}: ${String(err)}`);
       });
-    await enqueue(chatId, task);
-  };
-  const resolveSenderDebounceId = (event: FeishuMessageEvent): string | undefined => {
-    const senderId =
-      event.sender.sender_id.open_id?.trim() || event.sender.sender_id.user_id?.trim();
-    return senderId || undefined;
-  };
-  const resolveDebounceText = (event: FeishuMessageEvent): string => {
-    const botOpenId = botOpenIds.get(accountId);
-    const parsed = parseFeishuMessageEvent(event, botOpenId, botNames.get(accountId));
-    return parsed.content.trim();
-  };
-  const recordSuppressedMessageIds = async (
-    entries: FeishuMessageEvent[],
-    dispatchMessageId?: string,
-  ) => {
-    const keepMessageId = dispatchMessageId?.trim();
-    const suppressedIds = new Set(
-      entries
-        .map((entry) => entry.message.message_id?.trim())
-        .filter((id): id is string => Boolean(id) && (!keepMessageId || id !== keepMessageId)),
-    );
-    if (suppressedIds.size === 0) {
       return;
     }
-    for (const messageId of suppressedIds) {
-      try {
-        await recordProcessedFeishuMessage(messageId, accountId, log);
-      } catch (err) {
-        error(
-          `feishu[${accountId}]: failed to record merged dedupe id ${messageId}: ${String(err)}`,
-        );
-      }
+    try {
+      await params.task();
+    } catch (err) {
+      error(`${params.errorMessage}: ${String(err)}`);
     }
   };
-  const isMessageAlreadyProcessed = async (entry: FeishuMessageEvent): Promise<boolean> => {
-    return await hasProcessedFeishuMessage(entry.message.message_id, accountId, log);
-  };
-  const inboundDebouncer = core.channel.debounce.createInboundDebouncer<FeishuMessageEvent>({
-    debounceMs: inboundDebounceMs,
-    buildKey: (event) => {
-      const chatId = event.message.chat_id?.trim();
-      const senderId = resolveSenderDebounceId(event);
-      if (!chatId || !senderId) {
-        return null;
-      }
-      const rootId = event.message.root_id?.trim();
-      const threadKey = rootId ? `thread:${rootId}` : "chat";
-      return `feishu:${accountId}:${chatId}:${threadKey}:${senderId}`;
-    },
-    shouldDebounce: (event) => {
-      if (event.message.message_type !== "text") {
-        return false;
-      }
-      const text = resolveDebounceText(event);
-      if (!text) {
-        return false;
-      }
-      return !core.channel.text.hasControlCommand(text, cfg);
-    },
-    onFlush: async (entries) => {
-      const last = entries.at(-1);
-      if (!last) {
-        return;
-      }
-      if (entries.length === 1) {
-        await dispatchFeishuMessage(last);
-        return;
-      }
-      const dedupedEntries = dedupeFeishuDebounceEntriesByMessageId(entries);
-      const freshEntries: FeishuMessageEvent[] = [];
-      for (const entry of dedupedEntries) {
-        if (!(await isMessageAlreadyProcessed(entry))) {
-          freshEntries.push(entry);
-        }
-      }
-      const dispatchEntry = freshEntries.at(-1);
-      if (!dispatchEntry) {
-        return;
-      }
-      await recordSuppressedMessageIds(dedupedEntries, dispatchEntry.message.message_id);
-      const combinedText = freshEntries
-        .map((entry) => resolveDebounceText(entry))
-        .filter(Boolean)
-        .join("\n");
-      const mergedMentions = resolveFeishuDebounceMentions({
-        entries: freshEntries,
-        botOpenId: botOpenIds.get(accountId),
-      });
-      if (!combinedText.trim()) {
-        await dispatchFeishuMessage({
-          ...dispatchEntry,
-          message: {
-            ...dispatchEntry.message,
-            mentions: mergedMentions ?? dispatchEntry.message.mentions,
-          },
-        });
-        return;
-      }
-      await dispatchFeishuMessage({
-        ...dispatchEntry,
-        message: {
-          ...dispatchEntry.message,
-          message_type: "text",
-          content: JSON.stringify({ text: combinedText }),
-          mentions: mergedMentions ?? dispatchEntry.message.mentions,
-        },
-      });
-    },
-    onError: (err, entries) => {
-      for (const entry of entries) {
-        releaseFeishuMessageProcessing(entry.message.message_id, accountId);
-      }
-      error(`feishu[${accountId}]: inbound debounce flush failed: ${String(err)}`);
-    },
-  });
 
   eventDispatcher.register({
-    "im.message.receive_v1": async (data) => {
-      const event = data as unknown as FeishuMessageEvent;
-      const messageId = event.message?.message_id?.trim();
-      if (!tryBeginFeishuMessageProcessing(messageId, accountId)) {
-        log(`feishu[${accountId}]: dropping duplicate event for message ${messageId}`);
-        return;
-      }
-      const processMessage = async () => {
-        await inboundDebouncer.enqueue(event);
-      };
-      if (fireAndForget) {
-        void processMessage().catch((err) => {
-          releaseFeishuMessageProcessing(messageId, accountId);
-          error(`feishu[${accountId}]: error handling message: ${String(err)}`);
-        });
-        return;
-      }
-      try {
-        await processMessage();
-      } catch (err) {
-        releaseFeishuMessageProcessing(messageId, accountId);
-        error(`feishu[${accountId}]: error handling message: ${String(err)}`);
-      }
-    },
+    "im.message.receive_v1": createFeishuMessageReceiveHandler({
+      cfg,
+      core: getFeishuRuntime(),
+      accountId,
+      runtime,
+      chatHistories,
+      fireAndForget,
+      handleMessage: handleFeishuMessage,
+      resolveDebounceText: ({ event, botOpenId, botName }) =>
+        parseFeishuMessageEvent(event, botOpenId, botName).content,
+      hasProcessedMessage: hasProcessedFeishuMessage,
+      recordProcessedMessage: recordProcessedFeishuMessage,
+      getBotOpenId: (id) => botOpenIds.get(id),
+      getBotName: (id) => botNames.get(id),
+      resolveSequentialKey: getFeishuSequentialKey,
+    }),
     "im.message.message_read_v1": async () => {
       // Ignore read receipts
     },
     "im.chat.member.bot.added_v1": async (data) => {
       try {
-        const event = data as unknown as FeishuBotAddedEvent;
+        const event = parseFeishuBotAddedEventPayload(data);
+        if (!event) {
+          return;
+        }
         log(`feishu[${accountId}]: bot added to chat ${event.chat_id}`);
       } catch (err) {
         error(`feishu[${accountId}]: error handling bot added event: ${String(err)}`);
@@ -421,63 +292,94 @@ function registerEventHandlers(
     },
     "im.chat.member.bot.deleted_v1": async (data) => {
       try {
-        const event = data as unknown as { chat_id: string };
-        log(`feishu[${accountId}]: bot removed from chat ${event.chat_id}`);
+        const chatId = parseFeishuBotRemovedChatId(data);
+        if (!chatId) {
+          return;
+        }
+        log(`feishu[${accountId}]: bot removed from chat ${chatId}`);
       } catch (err) {
         error(`feishu[${accountId}]: error handling bot removed event: ${String(err)}`);
       }
     },
+    "drive.notice.comment_add_v1": createFeishuDriveCommentNoticeHandler({
+      cfg,
+      accountId,
+      runtime,
+      fireAndForget,
+    }),
     "im.message.reaction.created_v1": async (data) => {
-      const processReaction = async () => {
-        const event = data as FeishuReactionCreatedEvent;
-        const myBotId = botOpenIds.get(accountId);
-        const syntheticEvent = await resolveReactionSyntheticEvent({
-          cfg,
-          accountId,
-          event,
-          botOpenId: myBotId,
-          logger: log,
-        });
-        if (!syntheticEvent) {
-          return;
-        }
-        const promise = handleFeishuMessage({
-          cfg,
-          event: syntheticEvent,
-          botOpenId: myBotId,
-          botName: botNames.get(accountId),
-          runtime,
-          chatHistories,
-          accountId,
-        });
-        if (fireAndForget) {
-          promise.catch((err) => {
-            error(`feishu[${accountId}]: error handling reaction: ${String(err)}`);
+      await runFeishuHandler({
+        errorMessage: `feishu[${accountId}]: error handling reaction event`,
+        task: async () => {
+          const event = data as FeishuReactionCreatedEvent;
+          const myBotId = botOpenIds.get(accountId);
+          const syntheticEvent = await resolveReactionSyntheticEvent({
+            cfg,
+            accountId,
+            event,
+            botOpenId: myBotId,
+            logger: log,
           });
-          return;
-        }
-        await promise;
-      };
-
-      if (fireAndForget) {
-        void processReaction().catch((err) => {
-          error(`feishu[${accountId}]: error handling reaction event: ${String(err)}`);
-        });
-        return;
-      }
-
-      try {
-        await processReaction();
-      } catch (err) {
-        error(`feishu[${accountId}]: error handling reaction event: ${String(err)}`);
-      }
+          if (!syntheticEvent) {
+            return;
+          }
+          const promise = handleFeishuMessage({
+            cfg,
+            event: syntheticEvent,
+            botOpenId: myBotId,
+            botName: botNames.get(accountId),
+            runtime,
+            chatHistories,
+            accountId,
+          });
+          await promise;
+        },
+      });
     },
-    "im.message.reaction.deleted_v1": async () => {
-      // Ignore reaction removals
+    "im.message.reaction.deleted_v1": async (data) => {
+      await runFeishuHandler({
+        errorMessage: `feishu[${accountId}]: error handling reaction removal event`,
+        task: async () => {
+          const event = data as FeishuReactionDeletedEvent;
+          const myBotId = botOpenIds.get(accountId);
+          const syntheticEvent = await resolveReactionSyntheticEvent({
+            cfg,
+            accountId,
+            event,
+            botOpenId: myBotId,
+            logger: log,
+            action: "deleted",
+          });
+          if (!syntheticEvent) {
+            return;
+          }
+          const promise = handleFeishuMessage({
+            cfg,
+            event: syntheticEvent,
+            botOpenId: myBotId,
+            botName: botNames.get(accountId),
+            runtime,
+            chatHistories,
+            accountId,
+          });
+          await promise;
+        },
+      });
     },
+    "application.bot.menu_v6": createFeishuBotMenuHandler({
+      cfg,
+      accountId,
+      runtime,
+      chatHistories,
+      fireAndForget,
+    }),
     "card.action.trigger": async (data: unknown) => {
       try {
-        const event = data as unknown as FeishuCardActionEvent;
+        const event = parseFeishuCardActionEventPayload(data);
+        if (!event) {
+          error(`feishu[${accountId}]: ignoring malformed card action payload`);
+          return;
+        }
         const promise = handleFeishuCardAction({
           cfg,
           event,
@@ -509,6 +411,7 @@ export type MonitorSingleAccountParams = {
   runtime?: RuntimeEnv;
   abortSignal?: AbortSignal;
   botOpenIdSource?: BotOpenIdSource;
+  fireAndForget?: boolean;
 };
 
 export async function monitorSingleAccount(params: MonitorSingleAccountParams): Promise<void> {
@@ -521,16 +424,13 @@ export async function monitorSingleAccount(params: MonitorSingleAccountParams):
     botOpenIdSource.kind === "prefetched"
       ? { botOpenId: botOpenIdSource.botOpenId, botName: botOpenIdSource.botName }
       : await fetchBotIdentityForMonitor(account, { runtime, abortSignal });
-  const botOpenId = botIdentity.botOpenId;
-  const botName = botIdentity.botName?.trim();
-  botOpenIds.set(accountId, botOpenId ?? "");
-  if (botName) {
-    botNames.set(accountId, botName);
-  } else {
-    botNames.delete(accountId);
-  }
+  const { botOpenId } = applyBotIdentityState(accountId, botIdentity);
   log(`feishu[${accountId}]: bot open_id resolved: ${botOpenId ?? "unknown"}`);
 
+  if (!botOpenId && !abortSignal?.aborted) {
+    startBotIdentityRecovery({ account, accountId, runtime, abortSignal });
+  }
+
   const connectionMode = account.config.connectionMode ?? "websocket";
   if (connectionMode === "webhook" && !account.verificationToken?.trim()) {
     throw new Error(`Feishu account "${accountId}" webhook mode requires verificationToken`);
@@ -544,19 +444,25 @@ export async function monitorSingleAccount(params: MonitorSingleAccountParams):
     log(`feishu[${accountId}]: dedup warmup loaded ${warmupCount} entries from disk`);
   }
 
-  const eventDispatcher = createEventDispatcher(account);
-  const chatHistories = new Map<string, HistoryEntry[]>();
+  let threadBindingManager: ReturnType<typeof createFeishuThreadBindingManager> | null = null;
+  try {
+    const eventDispatcher = createEventDispatcher(account);
+    const chatHistories = new Map<string, HistoryEntry[]>();
+    threadBindingManager = createFeishuThreadBindingManager({ accountId, cfg });
 
-  registerEventHandlers(eventDispatcher, {
-    cfg,
-    accountId,
-    runtime,
-    chatHistories,
-    fireAndForget: true,
-  });
+    registerEventHandlers(eventDispatcher, {
+      cfg,
+      accountId,
+      runtime,
+      chatHistories,
+      fireAndForget: params.fireAndForget ?? true,
+    });
 
-  if (connectionMode === "webhook") {
-    return monitorWebhook({ account, accountId, runtime, abortSignal, eventDispatcher });
+    if (connectionMode === "webhook") {
+      return await monitorWebhook({ account, accountId, runtime, abortSignal, eventDispatcher });
+    }
+    return await monitorWebSocket({ account, accountId, runtime, abortSignal, eventDispatcher });
+  } finally {
+    threadBindingManager?.stop();
   }
-  return monitorWebSocket({ account, accountId, runtime, abortSignal, eventDispatcher });
 }