@openclaw-china/dingtalk 0.1.23 → 0.1.25

package/dist/index.d.ts

@@ -532,6 +532,24 @@ interface PluginRuntime {
                 agentId?: string;
             };
         };
+        session?: {
+            resolveStorePath?: (store: unknown, params: {
+                agentId?: string;
+            }) => string | undefined;
+            recordInboundSession?: (params: {
+                storePath: string;
+                sessionKey: string;
+                ctx: unknown;
+                updateLastRoute?: {
+                    sessionKey: string;
+                    channel: string;
+                    to: string;
+                    accountId?: string;
+                    threadId?: string | number;
+                };
+                onRecordError?: (err: unknown) => void;
+            }) => Promise<void>;
+        };
         reply?: {
             dispatchReplyFromConfig?: (params: {
                 ctx: unknown;

package/dist/index.js

@@ -4088,7 +4088,7 @@ var DingtalkConfigSchema = external_exports.object({
   /** 媒体文件大小限制 (MB)，默认 100MB */
   maxFileSizeMB: external_exports.number().positive().optional().default(100),
   /** 仅发送最终回复（非流式） */
-  replyFinalOnly: external_exports.boolean().optional().default(true)
+  replyFinalOnly: external_exports.boolean().optional().default(false)
 });
 function isConfigured(config) {
   return Boolean(config?.clientId && config?.clientSecret);
@@ -4110,7 +4110,8 @@ function createDingtalkClient(opts) {
   }
   const client = new DWClient({
     clientId: opts.clientId,
-    clientSecret: opts.clientSecret
+    clientSecret: opts.clientSecret,
+    ...opts.ua ? { ua: opts.ua } : {}
   });
   cachedClient = client;
   cachedConfig = {
@@ -4124,7 +4125,10 @@ function createDingtalkClientFromConfig(cfg) {
   if (!creds) {
     throw new Error("DingTalk credentials not configured (clientId, clientSecret required)");
   }
-  return createDingtalkClient(creds);
+  return createDingtalkClient({
+    ...creds,
+    ua: "openclaw-dingtalk"
+  });
 }
 var DINGTALK_OAUTH_URL = "https://api.dingtalk.com/v1.0/oauth2/accessToken";
 var TOKEN_REQUEST_TIMEOUT = 1e4;
@@ -4954,6 +4958,96 @@ function extractMediaFromText(text, options = {}) {
     all: [...images, ...files]
   };
 }
+
+// ../../packages/shared/src/cron/index.ts
+var CRON_HIDDEN_PROMPT = `
+When creating or updating a cron task, use the main session's last route as the delivery target.
+- Do not ask the user for userId/chatId
+- sessionTarget="isolated"
+- payload.kind="agentTurn"
+- payload.deliver=true
+- Do not set payload.channel/to (fall back to last route automatically)
+- Do not call the message tool to send`;
+var CRON_TRIGGER_KEYWORDS = [
+  "\u5B9A\u65F6",
+  "\u63D0\u9192",
+  "\u6BCF\u5206\u949F",
+  "\u6BCF\u5C0F\u65F6",
+  "\u6BCF\u5929",
+  "\u6BCF\u5468",
+  "\u51E0\u70B9",
+  "\u65E9\u4E0A",
+  "\u665A\u4E0A",
+  "\u5DE5\u4F5C\u65E5",
+  "cron",
+  "remind",
+  "reminder",
+  "schedule",
+  "scheduled",
+  "every minute",
+  "every hour",
+  "every day",
+  "daily",
+  "every week",
+  "weekly",
+  "weekday",
+  "workday",
+  "morning",
+  "evening"
+];
+var CRON_TRIGGER_PATTERNS = [
+  /提醒我/u,
+  /帮我定时/u,
+  /每.+提醒/u,
+  /每天.+发/u,
+  /remind me/iu,
+  /set (a )?reminder/iu,
+  /every .+ remind/iu,
+  /every day .+ (send|post|notify)/iu,
+  /schedule .+ (reminder|message|notification)/iu
+];
+var CRON_EXCLUDE_PATTERNS = [
+  /是什么意思/u,
+  /区别/u,
+  /为什么/u,
+  /\bhelp\b/iu,
+  /文档/u,
+  /怎么用/u,
+  /what does|what's|meaning of/iu,
+  /difference/iu,
+  /why/iu,
+  /\bdocs?\b/iu,
+  /documentation/iu,
+  /how to/iu,
+  /usage/iu
+];
+function shouldInjectCronHiddenPrompt(text) {
+  const normalized = text.trim();
+  if (!normalized) return false;
+  const lowered = normalized.toLowerCase();
+  for (const pattern of CRON_EXCLUDE_PATTERNS) {
+    if (pattern.test(lowered)) return false;
+  }
+  for (const keyword of CRON_TRIGGER_KEYWORDS) {
+    if (lowered.includes(keyword.toLowerCase())) return true;
+  }
+  return CRON_TRIGGER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function splitCronHiddenPrompt(text) {
+  const idx = text.indexOf(CRON_HIDDEN_PROMPT);
+  if (idx === -1) {
+    return { base: text };
+  }
+  const base = text.slice(0, idx).trimEnd();
+  return { base, prompt: CRON_HIDDEN_PROMPT };
+}
+function appendCronHiddenPrompt(text) {
+  if (!shouldInjectCronHiddenPrompt(text)) return text;
+  if (text.includes(CRON_HIDDEN_PROMPT)) return text;
+  return `${text}
+
+${CRON_HIDDEN_PROMPT}`;
+}
 var FileSizeLimitError2 = class _FileSizeLimitError extends Error {
   /** Actual file size in bytes */
   actualSize;
@@ -5975,7 +6069,8 @@ async function finishAICard(card, content, log) {
 
 // src/bot.ts
 function buildGatewayUserContent(inboundCtx, logger) {
-  const base = inboundCtx.Body ?? "";
+  const base = inboundCtx.CommandBody ?? inboundCtx.Body ?? "";
+  const { base: baseText, prompt } = splitCronHiddenPrompt(base);
   const rawPaths = [];
   if (typeof inboundCtx.MediaPath === "string") {
     rawPaths.push(inboundCtx.MediaPath);
@@ -5995,13 +6090,18 @@ function buildGatewayUserContent(inboundCtx, logger) {
     files.add(localPath);
   }
   if (files.size === 0) {
-    return base;
+    return prompt ? `${baseText}
+
+${prompt}` : baseText;
   }
   const list = Array.from(files).map((p) => `- ${p}`).join("\n");
-  return `${base}
+  const content = `${baseText}
 
 [local files]
 ${list}`;
+  return prompt ? `${content}
+
+${prompt}` : content;
 }
 function extractLocalMediaFromText(params) {
   const { text, logger } = params;
@@ -6046,6 +6146,22 @@ function extractMediaLinesFromText(params) {
   const mediaUrls = result.all.map((m) => m.isLocal ? m.localPath ?? m.source : m.source).filter((m) => typeof m === "string" && m.trim().length > 0);
   return { text: result.text, mediaUrls };
 }
+function resolveAudioRecognition(raw) {
+  if (raw.msgtype !== "audio") return void 0;
+  if (!raw.content) return void 0;
+  const contentObj = typeof raw.content === "string" ? (() => {
+    try {
+      return JSON.parse(raw.content);
+    } catch {
+      return null;
+    }
+  })() : raw.content;
+  if (!contentObj || typeof contentObj !== "object") return void 0;
+  const recognition = contentObj.recognition;
+  if (typeof recognition !== "string") return void 0;
+  const trimmed = recognition.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
 function resolveGatewayAuthFromConfigFile(logger) {
   try {
     const fs5 = __require("fs");
@@ -6152,16 +6268,10 @@ function parseDingtalkMessage(raw) {
   let content = "";
   if (raw.msgtype === "text" && raw.text?.content) {
     content = raw.text.content.trim();
-  } else if (raw.msgtype === "audio" && raw.content) {
-    const contentObj = typeof raw.content === "string" ? (() => {
-      try {
-        return JSON.parse(raw.content);
-      } catch {
-        return null;
-      }
-    })() : raw.content;
-    if (contentObj && typeof contentObj === "object" && "recognition" in contentObj && typeof contentObj.recognition === "string") {
-      content = contentObj.recognition.trim();
+  } else if (raw.msgtype === "audio") {
+    const recognition = resolveAudioRecognition(raw);
+    if (recognition) {
+      content = recognition;
     }
   }
   const mentionedBot = resolveMentionedBot(raw);
@@ -6383,6 +6493,7 @@ async function handleDingtalkMessage(params) {
   });
   const ctx = parseDingtalkMessage(raw);
   const isGroup = ctx.chatType === "group";
+  const audioRecognition = resolveAudioRecognition(raw);
   logger.debug(`raw message: msgtype=${raw.msgtype}, hasText=${!!raw.text?.content}, hasContent=${!!raw.content}, textContent="${raw.text?.content ?? ""}"`);
   if (raw.msgtype === "richText") {
     try {
@@ -6472,30 +6583,34 @@ async function handleDingtalkMessage(params) {
     let richTextParseResult = null;
     const mediaTypes = ["picture", "video", "audio", "file"];
     if (mediaTypes.includes(raw.msgtype)) {
-      try {
-        extractedFileInfo = extractFileFromMessage(raw);
-        if (extractedFileInfo && channelCfg?.clientId && channelCfg?.clientSecret) {
-          const accessToken = await getAccessToken(channelCfg.clientId, channelCfg.clientSecret);
-          downloadedMedia = await downloadDingTalkFile({
-            downloadCode: extractedFileInfo.downloadCode,
-            robotCode: channelCfg.clientId,
-            accessToken,
-            fileName: extractedFileInfo.fileName,
-            msgType: extractedFileInfo.msgType,
-            log: logger,
-            maxFileSizeMB: channelCfg.maxFileSizeMB
-          });
-          logger.debug(`downloaded media file: ${downloadedMedia.path} (${downloadedMedia.size} bytes)`);
-          mediaBody = buildFileContextMessage(
-            extractedFileInfo.msgType,
-            extractedFileInfo.fileName
-          );
+      if (raw.msgtype === "audio" && audioRecognition) {
+        logger.debug("[audio] recognition present; treat as text and skip audio file download");
+      } else {
+        try {
+          extractedFileInfo = extractFileFromMessage(raw);
+          if (extractedFileInfo && channelCfg?.clientId && channelCfg?.clientSecret) {
+            const accessToken = await getAccessToken(channelCfg.clientId, channelCfg.clientSecret);
+            downloadedMedia = await downloadDingTalkFile({
+              downloadCode: extractedFileInfo.downloadCode,
+              robotCode: channelCfg.clientId,
+              accessToken,
+              fileName: extractedFileInfo.fileName,
+              msgType: extractedFileInfo.msgType,
+              log: logger,
+              maxFileSizeMB: channelCfg.maxFileSizeMB
+            });
+            logger.debug(`downloaded media file: ${downloadedMedia.path} (${downloadedMedia.size} bytes)`);
+            mediaBody = buildFileContextMessage(
+              extractedFileInfo.msgType,
+              extractedFileInfo.fileName
+            );
+          }
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          logger.warn(`media download failed, continuing with text: ${errorMessage}`);
+          downloadedMedia = null;
+          extractedFileInfo = null;
         }
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        logger.warn(`media download failed, continuing with text: ${errorMessage}`);
-        downloadedMedia = null;
-        extractedFileInfo = null;
       }
     }
     if (raw.msgtype === "richText") {
@@ -6547,6 +6662,9 @@ async function handleDingtalkMessage(params) {
       }
     }
     const inboundCtx = buildInboundContext(ctx, route?.sessionKey, route?.accountId);
+    if (audioRecognition) {
+      inboundCtx.Transcript = audioRecognition;
+    }
     if (downloadedMedia) {
       inboundCtx.MediaPath = downloadedMedia.path;
       inboundCtx.MediaType = downloadedMedia.contentType;
@@ -6583,6 +6701,51 @@ async function handleDingtalkMessage(params) {
     }
     const finalizeInboundContext = replyApi?.finalizeInboundContext;
     const finalCtx = finalizeInboundContext ? finalizeInboundContext(inboundCtx) : inboundCtx;
+    let cronSource = "";
+    let cronBase = "";
+    if (typeof finalCtx.RawBody === "string" && finalCtx.RawBody) {
+      cronSource = "RawBody";
+      cronBase = finalCtx.RawBody;
+    } else if (typeof finalCtx.Body === "string" && finalCtx.Body) {
+      cronSource = "Body";
+      cronBase = finalCtx.Body;
+    } else if (typeof finalCtx.CommandBody === "string" && finalCtx.CommandBody) {
+      cronSource = "CommandBody";
+      cronBase = finalCtx.CommandBody;
+    }
+    if (cronBase) {
+      const nextCron = appendCronHiddenPrompt(cronBase);
+      const injected = nextCron !== cronBase;
+      if (injected) {
+        finalCtx.BodyForAgent = nextCron;
+      }
+    }
+    const channelSession = coreChannel?.session;
+    const storePath = channelSession?.resolveStorePath?.(
+      cfg?.session?.store,
+      { agentId: route?.agentId }
+    );
+    if (channelSession?.recordInboundSession && storePath) {
+      const mainSessionKeyRaw = route?.mainSessionKey;
+      const mainSessionKey = typeof mainSessionKeyRaw === "string" && mainSessionKeyRaw.trim() ? mainSessionKeyRaw : void 0;
+      const updateLastRoute = !isGroup && mainSessionKey ? {
+        sessionKey: mainSessionKey,
+        channel: "dingtalk",
+        to: finalCtx.OriginatingTo ?? finalCtx.To ?? `user:${ctx.senderId}`,
+        accountId: route?.accountId
+      } : void 0;
+      const recordSessionKeyRaw = finalCtx.SessionKey ?? route.sessionKey;
+      const recordSessionKey = typeof recordSessionKeyRaw === "string" && recordSessionKeyRaw.trim() ? recordSessionKeyRaw : String(recordSessionKeyRaw ?? "");
+      await channelSession.recordInboundSession({
+        storePath,
+        sessionKey: recordSessionKey,
+        ctx: finalCtx,
+        updateLastRoute,
+        onRecordError: (err) => {
+          logger.error(`dingtalk: failed updating session meta: ${String(err)}`);
+        }
+      });
+    }
     const dingtalkCfgResolved = channelCfg;
     if (!dingtalkCfgResolved) {
       logger.warn("channel config missing, skipping dispatch");
@@ -6935,6 +7098,14 @@ var currentAccountId = null;
 var currentPromise = null;
 var processedMessages = /* @__PURE__ */ new Map();
 var MESSAGE_DEDUP_TTL_MS = 6e4;
+var WATCHDOG_INTERVAL_MS = 1e4;
+var CONNECT_TIMEOUT_MS = 3e4;
+var REGISTER_TIMEOUT_MS = 3e4;
+var DISCONNECT_GRACE_MS = 15e3;
+var MIN_RECONNECT_INTERVAL_MS = 1e4;
+function getClientState(client) {
+  return client;
+}
 async function monitorDingtalkProvider(opts = {}) {
   const { config, runtime: runtime2, abortSignal, accountId = "default" } = opts;
   const logger = createLogger("dingtalk", {
@@ -6968,7 +7139,47 @@ async function monitorDingtalkProvider(opts = {}) {
   logger.info(`starting Stream connection for account ${accountId}...`);
   currentPromise = new Promise((resolve2, reject) => {
     let stopped = false;
+    let watchdogId = null;
+    let lastSocket = null;
+    let connectStartedAt = Date.now();
+    let lastConnectedAt = null;
+    let lastReconnectAt = 0;
+    const attachSocketListeners = () => {
+      const { socket } = getClientState(client);
+      if (!socket || socket === lastSocket) return;
+      lastSocket = socket;
+      socket.once("open", () => {
+        const now = Date.now();
+        connectStartedAt = now;
+        lastConnectedAt = now;
+        logger.info("Stream socket opened");
+      });
+      socket.once("close", () => {
+        logger.warn("Stream socket closed");
+      });
+      socket.once("error", (err) => {
+        logger.warn(`Stream socket error: ${String(err)}`);
+      });
+    };
+    const forceReconnect = (reason) => {
+      const now = Date.now();
+      if (now - lastReconnectAt < MIN_RECONNECT_INTERVAL_MS) {
+        return;
+      }
+      lastReconnectAt = now;
+      logger.warn(`[reconnect] forcing reconnect: ${reason}`);
+      try {
+        const { socket } = getClientState(client);
+        socket?.terminate?.();
+      } catch (err) {
+        logger.error(`failed to terminate socket: ${String(err)}`);
+      }
+    };
     const cleanup = () => {
+      if (watchdogId) {
+        clearInterval(watchdogId);
+        watchdogId = null;
+      }
       if (currentClient === client) {
         currentClient = null;
         currentAccountId = null;
@@ -7066,8 +7277,42 @@ async function monitorDingtalkProvider(opts = {}) {
           logger.error(`error parsing message: ${String(err)}`);
         }
       });
+      watchdogId = setInterval(() => {
+        if (stopped) return;
+        attachSocketListeners();
+        const now = Date.now();
+        const state = getClientState(client);
+        const connected = state.connected === true;
+        const registered = state.registered === true;
+        if (connected) {
+          lastConnectedAt = now;
+        }
+        if (!connected && now - connectStartedAt > CONNECT_TIMEOUT_MS) {
+          forceReconnect("connect timeout");
+          connectStartedAt = now;
+          lastConnectedAt = null;
+          return;
+        }
+        if (connected && !registered && now - connectStartedAt > REGISTER_TIMEOUT_MS) {
+          forceReconnect("register timeout");
+          connectStartedAt = now;
+          lastConnectedAt = null;
+          return;
+        }
+        if (!connected) {
+          const lastSeen = lastConnectedAt ?? connectStartedAt;
+          if (now - lastSeen > DISCONNECT_GRACE_MS) {
+            forceReconnect("client marked disconnected");
+            connectStartedAt = now;
+            lastConnectedAt = null;
+          }
+        }
+      }, WATCHDOG_INTERVAL_MS);
+      connectStartedAt = Date.now();
+      lastConnectedAt = null;
+      attachSocketListeners();
       client.connect();
-      logger.info("Stream client connected");
+      logger.info("Stream client connect invoked");
     } catch (err) {
       logger.error(`failed to start Stream connection: ${String(err)}`);
       finalizeReject(err);