@dcrays/dcgchat-test 0.3.36 → 0.3.37

package/package.json

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

package/src/bot.ts

@@ -1,8 +1,8 @@
 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 type { PluginRuntime, ReplyPayload } from 'openclaw/plugin-sdk'
+import { createPluginRuntimeStore, createReplyPrefixContext, createTypingCallbacks } from 'openclaw/plugin-sdk'
 import type { InboundMessage } from './types.js'
 import {
   clearSentMediaKeys,
@@ -18,8 +18,9 @@ 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 +45,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
@@ -132,7 +126,14 @@ function resolveReplyMediaList(payload: ReplyPayload): string[] {
   if (payload.mediaUrls?.length) return payload.mediaUrls.filter(Boolean)
   return payload.mediaUrl ? [payload.mediaUrl] : []
 }
-
+const typingCallbacks = createTypingCallbacks({
+  start: async () => {
+    console.log('typing start')
+  },
+  onStartError: (err) => {
+    console.log('typing start error', err)
+  }
+})
 /**
  * 处理一条用户消息，调用 Agent 并返回回复
  */
@@ -178,10 +179,6 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     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)
@@ -189,29 +186,15 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     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()
 
   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> = {}
@@ -249,11 +232,10 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       CommandAuthorized: true,
       OriginatingChannel: "dcgchat-test",
       OriginatingTo: effectiveSessionKey,
+      Target: effectiveSessionKey,
+      SourceTarget: effectiveSessionKey,
       ...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
@@ -266,7 +248,7 @@ 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),
@@ -282,7 +264,8 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         }
       },
       onError: (err: unknown, info: { kind: string }) => {
-        safeSendFinal('error')
+        setMsgStatus(effectiveSessionKey, 'finished')
+        sendFinal(outboundCtx, 'error')
         dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
         activeRunIdBySessionKey.delete(effectiveSessionKey)
         streamChunkIdxBySessionKey.delete(effectiveSessionKey)
@@ -292,7 +275,9 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         }
         dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
       },
-      onIdle: () => {}
+      onIdle: () => {
+        typingCallbacks.onIdle?.()
+      }
     })
 
     try {
@@ -302,42 +287,78 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       }
 
       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(effectiveSessionKey, runId)
