@dcrays/dcgchat 0.2.32 → 0.3.18

package/index.ts

@@ -4,6 +4,7 @@ import { dcgchatPlugin } from './src/channel.js'
 import { setDcgchatRuntime, setWorkspaceDir } from './src/utils/global.js'
 import { monitoringToolMessage } from './src/tool.js'
 import { setOpenClawConfig } from './src/utils/global.js'
+import { startDcgchatGatewaySocket } from './src/gateway/socket.js'
 
 const plugin = {
   id: "dcgchat",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/dcgchat",
-  "version": "0.2.32",
+  "version": "0.3.18",
   "type": "module",
   "description": "OpenClaw channel plugin for 书灵墨宝 (WebSocket)",
   "main": "index.ts",
@@ -12,7 +12,7 @@
   ],
   "keywords": [
     "openclaw",
-    "dcgchat",
+    "dcgchat-test",
     "websocket",
     "ai"
   ],
@@ -42,4 +42,4 @@
       "defaultChoice": "npm"
     }
   }
-}
+}

package/src/bot.ts

@@ -3,20 +3,23 @@ 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 os from 'node:os'
 import {
   clearSentMediaKeys,
   getDcgchatRuntime,
   getOpenClawConfig,
+  getSessionKey,
   getWorkspaceDir,
-  getWsConnection,
   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, 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'
 
 type MediaInfo = {
   path: string
@@ -29,17 +32,20 @@ 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>()
-
-/** 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)
-  }
-}
+// const activeGenerations = new Map<string, AbortController>()
 
 /**
  * Extract agentId from conversation_id formatted as "agentId::suffix".
@@ -131,7 +137,7 @@ function resolveReplyMediaList(payload: ReplyPayload): string[] {
  * 处理一条用户消息，调用 Agent 并返回回复
  */
 export async function handleDcgchatMessage(msg: InboundMessage, accountId: string): Promise<void> {
-  const msgCtx = createMsgContext(msg)
+  let finalSent = false
 
   let completeText = ''
   const config = getOpenClawConfig()
@@ -141,43 +147,64 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
   }
   const account = resolveAccount(config, accountId)
   const userId = msg._userId.toString()
-  const text = msg.content.text?.trim()
 
-  if (!text) {
-    sendTextMsg(msgCtx, '你需要我帮你做什么呢？')
-    sendFinal(msgCtx)
-    return
-  }
+  const core = getDcgchatRuntime()
 
-  try {
-    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 conversationId = msg.content.session_id?.trim()
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg: config,
+    channel: "dcgchat",
+    accountId: account.accountId,
+    peer: { kind: 'direct', id: conversationId }
+  })
 
-    const route = core.channel.routing.resolveAgentRoute({
-      cfg: config,
-      channel: "dcgchat",
-      accountId: account.accountId,
-      peer: { kind: 'direct', id: conversationId }
-    })
+  const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
 
-    // If conversation_id encodes an agentId prefix ("agentId::suffix"), override the route.
-    const embeddedAgentId = extractAgentIdFromConversationId(conversationId)
-    const effectiveAgentId = embeddedAgentId ?? route.agentId
-    const effectiveSessionKey = embeddedAgentId
-      ? `agent:${embeddedAgentId}:mobook:direct:${conversationId}`.toLowerCase()
-      : route.sessionKey
+  const effectiveAgentId = embeddedAgentId ?? route.agentId
+  const effectiveSessionKey = getSessionKey(msg.content, account.accountId)
+
+  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 = (tag: string) => {
+    if (finalSent) return
+    finalSent = true
+    sendFinal(outboundCtx, tag)
+    setMsgStatus(effectiveSessionKey, 'finished')
+  }
+
+  const text = msg.content.text?.trim()
 
-    const agentEntry =
-      effectiveAgentId && effectiveAgentId !== 'main' ? config.agents?.list?.find((a) => a.id === effectiveAgentId) : undefined
-    const agentDisplayName = agentEntry?.name ?? (effectiveAgentId && effectiveAgentId !== 'main' ? effectiveAgentId : undefined)
+  if (!text) {
+    sendTextMsg('你需要我帮你做什么呢？', outboundCtx)
+    safeSendFinal('not text')
+    return
+  }
 
+  try {
     // Abort any existing generation for this conversation, then start a new one
-    const existingCtrl = activeGenerations.get(conversationId)
-    if (existingCtrl) existingCtrl.abort()
-    const genCtrl = new AbortController()
-    const genSignal = genCtrl.signal
-    activeGenerations.set(conversationId, genCtrl)
+    // const existingCtrl = activeGenerations.get(conversationId)
+    // if (existingCtrl) existingCtrl.abort()
+    // const genCtrl = new AbortController()
+    // const genSignal = genCtrl.signal
+    // activeGenerations.set(conversationId, genCtrl)
 
     // 处理用户上传的文件
     const files = msg.content.files ?? []
@@ -202,7 +229,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',
@@ -215,7 +242,7 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
       WasMentioned: true,
       CommandAuthorized: true,
       OriginatingChannel: "dcgchat",
-      OriginatingTo: `user:${userId}`,
+      OriginatingTo: effectiveSessionKey,
       ...mediaPayload
     })
 
