@dcrays/dcgchat-test 0.3.0 → 0.3.1

package/package.json

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

package/src/bot.ts

@@ -3,21 +3,15 @@ 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,
-  setMsgParamsSessionKey,
-  setMsgStatus
-} from './utils/global.js'
+import { clearSentMediaKeys, getDcgchatRuntime, getOpenClawConfig, 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 { createMsgContext, sendChunk, sendFinal, sendText as sendTextMsg, sendError, sendText } from './transport.js'
+import { sendChunk, sendFinal, sendText as sendTextMsg, sendError } from './transport.js'
 import { dcgLogger } from './utils/log.js'
 import { channelInfo, systemCommand, interruptCommand, ENV } from './utils/constant.js'
 import { sendMessageToGateway } from './gateway/socket.js'
+import { getEffectiveMsgParams, setParamsMessage } from './utils/params.js'
 
 type MediaInfo = {
   path: string
@@ -33,15 +27,6 @@ const mediaMaxBytes = 300 * 1024 * 1024
 /** Active LLM generation abort controllers, keyed by conversationId */
 // const activeGenerations = new Map<string, AbortController>()
 
-// /** Abort an in-progress LLM generation for a given conversationId */
-// export function abortMobookappGeneration(conversationId: string): void {
-//   const ctrl = activeGenerations.get(conversationId)
-//   if (ctrl) {
-//     ctrl.abort()
-//     activeGenerations.delete(conversationId)
-//   }
-// }
-
 /**
  * Extract agentId from conversation_id formatted as "agentId::suffix".
  * Returns null if the conversation_id does not contain the "::" separator.
@@ -132,16 +117,8 @@ function resolveReplyMediaList(payload: ReplyPayload): string[] {
  * 处理一条用户消息，调用 Agent 并返回回复
  */
 export async function handleDcgchatMessage(msg: InboundMessage, accountId: string): Promise<void> {
-  const msgCtx = createMsgContext(msg)
-
   let finalSent = false
 
-  const safeSendFinal = () => {
-    if (finalSent) return
-    finalSent = true
-    sendFinal(msgCtx)
-  }
-
   let completeText = ''
   const config = getOpenClawConfig()
   if (!config) {
@@ -150,39 +127,58 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   }
   const account = resolveAccount(config, accountId)
   const userId = msg._userId.toString()
+
+  const core = getDcgchatRuntime()
+
+  const conversationId = msg.content.session_id?.trim()
+  const agentId = msg.content.agent_id?.trim()
+  const real_mobook = msg.content.real_mobook?.toString().trim()
+
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: config,
+    channel: "dcgchat-test",
+    accountId: account.accountId,
+    peer: { kind: 'direct', id: conversationId }
+  })
+
+  const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
+
+  const effectiveAgentId = embeddedAgentId ?? route.agentId
+  const effectiveSessionKey =
+    real_mobook === '1' ? route.sessionKey : `agent:main:mobook:direct:${agentId}:${conversationId}`.toLowerCase()
+
+  setParamsMessage(effectiveSessionKey, {
+    userId: msg._userId,
+    botToken: msg.content.bot_token,
+    sessionId: conversationId,
+    messageId: msg.content.message_id,
+    domainId: msg.content.domain_id,
+    appId: msg.content.app_id,
+    botId: msg.content.bot_id ?? '',
+    agentId: msg.content.agent_id ?? '',
+    sessionKey: effectiveSessionKey,
+    real_mobook
+  })
+  const outboundCtx = getEffectiveMsgParams(effectiveSessionKey)
+  const agentEntry =
+    effectiveAgentId && effectiveAgentId !== 'main' ? config.agents?.list?.find((a) => a.id === effectiveAgentId) : undefined
+  const agentDisplayName = agentEntry?.name ?? (effectiveAgentId && effectiveAgentId !== 'main' ? effectiveAgentId : undefined)
+
+  const safeSendFinal = () => {
+    if (finalSent) return
+    finalSent = true
+    sendFinal(outboundCtx)
+  }
+
   const text = msg.content.text?.trim()
 
   if (!text) {
-    sendTextMsg(msgCtx, '你需要我帮你做什么呢？')
+    sendTextMsg('你需要我帮你做什么呢？', outboundCtx)
     safeSendFinal()
     return
   }
 
   try {
-    const core = getDcgchatRuntime()
-
-    const conversationId = msg.content.session_id?.trim()
-    const agentId = msg.content.agent_id?.trim()
-    const realMobook = msg.content.real_mobook?.toString().trim()
-
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg: config,
-      channel: "dcgchat-test",
-      accountId: account.accountId,
-      peer: { kind: 'direct', id: conversationId }
-    })
-
-    // If conversation_id encodes an agentId prefix ("agentId::suffix"), override the route.
-    const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
-    const effectiveAgentId = embeddedAgentId ?? route.agentId
-    const effectiveSessionKey =
-      realMobook === '1' ? route.sessionKey : `agent:main:mobook:direct:${agentId}:${conversationId}`.toLowerCase()
-    setMsgParamsSessionKey(effectiveSessionKey)
-
-    const agentEntry =
-      effectiveAgentId && effectiveAgentId !== 'main' ? config.agents?.list?.find((a) => a.id === effectiveAgentId) : undefined
-    const agentDisplayName = agentEntry?.name ?? (effectiveAgentId && effectiveAgentId !== 'main' ? effectiveAgentId : undefined)
-
     // Abort any existing generation for this conversation, then start a new one
     // const existingCtrl = activeGenerations.get(conversationId)
     // if (existingCtrl) existingCtrl.abort()
