@yaoyuanchao/dingtalk 1.7.9 → 1.7.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.7.9",
+  "version": "1.7.11",
   "type": "module",
   "description": "DingTalk channel plugin for ClawdBot/OpenClaw with Stream Mode support",
   "license": "MIT",

package/src/channel.ts

@@ -1,6 +1,6 @@
 import { getDingTalkRuntime } from './runtime.js';
 import { resolveDingTalkAccount, listDingTalkAccountIds, resolveDefaultDingTalkAccountId } from './accounts.js';
-import { startDingTalkMonitor } from './monitor.js';
+import { startDingTalkMonitor, getCachedReplyTarget, deliverReply } from './monitor.js';
 import { sendDingTalkRestMessage, uploadMediaFile, sendFileMessage, textToMarkdownFile } from './api.js';
 import { probeDingTalk } from './probe.js';
 
@@ -384,7 +384,40 @@ export const dingtalkPlugin = {
     async handleAction(ctx: any) {
       const { action, params, cfg, accountId, conversationTarget } = ctx;
 
-      // Only handle sendAttachment action
+      // Handle 'send' action: route through deliverReply for sessionWebhook persona
+      if (action === 'send') {
+        const text = params?.text || params?.message;
+        if (!text) return null;
+
+        let target = params?.target || params?.to || conversationTarget;
+        if (!target) return null;
+
+        const { type, id } = parseOutboundTo(target);
+        const cacheKey = (type === 'dm' ? 'dm:' : 'group:') + id;
+        const cached = getCachedReplyTarget(cacheKey);
+
+        // Build a replyTarget — use cached sessionWebhook if available
+        const account = resolveDingTalkAccount({ cfg, accountId });
+        const replyTarget = cached
+          ? { ...cached, account } // refresh account credentials
+          : {
+              sessionWebhook: undefined,
+              sessionWebhookExpiry: 0,
+              conversationId: type === 'group' ? id : '',
+              senderId: type === 'dm' ? id : '',
+              isDm: type === 'dm',
+              account,
+            };
+
+        await deliverReply(replyTarget, text);
+        return {
+          ok: true,
+          channel: 'dingtalk',
+          content: [{ type: 'text', text: JSON.stringify({ ok: true, sent: true }) }],
+        };
+      }
+
+      // Only handle sendAttachment action below
       if (action !== 'sendAttachment') {
         return null; // Let SDK handle other actions
       }

package/src/monitor.ts

@@ -249,6 +249,30 @@ interface BufferedMessage {
 const messageBuffer = new Map<string, BufferedMessage>();
 const AGGREGATION_DELAY_MS = 2000; // 2 seconds - balance between UX and catching split messages
 
+// ============================================================================
+// Reply Target Cache — remember the latest replyTarget (with sessionWebhook)
+// per conversation so that proactive/cron sends can use the persona-preserving
+// sessionWebhook path instead of falling back to robot-identity REST API.
+// ============================================================================
+
+const replyTargetCache = new Map<string, any>();
+const REPLY_TARGET_CACHE_TTL_MS = 3 * 60 * 60 * 1000; // 3 hours
+
+function buildReplyTargetCacheKey(isDm: boolean, conversationId: string, senderId: string): string {
+  return isDm ? `dm:${senderId}` : `group:${conversationId}`;
+}
+
+/** Look up the most recent replyTarget for a conversation (for outbound/cron sends). */
+export function getCachedReplyTarget(cacheKey: string): any | undefined {
+  const entry = replyTargetCache.get(cacheKey);
+  if (!entry) return undefined;
+  if (Date.now() - entry._cachedAt > REPLY_TARGET_CACHE_TTL_MS) {
+    replyTargetCache.delete(cacheKey);
+    return undefined;
+  }
+  return entry;
+}
+
 // ============================================================================
 // Per-Session Message Queue - serializes dispatch to prevent concurrent
 // processing of messages in the same conversation. Uses Promise chaining:
@@ -1358,6 +1382,10 @@ async function processInboundMessage(
     account,
   };
 
+  // Cache replyTarget so proactive/cron sends can use sessionWebhook
+  const rtCacheKey = buildReplyTargetCacheKey(isDm, conversationId, senderId);
+  replyTargetCache.set(rtCacheKey, { ...replyTarget, _cachedAt: Date.now() });
+
   // Check if message aggregation is enabled
   const aggregationEnabled = account.config.messageAggregation !== false;
   const aggregationDelayMs = account.config.messageAggregationDelayMs ?? AGGREGATION_DELAY_MS;
@@ -1465,6 +1493,22 @@ async function flushMessageBuffer(bufferKey: string): Promise<void> {
   });
 }
 
+/**
+ * Resolve queue lane suffix based on message content.
+ * /btw and abort/status commands get their own lanes so they can run
+ * in parallel with the main message queue (matching Feishu/Telegram behaviour).
+ */
+function resolveQueueLane(text: string): string {
+  const t = text.trim();
+  // /btw side question — separate lane
+  if (/^\/btw(\s|:|$)/i.test(t)) return ':btw';
+  // abort / stop — control lane
+  if (/^\/stop(\s|$)/i.test(t) || /^(stop|esc|abort|cancel|exit|halt|interrupt)$/i.test(t)) return ':control';
+  // status commands — control lane
+  if (/^\/(help|commands|tools|status|tasks|context)(\s|$)/i.test(t)) return ':control';
+  return '';
+}
+
 /**
  * Dispatch a message to the agent (after aggregation or immediately).
  * Enqueues into per-session queue to prevent concurrent processing.
@@ -1485,16 +1529,21 @@ async function dispatchMessage(params: {
   const { ctx, conversationId } = params;
   const { account, log } = ctx;
 
-  const queueKey = `${account.accountId}:${conversationId}`;
+  const lane = resolveQueueLane(params.rawBody);
+  const mainQueueKey = `${account.accountId}:${conversationId}`;
+  const queueKey = `${mainQueueKey}${lane}`;
   // Check both the explicit queue AND recent delivery activity.
   // The SDK's dispatchReplyFromConfig may resolve before the agent's full turn
   // completes (followup turns run in background), clearing the queue entry
   // while deliveries are still happening.
-  const isQueueBusy = sessionQueues.has(queueKey) || hasActiveDelivery(queueKey);
+  // btw/control lanes check against their OWN key (not the main queue) —
+  // they are allowed to run in parallel with the main queue.
+  const isQueueBusy = sessionQueues.has(queueKey) || (lane === '' && hasActiveDelivery(mainQueueKey));
 
   // If queue is busy, add emotion reaction on user's message to indicate queued
+  // (skip for btw/control lanes — they bypass the main queue by design)
   let queueAckCleanup: (() => Promise<void>) | null = null;
-  if (isQueueBusy) {
+  if (isQueueBusy && lane === '') {
     log?.info?.("[dingtalk] Queue busy for " + queueKey + ", adding queue reaction");
     try {
       if (account.clientId && account.clientSecret && params.msg.msgId && conversationId) {
@@ -1977,7 +2026,7 @@ function buildMarkdownPreviewTitle(text: string, fallback = "Jax"): string {
   return fallback;
 }
 
-async function deliverReply(target: any, text: string, log?: any): Promise<void> {
+export async function deliverReply(target: any, text: string, log?: any): Promise<void> {
   const now = Date.now();
   const chunkLimit = target.account.config.textChunkLimit ?? 2000;
   const messageFormat = target.account.config.messageFormat ?? "text";