@dcrays/dcgchat-test 0.1.9

package/README.md

@@ -0,0 +1,83 @@
+# OpenClaw DCG Chat 插件
+
+连接 OpenClaw 与 DCG Chat 产品的通道插件。
+
+## 架构
+
+```
+┌──────────┐      WebSocket       ┌──────────────┐      WebSocket      ┌─────────────────────┐
+│ Web 前端 │  ←───────────────→   │  公司后端服务  │  ←───────────────→  │ OpenClaw（工作电脑） │
+└──────────┘                      └──────────────┘   (OpenClaw 主动连)   └─────────────────────┘
+```
+
+- OpenClaw 插件**主动连接**后端的 WebSocket 服务（不需要公网 IP）
+- 后端收到用户消息后转发给 OpenClaw，OpenClaw 回复后发回后端
+
+## 快速开始
+
+### 1. 安装插件
+
+```bash
+pnpm openclaw plugins install -l /path/to/openclaw-dcgchat
+```
+
+### 2. 配置
+
+```bash
+openclaw config set channels.dcgchat.enabled true
+openclaw config set channels.dcgchat.wsUrl "ws://your-backend:8080/openclaw/ws"
+```
+
+### 3. 启动
+
+```bash
+pnpm openclaw gateway
+```
+
+## 消息协议（MVP）
+
+### 下行：后端 → OpenClaw（用户消息）
+
+```json
+{ "type": "message", "userId": "user_001", "text": "你好" }
+```
+
+### 上行：OpenClaw → 后端（Agent 回复）
+
+```json
+{ "type": "reply", "userId": "user_001", "text": "你好！有什么可以帮你的？" }
+```
+
+## 配置项
+
+| 配置键 | 类型 | 说明 |
+|--------|------|------|
+| `channels.dcgchat.enabled` | boolean | 是否启用 |
+| `channels.dcgchat.wsUrl` | string | 后端 WebSocket 地址 |
+
+## 开发
+
+```bash
+# 安装依赖
+pnpm install
+
+# 类型检查
+pnpm typecheck
+```
+
+## 文件结构
+
+- `index.ts` - 插件入口
+- `src/channel.ts` - ChannelPlugin 定义
+- `src/runtime.ts` - 插件 runtime
+- `src/types.ts` - 类型定义
+- `src/monitor.ts` - WebSocket 连接与断线重连
+- `src/bot.ts` - 消息处理与 Agent 调用
+
+## 后续迭代
+
+- [ ] Token 认证
+- [ ] 流式输出
+- [ ] Typing 指示
+- [ ] messageId 去重
+- [ ] 错误消息类型

package/index.ts

@@ -0,0 +1,24 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { dcgchatPlugin } from "./src/channel.js";
+import { setDcgchatRuntime, setWorkspaceDir } from "./src/runtime.js";
+import { monitoringToolMessage } from "./src/tool.js";
+
+const plugin = {
+  id: "dcgchat",
+  name: "DCG Chat",
+  description: "连接 OpenClaw 与 DCG Chat 产品（WebSocket）",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    setDcgchatRuntime(api.runtime);
+    monitoringToolMessage(api);
+    api.registerChannel({ plugin: dcgchatPlugin });
+    api.registerTool((ctx) => {
+      const workspaceDir = ctx.workspaceDir;
+      setWorkspaceDir(workspaceDir);
+      return null;
+    });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "dcgchat",
+  "channels": ["dcgchat"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@dcrays/dcgchat-test",
+  "version": "0.1.9",
+  "type": "module",
+  "description": "OpenClaw channel plugin for DCG Chat (WebSocket)",
+  "main": "index.ts",
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "src",
+    "openclaw.plugin.json"
+  ],
+  "keywords": [
+    "openclaw",
+    "dcgchat",
+    "websocket",
+    "ai"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ali-oss": "file:src/libs/ali-oss-6.23.0.tgz",
+    "ws": "file:src/libs/ws-8.19.0.tgz",
+    "axios": "file:src/libs/axios-1.13.6.tgz",
+    "md5": "file:src/libs/md5-2.3.0.tgz",
+    "unzipper": "file:src/libs/unzipper-0.12.3.tgz"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "openclaw": "2026.2.13",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.2.13"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "channel": {
+      "id": "dcgchat",
+      "label": "DCG Chat",
+      "selectionLabel": "DCG Chat",
+      "docsPath": "/channels/dcgchat",
+      "docsLabel": "dcgchat",
+      "blurb": "连接 OpenClaw 与 DCG Chat 产品",
+      "order": 80
+    },
+    "install": {
+      "npmSpec": "@dcrays/dcgchat-test",
+      "localPath": "extensions/dcgchat",
+      "defaultChoice": "npm"
+    }
+  }
+}

