@meet-im/meet 1.0.3

package/skills/meet-markdown/references/quick-reference.md

@@ -0,0 +1,86 @@
+# Meet Markdown 语法快速参考
+
+## 内联样式
+
+| 语法 | 效果 | 示例 |
+|------|------|------|
+| `**text**` | 粗体 | **粗体** |
+| `__text__` | 粗体 | __粗体__ |
+| `_text_` | 斜体 | _斜体_ |
+| `~~text~~` | 删除线 | ~~删除线~~ |
+| `` `code` `` | 行内代码 | `code` |
+| `!!#RRGGBB text!!` | 颜色文本 | 彩色文本 |
+
+## 块级元素
+
+### 标题
+
+```markdown
+# H1
+## H2
+### H3
+#### H4
+##### H5
+###### H6
+```
+
+### 代码块
+
+````markdown
+```language
+代码内容
+```
+````
+
+常用语言：javascript, typescript, python, json, bash, markdown
+
+### 引用
+
+```markdown
+> 引用内容
+> 可以多行
+```
+
+### 列表
+
+```markdown
+- 无序列表
+- 项目
+
+1. 有序列表
+2. 项目
+```
+
+### 表格
+
+```markdown
+| 列1 | 列2 |
+|-----|-----|
+| 值1 | 值2 |
+```
+
+### 分割线
+
+```markdown
+---
+```
+
+## 链接与图片
+
+```markdown
+[链接文本](URL)
+![图片替代文本](图片URL)
+```
+
+## 颜色代码参考
+
+常用颜色：
+
+| 颜色 | 代码 | 示例 |
+|------|------|------|
+| 红色 | `#FF0000` | `!!#FF0000 红色!!` |
+| 绿色 | `#00FF00` | `!!#00FF00 绿色!!` |
+| 蓝色 | `#0000FF` | `!!#0000FF 蓝色!!` |
+| 橙色 | `#FF6600` | `!!#FF6600 橙色!!` |
+| 紫色 | `#9900FF` | `!!#9900FF 紫色!!` |
+| 灰色 | `#666666` | `!!#666666 灰色!!` |

package/src/accounts.ts

