@dcrays/dcgchat-test 0.4.20 → 0.4.21

package/package.json

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

package/src/bot.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto'
 import path from 'node:path'
 import type { ReplyPayload } from 'openclaw/plugin-sdk'
 import { createReplyPrefixContext, createTypingCallbacks } from 'openclaw/plugin-sdk'
@@ -15,9 +16,19 @@ import { generateSignUrl } from './request/api.js'
 import { sendChunk, sendFinal, sendText as sendTextMsg, sendError, wsSendRaw, sendText } from './transport.js'
 import { dcgLogger } from './utils/log.js'
 import { channelInfo, systemCommand, stopCommand, ENV, ignoreToolCommand } from './utils/constant.js'
-import { sendGatewayRpc } from './gateway/socket.js'
 import { clearParamsMessage, getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
-import { getDescendantSessionKeysForRequester, resetSubagentStateForRequesterSession, waitUntilSubagentsIdle } from './tool.js'
+import { waitUntilSubagentsIdle } from './tool.js'
+import {
+  beginSupersedingUserTurn,
+  clearActiveRunIdForSession,
+  clearSessionStreamSuppression,
+  interruptLocalDispatchAndGateway,
+  isSessionStreamSuppressed,
+  preemptInboundQueueForStop,
+  releaseDispatchAbortIfCurrent,
+  runInboundTurnSequenced,
+  setActiveRunIdForSession
+} from './sessionTermination.js'
 
 type MediaInfo = {
   path: string
@@ -30,23 +41,18 @@ type TFileInfo = { name: string; url: string }
 
 const mediaMaxBytes = 300 * 1024 * 1024
 
-/** 当前会话最近一次 agent run 的 runId（供观测；/stop 时对子会话与主会话使用不传 runId 的 chat.abort 以终止该键下全部活跃 run） */
-const activeRunIdBySessionKey = new Map<string, string>()
-
-/** 本通道用 dispatchReplyFromConfig 在进程内跑 agent，网关 chat.abort 往往碰不到该 run；靠 AbortSignal 才能真正停工具与模型调用。 */
-const dispatchAbortBySessionKey = new Map<string, AbortController>()
-
 /**
- * 用户在该 sessionKey 上触发打断后，旧 run 的流式/投递不再下发；与 sessionKey 一一对应，支持多会话。
- * 清除时机：① 下一条非打断用户消息开始处理时；② 旧 run 收尾到 mobook 段时若仍抑制则跳过并发后删除。
+ * 每条入站消息（含 /stop）递增。用于丢弃「已被后续入站抢占」的处理在 dispatch 结束后的尾部逻辑。
+ * 仅 /stop 时的 epoch 无法覆盖「新用户消息抢占上一轮」的并发 WS 场景，会导致旧 handler 仍执行 sendFinal(end)、
+ * 而新消息被误判为 stale；且上一轮若未对网关 chat.abort，服务端 run 会继续，表现为「新消息秒结束、旧回复复活」。
  */
-const sessionStreamSuppressed = new Set<string>()
+const inboundGenerationBySessionKey = new Map<string, number>()
 
-/**
- * 每次 /stop 递增。用于丢弃「已被后续打断」的那条入站处理在 dispatch 结束后的尾部逻辑
- *（否则旧 handler 会删掉 sessionStreamSuppressed、再发 sendFinal(end)/recordInboundSession，导致旧回复复活、新消息异常）。
- */
-const replyAbortEpochBySessionKey = new Map<string, number>()
+function bumpInboundGeneration(sessionKey: string): number {
+  const n = (inboundGenerationBySessionKey.get(sessionKey) ?? 0) + 1
+  inboundGenerationBySessionKey.set(sessionKey, n)
+  return n
+}
 
 /** 各 sessionKey 当前轮回复的流式分片序号（仅统计实际下发的文本 chunk）；每轮非打断消息开始时置 0 */
 const streamChunkIdxBySessionKey = new Map<string, number>()
@@ -149,7 +155,7 @@ const typingCallbacks = createTypingCallbacks({
 })
 
 /**
- * 处理一条用户消息，调用 Agent 并返回回复
+ * 处理一条用户消息，调用 Agent 并返回回复（同会话串行见 sessionTermination.runInboundTurnSequenced）。
  */
 export async function handleDcgchatMessage(msg: InboundMessage, accountId: string): Promise<void> {
   const config = getOpenClawConfig()
@@ -158,6 +164,20 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     return
   }
   const account = resolveAccount(config, accountId)
+  const queueSessionKey = getSessionKey(msg.content, account.accountId)
+  const queueText = (msg.content.text ?? '').trim()
+  if (stopCommand.includes(queueText)) {
+    preemptInboundQueueForStop(queueSessionKey)
+  }
+  await runInboundTurnSequenced(queueSessionKey, () => handleDcgchatMessageInboundTurn(msg, accountId))
+}
+
+async function handleDcgchatMessageInboundTurn(msg: InboundMessage, accountId: string): Promise<void> {
+  const config = getOpenClawConfig()
+  if (!config) {
+    return
+  }
+  const account = resolveAccount(config, accountId)
   const userId = msg._userId.toString()
 
   const core = getDcgchatRuntime()
@@ -176,7 +196,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
 
   const effectiveAgentId = embeddedAgentId ?? route.agentId
   const dcgSessionKey = getSessionKey(msg.content, account.accountId)
-  const replyAbortEpochAtStart = replyAbortEpochBySessionKey.get(dcgSessionKey) ?? 0
+  const inboundGenAtStart = bumpInboundGeneration(dcgSessionKey)
 
   const mergedParams = {
     userId: msg._userId,
@@ -204,6 +224,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   if (!text) {
     sendTextMsg('你需要我帮你做什么呢？', outboundCtx)
     sendFinal(outboundCtx, 'not text')
+    setMsgStatus(dcgSessionKey, 'finished')
     return
   }
 
@@ -284,7 +305,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       humanDelay: core.channel.reply.resolveHumanDelayConfig(config, route.agentId),
       onReplyStart: async () => {},
       deliver: async (payload: ReplyPayload, info) => {
-        if (sessionStreamSuppressed.has(dcgSessionKey)) return
+        if (isSessionStreamSuppressed(dcgSessionKey)) return
         const mediaList = resolveReplyMediaList(payload)
         for (const mediaUrl of mediaList) {
           const key = getMediaKey(mediaUrl)
@@ -297,9 +318,9 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       onError: (err: unknown, info: { kind: string }) => {
         setMsgStatus(dcgSessionKey, 'finished')
         sendFinal(outboundCtx, 'error')
-        activeRunIdBySessionKey.delete(dcgSessionKey)
+        clearActiveRunIdForSession(dcgSessionKey)
         streamChunkIdxBySessionKey.delete(dcgSessionKey)
-        const suppressed = sessionStreamSuppressed.has(dcgSessionKey)
+        const suppressed = isSessionStreamSuppressed(dcgSessionKey)
         dcgLogger(`${info.kind} reply failed${suppressed ? ' (stream suppressed)' : ''}: ${String(err)}`, 'error')
       },
       onIdle: () => {
@@ -310,11 +331,8 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     let dispatchAbort: AbortController | undefined
     try {
       if (!stopCommand.includes(text?.trim())) {
-        sessionStreamSuppressed.delete(dcgSessionKey)
         streamChunkIdxBySessionKey.set(dcgSessionKey, 0)
-        dispatchAbortBySessionKey.get(dcgSessionKey)?.abort()
-        dispatchAbort = new AbortController()
-        dispatchAbortBySessionKey.set(dcgSessionKey, dispatchAbort)
+        dispatchAbort = await beginSupersedingUserTurn(dcgSessionKey)
       }
 
       if (systemCommand.includes(text?.trim())) {
@@ -332,54 +350,16 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                 abortSignal: dispatchAbort!.signal,
                 onModelSelected: prefixContext.onModelSelected,
                 onAgentRunStart: (runId) => {
-                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                  setActiveRunIdForSession(dcgSessionKey, runId)
                 }
               }
             })
         })
       } else if (stopCommand.includes(text?.trim())) {
-        dcgLogger(`interrupt command: ${text}`)
-        const inFlightAbort = dispatchAbortBySessionKey.get(dcgSessionKey)
-        if (inFlightAbort) {
-          dcgLogger(`interrupt: AbortController.abort() in-process run sessionKey=${dcgSessionKey}`)
-          inFlightAbort.abort()
-          dispatchAbortBySessionKey.delete(dcgSessionKey)
-        }
         const ctxForAbort = priorOutboundCtx.messageId?.trim() || priorOutboundCtx.sessionId?.trim() ? priorOutboundCtx : outboundCtx
-        sendFinal(ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` }, 'abort')
-        sessionStreamSuppressed.add(dcgSessionKey)
-        replyAbortEpochBySessionKey.set(
-          dcgSessionKey,
-          (replyAbortEpochBySessionKey.get(dcgSessionKey) ?? 0) + 1
-        )
-        // 网关侧：子 agent 独立 sessionKey，自深到浅 abort 后再 abort 主会话；主会话有 runId 时带上以便网关侧若有登记可一并取消
-        const descendantKeys = getDescendantSessionKeysForRequester(dcgSessionKey)
-        const abortSubKeys = [...descendantKeys].reverse()
-        if (abortSubKeys.length > 0) {
-          dcgLogger(`interrupt: chat.abort ${abortSubKeys.length} subagent session(s) (nested incl.)`)
-        }
-        for (const subKey of abortSubKeys) {
-          try {
-            await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: subKey } })
-          } catch (e) {
-            dcgLogger(`chat.abort subagent ${subKey}: ${String(e)}`, 'error')
-          }
-        }
-        try {
-          const mainRunId = activeRunIdBySessionKey.get(dcgSessionKey)
-          await sendGatewayRpc({
-            method: 'chat.abort',
-            params: mainRunId
-              ? { sessionKey: dcgSessionKey, runId: mainRunId }
-              : { sessionKey: dcgSessionKey }
-          })
-        } catch (e) {
-          dcgLogger(`chat.abort main ${dcgSessionKey}: ${String(e)}`, 'error')
-        }
-        activeRunIdBySessionKey.delete(dcgSessionKey)
+        await interruptLocalDispatchAndGateway(dcgSessionKey, ctxForAbort)
         streamChunkIdxBySessionKey.delete(dcgSessionKey)
         clearSentMediaKeys(msg.content.message_id)
-        resetSubagentStateForRequesterSession(dcgSessionKey)
         setMsgStatus(dcgSessionKey, 'finished')
         clearParamsMessage(dcgSessionKey)
         sendText('会话已终止', outboundCtx)
@@ -415,10 +395,10 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                 abortSignal: dispatchAbort!.signal,
                 onModelSelected: prefixContext.onModelSelected,
                 onAgentRunStart: (runId) => {
-                  activeRunIdBySessionKey.set(dcgSessionKey, runId)
+                  setActiveRunIdForSession(dcgSessionKey, runId)
                 },
                 onPartialReply: async (payload: ReplyPayload) => {
-                  if (sessionStreamSuppressed.has(dcgSessionKey)) return
+                  if (isSessionStreamSuppressed(dcgSessionKey)) return
 
                   // --- Streaming text chunks ---
                   if (payload.text) {
@@ -456,29 +436,37 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         })
       }
     } catch (err: unknown) {
-      dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
-    } finally {
-      if (dispatchAbort && dispatchAbortBySessionKey.get(dcgSessionKey) === dispatchAbort) {
-        dispatchAbortBySessionKey.delete(dcgSessionKey)
+      dcgLogger(`handleDcgchatMessage error: ${String(err)}`, 'error')
+      if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) === inboundGenAtStart) {
+        setMsgStatus(dcgSessionKey, 'finished')
       }
+    } finally {
+      releaseDispatchAbortIfCurrent(dcgSessionKey, dispatchAbort)
     }
 
-    const replyAbortEpochNow = replyAbortEpochBySessionKey.get(dcgSessionKey) ?? 0
-    if (replyAbortEpochNow !== replyAbortEpochAtStart) {
-      dcgLogger(
-        `skip post-reply tail: sessionKey=${dcgSessionKey} (abort epoch ${replyAbortEpochAtStart}→${replyAbortEpochNow}, stale handler after interrupt)`
-      )
+    const inboundGenNow = inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0
+    if (inboundGenNow !== inboundGenAtStart) {
+      dcgLogger(`skip post-reply tail: sessionKey=${dcgSessionKey} (stale handler: inbound gen ${inboundGenAtStart}→${inboundGenNow})`)
       return
     }
 
     if (![...systemCommand, ...stopCommand].includes(text?.trim())) {
-      if (sessionStreamSuppressed.has(dcgSessionKey)) {
-        sessionStreamSuppressed.delete(dcgSessionKey)
+      if (isSessionStreamSuppressed(dcgSessionKey)) {
+        clearSessionStreamSuppression(dcgSessionKey)
       }
     }
     clearSentMediaKeys(msg.content.message_id)
     const storePath = core.channel.session.resolveStorePath(config.session?.store)
     await waitUntilSubagentsIdle(dcgSessionKey, { timeoutMs: 600_000 })
+    // 等待子 agent 期间可能已有新入站消息（generation 已变），不能再 end/finished，否则会误结束新轮或放行错挂的正文。
+    if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) !== inboundGenAtStart) {
+      dcgLogger(
+        `skip post-wait tail: sessionKey=${dcgSessionKey} (stale handler after subagent wait: inbound gen ${inboundGenAtStart}→${inboundGenerationBySessionKey.get(dcgSessionKey)})`
+      )
+      return
+    }
+    clearActiveRunIdForSession(dcgSessionKey)
+    setMsgStatus(dcgSessionKey, 'finished')
     sendFinal(outboundCtx, 'end')
     dcgLogger(`record session route: updateLastRoute.to=${dcgSessionKey}, accountId=${route.accountId}`)
     core.channel.session
@@ -501,6 +489,9 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       })
   } catch (err) {
     dcgLogger(` handle message failed: ${String(err)}`, 'error')
+    if ((inboundGenerationBySessionKey.get(dcgSessionKey) ?? 0) === inboundGenAtStart) {
+      setMsgStatus(dcgSessionKey, 'finished')
+    }
     sendError(err instanceof Error ? err.message : String(err), outboundCtx)
   }
 }

package/src/channel.ts

@@ -13,6 +13,7 @@ import {
 import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
 import { dcgLogger, setLogger } from './utils/log.js'
 import { getOutboundMsgParams, getParamsMessage } from './utils/params.js'
+import { isSessionActiveForTool } from './tool.js'
 import { startDcgchatGatewaySocket } from './gateway/socket.js'
 import { getCronJobsPath, readCronJob } from './cron.js'
 
@@ -297,6 +298,16 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
         const content: Record<string, unknown> = { response: ctx.text }
         if (!isCron) {
           if (outboundCtx?.sessionId) {
+            // 入站 handler 已将本轮标为 running；若已 sendFinal(end) 则应为 finished。
+            // 否则网关/Core 晚到的正文会仍用「当前 params map」里的 messageId，错挂到后一条用户消息上。
+            if (!isSessionActiveForTool(to)) {
+              dcgLogger(`channel sendText dropped (session not active): to=${to}`)
+              return {
+                channel: "dcgchat-test",
+                messageId: '',
+                chatId: outboundChatId(ctx.to, to)
+              }
+            }
             messageId = outboundCtx?.messageId || `${Date.now()}`
             const newCtx = { ...outboundCtx, messageId }
             wsSendRaw(newCtx, content)

package/src/sessionTermination.ts

@@ -0,0 +1,154 @@
+/**
+ * 会话终止 / 抢占 / 网关 abort 的集中实现，便于单独调整策略与观测。
+ * 与 bot 的 generation、流式分片序号、入站业务上下文分离，仅负责：本地 AbortController、流抑制标记、
+ * 入站串行队尾、activeRunId、chat.abort 子会话→主会话。
+ */
+import { sendGatewayRpc } from './gateway/socket.js'
+import { sendFinal } from './transport.js'
+import type { IMsgParams } from './types.js'
+import { dcgLogger } from './utils/log.js'
+import { getDescendantSessionKeysForRequester, resetSubagentStateForRequesterSession } from './tool.js'
+
+// --- 状态（仅本模块内修改，供 bot 通过下方 API 使用）---
+
+/** 当前会话最近一次 agent run 的 runId（网关 chat.abort 主会话时携带） */
+const activeRunIdBySessionKey = new Map<string, string>()
+
+/** dispatchReplyFromConfig 使用的 AbortSignal，用于真正掐断工具与模型 */
+const dispatchAbortBySessionKey = new Map<string, AbortController>()
+
+/** 打断后抑制 deliver / onPartialReply 继续下发 */
+const sessionStreamSuppressed = new Set<string>()
+
+/**
+ * 同 sessionKey 入站串行队尾；与 Core session lane 对齐，避免并发 dispatch 过早返回。
+ */
+const inboundTurnTailBySessionKey = new Map<string, Promise<void>>()
+
+// --- activeRunId（供 bot 在 onAgentRunStart / 错误收尾时同步）---
+
+export function setActiveRunIdForSession(sessionKey: string, runId: string): void {
+  activeRunIdBySessionKey.set(sessionKey, runId)
+}
+
+export function clearActiveRunIdForSession(sessionKey: string): void {
+  activeRunIdBySessionKey.delete(sessionKey)
+}
+
+// --- 流抑制 ---
+
+export function isSessionStreamSuppressed(sessionKey: string): boolean {
+  return sessionStreamSuppressed.has(sessionKey)
+}
+
+export function clearSessionStreamSuppression(sessionKey: string): void {
+  sessionStreamSuppressed.delete(sessionKey)
+}
+
+export function markSessionStreamSuppressed(sessionKey: string): void {
+  sessionStreamSuppressed.add(sessionKey)
+}
+
+// --- 入站串行队列 ---
+
+/** /stop 入队前：掐断当前 in-process，并重置队尾，使本条 stop 不必等待已被 abort 的长 turn */
+export function preemptInboundQueueForStop(sessionKey: string): void {
+  const c = dispatchAbortBySessionKey.get(sessionKey)
+  if (c) {
+    c.abort()
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+  inboundTurnTailBySessionKey.set(sessionKey, Promise.resolve())
+  dcgLogger(`inbound queue: reset tail for /stop sessionKey=${sessionKey}`)
+}
+
+/** 将本轮入站处理挂到 sessionKey 队尾，保证同会话顺序执行 */
+export async function runInboundTurnSequenced(sessionKey: string, run: () => Promise<void>): Promise<void> {
+  const prev = inboundTurnTailBySessionKey.get(sessionKey) ?? Promise.resolve()
+  const next = prev.catch(() => {}).then(run)
+  inboundTurnTailBySessionKey.set(sessionKey, next.catch(() => {}))
+  await next
+}
+
+// --- 网关 abort ---
+
+/**
+ * 终止网关上仍可能活跃的 run（子会话自深到浅，再主会话）。
+ * supersede：仅当有子会话或 mainRunId 时发 RPC；interrupt：主会话始终 chat.abort。
+ */
+export async function abortGatewayRunsForSession(sessionKey: string, reason: 'interrupt' | 'supersede'): Promise<void> {
+  const prefix = reason === 'interrupt' ? 'interrupt' : 'supersede'
+  const descendantKeys = getDescendantSessionKeysForRequester(sessionKey)
+  const abortSubKeys = [...descendantKeys].reverse()
+  const mainRunId = activeRunIdBySessionKey.get(sessionKey)
+
+  if (reason === 'supersede' && abortSubKeys.length === 0 && !mainRunId) {
+    return
+  }
+
+  if (abortSubKeys.length > 0) {
+    dcgLogger(`${prefix}: chat.abort ${abortSubKeys.length} subagent session(s) (nested incl.)`)
+  }
+  for (const subKey of abortSubKeys) {
+    try {
+      await sendGatewayRpc({ method: 'chat.abort', params: { sessionKey: subKey } })
+    } catch (e) {
+      dcgLogger(`${prefix}: chat.abort subagent ${subKey}: ${String(e)}`, 'error')
+    }
+  }
+
+  const shouldMainAbort = reason === 'interrupt' || Boolean(mainRunId)
+  if (shouldMainAbort) {
+    try {
+      await sendGatewayRpc({
+        method: 'chat.abort',
+        params: mainRunId ? { sessionKey, runId: mainRunId } : { sessionKey }
+      })
+    } catch (e) {
+      dcgLogger(`${prefix}: chat.abort main ${sessionKey}: ${String(e)}`, 'error')
+    }
+  }
+
+  activeRunIdBySessionKey.delete(sessionKey)
+  resetSubagentStateForRequesterSession(sessionKey)
+}
+
+// --- 本地 dispatch AbortController ---
+
+/**
+ * 新一轮非 /stop 用户消息：清除流抑制、abort 上一轮 controller、网关 supersede，并安装新的 AbortController。
+ * 调用方须在之前或之后自行 `streamChunkIdxBySessionKey.set(sessionKey, 0)`。
+ */
+export async function beginSupersedingUserTurn(sessionKey: string): Promise<AbortController> {
+  sessionStreamSuppressed.delete(sessionKey)
+  dispatchAbortBySessionKey.get(sessionKey)?.abort()
+  await abortGatewayRunsForSession(sessionKey, 'supersede')
+  const ac = new AbortController()
+  dispatchAbortBySessionKey.set(sessionKey, ac)
+  return ac
+}
+
+/** try/finally 中：仅当仍是当前 controller 时从 map 移除 */
+export function releaseDispatchAbortIfCurrent(sessionKey: string, controller: AbortController | undefined): void {
+  if (controller && dispatchAbortBySessionKey.get(sessionKey) === controller) {
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+}
+
+/**
+ * 用户发送 /stop：本地 abort、对「上一轮对话」发 abort final、标记流抑制、网关 interrupt。
+ * 之后的 clearSentMedia、params、UI「已终止」等由 bot 继续处理。
+ */
+export async function interruptLocalDispatchAndGateway(sessionKey: string, ctxForAbort: IMsgParams): Promise<void> {
+  dcgLogger(`interrupt command: sessionKey=${sessionKey}`)
+  const inFlight = dispatchAbortBySessionKey.get(sessionKey)
+  if (inFlight) {
+    dcgLogger(`interrupt: AbortController.abort() in-process run sessionKey=${sessionKey}`)
+    inFlight.abort()
+    dispatchAbortBySessionKey.delete(sessionKey)
+  }
+  const finalCtx = ctxForAbort.messageId?.trim() ? ctxForAbort : { ...ctxForAbort, messageId: `${Date.now()}` }
+  sendFinal(finalCtx, 'abort')
+  markSessionStreamSuppressed(sessionKey)
+  await abortGatewayRunsForSession(sessionKey, 'interrupt')
+}

package/src/tool.ts

@@ -65,7 +65,7 @@ function resolveOutboundParamsForSession(sk: string) {
 }
 
 /** 主会话已 running 时，子会话上的工具/事件也应下发（否则子 key 无 running 状态会整段丢消息） */
-function isSessionActiveForTool(sk: string): boolean {
+export function isSessionActiveForTool(sk: string): boolean {
   const k = sk.trim()
   if (!k) return false
   if (getMsgStatus(k) === 'running') return true