package/src/api.ts

@@ -0,0 +1,62 @@
+import { post } from "./request.js";
+import type { IStsToken, IStsTokenReq } from "./types.js";
+import { getUserTokenCache, setUserTokenCache } from "./userInfo.js";
+
+export const getStsToken = async (name: string, botToken: string) => {
+  // 确保 userToken 已缓存（如果未缓存会自动获取并缓存）
+  await getUserToken(botToken);
+
+  const response = await post<IStsTokenReq, IStsToken>(
+    "/user/getStsToken",
+    {
+      sourceFileName: name,
+      isPrivate: 0,
+    },
+    { botToken },
+  );
+
+  if (!response || !response.data || !response.data.bucket) {
+    throw new Error("获取 OSS 临时凭证失败");
+  }
+
+  return response.data;
+};
+
+/**
+ * 通过 botToken 查询 userToken
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const queryUserTokenByBotToken = async (botToken: string): Promise<string> => {
+  const response = await post<{botToken: string}, {token: string}>("/organization/queryUserTokenByBotToken", {
+    botToken,
+  });
+
+  if (!response || !response.data || !response.data.token) {
+    throw new Error("获取绑定的用户信息失败");
+  }
+
+  return response.data.token;
+};
+
+/**
+ * 获取 userToken（优先从缓存获取，缓存未命中则调用 API）
+ * @param botToken 机器人 token
+ * @returns userToken
+ */
+export const getUserToken = async (botToken: string): Promise<string> => {
+  // 1. 尝试从缓存获取
+  const cachedToken = getUserTokenCache(botToken);
+  if (cachedToken) {
+    return cachedToken;
+  }
+
+  // 2. 缓存未命中，调用 API 获取
+  console.log(`[api] cache miss, fetching userToken for botToken=${botToken.slice(0, 10)}...`);
+  const userToken = await queryUserTokenByBotToken(botToken);
+
+  // 3. 缓存新获取的 token
+  setUserTokenCache(botToken, userToken);
+
+  return userToken;
+};

package/src/bot.ts