+                }
+              }
+            })
         })
       } else if (interruptCommand.includes(text?.trim())) {
         dcgLogger(`interrupt command: ${text}`)
         sendFinal(outboundCtx, 'abort')
         sendText('会话已终止', outboundCtx)
         sessionStreamSuppressed.add(effectiveSessionKey)
-        const runId = activeRunIdBySessionKey.get(effectiveSessionKey)
-        sendMessageToGateway(
-          JSON.stringify({
-            method: 'chat.abort',
-            params: {
-              sessionKey: effectiveSessionKey,
-              ...(runId ? { runId } : {})
-            }
+
+        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(effectiveSessionKey))
+        try {
+          const listed = await sendGatewayRpc<{ sessions?: Array<{ key?: string }> }>({
+            method: 'sessions.list',
+            params: { spawnedBy: effectiveSessionKey, limit: 256 }
+          })
+          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(effectiveSessionKey)
+
+        try {
+          await sendGatewayRpc({
+            method: 'sessions.reset',
+            params: { key: effectiveSessionKey, reason: 'reset' }
           })
-        )
-        if (runId) activeRunIdBySessionKey.delete(effectiveSessionKey)
-        safeSendFinal('stop')
+        } catch (e) {
+          dcgLogger(`sessions.reset: ${String(e)}`, 'error')
+        }
+
+        activeRunIdBySessionKey.delete(effectiveSessionKey)
+        streamChunkIdxBySessionKey.delete(effectiveSessionKey)
+        resetSubagentStateForRequesterSession(effectiveSessionKey)
+        setMsgStatus(effectiveSessionKey, 'finished')
+        clearSentMediaKeys(msg.content.message_id)
+        clearParamsMessage(effectiveSessionKey)
+        clearParamsMessage(userId)
+
+        sendFinal(outboundCtx, 'stop')
         return
       } else {
-        dcgLogger(`dispatching to agent (session=${route.sessionKey})`)
         const params = getEffectiveMsgParams(effectiveSessionKey)
         if (!ignoreToolCommand.includes(text?.trim())) {
-          // message_received 没有 sessionKey 前置到bot中执行
           wsSendRaw(params, {
             is_finish: -1,
             tool_call_id: Date.now().toString(),
@@ -352,70 +373,58 @@ 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(effectiveSessionKey, runId)
+                },
+                onPartialReply: async (payload: ReplyPayload) => {
+                  if (sessionStreamSuppressed.has(effectiveSessionKey)) 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(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)}`)
+                    }
+                    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: effectiveSessionKey, 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)
@@ -442,11 +451,10 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         }
       }
     }
-    safeSendFinal('end')
     clearSentMediaKeys(msg.content.message_id)
-
-    // Record session metadata
     const storePath = core.channel.session.resolveStorePath(config.session?.store)
+    await waitUntilSubagentsIdle(effectiveSessionKey, { timeoutMs: 600_000 })
+    sendFinal(outboundCtx, 'end')
     dcgLogger(
       `record session route: rawTarget=${userId}, normalizedTarget=${effectiveSessionKey}, updateLastRoute.to=${effectiveSessionKey}, accountId=${route.accountId}`
     )
@@ -455,7 +463,6 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         storePath,
         sessionKey: effectiveSessionKey,
         ctx: ctxPayload,
-        // 与 Telegram/Discord 等一致：写入 deliveryContext.to，否则投递可能回退为 From（userId），channel sendMedia 里 ctx.to 会变成数字 userId
         updateLastRoute: {
           sessionKey: effectiveSessionKey,
           channel: "dcgchat-test",
@@ -472,7 +479,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')
   }
 }

package/src/channel.ts

@@ -1,8 +1,15 @@
-import type { ChannelPlugin, OpenClawConfig } from 'openclaw/plugin-sdk'
-import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
+import type { ChannelPlugin, OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
+import { createPluginRuntimeStore, DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
 import type { ResolvedDcgchatAccount, DcgchatConfig } from './types.js'
 import { ossUpload } from './request/oss.js'
-import { addSentMediaKey, getCronMessageId, getInfoBySessionKey, getOpenClawConfig, hasSentMediaKey } from './utils/global.js'
+import {
+  addSentMediaKey,
+  getCronMessageId,
+  getDcgchatRuntime,
+  getInfoBySessionKey,
+  getOpenClawConfig,
+  hasSentMediaKey
+} from './utils/global.js'
 import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
 import { dcgLogger, setLogger } from './utils/log.js'
 import { getOutboundMsgParams, getParamsMessage } from './utils/params.js'
@@ -116,7 +123,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
     uiHints: {
       userId: {
         label: 'WS 连接 _userId',
-        help: '仅用于拼接网关 WebSocket URL 的查询参数，不是 Agent 发消息时的 target。发消息请使用 effectiveSessionKey（与入站上下文 SessionKey 相同，格式如 agent:main:mobook:direct:…）。'
+        help: '仅用于拼接网关 WebSocket URL 的查询参数，不是 Agent 发消息时的 target。发消息请使用 effectiveSessionKey（与入站上下文 SessionKey 相同，格式如 agent:main:mobook:direct:<agent_id>:<session_id>）。'
       }
     }
   },
@@ -155,8 +162,9 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
   },
   agentPrompt: {
     messageToolHints: () => [
-      '书灵墨宝：message 工具的 target 必须填 effectiveSessionKey（与当前会话 SessionKey / OriginatingTo 相同），形如 agent:main:mobook:direct:<agent_id>:<session_id>；不要填 channels.dcgchat.userId 或纯数字 userId。',
-      'OpenClaw 自带的 target 字段说明里仍可能出现 “user id”，在本频道请忽略该字样，一律按 effectiveSessionKey 理解。'
+      '生成文件后，**尽可能不要**把文件路径、地址直接告诉用户。',
+      '生成文件后，把文件名告诉用户。',
+      '生成文件后，必须调用 message 工具发送文件，不可以直接在文本回复里包含文件路径、文件名、地址。'
     ]
   },
   outbound: {
@@ -167,6 +175,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
       }
       return { ok: true, to: to }
     },
+    chunker: (text, limit) => getDcgchatRuntime().channel.text.chunkMarkdownText(text, limit),
     textChunkLimit: 4000,
     sendText: async (ctx) => {
       dcgLogger(`channel sendText to ${ctx.to} `)

package/src/gateway/index.ts

@@ -3,8 +3,8 @@ import { WebSocket } from 'ws'
 import crypto from 'crypto'
 import { deriveDeviceIdFromPublicKey, publicKeyRawBase64UrlFromPem, buildDeviceAuthPayloadV3, signDevicePayload } from './security.js'
 import { dcgLogger } from '../utils/log.js'
-import { finishedDcgchatCron, sendDcgchatCron } from '../cron.js'
 import { getWorkspaceDir } from '../utils/global.js'
+import { handleGatewayEventMessage } from '../utils/gatewayMsgHanlder.js'
 
 export interface GatewayEvent {
   type: string
@@ -358,31 +358,7 @@ export class GatewayConnection {
     }
 
     if (msg.type === 'event') {
-      try {
-        // 定时任务相关事件
-        if (msg.event === 'cron') {
-          dcgLogger(`[Gateway] 收到事件: ${JSON.stringify(msg)}`)
-          if (msg.payload?.action === 'added') {
-            sendDcgchatCron(msg.payload?.jobId)
-          }
-          if (msg.payload?.action === 'updated') {
-            sendDcgchatCron(msg.payload?.jobId as string)
-          }
-          if (msg.payload?.action === 'removed') {
-            sendDcgchatCron(msg.payload?.jobId as string)
-          }
-          if (msg.payload?.action === 'finished') {
-            finishedDcgchatCron(msg.payload?.jobId as string)
-          }
-        }
-      } catch (error) {
-        dcgLogger(`[Gateway] 处理事件失败: ${error}`, 'error')
-      }
-      const event: GatewayEvent = {
-        type: msg.event as string,
-        payload: msg.payload as Record<string, unknown> | undefined,
-        seq: msg.seq as number | undefined
-      }
+      const event = handleGatewayEventMessage(msg)
       this.eventHandlers.forEach((h) => h(event))
     }
   }

package/src/tool.ts

@@ -2,7 +2,7 @@ import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
 import { getMsgStatus } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
 import { sendFinal, sendText, wsSendRaw } from './transport.js'
-import { getEffectiveMsgParams } from './utils/params.js'
+import { getEffectiveMsgParams, deleteSessionKeyBySubAgentRunId, setSessionKeyBySubAgentRunId } from './utils/params.js'
 import { cronToolCall } from './cronToolCall.js'
 
 type PluginHookName =
@@ -68,10 +68,244 @@ interface CronDelivery {
   [key: string]: unknown
 }
 
+// --- Subagent 活跃跟踪（按主会话 requesterSessionKey）---
+
+/** 主会话 sessionKey -> 仍活跃的子 agent runId */
+const activeSubagentRunIdsByRequester = new Map<string, Set<string>>()
+/** 子会话 childSessionKey -> 主会话 requesterSessionKey */
+const requesterByChildSessionKey = new Map<string, string>()
+/** 子会话 childSessionKey -> spawn 时的 runId（ended 事件可能不带 runId） */
+const runIdByChildSessionKey = new Map<string, string>()
+/** 主会话 -> 等待「子 agent 全部结束」的回调 */
+const subagentIdleWaiters = new Map<string, Set<() => void>>()
+
+function getOrCreateRunIdSet(requesterSessionKey: string): Set<string> {
+  let set = activeSubagentRunIdsByRequester.get(requesterSessionKey)
+  if (!set) {
+    set = new Set()
+    activeSubagentRunIdsByRequester.set(requesterSessionKey, set)
+  }
+  return set
+}
+
+function flushSubagentIdleWaiters(requesterSessionKey: string): void {
+  const set = activeSubagentRunIdsByRequester.get(requesterSessionKey)
+  if (set && set.size > 0) return
+  activeSubagentRunIdsByRequester.delete(requesterSessionKey)
+  const waiters = subagentIdleWaiters.get(requesterSessionKey)
+  if (!waiters?.size) return
+  subagentIdleWaiters.delete(requesterSessionKey)
+  for (const w of waiters) {
+    try {
+      w()
+    } catch (e) {
+      dcgLogger(`subagent idle waiter error: ${String(e)}`, 'error')
+    }
+  }
+}
+
+function registerSubagentSpawn(requesterSessionKey: string, runId: string, childSessionKey: string): void {
+  const req = requesterSessionKey.trim()
+  const rid = runId.trim()
+  const child = childSessionKey.trim()
+  if (!req || !rid || !child) {
+    dcgLogger(`subagent track spawn skipped: missing key req=${req} runId=${rid} child=${child}`)
+    return
+  }
+  getOrCreateRunIdSet(req).add(rid)
+  requesterByChildSessionKey.set(child, req)
+  runIdByChildSessionKey.set(child, rid)
+  dcgLogger(`subagent track spawn: requester=${req} runId=${rid} child=${child} active=${getOrCreateRunIdSet(req).size}`)
+}
+
+function registerSubagentEnd(
+  ctx: { requesterSessionKey?: string; sessionKey?: string },
+  targetSessionKey: string,
+  runId?: string
+): void {
+  const child = targetSessionKey.trim()
+  if (!child) return
+  const req = ctx.requesterSessionKey?.trim() || requesterByChildSessionKey.get(child) || ctx.sessionKey?.trim() || ''
+  const resolvedRunId = (runId?.trim() || runIdByChildSessionKey.get(child) || '').trim()
+  deleteSessionKeyBySubAgentRunId(resolvedRunId)
+  if (!req) {
+    dcgLogger(`subagent track end: no requester for child=${child} runId=${resolvedRunId}`)
+    requesterByChildSessionKey.delete(child)
+    runIdByChildSessionKey.delete(child)
+    return
+  }
+  const set = activeSubagentRunIdsByRequester.get(req)
+  if (set && resolvedRunId) {
+    set.delete(resolvedRunId)
+  }
+  requesterByChildSessionKey.delete(child)
+  runIdByChildSessionKey.delete(child)
+  dcgLogger(`subagent track end: requester=${req} runId=${resolvedRunId || 'n/a'} remaining=${set?.size ?? 0}`)
+  if (set && set.size === 0) {
+    activeSubagentRunIdsByRequester.delete(req)
+  }
+  flushSubagentIdleWaiters(req)
+}
+
+/** 当前跟踪到的、挂在该主会话下的子会话 sessionKey（供 /stop 时逐个 chat.abort） */
+export function getChildSessionKeysTrackedForRequester(requesterSessionKey: string): string[] {
+  const req = requesterSessionKey.trim()
+  if (!req) return []
+  const out: string[] = []
+  for (const [child, parent] of requesterByChildSessionKey.entries()) {
+    if (parent === req) out.push(child)
+  }
+  return out
+}
+
+/**
+ * 打断后清空本地子 agent 跟踪（runId、父子映射、子 runId→sessionKey），并唤醒 waitUntilSubagentsIdle，避免永久挂起。
+ */
+export function resetSubagentStateForRequesterSession(requesterSessionKey: string): void {
+  const req = requesterSessionKey.trim()
+  if (!req) return
+
+  const runIdSet = activeSubagentRunIdsByRequester.get(req)
+  if (runIdSet) {
+    for (const rid of runIdSet) {
+      deleteSessionKeyBySubAgentRunId(rid)
+    }
+  }
+
+  for (const [child, parent] of [...requesterByChildSessionKey.entries()]) {
+    if (parent === req) {
+      requesterByChildSessionKey.delete(child)
+      runIdByChildSessionKey.delete(child)
+    }
+  }
+
+  activeSubagentRunIdsByRequester.delete(req)
+
+  const waiters = subagentIdleWaiters.get(req)
+  if (!waiters?.size) return
+  subagentIdleWaiters.delete(req)
+  for (const w of waiters) {
+    try {
+      w()
+    } catch (e) {
+      dcgLogger(`subagent idle waiter error: ${String(e)}`, 'error')
+    }
+  }
+}
+
+/** 当前主会话下仍在跑的子 agent 数量（按 spawn 时 runId 去重） */
+export function getActiveSubagentCount(sessionKey: string): number {
+  const sk = sessionKey?.trim()
+  if (!sk) return 0
+  return activeSubagentRunIdsByRequester.get(sk)?.size ?? 0
+}
+
+/**
+ * 等到指定主会话下已跟踪的子 agent 全部结束（spawn 失败等路径也会触发 subagent_ended，一般会配对清理）。
+ * 注意：须在收到 `subagent_spawned` 之后才会计入；仅 spawning 未 spawned 的不会阻塞。
+ */
+export function waitUntilSubagentsIdle(sessionKey: string, opts?: { timeoutMs?: number; signal?: AbortSignal }): Promise<void> {
+  console.log('🚀 ~ waitUntilSubagentsIdle ~ sessionKey:', sessionKey)
+  const sk = sessionKey?.trim()
+  if (!sk) return Promise.resolve()
+
+  if (getActiveSubagentCount(sk) === 0) return Promise.resolve()
+
+  return new Promise<void>((resolve, reject) => {
+    let settled = false
+    const finish = (fn: () => void) => {
+      if (settled) return
+      settled = true
+      if (timeoutId) clearTimeout(timeoutId)
+      opts?.signal?.removeEventListener('abort', onAbort)
+      removeWaiter()
+      fn()
+    }
+
+    const removeWaiter = () => {
+      const bucket = subagentIdleWaiters.get(sk)
+      if (!bucket) return
+      bucket.delete(onIdle)
+      if (bucket.size === 0) subagentIdleWaiters.delete(sk)
+    }
+
+    const onIdle = () => finish(() => resolve())
+
+    const onAbort = () => {
+      const reason = opts?.signal?.reason
+      finish(() => reject(reason instanceof Error ? reason : new Error(String(reason ?? 'Aborted'))))
+    }
+
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+    if (opts?.timeoutMs != null && opts.timeoutMs > 0) {
+      timeoutId = setTimeout(
+        () => finish(() => reject(new Error(`waitUntilSubagentsIdle timeout ${opts.timeoutMs}ms`))),
+        opts.timeoutMs
+      )
+    }
+
+    if (opts?.signal) {
+      if (opts.signal.aborted) {
+        onAbort()
+        return
+      }
+      opts.signal.addEventListener('abort', onAbort, { once: true })
+    }
+
+    let set = subagentIdleWaiters.get(sk)
+    if (!set) {
+      set = new Set()
+      subagentIdleWaiters.set(sk, set)
+    }
+    set.add(onIdle)
+
+    if (getActiveSubagentCount(sk) === 0) {
+      onIdle()
+    }
+  })
+}
+
+function resolveHookSessionKey(
+  eventName: string,
+  args: { sessionKey?: string; requesterSessionKey?: string; runId?: string }
+): string {
+  if (
+    eventName === 'subagent_spawned' ||
+    eventName === 'subagent_ended' ||
+    eventName === 'subagent_spawning' ||
+    eventName === 'subagent_delivery_target'
+  ) {
+    if (args?.runId && args?.requesterSessionKey) setSessionKeyBySubAgentRunId(args?.runId, args?.requesterSessionKey)
+    return (args?.requesterSessionKey || args?.sessionKey || '').trim()
+  }
+  return (args?.sessionKey || '').trim()
+}
+
+function trackSubagentLifecycle(eventName: string, event: any, args: any): void {
+  if (eventName === 'subagent_spawned') {
+    const runId = typeof event?.runId === 'string' ? event.runId : ''
+    const childSessionKey = typeof event?.childSessionKey === 'string' ? event.childSessionKey : ''
+    const requester =
+      typeof args?.requesterSessionKey === 'string'
+        ? args.requesterSessionKey
+        : typeof args?.sessionKey === 'string'
+          ? args.sessionKey
+          : ''
+    registerSubagentSpawn(requester, runId, childSessionKey)
+    return
+  }
+  if (eventName === 'subagent_ended') {
+    const targetSessionKey = typeof event?.targetSessionKey === 'string' ? event.targetSessionKey : ''
+    const runId = typeof event?.runId === 'string' ? event.runId : undefined
+    registerSubagentEnd(args ?? {}, targetSessionKey, runId)
+  }
+}
+
 export function monitoringToolMessage(api: OpenClawPluginApi) {
   for (const item of eventList) {
     api.on(item.event as PluginHookName, (event: any, args: any) => {
-      const sk = args?.sessionKey as string
+      trackSubagentLifecycle(item.event, event, args)
+      const sk = resolveHookSessionKey(item.event, args ?? {})
       if (sk) {
         const status = getMsgStatus(sk)
         if (status === 'running') {

package/src/utils/constant.ts

@@ -2,6 +2,6 @@ export const ENV: 'production' | 'test' | 'develop' = 'test'
 
 
 export const systemCommand = ['/new', '/status']
-export const interruptCommand = ['chat.stop']
+export const interruptCommand = ['/stop']
 
-export const ignoreToolCommand = ['/search', '/abort', '/stop', '/queue interrupt', ...systemCommand, ...interruptCommand]
+export const ignoreToolCommand = ['/search', '/abort', '/queue interrupt', ...systemCommand, ...interruptCommand]

package/src/utils/gatewayMsgHanlder.ts

@@ -0,0 +1,43 @@
+import type { GatewayEvent } from '../gateway/index.js'
+import { finishedDcgchatCron, sendDcgchatCron } from '../cron.js'
+import { dcgLogger } from './log.js'
+import { getEffectiveMsgParams, getSessionKeyBySubAgentRunId } from './params.js'
+import { sendChunk } from '../transport.js'
+
+/**
+ * 处理网关 event 帧的副作用（agent 流式输出、cron 同步），并构造供上层分发的 GatewayEvent。
+ */
+export function handleGatewayEventMessage(msg: { event?: string; payload?: Record<string, unknown>; seq?: number }): GatewayEvent {
+  try {
+    if (msg.event === 'agent') {
+      dcgLogger(`[Gateway] 收到agent事件: ${JSON.stringify(msg).slice(0, 100)}`)
+      const pl = msg.payload as { runId: string; data?: { delta?: unknown } }
+      const sessionKey = getSessionKeyBySubAgentRunId(pl.runId)
+      const outboundCtx = getEffectiveMsgParams(sessionKey)
+      if (outboundCtx.sessionId && pl.data?.delta) sendChunk(pl.data.delta as string, outboundCtx, 0)
+    }
+    if (msg.event === 'cron') {
+      const p = msg.payload
+      dcgLogger(`[Gateway] 收到定时任务事件: ${JSON.stringify(p)}`)
+      if (p?.action === 'added') {
+        sendDcgchatCron(p?.jobId as string)
+      }
+      if (p?.action === 'updated') {
+        sendDcgchatCron(p?.jobId as string)
+      }
+      if (p?.action === 'removed') {
+        sendDcgchatCron(p?.jobId as string)
+      }
+      if (p?.action === 'finished') {
+        finishedDcgchatCron(p?.jobId as string)
+      }
+    }
+  } catch (error) {
+    dcgLogger(`[Gateway] 处理事件失败: ${error}`, 'error')
+  }
+  return {
+    type: msg.event as string,
+    payload: msg.payload,
+    seq: msg.seq as number | undefined
+  }
+}

package/src/utils/global.ts

@@ -22,7 +22,7 @@ export function getOpenClawConfig(): OpenClawConfig | null {
   return config
 }
 
-import type { OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
+import { createPluginRuntimeStore, type OpenClawConfig, type PluginRuntime } from 'openclaw/plugin-sdk'
 import { dcgLogger } from './log.js'
 import { channelInfo, ENV } from './constant.js'
 
@@ -42,7 +42,6 @@ function getWorkspacePath() {
   return null
 }
 
-let runtime: PluginRuntime | null = null
 let workspaceDir: string = getWorkspacePath()
 
 export function setWorkspaceDir(dir?: string) {
@@ -56,17 +55,10 @@ export function getWorkspaceDir(): string {
   }
   return workspaceDir
 }
-
-export function setDcgchatRuntime(next: PluginRuntime) {
-  runtime = next
-}
-
-export function getDcgchatRuntime(): PluginRuntime {
-  if (!runtime) {
-    dcgLogger?.('runtime not initialized', 'error')
-  }
-  return runtime as PluginRuntime
-}
+const { setRuntime: setDcgchatRuntime, getRuntime: getDcgchatRuntime } = createPluginRuntimeStore<PluginRuntime>(
+  `${"dcgchat-test"} runtime not initialized`
+)
+export { setDcgchatRuntime, getDcgchatRuntime }
 
 export type MsgSessionStatus = 'running' | 'finished' | ''
 

package/src/utils/params.ts

@@ -69,3 +69,21 @@ export function setParamsMessage(sessionKey: string, params: Partial<IMsgParams>
 export function getParamsMessage(sessionKey: string): IMsgParams | undefined {
   return paramsMessageMap.get(sessionKey)
 }
+
+export function clearParamsMessage(sessionKey: string): void {
+  const k = sessionKey?.trim()
+  if (!k) return
+  paramsMessageMap.delete(k)
+}
+
+// sessionKey 对应的 子agent的runId
+const subagentRunIdMap = new Map<string, string>()
+export function getSessionKeyBySubAgentRunId(runId: string): string | undefined {
+  return subagentRunIdMap.get(runId)
+}
+export function setSessionKeyBySubAgentRunId(runId: string, sessionKey: string) {
+  subagentRunIdMap.set(runId, sessionKey)
+}
+export function deleteSessionKeyBySubAgentRunId(runId: string) {
+  subagentRunIdMap.delete(runId)
+}