@soimy/dingtalk 3.5.0 → 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/onboarding.ts

@@ -126,8 +126,6 @@ function applyAccountConfig(params: {
       ? { mediaUrlAllowlist: input.mediaUrlAllowlist }
       : {}),
     ...(input.messageType ? { messageType: input.messageType } : {}),
-    ...(input.cardTemplateId ? { cardTemplateId: input.cardTemplateId } : {}),
-    ...(input.cardTemplateKey ? { cardTemplateKey: input.cardTemplateKey } : {}),
     ...(typeof input.maxReconnectCycles === "number"
       ? { maxReconnectCycles: input.maxReconnectCycles }
       : {}),
@@ -234,41 +232,17 @@ async function configureDingTalkAccount(params: {
     initialValue: resolved.messageType === "card",
   });
 
-  let cardTemplateId: string | undefined;
-  let cardTemplateKey: string | undefined;
   let messageType: "markdown" | "card" = "markdown";
 
   if (wantsCardMode) {
     await prompter.note(
       [
-        "Create an AI card template in DingTalk Developer Console:",
-        "https://open-dev.dingtalk.com/fe/card",
-        "1. Go to 'My Templates' > 'Create Template'",
-        "2. Select 'AI Card' scenario",
-        "3. Design your card and publish",
-        "4. Copy the Template ID (e.g., xxx.schema)",
+        "AI interactive card mode now uses the built-in DingTalk template contract.",
+        "No manual Template ID or content field configuration is required.",
+        "Legacy cardTemplateId/cardTemplateKey config is deprecated and ignored.",
       ].join("\n"),
-      "Card Template Setup",
+      "Built-in AI Card Template",
     );
-
-    cardTemplateId =
-      String(
-        await prompter.text({
-          message: "Card Template ID",
-          placeholder: "xxxxx-xxxxx-xxxxx.schema",
-          initialValue: resolved.cardTemplateId ?? undefined,
-        }),
-      ).trim() || undefined;
-
-    cardTemplateKey =
-      String(
-        await prompter.text({
-          message: "Card Template Key (content field name)",
-          placeholder: "content",
-          initialValue: resolved.cardTemplateKey ?? "content",
-        }),
-      ).trim() || "content";
-
     messageType = "card";
   }
 
@@ -436,8 +410,6 @@ async function configureDingTalkAccount(params: {
       displayNameResolution: displayNameResolutionValue as "disabled" | "all",
       mediaUrlAllowlist,
       messageType,
-      cardTemplateId,
-      cardTemplateKey,
       maxReconnectCycles,
       mediaMaxMb,
       journalTTLDays,

package/src/reply-strategy-card.ts

@@ -10,54 +10,99 @@ 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";
 import { sendBySession, sendMessage } from "./send-service";
 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 },
+  ctx: ReplyStrategyContext & { card: AICardInstance; isStopRequested?: () => boolean },
 ): ReplyStrategy {
-  const { card, config, log } = ctx;
+  const { card, config, log, isStopRequested } = ctx;
 
   const controller = createCardDraftController({ card, log });
+  const reasoningAssembler = createReasoningBlockAssembler();
+  if (card.outTrackId) {
+    attachCardRunController(card.outTrackId, controller);
+  }
   let finalTextForFallback: string | undefined;
   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 () => {
-          await controller.notifyNewAssistantTurn();
+          if (isStopRequested?.()) {
+            return;
+          }
+          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
           ? async (payload) => {
-              if (payload.text) {
+              if (payload.text && !isStopRequested?.()) {
                 await controller.updateAnswer(payload.text);
               }
             }
           : undefined,
 
         onReasoningStream: async (payload) => {
-          if (payload.text) {
-            await controller.updateThinking(payload.text);
+          if (payload.text && !isStopRequested?.()) {
+            await ingestReasoningSnapshot(payload.text);
           }
         },
       };
@@ -75,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} ` +
@@ -99,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)}`,
         );
@@ -106,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);
       }
@@ -122,11 +178,21 @@ export function createCardReplyStrategy(
         `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
       );
 
+      if (isStopRequested?.()) {
+        log?.info?.("[DingTalk][Finalize] Skipping — card stop was requested");
+        return;
+      }
+
       if (card.state === AICardStatus.FINISHED) {
         log?.info?.("[DingTalk][Finalize] Skipping — card already FINISHED");
         return;
       }
 
+      if (card.state === AICardStatus.STOPPED) {
+        log?.info?.("[DingTalk][Finalize] Skipping — card already STOPPED");
+        return;
+      }
+
       // Card failed -> markdown fallback (bypass sendMessage to avoid duplicate card).
       if (card.state === AICardStatus.FAILED || controller.isFailed()) {
         const fallbackText = getRenderedTimeline({ preferFinalAnswer: true })
@@ -156,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, {
@@ -211,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,10 +52,14 @@ export interface ReplyStrategyContext {
   isDirect: boolean;
   accountId: string;
   storePath: string;
+  disableBlockStreaming?: boolean;
+  sessionKey?: string;
+  sessionAgentId?: string;
   groupId?: string;
   log?: Logger;
   replyQuotedRef?: QuotedRef;
   deliverMedia: (urls: string[]) => Promise<void>;
+  isStopRequested?: () => boolean;
 }
 
 // ---- Factory -----------------------------------------------------