@@ -0,0 +1,272 @@
+import path from "node:path";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import { createReplyPrefixContext } from "openclaw/plugin-sdk";
+import type { InboundMessage, OutboundReply } from "./types.js";
+import { getDcgchatRuntime } from "./runtime.js";
+import { resolveAccount } from "./channel.js";
+import { setMsgParams } from "./tool.js";
+
+type MediaInfo = {
+  path: string;
+  contentType: string;
+  placeholder: string;
+};
+
+async function resolveMediaFromUrls(
+  fileUrls: string[],
+  maxBytes: number,
+  log?: (msg: string) => void,
+): Promise<MediaInfo[]> {
+  const core = getDcgchatRuntime();
+  const out: MediaInfo[] = [];
+
+  log?.(`dcgchat media: starting resolve for ${fileUrls.length} file(s): ${JSON.stringify(fileUrls)}`);
+
+  for (let i = 0; i < fileUrls.length; i++) {
+    const url = fileUrls[i];
+    log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetching ${url}`);
+    try {
+      const response = await fetch(url);
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetch response status=${response.status}, content-type=${response.headers.get("content-type")}, content-length=${response.headers.get("content-length")}`);
+      if (!response.ok) {
+        log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fetch failed with HTTP ${response.status}, skipping`);
+        continue;
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] downloaded buffer size=${buffer.length} bytes`);
+
+      let contentType = response.headers.get("content-type") || "";
+      if (!contentType) {
+        log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] no content-type header, detecting mime...`);
+        contentType = await core.media.detectMime({ buffer });
+      }
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] resolved contentType=${contentType}`);
+
+      const fileName = path.basename(new URL(url).pathname) || "file";
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] fileName=${fileName}, saving to disk (maxBytes=${maxBytes})...`);
+
+      const saved = await core.channel.media.saveMediaBuffer(
+        buffer,
+        contentType,
+        "inbound",
+        maxBytes,
+        fileName,
+      );
+
+      const isImage = contentType.startsWith("image/");
+      out.push({
+        path: saved.path,
+        contentType: saved.contentType,
+        placeholder: isImage ? "<media:image>" : "<media:file>",
+      });
+
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] saved to ${saved.path} (contentType=${saved.contentType}, isImage=${isImage})`);
+    } catch (err) {
+      log?.(`dcgchat media: [${i + 1}/${fileUrls.length}] FAILED to process ${url}: ${String(err)}`);
+    }
+  }
+
+  log?.(`dcgchat media: resolve complete, ${out.length}/${fileUrls.length} file(s) succeeded`);
+
+  return out;
+}
+
+function buildMediaPayload(mediaList: MediaInfo[]): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  if (mediaList.length === 0) return {};
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((m) => m.path);
+  const mediaTypes = mediaList.map((m) => m.contentType).filter(Boolean);
+  return {
+    MediaPath: first?.path,
+    MediaType: first?.contentType,
+    MediaUrl: first?.path,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+  };
+}
+
+/**
+ * 处理一条用户消息，调用 Agent 并返回回复
+ */
+export async function handleDcgchatMessage(params: {
+  cfg: ClawdbotConfig;
+  msg: InboundMessage;
+  accountId: string;
+  runtime?: RuntimeEnv;
+  onChunk: (reply: OutboundReply) => void;
+}): Promise<void> {
+  const { cfg, msg, accountId, runtime } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const account = resolveAccount(cfg, accountId);
+  const userId = msg._userId.toString();
+  // const text = msg.text?.trim();
+  const text = msg.content.text?.trim();
+
+  if (!userId || !text) {
+    params.onChunk({
+      messageType: "openclaw_bot_chat",
+      _userId: msg._userId,
+      source: "client",
+      content: {
+        bot_token: msg.content.bot_token,
+        session_id: msg.content.session_id,
+        message_id: msg.content.message_id,
+        response: "[错误] 消息格式不正确",
+      },
+    });
+    return;
+  }
+
+  try {
+    const core = getDcgchatRuntime();
+
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dcgchat",
+      accountId: account.accountId,
+      peer: { kind: "direct", id: userId },
+    });
+
+    // 处理用户上传的文件
+    const fileUrls = msg.content.file_urls ?? [];
+    log(`dcgchat[${accountId}]: incoming message from user=${userId}, text="${text?.slice(0, 80)}", file_urls count=${fileUrls.length}`);
+    let mediaPayload: Record<string, unknown> = {};
+    if (fileUrls.length > 0) {
+      log(`dcgchat[${accountId}]: processing ${fileUrls.length} file(s): ${JSON.stringify(fileUrls)}`);
+      const mediaMaxBytes = 30 * 1024 * 1024;
+      const mediaList = await resolveMediaFromUrls(fileUrls, mediaMaxBytes, log);
+      mediaPayload = buildMediaPayload(mediaList);
+      log(`dcgchat[${accountId}]: media resolved ${mediaList.length}/${fileUrls.length} file(s), payload=${JSON.stringify(mediaPayload)}`);
+    }
+
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    // const messageBody = `${userId}: ${text}`;
+    const messageBody = text;
+    const bodyFormatted = core.channel.reply.formatAgentEnvelope({
+      channel: "DCG Chat",
+      from: userId,
+      timestamp: new Date(),
+      envelope: envelopeOptions,
+      body: messageBody,
+    });
+
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+      Body: bodyFormatted,
+      RawBody: text,
+      CommandBody: text,
+      From: userId,
+      To: userId,
+      SessionKey: route.sessionKey,
+      AccountId: msg.content.session_id,
+      ChatType: "direct",
+      SenderName: userId,
+      SenderId: userId,
+      Provider: "dcgchat" as const,
+      Surface: "dcgchat" as const,
+      MessageSid: msg.content.message_id,
+      Timestamp: Date.now(),
+      WasMentioned: true,
+      CommandAuthorized: true,
+      OriginatingChannel: "dcgchat" as const,
+      OriginatingTo: `user:${userId}`,
+      ...mediaPayload,
+    });
+
+    log(`dcgchat[${accountId}]: ctxPayload=${JSON.stringify(ctxPayload)}`);
+
+    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+
+    const { dispatcher, replyOptions, markDispatchIdle } =
+      core.channel.reply.createReplyDispatcherWithTyping({
+        responsePrefix: prefixContext.responsePrefix,
+        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, route.agentId),
+        onReplyStart: async () => {},
+        deliver: async (payload) => {
+          log(`dcgchat[${accountId}][deliver]: received chunk, text length=${payload.text?.length || 0}`);
+          const t = payload.text?.trim();
+          if (t) {
+            log(`dcgchat[${accountId}][deliver]: sending chunk to user ${msg._userId}, text="${t.slice(0, 50)}..."`);
+            params.onChunk({
+              messageType: "openclaw_bot_chat",
+              _userId: msg._userId,
+              source: "client",
+              content: {
+                bot_token: msg.content.bot_token,
+                session_id: msg.content.session_id,
+                message_id: msg.content.message_id,
+                response: t,
+                state: 'chunk',
+              },
+            });
+            log(`dcgchat[${accountId}][deliver]: chunk sent successfully`);
+          } else {
+            log(`dcgchat[${accountId}][deliver]: skipping empty chunk`);
+          }
+        },
+        onError: (err, info) => {
+          error(`dcgchat[${accountId}] ${info.kind} reply failed: ${String(err)}`);
+        },
+        onIdle: () => {},
+      });
+
+    log(`dcgchat[${accountId}]: dispatching to agent (session=${route.sessionKey})`);
+
+    await core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions: {
+        ...replyOptions,
+        onModelSelected: prefixContext.onModelSelected,
+      },
+    });
+
+    log(`dcgchat[${accountId}]: dispatch complete, sending final state`);
+    params.onChunk({
+      messageType: "openclaw_bot_chat",
+      _userId: msg._userId,
+      source: "client",
+      content: {
+        bot_token: msg.content.bot_token,
+        session_id: msg.content.session_id,
+        message_id: msg.content.message_id,
+        response: '',
+        state: 'final',
+      },
+    });
+    setMsgParams({
+      sessionId: '',
+      messageId: ''
+    });
+    log(`dcgchat[${accountId}]: final state sent`);
+
+    markDispatchIdle();
+    log(`dcgchat[${accountId}]: message handling complete`);
+
+  } catch (err) {
+    error(`dcgchat[${accountId}]: handle message failed: ${String(err)}`);
+    params.onChunk({
+      messageType: "openclaw_bot_chat",
+      _userId: msg._userId,
+      source: "client",
+      content: {
+        bot_token: msg.content.bot_token,
+        session_id: msg.content.session_id,
+        message_id: msg.content.message_id,
+        response: `[错误] ${err instanceof Error ? err.message : String(err)}`,
+        state: 'final',
+      },
+    });
+  }
+}

