@lark-project/openclaw-lark-project 2026.3.131

package/dist/src/messaging/inbound/dispatch-builders.js

@@ -0,0 +1,98 @@
+import { buildPendingHistoryContextFromMap } from "openclaw/plugin-sdk";
+import { nonBotMentions } from "./mention";
+import { threadScopedKey } from "../../channel/chat-queue";
+function buildMentionAnnotation(ctx) {
+  const mentions = nonBotMentions(ctx);
+  if (mentions.length === 0) return void 0;
+  const mentionDetails = mentions.map((t) => `${t.name} (open_id: ${t.openId})`).join(", ");
+  return `[System: This message @mentions the following users: ${mentionDetails}. Use these open_ids when performing actions involving these users.]`;
+}
+function buildMessageBody(ctx, quotedContent) {
+  let messageBody = ctx.content;
+  if (quotedContent) {
+    messageBody = `[Replying to: "${quotedContent}"]
+
+${ctx.content}`;
+  }
+  const speaker = ctx.senderName ?? ctx.senderId;
+  messageBody = `${speaker}: ${messageBody}`;
+  const mentionAnnotation = buildMentionAnnotation(ctx);
+  if (mentionAnnotation) {
+    messageBody += `
+
+${mentionAnnotation}`;
+  }
+  return messageBody;
+}
+function buildBodyForAgent(ctx) {
+  const mentionAnnotation = buildMentionAnnotation(ctx);
+  if (mentionAnnotation) {
+    return `${ctx.content}
+
+${mentionAnnotation}`;
+  }
+  return ctx.content;
+}
+function buildInboundPayload(dc, opts) {
+  return dc.core.channel.reply.finalizeInboundContext({
+    // extraFields first — fixed fields below always take precedence
+    ...opts.extraFields,
+    Body: opts.body,
+    BodyForAgent: opts.bodyForAgent,
+    RawBody: opts.rawBody,
+    CommandBody: opts.commandBody,
+    From: dc.feishuFrom,
+    To: dc.feishuTo,
+    SessionKey: dc.threadSessionKey ?? dc.route.sessionKey,
+    AccountId: dc.route.accountId,
+    ChatType: dc.isGroup ? "group" : "direct",
+    GroupSubject: dc.isGroup ? dc.ctx.chatId : void 0,
+    SenderName: opts.senderName,
+    SenderId: opts.senderId,
+    Provider: "feishu",
+    Surface: "feishu",
+    MessageSid: opts.messageSid,
+    ReplyToBody: opts.replyToBody,
+    InboundHistory: opts.inboundHistory,
+    Timestamp: Date.now(),
+    WasMentioned: opts.wasMentioned,
+    CommandAuthorized: dc.commandAuthorized,
+    OriginatingChannel: "feishu",
+    OriginatingTo: dc.feishuTo
+  });
+}
+function buildEnvelopeWithHistory(dc, messageBody, chatHistories, historyLimit) {
+  const body = dc.core.channel.reply.formatAgentEnvelope({
+    channel: "Feishu",
+    from: dc.envelopeFrom,
+    timestamp: /* @__PURE__ */ new Date(),
+    envelope: dc.envelopeOptions,
+    body: messageBody
+  });
+  let combinedBody = body;
+  const historyKey = dc.isGroup ? threadScopedKey(dc.ctx.chatId, dc.isThread ? dc.ctx.threadId : void 0) : void 0;
+  if (dc.isGroup && historyKey && chatHistories) {
+    combinedBody = buildPendingHistoryContextFromMap({
+      historyMap: chatHistories,
+      historyKey,
+      limit: historyLimit,
+      currentMessage: combinedBody,
+      formatEntry: (entry) => dc.core.channel.reply.formatAgentEnvelope({
+        channel: "Feishu",
+        from: `${dc.ctx.chatId}:${entry.sender}`,
+        timestamp: entry.timestamp,
+        body: entry.body,
+        envelope: dc.envelopeOptions
+      })
+    });
+  }
+  return { combinedBody, historyKey };
+}
+export {
+  buildBodyForAgent,
+  buildEnvelopeWithHistory,
+  buildInboundPayload,
+  buildMentionAnnotation,
+  buildMessageBody
+};
+//# sourceMappingURL=dispatch-builders.js.map

