moltbot-dingtalk-stream 1.0.7 → 1.0.9

package/src/index.ts

@@ -1,373 +1,642 @@
-import { DWClient, DWClientDownStream } from 'dingtalk-stream';
-import axios from 'axios';
+import { DWClient } from "dingtalk-stream";
+import { getDingTalkRuntime, type ClawdbotCoreRuntime } from "./runtime.js";
+import {
+  CHANNEL_ID,
+  DEFAULT_ACCOUNT_ID,
+  DingTalkConfigSchema,
+  listDingTalkAccountIds,
+  resolveDingTalkAccount,
+  resolveDefaultDingTalkAccountId,
+  normalizeAccountId,
+  setAccountEnabledInConfig,
+  deleteAccountFromConfig,
+  applyAccountNameToConfig,
+  type ClawdbotConfig,
+  type ResolvedDingTalkAccount,
+} from "./schema.js";
+
+// ============================================================================
+// Plugin API Types
+// ============================================================================
 
-// Define interfaces
 interface ClawdbotPluginApi {
   config: ClawdbotConfig;
-  logger: any;
-  runtime: any;
-  postMessage(params: any): Promise<void>;
-  registerChannel(opts: { plugin: any }): void;
-  registerService(service: any): void;
+  logger: Console;
+  runtime: ClawdbotCoreRuntime;
+  registerChannel(opts: { plugin: ChannelPlugin }): void;
+  registerService?(service: unknown): void;
 }
 
