@soimy/dingtalk 3.5.1 → 3.5.3

package/src/reply-strategy-card.ts

@@ -9,7 +9,14 @@
 import {
   finishAICard,
   isCardInTerminalState,
+  recallAICardMessage,
 } from "./card-service";
+import { splitCardReasoningAnswerText } from "./card/reasoning-answer-split";
+import { createReasoningBlockAssembler } from "./card/reasoning-block-assembler";
+import {
+  resolveCardStreamingMode,
+  shouldWarnDeprecatedCardRealTimeStreamOnce,
+} from "./card/card-streaming-mode";
 import { createCardDraftController } from "./card-draft-controller";
 import { attachCardRunController } from "./card/card-run-registry";
 import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy";
@@ -18,59 +25,250 @@ import type { AICardInstance } from "./types";
 import { AICardStatus } from "./types";
 import { formatDingTalkErrorPayloadLog } from "./utils";
 
-const FILE_ONLY_FALLBACK_ANSWER = "附件已发送，请查收。";
+const EMPTY_FINAL_REPLY = "✅ Done";
+type CardReplyLifecycleState = "open" | "final_seen" | "sealed";
 
 export function createCardReplyStrategy(
   ctx: ReplyStrategyContext & { card: AICardInstance; isStopRequested?: () => boolean },
 ): ReplyStrategy {
   const { card, config, log, isStopRequested } = ctx;
+  const { mode, usedDeprecatedCardRealTimeStream } = resolveCardStreamingMode(config);
+  const streamAnswerLive = mode === "answer" || mode === "all";
+  const streamThinkingLive = mode === "all";
+  let lifecycleState: CardReplyLifecycleState = "open";
+  const shouldAcceptAnswerSnapshot = () => lifecycleState === "open";
+  const isLifecycleSealed = () => lifecycleState === "sealed";
+
+  if (usedDeprecatedCardRealTimeStream) {
+    const warningKey = `dingtalk-card-streaming:${ctx.accountId || config.clientId || "default"}`;
+    if (shouldWarnDeprecatedCardRealTimeStreamOnce(warningKey)) {
+      log?.warn?.(
+        "[DingTalk][Config] `cardRealTimeStream` is deprecated. Use `cardStreamingMode` with `off` | `answer` | `all`.",
+      );
+    }
+  }
 
-  const controller = createCardDraftController({ card, log });
+  const controller = createCardDraftController({
+    card,
+    log,
+    throttleMs: config.cardStreamInterval ?? 1000,
+  });
+  const reasoningAssembler = createReasoningBlockAssembler();
   if (card.outTrackId) {
     attachCardRunController(card.outTrackId, controller);
   }
   let finalTextForFallback: string | undefined;
   let sawFinalDelivery = false;
+  let successfulMediaDeliveries = 0;
+  let failedMediaDeliveries = 0;
+  /** Tracks the latest reasoning snapshot text for non-streaming boundary flush. */
+  let latestReasoningSnapshot = "";
 
   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 getRawRenderedTimeline = (): string =>
+    controller.getRenderedContent({
+      fallbackAnswer: undefined,
+      overrideAnswer: undefined,
+    });
+
+  const appendAssembledThinkingBlocks = async (blocks: string[]): Promise<void> => {
+    for (const block of blocks) {
+      if (!block.trim() || isStopRequested?.()) {
+        continue;
+      }
+      await controller.appendThinkingBlock(block);
+    }
+  };
+
+  const applyModeAwareDeliveredReasoning = async (text: string | undefined): Promise<void> => {
+    if (typeof text !== "string" || !text.trim() || isStopRequested?.()) {
+      return;
+    }
+    if (streamThinkingLive) {
+      await controller.appendThinkingBlock(text);
+      return;
+    }
+    await applyModeAwareReasoningSnapshot(text);
+  };
+
+  const applyModeAwareReasoningSnapshot = async (text: string | undefined): Promise<void> => {
+    if (typeof text !== "string" || !text.trim() || isStopRequested?.()) {
+      return;
+    }
+    if (streamThinkingLive) {
+      latestReasoningSnapshot = text;
+      await controller.updateReasoning(text);
+      return;
+    }
+    const blocks = reasoningAssembler.ingestSnapshot(text);
+    const trimmed = text.trimStart();
+    if (
+      blocks.length === 0
+      && !trimmed.startsWith("Reasoning:")
+    ) {
+      if (trimmed.startsWith("Reason:")) {
+        latestReasoningSnapshot = "";
+        return;
+      }
+      latestReasoningSnapshot = text.trim();
+      return;
+    }
+    latestReasoningSnapshot = "";
+    await appendAssembledThinkingBlocks(blocks);
+  };
+
+  const flushPendingReasoning = async (): Promise<void> => {
+    if (streamThinkingLive) {
+      await controller.sealActiveThinking();
+      latestReasoningSnapshot = "";
+      return;
+    }
+    const blocks = reasoningAssembler.flushPendingAtBoundary();
+    if (latestReasoningSnapshot) {
+      blocks.push(latestReasoningSnapshot);
+      latestReasoningSnapshot = "";
+    }
+    await appendAssembledThinkingBlocks(blocks);
+  };
+
+  const handleAssistantBoundary = async (): Promise<void> => {
+    if (streamThinkingLive) {
+      await controller.sealActiveThinking();
+      latestReasoningSnapshot = "";
+      reasoningAssembler.reset();
+      await controller.notifyNewAssistantTurn();
+      return;
+    }
+    const pendingReasoningBlocks = reasoningAssembler.flushPendingAtBoundary();
+    if (latestReasoningSnapshot) {
+      pendingReasoningBlocks.push(latestReasoningSnapshot);
+      latestReasoningSnapshot = "";
+    }
+    reasoningAssembler.reset();
+    const turnBoundary = controller.notifyNewAssistantTurn();
+    if (pendingReasoningBlocks.length > 0) {
+      await turnBoundary;
+      await appendAssembledThinkingBlocks(pendingReasoningBlocks);
+      return;
+    }
+    await turnBoundary;
+  };
+
+  const normalizeDeliveredText = (
+    text: string,
+    options: { isReasoning: boolean },
+  ): { reasoningText?: string; answerText?: string } => {
+    if (options.isReasoning) {
+      const split = splitCardReasoningAnswerText(text);
+      return { reasoningText: split.reasoningText || text };
+    }
+    const split = splitCardReasoningAnswerText(text);
+    return {
+      reasoningText: split.reasoningText,
+      answerText: split.answerText,
+    };
+  };
+
+  const applyDeliveredContent = async (
+    normalized: { reasoningText?: string; answerText?: string },
+    options: {
+      routeReasoningThroughModePolicy: boolean;
+      answerHandling?: "update" | "capture" | "ignore";
+    },
+  ): Promise<void> => {
+    if (normalized.reasoningText) {
+      if (options.routeReasoningThroughModePolicy) {
+        await applyModeAwareDeliveredReasoning(normalized.reasoningText);
+      } else {
+        // Conservative local split fallback: keep existing behavior for mixed payloads.
+        await controller.appendThinkingBlock(normalized.reasoningText);
+      }
+    }
+    if (normalized.answerText && options.answerHandling !== "ignore") {
+      if (options.answerHandling === "capture") {
+        finalTextForFallback = normalized.answerText;
+        return;
+      }
+      await controller.updateAnswer(normalized.answerText);
+    }
+  };
+
+  const handleAnswerSnapshot = async (text: string | undefined): Promise<void> => {
+    if (!shouldAcceptAnswerSnapshot() || isStopRequested?.()) {
+      return;
+    }
+    if (!text) {
+      return;
+    }
+    await controller.updateAnswer(text, { stream: streamAnswerLive });
+  };
+
+  const applySplitTextToTimeline = async (
+    text: string,
+    options: { answerHandling?: "update" | "capture" | "ignore" } = {},
+  ) => {
+    const normalized = normalizeDeliveredText(text, { isReasoning: false });
+    await applyDeliveredContent(normalized, {
+      routeReasoningThroughModePolicy: true,
+      answerHandling: options.answerHandling ?? "update",
+    });
+    return normalized;
+  };
+
+  const deliverMediaWithTracking = async (
+    mediaUrls: string[],
+    options: { audioAsVoice?: boolean },
+  ): Promise<void> => {
+    if (mediaUrls.length === 0) {
+      return;
+    }
+    try {
+      await ctx.deliverMedia(mediaUrls, options);
+      successfulMediaDeliveries += mediaUrls.length;
+    } catch (err) {
+      failedMediaDeliveries += mediaUrls.length;
+      throw err;
+    }
+  };
+
   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?.()) {
+          if (isLifecycleSealed() || isStopRequested?.()) {
             return;
           }
-          await controller.notifyNewAssistantTurn();
+          await handleAssistantBoundary();
         },
 