package/dist/src/messaging/inbound/dispatch-builders.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/dispatch-builders.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Pure construction functions for the agent dispatch pipeline.\n *\n * All functions in this module are side-effect-free: they build data\n * structures (message bodies, envelope payloads, inbound context) but\n * never perform I/O, send messages, or mutate external state.\n */\n\nimport type { HistoryEntry } from 'openclaw/plugin-sdk';\nimport { buildPendingHistoryContextFromMap } from 'openclaw/plugin-sdk';\nimport type { MessageContext } from '../types';\nimport type { DispatchContext } from './dispatch-context';\nimport { LarkClient } from '../../core/lark-client';\nimport { nonBotMentions } from './mention';\nimport { threadScopedKey } from '../../channel/chat-queue';\n\n// ---------------------------------------------------------------------------\n// Mention annotation\n// ---------------------------------------------------------------------------\n\n/**\n * Build a `[System: ...]` mention annotation when the message @-mentions\n * non-bot users.  Returns `undefined` when there are no user mentions.\n *\n * Sender identity / chat metadata are handled by the SDK's own\n * `buildInboundUserContextPrefix` (via SenderId, SenderName, ReplyToBody,\n * InboundHistory, etc.), so we only inject the mention data that the SDK\n * does not natively support.\n */\nexport function buildMentionAnnotation(ctx: MessageContext): string | undefined {\n  const mentions = nonBotMentions(ctx);\n  if (mentions.length === 0) return undefined;\n  const mentionDetails = mentions.map((t) => `${t.name} (open_id: ${t.openId})`).join(', ');\n  return `[System: This message @mentions the following users: ${mentionDetails}. Use these open_ids when performing actions involving these users.]`;\n}\n\n// ---------------------------------------------------------------------------\n// Message body builders\n// ---------------------------------------------------------------------------\n\n/**\n * Pure function: build the annotated message body with optional quote,\n * speaker prefix, and mention annotation (for the envelope Body).\n *\n * Note: message_id and reply_to are now conveyed via system-event tags\n * (msg:om_xxx, reply_to:om_yyy) instead of inline annotations, keeping\n * the body cleaner and avoiding misleading heuristics for non-text\n * message types (merge_forward, interactive cards, etc.).\n */\nexport function buildMessageBody(ctx: MessageContext, quotedContent?: string): string {\n  let messageBody = ctx.content;\n  if (quotedContent) {\n    messageBody = `[Replying to: \"${quotedContent}\"]\\n\\n${ctx.content}`;\n  }\n\n  const speaker = ctx.senderName ?? ctx.senderId;\n  messageBody = `${speaker}: ${messageBody}`;\n\n  const mentionAnnotation = buildMentionAnnotation(ctx);\n  if (mentionAnnotation) {\n    messageBody += `\\n\\n${mentionAnnotation}`;\n  }\n\n  return messageBody;\n}\n\n/**\n * Build the BodyForAgent value: the clean message content plus an\n * optional mention annotation.\n *\n * SDK >= 2026.2.10 changed the BodyForAgent fallback chain from\n * `BodyForAgent ?? Body` to `BodyForAgent ?? CommandBody ?? RawBody ?? Body`,\n * so annotations embedded only in Body never reach the AI.  Setting\n * BodyForAgent explicitly ensures the mention annotation survives.\n *\n * Sender identity, reply context, and chat history are NOT duplicated\n * here \u2014 they are injected by the SDK's `buildInboundUserContextPrefix`\n * via the standard fields (SenderId, SenderName, ReplyToBody,\n * InboundHistory) that we pass in buildInboundPayload.\n *\n * Note: media file paths are substituted into `ctx.content` upstream\n * (handler.ts -> substituteMediaPaths) before this function is called.\n * The SDK's `detectAndLoadPromptImages` will discover image paths from\n * the text and inject them as multimodal content blocks.\n */\nexport function buildBodyForAgent(ctx: MessageContext): string {\n  const mentionAnnotation = buildMentionAnnotation(ctx);\n  if (mentionAnnotation) {\n    return `${ctx.content}\\n\\n${mentionAnnotation}`;\n  }\n  return ctx.content;\n}\n\n// ---------------------------------------------------------------------------\n// Inbound payload builder\n// ---------------------------------------------------------------------------\n\n/**\n * Unified call to `finalizeInboundContext`, eliminating the duplicated\n * field-mapping between permission notification and main message paths.\n */\nexport function buildInboundPayload(\n  dc: DispatchContext,\n  opts: {\n    body: string;\n    bodyForAgent: string;\n    rawBody: string;\n    commandBody: string;\n    senderName: string;\n    senderId: string;\n    messageSid: string;\n    wasMentioned: boolean;\n    replyToBody?: string;\n    inboundHistory?: { sender: string; body: string; timestamp: number }[];\n    extraFields?: Record<string, unknown>;\n  },\n): ReturnType<typeof LarkClient.runtime.channel.reply.finalizeInboundContext> {\n  return dc.core.channel.reply.finalizeInboundContext({\n    // extraFields first \u2014 fixed fields below always take precedence\n    ...opts.extraFields,\n    Body: opts.body,\n    BodyForAgent: opts.bodyForAgent,\n    RawBody: opts.rawBody,\n    CommandBody: opts.commandBody,\n    From: dc.feishuFrom,\n    To: dc.feishuTo,\n    SessionKey: dc.threadSessionKey ?? dc.route.sessionKey,\n    AccountId: dc.route.accountId,\n    ChatType: dc.isGroup ? 'group' : 'direct',\n    GroupSubject: dc.isGroup ? dc.ctx.chatId : undefined,\n    SenderName: opts.senderName,\n    SenderId: opts.senderId,\n    Provider: 'feishu' as const,\n    Surface: 'feishu' as const,\n    MessageSid: opts.messageSid,\n    ReplyToBody: opts.replyToBody,\n    InboundHistory: opts.inboundHistory,\n    Timestamp: Date.now(),\n    WasMentioned: opts.wasMentioned,\n    CommandAuthorized: dc.commandAuthorized,\n    OriginatingChannel: 'feishu' as const,\n    OriginatingTo: dc.feishuTo,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Envelope + history builder\n// ---------------------------------------------------------------------------\n\n/**\n * Format the agent envelope and prepend group chat history if applicable.\n * Returns the combined body and the history key (undefined for DMs).\n */\nexport function buildEnvelopeWithHistory(\n  dc: DispatchContext,\n  messageBody: string,\n  chatHistories: Map<string, HistoryEntry[]> | undefined,\n  historyLimit: number,\n): { combinedBody: string; historyKey: string | undefined } {\n  const body = dc.core.channel.reply.formatAgentEnvelope({\n    channel: 'Feishu',\n    from: dc.envelopeFrom,\n    timestamp: new Date(),\n    envelope: dc.envelopeOptions,\n    body: messageBody,\n  });\n\n  let combinedBody = body;\n  const historyKey = dc.isGroup ? threadScopedKey(dc.ctx.chatId, dc.isThread ? dc.ctx.threadId : undefined) : undefined;\n\n  if (dc.isGroup && historyKey && chatHistories) {\n    combinedBody = buildPendingHistoryContextFromMap({\n      historyMap: chatHistories,\n      historyKey,\n      limit: historyLimit,\n      currentMessage: combinedBody,\n      formatEntry: (entry) =>\n        dc.core.channel.reply.formatAgentEnvelope({\n          channel: 'Feishu',\n          from: `${dc.ctx.chatId}:${entry.sender}`,\n          timestamp: entry.timestamp,\n          body: entry.body,\n          envelope: dc.envelopeOptions,\n        }),\n    });\n  }\n\n  return { combinedBody, historyKey };\n}\n"],
+  "mappings": "AAYA,SAAS,yCAAyC;AAIlD,SAAS,sBAAsB;AAC/B,SAAS,uBAAuB;AAezB,SAAS,uBAAuB,KAAyC;AAC9E,QAAM,WAAW,eAAe,GAAG;AACnC,MAAI,SAAS,WAAW,EAAG,QAAO;AAClC,QAAM,iBAAiB,SAAS,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,cAAc,EAAE,MAAM,GAAG,EAAE,KAAK,IAAI;AACxF,SAAO,wDAAwD,cAAc;AAC/E;AAeO,SAAS,iBAAiB,KAAqB,eAAgC;AACpF,MAAI,cAAc,IAAI;AACtB,MAAI,eAAe;AACjB,kBAAc,kBAAkB,aAAa;AAAA;AAAA,EAAS,IAAI,OAAO;AAAA,EACnE;AAEA,QAAM,UAAU,IAAI,cAAc,IAAI;AACtC,gBAAc,GAAG,OAAO,KAAK,WAAW;AAExC,QAAM,oBAAoB,uBAAuB,GAAG;AACpD,MAAI,mBAAmB;AACrB,mBAAe;AAAA;AAAA,EAAO,iBAAiB;AAAA,EACzC;AAEA,SAAO;AACT;AAqBO,SAAS,kBAAkB,KAA6B;AAC7D,QAAM,oBAAoB,uBAAuB,GAAG;AACpD,MAAI,mBAAmB;AACrB,WAAO,GAAG,IAAI,OAAO;AAAA;AAAA,EAAO,iBAAiB;AAAA,EAC/C;AACA,SAAO,IAAI;AACb;AAUO,SAAS,oBACd,IACA,MAa4E;AAC5E,SAAO,GAAG,KAAK,QAAQ,MAAM,uBAAuB;AAAA;AAAA,IAElD,GAAG,KAAK;AAAA,IACR,MAAM,KAAK;AAAA,IACX,cAAc,KAAK;AAAA,IACnB,SAAS,KAAK;AAAA,IACd,aAAa,KAAK;AAAA,IAClB,MAAM,GAAG;AAAA,IACT,IAAI,GAAG;AAAA,IACP,YAAY,GAAG,oBAAoB,GAAG,MAAM;AAAA,IAC5C,WAAW,GAAG,MAAM;AAAA,IACpB,UAAU,GAAG,UAAU,UAAU;AAAA,IACjC,cAAc,GAAG,UAAU,GAAG,IAAI,SAAS;AAAA,IAC3C,YAAY,KAAK;AAAA,IACjB,UAAU,KAAK;AAAA,IACf,UAAU;AAAA,IACV,SAAS;AAAA,IACT,YAAY,KAAK;AAAA,IACjB,aAAa,KAAK;AAAA,IAClB,gBAAgB,KAAK;AAAA,IACrB,WAAW,KAAK,IAAI;AAAA,IACpB,cAAc,KAAK;AAAA,IACnB,mBAAmB,GAAG;AAAA,IACtB,oBAAoB;AAAA,IACpB,eAAe,GAAG;AAAA,EACpB,CAAC;AACH;AAUO,SAAS,yBACd,IACA,aACA,eACA,cAC0D;AAC1D,QAAM,OAAO,GAAG,KAAK,QAAQ,MAAM,oBAAoB;AAAA,IACrD,SAAS;AAAA,IACT,MAAM,GAAG;AAAA,IACT,WAAW,oBAAI,KAAK;AAAA,IACpB,UAAU,GAAG;AAAA,IACb,MAAM;AAAA,EACR,CAAC;AAED,MAAI,eAAe;AACnB,QAAM,aAAa,GAAG,UAAU,gBAAgB,GAAG,IAAI,QAAQ,GAAG,WAAW,GAAG,IAAI,WAAW,MAAS,IAAI;AAE5G,MAAI,GAAG,WAAW,cAAc,eAAe;AAC7C,mBAAe,kCAAkC;AAAA,MAC/C,YAAY;AAAA,MACZ;AAAA,MACA,OAAO;AAAA,MACP,gBAAgB;AAAA,MAChB,aAAa,CAAC,UACZ,GAAG,KAAK,QAAQ,MAAM,oBAAoB;AAAA,QACxC,SAAS;AAAA,QACT,MAAM,GAAG,GAAG,IAAI,MAAM,IAAI,MAAM,MAAM;AAAA,QACtC,WAAW,MAAM;AAAA,QACjB,MAAM,MAAM;AAAA,QACZ,UAAU,GAAG;AAAA,MACf,CAAC;AAAA,IACL,CAAC;AAAA,EACH;AAEA,SAAO,EAAE,cAAc,WAAW;AACpC;",
+  "names": []
+}

