@dcrays/dcgchat 0.3.35 → 0.4.4

package/index.ts

@@ -4,7 +4,7 @@ import { dcgchatPlugin } from './src/channel.js'
 import { setDcgchatRuntime, setWorkspaceDir } from './src/utils/global.js'
 import { monitoringToolMessage } from './src/tool.js'
 import { setOpenClawConfig } from './src/utils/global.js'
-import { startDcgchatGatewaySocket } from './src/gateway/socket.js'
+import { createDcgchatMessageTool } from './src/tools/messageTool.js'
 
 const plugin = {
   id: "dcgchat",
@@ -18,9 +18,8 @@ const plugin = {
     api.registerChannel({ plugin: dcgchatPlugin })
     setWorkspaceDir(api.config?.agents?.defaults?.workspace)
     api.registerTool((ctx) => {
-      const workspaceDir = ctx.workspaceDir
-      setWorkspaceDir(workspaceDir)
-      return null
+      setWorkspaceDir(ctx.workspaceDir)
+      return createDcgchatMessageTool(ctx)
     })
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.3.35",
+  "version": "0.4.4",
   "type": "module",
   "description": "OpenClaw channel plugin for 书灵墨宝 (WebSocket)",
   "main": "index.ts",

package/src/agent.ts

@@ -0,0 +1,125 @@
+import axios from 'axios'
+import fs from 'fs'
+import path from 'path'
+import { getWorkspaceDir } from './utils/global.js'
+import { getWsConnection } from './utils/global.js'
+import { dcgLogger } from './utils/log.js'
+import { isWsOpen } from './transport.js'
+import { sendMessageToGateway } from './gateway/socket.js'
+import { extractZipBufferToDirectory } from './utils/zipExtract.js'
+
+type IAgentParams = {
+  url: string
+  agent_code: string
+  agent_name: string
+  agent_description: string
+}
+
+function sendEvent(msgContent: Record<string, any>) {
+  const ws = getWsConnection()
+  if (isWsOpen()) {
+    ws?.send(
+      JSON.stringify({
+        messageType: 'openclaw_bot_event',
+        source: 'client',
+        content: msgContent
+      })
+    )
+    dcgLogger(`agent安装: ${JSON.stringify(msgContent)}`)
+  }
+}
+
+/** 若 workspace-${clone_code}/agent 存在，则复制到 agents/${clone_code}/agent */
+function copyAgentsFiles(clone_code: string) {
+  const workspacePath = getWorkspaceDir()
+  if (!workspacePath) return
+  const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+  const agentDir = path.join(workspacePath, '../', `agents/${clone_code}`)
+  const sourceAgent = path.join(workspaceDir, 'agent')
+  try {
+    if (!fs.existsSync(sourceAgent)) return
+    if (!fs.statSync(sourceAgent).isDirectory()) return
+    fs.mkdirSync(agentDir, { recursive: true })
+    const dest = path.join(agentDir, 'agent')
+    if (fs.existsSync(dest)) {
+      fs.rmSync(dest, { recursive: true, force: true })
+    }
+    fs.cpSync(sourceAgent, dest, { recursive: true })
+  } catch (err: unknown) {
+    dcgLogger(`copyAgentsFiles failed: ${String(err)}`, 'error')
+  }
+}
+
+export async function onCreateAgent(params: Record<string, any>) {
+  const { clone_code, name, description } = params
+  try {
+    await sendMessageToGateway(JSON.stringify({ method: 'agents.create', params: { name: clone_code, workspace: clone_code } }))
+  } catch (err: unknown) {
+    dcgLogger(`agents.create failed: ${String(err)}`, 'error')
+  }
+  // Update config.name to the user-supplied display name (may contain CJK, spaces, etc.)
+  try {
+    await sendMessageToGateway(JSON.stringify({ method: 'agents.update', params: { name: name, agentId: clone_code } }))
+  } catch (err: unknown) {
+    dcgLogger(`agents.update failed: ${String(err)}`, 'error')
+  }
+  if (description?.trim()) {
+    try {
+      await sendMessageToGateway(
+        JSON.stringify({
+          method: 'agents.files.set',
+          params: { agentId: clone_code, name: 'IDENTITY.md', content: description.trim() }
+        })
+      )
+    } catch {
+      // Non-fatal
+    }
+  }
+  if (name?.trim()) {
+    try {
+      await sendMessageToGateway(
+        JSON.stringify({
+          method: 'agents.files.set',
+          params: { agentId: clone_code, name: 'USER.md', content: name.trim() }
+        })
+      )
+    } catch {
+      // Non-fatal
+    }
+  }
+  copyAgentsFiles(clone_code)
+  sendEvent({ ...params, status: 'ok' })
+}
+
+export async function createAgent(msgContent: Record<string, any>) {
+  const { url, clone_code } = msgContent
+  if (!url || !clone_code) {
+    dcgLogger(`createAgent failed empty url&clone_code: ${JSON.stringify(msgContent)}`, 'error')
+    sendEvent({ ...msgContent, status: 'fail' })
+    return
+  }
+  const workspacePath = getWorkspaceDir()
+  const workspaceDir = path.join(workspacePath, '../', `workspace-${clone_code}`)
+
+  // 如果目标目录已存在，先删除
+  if (fs.existsSync(workspaceDir)) {
+    fs.rmSync(workspaceDir, { recursive: true, force: true })
+  }
+
+  try {
+    const response = await axios({
+      method: 'get',
+      url,
+      responseType: 'arraybuffer'
+    })
+    fs.mkdirSync(workspaceDir, { recursive: true })
+    await extractZipBufferToDirectory(Buffer.from(response.data), workspaceDir)
+    await onCreateAgent(msgContent)
+  } catch (error) {
+    // 如果安装失败，清理目录
+    if (fs.existsSync(workspaceDir)) {
+      fs.rmSync(workspaceDir, { recursive: true, force: true })
+    }
+    sendEvent({ ...msgContent, status: 'fail' })
+  }
+}

package/src/bot.ts

@@ -1,8 +1,6 @@
 import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
 import type { ReplyPayload } from 'openclaw/plugin-sdk'
-import { createReplyPrefixContext } from 'openclaw/plugin-sdk'
+import { createReplyPrefixContext, createTypingCallbacks } from 'openclaw/plugin-sdk'
 import type { InboundMessage } from './types.js'
 import {
   clearSentMediaKeys,
@@ -14,12 +12,12 @@ import {
 } from './utils/global.js'
 import { resolveAccount, sendDcgchatMedia } from './channel.js'
 import { generateSignUrl } from './request/api.js'
-import { extractMobookFiles } from './utils/searchFile.js'
 import { sendChunk, sendFinal, sendText as sendTextMsg, sendError, wsSendRaw, sendText } from './transport.js'
 import { dcgLogger } from './utils/log.js'
 import { channelInfo, systemCommand, interruptCommand, ENV, ignoreToolCommand } from './utils/constant.js'
-import { sendMessageToGateway } from './gateway/socket.js'
-import { getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
+import { sendGatewayRpc } from './gateway/socket.js'
+import { clearParamsMessage, getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
+import { getChildSessionKeysTrackedForRequester, resetSubagentStateForRequesterSession, waitUntilSubagentsIdle } from './tool.js'
 
 type MediaInfo = {
   path: string
@@ -44,13 +42,6 @@ const sessionStreamSuppressed = new Set<string>()
 /** 各 sessionKey 当前轮回复的流式分片序号（仅统计实际下发的文本 chunk）；每轮非打断消息开始时置 0 */
 const streamChunkIdxBySessionKey = new Map<string, number>()
 
-/** Active LLM generation abort controllers, keyed by conversationId */
-// const activeGenerations = new Map<string, AbortController>()
-
-/**
- * Extract agentId from conversation_id formatted as "agentId::suffix".
- * Returns null if the conversation_id does not contain the "::" separator.
- */
 export function extractAgentIdFromConversationId(conversationId: string): string | null {
   const idx = conversationId.indexOf('::')
   if (idx <= 0) return null
@@ -133,12 +124,17 @@ function resolveReplyMediaList(payload: ReplyPayload): string[] {
   return payload.mediaUrl ? [payload.mediaUrl] : []
 }
 
+const typingCallbacks = createTypingCallbacks({
+  start: async () => {},
+  onStartError: (err) => {
+    dcgLogger(`typing start error: ${String(err)}`, 'error')
+  }
+})
+
 /**
  * 处理一条用户消息，调用 Agent 并返回回复
  */
 export async function handleDcgchatMessage(msg: InboundMessage, accountId: string): Promise<void> {
-  let finalSent = false
-
   let completeText = ''
   const config = getOpenClawConfig()
   if (!config) {
@@ -151,7 +147,6 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   const core = getDcgchatRuntime()
 
   const conversationId = msg.content.session_id?.trim()
-  const agentId = msg.content.agent_id?.trim()
   const real_mobook = msg.content.real_mobook?.toString().trim()
 
   const route = core.channel.routing.resolveAgentRoute({
@@ -164,7 +159,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
 
   const effectiveAgentId = embeddedAgentId ?? route.agentId
-  const effectiveSessionKey = getSessionKey(msg.content, account.accountId)
+  const dcgSessionKey = getSessionKey(msg.content, account.accountId)
 
   const mergedParams = {
     userId: msg._userId,
@@ -175,44 +170,27 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     appId: msg.content.app_id,
     botId: msg.content.bot_id ?? '',
     agentId: msg.content.agent_id ?? '',
-    sessionKey: effectiveSessionKey,
+    sessionKey: dcgSessionKey,
     real_mobook
   }
-  setParamsMessage(effectiveSessionKey, mergedParams)
-  // 与 OpenClaw 会话投递里仍可能出现的 ctx.to=SenderId（userId）对齐，便于 getOutboundMsgParams 命中
-  dcgLogger(
-    `target normalize: rawTarget=${userId}, normalizedTarget=${effectiveSessionKey}, conversationId=${conversationId ?? ''}, messageId=${msg.content.message_id}`
-  )
-  setParamsMessage(userId, mergedParams)
-  dcgLogger(`target alias bound: aliasTarget=${userId} -> sessionKey=${effectiveSessionKey}`)
-  const outboundCtx = getEffectiveMsgParams(effectiveSessionKey)
+  /** 写入本条消息参数前快照：流式/abort 的 final 须对齐「上一轮」触发的对话 messageId，而非打断指令本身 */
+  const priorOutboundCtx = getEffectiveMsgParams(dcgSessionKey)
+  setParamsMessage(dcgSessionKey, mergedParams)
+  dcgLogger(`target alias bound: aliasTarget=${userId} -> sessionKey=${dcgSessionKey}`)
+  const outboundCtx = getEffectiveMsgParams(dcgSessionKey)
   const agentEntry =
     effectiveAgentId && effectiveAgentId !== 'main' ? config.agents?.list?.find((a) => a.id === effectiveAgentId) : undefined
   const agentDisplayName = agentEntry?.name ?? (effectiveAgentId && effectiveAgentId !== 'main' ? effectiveAgentId : undefined)
 
-  const safeSendFinal = (tag: string) => {
-    if (finalSent) return
-    finalSent = true
-    sendFinal(outboundCtx, tag)
-    setMsgStatus(effectiveSessionKey, 'finished')
-  }
-
-  const text = msg.content.text?.trim()
+  let text = msg.content.text?.trim()
 
   if (!text) {
     sendTextMsg('你需要我帮你做什么呢？', outboundCtx)
-    safeSendFinal('not text')
+    sendFinal(outboundCtx, 'not text')
     return
   }
 
   try {
-    // Abort any existing generation for this conversation, then start a new one
-    // const existingCtrl = activeGenerations.get(conversationId)
-    // if (existingCtrl) existingCtrl.abort()
-    // const genCtrl = new AbortController()
-    // const genSignal = genCtrl.signal
-    // activeGenerations.set(conversationId, genCtrl)
-
     // 处理用户上传的文件
     const files = msg.content.files ?? []
     let mediaPayload: Record<string, unknown> = {}
@@ -236,8 +214,8 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       RawBody: text,
       CommandBody: text,
       From: userId,
-      To: effectiveSessionKey,
-      SessionKey: effectiveSessionKey,
+      To: dcgSessionKey,
+      SessionKey: dcgSessionKey,
       AccountId: route.accountId,
       ChatType: 'direct',
       SenderName: agentDisplayName,
@@ -249,17 +227,27 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       WasMentioned: true,
       CommandAuthorized: true,
       OriginatingChannel: "dcgchat",
-      OriginatingTo: effectiveSessionKey,
+      OriginatingTo: dcgSessionKey,
+      Target: dcgSessionKey,
+      SourceTarget: dcgSessionKey,
       ...mediaPayload
     })
-  dcgLogger(
-    `inbound context target: rawTarget=${userId}, normalizedTarget=${effectiveSessionKey}, ctx.To=${String(ctxPayload.To ?? '')}, ctx.SessionKey=${String(ctxPayload.SessionKey ?? '')}, ctx.OriginatingTo=${String(ctxPayload.OriginatingTo ?? '')}`
-  )
 
     const sentMediaKeys = new Set<string>()
     const getMediaKey = (url: string) => url.split(/[\\/]/).pop() ?? url
     let streamedTextLen = 0
 
+    if (msg.content.skills_scope.length > 0 && !msg.content?.agent_clone_code) {
+      const workspaceDir = getWorkspaceDir()
+      const skillText = msg.content.skills_scope
+        .map((skill) => {
+          const skillDir = `${workspaceDir}/skills/${skill.skill_code}`
+          return `技能${skill.skill_code} 在目录${skillDir}下，在目录${skillDir}下读取技能 \n`
+        })
+        .join('\n')
+      text = skillText ? `${skillText} ${text}` : text
+      dcgLogger(`skill: text: ${text}`)
+    }
     const prefixContext = createReplyPrefixContext({
       cfg: config,
       agentId: effectiveAgentId ?? '',
@@ -267,78 +255,106 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       accountId: account.accountId
     })
 
-    const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
       responsePrefix: prefixContext.responsePrefix,
       responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
       humanDelay: core.channel.reply.resolveHumanDelayConfig(config, route.agentId),
       onReplyStart: async () => {},
       deliver: async (payload: ReplyPayload, info) => {
-        if (sessionStreamSuppressed.has(effectiveSessionKey)) return
+        if (sessionStreamSuppressed.has(dcgSessionKey)) return
         const mediaList = resolveReplyMediaList(payload)
         for (const mediaUrl of mediaList) {
           const key = getMediaKey(mediaUrl)
           if (sentMediaKeys.has(key)) continue
           sentMediaKeys.add(key)
-          await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl, text: '' })
+          await sendDcgchatMedia({ sessionKey: dcgSessionKey, mediaUrl, text: '' })
         }
       },
       onError: (err: unknown, info: { kind: string }) => {
-        safeSendFinal('error')
-        dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
-        activeRunIdBySessionKey.delete(effectiveSessionKey)
-        streamChunkIdxBySessionKey.delete(effectiveSessionKey)
-        if (sessionStreamSuppressed.has(effectiveSessionKey)) {
-          dcgLogger(`${info.kind} reply failed (stream suppressed): ${String(err)}`, 'error')
-          return
-        }
-        dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
+        setMsgStatus(dcgSessionKey, 'finished')
+        sendFinal(outboundCtx, 'error')
+        activeRunIdBySessionKey.delete(dcgSessionKey)
+        streamChunkIdxBySessionKey.delete(dcgSessionKey)
+        const suppressed = sessionStreamSuppressed.has(dcgSessionKey)
+        dcgLogger(`${info.kind} reply failed${suppressed ? ' (stream suppressed)' : ''}: ${String(err)}`, 'error')
       },
-      onIdle: () => {}
+      onIdle: () => {
+        typingCallbacks.onIdle?.()
+      }
     })
 
     try {
       if (!interruptCommand.includes(text?.trim())) {
-        sessionStreamSuppressed.delete(effectiveSessionKey)
-        streamChunkIdxBySessionKey.set(effectiveSessionKey, 0)
+        sessionStreamSuppressed.delete(dcgSessionKey)
+        streamChunkIdxBySessionKey.set(dcgSessionKey, 0)
       }
 
       if (systemCommand.includes(text?.trim())) {
-        dcgLogger(`dispatching /new`)
-        await core.channel.reply.dispatchReplyFromConfig({
-          ctx: ctxPayload,
-          cfg: config,
+        dcgLogger(`dispatching ${text?.trim()}`)
+        await core.channel.reply.withReplyDispatcher({
           dispatcher,
-          replyOptions: {
-            ...replyOptions,
-            onModelSelected: prefixContext.onModelSelected,
-            onAgentRunStart: (runId) => {
-              activeRunIdBySessionKey.set(effectiveSessionKey, runId)
-            }
-          }
+          onSettled: () => markDispatchIdle(),
+          run: () =>
+            core.channel.reply.dispatchReplyFromConfig({
+              ctx: ctxPayload,
+              cfg: config,
+              dispatcher,
+              replyOptions: {
+                ...replyOptions,
+                onModelSelected: prefixContext.onModelSelected,
+                onAgentRunStart: (runId) => {
+                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                }
+              }
+            })
         })
       } else if (interruptCommand.includes(text?.trim())) {
         dcgLogger(`interrupt command: ${text}`)
-        safeSendFinal('abort')
+        const ctxForAbort =
+          priorOutboundCtx.messageId?.trim() || priorOutboundCtx.sessionId?.trim()
+            ? priorOutboundCtx
+            : outboundCtx
+        sendFinal(
+          ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` },
+          'abort'
+        )
         sendText('会话已终止', outboundCtx)
-        sessionStreamSuppressed.add(effectiveSessionKey)
-        const runId = activeRunIdBySessionKey.get(effectiveSessionKey)
-        sendMessageToGateway(
-          JSON.stringify({
-            method: 'chat.abort',
-            params: {
-              sessionKey: effectiveSessionKey,
-              ...(runId ? { runId } : {})
-            }
+        sessionStreamSuppressed.add(dcgSessionKey)
+        const abortOneSession = async (sessionKey: string) => {
+          try {
+            await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey } })
+          } catch (e) {
+            dcgLogger(`chat.abort ${sessionKey}: ${String(e)}`, 'error')
+          }
+        }
+        const keysToAbort = new Set<string>(getChildSessionKeysTrackedForRequester(dcgSessionKey))
+        try {
+          const listed = await sendGatewayRpc<{ sessions?: Array<{ key?: string }> }>({
+            method: 'sessions.list',
+            params: { spawnedBy: dcgSessionKey, limit: 256 }
           })
-        )
-        if (runId) activeRunIdBySessionKey.delete(effectiveSessionKey)
-        safeSendFinal('stop')
+          for (const s of listed?.sessions ?? []) {
+            const k = typeof s?.key === 'string' ? s.key.trim() : ''
+            if (k) keysToAbort.add(k)
+          }
+        } catch (e) {
+          dcgLogger(`sessions.list spawnedBy: ${String(e)}`, 'error')
+        }
+        for (const sk of keysToAbort) {
+          await abortOneSession(sk)
+        }
+        await abortOneSession(dcgSessionKey)
+        streamChunkIdxBySessionKey.delete(dcgSessionKey)
+        resetSubagentStateForRequesterSession(dcgSessionKey)
+        setMsgStatus(dcgSessionKey, 'finished')
+        clearSentMediaKeys(msg.content.message_id)
+        clearParamsMessage(dcgSessionKey)
+        clearParamsMessage(userId)
+        sendFinal(outboundCtx, 'stop')
         return
       } else {
-        dcgLogger(`dispatching to agent (session=${route.sessionKey})`)
-        const params = getEffectiveMsgParams(effectiveSessionKey)
+        const params = getEffectiveMsgParams(dcgSessionKey)
         if (!ignoreToolCommand.includes(text?.trim())) {
-          // message_received 没有 sessionKey 前置到bot中执行
           wsSendRaw(params, {
             is_finish: -1,
             tool_call_id: Date.now().toString(),
@@ -353,114 +369,79 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
             response: ''
           })
         }
-        await core.channel.reply.dispatchReplyFromConfig({
-          ctx: ctxPayload,
-          cfg: config,
+        await core.channel.reply.withReplyDispatcher({
           dispatcher,
-          replyOptions: {
-            ...replyOptions,
-            // abortSignal: genSignal,
-            onModelSelected: prefixContext.onModelSelected,
-            onAgentRunStart: (runId) => {
-              activeRunIdBySessionKey.set(effectiveSessionKey, runId)
-            },
-            onPartialReply: async (payload: ReplyPayload) => {
-              if (sessionStreamSuppressed.has(effectiveSessionKey)) return
-
-              // Accumulate full text
-              if (payload.text) {
-                completeText = payload.text
-              }
-              // --- Streaming text chunks ---
-              if (payload.text) {
-                const delta = payload.text.startsWith(completeText.slice(0, streamedTextLen))
-                  ? payload.text.slice(streamedTextLen)
-                  : payload.text
-                if (delta.trim()) {
-                  const prev = streamChunkIdxBySessionKey.get(effectiveSessionKey) ?? 0
-                  streamChunkIdxBySessionKey.set(effectiveSessionKey, prev + 1)
-                  sendChunk(delta, outboundCtx, prev)
-                  dcgLogger(`[stream]: chunkIdx=${prev} len=${delta.length} user=${msg._userId} ${delta.slice(0, 100)}`)
+          onSettled: () => markDispatchIdle(),
+          run: () =>
+            core.channel.reply.dispatchReplyFromConfig({
+              ctx: ctxPayload,
+              cfg: config,
+              dispatcher,
+              replyOptions: {
+                ...replyOptions,
+                onModelSelected: prefixContext.onModelSelected,
+                onAgentRunStart: (runId) => {
+                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                },
+                onPartialReply: async (payload: ReplyPayload) => {
+                  if (sessionStreamSuppressed.has(dcgSessionKey)) return
+
+                  if (payload.text) {
+                    completeText = payload.text
+                  }
+                  // --- Streaming text chunks ---
+                  if (payload.text) {
+                    const delta = payload.text.startsWith(completeText.slice(0, streamedTextLen))
+                      ? payload.text.slice(streamedTextLen)
+                      : payload.text
+                    if (delta.trim()) {
+                      const prev = streamChunkIdxBySessionKey.get(dcgSessionKey) ?? 0
+                      streamChunkIdxBySessionKey.set(dcgSessionKey, prev + 1)
+                      sendChunk(delta, outboundCtx, prev)
+                      dcgLogger(
+                        `[stream]: chunkIdx=${prev} len=${delta.length} sessionId=${outboundCtx.sessionId} ${delta.slice(0, 100)}`
+                      )
+                    }
+                    streamedTextLen = payload.text.length
+                  } else {
+                    dcgLogger(`onPartialReply no text: ${JSON.stringify(payload)}`, 'error')
+                  }
+                  // --- Media from payload ---
+                  const mediaList = resolveReplyMediaList(payload)
+                  for (const mediaUrl of mediaList) {
+                    const key = getMediaKey(mediaUrl)
+                    if (sentMediaKeys.has(key)) continue
+                    sentMediaKeys.add(key)
+                    await sendDcgchatMedia({ sessionKey: dcgSessionKey, mediaUrl, text: '' })
+                  }
                 }
-                streamedTextLen = payload.text.length
-              }
-              // --- Media from payload ---
-              const mediaList = resolveReplyMediaList(payload)
-              for (const mediaUrl of mediaList) {
-                const key = getMediaKey(mediaUrl)
-                if (sentMediaKeys.has(key)) continue
-                sentMediaKeys.add(key)
-                await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl, text: '' })
               }
-            }
-          }
+            })
         })
       }
     } catch (err: unknown) {
-      // if (genSignal.aborted) {
-      //   wasAborted = true
-      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      // } else if (err instanceof Error && err.name === 'AbortError') {
-      //   wasAborted = true
-      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      // } else {
-      //   dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
-      // }
-    } finally {
-      // if (activeGenerations.get(conversationId) === genCtrl) {
-      //   activeGenerations.delete(conversationId)
-      // }
-    }
-    try {
-      markRunComplete()
-      markDispatchIdle()
-    } catch (err) {
-      dcgLogger(` markRunComplete||markRunComplete error: ${String(err)}`, 'error')
+      dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
     }
+
     if (![...systemCommand, ...interruptCommand].includes(text?.trim())) {
-      if (sessionStreamSuppressed.has(effectiveSessionKey)) {
-        sessionStreamSuppressed.delete(effectiveSessionKey)
-      } else {
-        for (const file of extractMobookFiles(completeText)) {
-          const candidates: string[] = [file]
-          candidates.push(path.join(getWorkspaceDir(), file))
-          candidates.push(path.join(getWorkspaceDir(), file.replace(/^\//, '')))
-          const underMobook = file.replace(/^\/mobook\//i, '').replace(/^mobook[\\/]/i, '')
-          if (underMobook) {
-            if (process.platform === 'win32') {
-              candidates.push(path.join('C:\\', 'mobook', underMobook))
-            } else if (process.platform === 'darwin') {
-              candidates.push(path.join(os.homedir(), 'mobook', underMobook))
-            }
-          }
-          const resolved = candidates.find((p) => fs.existsSync(p))
-          if (!resolved) continue
-          try {
-            await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl: resolved, text: '' })
-          } catch (err) {
-            dcgLogger(` sendDcgchatMedia error: ${String(err)}`, 'error')
-          }
-        }
+      if (sessionStreamSuppressed.has(dcgSessionKey)) {
+        sessionStreamSuppressed.delete(dcgSessionKey)
       }
     }
-    safeSendFinal('end')
     clearSentMediaKeys(msg.content.message_id)
-
-    // Record session metadata
     const storePath = core.channel.session.resolveStorePath(config.session?.store)
-    dcgLogger(
-      `record session route: rawTarget=${userId}, normalizedTarget=${effectiveSessionKey}, updateLastRoute.to=${effectiveSessionKey}, accountId=${route.accountId}`
-    )
+    await waitUntilSubagentsIdle(dcgSessionKey, { timeoutMs: 600_000 })
+    sendFinal(outboundCtx, 'end')
+    dcgLogger(`record session route: updateLastRoute.to=${dcgSessionKey}, accountId=${route.accountId}`)
     core.channel.session
       .recordInboundSession({
         storePath,
-        sessionKey: effectiveSessionKey,
+        sessionKey: dcgSessionKey,
         ctx: ctxPayload,
-        // 与 Telegram/Discord 等一致：写入 deliveryContext.to，否则投递可能回退为 From（userId），channel sendMedia 里 ctx.to 会变成数字 userId
         updateLastRoute: {
-          sessionKey: effectiveSessionKey,
+          sessionKey: dcgSessionKey,
           channel: "dcgchat",
-          to: effectiveSessionKey,
+          to: dcgSessionKey,
           accountId: route.accountId
         },
         onRecordError: (err) => {
@@ -473,7 +454,5 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   } catch (err) {
     dcgLogger(` handle message failed: ${String(err)}`, 'error')
     sendError(err instanceof Error ? err.message : String(err), outboundCtx)
-  } finally {
-    safeSendFinal('finally')
   }
 }