package/src/channel.ts

@@ -0,0 +1,192 @@
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import type { ResolvedDcgchatAccount, DcgchatConfig } from "./types.js";
+import { logDcgchat } from "./log.js";
+import { getWsConnection } from "./connection.js";
+import { ossUpload } from "./oss.js";
+import { getMsgParams } from "./tool.js";
+
+export function resolveAccount(cfg: OpenClawConfig, accountId?: string | null): ResolvedDcgchatAccount {
+  const id = accountId ?? DEFAULT_ACCOUNT_ID;
+  const raw = (cfg.channels?.["dcgchat"] as DcgchatConfig | undefined) ?? {};
+  return {
+    accountId: id,
+    enabled: raw.enabled !== false,
+    configured: Boolean(raw.wsUrl),
+    wsUrl: raw.wsUrl ?? "",
+    botToken: raw.botToken ?? "",
+    userId: raw.userId ?? "",
+    domainId: raw.domainId ?? "",
+    appId: raw.appId ?? "",
+  };
+}
+
+export const dcgchatPlugin: ChannelPlugin<ResolvedDcgchatAccount> = {
+  id: "dcgchat",
+  meta: {
+    id: "dcgchat",
+    label: "DCG Chat",
+    selectionLabel: "DCG Chat",
+    docsPath: "/channels/dcgchat",
+    docsLabel: "dcgchat",
+    blurb: "连接 OpenClaw 与 DCG Chat 产品",
+    order: 80,
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    polls: false,
+    threads: true,
+    media: true,
+    nativeCommands: true,
+    reactions: true,
+    edit: false,
+    reply: true,
+    effects: true,
+    // blockStreaming: true,
+  },
+  reload: { configPrefixes: ["channels.dcgchat"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        wsUrl: { type: "string" },
+        botToken: { type: "string" },
+        userId: { type: "string" },
+        appId: { type: "string" },
+        domainId: { type: "string" },
+        capabilities: { type: "array", items: { type: "string" } },
+      },
+    },
+  },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    setAccountEnabled: ({ cfg, enabled }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        "dcgchat": {
+          ...(cfg.channels?.["dcgchat"] as Record<string, unknown> | undefined),
+          enabled,
+        },
+      },
+    }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      wsUrl: account.wsUrl,
+      botToken: account.botToken ? "***" : "",
+      userId: account.userId,
+      domainId: account.domainId,
+      appId: account.appId,
+    }),
+  },
+  messaging: {
+    normalizeTarget: (raw) => raw?.trim() || undefined,
+    targetResolver: {
+      looksLikeId: (raw) => Boolean(raw?.trim()),
+      hint: "userId",
+    },
+  },
+  outbound: {
+    deliveryMode: "direct",
+    // textChunkLimit: 25,
+    textChunkLimit: 4000,
+    sendText: async (ctx) => {
+      const target = ctx.to || "(implicit)";
+      const ws = getWsConnection()
+      const params = getMsgParams();
+       if (ws?.readyState === WebSocket.OPEN) {
+        const {botToken} = resolveAccount(ctx.cfg, ctx.accountId);
+        const content = {
+          messageType: "openclaw_bot_chat",
+          _userId: target,
+          source: "client",
+          content: {
+            bot_token: botToken,
+            response: ctx.text,
+            session_id: params.sessionId ||  Date.now().toString(),
+            message_id: params.messageId ||Date.now().toString(),
+          },
+        };
+        ws.send(JSON.stringify(content));
+        logDcgchat.info(`dcgchat[${ctx.accountId}]: sendText to ${target}, ${JSON.stringify(content)}`);
+      } else {
+        logDcgchat.warn(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> ${ws?.readyState}: ${ctx.text}`);
+      }
+      return {
+        channel: "dcgchat",
+        messageId: `dcg-${Date.now()}`,
+        chatId: target,
+      };
+    },
+    sendMedia: async (ctx) => {
+      const target = ctx.to || "(implicit)";
+      const ws = getWsConnection()
+      const params = getMsgParams();
+       if (ws?.readyState === WebSocket.OPEN) {
+        const {botToken} = resolveAccount(ctx.cfg, ctx.accountId);
+        try {
+          const url = ctx.mediaUrl ? await ossUpload(ctx.mediaUrl, botToken) : '';
+          const fileName = ctx.mediaUrl?.split(/[\\/]/).pop() || ''
+          const content = {
+            messageType: "openclaw_bot_chat",
+            _userId: target,
+            source: "client",
+            content: {
+              bot_token: botToken,
+              response: ctx.text + '\n' +  `[${fileName}](${url})`,
+              session_id: params.sessionId ||  Date.now().toString(),
+              message_id: params.messageId ||Date.now().toString(),
+            },
+          };
+          ws.send(JSON.stringify(content));
+          logDcgchat.info(`dcgchat[${ctx.accountId}]: sendMedia to ${target}, ${JSON.stringify(content)}`);
+        } catch (error) {
+         const content = {
+            messageType: "openclaw_bot_chat",
+            _userId: target,
+            source: "client",
+            content: {
+              bot_token: botToken,
+              response: ctx.text + '\n' +  ctx.mediaUrl,
+              session_id: params.sessionId ||  Date.now().toString(),
+              message_id: params.messageId ||Date.now().toString(),
+            },
+          };
+          ws.send(JSON.stringify(content));
+          logDcgchat.info(`dcgchat[${ctx.accountId}]: sendMedia to ${target}, ${JSON.stringify(content)}`);
+        }
+      } else {
+        logDcgchat.warn(`[dcgchat][${ctx.accountId ?? DEFAULT_ACCOUNT_ID}] outbound -> ${ws?.readyState}: ${ctx.text}`);
+      }
+      return {
+        channel: "dcgchat",
+        messageId: `dcg-${Date.now()}`,
+        chatId: target,
+      };  
+    },
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { monitorDcgchatProvider } = await import("./monitor.js");
+      const account = resolveAccount(ctx.cfg, ctx.accountId);
+      if (!account.wsUrl) {
+        ctx.log?.warn(`dcgchat[${account.accountId}]: wsUrl not configured, skipping`);
+        return;
+      }
+      // ctx.log?.info(`dcgchat[${account.accountId}]: connecting to ${account.wsUrl}`);
+      return monitorDcgchatProvider({
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        accountId: ctx.accountId,
+      });
+    },
+  },
+};