package/dist/src/messaging/inbound/dispatch-commands.js

@@ -0,0 +1,94 @@
+import { larkLogger } from "../../core/lark-logger";
+import { ticketElapsed } from "../../core/lark-ticket";
+import { createFeishuReplyDispatcher } from "../../card/reply-dispatcher";
+import { sendMessageFeishu } from "../outbound/send";
+import { buildInboundPayload } from "./dispatch-builders";
+const log = larkLogger("inbound/dispatch-commands");
+async function dispatchPermissionNotification(dc, permissionError, replyToMessageId) {
+  const grantUrl = permissionError.grantUrl ?? "";
+  const permissionNotifyBody = `[System: The bot encountered a Feishu API permission error. Please inform the user about this issue and provide the permission grant URL for the admin to authorize. Permission grant URL: ${grantUrl}]`;
+  const permBody = dc.core.channel.reply.formatAgentEnvelope({
+    channel: "Feishu",
+    from: dc.envelopeFrom,
+    timestamp: /* @__PURE__ */ new Date(),
+    envelope: dc.envelopeOptions,
+    body: permissionNotifyBody
+  });
+  const permCtx = buildInboundPayload(dc, {
+    body: permBody,
+    bodyForAgent: permissionNotifyBody,
+    rawBody: permissionNotifyBody,
+    commandBody: permissionNotifyBody,
+    senderName: "system",
+    senderId: "system",
+    messageSid: `${dc.ctx.messageId}:permission-error`,
+    wasMentioned: false
+  });
+  const {
+    dispatcher: permDispatcher,
+    replyOptions: permReplyOptions,
+    markDispatchIdle: markPermIdle,
+    markFullyComplete: markPermComplete
+  } = createFeishuReplyDispatcher({
+    cfg: dc.accountScopedCfg,
+    agentId: dc.route.agentId,
+    chatId: dc.ctx.chatId,
+    replyToMessageId: replyToMessageId ?? dc.ctx.messageId,
+    accountId: dc.account.accountId,
+    chatType: dc.ctx.chatType,
+    replyInThread: dc.isThread
+  });
+  dc.log(`feishu[${dc.account.accountId}]: dispatching permission error notification to agent`);
+  await dc.core.channel.reply.dispatchReplyFromConfig({
+    ctx: permCtx,
+    cfg: dc.accountScopedCfg,
+    dispatcher: permDispatcher,
+    replyOptions: permReplyOptions
+  });
+  await permDispatcher.waitForIdle();
+  markPermComplete();
+  markPermIdle();
+}
+async function dispatchSystemCommand(dc, ctxPayload, suppressReply = false, replyToMessageId) {
+  let delivered = false;
+  dc.log(
+    `feishu[${dc.account.accountId}]: detected system command, using plain-text dispatch${suppressReply ? " (reply suppressed)" : ""}`
+  );
+  log.info(`system command detected, plain-text dispatch${suppressReply ? ", reply suppressed" : ""}`);
+  await dc.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg: dc.accountScopedCfg,
+    dispatcherOptions: {
+      deliver: async (payload) => {
+        if (suppressReply) return;
+        const text = payload.text?.trim() ?? "";
+        if (!text) return;
+        await sendMessageFeishu({
+          cfg: dc.accountScopedCfg,
+          to: dc.ctx.chatId,
+          text,
+          replyToMessageId: replyToMessageId ?? dc.ctx.messageId,
+          accountId: dc.account.accountId,
+          replyInThread: dc.isThread
+        });
+        delivered = true;
+      },
+      onSkip: (_payload, info) => {
+        if (info.reason !== "silent") {
+          dc.log(`feishu[${dc.account.accountId}]: command reply skipped (reason=${info.reason})`);
+        }
+      },
+      onError: (err, info) => {
+        dc.error(`feishu[${dc.account.accountId}]: command ${info.kind} reply failed: ${String(err)}`);
+      }
+    },
+    replyOptions: {}
+  });
+  dc.log(`feishu[${dc.account.accountId}]: system command dispatched (delivered=${delivered})`);
+  log.info(`system command dispatched (delivered=${delivered}, elapsed=${ticketElapsed()}ms)`);
+}
+export {
+  dispatchPermissionNotification,
+  dispatchSystemCommand
+};
+//# sourceMappingURL=dispatch-commands.js.map