@@ -236,24 +263,35 @@ 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)
           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 }) => {
+        safeSendFinal('error')
+        dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
+        activeRunIdBySessionKey.delete(effectiveSessionKey)
+        streamChunkIdxBySessionKey.delete(effectiveSessionKey)
+        if (sessionStreamSuppressed.has(effectiveSessionKey)) {
+          dcgLogger(`${info.kind} reply failed (stream suppressed): ${String(err)}`, 'error')
+          return
+        }
         dcgLogger(`${info.kind} reply failed: ${String(err)}`, 'error')
       },
-      onIdle: () => {
-        sendFinal(msgCtx)
-      }
+      onIdle: () => {}
     })
 
-    let wasAborted = false
     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({
@@ -262,25 +300,63 @@ 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}`)
-        abortMobookappGeneration(conversationId)
-        sendFinal(msgCtx)
+        safeSendFinal('abort')
+        sendText('会话已终止', outboundCtx)
+        sessionStreamSuppressed.add(effectiveSessionKey)
+        const runId = activeRunIdBySessionKey.get(effectiveSessionKey)
+        sendMessageToGateway(
+          JSON.stringify({
+            method: 'chat.abort',
+            params: {
+              sessionKey: effectiveSessionKey,
+              ...(runId ? { runId } : {})
+            }
+          })
+        )
+        if (runId) activeRunIdBySessionKey.delete(effectiveSessionKey)
+        safeSendFinal('stop')
         return
       } else {
         dcgLogger(`dispatching to agent (session=${route.sessionKey})`)
+        const params = getEffectiveMsgParams(effectiveSessionKey)
+        if (!ignoreToolCommand.includes(text?.trim())) {
+          // message_received 没有 sessionKey 前置到bot中执行
+          wsSendRaw(params, {
+            is_finish: -1,
+            tool_call_id: Date.now().toString(),
+            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,
           dispatcher,
           replyOptions: {
             ...replyOptions,
-            abortSignal: genSignal,
+            // 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
@@ -291,8 +367,10 @@ export async function handleDcgchatMessage(msg: InboundMessage, accountId: strin
                   ? payload.text.slice(streamedTextLen)
                   : payload.text
                 if (delta.trim()) {
-                  sendChunk(msgCtx, delta)
-                  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
               }
@@ -302,46 +380,61 @@ 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: '' })
               }
             }
           }
         })
       }
     } catch (err: unknown) {
-      if (genSignal.aborted) {
-        wasAborted = true
-        dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      } else if (err instanceof Error && err.name === 'AbortError') {
-        wasAborted = true
-        dcgLogger(` generation aborted for conversationId=${conversationId}`)
-      } else {
-        dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
-      }
+      // if (genSignal.aborted) {
+      //   wasAborted = true
+      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
+      // } else if (err instanceof Error && err.name === 'AbortError') {
+      //   wasAborted = true
+      //   dcgLogger(` generation aborted for conversationId=${conversationId}`)
+      // } else {
+      //   dcgLogger(` dispatchReplyFromConfig error: ${String(err)}`, 'error')
+      // }
     } finally {
-      if (activeGenerations.get(conversationId) === genCtrl) {
-        activeGenerations.delete(conversationId)
-      }
+      // if (activeGenerations.get(conversationId) === genCtrl) {
+      //   activeGenerations.delete(conversationId)
+      // }
     }
     try {
       markRunComplete()
+      markDispatchIdle()
     } catch (err) {
-      dcgLogger(` markRunComplete error: ${String(err)}`, 'error')
+      dcgLogger(` markRunComplete||markRunComplete error: ${String(err)}`, 'error')
     }
-    markDispatchIdle()
     if (![...systemCommand, ...interruptCommand].includes(text?.trim())) {
-      for (const file of extractMobookFiles(completeText)) {
-        let resolved = file
-        if (!fs.existsSync(resolved)) {
-          resolved = path.join(getWorkspaceDir(), file)
-          if (!fs.existsSync(resolved)) return
+      if (sessionStreamSuppressed.has(effectiveSessionKey)) {
+        sessionStreamSuppressed.delete(effectiveSessionKey)
+      } else {
+        for (const file of extractMobookFiles(completeText)) {
+          const candidates: string[] = [file]
+          candidates.push(path.join(getWorkspaceDir(), file))
+          candidates.push(path.join(getWorkspaceDir(), file.replace(/^\//, '')))
+          const underMobook = file.replace(/^\/mobook\//i, '').replace(/^mobook[\\/]/i, '')
+          if (underMobook) {
+            if (process.platform === 'win32') {
+              candidates.push(path.join('C:\\', 'mobook', underMobook))
+            } else if (process.platform === 'darwin') {
+              candidates.push(path.join(os.homedir(), 'mobook', underMobook))
+            }
+          }
+          const resolved = candidates.find((p) => fs.existsSync(p))
+          if (!resolved) continue
+          try {
+            await sendDcgchatMedia({ sessionKey: effectiveSessionKey, mediaUrl: resolved, text: '' })
+          } catch (err) {
+            dcgLogger(` sendDcgchatMedia error: ${String(err)}`, 'error')
+          }
         }
-        await sendDcgchatMedia({ msgCtx, mediaUrl: resolved, text: '' })
       }
     }
-    sendFinal(msgCtx)
+    safeSendFinal('end')
     clearSentMediaKeys(msg.content.message_id)
-    setMsgStatus('finished')
 
     // Record session metadata
     const storePath = core.channel.session.resolveStorePath(config.session?.store)
@@ -359,6 +452,8 @@ 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('finally')
   }
 }

package/src/channel.ts

@@ -2,36 +2,41 @@ 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, getCronMessageId, getOpenClawConfig, hasSentMediaKey } from './utils/global.js'
+import { isWsOpen, mergeDefaultParams, mergeSessionParams, sendFinal, wsSendRaw } from './transport.js'
 import { dcgLogger, setLogger } from './utils/log.js'
+import { getEffectiveMsgParams, getCurrentSessionKey } from './utils/params.js'
+import { startDcgchatGatewaySocket } from './gateway/socket.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) : ''
+    const botToken = msgCtx.botToken ?? getOpenClawConfig()?.channels?.["dcgchat"]?.botToken ?? ''
+    const url = opts.mediaUrl ? await ossUpload(opts.mediaUrl, botToken, 1) : ''
     wsSendRaw(msgCtx, {
       response: opts.text ?? '',
       files: [{ url, name: fileName }]
@@ -61,22 +66,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",
   meta: {
@@ -153,24 +142,55 @@ 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)}`)
+        // 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)
+        if (outboundCtx?.sessionId) {
+          const newCtx = messageId ? { ...outboundCtx, messageId } : outboundCtx
+          wsSendRaw(newCtx, { response: ctx.text, is_finish: -1, message_tags: { source: 'channel' } })
+          dcgLogger(`channel sendText to ${ctx.to} ${ctx.text?.slice(0, 50)}`)
+        } else {
+          const sessionInfo = ctx.to.split(':')
+          const sessionId = sessionInfo.at(-1) ?? ''
+          const agentId = sessionInfo.at(-2) ?? ''
+          const merged = mergeDefaultParams({
+            agentId: agentId,
+            sessionId: `${sessionId}`,
+            messageId: messageId,
+            is_finish: -1,
+            real_mobook: !sessionId ? 1 : ''
+          })
+          dcgLogger(`channel sendText to ${ctx.to} ${ctx.text?.slice(0, 50)}`)
+          wsSendRaw(merged, { response: ctx.text })
+        }
       }
       return {
         channel: "dcgchat",
         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 msgCtx = getEffectiveMsgParams(ctx.to)
+      dcgLogger(`channel sendMedia to ${ctx.to} ${ctx.mediaUrl?.slice(0, 50)}`)
+      await sendDcgchatMedia({ sessionKey: ctx.to ?? '', mediaUrl: ctx.mediaUrl ?? '' })
       return {
         channel: "dcgchat",
         messageId: `dcg-${Date.now()}`,
-        chatId: msgCtx.userId.toString()
+        chatId: msgCtx.userId?.toString()
       }
     }
   },
@@ -183,6 +203,7 @@ export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
         dcgLogger(`dcgchat[${account.accountId}]: wsUrl not configured, skipping`, 'error')
         return
       }
+      startDcgchatGatewaySocket()
       return monitorDcgchatProvider({
         config: ctx.cfg,
         runtime: ctx.runtime,