@@ -252,7 +248,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
           const key = getMediaKey(mediaUrl)
           if (sentMediaKeys.has(key)) continue
           sentMediaKeys.add(key)
-          await sendDcgchatMedia({ msgCtx, mediaUrl, text: '' })
+          await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl, text: '' })
         }
       },
       onError: (err: unknown, info: { kind: string }) => {
@@ -278,14 +274,13 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         })
       } else if (interruptCommand.includes(text?.trim())) {
         dcgLogger(`interrupt command: ${text}`)
-        // abortMobookappGeneration(conversationId)
         sendMessageToGateway(
           JSON.stringify({
             method: 'chat.abort',
             params: { sessionKey: effectiveSessionKey }
           })
         )
-        sendFinal(msgCtx)
+        safeSendFinal()
         return
       } else {
         dcgLogger(`dispatching to agent (session=${route.sessionKey})`)
@@ -308,7 +303,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                   ? payload.text.slice(streamedTextLen)
                   : payload.text
                 if (delta.trim()) {
-                  sendChunk(msgCtx, delta)
+                  sendChunk(delta, outboundCtx)
                   dcgLogger(`[stream]: chunk ${delta.length} chars to user ${msg._userId} ${delta.slice(0, 100)}`)
                 }
                 streamedTextLen = payload.text.length
@@ -319,7 +314,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                 const key = getMediaKey(mediaUrl)
                 if (sentMediaKeys.has(key)) continue
                 sentMediaKeys.add(key)
-                await sendDcgchatMedia({ msgCtx, mediaUrl, text: '' })
+                await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl, text: '' })
               }
             }
           }
@@ -360,7 +355,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
         const resolved = candidates.find((p) => fs.existsSync(p))
         if (!resolved) continue
         try {
-          await sendDcgchatMedia({ msgCtx, mediaUrl: resolved, text: '' })
+          await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl: resolved, text: '' })
         } catch (err) {
           dcgLogger(` sendDcgchatMedia error: ${String(err)}`, 'error')
         }
@@ -386,7 +381,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       })
   } catch (err) {
     dcgLogger(` handle message failed: ${String(err)}`, 'error')
-    sendError(msgCtx, err instanceof Error ? err.message : String(err))
+    sendError(err instanceof Error ? err.message : String(err), outboundCtx)
   } finally {
     safeSendFinal()
   }

package/src/channel.ts

@@ -2,36 +2,40 @@ 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, getMsgParams, hasSentMediaKey } from './utils/global.js'
-import { type DcgchatMsgContext, isWsOpen, sendFinal, wsSendRaw } from './transport.js'
+import { addSentMediaKey, 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'
 
 export type DcgchatMediaSendOptions = {
-  msgCtx: DcgchatMsgContext
+  /** 与 setParamsMessage / map 一致，用于 getEffectiveMsgParams */
+  sessionKey: string
   mediaUrl?: string
   text?: string
 }
 
 export async function sendDcgchatMedia(opts: DcgchatMediaSendOptions): Promise<void> {
-  const { msgCtx } = opts
+  const msgCtx = getEffectiveMsgParams(opts.sessionKey)
   if (!isWsOpen()) {
     dcgLogger(`outbound media skipped -> ws not open: ${opts.mediaUrl ?? ''}`)
     return
   }
 
   const mediaUrl = opts.mediaUrl
-  if (mediaUrl && hasSentMediaKey(msgCtx.messageId, mediaUrl)) {
+  const dedupeId = msgCtx.messageId
+  if (mediaUrl && dedupeId && hasSentMediaKey(dedupeId, mediaUrl)) {
     dcgLogger(`dcgchat: sendMedia skipped (duplicate in session): ${mediaUrl}`)
     return
   }
-  if (mediaUrl) {
-    addSentMediaKey(msgCtx.messageId, mediaUrl)
+  if (mediaUrl && dedupeId) {
+    addSentMediaKey(dedupeId, mediaUrl)
   }
 
   const fileName = mediaUrl?.split(/[\\/]/).pop() || ''
 
   try {
-    const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, msgCtx.botToken, 1) : ''
+    const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.["dcgchat-test"]?.botToken ?? ''
+    const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, botToken, 1) : ''
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
       files: [{ url, name: fileName }]
@@ -61,22 +65,6 @@ export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null):
   }
 }
 