-interface ClawdbotConfig {
-  channels?: {
-    'moltbot-dingtalk-stream'?: {
-      accounts?: {
-        [key: string]: DingTalkAccountConfig;
-      };
-    };
-    [key: string]: any;
-  };
+interface InboundContext {
+  Body: string;
+  RawBody: string;
+  CommandBody: string;
+  From: string;
+  To: string;
+  SessionKey: string;
+  AccountId: string;
+  ChatType: "direct" | "group";
+  SenderName?: string;
+  SenderId: string;
+  SenderUsername?: string;
+  Provider: string;
+  Surface: string;
+  MessageSid: string;
+  Timestamp: number;
+  GroupSubject?: string;
+  ConversationLabel?: string;
+  OriginatingChannel?: string;
+  OriginatingTo?: string;
 }
 
-interface DingTalkAccountConfig {
-  enabled?: boolean;
-  clientId: string;
-  clientSecret: string;
-  webhookUrl?: string;
-  name?: string;
+interface Dispatcher {
+  sendFinalReply: (payload: { text?: string; content?: string }) => boolean;
+  typing: () => Promise<void>;
+  reaction: () => Promise<void>;
+  isSynchronous: () => boolean;
+  waitForIdle: () => Promise<void>;
+  sendBlockReply: (block: { text?: string; delta?: string; content?: string }) => Promise<void>;
+  getQueuedCounts: () => { active: number; queued: number; final: number };
 }
 
-interface ResolvedDingTalkAccount {
-  accountId: string;
-  name?: string;
-  enabled: boolean;
-  configured: boolean;
-  config: DingTalkAccountConfig;
+interface DispatchOptions {
+  ctx: InboundContext;
+  cfg: ClawdbotConfig;
+  dispatcher: Dispatcher;
+  replyOptions: Record<string, unknown>;
 }
 
-interface DingTalkRobotMessage {
-  conversationId: string;
-  chatbotCorpId: string;
-  chatbotUserId: string;
-  msgId: string;
-  senderNick: string;
-  isAdmin: boolean;
-  senderStaffId?: string;
-  sessionWebhook: string;
-  sessionWebhookExpiredTime: number;
-  createAt: number;
-  senderCorpId?: string;
-  conversationType: '1' | '2';
-  senderId: string;
-  text?: {
-    content: string;
+interface GatewayContext {
+  account: ResolvedDingTalkAccount;
+  cfg: ClawdbotConfig;
+  runtime: ClawdbotCoreRuntime;
+  abortSignal?: AbortSignal;
+  log?: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug?: (msg: string) => void;
   };
-  msgtype: string;
+  setStatus?: (status: Record<string, unknown>) => void;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 }
 
-// Store plugin runtime
-let pluginRuntime: ClawdbotPluginApi | null = null;
-
-// Store session webhooks for reply
-const sessionWebhooks: Map<string, string> = new Map();
-// Store active clients for each account
-const activeClients: Map<string, DWClient> = new Map();
-
-// Helper functions
-function listDingTalkAccountIds(cfg: ClawdbotConfig): string[] {
-  const accounts = cfg.channels?.['moltbot-dingtalk-stream']?.accounts;
-  return accounts ? Object.keys(accounts) : [];
+interface ChannelPlugin {
+  id: string;
+  meta: {
+    id: string;
+    label: string;
+    selectionLabel: string;
+    docsPath: string;
+    docsLabel: string;
+    blurb: string;
+    order: number;
+    aliases: string[];
+  };
+  capabilities: {
+    chatTypes: readonly string[];
+    media?: boolean;
+    threads?: boolean;
+  };
+  reload: { configPrefixes: string[] };
+  configSchema: typeof DingTalkConfigSchema;
+  config: {
+    listAccountIds: (cfg: ClawdbotConfig) => string[];
+    resolveAccount: (cfg: ClawdbotConfig, accountId?: string) => ResolvedDingTalkAccount;
+    defaultAccountId: (cfg: ClawdbotConfig) => string;
+    setAccountEnabled: (opts: { cfg: ClawdbotConfig; accountId: string; enabled: boolean }) => ClawdbotConfig;
+    deleteAccount: (opts: { cfg: ClawdbotConfig; accountId: string }) => ClawdbotConfig;
+    isConfigured: (account: ResolvedDingTalkAccount) => boolean;
+    describeAccount: (account: ResolvedDingTalkAccount) => Record<string, unknown>;
+  };
+  security?: {
+    resolveDmPolicy: (opts: {
+      cfg: ClawdbotConfig;
+      accountId?: string;
+      account: ResolvedDingTalkAccount;
+    }) => {
+      policy: string;
+      allowFrom: string[];
+      allowFromPath: string;
+      normalizeEntry: (raw: string) => string;
+    };
+  };
+  mentions?: {
+    stripPatterns: () => string[];
+  };
+  groups?: {
+    resolveRequireMention: (opts: { cfg: ClawdbotConfig; accountId?: string }) => boolean;
+  };
+  messaging?: {
+    normalizeTarget: (target: string) => string;
+    targetResolver?: {
+      looksLikeId: (id: string) => boolean;
+      hint: string;
+    };
+  };
+  setup?: {
+    resolveAccountId: (opts: { accountId?: string }) => string;
+    applyAccountName: (opts: { cfg: ClawdbotConfig; accountId: string; name?: string }) => ClawdbotConfig;
+    validateInput: (opts: { accountId: string; input: SetupInput }) => string | null;
+    applyAccountConfig: (opts: { cfg: ClawdbotConfig; accountId: string; input: SetupInput }) => ClawdbotConfig;
+  };
+  outbound: {
+    deliveryMode: "direct";
+    textChunkLimit?: number;
+    sendText: (opts: {
+      to: string;
+      text: string;
+      accountId?: string;
+      deps?: Record<string, unknown>;
+      replyToId?: string;
+    }) => Promise<{ channel: string; ok: boolean; error?: string }>;
+    sendMedia?: (opts: {
+      to: string;
+      text: string;
+      mediaUrl: string;
+      accountId?: string;
+    }) => Promise<{ channel: string; ok: boolean; error?: string }>;
+  };
+  status?: {
+    defaultRuntime: {
+      accountId: string;
+      running: boolean;
+      lastStartAt: null;
+      lastStopAt: null;
+      lastError: null;
+    };
+    probeAccount: (opts: { account: ResolvedDingTalkAccount; timeoutMs?: number }) => Promise<{
+      ok: boolean;
+      error?: string;
+      bot?: { name?: string };
+    }>;
+    buildAccountSnapshot: (opts: {
+      account: ResolvedDingTalkAccount;
+      runtime?: Record<string, unknown>;
+      probe?: Record<string, unknown>;
+    }) => Record<string, unknown>;
+  };
+  gateway: {
+    startAccount: (ctx: GatewayContext) => Promise<void>;
+  };
 }
 
-function resolveDingTalkAccount(opts: { cfg: ClawdbotConfig; accountId?: string }): ResolvedDingTalkAccount {
-  const { cfg, accountId = 'default' } = opts;
-  const account = cfg.channels?.['moltbot-dingtalk-stream']?.accounts?.[accountId];
-  return {
-    accountId,
-    name: account?.name,
-    enabled: account?.enabled ?? false,
-    configured: Boolean(account?.clientId && account?.clientSecret),
-    config: account || { clientId: '', clientSecret: '' }
-  };
+interface SetupInput {
+  name?: string;
+  clientId?: string;
+  clientSecret?: string;
+  useEnv?: boolean;
 }
 
+// ============================================================================
+// Channel Meta
+// ============================================================================
+
+const meta = {
+  id: CHANNEL_ID,
+  label: "DingTalk",
+  selectionLabel: "DingTalk Bot (Stream)",
+  docsPath: "/channels/dingtalk",
+  docsLabel: "dingtalk",
+  blurb: "DingTalk bot channel plugin (Stream mode)",
+  order: 100,
+  aliases: ["dt", "ding", "dingtalk"],
+};
+
+// ============================================================================
+// Store plugin runtime reference
+// ============================================================================
+
+let pluginRuntime: ClawdbotPluginApi | null = null;
+
+// ============================================================================
 // DingTalk Channel Plugin
-const dingTalkChannelPlugin = {
-  id: "moltbot-dingtalk-stream",
-  meta: {
-    id: "moltbot-dingtalk-stream",
-    label: "钉钉",
-    selectionLabel: "DingTalk Bot (Stream)",
-    docsPath: "/channels/moltbot-dingtalk-stream",
-    docsLabel: "dingtalk",
-    blurb: "钉钉机器人通道插件 (Stream模式)",
-    order: 100,
-    aliases: ["dt", "ding"],
-  },
+// ============================================================================
+
+export const dingtalkPlugin: ChannelPlugin = {
+  id: CHANNEL_ID,
+  meta,
+
   capabilities: {
-    chatTypes: ["direct", "group"] as const,
+    chatTypes: ["direct", "group"],
+    media: true,
+    threads: false,
+  },
+
+  reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+
+  configSchema: DingTalkConfigSchema,
+
+  // ============================================================================
+  // Config Management
+  // ============================================================================
+  config: {
+    listAccountIds: (cfg) => listDingTalkAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveDingTalkAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultDingTalkAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) =>
+      setAccountEnabledInConfig({ cfg, accountId, enabled }),
+    deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfig({ cfg, accountId }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      tokenSource: account.tokenSource,
+    }),
+  },
+
+  // ============================================================================
+  // Security (DM Policy)
+  // ============================================================================
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+      const channelConfig = cfg.channels?.[CHANNEL_ID];
+      const useAccountPath = Boolean(channelConfig?.accounts?.[resolvedAccountId]);
+      const allowFromPath = useAccountPath
+        ? `channels.${CHANNEL_ID}.accounts.${resolvedAccountId}.dm.`
+        : `channels.${CHANNEL_ID}.dm.`;
+
+      return {
+        policy: account.config.dm?.policy ?? "open",
+        allowFrom: account.config.dm?.allowFrom ?? [],
+        allowFromPath,
+        normalizeEntry: (raw) => raw.replace(/^dingtalk:/i, ""),
+      };
+    },
+  },
+
+  // ============================================================================
+  // Mentions
+  // ============================================================================
+  mentions: {
+    stripPatterns: () => ["@\\S+\\s*"],
   },
-  reload: { configPrefixes: ["channels.moltbot-dingtalk-stream"] },
-  configSchema: {
-    type: "object" as const,
-    properties: {
-      channels: {
-        type: "object" as const,
-        properties: {
-          'moltbot-dingtalk-stream': {
-            type: "object" as const,
-            properties: {
-              accounts: {
-                type: "object" as const,
-                additionalProperties: {
-                  type: "object" as const,
-                  properties: {
-                    enabled: { type: "boolean" as const },
-                    clientId: { type: "string" as const },
-                    clientSecret: { type: "string" as const },
-                    webhookUrl: { type: "string" as const },
-                    name: { type: "string" as const },
-                  },
-                  required: ["clientId", "clientSecret"],
-                },
+
+  // ============================================================================
+  // Groups
+  // ============================================================================
+  groups: {
+    resolveRequireMention: ({ cfg, accountId }) => {
+      const account = resolveDingTalkAccount({ cfg, accountId });
+      return account.config.requireMention ?? true;
+    },
+  },
+
+  // ============================================================================
+  // Messaging
+  // ============================================================================
+  messaging: {
+    normalizeTarget: (target) => {
+      if (target.startsWith("dingtalk:")) return target;
+      if (target.startsWith("group:")) return `dingtalk:${target}`;
+      if (target.startsWith("user:")) return `dingtalk:${target}`;
+      return `dingtalk:${target}`;
+    },
+    targetResolver: {
+      looksLikeId: (id) => /^[a-zA-Z0-9_-]+$/.test(id),
+      hint: "<conversationId|user:ID>",
+    },
+  },
+
+  // ============================================================================
+  // Setup (Account Configuration)
+  // ============================================================================
+  setup: {
+    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+
+    applyAccountName: ({ cfg, accountId, name }) =>
+      applyAccountNameToConfig({ cfg, accountId, name }),
+
+    validateInput: ({ accountId, input }) => {
+      if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) {
+        return "Environment variables can only be used for the default account";
+      }
+      if (!input.useEnv && (!input.clientId || !input.clientSecret)) {
+        return "DingTalk requires clientId and clientSecret";
+      }
+      return null;
+    },
+
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const namedConfig = applyAccountNameToConfig({
+        cfg,
+        accountId,
+        name: input.name,
+      });
+
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+          ...namedConfig,
+          channels: {
+            ...namedConfig.channels,
+            [CHANNEL_ID]: {
+              ...namedConfig.channels?.[CHANNEL_ID],
+              enabled: true,
+              ...(input.useEnv ? {} : { clientId: input.clientId, clientSecret: input.clientSecret }),
+            },
+          },
+        };
+      }
+
+      return {
+        ...namedConfig,
+        channels: {
+          ...namedConfig.channels,
+          [CHANNEL_ID]: {
+            ...namedConfig.channels?.[CHANNEL_ID],
+            enabled: true,
+            accounts: {
+              ...namedConfig.channels?.[CHANNEL_ID]?.accounts,
+              [accountId]: {
+                ...namedConfig.channels?.[CHANNEL_ID]?.accounts?.[accountId],
+                enabled: true,
+                clientId: input.clientId,
+                clientSecret: input.clientSecret,
               },
             },
           },
         },
-      },
+      };
     },
   },
-  config: {
-    listAccountIds: (cfg: ClawdbotConfig) => listDingTalkAccountIds(cfg),
-    resolveAccount: (cfg: ClawdbotConfig, accountId?: string) => resolveDingTalkAccount({ cfg, accountId }),
-    defaultAccountId: (_cfg: ClawdbotConfig) => 'default',
-    isConfigured: (account: ResolvedDingTalkAccount) => account.configured,
-    describeAccount: (account: ResolvedDingTalkAccount) => ({
+
+  // ============================================================================
+  // Outbound (Send Messages)
+  // ============================================================================
+  outbound: {
+    deliveryMode: "direct",
+    textChunkLimit: 2000,
+
+    sendText: async ({ to, text, accountId }) => {
+      const result = await getDingTalkRuntime().channel.dingtalk.sendMessage(to, text, {
+        accountId,
+      });
+      return { channel: CHANNEL_ID, ...result };
+    },
+
+    sendMedia: async ({ to, text, mediaUrl, accountId }) => {
+      const result = await getDingTalkRuntime().channel.dingtalk.sendMessage(to, text, {
+        accountId,
+        mediaUrl,
+      });
+      return { channel: CHANNEL_ID, ...result };
+    },
+  },
+
+  // ============================================================================
+  // Status (Probe & Monitoring)
+  // ============================================================================
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+
+    probeAccount: async ({ account, timeoutMs }) => {
+      if (!account.clientId || !account.clientSecret) {
+        return { ok: false, error: "Missing clientId or clientSecret" };
+      }
+      return getDingTalkRuntime().channel.dingtalk.probe(
+        account.clientId,
+        account.clientSecret,
+        timeoutMs
+      );
+    },
+
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
       accountId: account.accountId,
       name: account.name,
       enabled: account.enabled,
       configured: account.configured,
+      tokenSource: account.tokenSource,
+      running: (runtime as Record<string, unknown>)?.running ?? false,
+      lastStartAt: (runtime as Record<string, unknown>)?.lastStartAt ?? null,
+      lastStopAt: (runtime as Record<string, unknown>)?.lastStopAt ?? null,
+      lastError: (runtime as Record<string, unknown>)?.lastError ?? null,
+      probe,
     }),
   },
+
+  // ============================================================================
+  // Gateway (Start/Stop Bot)
+  // ============================================================================
   gateway: {
-    startAccount: async (ctx: any) => {
-      const account: ResolvedDingTalkAccount = ctx.account;
-      const config = account.config;
+    startAccount: async (ctx) => {
+      const { account, cfg, abortSignal, log, statusSink } = ctx;
       const accountId = account.accountId;
+      const core = pluginRuntime?.runtime;
 
-      if (!config.clientId || !config.clientSecret) {
-        ctx.log?.warn?.(`[${accountId}] missing clientId or clientSecret`);
+      if (!account.clientId || !account.clientSecret) {
+        log?.warn?.(`[${accountId}] Missing clientId or clientSecret`);
         return;
       }
 
-      ctx.log?.info?.(`[${accountId}] starting DingTalk Stream client`);
+      if (!core?.channel?.reply) {
+        log?.error?.(`[${accountId}] runtime.channel.reply not available`);
+        return;
+      }
 
+      log?.info?.(`[${accountId}] Starting DingTalk Stream client`);
+
+      // Probe 检测凭据
       try {
-        const client = new DWClient({
-          clientId: config.clientId,
-          clientSecret: config.clientSecret,
-        });
-
-        // Helper to safely handle messages
-        const handleMessage = async (res: any) => {
-          try {
-            const message = JSON.parse(res.data);
-            const textContent = message.text?.content || "";
-            const senderId = message.senderId;
-            const convoId = message.conversationId;
-            const msgId = message.msgId;
-            // Store session webhook if provided (DingTalk Stream mode provides this for replies)
-            if (message.sessionWebhook) {
-              sessionWebhooks.set(convoId, message.sessionWebhook);
-            }
+        const probe = await getDingTalkRuntime().channel.dingtalk.probe(
+          account.clientId,
+          account.clientSecret,
+          2500
+        );
+        if (probe.ok) {
+          log?.info?.(`[${accountId}] Credentials verified successfully`);
+          ctx.setStatus?.({ accountId, probe });
+        } else {
+          log?.warn?.(`[${accountId}] Credential verification failed: ${probe.error}`);
+        }
+      } catch (err) {
+        log?.debug?.(`[${accountId}] Probe failed: ${String(err)}`);
+      }
 
-            // Log reception
-            ctx.log?.info?.(`[${accountId}] received message from ${message.senderNick || senderId}: ${textContent}`);
-
-            // Filter out empty messages
-            if (!textContent) return;
-
-            // Simple text cleaning (remove @bot mentions if possible, though DingTalk usually gives clean content or we might need to parse entities)
-            const cleanedText = textContent.replace(/@\w+\s*/g, '').trim();
-
-            // Forward the message to Clawdbot for processing
-            if (pluginRuntime?.runtime?.channel?.reply) {
-              const replyModule = pluginRuntime.runtime.channel.reply;
-              const chatType = String(message.conversationType) === '2' ? 'group' : 'direct';
-              const fromAddress = chatType === 'group' ? `dingtalk:group:${convoId}` : `dingtalk:${senderId}`;
-
-              const ctxPayload = {
-                Body: cleanedText,
-                RawBody: textContent,
-                CommandBody: cleanedText,
-                From: fromAddress,
-                To: 'bot',
-                SessionKey: `dingtalk:${convoId}`,
-                AccountId: accountId,
-                ChatType: chatType,
-                SenderName: message.senderNick,
-                SenderId: senderId,
-                Provider: 'dingtalk',
-                Surface: 'dingtalk',
-                MessageSid: message.msgId,
-                Timestamp: message.createAt,
-                // Required for some logic
-                GroupSubject: chatType === 'group' ? (message.conversationId) : undefined,
-              };
-
-              const finalizedCtx = replyModule.finalizeInboundContext(ctxPayload);
-
-              let replyBuffer = "";
-              let replySent = false;
-
-              const sendToDingTalk = async (text: string) => {
-                if (!text) return;
-                if (replySent) {
-                  ctx.log?.info?.(`[${accountId}] Reply already sent, skipping buffer flush.`);
-                  return;
-                }
-
-                const replyWebhook = sessionWebhooks.get(convoId) || config.webhookUrl;
-                if (!replyWebhook) {
-                  ctx.log?.error?.(`[${accountId}] No webhook to reply to ${convoId}`);
-                  return;
-                }
-
-                try {
-                  await axios.post(replyWebhook, {
-                    msgtype: "text",
-                    text: { content: text }
-                  }, { headers: { 'Content-Type': 'application/json' } });
-                  replySent = true;
-                  ctx.log?.info?.(`[${accountId}] Reply sent successfully.`);
-                } catch (e) {
-                  ctx.log?.error?.(`[${accountId}] Failed to send reply: ${e}`);
-                }
-              };
-
-              const dispatcher = {
-                sendFinalReply: (payload: any) => {
-                  const text = payload.text || payload.content || '';
-                  sendToDingTalk(text).catch(e => ctx.log?.error?.(`[${accountId}] sendToDingTalk failed: ${e}`));
-                  return true;
-                },
-                typing: async () => { },
-                reaction: async () => { },
-                isSynchronous: () => false,
-                waitForIdle: async () => { },
-                sendBlockReply: async (block: any) => {
-                  // Accumulate text from blocks
-                  const text = block.text || block.delta || block.content || '';
-                  if (text) {
-                    replyBuffer += text;
-                  }
-                },
-                getQueuedCounts: () => ({ active: 0, queued: 0, final: 0 })
-              };
-
-              // Internal dispatch
-              const dispatchPromise = replyModule.dispatchReplyFromConfig({
-                ctx: finalizedCtx,
-                cfg: pluginRuntime.config,
-                dispatcher: dispatcher,
-                replyOptions: {}
-              });
+      const client = new DWClient({
+        clientId: account.clientId,
+        clientSecret: account.clientSecret,
+      });
 
-              // ACK immediately to prevent retries
-              if (res.headers && res.headers.messageId) {
-                client.socketCallBackResponse(res.headers.messageId, { status: "SUCCEED" });
-              }
+      const handleMessage = async (res: { data: string; headers?: { messageId?: string } }) => {
+        try {
+          const message = JSON.parse(res.data);
+          const textContent = message.text?.content || "";
+          const senderId = message.senderId;
+          const convoId = message.conversationId;
 
-              // Wait for run to finish
-              await dispatchPromise;
+          log?.info?.(`[${accountId}] Received message from ${message.senderNick || senderId}: ${textContent}`);
 
-              // If final reply wasn't called but we have buffer (streaming case where agent didn't return final payload?)
-              if (!replySent && replyBuffer) {
-                ctx.log?.info?.(`[${accountId}] Sending accumulated buffer from blocks (len=${replyBuffer.length}).`);
-                await sendToDingTalk(replyBuffer);
-              }
+          statusSink?.({ lastInboundAt: Date.now() });
 
-            } else {
-              ctx.log?.error?.(`[${accountId}] runtime.channel.reply not available`);
+          if (!textContent) return;
+
+          const rawBody = textContent;
+          const cleanedText = textContent.replace(/@\S+\s*/g, "").trim();
+
+          const chatType = String(message.conversationType) === "2" ? "group" : "direct";
+
+          // Store session webhook with multiple keys for flexible lookup
+          if (message.sessionWebhook) {
+            getDingTalkRuntime().channel.dingtalk.setSessionWebhook(convoId, message.sessionWebhook);
+            if (chatType === "direct" && senderId) {
+              getDingTalkRuntime().channel.dingtalk.setSessionWebhook(senderId, message.sessionWebhook);
+              getDingTalkRuntime().channel.dingtalk.setSessionWebhook(`dingtalk:user:${senderId}`, message.sessionWebhook);
+            }
+            if (chatType === "group" && convoId) {
+              getDingTalkRuntime().channel.dingtalk.setSessionWebhook(`dingtalk:channel:${convoId}`, message.sessionWebhook);
             }
-          } catch (error) {
-            ctx.log?.error?.(`[${accountId}] error processing message: ${error instanceof Error ? error.message : String(error)}`);
-            console.error('DingTalk Handler Error:', error);
           }
-        };
 
-        // Register callback for robot messages
-        client.registerCallbackListener('/v1.0/im/bot/messages/get', handleMessage);
+          const route = core.channel.routing?.resolveAgentRoute?.({
+            cfg,
+            channel: CHANNEL_ID,
+            accountId,
+            peer: {
+              kind: chatType === "group" ? "group" : "direct",
+              id: chatType === "group" ? convoId : senderId,
+            },
+          }) ?? { agentId: "main", sessionKey: `dingtalk:${convoId}`, accountId };
+
+          const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions?.(cfg) ?? {};
+          const body = core.channel.reply.formatAgentEnvelope?.({
+            channel: "DingTalk",
+            from: message.senderNick ?? message.senderId,
+            timestamp: message.createAt,
+            envelope: envelopeOptions,
+            body: cleanedText,
+          }) ?? cleanedText;
+
+          const ctxPayload: InboundContext = {
+            Body: body,
+            RawBody: rawBody,
+            CommandBody: cleanedText,
+            From: `dingtalk:user:${senderId}`,
+            To: chatType === "group" ? `dingtalk:channel:${convoId}` : `dingtalk:user:${senderId}`,
+            SessionKey: route.sessionKey,
+            AccountId: route.accountId,
+            ChatType: chatType,
+            ConversationLabel: chatType === "group" ? convoId : undefined,
+            SenderName: message.senderNick,
+            SenderId: senderId,
+            SenderUsername: message.senderNick,
+            Provider: "dingtalk",
+            Surface: "dingtalk",
+            MessageSid: message.msgId,
+            Timestamp: message.createAt,
+            GroupSubject: chatType === "group" ? convoId : undefined,
+            OriginatingChannel: CHANNEL_ID,
+            OriginatingTo: chatType === "group" ? `dingtalk:channel:${convoId}` : `dingtalk:user:${senderId}`,
+          };
+
+          const finalizedCtx = core.channel.reply.finalizeInboundContext(ctxPayload);
+
+          const storePath = core.channel.session?.resolveStorePath?.(
+            (cfg as Record<string, unknown>).session,
+            { agentId: route.agentId }
+          ) ?? "";
+          
+          if (core.channel.session?.recordInboundSession) {
+            await core.channel.session.recordInboundSession({
+              storePath,
+              sessionKey: route.sessionKey,
+              ctx: finalizedCtx,
+              onRecordError: (err) => {
+                log?.error?.(`[${accountId}] Failed to record session: ${String(err)}`);
+              },
+            });
+          }
 
-        // Connect to DingTalk Stream
-        await client.connect();
-        activeClients.set(accountId, client);
-        ctx.log?.info?.(`[${accountId}] DingTalk Stream client connected`);
+          if (res.headers?.messageId) {
+            client.socketCallBackResponse(res.headers.messageId, { status: "SUCCEED" });
+          }
 
-        // Handle abort signal for cleanup
-        ctx.abortSignal?.addEventListener('abort', () => {
-          ctx.log?.info?.(`[${accountId}] stopping DingTalk Stream client`);
-          client.disconnect();
-          activeClients.delete(accountId);
-        });
+          const DINGTALK_TEXT_LIMIT = 2000;
 
-      } catch (error) {
-        ctx.log?.error?.(`[${accountId}] failed to start: ${error instanceof Error ? error.message : String(error)}`);
-        throw error;
-      }
-    },
-  },
-  outbound: {
-    deliveryMode: "direct" as const,
-    sendText: async (opts: { text: string; account: ResolvedDingTalkAccount; target: string; senderId?: string }) => {
-      const { text, account, target } = opts;
-      const config = account.config;
+          const deliverDingTalkReply = async (payload: { text?: string; content?: string; mediaUrls?: string[] }) => {
+            const text = payload.text || payload.content || "";
+            if (!text) {
+              log?.warn?.(`[${accountId}] Received empty payload`);
+              return;
+            }
 
-      // Try session webhook first (for replies)
-      const sessionWebhook = sessionWebhooks.get(target);
+            log?.info?.(`[${accountId}] Sending reply: ${text.substring(0, 50)}...`);
+            
+            const chunkMode = core.channel.text?.resolveChunkMode?.(cfg, CHANNEL_ID, accountId) ?? "smart";
+            const chunks = core.channel.text?.chunkMarkdownTextWithMode?.(text, DINGTALK_TEXT_LIMIT, chunkMode) ?? [text];
+            
+            for (const chunk of chunks.length > 0 ? chunks : [text]) {
+              if (!chunk) continue;
+              const result = await getDingTalkRuntime().channel.dingtalk.sendMessage(convoId, chunk, {
+                accountId,
+              });
 
-      if (sessionWebhook) {
-        try {
-          await axios.post(sessionWebhook, {
-            msgtype: "text",
-            text: { content: text }
-          }, {
-            headers: { 'Content-Type': 'application/json' }
-          });
-          return { ok: true as const };
-        } catch (error) {
-          // Fall through to webhookUrl
-        }
-      }
+              if (result.ok) {
+                log?.info?.(`[${accountId}] Reply sent successfully`);
+                statusSink?.({ lastOutboundAt: Date.now() });
+              } else {
+                log?.error?.(`[${accountId}] Failed to send reply: ${result.error}`);
+              }
+            }
+          };
 
-      // Fallback to webhookUrl for proactive messages
-      if (config?.webhookUrl) {
-        try {
-          await axios.post(config.webhookUrl, {
-            msgtype: "text",
-            text: { content: text }
-          }, {
-            headers: { 'Content-Type': 'application/json' }
+          log?.info?.(`[${accountId}] Using dispatchReplyWithBufferedBlockDispatcher`);
+
+          await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: finalizedCtx,
+            cfg,
+            dispatcherOptions: {
+              deliver: deliverDingTalkReply,
+              onError: (err, info) => {
+                log?.error?.(`[${accountId}] DingTalk ${info.kind} reply failed: ${String(err)}`);
+              },
+            },
           });
-          return { ok: true as const };
+
+          log?.info?.(`[${accountId}] dispatchReplyWithBufferedBlockDispatcher completed`);
         } catch (error) {
-          return { ok: false as const, error: error instanceof Error ? error.message : String(error) };
+          log?.error?.(
+            `[${accountId}] Error processing message: ${error instanceof Error ? error.message : String(error)}`
+          );
         }
-      }
+      };
 
-      return { ok: false as const, error: "No webhook available for sending messages" };
-    }
-  }
-};
+      client.registerCallbackListener("/v1.0/im/bot/messages/get", handleMessage);
+
+      await client.connect();
+      getDingTalkRuntime().channel.dingtalk.setClient(accountId, client);
+      log?.info?.(`[${accountId}] DingTalk Stream client connected`);
 
+      abortSignal?.addEventListener("abort", () => {
+        log?.info?.(`[${accountId}] Stopping DingTalk Stream client`);
+        client.disconnect();
+        getDingTalkRuntime().channel.dingtalk.removeClient(accountId);
+      });
+    },
+  },
+};
 
+// ============================================================================
+// Plugin Export
+// ============================================================================
 
-// Plugin object format required by Clawdbot
 const plugin = {
-  id: "moltbot-dingtalk-stream",
+  id: CHANNEL_ID,
   name: "DingTalk Channel",
-  description: "DingTalk channel plugin using Stream mode",
-  configSchema: {
-    type: "object" as const,
-    properties: {}
-  },
+  description: "DingTalk channel plugin (Stream mode)",
+
   register(api: ClawdbotPluginApi) {
     pluginRuntime = api;
-    api.registerChannel({ plugin: dingTalkChannelPlugin });
-  }
+    api.registerChannel({ plugin: dingtalkPlugin });
+  },
 };
 
-export default plugin;
+export default plugin;