@dcrays/dcgchat-test 0.3.2 → 0.3.4

package/package.json

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

package/src/bot.ts

@@ -3,13 +3,20 @@ import path from 'node:path'
 import type { ReplyPayload } from 'openclaw/plugin-sdk'
 import { createReplyPrefixContext } from 'openclaw/plugin-sdk'
 import type { InboundMessage } from './types.js'
-import { clearSentMediaKeys, getDcgchatRuntime, getOpenClawConfig, getWorkspaceDir, setMsgStatus } from './utils/global.js'
+import {
+  clearSentMediaKeys,
+  getDcgchatRuntime,
+  getOpenClawConfig,
+  getSessionKey,
+  getWorkspaceDir,
+  setMsgStatus
+} 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 } from './transport.js'
+import { sendChunk, sendFinal, sendText as sendTextMsg, sendError, wsSendRaw, sendText } from './transport.js'
 import { dcgLogger } from './utils/log.js'
-import { channelInfo, systemCommand, interruptCommand, ENV } from './utils/constant.js'
+import { channelInfo, systemCommand, interruptCommand, ENV, ignoreToolCommand } from './utils/constant.js'
 import { sendMessageToGateway } from './gateway/socket.js'
 import { getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
 
@@ -24,6 +31,18 @@ type TFileInfo = { name: string; url: string }
 
 const mediaMaxBytes = 300 * 1024 * 1024
 
+/** 当前会话最近一次 agent run 的 runId（供 chat.abort 精确打断；无则仅传 sessionKey 仍会中止该会话全部活动运行） */
+const activeRunIdBySessionKey = new Map<string, string>()
+
+/**
+ * 用户在该 sessionKey 上触发打断后，旧 run 的流式/投递不再下发；与 sessionKey 一一对应，支持多会话。
+ * 清除时机：① 下一条非打断用户消息开始处理时；② 旧 run 收尾到 mobook 段时若仍抑制则跳过并发后删除。
+ */
+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>()
 
@@ -144,8 +163,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
 
   const effectiveAgentId = embeddedAgentId ?? route.agentId
-  const effectiveSessionKey =
-    real_mobook === '1' ? route.sessionKey : `agent:main:mobook:direct:${agentId}:${conversationId}`.toLowerCase()
+  const effectiveSessionKey = getSessionKey(msg.content, account.accountId)
 
   setParamsMessage(effectiveSessionKey, {
     userId: msg._userId,
@@ -168,6 +186,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
     if (finalSent) return
     finalSent = true
     sendFinal(outboundCtx)
+    setMsgStatus(effectiveSessionKey, 'finished')
   }
 
   const text = msg.content.text?.trim()
@@ -209,7 +228,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       RawBody: text,
       CommandBody: text,
       From: userId,
-      To: conversationId,
+      To: effectiveSessionKey,
       SessionKey: effectiveSessionKey,
       AccountId: route.accountId,
       ChatType: 'direct',
@@ -222,7 +241,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       WasMentioned: true,
       CommandAuthorized: true,
       OriginatingChannel: "dcgchat-test",
-      OriginatingTo: `user:${userId}`,
+      OriginatingTo: effectiveSessionKey,
       ...mediaPayload
     })
 