package/dist/src/messaging/inbound/dispatch-commands.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/dispatch-commands.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * System command and permission notification dispatch for inbound messages.\n *\n * Handles control commands (/help, /reset, etc.) via plain-text delivery\n * and permission-error notifications via the streaming card flow.\n */\n\nimport type { DispatchContext } from './dispatch-context';\nimport type { PermissionError } from './permission';\nimport { LarkClient } from '../../core/lark-client';\nimport { larkLogger } from '../../core/lark-logger';\nimport { ticketElapsed } from '../../core/lark-ticket';\nimport { createFeishuReplyDispatcher } from '../../card/reply-dispatcher';\nimport { sendMessageFeishu } from '../outbound/send';\nimport { buildInboundPayload } from './dispatch-builders';\n\nconst log = larkLogger('inbound/dispatch-commands');\n\n// ---------------------------------------------------------------------------\n// Permission error notification\n// ---------------------------------------------------------------------------\n\n/**\n * Dispatch a permission-error notification to the agent so it can\n * inform the user about the missing Feishu API scope.\n */\nexport async function dispatchPermissionNotification(\n  dc: DispatchContext,\n  permissionError: PermissionError,\n  replyToMessageId?: string,\n): Promise<void> {\n  const grantUrl = permissionError.grantUrl ?? '';\n  const permissionNotifyBody = `[System: The bot encountered a Feishu API permission error. Please inform the user about this issue and provide the permission grant URL for the admin to authorize. Permission grant URL: ${grantUrl}]`;\n\n  const permBody = dc.core.channel.reply.formatAgentEnvelope({\n    channel: 'Feishu',\n    from: dc.envelopeFrom,\n    timestamp: new Date(),\n    envelope: dc.envelopeOptions,\n    body: permissionNotifyBody,\n  });\n\n  const permCtx = buildInboundPayload(dc, {\n    body: permBody,\n    bodyForAgent: permissionNotifyBody,\n    rawBody: permissionNotifyBody,\n    commandBody: permissionNotifyBody,\n    senderName: 'system',\n    senderId: 'system',\n    messageSid: `${dc.ctx.messageId}:permission-error`,\n    wasMentioned: false,\n  });\n\n  const {\n    dispatcher: permDispatcher,\n    replyOptions: permReplyOptions,\n    markDispatchIdle: markPermIdle,\n    markFullyComplete: markPermComplete,\n  } = createFeishuReplyDispatcher({\n    cfg: dc.accountScopedCfg,\n    agentId: dc.route.agentId,\n    chatId: dc.ctx.chatId,\n    replyToMessageId: replyToMessageId ?? dc.ctx.messageId,\n    accountId: dc.account.accountId,\n    chatType: dc.ctx.chatType,\n    replyInThread: dc.isThread,\n  });\n\n  dc.log(`feishu[${dc.account.accountId}]: dispatching permission error notification to agent`);\n\n  await dc.core.channel.reply.dispatchReplyFromConfig({\n    ctx: permCtx,\n    cfg: dc.accountScopedCfg,\n    dispatcher: permDispatcher,\n    replyOptions: permReplyOptions,\n  });\n\n  await permDispatcher.waitForIdle();\n  markPermComplete();\n  markPermIdle();\n}\n\n// ---------------------------------------------------------------------------\n// System command dispatch\n// ---------------------------------------------------------------------------\n\n/**\n * Dispatch a system command (/help, /reset, etc.) via plain-text delivery.\n * No streaming card, no \"Processing...\" state.\n *\n * When `suppressReply` is true the agent still runs (e.g. reads workspace\n * files) but its text output is not forwarded to Feishu.  This is used for\n * bare /new and /reset commands: the SDK already sends a \"done\" notice\n * via its own route, so the AI greeting would be redundant.\n */\nexport async function dispatchSystemCommand(\n  dc: DispatchContext,\n  ctxPayload: ReturnType<typeof LarkClient.runtime.channel.reply.finalizeInboundContext>,\n  suppressReply = false,\n  replyToMessageId?: string,\n): Promise<void> {\n  let delivered = false;\n\n  dc.log(\n    `feishu[${dc.account.accountId}]: detected system command, using plain-text dispatch${suppressReply ? ' (reply suppressed)' : ''}`,\n  );\n  log.info(`system command detected, plain-text dispatch${suppressReply ? ', reply suppressed' : ''}`);\n\n  await dc.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({\n    ctx: ctxPayload,\n    cfg: dc.accountScopedCfg,\n    dispatcherOptions: {\n      deliver: async (payload) => {\n        if (suppressReply) return;\n        const text = payload.text?.trim() ?? '';\n        if (!text) return;\n        await sendMessageFeishu({\n          cfg: dc.accountScopedCfg,\n          to: dc.ctx.chatId,\n          text,\n          replyToMessageId: replyToMessageId ?? dc.ctx.messageId,\n          accountId: dc.account.accountId,\n          replyInThread: dc.isThread,\n        });\n        delivered = true;\n      },\n      onSkip: (_payload, info) => {\n        if (info.reason !== 'silent') {\n          dc.log(`feishu[${dc.account.accountId}]: command reply skipped (reason=${info.reason})`);\n        }\n      },\n      onError: (err, info) => {\n        dc.error(`feishu[${dc.account.accountId}]: command ${info.kind} reply failed: ${String(err)}`);\n      },\n    },\n    replyOptions: {},\n  });\n\n  dc.log(`feishu[${dc.account.accountId}]: system command dispatched (delivered=${delivered})`);\n  log.info(`system command dispatched (delivered=${delivered}, elapsed=${ticketElapsed()}ms)`);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/messaging/inbound/dispatch-context.js