-/** Build a DcgchatMsgContext for the outbound pipeline (uses global msgParams). */
-function createOutboundMsgContext(cfg: OpenClawConfig, accountId?: string | null): DcgchatMsgContext {
-  const params = getMsgParams()
-  const { botToken } = resolveAccount(cfg, accountId)
-  return {
-    userId: params.userId,
-    botToken,
-    domainId: params.domainId,
-    appId: params.appId,
-    botId: params.botId,
-    agentId: params.agentId,
-    sessionId: params.sessionId,
-    messageId: params.messageId
-  }
-}
-
 export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
   id: "dcgchat-test",
   meta: {
@@ -153,24 +141,30 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
     deliveryMode: 'direct',
     textChunkLimit: 4000,
     sendText: async (ctx) => {
-      const msgCtx = createOutboundMsgContext(ctx.cfg, ctx.accountId)
       if (isWsOpen()) {
-        wsSendRaw(msgCtx, { response: ctx.text })
-        dcgLogger(`channel sendText to ${msgCtx.userId} ${ctx.text?.slice(0, 50)}`)
+        const merged = mergeDefaultParams({
+          agentId: ctx.accountId ?? '',
+          sessionId: ctx.to,
+          messageId: `${Date.now()}`
+        })
+        wsSendRaw(merged, { response: ctx.text })
+        sendFinal(merged)
+        dcgLogger(`channel sendText to ${ctx.to} ${ctx.text?.slice(0, 50)}`)
       }
       return {
         channel: "dcgchat-test",
         messageId: `dcg-${Date.now()}`,
-        chatId: msgCtx.userId.toString()
+        chatId: ctx.to
       }
     },
     sendMedia: async (ctx) => {
-      const msgCtx = createOutboundMsgContext(ctx.cfg, ctx.accountId)
-      await sendDcgchatMedia({ msgCtx, mediaUrl: ctx.mediaUrl })
+      const sk = getCurrentSessionKey()
+      const msgCtx = getEffectiveMsgParams('sk')
+      await sendDcgchatMedia({ sessionKey: sk ?? '', mediaUrl: ctx.mediaUrl ?? '' })
       return {
         channel: "dcgchat-test",
         messageId: `dcg-${Date.now()}`,
-        chatId: msgCtx.userId.toString()
+        chatId: msgCtx.userId?.toString()
       }
     }
   },

package/src/cron.ts

@@ -6,11 +6,13 @@ import { promisify } from 'node:util'
 
 const execFileAsync = promisify(execFile)
 import type { IMsgParams } from './types.js'