@@ -0,0 +1,182 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  createAccountListHelpers,
+  type ClawdbotConfig,
+} from "openclaw/plugin-sdk"
+import type { MeetConfig, MeetAccountConfig, ResolvedMeetAccount } from "./types.js"
+
+const { listAccountIds: listNestedAccountIds, resolveDefaultAccountId: resolveNestedDefaultAccountId } = createAccountListHelpers("meet")
+
+const MEET_PREFIX = "meet."
+
+export function getFlatAccountKey(accountId: string): string {
+  return `${MEET_PREFIX}${accountId}`
+}
+
+function listFlatAccountIds(cfg: ClawdbotConfig): string[] {
+  const channels = cfg.channels
+  if (!channels || typeof channels !== "object") {
+    return []
+  }
+  const ids: string[] = []
+  for (const key of Object.keys(channels)) {
+    if (key.startsWith(MEET_PREFIX)) {
+      const accountId = key.slice(MEET_PREFIX.length)
+      if (accountId) {
+        ids.push(accountId)
+      }
+    }
+  }
+  return ids
+}
+
+function resolveFlatAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): MeetAccountConfig | undefined {
+  const key = `${MEET_PREFIX}${accountId}`
+  const config = cfg.channels?.[key]
+  if (!config || typeof config !== "object") {
+    return undefined
+  }
+  return config as MeetAccountConfig
+}
+
+function listMeetAccountIds(cfg: ClawdbotConfig): string[] {
+  const nestedIds = listNestedAccountIds(cfg)
+  const flatIds = listFlatAccountIds(cfg)
+  
+  if (flatIds.length > 0) {
+    const filteredNestedIds = nestedIds.filter(id => id !== DEFAULT_ACCOUNT_ID)
+    const allIds = new Set([...filteredNestedIds, ...flatIds])
+    return [...allIds].sort((a, b) => a.localeCompare(b))
+  }
+  
+  if (nestedIds.length === 0) {
+    return [DEFAULT_ACCOUNT_ID]
+  }
+  return nestedIds
+}
+
+function resolveDefaultMeetAccountId(cfg: ClawdbotConfig): string {
+  const flatIds = listFlatAccountIds(cfg)
+  if (flatIds.length > 0) {
+    const nestedDefault = resolveNestedDefaultAccountId(cfg)
+    if (nestedDefault !== DEFAULT_ACCOUNT_ID && flatIds.includes(nestedDefault)) {
+      return nestedDefault
+    }
+    return flatIds[0] ?? DEFAULT_ACCOUNT_ID
+  }
+  return resolveNestedDefaultAccountId(cfg)
+}
+
+export { listMeetAccountIds, resolveDefaultMeetAccountId }
+
+export function isFlatAccountConfig(cfg: ClawdbotConfig, accountId: string): boolean {
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return false
+  }
+  return resolveFlatAccountConfig(cfg, accountId) !== undefined
+}
+
+function resolveAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): MeetAccountConfig | undefined {
+  const nestedConfig = (() => {
+    const accounts = (cfg.channels?.meet as MeetConfig | undefined)?.accounts
+    if (!accounts || typeof accounts !== "object") {
+      return undefined
+    }
+    return accounts[accountId] as MeetAccountConfig | undefined
+  })()
+  if (nestedConfig) {
+    return nestedConfig
+  }
+  return resolveFlatAccountConfig(cfg, accountId)
+}
+
+function mergeMeetAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): MeetConfig {
+  const meetCfg = cfg.channels?.meet as MeetConfig | undefined
+  const { accounts: _ignored, ...base } = meetCfg ?? {}
+  const account = resolveAccountConfig(cfg, accountId) ?? {}
+  
+  const baseGroups = base.groups ?? {}
+  const accountGroups = (account as MeetConfig).groups ?? {}
+  const mergedGroups = { ...baseGroups, ...accountGroups }
+  
+  return { 
+    ...base, 
+    ...account, 
+    groups: Object.keys(mergedGroups).length > 0 ? mergedGroups : undefined,
+  } as MeetConfig
+}
+
+function resolveMeetToken(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): {
+  token: string
+  endpoint: string
+  source: "env" | "config" | "none"
+} {
+  const merged = mergeMeetAccountConfig(cfg, accountId)
+
+  const configToken = merged.token || merged.apiToken
+  if (configToken) {
+    return {
+      token: configToken,
+      endpoint: merged.apiEndpoint ?? process.env.MEET_API_ENDPOINT ?? "https://staging-meet-api.miyachat.com",
+      source: "config",
+    }
+  }
+
+  const envToken = process.env.MEET_API_TOKEN
+  if (envToken) {
+    return {
+      token: envToken,
+      endpoint: merged.apiEndpoint ?? process.env.MEET_API_ENDPOINT ?? "https://staging-meet-api.miyachat.com",
+      source: "env",
+    }
+  }
+
+  return {
+    token: "",
+    endpoint: "",
+    source: "none",
+  }
+}
+
+export function resolveMeetAccount(params: {
+  cfg: ClawdbotConfig
+  accountId?: string | null
+}): ResolvedMeetAccount {
+  const accountId = normalizeAccountId(params.accountId)
+  const baseEnabled = params.cfg.channels?.meet?.enabled !== false
+  const merged = mergeMeetAccountConfig(params.cfg, accountId)
+  const accountEnabled = merged.enabled !== false
+  const enabled = baseEnabled && accountEnabled
+  const tokenResolution = resolveMeetToken(params.cfg, accountId)
+
+  return {
+    accountId,
+    enabled,
+    configured: tokenResolution.source !== "none",
+    name: (merged as MeetAccountConfig).name?.trim() || undefined,
+    apiEndpoint: tokenResolution.endpoint,
+    apiToken: tokenResolution.token,
+    config: merged,
+  }
+}
+
+export function listEnabledMeetAccounts(
+  cfg: ClawdbotConfig,
+): ResolvedMeetAccount[] {
+  return listMeetAccountIds(cfg)
+    .map((accountId) => resolveMeetAccount({ cfg, accountId }))
+    .filter((account) => account.enabled && account.configured)
+}

