@soimy/dingtalk 3.5.1 → 3.5.2

package/src/logger-context.ts

@@ -1,17 +1,31 @@
 import type { Logger } from "./types";
 
 let currentLogger: Logger | undefined;
+const loggerByAccountId = new Map<string, Logger>();
 
 /**
  * Persist current request logger for shared services invoked outside handler scope.
  */
-export function setCurrentLogger(log?: Logger): void {
+export function setCurrentLogger(log?: Logger, accountId?: string | null): void {
   currentLogger = log;
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (!normalizedAccountId) {
+    return;
+  }
+  if (log) {
+    loggerByAccountId.set(normalizedAccountId, log);
+    return;
+  }
+  loggerByAccountId.delete(normalizedAccountId);
 }
 
 /**
  * Read current logger bound by inbound handler.
  */
-export function getLogger(): Logger | undefined {
+export function getLogger(accountId?: string | null): Logger | undefined {
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (normalizedAccountId) {
+    return loggerByAccountId.get(normalizedAccountId);
+  }
   return currentLogger;
 }

package/src/media-utils.ts

@@ -11,7 +11,7 @@ import * as path from "node:path";
 import { promises as fsPromises } from "node:fs";
 import { lookup as dnsLookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
-import axios from "axios";
+import axios from "./http-client";
 import FormData from "form-data";
 import type { DingTalkConfig, Logger } from "./types";
 import { formatDingTalkErrorPayloadLog, getProxyBypassOption } from "./utils";
@@ -26,7 +26,7 @@ interface PluginRuntimeWithMedia {
   media?: {
     loadWebMedia(
       mediaPath: string,
-      options?: { mediaLocalRoots?: string[] },
+      options?: { localRoots?: readonly string[] | "any" },
     ): Promise<{ buffer: Buffer | ArrayBuffer; fileName?: string; contentType?: string } | null>;
   };
   [key: string]: unknown;
@@ -667,7 +667,7 @@ async function readMediaBuffer(
   }
 
   const media = await rt.media.loadWebMedia(mediaPath, {
-    mediaLocalRoots: options?.mediaLocalRoots,
+    localRoots: options?.mediaLocalRoots,
   });
 
   if (!media || !media.buffer) {

package/src/{attachment-text-extractor.ts → messaging/attachment-text-extractor.ts}

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import type { AttachmentTextSource } from "./types";
+import type { AttachmentTextSource } from "../types";
 
 const MAX_EXTRACTED_TEXT_CHARS = 6000;
 const MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;

package/src/{quoted-file-service.ts → messaging/quoted-file-service.ts}

@@ -1,10 +1,10 @@
 import http from "node:http";
 import https from "node:https";
-import axios from "axios";
-import { getAccessToken } from "./auth";
-import { getDingTalkRuntime } from "./runtime";
-import type { DingTalkConfig, Logger, MediaFile } from "./types";
-import { formatDingTalkErrorPayload, formatDingTalkErrorPayloadLog } from "./utils";
+import axios from "../http-client";
+import { getAccessToken } from "../auth";
+import { getDingTalkRuntime } from "../runtime";
+import type { DingTalkConfig, Logger, MediaFile } from "../types";
+import { formatDingTalkErrorPayload, formatDingTalkErrorPayloadLog } from "../utils";
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
     if (!value || typeof value !== "object" || Array.isArray(value)) {

package/src/reply-strategy-card.ts

@@ -10,6 +10,7 @@ import {
   finishAICard,
   isCardInTerminalState,
 } from "./card-service";
+import { createReasoningBlockAssembler } from "./card/reasoning-block-assembler";
 import { createCardDraftController } from "./card-draft-controller";
 import { attachCardRunController } from "./card/card-run-registry";
 import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy";
@@ -18,7 +19,7 @@ import type { AICardInstance } from "./types";
 import { AICardStatus } from "./types";
 import { formatDingTalkErrorPayloadLog } from "./utils";
 
-const FILE_ONLY_FALLBACK_ANSWER = "附件已发送，请查收。";
+const EMPTY_FINAL_REPLY = "✅ Done";
 
 export function createCardReplyStrategy(
   ctx: ReplyStrategyContext & { card: AICardInstance; isStopRequested?: () => boolean },
@@ -26,6 +27,7 @@ export function createCardReplyStrategy(
   const { card, config, log, isStopRequested } = ctx;
 
   const controller = createCardDraftController({ card, log });
+  const reasoningAssembler = createReasoningBlockAssembler();
   if (card.outTrackId) {
     attachCardRunController(card.outTrackId, controller);
   }
@@ -33,25 +35,61 @@ export function createCardReplyStrategy(
   let sawFinalDelivery = false;
 
   const getRenderedTimeline = (options: { preferFinalAnswer?: boolean } = {}): string => {
-    const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? FILE_ONLY_FALLBACK_ANSWER : undefined);
+    const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
     return controller.getRenderedContent({
       fallbackAnswer,
       overrideAnswer: options.preferFinalAnswer ? finalTextForFallback : undefined,
     });
   };
 
+  const appendAssembledThinkingBlocks = async (blocks: string[]): Promise<void> => {
+    for (const block of blocks) {
+      if (!block.trim() || isStopRequested?.()) {
+        continue;
+      }
+      await controller.appendThinkingBlock(block);
+    }
+  };
+
+  const ingestReasoningSnapshot = async (text: string | undefined): Promise<void> => {
+    const blocks = reasoningAssembler.ingestSnapshot(text);
+    if (
+      blocks.length === 0
+      && typeof text === "string"
+      && text.trim()
+      && !text.trimStart().startsWith("Reasoning:")
+    ) {
+      await appendAssembledThinkingBlocks([text.trim()]);
+      return;
+    }
+    await appendAssembledThinkingBlocks(blocks);
+  };
+
+  const flushPendingReasoning = async (): Promise<void> => {
+    const blocks = reasoningAssembler.flushPendingAtBoundary();
+    await appendAssembledThinkingBlocks(blocks);
+  };
+
   return {
     getReplyOptions(): ReplyOptions {
       return {
-        // Card mode: intermediate blocks are unused — card updates go through
-        // onPartialReply (real-time) or deliver(final) -> finishAICard.
-        disableBlockStreaming: true,
+        // Card mode keeps runtime block streaming disabled, but still consumes
+        // reasoning blocks through explicit callbacks and delivery metadata.
+        disableBlockStreaming: ctx.disableBlockStreaming ?? true,
 
         onAssistantMessageStart: async () => {
           if (isStopRequested?.()) {
             return;
           }
-          await controller.notifyNewAssistantTurn();
+          const pendingReasoningBlocks = reasoningAssembler.flushPendingAtBoundary();
+          reasoningAssembler.reset();
+          const turnBoundary = controller.notifyNewAssistantTurn();
+          if (pendingReasoningBlocks.length > 0) {
+            await turnBoundary;
+            await appendAssembledThinkingBlocks(pendingReasoningBlocks);
+            return;
+          }
+          await turnBoundary;
         },
 
         onPartialReply: config.cardRealTimeStream
@@ -64,7 +102,7 @@ export function createCardReplyStrategy(
 
         onReasoningStream: async (payload) => {
           if (payload.text && !isStopRequested?.()) {
-            await controller.updateThinking(payload.text);
+            await ingestReasoningSnapshot(payload.text);
           }
         },
       };
@@ -82,6 +120,7 @@ export function createCardReplyStrategy(
 
       // ---- final: defer to finalize, just save text ----
       if (payload.kind === "final") {
+        await flushPendingReasoning();
         sawFinalDelivery = true;
         log?.info?.(
           `[DingTalk][Finalize] deliver(final) received — cardState=${card.state} ` +
@@ -106,6 +145,7 @@ export function createCardReplyStrategy(
           log?.debug?.("[DingTalk] Card failed, skipping tool result (will send full reply on final)");
           return;
         }
+        await flushPendingReasoning();
         log?.info?.(
           `[DingTalk] Tool result received, streaming to AI Card: ${(textToSend ?? "").slice(0, 100)}`,
         );
@@ -113,7 +153,16 @@ export function createCardReplyStrategy(
         return;
       }
 
-      // ---- block: only handle media (text blocks are unused) ----
+      const isReasoningBlock = payload.isReasoning === true;
+      if (typeof textToSend === "string" && textToSend.trim()) {
+        if (isReasoningBlock) {
+          await ingestReasoningSnapshot(textToSend);
+        } else {
+          await controller.updateAnswer(textToSend);
+        }
+      }
+
+      // ---- block: only handle reasoning/media (other text blocks are unused) ----
       if (payload.mediaUrls.length > 0) {
         await ctx.deliverMedia(payload.mediaUrls);
       }
@@ -173,13 +222,15 @@ export function createCardReplyStrategy(
 
       // Normal finalize.
       try {
+        await flushPendingReasoning();
         await controller.flush();
         await controller.waitForInFlight();
-        const finalText = getRenderedTimeline() || "✅ Done";
+        const renderedTimeline = getRenderedTimeline({ preferFinalAnswer: true });
+        const finalText = renderedTimeline || EMPTY_FINAL_REPLY;
         controller.stop();
         log?.info?.(
           `[DingTalk][Finalize] Calling finishAICard — finalTextLen=${finalText.length} ` +
-          `source=${controller.getFinalAnswerContent() ? "timeline.answer" : sawFinalDelivery ? "timeline.fileOnly" : "fallbackDone"} ` +
+          `source=${finalTextForFallback ? "final.payload" : controller.getFinalAnswerContent() ? "timeline.answer" : sawFinalDelivery ? "timeline.fileOnly" : "fallbackDone"} ` +
           `preview="${finalText.slice(0, 120)}"`,
         );
         await finishAICard(card, finalText, log, {
@@ -228,9 +279,9 @@ export function createCardReplyStrategy(
     },
 
     getFinalText(): string | undefined {
-      return controller.getFinalAnswerContent()
-        || finalTextForFallback
-        || (sawFinalDelivery ? FILE_ONLY_FALLBACK_ANSWER : undefined);
+      return finalTextForFallback
+        || controller.getFinalAnswerContent()
+        || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
     },
   };
 }

package/src/reply-strategy-markdown.ts

@@ -1,47 +1,152 @@
 /**
  * Markdown / text reply strategy.
  *
- * Buffers all blocks (disableBlockStreaming=true) and delivers the
- * final text as a single message via sendMessage.
+ * DingTalk cannot edit prior messages in place, so markdown mode emits
+ * incremental answer tails from dispatcher-delivered block/final payloads.
+ * Reasoning display is intentionally unsupported on DingTalk markdown.
  */
 
 import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy";
 import { sendMessage } from "./send-service";
 
+const EMPTY_FINAL_FALLBACK_TEXT = "✅ Done";
+
+function renderQuotedSegment(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.length > 0 ? `> ${line}` : ">")
+    .join("\n");
+}
+
+function computeIncrementalSuffix(previous: string, next: string): string {
+  const prev = previous || "";
+  const current = next || "";
+  if (!current.trim()) {
+    return "";
+  }
+  if (!prev) {
+    return current;
+  }
+  if (!current.startsWith(prev)) {
+    return "";
+  }
+  const suffix = current.slice(prev.length);
+  return suffix.trim() ? suffix : "";
+}
+
+function computeSharedPrefixTail(previous: string, next: string): string {
+  const prev = previous || "";
+  const current = next || "";
+  if (!prev || !current.trim()) {
+    return "";
+  }
+  const limit = Math.min(prev.length, current.length);
+  let sharedPrefixLength = 0;
+  while (sharedPrefixLength < limit && prev[sharedPrefixLength] === current[sharedPrefixLength]) {
+    sharedPrefixLength += 1;
+  }
+  if (sharedPrefixLength === 0) {
+    return "";
+  }
+  const suffix = current.slice(sharedPrefixLength);
+  return suffix.trim() ? suffix : "";
+}
+
 export function createMarkdownReplyStrategy(
   ctx: ReplyStrategyContext,
 ): ReplyStrategy {
   let finalText: string | undefined;
+  let activeAnswerText = "";
+  let lastSentAnswerText = "";
+  let sentVisibleContent = false;
+
+  const sendMarkdownSegment = async (text: string): Promise<void> => {
+    if (!text.trim()) {
+      return;
+    }
+    const sendResult = await sendMessage(ctx.config, ctx.to, text, {
+      sessionWebhook: ctx.sessionWebhook,
+      atUserId: !ctx.isDirect ? ctx.senderId : null,
+      log: ctx.log,
+      accountId: ctx.accountId,
+      storePath: ctx.storePath,
+      conversationId: ctx.groupId,
+      quotedRef: ctx.replyQuotedRef,
+    });
+    if (!sendResult.ok) {
+      throw new Error(sendResult.error || "Reply send failed");
+    }
+    sentVisibleContent = true;
+  };
+
+  const emitAnswerSuffix = async (text: string | undefined): Promise<void> => {
+    const current = typeof text === "string" ? text : "";
+    if (current.length > 0) {
+      activeAnswerText = current;
+      finalText = current;
+    }
+
+    const suffix = computeIncrementalSuffix(lastSentAnswerText, current);
+    if (suffix) {
+      await sendMarkdownSegment(suffix);
+      lastSentAnswerText = current;
+      return;
+    }
+
+    if (current.trim() && lastSentAnswerText && !current.startsWith(lastSentAnswerText)) {
+      const suffix = computeSharedPrefixTail(lastSentAnswerText, current);
+      ctx.log?.warn?.(
+        `[DingTalk][Markdown] answer prefix drift detected; falling back to shared-prefix tail ` +
+        `prevLen=${lastSentAnswerText.length} currentLen=${current.length}`,
+      );
+      lastSentAnswerText = "";
+      if (suffix) {
+        await sendMarkdownSegment(suffix);
+        lastSentAnswerText = current;
+        return;
+      }
+      await sendMarkdownSegment(current);
+      lastSentAnswerText = current;
+    }
+  };
 
   return {
     getReplyOptions(): ReplyOptions {
-      return { disableBlockStreaming: true };
+      return {
+        disableBlockStreaming: ctx.disableBlockStreaming === true,
+      };
     },
 
     async deliver(payload: DeliverPayload): Promise<void> {
       if (payload.mediaUrls.length > 0) {
         await ctx.deliverMedia(payload.mediaUrls);
+        sentVisibleContent = true;
       }
 
-      if (payload.kind === "final" && typeof payload.text === "string" && payload.text.length > 0) {
-        finalText = payload.text;
-        const sendResult = await sendMessage(ctx.config, ctx.to, payload.text, {
-          sessionWebhook: ctx.sessionWebhook,
-          atUserId: !ctx.isDirect ? ctx.senderId : null,
-          log: ctx.log,
-          accountId: ctx.accountId,
-          storePath: ctx.storePath,
-          conversationId: ctx.groupId,
-          quotedRef: ctx.replyQuotedRef,
-        });
-        if (!sendResult.ok) {
-          throw new Error(sendResult.error || "Reply send failed");
+      if (payload.kind === "tool") {
+        const text = typeof payload.text === "string" ? payload.text : "";
+        if (!text.trim()) {
+          return;
         }
+        await sendMarkdownSegment(renderQuotedSegment(text));
+        return;
+      }
+
+      if (
+        (payload.kind === "block" || payload.kind === "final")
+        && typeof payload.text === "string"
+      ) {
+        await emitAnswerSuffix(payload.text);
       }
     },
 
     async finalize(): Promise<void> {
-      // Markdown mode: delivery already happened in deliver(final).
+      if (sentVisibleContent) {
+        return;
+      }
+      finalText = EMPTY_FINAL_FALLBACK_TEXT;
+      activeAnswerText = EMPTY_FINAL_FALLBACK_TEXT;
+      await sendMarkdownSegment(EMPTY_FINAL_FALLBACK_TEXT);
     },
 
     async abort(): Promise<void> {
@@ -49,7 +154,7 @@ export function createMarkdownReplyStrategy(
     },
 
     getFinalText(): string | undefined {
-      return finalText;
+      return finalText || activeAnswerText || undefined;
     },
   };
 }

package/src/reply-strategy.ts

@@ -16,6 +16,7 @@ export interface DeliverPayload {
   text?: string;
   mediaUrls: string[];
   kind: "block" | "final" | "tool";
+  isReasoning?: boolean;
 }
 
 export interface ReplyOptions {
@@ -51,6 +52,9 @@ export interface ReplyStrategyContext {
   isDirect: boolean;
   accountId: string;
   storePath: string;
+  disableBlockStreaming?: boolean;
+  sessionKey?: string;
+  sessionAgentId?: string;
   groupId?: string;
   log?: Logger;
   replyQuotedRef?: QuotedRef;

package/src/send-service.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import axios from "axios";
+import axios from "./http-client";
 import { getAccessToken } from "./auth";
 import {
   isCardInTerminalState,
@@ -37,6 +37,53 @@ import type {
 
 export { detectMediaTypeFromExtension } from "./media-utils";
 
+const MARKDOWN_LOCAL_IMAGE_RE =
+  /!\[([^\]]*)\]\((file:\/\/\/[^)]+|\/(?:tmp|var|private|Users|home|root)[^)]+|[A-Za-z]:[\\/][^)]+)\)/g;
+
+function decodeMarkdownLocalImagePath(rawPath: string): string {
+  const unescapedPath = rawPath.replace(/\\ /g, " ");
+  if (unescapedPath.startsWith("file://")) {
+    try {
+      return decodeURIComponent(unescapedPath.replace("file://", ""));
+    } catch {
+      return unescapedPath.replace("file://", "");
+    }
+  }
+  return unescapedPath;
+}
+
+async function replaceMarkdownLocalImages(params: {
+  config: DingTalkConfig;
+  text: string;
+  log?: Logger;
+  mediaLocalRoots?: string[];
+}): Promise<string> {
+  const matches = [...params.text.matchAll(MARKDOWN_LOCAL_IMAGE_RE)];
+  if (matches.length === 0) {
+    return params.text;
+  }
+
+  let result = params.text;
+  for (const match of matches) {
+    const [fullMatch, altText, rawPath] = match;
+    const mediaPath = decodeMarkdownLocalImagePath(rawPath);
+    const uploadResult = await uploadMedia(params.config, mediaPath, "image", params.log, {
+      mediaLocalRoots: params.mediaLocalRoots,
+    });
+
+    if (!uploadResult?.mediaId) {
+      params.log?.warn?.(
+        `[DingTalk] Markdown local image upload failed, keep original reference: ${mediaPath}`,
+      );
+      continue;
+    }
+
+    result = result.replace(fullMatch, () => `![${altText}](${uploadResult.mediaId})`);
+  }
+
+  return result;
+}
+
 type ProactiveTextSendResult = AxiosResponse | { tracking: DingTalkTrackingMetadata };
 
 function isTrackingResult(result: ProactiveTextSendResult): result is { tracking: DingTalkTrackingMetadata } {
@@ -252,7 +299,16 @@ export async function sendProactiveTextOrMarkdown(
     ? "https://api.dingtalk.com/v1.0/robot/groupMessages/send"
     : "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
 
-  const normalizedText = config.convertMarkdownTables !== false ? convertMarkdownTablesToPlainText(text) : text;
+  const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
+    config,
+    text,
+    log,
+    mediaLocalRoots: options.mediaLocalRoots,
+  });
+  const normalizedText =
+    config.convertMarkdownTables !== false
+      ? convertMarkdownTablesToPlainText(textWithUploadedLocalImages)
+      : textWithUploadedLocalImages;
   const { useMarkdown, title } = detectMarkdownAndExtractTitle(normalizedText, options, "OpenClaw 提醒");
 
   log?.debug?.(
@@ -531,7 +587,16 @@ export async function sendBySession(
   }
 
   // Fallback to text/markdown reply payload.
-  const normalizedText = config.convertMarkdownTables !== false ? convertMarkdownTablesToPlainText(text) : text;
+  const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
+    config,
+    text,
+    log,
+    mediaLocalRoots: options.mediaLocalRoots,
+  });
+  const normalizedText =
+    config.convertMarkdownTables !== false
+      ? convertMarkdownTablesToPlainText(textWithUploadedLocalImages)
+      : textWithUploadedLocalImages;
   const { useMarkdown, title } = detectMarkdownAndExtractTitle(normalizedText, options, "Clawdbot 消息");
   const chunks = splitMarkdownChunks(normalizedText, DINGTALK_TEXT_CHUNK_LIMIT);
 

package/src/targeting/agent-routing.ts

@@ -8,6 +8,7 @@
  */
 
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { maybeResolveTextAlias } from "openclaw/plugin-sdk/command-auth";
 import { resolveAtAgents } from "./agent-name-matcher";
 import { resolveRobotCode } from "../config";
 import { parseLearnCommand } from "../learning-command-service";
@@ -93,16 +94,22 @@ export async function resolveSubAgentRoute(params: {
   const atMentions = extractedContent.atMentions || [];
   // DM has no @picker list from DingTalk; only group chats provide atUsers for real-user hints.
   const atUserDingtalkIds = isGroup ? extractedContent.atUserDingtalkIds : undefined;
-  // Strip quoted prefix before checking /learn to avoid false positives
-  // when the quoted message itself contains a /learn command.
+  // Strip quoted prefix before checking commands to avoid false positives
+  // when the quoted message itself contains a command.
   const textForCommandCheck = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
   const isLearnCommand = parseLearnCommand(textForCommandCheck).scope !== "unknown";
+  // Slash commands like /new, /stop, /reasoning etc. must bypass sub-agent
+  // routing so they reach the framework's own command handling layer.
+  // Strip leading @mention tokens first since DM text may look like "@Agent /new".
+  const textWithoutMentions = textForCommandCheck.replace(/^(?:@\S+\s+)*/u, "").trim();
+  const isSlashCommand = maybeResolveTextAlias(textWithoutMentions, cfg) !== null;
 
   if (
     atMentions.length === 0 ||
     !cfg.agents?.list ||
     cfg.agents.list.length === 0 ||
-    isLearnCommand
+    isLearnCommand ||
+    isSlashCommand
   ) {
     return null;
   }
@@ -173,7 +180,7 @@ export async function dispatchSubAgents(params: {
         dingtalkConfig,
         subAgentOptions: {
           agentId: agentMatch.agentId,
-          responsePrefix: `[${sanitizeAgentName(agentMatch.matchedName)}] `,
+          responsePrefix: `> 🤖 **${sanitizeAgentName(agentMatch.matchedName)}**:\n\n`,
           matchedName: agentMatch.matchedName,
         },
         preDownloadedMedia,

package/src/{group-members-store.ts → targeting/group-members-store.ts}

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { readNamespaceJson, writeNamespaceJsonAtomic } from "./persistence-store";
+import { readNamespaceJson, writeNamespaceJsonAtomic } from "../persistence-store";
 
 const GROUP_MEMBERS_NAMESPACE = "members.group-roster";