-import { DcgchatMsgContext, sendEventMessage } from './transport.js'
-import { getMsgParams, getWorkspaceDir } from './utils/global.js'
+import { sendEventMessage } from './transport.js'
+import { getWorkspaceDir } 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 {
   const workspaceDir = getWorkspaceDir()
@@ -18,33 +20,28 @@ export function getCronJobsPath(): string {
   return path.join(cronDir, 'jobs.json')
 }
 
-function msgParamsToCtx(p: IMsgParams): DcgchatMsgContext | null {
-  if (!p?.token) return null
-  return {
-    userId: p.userId,
-    botToken: p.token,
-    domainId: p.domainId,
-    appId: p.appId,
-    botId: p.botId,
-    agentId: p.agentId,
-    sessionId: p.sessionId,
-    messageId: p.messageId
-  }
+function msgParamsToCtx(p: IMsgParams): IMsgParams | null {
+  if (!p?.botToken) return null
+  return p
 }
 
 const CRON_UPLOAD_DEBOUNCE_MS = 30_000
 
 /** 待合并的上传上下文（短时间内多次调用只保留最后一次） */
-let pendingCronUploadCtx: DcgchatMsgContext | null = null
+let pendingCronUploadCtx: IMsgParams | null = null
 let cronUploadFlushTimer: ReturnType<typeof setTimeout> | null = null
 
-async function runCronJobsUpload(msgCtx: DcgchatMsgContext): Promise<void> {
+async function runCronJobsUpload(msgCtx: IMsgParams): Promise<void> {
   const jobPath = getCronJobsPath()
   if (fs.existsSync(jobPath)) {
     try {
-      const url = await ossUpload(jobPath, msgCtx.botToken, 0)
+      const url = await ossUpload(jobPath, msgCtx.botToken ?? '', 0)
       dcgLogger(`定时任务创建成功: ${url}`)
-      sendEventMessage(msgCtx, url)
+      if (!msgCtx.sessionKey) {
+        dcgLogger('runCronJobsUpload: missing sessionKey on msgCtx', 'error')
+        return
+      }
+      sendEventMessage(url, msgCtx.sessionKey)
     } catch (error) {
       dcgLogger(`${jobPath} upload failed: ${error}`, 'error')
     }
@@ -63,10 +60,10 @@ function flushCronUploadQueue(): void {
 
 /**
  * 将 jobs.json 同步到 OSS 并推送事件。30s 内多次调用合并为一次上传；定时触发后清空待处理项，避免重复执行。
- * @param msgCtx 可选；省略时使用当前 getMsgParams() 快照
+ * @param msgCtx 可选；省略时使用当前会话 getEffectiveMsgParams(sessionKey) 快照
  */
 export function sendDcgchatCron(): void {
-  const ctx = msgParamsToCtx(getMsgParams() as IMsgParams)
+  const ctx = msgParamsToCtx(getEffectiveMsgParams(getCurrentSessionKey() ?? ''))
   if (!ctx) {
     dcgLogger('sendDcgchatCron: no message context (missing token / params)', 'error')
     return
@@ -120,6 +117,22 @@ export const updateCronJobSessionKey = async (jobId: string) => {
     dcgLogger('onRemoveCronJob: empty jobId', 'error')
     return
   }
-  const params = getMsgParams()
-  sendMessageToGateway(JSON.stringify({ method: 'cron.update', params: { id: jobId, patch: { sessionKey: params.sessionKey } } }))
+  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
+          }
+        }
+      }
+    })
+  )
 }

package/src/gateway/index.ts

@@ -91,7 +91,7 @@ export class GatewayConnection {
   /** 服务端 connect.challenge 提供的 nonce，须与签名载荷一致 */
   private connectChallengeNonce: string | null = null
   private connectSent: boolean = false
-  private messageHandlers: Map<string, (response: GatewayResponse) => void> = new Map()
+  private pendingRpcById: Map<string, (response: GatewayResponse) => void> = new Map()
   private eventHandlers: Set<(event: GatewayEvent) => void> = new Set()
 
   constructor(config: GatewayConfig) {
@@ -347,23 +347,33 @@ export class GatewayConnection {
       return
     }
     if (msg.type === 'res') {
-      const handler = this.messageHandlers.get(msg.id as string)
+      const handler = this.pendingRpcById.get(msg.id as string)
       if (handler) {
-        this.messageHandlers.delete(msg.id as string)
+        this.pendingRpcById.delete(msg.id as string)
         handler(msg as unknown as GatewayResponse)
       }
       return
     }
 
     if (msg.type === 'event') {
-      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()
+      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()
+          }
         }
+      } catch (error) {
+        dcgLogger(`[Gateway] 处理事件失败: ${error}`, 'error')
       }
       const event: GatewayEvent = {
         type: msg.event as string,
@@ -387,11 +397,11 @@ export class GatewayConnection {
       }
 
       const timeout = setTimeout(() => {
-        this.messageHandlers.delete(id)
+        this.pendingRpcById.delete(id)
         reject(new Error('Method call timeout'))
       }, 30000)
 
-      this.messageHandlers.set(id, (response) => {
+      this.pendingRpcById.set(id, (response) => {
         clearTimeout(timeout)
         if (response.ok) {
           const body = response.result !== undefined ? response.result : (response as GatewayResponse).payload

package/src/gateway/security.ts

@@ -1,8 +1,5 @@
 // Security utilities for the tunnel plugin
 import crypto from 'crypto'
-import fs from 'fs'
-import jwt from 'jsonwebtoken'
-import { z } from 'zod'
 
 // ED25519 SubjectPublicKeyInfo prefix (must match openclaw gateway `ED25519_SPKI_PREFIX`)
 const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex')
@@ -12,10 +9,7 @@ const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex')
  */
 export function derivePublicKeyRawFromPem(publicKeyPem: string): Buffer {
   const spki = crypto.createPublicKey(publicKeyPem).export({ type: 'spki', format: 'der' }) as Buffer
-  if (
-    spki.length === ED25519_SPKI_PREFIX.length + 32 &&
-    spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)
-  ) {
+  if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
     return spki.subarray(ED25519_SPKI_PREFIX.length)
   }
   return spki

package/src/gateway/socket.ts

@@ -99,6 +99,8 @@ export type GatewayRpcPayload = {
 let persistentConn: GatewayConnection | null = null
 let pingTimer: ReturnType<typeof setInterval> | null = null
 let reconnectTimer: ReturnType<typeof setTimeout> | null = null
+/** register 可能被调用多次，只保留一个「延迟首次连接」定时器，避免同一时刻触发两次 connect */
+let startupConnectTimer: ReturnType<typeof setTimeout> | null = null
 let connectInFlight = false
 let socketStopped = true
 /** 用于忽略「已被替换的旧连接」上的 close/error */
@@ -118,6 +120,13 @@ function clearReconnectTimer(): void {
   }
 }
 
+function clearStartupConnectTimer(): void {
+  if (startupConnectTimer) {
+    clearTimeout(startupConnectTimer)
+    startupConnectTimer = null
+  }
+}
+
 function startPingTimer(gw: GatewayConnection): void {
   clearPingTimer()
   pingTimer = setInterval(() => {
@@ -159,7 +168,9 @@ function attachSocketLifecycle(gw: GatewayConnection, generation: number): void
 }
 
 async function connectPersistentGateway(): Promise<void> {
-  if (socketStopped || connectInFlight) return
+  if (socketStopped) return
+  if (persistentConn?.isConnected()) return
+  if (connectInFlight) return
 
   const cfg = resolveConfigSafe()
   if (!cfg) return
@@ -218,7 +229,9 @@ async function connectPersistentGateway(): Promise<void> {
 export function startDcgchatGatewaySocket(): void {
   socketStopped = false
   clearReconnectTimer()
-  setTimeout(() => {
+  if (startupConnectTimer != null) return
+  startupConnectTimer = setTimeout(() => {
+    startupConnectTimer = null
     void connectPersistentGateway()
   }, 10000)
 }
@@ -229,6 +242,7 @@ export function startDcgchatGatewaySocket(): void {
 export function stopDcgchatGatewaySocket(): void {
   socketStopped = true
   clearReconnectTimer()
+  clearStartupConnectTimer()
   clearPingTimer()
   if (persistentConn) {
     try {

package/src/monitor.ts

@@ -2,9 +2,8 @@ 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 } from './utils/global.js'
+import { setWsConnection, getOpenClawConfig, setMsgStatus } from './utils/global.js'
 import type { InboundMessage } from './types.js'
-import { setMsgParams, setMsgStatus } from './utils/global.js'
 import { installSkill, uninstallSkill } from './skill.js'
 import { dcgLogger } from './utils/log.js'
 import { ignoreToolCommand } from './utils/constant.js'
@@ -130,19 +129,6 @@ export async function monitorDcgchatProvider(opts: MonitorDcgchatOpts): Promise<
         if (!ignoreToolCommand.includes(msg.content.text?.trim())) {
           setMsgStatus('running')
         }
-        // 设置获取用户消息消息参数
-        setMsgParams({
-          userId: msg._userId,
-          token: msg.content.bot_token,
-          sessionId: msg.content.session_id,
-          messageId: msg.content.message_id,
-          domainId: account.domainId || 1000,
-          appId: account.appId || '100',
-          botId: msg.content.bot_id,
-          agentId: msg.content.agent_id
-        })
-        msg.content.app_id = account.appId || '100'
-        msg.content.domain_id = account.domainId || '1000'
 
         await handleDcgchatMessage(msg, account.accountId)
       } else if (parsed.messageType == 'openclaw_bot_event') {

package/src/request/request.ts

@@ -3,7 +3,7 @@ import axios from 'axios'
 import md5 from 'md5'
 import type { IResponse } from '../types.js'
 import { getUserTokenCache } from './userInfo.js'
-import { getMsgParams } from '../utils/global.js'
+import { getCurrentSessionKey, getEffectiveMsgParams } from '../utils/params.js'
 import { ENV } from '../utils/constant.js'
 import { dcgLogger } from '../utils/log.js'
 
@@ -172,7 +172,7 @@ export function post<T = Record<string, unknown>, R = unknown>(
     botToken?: string
   }
 ): Promise<IResponse<R>> {
-  const params = getMsgParams() || {}
+  const params = getEffectiveMsgParams(getCurrentSessionKey() ?? '') || {}
   const config: any = {
     method: 'POST',
     url,

package/src/tool.ts

@@ -1,7 +1,8 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { getMsgParams, getMsgStatus, getWsConnection } from './utils/global.js'
+import { getMsgStatus, getWsConnection } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
 import { isWsOpen, sendFinal, sendText } from './transport.js'
+import { getCurrentSessionKey, getEffectiveMsgParams } from './utils/params.js'
 
 let toolCallId = ''
 let toolName = ''
@@ -51,7 +52,9 @@ const eventList = [
 
 function sendToolCallMessage(text: string, toolCallId: string, isCover: number) {
   const ws = getWsConnection()
-  const params = getMsgParams()
+  const sk = getCurrentSessionKey()
+  if (!sk) return
+  const params = getEffectiveMsgParams(sk)
   if (isWsOpen()) {
     ws?.send(
       JSON.stringify({
@@ -61,7 +64,7 @@ function sendToolCallMessage(text: string, toolCallId: string, isCover: number)
         is_finish: -1,
         content: {
           is_finish: -1,
-          bot_token: params?.token,
+          bot_token: params?.botToken,
           domain_id: params?.domainId,
           app_id: params?.appId,
           bot_id: params?.botId,
@@ -85,7 +88,7 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
       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)}`)
+          dcgLogger(`工具调用结果： ~ event:${item.event} ~ params:${JSON.stringify(rest)}, args: ${JSON.stringify(args)}`)
           const text = JSON.stringify({
             type: item.event,
             specialIdentification: 'dcgchat_tool_call_special_identification',
@@ -97,22 +100,14 @@ export function monitoringToolMessage(api: OpenClawPluginApi) {
         } else if (item.event) {
           dcgLogger(`工具调用结果： ~ event:${item.event}`)
           if (item.event === 'llm_output') {
-            dcgLogger(`llm_output工具调用结果： ~ event:${JSON.stringify(event)}`)
+            dcgLogger(`llm_output工具调用结果： ~ event:${JSON.stringify(event)}, args: ${JSON.stringify(args)}`)
             if (event.lastAssistant?.errorMessage === '429-账户额度耗尽') {
-              const params = getMsgParams()
               const message = '您的积分已消耗完，您可以通过充值积分来继续使用'
-              const ctx = {
-                userId: params.userId,
-                botToken: params.token,
-                domainId: params.domainId,
-                appId: params.appId,
-                botId: params.botId,
-                agentId: params.agentId,
-                sessionId: params.sessionId,
-                messageId: params.messageId
-              }
-              sendText(ctx, message, { message_tags: { insufficient_balance: 1 }, is_finish: -1 })
-              sendFinal(ctx)
+              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
             }
           }

package/src/transport.ts

@@ -1,19 +1,22 @@
 import { getWsConnection } from './utils/global.js'
 import { dcgLogger } from './utils/log.js'
+import type { IMsgParams } from './types.js'
+import { getEffectiveMsgParams, getParamsDefaults } from './utils/params.js'
 
-export type DcgchatMsgContext = {
-  userId: number
-  botToken: string
-  domainId?: string
-  appId?: string
-  botId?: string
-  agentId?: string
-  sessionId: string
-  messageId: string
+/** 用 sessionKey 从 map 取参，再合并 overrides（channel 出站、媒体等） */
+export function mergeSessionParams(sessionKey: string, overrides?: Partial<IMsgParams>): IMsgParams {
+  const base = getEffectiveMsgParams(sessionKey)
+  if (!overrides) return base
+  return { ...base, ...overrides }
+}
+export function mergeDefaultParams(overrides?: Partial<IMsgParams>): IMsgParams {
+  const base = getParamsDefaults()
+  if (!overrides) return base
+  return { ...base, ...overrides }
 }
 
-export function createMsgContext(msg: {
-  _userId: number
+export type InboundMsgForContext = {
+  _userId: number | string
   content: {
     bot_token: string
     domain_id?: string
@@ -23,90 +26,157 @@ export function createMsgContext(msg: {
     session_id: string
     message_id: string
   }
-}): DcgchatMsgContext {
+}
+
+export type OpenclawBotChatEnvelope = {
+  messageType: 'openclaw_bot_chat'
+  _userId: number | undefined
+  source: 'client'
+  content: Record<string, unknown>
+}
+
+function isInboundWire(arg: unknown): arg is InboundMsgForContext {
+  return Boolean(arg && typeof arg === 'object' && '_userId' in arg && 'content' in arg)
+}
+
+/** 下行 WebSocket 帧 → 内部上下文（字段缺省用 channel 配置补） */
+function inboundToCtx(msg: InboundMsgForContext, d: IMsgParams): IMsgParams {
+  const c = msg.content
   return {
-    userId: msg._userId,
-    botToken: msg.content.bot_token,
-    domainId: msg.content.domain_id,
-    appId: msg.content.app_id,
-    botId: msg.content.bot_id,
-    agentId: msg.content.agent_id,
-    sessionId: msg.content.session_id,
-    messageId: msg.content.message_id
+    userId: Number(msg._userId ?? d.userId),
+    botToken: c.bot_token ?? d.botToken,
+    domainId: String(c.domain_id ?? d.domainId),
+    appId: String(c.app_id ?? d.appId),
+    botId: c.bot_id,
+    agentId: c.agent_id,
+    sessionId: c.session_id,
+    messageId: c.message_id
   }
 }
 
-function buildContent(ctx: DcgchatMsgContext, extra: Record<string, unknown>) {
+/** 上行：与配置合并缺省后再 `...ctx` 覆盖（原 wsSendRaw） */
+function mergeOutboundWithDefaults(ctx: IMsgParams, d: IMsgParams): IMsgParams {
   return {
-    bot_token: ctx.botToken,
-    domain_id: ctx.domainId,
-    app_id: ctx.appId,
-    bot_id: ctx.botId,
-    agent_id: ctx.agentId,
-    session_id: ctx.sessionId,
-    message_id: ctx.messageId || Date.now().toString(),
-    ...extra
+    userId: Number(ctx.userId ?? d.userId),
+    botToken: ctx.botToken ?? d.botToken,
+    domainId: String(ctx.domainId ?? d.domainId),
+    appId: String(ctx.appId ?? d.appId),
+    ...ctx
   }
 }
 
-function buildEnvelope(ctx: DcgchatMsgContext, extra: Record<string, unknown>) {
+/**
+ * 组装完整 wire `content` 对象：先写会话/机器人基础字段（回落到 d），再合并调用方传入的 payload。
+ * `content` 在使用处构造（如 response、state、files），同名键可覆盖基础字段。
+ */
+export function buildWireContent(base: IMsgParams, d: IMsgParams, content: Record<string, unknown>): Record<string, unknown> {
+  const resolvedBotToken = base.botToken ?? d.botToken
+  const domain = base.domainId ?? d.domainId
+  const app = base.appId ?? d.appId
   return {
-    messageType: 'openclaw_bot_chat' as const,
-    _userId: ctx.userId,
-    source: 'client' as const,
-    content: buildContent(ctx, extra)
+    bot_token: base.botToken || resolvedBotToken,
+    domain_id: base.domainId || domain,
+    app_id: base.appId || app,
+    bot_id: base.botId,
+    agent_id: base.agentId,
+    session_id: base.sessionId,
+    message_id: base.messageId || Date.now().toString(),
+    ...content
   }
 }
 
+/** 上行：在已合并的 ctx 上套 openclaw_bot_chat 信封（messageType / _userId / source + content） */
+function buildOutboundOpenclawBotChatEnvelope(
+  ctx: IMsgParams,
+  content: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): OpenclawBotChatEnvelope {
+  const d = getParamsDefaults()
+  const base = opts?.mergeChannelDefaults ? mergeOutboundWithDefaults(ctx, d) : ctx
+  return {
+    messageType: 'openclaw_bot_chat',
+    _userId: base.userId,
+    source: 'client',
+    content: buildWireContent(base, d, content)
+  }
+}
+
+/**
+ * 下行解析为 DcgchatMsgContext，或上行组装 openclaw_bot_chat 信封。
+ * 上行时 `content` 由调用方传入；基础参数来自 `ctx` 与 `getParamsDefaults()`（可选 mergeChannelDefaults，同原 wsSendRaw）。
+ */
+export function buildOpenclawBotChat(msg: InboundMsgForContext): IMsgParams
+export function buildOpenclawBotChat(
+  ctx: IMsgParams,
+  content: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): OpenclawBotChatEnvelope
+export function buildOpenclawBotChat(
+  arg1: InboundMsgForContext | IMsgParams,
+  arg2?: Record<string, unknown>,
+  opts?: { mergeChannelDefaults?: boolean }
+): IMsgParams | OpenclawBotChatEnvelope {
+  const d = getParamsDefaults()
+
+  if (arg2 === undefined && isInboundWire(arg1)) {
+    return inboundToCtx(arg1, d)
+  }
+
+  const ctx = arg1 as IMsgParams
+  return buildOutboundOpenclawBotChatEnvelope(ctx, arg2 ?? {}, opts)
+}
+
 export function isWsOpen(): boolean {
   const isOpen = getWsConnection()?.readyState === WebSocket.OPEN
   if (!isOpen) {
-    dcgLogger(`socket not ready ${getWsConnection()?.readyState}`, 'error')
+    dcgLogger(`server socket not ready ${getWsConnection()?.readyState}`, 'error')
   }
   return isOpen
 }
 
 /**
- * Content is stringified separately (double-encoded) to match the
- * dcgchat wire protocol used by the chat stream path.
+ * 聊天流路径：content 单独 JSON.stringify（双重编码），符合 dcgchat 协议。
+ * `ctx` 须由调用方用 getEffectiveMsgParams(sessionKey) 等解析好；`content` 为完整业务 payload。
  */
-export function wsSend(ctx: DcgchatMsgContext, extra: Record<string, unknown>): boolean {
+export function wsSend(ctx: IMsgParams, content: Record<string, unknown>): boolean {
   const ws = getWsConnection()
   if (ws?.readyState !== WebSocket.OPEN) return false
-  const envelope = buildEnvelope(ctx, extra)
+  const envelope = buildOpenclawBotChat(ctx, content)
   ws.send(JSON.stringify({ ...envelope, content: JSON.stringify(envelope.content) }))
   return true
 }
 
 /**
- * Content stays as a nested object (single-encoded).
- * Matches the legacy wire format used by media and outbound-pipeline messages.
+ * 媒体 / channel 出站：content 保持嵌套对象（单次编码）。
+ * `ctx` 须由调用方解析（如需合并覆盖可先 mergeSessionParams）。
  */
-export function wsSendRaw(ctx: DcgchatMsgContext, extra: Record<string, unknown>): boolean {
+export function wsSendRaw(ctx: IMsgParams, content: Record<string, unknown>): boolean {
   const ws = getWsConnection()
   if (isWsOpen()) {
-    ws?.send(JSON.stringify(buildEnvelope(ctx, extra)))
+    ws?.send(JSON.stringify(buildOpenclawBotChat(ctx, content, { mergeChannelDefaults: true })))
   }
   return true
 }
 
-export function sendChunk(ctx: DcgchatMsgContext, text: string): boolean {
+export function sendChunk(text: string, ctx: IMsgParams): boolean {
   return wsSend(ctx, { response: text, state: 'chunk' })
 }
 
-export function sendFinal(ctx: DcgchatMsgContext): boolean {
+export function sendFinal(ctx: IMsgParams): boolean {
   dcgLogger(` message handling complete state: final`)
   return wsSend(ctx, { response: '', state: 'final' })
 }
 
-export function sendText(ctx: DcgchatMsgContext, text: string, event?: Record<string, unknown>): boolean {
+export function sendText(text: string, ctx: IMsgParams, event?: Record<string, unknown>): boolean {
   return wsSend(ctx, { response: text, ...event })
 }
 
-export function sendError(ctx: DcgchatMsgContext, errorMsg: string): boolean {
+export function sendError(errorMsg: string, ctx: IMsgParams): boolean {
   return wsSend(ctx, { response: `[错误] ${errorMsg}`, state: 'final' })
 }
-export function sendEventMessage(ctx: DcgchatMsgContext, url: string) {
+
+export function sendEventMessage(url: string, sessionKey: string) {
+  const ctx = getEffectiveMsgParams(sessionKey)
   const ws = getWsConnection()
   if (isWsOpen()) {
     ws?.send(

package/src/types.ts

@@ -116,13 +116,15 @@ export interface IStsTokenReq {
 }
 
 export interface IMsgParams {
-  userId: number
-  token: string
-  sessionId: string
-  messageId: string
-  domainId: string
-  appId: string
-  botId: string
-  agentId: string
-  sessionKey: string
+  userId?: number
+  botToken?: string
+  sessionId?: string
+  messageId?: string
+  domainId?: string
+  appId?: string
+  botId?: string
+  agentId?: string
+  /** 与 OpenClaw 路由一致，用于 map 与异步链路（工具 / HTTP / cron）对齐当前会话 */
+  sessionKey?: string
+  real_mobook?: string | number
 }

package/src/utils/global.ts

@@ -24,7 +24,6 @@ export function getOpenClawConfig(): OpenClawConfig | null {
 
 import type { OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk'
 import { dcgLogger } from './log.js'
-import { IMsgParams } from '../types.js'
 import { channelInfo, ENV } from './constant.js'
 
 const path = require('path')
@@ -69,17 +68,6 @@ export function getDcgchatRuntime(): PluginRuntime {
   return runtime as PluginRuntime
 }
 
-let msgParams = {} as IMsgParams
-export function setMsgParams(params: any) {
-  msgParams = params
-}
-export function getMsgParams() {
-  return msgParams
-}
-export function setMsgParamsSessionKey(sessionKey: string) {
-  if (sessionKey) msgParams.sessionKey = sessionKey
-}
-
 let msgStatus: 'running' | 'finished' | '' = ''
 export function setMsgStatus(status: 'running' | 'finished' | '') {
   msgStatus = status

package/src/utils/params.ts

@@ -0,0 +1,65 @@
+import { channelInfo, ENV } from './constant.js'
+import { getOpenClawConfig } from './global.js'
+import type { DcgchatConfig, IMsgParams } from '../types.js'
+
+/**
+ * map key 是 session_key，value 为该会话下已 merge 后的消息参数。
+ */
+const paramsMessageMap = new Map<string, IMsgParams>()
+
+/** 最近一次 setParamsMessage 的 key，供不传参的 getEffectiveMsgParams() 使用 */
+let currentSessionKey: string | null = null
+
+/** 从 OpenClaw 配置读取当前 channel 的基础参数（唯一来源，供 transport / resolve 等复用） */
+export function getParamsDefaults(): IMsgParams {
+  const ch = (getOpenClawConfig()?.channels?.["dcgchat-test"] as DcgchatConfig | undefined) ?? {}
+  return {
+    userId: Number(ch.userId ?? 0),
+    botToken: ch.botToken ?? '',
+    sessionId: '',
+    messageId: '',
+    domainId: String(ch.domainId ?? '1000'),
+    appId: String(ch.appId ?? '100'),
+    botId: '',
+    agentId: '',
+    sessionKey: ''
+  }
+}
+
+export function resolveParamsMessage(params: Partial<IMsgParams>): IMsgParams {
+  const defaults = getParamsDefaults()
+  return {
+    userId: Number(params.userId ?? defaults.userId),
+    botToken: params.botToken ?? defaults.botToken,
+    sessionId: params.sessionId ?? defaults.sessionId,
+    messageId: params.messageId ?? defaults.messageId,
+    domainId: String(params.domainId ?? defaults.domainId),
+    appId: String(params.appId ?? defaults.appId),
+    botId: params.botId ?? defaults.botId,
+    agentId: params.agentId ?? defaults.agentId,
+    sessionKey: params.sessionKey ?? defaults.sessionKey
+  }
+}
+
+/**
+ * 统一取值入口：显式 sessionKey，或回落到当前会话；再与配置缺省 merge，保证字段完整。
+ */
+export function getEffectiveMsgParams(sessionKey?: string): IMsgParams {
+  const key = sessionKey ?? currentSessionKey
+  const stored = key ? paramsMessageMap.get(key) : undefined
+  return stored ? resolveParamsMessage(stored) : getParamsDefaults()
+}
+
+export function setParamsMessage(sessionKey: string, params: Partial<IMsgParams>) {
+  if (!sessionKey) return
+  currentSessionKey = sessionKey
+  paramsMessageMap.set(sessionKey, resolveParamsMessage({ ...params, sessionKey }))
+}
+
+export function getParamsMessage(sessionKey: string): IMsgParams | undefined {
+  return paramsMessageMap.get(sessionKey)
+}
+
+export function getCurrentSessionKey(): string | null {
+  return currentSessionKey
+}