package/src/bot.ts

@@ -0,0 +1,414 @@
+import type { ClawdbotConfig, RuntimeEnv, ReplyPayload, HistoryEntry } from "openclaw/plugin-sdk"
+import {
+  buildPendingHistoryContextFromMap,
+  clearHistoryEntriesIfEnabled,
+  recordPendingHistoryEntryIfEnabled,
+  DEFAULT_ACCOUNT_ID,
+} from "openclaw/plugin-sdk"
+import type { MeetBot, MsgContent } from "@meet-im/meet-bot-jssdk"
+import type { ResolvedMeetAccount, MeetMessageContext } from "./types.js"
+import { msgContentToContext, extractQuoteMessageMedia } from "./sdk-bridge.js"
+import { getMeetRuntime } from "./runtime.js"
+import { resolveMeetAllowlistMatch, resolveMeetGroupPolicy, resolveMeetGroupConfig, resolveMeetGroupUserPolicy } from "./policy.js"
+import { sendMessageMeet } from "./send.js"
+import { resolveMediaAttachments, setMediaDebugLogger } from "./media.js"
+
+const DEFAULT_GROUP_SYSTEM_PROMPT =
+  "你正在 Meet 群组中对话。请保持回复简洁明了，适合群聊场景。如需回复特定用户，请使用 <@USER_ID> 格式提及对方，例如 <@553>。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。"
+
+const DEFAULT_DM_SYSTEM_PROMPT =
+  "你正在 Meet 私聊中对话。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。"
+
+function formatHistoryEntry(entry: HistoryEntry): string {
+  return `${entry.sender}: ${entry.body}`
+}
+
+export async function handleMeetMessage(params: {
+  cfg: ClawdbotConfig
+  msg: MsgContent
+  botUserId: string
+  runtime?: RuntimeEnv
+  accountId: string
+  account: ResolvedMeetAccount
+  bot: MeetBot
+  groupHistories: Map<string, HistoryEntry[]>
+  quoteMsgMap?: Record<string, MsgContent>
+}): Promise<void> {
+  const { cfg, msg, botUserId, runtime, accountId, account, bot, groupHistories, quoteMsgMap } = params
+  const log = runtime?.log ?? console.log
+  const error = runtime?.error ?? console.error
+
+  let ctx: MeetMessageContext
+  try {
+    ctx = msgContentToContext(msg, botUserId, quoteMsgMap)
+  } catch (err) {
+    error(`[${accountId}]: failed to parse message: ${String(err)}`)
+    return
+  }
+
+  const isGroup = ctx.chatType === "channel"
+
+  if (ctx.senderId === botUserId) {
+    log(`[${accountId}]: skipping own message ${ctx.messageId}`)
+    return
+  }
+
+  log(
+    `[${accountId}]: received message from ${ctx.senderId} in ${ctx.chatId} (${ctx.chatType})`,
+  )
+
+  const meetCfg = account.config
+  const dmPolicy = meetCfg.dmPolicy ?? "pairing"
+  const allowFrom = meetCfg.allowFrom ?? []
+  const historyLimit = isGroup
+    ? Math.max(0, meetCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20)
+    : Math.max(0, meetCfg.dmHistoryLimit ?? 0)
+  const speaker = ctx.senderName ?? ctx.senderId
+  // Discord 做法：文字优先，无文字时用媒体占位符
+  const messageBody = ctx.content.trim()
+    ? `${speaker}: ${ctx.content.trim()}`
+    : `${speaker}: ${ctx.placeholder || ""}`
+
+  const pendingEntry: HistoryEntry = {
+    sender: speaker,
+    body: ctx.content.trim() || ctx.placeholder || "",
+    timestamp: ctx.timestamp,
+    messageId: ctx.messageId,
+  }
+
+    try {
+    const core = getMeetRuntime()
+
+    if (!isGroup) {
+      // pairing 模式：需要从 pairing store 读取已授权用户列表
+      // allowlist 模式：只使用配置中的 allowFrom
+      let effectiveAllowFrom = allowFrom
+      if (dmPolicy === "pairing") {
+        try {
+          const storeAllowFrom = await core.channel.pairing.readAllowFromStore({
+            channel: "meet",
+            accountId,
+          })
+          // 合并配置中的 allowFrom 和 store 中的授权列表
+          effectiveAllowFrom = [...allowFrom, ...storeAllowFrom]
+        } catch (err) {
+          error(`[${accountId}]: failed to read pairing store: ${String(err)}`)
+        }
+      }
+
+      const dmAllowed = resolveMeetAllowlistMatch({
+        allowFrom: effectiveAllowFrom,
+        senderId: ctx.senderId,
+      }).allowed
+
+      // pairing 模式：创建配对请求并发送授权码给用户
+      // allowlist 模式：直接拒绝未授权用户
+      if (dmPolicy !== "open" && !dmAllowed) {
+        if (dmPolicy === "pairing") {
+          log(`[${accountId}]: pairing request from ${ctx.senderId}`)
+
+          // 创建或更新配对请求
+          const { code, created } = await core.channel.pairing.upsertPairingRequest({
+            channel: "meet",
+            id: ctx.senderId,
+            accountId,
+            meta: {
+              name: ctx.senderName,
+            },
+          })
+
+          // 发送配对码给用户（新创建或已存在都发送）
+          if (code) {
+            const accountArg = accountId === DEFAULT_ACCOUNT_ID ? "" : ` --account ${accountId}`
+            const lines = [
+              "OpenClaw: 尚未授权访问。",
+              "",
+              `您的 Meet 用户 ID: ${ctx.senderId}`,
+              "",
+              `配对码: ${code}`,
+              "",
+              "请联系机器人管理员审批：",
+              `openclaw pairing approve meet ${code}${accountArg}`,
+            ]
+            // 如果是已存在的请求，添加提示
+            if (!created) {
+              lines.splice(2, 0, "（您的配对请求已在等待审批中）")
+            }
+            const replyText = lines.join("\n")
+            try {
+              await sendMessageMeet({
+                cfg,
+                to: `user:${ctx.senderId}`,
+                text: replyText,
+                accountId,
+              })
+            } catch (err) {
+              error(`[${accountId}]: failed to send pairing reply to ${ctx.senderId}: ${String(err)}`)
+            }
+          }
+        } else {
+          log(
+            `[${accountId}]: blocked unauthorized sender ${ctx.senderId} (dmPolicy=${dmPolicy})`,
+          )
+        }
+        return
+      }
+    }
+
+    if (isGroup) {
+      const groupPolicy = resolveMeetGroupPolicy({
+        groupPolicy: meetCfg.groupPolicy,
+        groupAllowFrom: meetCfg.groupAllowFrom ?? [],
+        chatId: ctx.chatId,
+        groups: meetCfg.groups,
+      })
+
+      if (!groupPolicy.allowed) {
+        log(
+          `[${accountId}]: group ${ctx.chatId} not allowed (groupPolicy=${meetCfg.groupPolicy})`,
+        )
+        return
+      }
+
+      const groupConfig = resolveMeetGroupConfig({
+        meetConfig: meetCfg,
+        chatId: ctx.chatId,
+      })
+
+      const groupUserPolicy = resolveMeetGroupUserPolicy({
+        groupConfig: groupConfig.groupConfig,
+        senderId: ctx.senderId,
+      })
+
+      if (!groupUserPolicy.allowed) {
+        log(`[${accountId}]: user ${ctx.senderId} not allowed in group ${ctx.chatId}`)
+        return
+      }
+
+      if (groupConfig.requireMention && !ctx.mentionedBot) {
+        log(`[${accountId}]: message in group ${ctx.chatId} skipped (mention required)`)
+        recordPendingHistoryEntryIfEnabled({
+          historyMap: groupHistories,
+          historyKey: ctx.chatId,
+          entry: pendingEntry,
+          limit: historyLimit,
+        })
+        return
+      }
+    }
+
+    const meetFrom = `meet:${ctx.senderId}`
+    const meetTo = isGroup ? `channel:${ctx.chatId}` : `user:${ctx.senderId}`
+
+    const peerId = isGroup ? ctx.chatId : ctx.senderId
+
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "meet",
+      accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: peerId,
+      },
+    })
+
+    // 处理媒体附件
+    let mediaContext = ""
+    let mediaPaths: string[] = []
+    if (ctx.media && ctx.media.length > 0) {
+      log(`[${accountId}]: processing ${ctx.media.length} media attachment(s)`)
+      // 初始化媒体调试日志
+      setMediaDebugLogger(log, error)
+      try {
+        const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined
+        const mediaInfos = await resolveMediaAttachments({
+          accountId,
+          attachments: ctx.media,
+          sessionInfo: {
+            firstId: ctx.sessionInfo.firstID,
+            secondId: ctx.sessionInfo.secondID,
+            sessionType: ctx.sessionInfo.sessionType,
+            companyId: ctx.sessionInfo.companyID,
+          },
+          seqId: Number(ctx.messageId),
+          maxBytes,
+        })
+        log(`[${accountId}]: resolved ${mediaInfos.length} media, paths=${mediaInfos.map(m => m.path).join(",")}`)
+        mediaPaths = mediaInfos.map((m) => m.path)
+        if (mediaInfos.length > 0) {
+          // 为 BodyForAgent 生成详细媒体描述（包含路径）
+          mediaContext = "\n\n" + mediaInfos.map((m) => {
+            const typeLabel = m.contentType?.startsWith("image/") ? "<media:image>"
+              : m.contentType?.startsWith("video/") ? "<media:video>"
+              : m.contentType?.startsWith("audio/") ? "<media:audio>"
+              : "<media:document>"
+            return `${typeLabel}: ${m.path}`
+          }).join("\n")
+        }
+      } catch (err) {
+        error(`[${accountId}]: failed to resolve media: ${String(err)}`)
+      }
+    }
+
+    // 处理引用消息的媒体附件
+    if (quoteMsgMap && ctx.replyContext) {
+      const quoteMedia = extractQuoteMessageMedia(msg, quoteMsgMap)
+      if (quoteMedia && quoteMedia.length > 0) {
+        log(`[${accountId}]: processing ${quoteMedia.length} quote message media attachment(s)`)
+        try {
+          const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined
+          const quoteMediaInfos = await resolveMediaAttachments({
+            accountId,
+            attachments: quoteMedia,
+            sessionInfo: {
+              firstId: ctx.sessionInfo.firstID,
+              secondId: ctx.sessionInfo.secondID,
+              sessionType: ctx.sessionInfo.sessionType,
+              companyId: ctx.sessionInfo.companyID,
+            },
+            seqId: Number(ctx.replyContext.messageId),
+            maxBytes,
+          })
+          log(`[${accountId}]: resolved ${quoteMediaInfos.length} quote media, paths=${quoteMediaInfos.map(m => m.path).join(",")}`)
+          // 将引用消息的媒体路径合并到 mediaPaths
+          mediaPaths = [...mediaPaths, ...quoteMediaInfos.map((m) => m.path)]
+        } catch (err) {
+          error(`[${accountId}]: failed to resolve quote media: ${String(err)}`)
+        }
+      }
+    }
+
+    // 构建最终的消息内容
+    // Discord 做法：文字优先，无文字时用媒体占位符
+    // 媒体路径通过 MediaPaths 传递，mediaContext 仅作为 BodyForAgent 的补充描述
+    const finalContent = ctx.content.trim()
+      ? `${ctx.content.trim()}${mediaContext}`
+      : (ctx.placeholder || "") + mediaContext
+
+    // Discord 做法：跳过空内容消息
+    if (!finalContent.trim() && mediaPaths.length === 0) {
+      log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`)
+      return
+    }
+
+    const preview = finalContent.replace(/\s+/g, " ").slice(0, 160)
+    const inboundLabel = isGroup
+      ? `Meet[${accountId}] message in group ${ctx.chatId}`
+      : `Meet[${accountId}] DM from ${ctx.senderId}`
+
+    core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+      sessionKey: route.sessionKey,
+      contextKey: `meet:message:${ctx.chatId}:${ctx.messageId}`,
+    })
+
+    const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId
+
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg)
+
+    // 将当前消息添加到历史（在确认要处理消息之后）
+    const historyEntries = isGroup && historyLimit > 0
+      ? (() => {
+          const entries = groupHistories.get(ctx.chatId) ?? []
+          entries.push(pendingEntry)
+          while (entries.length > historyLimit) {
+            entries.shift()
+          }
+          groupHistories.set(ctx.chatId, entries)
+          return entries
+        })()
+      : []
+
+    const bodyWithContext = buildPendingHistoryContextFromMap({
+      historyMap: groupHistories,
+      historyKey: ctx.chatId,
+      limit: historyLimit,
+      currentMessage: messageBody,
+      formatEntry: formatHistoryEntry,
+    })
+
+    const body = core.channel.reply.formatAgentEnvelope({
+      channel: "Meet",
+      from: envelopeFrom,
+      timestamp: new Date(),
+      envelope: envelopeOptions,
+      body: bodyWithContext,
+    })
+
+    const inboundHistory =
+      isGroup && historyLimit > 0
+        ? historyEntries.map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+          }))
+        : undefined
+
+    const channelConfig = isGroup ? meetCfg.channels?.[ctx.chatId] : undefined
+    const groupConfig = isGroup ? resolveMeetGroupConfig({ meetConfig: meetCfg, chatId: ctx.chatId }) : undefined
+    const systemPrompt = isGroup
+      ? (groupConfig?.systemPrompt ?? channelConfig?.systemPrompt ?? meetCfg.systemPrompt ?? DEFAULT_GROUP_SYSTEM_PROMPT)
+      : (meetCfg.systemPrompt ?? DEFAULT_DM_SYSTEM_PROMPT)
+
+    const inboundCtx = core.channel.reply.finalizeInboundContext({
+      Body: body,
+      BodyForAgent: finalContent,
+      RawBody: ctx.content,
+      CommandBody: ctx.content,
+      From: meetFrom,
+      To: meetTo,
+      SessionKey: route.sessionKey,
+      AccountId: route.accountId,
+      ChatType: isGroup ? "group" : "direct",
+      GroupSubject: isGroup ? ctx.chatId : undefined,
+      GroupSystemPrompt: systemPrompt,
+      SenderName: ctx.senderName,
+      SenderId: ctx.senderId,
+      Provider: "meet" as const,
+      Surface: "meet" as const,
+      MessageSid: ctx.messageId,
+      Timestamp: ctx.timestamp ?? Date.now(),
+      WasMentioned: ctx.mentionedBot,
+      ReplyToId: ctx.replyContext?.messageId,
+      ReplyToBody: ctx.replyContext?.content,
+      ReplyToSender: ctx.replyContext?.senderId,
+      InboundHistory: inboundHistory,
+      CommandAuthorized: true,
+      OriginatingChannel: "meet" as const,
+      OriginatingTo: meetTo,
+      MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    })
+
+    const { createMeetReplyDispatcher } = await import("./reply-dispatcher.js")
+    const { dispatcher, replyOptions, markDispatchIdle } = await createMeetReplyDispatcher({
+      cfg,
+      agentId: route.agentId,
+      runtime: runtime as RuntimeEnv,
+      chatId: ctx.chatId,
+      replyToMessageId: ctx.messageId,
+      accountId,
+      bot,
+      botUserId,
+    })
+
+    log(`[${accountId}]: dispatching to AI agent=${route.agentId} session=${route.sessionKey} history=${inboundHistory?.length ?? 0}`)
+
+    await core.channel.reply.dispatchReplyFromConfig({
+      ctx: inboundCtx,
+      cfg,
+      dispatcher,
+      replyOptions,
+    })
+
+    log(`[${accountId}]: AI response completed for message ${ctx.messageId}`)
+
+    markDispatchIdle()
+
+    clearHistoryEntriesIfEnabled({
+      historyMap: groupHistories,
+      historyKey: ctx.chatId,
+      limit: historyLimit,
+    })
+  } catch (err) {
+    error(`[${accountId}]: error processing message: ${String(err)}`)
+  }
+}