@@ -0,0 +1,96 @@
+import { resolveThreadSessionKeys } from "openclaw/plugin-sdk";
+import { LarkClient } from "../../core/lark-client";
+import { larkLogger } from "../../core/lark-logger";
+import { isThreadCapableGroup } from "../../core/chat-info-cache";
+const log = larkLogger("inbound/dispatch-context");
+function ensureRuntime(runtime) {
+  if (runtime) return runtime;
+  return {
+    log: (...args) => log.info(args.map(String).join(" ")),
+    error: (...args) => log.error(args.map(String).join(" ")),
+    exit: (code) => process.exit(code)
+  };
+}
+function buildDispatchContext(params) {
+  const { ctx, account, accountScopedCfg } = params;
+  const runtime = ensureRuntime(params.runtime);
+  const log2 = runtime.log;
+  const error = runtime.error;
+  const isGroup = ctx.chatType === "group";
+  const isThread = isGroup && Boolean(ctx.threadId);
+  const core = LarkClient.runtime;
+  const feishuFrom = `feishu:${ctx.senderId}`;
+  const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderId}`;
+  const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId;
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(accountScopedCfg);
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: accountScopedCfg,
+    channel: "feishu",
+    accountId: account.accountId,
+    peer: {
+      kind: isGroup ? "group" : "direct",
+      id: isGroup ? ctx.chatId : ctx.senderId
+    }
+  });
+  const sender = ctx.senderName ? `${ctx.senderName} (${ctx.senderId})` : ctx.senderId;
+  const location = isGroup ? `group ${ctx.chatId}` : "DM";
+  const tags = [];
+  tags.push(`msg:${ctx.messageId}`);
+  if (ctx.parentId) tags.push(`reply_to:${ctx.parentId}`);
+  if (ctx.contentType !== "text") tags.push(ctx.contentType);
+  if (ctx.mentions.some((m) => m.isBot)) tags.push("@bot");
+  if (ctx.threadId) tags.push(`thread:${ctx.threadId}`);
+  if (ctx.resources.length > 0) {
+    tags.push(`${ctx.resources.length} attachment(s)`);
+  }
+  const tagStr = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+  core.system.enqueueSystemEvent(`Feishu[${account.accountId}] ${location} | ${sender}${tagStr}`, {
+    sessionKey: route.sessionKey,
+    contextKey: `feishu:message:${ctx.chatId}:${ctx.messageId}`
+  });
+  return {
+    ctx,
+    accountScopedCfg,
+    account,
+    runtime,
+    log: log2,
+    error,
+    core,
+    isGroup,
+    isThread,
+    feishuFrom,
+    feishuTo,
+    envelopeFrom,
+    envelopeOptions,
+    route,
+    threadSessionKey: void 0,
+    commandAuthorized: params.commandAuthorized
+  };
+}
+async function resolveThreadSessionKey(params) {
+  const { accountScopedCfg, account, chatId, threadId, baseSessionKey } = params;
+  if (account.config?.threadSession !== true) return void 0;
+  const threadCapable = await isThreadCapableGroup({
+    cfg: accountScopedCfg,
+    chatId,
+    accountId: account.accountId
+  });
+  if (!threadCapable) {
+    log.info(`thread session skipped: group ${chatId} is not topic/thread mode`);
+    return void 0;
+  }
+  const { sessionKey } = resolveThreadSessionKeys({
+    baseSessionKey,
+    threadId,
+    parentSessionKey: baseSessionKey,
+    normalizeThreadId: (id) => id
+    // 飞书 thread ID (omt_xxx) 区分大小写，不做 lowercase
+  });
+  return sessionKey;
+}
+export {
+  buildDispatchContext,
+  ensureRuntime,
+  resolveThreadSessionKey
+};
+//# sourceMappingURL=dispatch-context.js.map

package/dist/src/messaging/inbound/dispatch-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/dispatch-context.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Dispatch context construction for the inbound agent dispatch pipeline.\n *\n * Derives all shared values needed by downstream dispatch helpers:\n * logging, addressing, route resolution, thread session, and system\n * event emission.\n */\n\nimport type { ClawdbotConfig, RuntimeEnv } from 'openclaw/plugin-sdk';\nimport { resolveThreadSessionKeys } from 'openclaw/plugin-sdk';\nimport type { MessageContext } from '../types';\nimport type { LarkAccount } from '../../core/types';\nimport { LarkClient } from '../../core/lark-client';\nimport { larkLogger } from '../../core/lark-logger';\nimport { isThreadCapableGroup } from '../../core/chat-info-cache';\n\nconst log = larkLogger('inbound/dispatch-context');\n\n// ---------------------------------------------------------------------------\n// DispatchContext type\n// ---------------------------------------------------------------------------\n\nexport interface DispatchContext {\n  ctx: MessageContext;\n  /** account \u7EA7\u522B\u7684 ClawdbotConfig\uFF08channels.feishu \u5DF2\u66FF\u6362\u4E3A per-account \u5408\u5E76\u540E\u7684\u914D\u7F6E\uFF09 */\n  accountScopedCfg: ClawdbotConfig;\n  account: LarkAccount;\n  runtime: RuntimeEnv;\n  log: (...args: unknown[]) => void;\n  error: (...args: unknown[]) => void;\n  core: typeof LarkClient.runtime;\n  isGroup: boolean;\n  isThread: boolean;\n  feishuFrom: string;\n  feishuTo: string;\n  envelopeFrom: string;\n  envelopeOptions: ReturnType<typeof LarkClient.runtime.channel.reply.resolveEnvelopeFormatOptions>;\n  route: ReturnType<typeof LarkClient.runtime.channel.routing.resolveAgentRoute>;\n  threadSessionKey?: string;\n  commandAuthorized?: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// RuntimeEnv fallback\n// ---------------------------------------------------------------------------\n\n/**\n * Provide a safe RuntimeEnv fallback when the caller did not supply one.\n * Replaces the previous unsafe `runtime as RuntimeEnv` casts.\n */\nexport function ensureRuntime(runtime: RuntimeEnv | undefined): RuntimeEnv {\n  if (runtime) return runtime;\n  return {\n    log: (...args: unknown[]) => log.info(args.map(String).join(' ')),\n    error: (...args: unknown[]) => log.error(args.map(String).join(' ')),\n    exit: (code: number) => process.exit(code) as never,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Context construction\n// ---------------------------------------------------------------------------\n\n/**\n * Derive all shared values needed by downstream helpers:\n * logging, addressing, route resolution, and system event emission.\n */\nexport function buildDispatchContext(params: {\n  ctx: MessageContext;\n  account: LarkAccount;\n  accountScopedCfg: ClawdbotConfig;\n  runtime?: RuntimeEnv;\n  commandAuthorized?: boolean;\n}): DispatchContext {\n  const { ctx, account, accountScopedCfg } = params;\n\n  const runtime = ensureRuntime(params.runtime);\n  const log = runtime.log;\n  const error = runtime.error;\n  const isGroup = ctx.chatType === 'group';\n  const isThread = isGroup && Boolean(ctx.threadId);\n  const core = LarkClient.runtime;\n\n  const feishuFrom = `feishu:${ctx.senderId}`;\n  const feishuTo = isGroup ? `chat:${ctx.chatId}` : `user:${ctx.senderId}`;\n\n  const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId;\n\n  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(accountScopedCfg);\n\n  // ---- Route resolution ----\n  const route = core.channel.routing.resolveAgentRoute({\n    cfg: accountScopedCfg,\n    channel: 'feishu',\n    accountId: account.accountId,\n    peer: {\n      kind: isGroup ? 'group' : 'direct',\n      id: isGroup ? ctx.chatId : ctx.senderId,\n    },\n  });\n\n  // ---- System event ----\n  const sender = ctx.senderName ? `${ctx.senderName} (${ctx.senderId})` : ctx.senderId;\n  const location = isGroup ? `group ${ctx.chatId}` : 'DM';\n\n  const tags: string[] = [];\n  tags.push(`msg:${ctx.messageId}`);\n  if (ctx.parentId) tags.push(`reply_to:${ctx.parentId}`);\n  if (ctx.contentType !== 'text') tags.push(ctx.contentType);\n  if (ctx.mentions.some((m) => m.isBot)) tags.push('@bot');\n  if (ctx.threadId) tags.push(`thread:${ctx.threadId}`);\n  if (ctx.resources.length > 0) {\n    tags.push(`${ctx.resources.length} attachment(s)`);\n  }\n  const tagStr = tags.length > 0 ? ` [${tags.join(', ')}]` : '';\n\n  core.system.enqueueSystemEvent(`Feishu[${account.accountId}] ${location} | ${sender}${tagStr}`, {\n    sessionKey: route.sessionKey,\n    contextKey: `feishu:message:${ctx.chatId}:${ctx.messageId}`,\n  });\n\n  return {\n    ctx,\n    accountScopedCfg,\n    account,\n    runtime,\n    log,\n    error,\n    core,\n    isGroup,\n    isThread,\n    feishuFrom,\n    feishuTo,\n    envelopeFrom,\n    envelopeOptions,\n    route,\n    threadSessionKey: undefined,\n    commandAuthorized: params.commandAuthorized,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Thread session resolution\n// ---------------------------------------------------------------------------\n\n/**\n * Resolve thread session key for thread-capable groups.\n *\n * Returns a thread-scoped session key when ALL conditions are met:\n *   1. `threadSession` config is enabled on the account\n *   2. The group is a topic group (chat_mode=topic) or uses thread\n *      message mode (group_message_type=thread)\n *\n * The group info is fetched via `im.chat.get` with a 1-hour LRU cache\n * to minimise OAPI calls.\n */\nexport async function resolveThreadSessionKey(params: {\n  accountScopedCfg: ClawdbotConfig;\n  account: LarkAccount;\n  chatId: string;\n  threadId: string;\n  baseSessionKey: string;\n}): Promise<string | undefined> {\n  const { accountScopedCfg, account, chatId, threadId, baseSessionKey } = params;\n\n  if (account.config?.threadSession !== true) return undefined;\n\n  const threadCapable = await isThreadCapableGroup({\n    cfg: accountScopedCfg,\n    chatId,\n    accountId: account.accountId,\n  });\n  if (!threadCapable) {\n    log.info(`thread session skipped: group ${chatId} is not topic/thread mode`);\n    return undefined;\n  }\n\n  // \u4F7F\u7528 SDK \u6807\u51C6\u51FD\u6570\uFF0C\u4FDD\u8BC1\u5206\u9694\u7B26\u683C\u5F0F\u4E0E resolveThreadParentSessionKey \u517C\u5BB9\n  const { sessionKey } = resolveThreadSessionKeys({\n    baseSessionKey,\n    threadId,\n    parentSessionKey: baseSessionKey,\n    normalizeThreadId: (id) => id, // \u98DE\u4E66 thread ID (omt_xxx) \u533A\u5206\u5927\u5C0F\u5199\uFF0C\u4E0D\u505A lowercase\n  });\n  return sessionKey;\n}\n"],
+  "mappings": "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",
+  "names": ["log"]
+}

package/dist/src/messaging/inbound/dispatch.js

@@ -0,0 +1,150 @@
+import { clearHistoryEntriesIfEnabled } from "openclaw/plugin-sdk";
+import { larkLogger } from "../../core/lark-logger";
+import { ticketElapsed } from "../../core/lark-ticket";
+import { createFeishuReplyDispatcher } from "../../card/reply-dispatcher";
+import { mentionedBot } from "./mention";
+import {
+  buildQueueKey,
+  threadScopedKey,
+  registerActiveDispatcher,
+  unregisterActiveDispatcher
+} from "../../channel/chat-queue";
+import { isLikelyAbortText } from "../../channel/abort-detect";
+import { buildDispatchContext, resolveThreadSessionKey } from "./dispatch-context";
+import {
+  buildMessageBody,
+  buildBodyForAgent,
+  buildInboundPayload,
+  buildEnvelopeWithHistory
+} from "./dispatch-builders";
+import { dispatchPermissionNotification, dispatchSystemCommand } from "./dispatch-commands";
+const log = larkLogger("inbound/dispatch");
+async function dispatchNormalMessage(dc, ctxPayload, chatHistories, historyKey, historyLimit, replyToMessageId, skillFilter, skipTyping) {
+  if (isLikelyAbortText(dc.ctx.content?.trim() ?? "")) {
+    dc.log(`feishu[${dc.account.accountId}]: abort message detected, using plain-text dispatch`);
+    log.info("abort message detected, using plain-text dispatch");
+    await dispatchSystemCommand(dc, ctxPayload, false, replyToMessageId);
+    return;
+  }
+  const { dispatcher, replyOptions, markDispatchIdle, markFullyComplete, abortCard } = createFeishuReplyDispatcher({
+    cfg: dc.accountScopedCfg,
+    agentId: dc.route.agentId,
+    chatId: dc.ctx.chatId,
+    replyToMessageId: replyToMessageId ?? dc.ctx.messageId,
+    accountId: dc.account.accountId,
+    chatType: dc.ctx.chatType,
+    skipTyping,
+    replyInThread: dc.isThread
+  });
+  const abortController = new AbortController();
+  const queueKey = buildQueueKey(dc.account.accountId, dc.ctx.chatId, dc.ctx.threadId);
+  registerActiveDispatcher(queueKey, { abortCard, abortController });
+  const effectiveSessionKey = dc.threadSessionKey ?? dc.route.sessionKey;
+  dc.log(`feishu[${dc.account.accountId}]: dispatching to agent (session=${effectiveSessionKey})`);
+  log.info(`dispatching to agent (session=${effectiveSessionKey})`);
+  try {
+    const { queuedFinal, counts } = await dc.core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg: dc.accountScopedCfg,
+      dispatcher,
+      replyOptions: {
+        ...replyOptions,
+        abortSignal: abortController.signal,
+        ...skillFilter ? { skillFilter } : {}
+      }
+    });
+    await dispatcher.waitForIdle();
+    markFullyComplete();
+    markDispatchIdle();
+    if (dc.isGroup && historyKey && chatHistories) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: chatHistories,
+        historyKey,
+        limit: historyLimit
+      });
+    }
+    dc.log(`feishu[${dc.account.accountId}]: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
+    log.info(`dispatch complete (replies=${counts.final}, elapsed=${ticketElapsed()}ms)`);
+  } finally {
+    unregisterActiveDispatcher(queueKey);
+  }
+}
+async function dispatchToAgent(params) {
+  const dc = buildDispatchContext(params);
+  if (dc.isThread && dc.ctx.threadId) {
+    dc.threadSessionKey = await resolveThreadSessionKey({
+      accountScopedCfg: dc.accountScopedCfg,
+      account: dc.account,
+      chatId: dc.ctx.chatId,
+      threadId: dc.ctx.threadId,
+      baseSessionKey: dc.route.sessionKey
+    });
+  }
+  const messageBody = buildMessageBody(params.ctx, params.quotedContent);
+  if (params.permissionError) {
+    try {
+      await dispatchPermissionNotification(dc, params.permissionError, params.replyToMessageId);
+    } catch (err) {
+      dc.error(`feishu[${dc.account.accountId}]: permission notification failed, continuing: ${String(err)}`);
+    }
+  }
+  const { combinedBody, historyKey } = buildEnvelopeWithHistory(
+    dc,
+    messageBody,
+    params.chatHistories,
+    params.historyLimit
+  );
+  const bodyForAgent = buildBodyForAgent(params.ctx);
+  const threadHistoryKey = threadScopedKey(dc.ctx.chatId, dc.isThread ? dc.ctx.threadId : void 0);
+  const inboundHistory = dc.isGroup && params.chatHistories && params.historyLimit > 0 ? (params.chatHistories.get(threadHistoryKey) ?? []).map((entry) => ({
+    sender: entry.sender,
+    body: entry.body,
+    timestamp: entry.timestamp ?? Date.now()
+  })) : void 0;
+  const isBareNewOrReset = /^\/(?:new|reset)\s*$/i.test((params.ctx.content ?? "").trim());
+  const groupSystemPrompt = dc.isGroup ? params.groupConfig?.systemPrompt?.trim() || params.defaultGroupConfig?.systemPrompt?.trim() || void 0 : void 0;
+  const ctxPayload = buildInboundPayload(dc, {
+    body: combinedBody,
+    bodyForAgent,
+    rawBody: params.ctx.content,
+    commandBody: params.ctx.content,
+    senderName: params.ctx.senderName ?? params.ctx.senderId,
+    senderId: params.ctx.senderId,
+    messageSid: params.ctx.messageId,
+    wasMentioned: mentionedBot(params.ctx),
+    replyToBody: params.quotedContent,
+    inboundHistory,
+    extraFields: {
+      ...params.mediaPayload,
+      ...groupSystemPrompt ? { GroupSystemPrompt: groupSystemPrompt } : {},
+      ...dc.ctx.threadId ? { MessageThreadId: dc.ctx.threadId } : {}
+    }
+  });
+  const isCommand = dc.core.channel.commands.isControlCommandMessage(params.ctx.content, params.accountScopedCfg);
+  const skillFilter = dc.isGroup ? params.groupConfig?.skills ?? params.defaultGroupConfig?.skills : void 0;
+  if (isCommand) {
+    await dispatchSystemCommand(dc, ctxPayload, isBareNewOrReset, params.replyToMessageId);
+    if (isBareNewOrReset && dc.isGroup && historyKey && params.chatHistories) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: params.chatHistories,
+        historyKey,
+        limit: params.historyLimit
+      });
+    }
+  } else {
+    await dispatchNormalMessage(
+      dc,
+      ctxPayload,
+      params.chatHistories,
+      historyKey,
+      params.historyLimit,
+      params.replyToMessageId,
+      skillFilter,
+      params.skipTyping
+    );
+  }
+}
+export {
+  dispatchToAgent
+};
+//# sourceMappingURL=dispatch.js.map