@@ -243,6 +262,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(effectiveSessionKey)) return
         const mediaList = resolveReplyMediaList(payload)
         for (const mediaUrl of mediaList) {
           const key = getMediaKey(mediaUrl)
@@ -252,15 +272,29 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         }
       },
       onError: (err: unknown, info: { kind: string }) => {
+        activeRunIdBySessionKey.delete(effectiveSessionKey)
+        streamChunkIdxBySessionKey.delete(effectiveSessionKey)
+        if (sessionStreamSuppressed.has(effectiveSessionKey)) {
+          dcgLogger(`${info.kind} reply failed (stream suppressed): ${String(err)}`, 'error')
+          return
+        }
         safeSendFinal()
         dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
       },
       onIdle: () => {
+        activeRunIdBySessionKey.delete(effectiveSessionKey)
+        streamChunkIdxBySessionKey.delete(effectiveSessionKey)
+        if (sessionStreamSuppressed.has(effectiveSessionKey)) return
         safeSendFinal()
       }
     })
 
     try {
+      if (!interruptCommand.includes(text?.trim())) {
+        sessionStreamSuppressed.delete(effectiveSessionKey)
+        streamChunkIdxBySessionKey.set(effectiveSessionKey, 0)
+      }
+
       if (systemCommand.includes(text?.trim())) {
         dcgLogger(`dispatching /new`)
         await core.channel.reply.dispatchReplyFromConfig({
@@ -269,21 +303,48 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
           dispatcher,
           replyOptions: {
             ...replyOptions,
-            onModelSelected: prefixContext.onModelSelected
+            onModelSelected: prefixContext.onModelSelected,
+            onAgentRunStart: (runId) => {
+              activeRunIdBySessionKey.set(effectiveSessionKey, runId)
+            }
           }
         })
       } else if (interruptCommand.includes(text?.trim())) {
         dcgLogger(`interrupt command: ${text}`)
+        sendText('会话已终止', outboundCtx)
+        safeSendFinal()
+        sessionStreamSuppressed.add(effectiveSessionKey)
+        const runId = activeRunIdBySessionKey.get(effectiveSessionKey)
         sendMessageToGateway(
           JSON.stringify({
             method: 'chat.abort',
-            params: { sessionKey: effectiveSessionKey }
+            params: {
+              sessionKey: effectiveSessionKey,
+              ...(runId ? { runId } : {})
+            }
           })
         )
-        safeSendFinal()
+        if (runId) activeRunIdBySessionKey.delete(effectiveSessionKey)
         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(),
+            is_cover: 0,
+            thinking_content: JSON.stringify({
+              type: 'message_received',
+              specialIdentification: 'dcgchat_tool_call_special_identification',
+              toolName: '',
+              callId: Date.now().toString(),
+              params: ''
+            }),
+            response: ''
+          })
+        }
         await core.channel.reply.dispatchReplyFromConfig({
           ctx: ctxPayload,
           cfg: config,
@@ -292,7 +353,12 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
             ...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
@@ -303,8 +369,10 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                   ? payload.text.slice(streamedTextLen)
                   : payload.text
                 if (delta.trim()) {
-                  sendChunk(delta, outboundCtx)
-                  dcgLogger(`[stream]: chunk ${delta.length} chars to user ${msg._userId} ${delta.slice(0, 100)}`)
+                  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
               }
@@ -342,28 +410,31 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       dcgLogger(` markRunComplete||markRunComplete error: ${String(err)}`, 'error')
     }
     if (![...systemCommand, ...interruptCommand].includes(text?.trim())) {
-      for (const file of extractMobookFiles(completeText)) {
-        const candidates: string[] = [file]
-        candidates.push(path.join(getWorkspaceDir(), file))
-        candidates.push(path.join(getWorkspaceDir(), file.replace(/^\//, '')))
-        if (process.platform === 'win32') {
-          const underMobook = file.replace(/^\/mobook\//i, '').replace(/^mobook[\\/]/i, '')
-          if (underMobook) {
-            candidates.push(path.join('C:\\', 'mobook', underMobook))
+      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(/^\//, '')))
+          if (process.platform === 'win32') {
+            const underMobook = file.replace(/^\/mobook\//i, '').replace(/^mobook[\\/]/i, '')
+            if (underMobook) {
+              candidates.push(path.join('C:\\', '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')
           }
-        }
-        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')
         }
       }
     }
     safeSendFinal()
     clearSentMediaKeys(msg.content.message_id)
-    setMsgStatus('finished')
 
     // Record session metadata
     const storePath = core.channel.session.resolveStorePath(config.session?.store)

package/src/channel.ts

@@ -2,10 +2,10 @@ import type { ChannelPlugin, OpenClawConfig } from 'openclaw/plugin-sdk'
 import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
 import type { ResolvedDcgchatAccount, DcgchatConfig } from './types.js'
 import { ossUpload } from './request/oss.js'
-import { addSentMediaKey, getOpenClawConfig, hasSentMediaKey } from './utils/global.js'
+import { addSentMediaKey, getCronMessageId, getOpenClawConfig, hasSentMediaKey } from './utils/global.js'
 import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
 import { dcgLogger, setLogger } from './utils/log.js'
-import { getParamsDefaults, getEffectiveMsgParams, getCurrentSessionKey } from './utils/params.js'
+import { getEffectiveMsgParams, getCurrentSessionKey } from './utils/params.js'
 import { startDcgchatGatewaySocket } from './gateway/socket.js'
 
 export type DcgchatMediaSendOptions = {
@@ -143,13 +143,23 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
     textChunkLimit: 4000,
     sendText: async (ctx) => {
       if (isWsOpen()) {
-        const merged = mergeDefaultParams({
-          agentId: ctx.accountId ?? '',
-          sessionId: ctx.to,
-          messageId: `${Date.now()}`
-        })
-        wsSendRaw(merged, { response: ctx.text })
-        sendFinal(merged)
+        // if (ctx.to.indexOf('cron:') >= 0) {
+        //   const sessionInfo = ctx.to.split(':')[1]
+        //   const sessionId = sessionInfo.split('-')[0]
+        //   const agentId = sessionInfo.split('-')[1]
+        //   const merged = mergeDefaultParams({
+        //     agentId: agentId,
+        //     sessionId: sessionId,
+        //     messageId: `${Date.now()}`,
+        //     is_finish: -1
+        //   })
+        //   wsSendRaw(merged, { response: ctx.text })
+        // } else {
+        // }
+        const outboundCtx = getEffectiveMsgParams(ctx.to)
+        const messageId = getCronMessageId(ctx.to)
+        const newCtx = messageId ? { ...outboundCtx, messageId } : outboundCtx
+        wsSendRaw(newCtx, { response: ctx.text, is_finish: -1 })
         dcgLogger(`channel sendText to ${ctx.to} ${ctx.text?.slice(0, 50)}`)
       }
       return {

package/src/cron.ts

@@ -1,17 +1,11 @@
 import path from 'node:path'
 import fs from 'node:fs'
-import crypto from 'node:crypto'
-import { execFile } from 'node:child_process'
-import { promisify } from 'node:util'
-
-const execFileAsync = promisify(execFile)
 import type { IMsgParams } from './types.js'
-import { sendEventMessage } from './transport.js'
-import { getWorkspaceDir } from './utils/global.js'
+import { sendEventMessage, sendFinal } from './transport.js'
+import { getWorkspaceDir, removeCronMessageId, setCronMessageId, setMsgStatus } from './utils/global.js'
 import { ossUpload } from './request/oss.js'
 import { dcgLogger } from './utils/log.js'
 import { sendMessageToGateway } from './gateway/socket.js'
-import { channelInfo, ENV } from './utils/constant.js'
 import { getCurrentSessionKey, getEffectiveMsgParams } from './utils/params.js'
 
 export function getCronJobsPath(): string {
@@ -20,6 +14,33 @@ export function getCronJobsPath(): string {
   return path.join(cronDir, 'jobs.json')
 }
 
+type CronJobsFile = {
+  version?: number
+  jobs?: Array<{ id?: string; sessionKey?: string }>
+}
+
+/**
+ * 在 `jobPath` 指向的 jobs.json（通常为 getCronJobsPath()）中按 id 查找任务并返回其 sessionKey。
+ */
+export function readCronJobSessionKey(jobPath: string, jobId: string): string | null {
+  const id = jobId?.trim()
+  if (!id) return null
+  if (!fs.existsSync(jobPath)) {
+    dcgLogger(`readCronJobSessionKey: file not found ${jobPath}`, 'error')
+    return null
+  }
+  try {
+    const raw = fs.readFileSync(jobPath, 'utf8')
+    const data = JSON.parse(raw) as CronJobsFile
+    const job = (data.jobs ?? []).find((j) => j.id === id)
+    const sk = job?.sessionKey?.trim()
+    return sk || null
+  } catch (e) {
+    dcgLogger(`readCronJobSessionKey: failed to read ${jobPath}: ${String(e)}`, 'error')
+    return null
+  }
+}
+
 function msgParamsToCtx(p: IMsgParams): IMsgParams | null {
   if (!p?.botToken) return null
   return p
@@ -103,36 +124,35 @@ export const onEnabledCronJob = async (jobId: string) => {
   }
   sendMessageToGateway(JSON.stringify({ method: 'cron.update', params: { id: jobId, patch: { enabled: true } } }))
 }
-export const onRunCronJob = async (jobId: string) => {
+export const onRunCronJob = async (jobId: string, messageId: string) => {
   const id = jobId?.trim()
   if (!id) {
     dcgLogger('onRemoveCronJob: empty jobId', 'error')
     return
   }
-  sendMessageToGateway(JSON.stringify({ method: 'cron.update', jobId }))
+  const jobPath = getCronJobsPath()
+  const sessionKey = readCronJobSessionKey(jobPath, jobId) || ''
+  if (!sessionKey) {
+    dcgLogger(`finishedDcgchatCron: no sessionKey for job id=${id}`, 'error')
+    return
+  }
+  setCronMessageId(sessionKey, messageId)
+  sendMessageToGateway(JSON.stringify({ method: 'cron.run', params: { id: jobId } }))
 }
-export const updateCronJobSessionKey = async (jobId: string) => {
+export const finishedDcgchatCron = async (jobId: string) => {
   const id = jobId?.trim()
   if (!id) {
-    dcgLogger('onRemoveCronJob: empty jobId', 'error')
+    dcgLogger('finishedDcgchatCron: empty jobId', 'error')
     return
   }
-  const params = getEffectiveMsgParams(getCurrentSessionKey() ?? '')
-  sendMessageToGateway(
-    JSON.stringify({
-      method: 'cron.update',
-      params: {
-        id: jobId,
-        patch: {
-          sessionKey: params.sessionKey,
-          delivery: {
-            channel: "dcgchat-test",
-            to: params.sessionId,
-            accountId: 14,
-            bestEffort: true
-          }
-        }
-      }
-    })
-  )
+  const jobPath = getCronJobsPath()
+  const sessionKey = readCronJobSessionKey(jobPath, id)
+  if (!sessionKey) {
+    dcgLogger(`finishedDcgchatCron: no sessionKey for job id=${id}`, 'error')
+    return
+  }
+  const outboundCtx = getEffectiveMsgParams(sessionKey)
+  sendFinal(outboundCtx)
+  removeCronMessageId(sessionKey)
+  dcgLogger(`finishedDcgchatCron: job=${id} sessionKey=${sessionKey}`)
 }

package/src/cronToolCall.ts

@@ -0,0 +1,185 @@
+import { channelInfo, ENV } from './utils/constant.js'
+/**
+ * cron-delivery-guard — 定时任务投递守护插件
+ *
+ * 核心机制：通过 before_tool_call 钩子拦截 cron 工具调用，
+ * 当 delivery.mode 为 "announce" 且未指定 channel 时，
+ * 自动注入 bestEffort: true，使投递失败时静默降级，
+ * 不影响 cron 执行结果的保存。
+ *
+ * 背景：
+ * - 定时任务的 delivery 设为 announce 模式，如果没有指定 channel，
+ *   投递可能因找不到有效渠道而失败
+ * - bestEffort: true 让框架在投递失败时不报错，避免丢失执行结果
+ */
+
+import { dcgLogger } from './utils/log.js'
+
+const LOG_TAG = 'cron-delivery-guard'
+
+// ---- 类型定义 ----
+
+interface ToolCallEvent {
+  toolName: string
+  toolCallId: string
+  params: Record<string, unknown>
+  result?: { content: string }
+}
+
+interface HookContext {
+  agentId: string
+  sessionKey: string
+}
+
+interface BeforeToolCallResult {
+  block?: boolean
+  blockReason?: string
+  params?: Record<string, unknown>
+}
+
+// ---- delivery 类型 ----
+
+interface CronDelivery {
+  mode?: string
+  channel?: string
+  to?: string
+  bestEffort?: boolean
+  [key: string]: unknown
+}
+/**
+ * 解析 OpenClaw mobook direct 会话 key。
+ * 形如 `agent:main:mobook:direct:14:5466`（大小写不敏感，与路由 toLowerCase 一致）
+ * - 倒数第二段：account / peer（delivery.accountId）
+ * - 最后一段：会话 id（delivery.to）
+ */
+export function formatterSessionKey(sessionKey: string): { agentId: string; sessionId: string } {
+  const parts = sessionKey.split(':').filter((s) => s.length > 0)
+  const norm = parts.map((s) => s.toLowerCase())
+  if (parts.length >= 6 && norm[0] === 'agent' && norm[2] === 'mobook' && norm[3] === 'direct') {
+    return {
+      agentId: parts[4] ?? '',
+      sessionId: parts[5] ?? ''
+    }
+  }
+  if (parts.length >= 2) {
+    return {
+      agentId: parts[parts.length - 2] ?? '',
+      sessionId: parts[parts.length - 1] ?? ''
+    }
+  }
+  return { agentId: '', sessionId: '' }
+}
+
+// ---- 辅助函数 ----
+
+/**
+ * 判断是否为 cron 工具调用
+ */
+function isCronTool(toolName: string): boolean {
+  return toolName === 'cron'
+}
+
+/**
+ * 从 cron 参数中提取 delivery 配置
+ * cron 工具的参数结构可能是:
+ * - params.delivery (顶层)
+ * - params.job.delivery (嵌套在 job 中)
+ */
+function extractDelivery(params: Record<string, unknown>): CronDelivery | null {
+  // 尝试顶层 delivery
+  if (params.delivery && typeof params.delivery === 'object') {
+    return params.delivery as CronDelivery
+  }
+
+  // 尝试 job.delivery
+  const job = params.job as Record<string, unknown> | undefined
+  if (job?.delivery && typeof job.delivery === 'object') {
+    return job.delivery as CronDelivery
+  }
+
+  // 尝试 payload 中的 deliver 相关字段 (兼容 qqbot-cron 风格)
+  const payload = job?.payload as Record<string, unknown> | undefined
+  if (payload?.deliver === true && payload.channel === undefined) {
+    // payload 风格: { deliver: true, channel?: string }
+    // 这种情况不是 delivery 对象，跳过
+    return null
+  }
+
+  return null
+}
+
+/**
+ * 判断 delivery 是否需要注入 bestEffort
+ * 条件: mode 为 "announce" 且没有 channel
+ */
+function needsBestEffort(delivery: CronDelivery): boolean {
+  return delivery.mode === 'announce' && !delivery.channel && !delivery.bestEffort
+}
+
+/**
+ * 深拷贝 params 并注入 bestEffort: true
+ */
+function injectBestEffort(params: Record<string, unknown>, sk: string): Record<string, unknown> {
+  const newParams = JSON.parse(JSON.stringify(params)) as Record<string, unknown>
+  const { agentId, sessionId } = formatterSessionKey(sk)
+  // 顶层 delivery
+  if (newParams.delivery && typeof newParams.delivery === 'object') {
+    ;(newParams.delivery as CronDelivery).bestEffort = true
+    ;(newParams.delivery as CronDelivery).to = sessionId
+    ;(newParams.delivery as CronDelivery).accountId = agentId
+    ;(newParams.delivery as CronDelivery).channel = "dcgchat-test"
+    newParams.sessionKey = sk
+    return newParams
+  }
+
+  // job.delivery
+  const job = newParams.job as Record<string, unknown> | undefined
+  if (job?.delivery && typeof job.delivery === 'object') {
+    ;(job.delivery as CronDelivery).bestEffort = true
+    ;(newParams.delivery as CronDelivery).to = sessionId
+    ;(newParams.delivery as CronDelivery).accountId = agentId
+    ;(newParams.delivery as CronDelivery).channel = "dcgchat-test"
+    newParams.sessionKey = sk
+    return newParams
+  }
+
+  return newParams
+}
+
+export function cronToolCall(event: { toolName: any; params: any; toolCallId: any }, sk: string) {
+  const { toolName, params, toolCallId } = event
+
+  // 仅处理 cron 工具
+  if (isCronTool(toolName)) {
+    const delivery = extractDelivery(params)
+    if (!delivery) {
+      dcgLogger(`[${LOG_TAG}] cron call (${toolCallId}) has no delivery config, skip.`)
+      return undefined
+    }
+    if (!needsBestEffort(delivery)) {
+      dcgLogger(
+        `[${LOG_TAG}] cron call (${toolCallId}) delivery does not need bestEffort ` +
+          `(mode=${String(delivery.mode)}, channel=${String(delivery.channel)}, bestEffort=${String(delivery.bestEffort)}), skip.`
+      )
+      return undefined
+    }
+
+    // ★ 核心：注入 bestEffort: true
+    const newParams = injectBestEffort(params, sk)
+    dcgLogger(
+      `[${LOG_TAG}] cron call (${toolCallId}) injected bestEffort=true ` +
+        `(mode=announce, no channel). delivery=${JSON.stringify(newParams.delivery || (newParams.job as Record<string, unknown>)?.delivery)}`
+    )
+
+    return { params: newParams }
+  } else if (toolName === 'exec') {
+    if (params.command.indexOf('cron create') || params.command.indexOf('cron add')) {
+      const newParams = JSON.parse(JSON.stringify(params)) as Record<string, unknown>
+      newParams.command =
+        params.command.replace('--json', '') + `  --session-key ${sk}  --channel ${"dcgchat-test"}  --to ${sk} --json`
+      return { params: newParams }
+    }
+  }
+
+  return undefined
+}

package/src/gateway/index.ts

@@ -3,7 +3,7 @@ import { WebSocket } from 'ws'
 import crypto from 'crypto'
 import { deriveDeviceIdFromPublicKey, publicKeyRawBase64UrlFromPem, buildDeviceAuthPayloadV3, signDevicePayload } from './security.js'
 import { dcgLogger } from '../utils/log.js'
-import { sendDcgchatCron, updateCronJobSessionKey } from '../cron.js'
+import { finishedDcgchatCron, sendDcgchatCron } from '../cron.js'
 
 export interface GatewayEvent {
   type: string
@@ -196,7 +196,7 @@ export class GatewayConnection {
         dcgLogger('Gateway connection opened（等待 connect.challenge）')
       })
 
-      this.ws.on('message', (data) => {
+      this.ws.on('message', (data, ...args) => {
         try {
           const msg = JSON.parse(data.toString())
           this.handleMessage(
@@ -357,20 +357,18 @@ export class GatewayConnection {
 
     if (msg.type === 'event') {
       try {
+        // 定时任务相关事件
         if (msg.event === 'cron') {
           dcgLogger(`[Gateway] 收到事件: ${JSON.stringify(msg)}`)
           if (msg.payload?.action === 'added') {
-            updateCronJobSessionKey(msg.payload?.jobId as string)
-          }
-          if (msg.payload?.action === 'updated') {
             sendDcgchatCron()
           }
-          if (msg.payload?.action === 'added') {
-            updateCronJobSessionKey(msg.payload?.jobId as string)
-          }
           if (msg.payload?.action === 'updated') {
             sendDcgchatCron()
           }
+          if (msg.payload?.action === 'finished') {
+            finishedDcgchatCron(msg.payload?.jobId as string)
+          }
         }
       } catch (error) {
         dcgLogger(`[Gateway] 处理事件失败: ${error}`, 'error')

package/src/gateway/socket.ts

@@ -230,10 +230,8 @@ export function startDcgchatGatewaySocket(): void {
   socketStopped = false
   clearReconnectTimer()
   if (startupConnectTimer != null) return
-  startupConnectTimer = setTimeout(() => {
-    startupConnectTimer = null
-    void connectPersistentGateway()
-  }, 10000)
+  startupConnectTimer = null
+  void connectPersistentGateway()
 }
 
 /**

package/src/monitor.ts

@@ -2,12 +2,12 @@ import type { ClawdbotConfig, RuntimeEnv } from 'openclaw/plugin-sdk'
 import WebSocket from 'ws'
 import { handleDcgchatMessage } from './bot.js'
 import { resolveAccount } from './channel.js'
-import { setWsConnection, getOpenClawConfig, setMsgStatus } from './utils/global.js'
+import { setWsConnection, getOpenClawConfig, setMsgStatus, getSessionKey } from './utils/global.js'
 import type { InboundMessage } from './types.js'
 import { installSkill, uninstallSkill } from './skill.js'
 import { dcgLogger } from './utils/log.js'
-import { ignoreToolCommand } from './utils/constant.js'
 import { onDisabledCronJob, onEnabledCronJob, onRemoveCronJob, onRunCronJob } from './cron.js'
+import { ignoreToolCommand } from './utils/constant.js'
 
 export type MonitorDcgchatOpts = {
   config?: ClawdbotConfig
@@ -126,10 +126,13 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
 
       if (parsed.messageType == 'openclaw_bot_chat') {
         const msg = parsed as unknown as InboundMessage
-        if (!ignoreToolCommand.includes(msg.content.text?.trim())) {
-          setMsgStatus('running')
+        // 与 monitor 原逻辑一致：工具类指令不进入 running，避免误触工具链监控
+        const effectiveSessionKey = getSessionKey(msg.content, account.accountId)
+        if (!ignoreToolCommand.includes(msg.content.text?.trim() ?? '')) {
+          setMsgStatus(effectiveSessionKey, 'running')
+        } else {
+          setMsgStatus(effectiveSessionKey, 'finished')
         }
-
         await handleDcgchatMessage(msg, account.accountId)
       } else if (parsed.messageType == 'openclaw_bot_event') {
         const { event_type, operation_type } = parsed.content ? parsed.content : ({} as Record<string, any>)
@@ -152,15 +155,15 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
             dcgLogger(`openclaw_bot_event unknown event_type: ${event_type}, ${data.toString()}`)
           }
         } else if (event_type === 'cron') {
-          const { job_id } = parsed.content
+          const { job_id, message_id } = parsed.content
           if (operation_type === 'remove') {
             await onRemoveCronJob(job_id)
           } else if (operation_type === 'enable') {
             await onEnabledCronJob(job_id)
           } else if (operation_type === 'disable') {
             await onDisabledCronJob(job_id)
-          } else if (operation_type === 'exec') {
-            await onRunCronJob(job_id)
+          } else if (operation_type === 'run') {
+            await onRunCronJob(job_id, message_id)
           }
         } else {
           dcgLogger(`openclaw_bot_event unknown operation_type: ${operation_type}, ${data.toString()}`)

package/src/tool.ts

@@ -1,8 +1,10 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { getMsgStatus, getWsConnection } from './utils/global.js'
+import { getMsgStatus } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
-import { isWsOpen, sendFinal, sendText } from './transport.js'
+import { sendFinal, sendText, wsSendRaw } from './transport.js'
 import { getCurrentSessionKey, getEffectiveMsgParams } from './utils/params.js'
+import { channelInfo, ENV } from './utils/constant.js'
+import { cronToolCall } from './cronToolCall.js'
 
 let toolCallId = ''
 let toolName = ''
@@ -31,8 +33,10 @@ type PluginHookName =
   | 'subagent_ended'
   | 'gateway_start'
   | 'gateway_stop'
+
+// message_received 没有 sessionKey 前置到bot中执行
 const eventList = [
-  { event: 'message_received', message: '' },
+  // { event: 'message_received', message: '' },
   // {event: 'before_model_resolve', message: ''},
   // {event: 'before_prompt_build', message: '正在查阅背景资料，构建思考逻辑'},
   // {event: 'before_agent_start', message: '书灵墨宝已就位，准备开始执行任务'},
@@ -50,75 +54,78 @@ const eventList = [
   { event: 'after_tool_call', message: '' }
 ]
 
-function sendToolCallMessage(text: string, toolCallId: string, isCover: number) {
-  const ws = getWsConnection()
-  const sk = getCurrentSessionKey()
-  if (!sk) return
+function sendToolCallMessage(sk: string, text: string, toolCallId: string, isCover: number) {
   const params = getEffectiveMsgParams(sk)
-  if (isWsOpen()) {
-    ws?.send(
-      JSON.stringify({
-        messageType: 'openclaw_bot_chat',
-        _userId: params?.userId,
-        source: 'client',
-        is_finish: -1,
-        content: {
-          is_finish: -1,
-          bot_token: params?.botToken,
-          domain_id: params?.domainId,
-          app_id: params?.appId,
-          bot_id: params?.botId,
-          agent_id: params?.agentId,
-          tool_call_id: toolCallId,
-          is_cover: isCover,
-          thinking_content: text,
-          response: '',
-          session_id: params?.sessionId,
-          message_id: params?.messageId || Date.now().toString()
-        }
-      })
-    )
-  }
+  wsSendRaw(params, {
+    is_finish: -1,
+    tool_call_id: toolCallId,
+    is_cover: isCover,
+    thinking_content: text,
+    response: ''
+  })
+}
+
+/**
+ * 深拷贝 params 并注入 bestEffort: true
+ */
+interface CronDelivery {
+  mode?: string
+  channel?: string
+  to?: string
+  bestEffort?: boolean
+  [key: string]: unknown
 }
 
 export function monitoringToolMessage(api: OpenClawPluginApi) {
   for (const item of eventList) {
     api.on(item.event as PluginHookName, (event: any, args: any) => {
-      const status = getMsgStatus()
-      if (status === 'running') {
-        if (['after_tool_call', 'before_tool_call'].includes(item.event)) {
-          const { result: _result, ...rest } = event
-          dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}`)
-          const text = JSON.stringify({
-            type: item.event,
-            specialIdentification: 'dcgchat_tool_call_special_identification',
-            callId: event.toolCallId || event.runId || Date.now().toString(),
-            ...rest,
-            status: item.event === 'after_tool_call' ? 'finished' : 'running'
-          })
-          sendToolCallMessage(text, event.toolCallId || event.runId || Date.now().toString(), item.event === 'after_tool_call' ? 1 : 0)
-        } else if (item.event) {
-          dcgLogger(`工具调用结果： ~ event:${item.event}`)
-          if (item.event === 'llm_output') {
-            if (event.lastAssistant?.errorMessage === '429-账户额度耗尽') {
-              const message = '您的积分已消耗完，您可以通过充值积分来继续使用'
-              const sk = ((args?.sessionKey as string | undefined) ?? getCurrentSessionKey()) || ''
-              if (!sk) return
-              const msgCtx = getEffectiveMsgParams(sk)
-              sendText(message, msgCtx, { message_tags: { insufficient_balance: 1 }, is_finish: -1 })
-              sendFinal(msgCtx)
-              return
+      const sk = args?.sessionKey as string
+      if (sk) {
+        const status = getMsgStatus(sk)
+        if (status === 'running') {
+          if (['after_tool_call', 'before_tool_call'].includes(item.event)) {
+            const { result: _result, ...rest } = event
+            dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}`)
+
+            if (item.event === 'before_tool_call') {
+              return cronToolCall(rest, sk)
+            }
+            const text = JSON.stringify({
+              type: item.event,
+              specialIdentification: 'dcgchat_tool_call_special_identification',
+              callId: event.toolCallId || event.runId || Date.now().toString(),
+              ...rest,
+              status: item.event === 'after_tool_call' ? 'finished' : 'running'
+            })
+            sendToolCallMessage(
+              sk,
+              text,
+              event.toolCallId || event.runId || Date.now().toString(),
+              item.event === 'after_tool_call' ? 1 : 0
+            )
+          } else if (item.event) {
+            const msgCtx = getEffectiveMsgParams(sk)
+            if (item.event === 'llm_output') {
+              if (event.lastAssistant?.errorMessage === '429-账户额度耗尽') {
+                const message = '您的积分已消耗完，您可以通过充值积分来继续使用'
+                sendText(message, msgCtx, { message_tags: { insufficient_balance: 1 }, is_finish: -1 })
+                sendFinal(msgCtx)
+                return
+              }
             }
+            const text = JSON.stringify({
+              type: item.event,
+              specialIdentification: 'dcgchat_tool_call_special_identification',
+              toolName: '',
+              callId: event.runId || Date.now().toString(),
+              params: item.message
+            })
+            sendToolCallMessage(sk, text, event.runId || Date.now().toString(), 0)
+            dcgLogger(`工具调用结果： ~ event:${item.event} ${status}`)
           }
-          const text = JSON.stringify({
-            type: item.event,
-            specialIdentification: 'dcgchat_tool_call_special_identification',
-            toolName: '',
-            callId: event.runId || Date.now().toString(),
-            params: item.message
-          })
-          sendToolCallMessage(text, event.runId || Date.now().toString(), 0)
         }
+      } else {
+        dcgLogger(`工具调用结果： ~ event:${item.event} ~ 没有sessionKey 为执行`)
       }
     })
   }

package/src/transport.ts

@@ -158,8 +158,8 @@ export function wsSendRaw(ctx: IMsgParams, content: Record<string, unknown>): bo
   return true
 }
 
-export function sendChunk(text: string, ctx: IMsgParams): boolean {
-  return wsSend(ctx, { response: text, state: 'chunk' })
+export function sendChunk(text: string, ctx: IMsgParams, chunkIdx: number): boolean {
+  return wsSend(ctx, { response: text, state: 'chunk', chunk_idx: chunkIdx })
 }
 
 export function sendFinal(ctx: IMsgParams): boolean {

package/src/types.ts

@@ -127,4 +127,5 @@ export interface IMsgParams {
   /** 与 OpenClaw 路由一致，用于 map 与异步链路（工具 / HTTP / cron）对齐当前会话 */
   sessionKey?: string
   real_mobook?: string | number
+  is_finish?: number
 }

package/src/utils/constant.ts

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

package/src/utils/global.ts

@@ -68,12 +68,22 @@ export function getDcgchatRuntime(): PluginRuntime {
   return runtime as PluginRuntime
 }
 
-let msgStatus: 'running' | 'finished' | '' = ''
-export function setMsgStatus(status: 'running' | 'finished' | '') {
-  msgStatus = status
+export type MsgSessionStatus = 'running' | 'finished' | ''
+
+const msgStatusBySessionKey = new Map<string, MsgSessionStatus>()
+
+export function setMsgStatus(sessionKey: string, status: MsgSessionStatus) {
+  if (!sessionKey?.trim()) return
+  if (status === '') {
+    msgStatusBySessionKey.delete(sessionKey)
+  } else {
+    msgStatusBySessionKey.set(sessionKey, status)
+  }
 }
-export function getMsgStatus() {
-  return msgStatus
+
+export function getMsgStatus(sessionKey: string): MsgSessionStatus {
+  if (!sessionKey?.trim()) return ''
+  return msgStatusBySessionKey.get(sessionKey) ?? ''
 }
 
 const getMediaKey = (url: string) => url.split(/[\\/]/).pop() ?? url
@@ -106,3 +116,30 @@ export function clearSentMediaKeys(messageId?: string) {
     sentMediaKeysBySession.clear()
   }
 }
+
+export const getSessionKey = (content: any, accountId: string) => {
+  const { real_mobook, agent_id, conversation_id, session_id } = content
+  const core = getDcgchatRuntime()
+
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: getOpenClawConfig() as OpenClawConfig,
+    channel: "dcgchat-test",
+    accountId: accountId || 'default',
+    peer: { kind: 'direct', id: session_id }
+  })
+  return real_mobook === '1' ? route.sessionKey : `agent:main:mobook:direct:${agent_id}:${session_id}`.toLowerCase()
+}
+
+const cronMessageIdMap = new Map<string, string>()
+
+export function setCronMessageId(sk: string, messageId: string) {
+  cronMessageIdMap.set(sk, messageId)
+}
+
+export function getCronMessageId(sk: string): string {
+  return cronMessageIdMap.get(sk) ?? ''
+}
+
+export function removeCronMessageId(sk: string) {
+  cronMessageIdMap.delete(sk)
+}

package/src/utils/params.ts

@@ -53,7 +53,9 @@ export function getEffectiveMsgParams(sessionKey?: string): IMsgParams {
 export function setParamsMessage(sessionKey: string, params: Partial<IMsgParams>) {
   if (!sessionKey) return
   currentSessionKey = sessionKey
-  paramsMessageMap.set(sessionKey, resolveParamsMessage({ ...params, sessionKey }))
+  const previous = paramsMessageMap.get(sessionKey)
+  const base = previous ? resolveParamsMessage(previous) : getParamsDefaults()
+  paramsMessageMap.set(sessionKey, resolveParamsMessage({ ...base, ...params, sessionKey }))
 }
 
 export function getParamsMessage(sessionKey: string): IMsgParams | undefined {