-        onPartialReply: config.cardRealTimeStream
-          ? async (payload) => {
-              if (payload.text && !isStopRequested?.()) {
-                await controller.updateAnswer(payload.text);
-              }
-            }
-          : undefined,
+        onPartialReply: async (payload) => {
+          await handleAnswerSnapshot(payload.text);
+        },
 
         onReasoningStream: async (payload) => {
-          if (payload.text && !isStopRequested?.()) {
-            await controller.updateThinking(payload.text);
+          if (isLifecycleSealed() || isStopRequested?.()) {
+            return;
           }
+          await applyModeAwareReasoningSnapshot(payload.text);
         },
       };
     },
 
     async deliver(payload: DeliverPayload): Promise<void> {
+      if (isLifecycleSealed()) {
+        return;
+      }
       const textToSend = payload.text;
 
       // Empty-payload guard — card final is an exception (e.g. file-only response).
@@ -82,7 +280,12 @@ export function createCardReplyStrategy(
 
       // ---- final: defer to finalize, just save text ----
       if (payload.kind === "final") {
-        sawFinalDelivery = true;
+        const isFirstFinalDelivery = !sawFinalDelivery;
+        lifecycleState = "final_seen";
+        await flushPendingReasoning();
+        if (isFirstFinalDelivery) {
+          sawFinalDelivery = true;
+        }
         log?.info?.(
           `[DingTalk][Finalize] deliver(final) received — cardState=${card.state} ` +
           `textLen=${typeof textToSend === "string" ? textToSend.length : "null"} ` +
@@ -91,11 +294,22 @@ export function createCardReplyStrategy(
           `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
         );
         if (payload.mediaUrls.length > 0) {
-          await ctx.deliverMedia(payload.mediaUrls);
+          await deliverMediaWithTracking(payload.mediaUrls, { audioAsVoice: payload.audioAsVoice });
         }
         const rawFinalText = typeof textToSend === "string" ? textToSend : "";
         if (rawFinalText) {
-          finalTextForFallback = rawFinalText;
+          if (payload.isReasoning === true) {
+            await applyModeAwareReasoningSnapshot(rawFinalText);
+            await flushPendingReasoning();
+          } else {
+            const normalizedFinal = await applySplitTextToTimeline(rawFinalText, {
+              answerHandling: "capture",
+            });
+            if (isFirstFinalDelivery && !normalizedFinal.answerText && !normalizedFinal.reasoningText) {
+              finalTextForFallback = rawFinalText;
+            }
+            await flushPendingReasoning();
+          }
         }
         return;
       }
@@ -106,16 +320,36 @@ 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)}`,
         );
-        await controller.appendTool(textToSend ?? "");
+        if (lifecycleState === "final_seen") {
+          await controller.appendToolBeforeCurrentAnswer(textToSend ?? "");
+        } else {
+          await controller.appendTool(textToSend ?? "");
+        }
         return;
       }
 
-      // ---- block: only handle media (text blocks are unused) ----
+      const isReasoningBlock = payload.isReasoning === true;
+      if (typeof textToSend === "string" && textToSend.trim()) {
+        if (isReasoningBlock) {
+          const normalized = normalizeDeliveredText(textToSend, { isReasoning: true });
+          await applyDeliveredContent(normalized, {
+            routeReasoningThroughModePolicy: true,
+            answerHandling: "ignore",
+          });
+        } else {
+          await applySplitTextToTimeline(textToSend, {
+            answerHandling: lifecycleState === "open" ? "update" : "capture",
+          });
+        }
+      }
+
+      // ---- block: only handle reasoning/media (other text blocks are unused) ----
       if (payload.mediaUrls.length > 0) {
-        await ctx.deliverMedia(payload.mediaUrls);
+        await deliverMediaWithTracking(payload.mediaUrls, { audioAsVoice: payload.audioAsVoice });
       }
     },
 
@@ -131,16 +365,19 @@ export function createCardReplyStrategy(
 
       if (isStopRequested?.()) {
         log?.info?.("[DingTalk][Finalize] Skipping — card stop was requested");
+        lifecycleState = "sealed";
         return;
       }
 
       if (card.state === AICardStatus.FINISHED) {
         log?.info?.("[DingTalk][Finalize] Skipping — card already FINISHED");
+        lifecycleState = "sealed";
         return;
       }
 
       if (card.state === AICardStatus.STOPPED) {
         log?.info?.("[DingTalk][Finalize] Skipping — card already STOPPED");
+        lifecycleState = "sealed";
         return;
       }
 
@@ -168,23 +405,49 @@ export function createCardReplyStrategy(
         } else {
           log?.debug?.("[DingTalk] Card failed but no content to fallback with");
         }
+        lifecycleState = "sealed";
         return;
       }
 
       // Normal finalize.
       try {
+        await flushPendingReasoning();
         await controller.flush();
         await controller.waitForInFlight();
-        const finalText = getRenderedTimeline() || "✅ Done";
+        const renderedTimeline = getRenderedTimeline({ preferFinalAnswer: true });
+        const rawRenderedTimeline = getRawRenderedTimeline();
+        const hasRenderedCardContent = Boolean(rawRenderedTimeline.trim());
+        const hasMeaningfulCardContent = hasRenderedCardContent
+          || Boolean((finalTextForFallback || "").trim())
+          || Boolean((controller.getFinalAnswerContent() || "").trim())
+          || Boolean((controller.getLastAnswerContent() || "").trim())
+          || Boolean((controller.getLastContent() || "").trim());
+        const shouldRecallEmptyCard =
+          successfulMediaDeliveries > 0
+          && failedMediaDeliveries === 0
+          && !hasMeaningfulCardContent;
+        if (shouldRecallEmptyCard) {
+          controller.stop();
+          log?.info?.(
+            `[DingTalk][Finalize] Attempting to recall empty card after successful media delivery ` +
+            `mediaCount=${successfulMediaDeliveries} conversationId=${card.conversationId}`,
+          );
+          if (await recallAICardMessage(card, log)) {
+            lifecycleState = "sealed";
+            return;
+          }
+        }
+        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, {
           quotedRef: ctx.replyQuotedRef,
         });
+        lifecycleState = "sealed";
 
         // In group chats, send a lightweight @mention via session webhook
         // so the sender gets a notification — card API doesn't support @mention.
@@ -210,10 +473,13 @@ export function createCardReplyStrategy(
           card.state = AICardStatus.FAILED;
           card.lastUpdated = Date.now();
         }
+      } finally {
+        lifecycleState = "sealed";
       }
     },
 
     async abort(_error: Error): Promise<void> {
+      lifecycleState = "sealed";
       if (!isCardInTerminalState(card.state)) {
         controller.stop();
         await controller.waitForInFlight();
@@ -228,9 +494,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);
+        await ctx.deliverMedia(payload.mediaUrls, { audioAsVoice: payload.audioAsVoice });
+        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

@@ -12,10 +12,22 @@ import { createMarkdownReplyStrategy } from "./reply-strategy-markdown";
 
 // ---- Public types ------------------------------------------------
 
+type InternalReplyStrategyConfig = DingTalkConfig & {
+  /** @deprecated Internal compatibility only. Removed from public config surface. */
+  cardStreamReasoning?: boolean;
+};
+
 export interface DeliverPayload {
   text?: string;
   mediaUrls: string[];
+  /**
+   * Shared reply-runtime voice hint. Strategies forward this unchanged into the
+   * channel media delivery helper; inbound-handler is responsible for bridging
+   * legacy aliases (for example `asVoice`) into this single field.
+   */
+  audioAsVoice?: boolean;
   kind: "block" | "final" | "tool";
+  isReasoning?: boolean;
 }
 
 export interface ReplyOptions {
@@ -44,17 +56,25 @@ export interface ReplyStrategy {
 
 /** Shared context passed to every strategy implementation. */
 export interface ReplyStrategyContext {
-  config: DingTalkConfig;
+  config: InternalReplyStrategyConfig;
   to: string;
   sessionWebhook: string;
   senderId: string;
   isDirect: boolean;
   accountId: string;
   storePath: string;
+  disableBlockStreaming?: boolean;
+  sessionKey?: string;
+  sessionAgentId?: string;
   groupId?: string;
   log?: Logger;
   replyQuotedRef?: QuotedRef;
-  deliverMedia: (urls: string[]) => Promise<void>;
+  /**
+   * Channel-level media delivery hook. The `audioAsVoice` option is the same
+   * shared voice semantic carried on DeliverPayload, not a second independent
+   * config knob.
+   */
+  deliverMedia: (urls: string[], options?: { audioAsVoice?: boolean }) => Promise<void>;
   isStopRequested?: () => boolean;
 }