package/dist/src/messaging/inbound/dispatch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/messaging/inbound/dispatch.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates\n * SPDX-License-Identifier: MIT\n *\n * Agent dispatch for inbound Feishu messages.\n *\n * Builds the agent envelope, prepends chat history context, and\n * dispatches through the appropriate reply path (system command\n * vs. normal streaming/static flow).\n *\n * Implementation details are split across focused modules:\n * - dispatch-context.ts  \u2014 DispatchContext type, route/session/event\n * - dispatch-builders.ts \u2014 pure payload/body/envelope construction\n * - dispatch-commands.ts \u2014 system command & permission notification\n */\n\nimport type { RuntimeEnv, HistoryEntry } from 'openclaw/plugin-sdk';\nimport { clearHistoryEntriesIfEnabled } from 'openclaw/plugin-sdk';\nimport type { MessageContext } from '../types';\nimport type { LarkAccount } from '../../core/types';\nimport type { FeishuGroupConfig } from '../../core/types';\nimport type { PermissionError } from './permission';\nimport { larkLogger } from '../../core/lark-logger';\nimport { ticketElapsed } from '../../core/lark-ticket';\nimport { createFeishuReplyDispatcher } from '../../card/reply-dispatcher';\nimport { mentionedBot } from './mention';\nimport {\n  buildQueueKey,\n  threadScopedKey,\n  registerActiveDispatcher,\n  unregisterActiveDispatcher,\n} from '../../channel/chat-queue';\nimport { isLikelyAbortText } from '../../channel/abort-detect';\nimport { type DispatchContext, buildDispatchContext, resolveThreadSessionKey } from './dispatch-context';\nimport {\n  buildMessageBody,\n  buildBodyForAgent,\n  buildInboundPayload,\n  buildEnvelopeWithHistory,\n} from './dispatch-builders';\nimport { dispatchPermissionNotification, dispatchSystemCommand } from './dispatch-commands';\nimport type { ClawdbotConfig } from 'openclaw/plugin-sdk';\nimport { LarkClient } from '../../core/lark-client';\n\nconst log = larkLogger('inbound/dispatch');\n\n// ---------------------------------------------------------------------------\n// Internal: normal message dispatch\n// ---------------------------------------------------------------------------\n\n/**\n * Dispatch a normal (non-command) message via the streaming card flow.\n * Cleans up consumed history entries after dispatch completes.\n *\n * Note: history cleanup is intentionally placed here and NOT in the\n * system-command path \u2014 command handlers don't consume history context,\n * so the entries should be preserved for the next normal message.\n */\nasync function dispatchNormalMessage(\n  dc: DispatchContext,\n  ctxPayload: ReturnType<typeof LarkClient.runtime.channel.reply.finalizeInboundContext>,\n  chatHistories: Map<string, HistoryEntry[]> | undefined,\n  historyKey: string | undefined,\n  historyLimit: number,\n  replyToMessageId?: string,\n  skillFilter?: string[],\n  skipTyping?: boolean,\n): Promise<void> {\n  // Abort messages should never create streaming cards \u2014 dispatch via the\n  // plain-text system-command path so the SDK's abort handler can reply\n  // without touching CardKit.\n  if (isLikelyAbortText(dc.ctx.content?.trim() ?? '')) {\n    dc.log(`feishu[${dc.account.accountId}]: abort message detected, using plain-text dispatch`);\n    log.info('abort message detected, using plain-text dispatch');\n    await dispatchSystemCommand(dc, ctxPayload, false, replyToMessageId);\n    return;\n  }\n\n  const { dispatcher, replyOptions, markDispatchIdle, markFullyComplete, abortCard } = createFeishuReplyDispatcher({\n    cfg: dc.accountScopedCfg,\n    agentId: dc.route.agentId,\n    chatId: dc.ctx.chatId,\n    replyToMessageId: replyToMessageId ?? dc.ctx.messageId,\n    accountId: dc.account.accountId,\n    chatType: dc.ctx.chatType,\n    skipTyping,\n    replyInThread: dc.isThread,\n  });\n\n  // Create an AbortController so the abort fast-path can cancel the\n  // underlying LLM request (not just the streaming card UI).\n  const abortController = new AbortController();\n\n  // Register the active dispatcher so the monitor abort fast-path can\n  // terminate the streaming card before this task completes.\n  const queueKey = buildQueueKey(dc.account.accountId, dc.ctx.chatId, dc.ctx.threadId);\n  registerActiveDispatcher(queueKey, { abortCard, abortController });\n\n  const effectiveSessionKey = dc.threadSessionKey ?? dc.route.sessionKey;\n  dc.log(`feishu[${dc.account.accountId}]: dispatching to agent (session=${effectiveSessionKey})`);\n  log.info(`dispatching to agent (session=${effectiveSessionKey})`);\n\n  try {\n    const { queuedFinal, counts } = await dc.core.channel.reply.dispatchReplyFromConfig({\n      ctx: ctxPayload,\n      cfg: dc.accountScopedCfg,\n      dispatcher,\n      replyOptions: {\n        ...replyOptions,\n        abortSignal: abortController.signal,\n        ...(skillFilter ? { skillFilter } : {}),\n      },\n    });\n\n    // Wait for all enqueued deliver() calls in the SDK's sendChain to\n    // complete before marking the dispatch as done.  Without this,\n    // dispatchReplyFromConfig() may return while the final deliver() is\n    // still pending in the Promise chain, causing markFullyComplete() to\n    // block it and leaving completedText incomplete \u2014 which in turn makes\n    // the streaming card's final update show truncated content.\n    await dispatcher.waitForIdle();\n\n    markFullyComplete();\n    markDispatchIdle();\n\n    // Clean up consumed history entries\n    if (dc.isGroup && historyKey && chatHistories) {\n      clearHistoryEntriesIfEnabled({\n        historyMap: chatHistories,\n        historyKey,\n        limit: historyLimit,\n      });\n    }\n\n    dc.log(`feishu[${dc.account.accountId}]: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);\n    log.info(`dispatch complete (replies=${counts.final}, elapsed=${ticketElapsed()}ms)`);\n  } finally {\n    unregisterActiveDispatcher(queueKey);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\nexport async function dispatchToAgent(params: {\n  ctx: MessageContext;\n  permissionError?: PermissionError;\n  mediaPayload: Record<string, unknown>;\n  quotedContent?: string;\n  account: LarkAccount;\n  /** account \u7EA7\u522B\u7684 ClawdbotConfig\uFF08channels.feishu \u5DF2\u66FF\u6362\u4E3A per-account \u5408\u5E76\u540E\u7684\u914D\u7F6E\uFF09 */\n  accountScopedCfg: ClawdbotConfig;\n  runtime?: RuntimeEnv;\n  chatHistories?: Map<string, HistoryEntry[]>;\n  historyLimit: number;\n  /** Override the message ID used for reply threading.  When set, the\n   *  reply-dispatcher uses this ID for typing indicators and card replies\n   *  instead of ctx.messageId (which may be a synthetic ID). */\n  replyToMessageId?: string;\n  /** When set, controls whether the sender is authorized to execute\n   *  control commands.  Computed by the handler via the SDK's access\n   *  group command gating system. */\n  commandAuthorized?: boolean;\n  /** Per-group configuration for skills, systemPrompt, etc. */\n  groupConfig?: FeishuGroupConfig;\n  /** Default group configuration from the \"*\" wildcard entry. */\n  defaultGroupConfig?: FeishuGroupConfig;\n  /** When true, the reply dispatcher skips typing indicators. */\n  skipTyping?: boolean;\n}): Promise<void> {\n  // 1. Derive shared context (including route resolution + system event)\n  const dc = buildDispatchContext(params);\n\n  // 1b. Resolve thread session isolation (async: may query group info API)\n  if (dc.isThread && dc.ctx.threadId) {\n    dc.threadSessionKey = await resolveThreadSessionKey({\n      accountScopedCfg: dc.accountScopedCfg,\n      account: dc.account,\n      chatId: dc.ctx.chatId,\n      threadId: dc.ctx.threadId,\n      baseSessionKey: dc.route.sessionKey,\n    });\n  }\n\n  // 2. Build annotated message body\n  const messageBody = buildMessageBody(params.ctx, params.quotedContent);\n\n  // 3. Permission-error notification (optional side-effect).\n  //    Isolated so a failure here does not block the main message dispatch.\n  if (params.permissionError) {\n    try {\n      await dispatchPermissionNotification(dc, params.permissionError, params.replyToMessageId);\n    } catch (err) {\n      dc.error(`feishu[${dc.account.accountId}]: permission notification failed, continuing: ${String(err)}`);\n    }\n  }\n\n  // 4. Build main envelope (with group chat history)\n  const { combinedBody, historyKey } = buildEnvelopeWithHistory(\n    dc,\n    messageBody,\n    params.chatHistories,\n    params.historyLimit,\n  );\n\n  // 5. Build BodyForAgent with mention annotation (if any).\n  //    SDK >= 2026.2.10 no longer falls back to Body for BodyForAgent,\n  //    so we must set it explicitly to preserve the annotation.\n  const bodyForAgent = buildBodyForAgent(params.ctx);\n\n  // 6. Build InboundHistory for SDK metadata injection (>= 2026.2.10).\n  //    The SDK's buildInboundUserContextPrefix renders these as structured\n  //    JSON blocks; earlier SDK versions simply ignore unknown fields.\n  const threadHistoryKey = threadScopedKey(dc.ctx.chatId, dc.isThread ? dc.ctx.threadId : undefined);\n  const inboundHistory =\n    dc.isGroup && params.chatHistories && params.historyLimit > 0\n      ? (params.chatHistories.get(threadHistoryKey) ?? []).map((entry) => ({\n          sender: entry.sender,\n          body: entry.body,\n          timestamp: entry.timestamp ?? Date.now(),\n        }))\n      : undefined;\n\n  // 7. Build inbound context payload\n  const isBareNewOrReset = /^\\/(?:new|reset)\\s*$/i.test((params.ctx.content ?? '').trim());\n  const groupSystemPrompt = dc.isGroup\n    ? params.groupConfig?.systemPrompt?.trim() || params.defaultGroupConfig?.systemPrompt?.trim() || undefined\n    : undefined;\n  const ctxPayload = buildInboundPayload(dc, {\n    body: combinedBody,\n    bodyForAgent,\n    rawBody: params.ctx.content,\n    commandBody: params.ctx.content,\n    senderName: params.ctx.senderName ?? params.ctx.senderId,\n    senderId: params.ctx.senderId,\n    messageSid: params.ctx.messageId,\n    wasMentioned: mentionedBot(params.ctx),\n    replyToBody: params.quotedContent,\n    inboundHistory,\n    extraFields: {\n      ...params.mediaPayload,\n      ...(groupSystemPrompt ? { GroupSystemPrompt: groupSystemPrompt } : {}),\n      ...(dc.ctx.threadId ? { MessageThreadId: dc.ctx.threadId } : {}),\n    },\n  });\n\n  // 8. Dispatch: system command vs. normal message\n  const isCommand = dc.core.channel.commands.isControlCommandMessage(params.ctx.content, params.accountScopedCfg);\n\n  // Resolve per-group skill filter (per-group > default \"*\")\n  const skillFilter = dc.isGroup ? (params.groupConfig?.skills ?? params.defaultGroupConfig?.skills) : undefined;\n\n  if (isCommand) {\n    await dispatchSystemCommand(dc, ctxPayload, isBareNewOrReset, params.replyToMessageId);\n    // /new and /reset explicitly start a new session \u2014 clear pending history\n    if (isBareNewOrReset && dc.isGroup && historyKey && params.chatHistories) {\n      clearHistoryEntriesIfEnabled({\n        historyMap: params.chatHistories,\n        historyKey,\n        limit: params.historyLimit,\n      });\n    }\n  } else {\n    // Normal message dispatch; history cleanup happens inside.\n    // System commands intentionally skip history cleanup \u2014 command handlers\n    // don't consume history context, so entries are preserved for the next\n    // normal message.\n    await dispatchNormalMessage(\n      dc,\n      ctxPayload,\n      params.chatHistories,\n      historyKey,\n      params.historyLimit,\n      params.replyToMessageId,\n      skillFilter,\n      params.skipTyping,\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}