@qwen-code/qwen-code 0.21.6-preview.0 → 0.21.7

package/chunks/{dist-A7H2KKUC.js → dist-K4WWQBHS.js}

@@ -37,7 +37,7 @@ init_esbuild_shims();
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 init_esbuild_shims();
 import { mkdirSync, writeFileSync } from "node:fs";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { basename as basename2, join } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -4540,15 +4540,17 @@ function replaceImageMarkers(text, markers, replacements) {
   return result;
 }
 __name(replaceImageMarkers, "replaceImageMarkers");
+function stripPartialImageMarker(text) {
+  const visibleText = maskCode(text);
+  const partialMarker = /\[I(?:M(?:A(?:G(?:E(?::[^\]\r\n]*)?)?)?)?)?$/i.exec(visibleText);
+  if (partialMarker?.index === void 0)
+    return text;
+  return `${text.slice(0, partialMarker.index)}[Image pending]`;
+}
+__name(stripPartialImageMarker, "stripPartialImageMarker");
 function sanitizeStreamingImageMarkers(text) {
   const markers = findImageMarkers(text);
-  let result = replaceImageMarkers(text, markers, markers.map(() => "[Image pending]"));
-  const visibleText = maskCode(result);
-  const partialMarker = /\[(?:I(?:M(?:A(?:G(?:E(?::[^\]\r\n]*)?)?)?)?)?)?$/i.exec(visibleText);
-  if (partialMarker?.index !== void 0) {
-    result = `${result.slice(0, partialMarker.index)}[Image pending]`;
-  }
-  return result;
+  return stripPartialImageMarker(replaceImageMarkers(text, markers, markers.map(() => "[Image pending]")));
 }
 __name(sanitizeStreamingImageMarkers, "sanitizeStreamingImageMarkers");
 function isInside(realPath, directory) {
@@ -5189,6 +5191,9 @@ __name(parseDingtalkCardActorId, "parseDingtalkCardActorId");
 init_esbuild_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
 var FLUSH_INTERVAL_MS = 500;
+var STATUS_REFRESH_INTERVAL_MS = 1e3;
+var BREAKER_PROBE_INTERVAL_MS = 3e4;
+var MAX_CONSECUTIVE_STATUS_FAILURES = 3;
 var CONTENT_LIMIT = 2e4;
 var TRUNCATION_MARKER = "[Earlier output truncated]\n";
 function boundContent(content) {
@@ -5209,22 +5214,66 @@ var StatusCardController = class {
   constructor(options) {
     this.options = options;
   }
-  append(segment, target, chunk) {
-    if (!chunk || this.terminalSegmentIds.has(segment.segmentId))
+  ensure(segment, target) {
+    if (this.terminalSegmentIds.has(segment.segmentId))
+      return;
+    if (!this.recordsBySegment.has(segment.segmentId)) {
+      this.createRecord(segment, target);
+    }
+  }
+  replace(segment, target, content) {
+    if (this.terminalSegmentIds.has(segment.segmentId))
       return;
-    let record = this.recordsBySegment.get(segment.segmentId);
+    const record = this.recordsBySegment.get(segment.segmentId);
     if (!record) {
-      record = this.createRecord(segment, target);
+      this.createRecord(segment, target, content);
+      return;
     }
     if (record.terminal)
       return;
-    record.content = boundContent(record.content + chunk);
+    record.content = boundContent(content);
     if (record.streamFailed)
       return;
     record.pendingSnapshot = sanitizeStreamingImageMarkers(record.content);
     this.scheduleFlush(record);
   }
-  createRecord(segment, target) {
+  /**
+   * Whether a created, still-running status card is displaying content for
+   * this segment. Awaits the in-flight creation so a boundary decision made
+   * while creation is pending does not race it. A latched stream failure
+   * means the card can never show further content, so it is not live.
+   */
+  async isCardLive(segmentId) {
+    const record = this.recordsBySegment.get(segmentId);
+    if (!record || record.terminal || record.streamFailed)
+      return false;
+    return record.ready;
+  }
+  /**
+   * Drain any pending snapshot so callers can treat the card's current
+   * content as delivered. Returns false when there is no live record, the
+   * card never became ready, or the stream failed during the drain, so the
+   * caller can fall back instead of claiming delivery.
+   */
+  async flushPending(segmentId) {
+    const record = this.recordsBySegment.get(segmentId);
+    if (!record || record.terminal)
+      return false;
+    if (!await record.ready)
+      return false;
+    while (!record.terminal && !record.streamFailed) {
+      if (record.flushTimer) {
+        clearTimeout(record.flushTimer);
+        record.flushTimer = void 0;
+      }
+      this.flush(record);
+      await record.writeChain;
+      if (record.pendingSnapshot === void 0)
+        break;
+    }
+    return !record.terminal && !record.streamFailed;
+  }
+  createRecord(segment, target, initialContent = "") {
     const outTrackId = `qwen-status-${randomUUID2()}`;
     const record = {
       segmentId: segment.segmentId,
@@ -5233,12 +5282,13 @@ var StatusCardController = class {
       ownerId: segment.owner.id,
       target,
       outTrackId,
-      content: "",
+      content: boundContent(initialContent),
       startedAt: Date.now(),
       lastStatusSecond: 0,
       ready: Promise.resolve(false),
       terminal: false,
       streamFailed: false,
+      consecutiveStatusFailures: 0,
       stopClaimed: false,
       forbiddenActors: /* @__PURE__ */ new Set(),
       lastWriteAt: Date.now(),
@@ -5250,10 +5300,14 @@ var StatusCardController = class {
     segmentIds.add(record.segmentId);
     this.segmentIdsByRun.set(record.runId, segmentIds);
     record.ready = this.create(record, target);
+    void record.ready.then((ready) => {
+      if (ready)
+        this.scheduleStatusRefresh(record);
+    });
     return record;
   }
-  complete(segmentId, text) {
-    return this.finalize(segmentId, boundContent(text), "Completed", false);
+  complete(segmentId, text, retainedContent) {
+    return this.finalize(segmentId, boundContent(text), "Completed", false, retainedContent);
   }
   fail(segmentId, error) {
     void this.finalize(segmentId, boundContent(error), "Failed", true);
@@ -5296,12 +5350,13 @@ var StatusCardController = class {
   }
   async create(record, target) {
     try {
+      const initialContent = sanitizeStreamingImageMarkers(record.content);
       await this.options.client.createAndDeliver({
         templateId: STATUS_CARD_TEMPLATE_ID,
         outTrackId: record.outTrackId,
         target,
         cardParamMap: {
-          content: "",
+          content: initialContent,
           flowStatus: 2,
           statusLine: this.statusLine(record, "Running").text,
           hasAction: "true",
@@ -5311,7 +5366,7 @@ var StatusCardController = class {
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
-        content: "",
+        content: initialContent,
         finalize: false
       });
       return true;
@@ -5358,6 +5413,10 @@ var StatusCardController = class {
     }).catch((error) => {
       record.streamFailed = true;
       record.pendingSnapshot = void 0;
+      if (record.statusTimer) {
+        clearTimeout(record.statusTimer);
+        record.statusTimer = void 0;
+      }
       this.options.onError?.("status card streaming", error);
     });
     const tracked = write.finally(() => {
@@ -5371,7 +5430,7 @@ var StatusCardController = class {
     record.inFlight = tracked;
     record.writeChain = tracked;
   }
-  async finalize(segmentId, content, state, isError) {
+  async finalize(segmentId, content, state, isError, retainedContent) {
     const record = this.recordsBySegment.get(segmentId);
     if (!record || record.terminal)
       return false;
@@ -5386,12 +5445,16 @@ var StatusCardController = class {
     if (record.flushTimer)
       clearTimeout(record.flushTimer);
     record.flushTimer = void 0;
+    if (record.statusTimer)
+      clearTimeout(record.statusTimer);
+    record.statusTimer = void 0;
     record.pendingSnapshot = void 0;
     try {
       if (!await record.ready)
         return false;
       await record.writeChain;
-      const finalContent = boundContent(sanitizeStreamingImageMarkers(content || record.content));
+      const retained = content || (retainedContent ? retainedContent(record.content) : record.content);
+      const finalContent = boundContent(sanitizeStreamingImageMarkers(retained));
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
@@ -5444,7 +5507,7 @@ var StatusCardController = class {
     };
   }
   async updateRunningStatus(record) {
-    if (record.terminal)
+    if (record.terminal || record.streamFailed)
       return;
     const status = this.statusLine(record, "Running");
     if (status.second === record.lastStatusSecond)
@@ -5455,10 +5518,37 @@ var StatusCardController = class {
         cardParamMap: { statusLine: status.text }
       });
       record.lastStatusSecond = status.second;
+      record.consecutiveStatusFailures = 0;
+      if (record.statusTimer) {
+        clearTimeout(record.statusTimer);
+        record.statusTimer = void 0;
+      }
+      this.scheduleStatusRefresh(record);
     } catch (error) {
+      record.consecutiveStatusFailures++;
       this.options.onError?.("status card metadata", error);
     }
   }
+  scheduleStatusRefresh(record, intervalMs = STATUS_REFRESH_INTERVAL_MS) {
+    if (record.terminal || record.streamFailed || record.statusTimer)
+      return;
+    const elapsed = Math.max(0, Date.now() - record.startedAt);
+    const delay = Math.max(50, intervalMs - elapsed % intervalMs);
+    record.statusTimer = setTimeout(() => {
+      record.statusTimer = void 0;
+      if (record.terminal || record.streamFailed)
+        return;
+      const refresh = record.writeChain.then(() => this.updateRunningStatus(record));
+      record.writeChain = refresh;
+      void refresh.finally(() => {
+        if (record.consecutiveStatusFailures >= MAX_CONSECUTIVE_STATUS_FAILURES) {
+          this.scheduleStatusRefresh(record, BREAKER_PROBE_INTERVAL_MS);
+          return;
+        }
+        this.scheduleStatusRefresh(record);
+      });
+    }, delay);
+  }
 };
 
 // packages/channels/dingtalk/dist/question-card-controller.js
@@ -5793,6 +5883,19 @@ ${questions}`;
 
 // packages/channels/dingtalk/dist/interaction-presenter.js
 init_esbuild_shims();
+import { randomUUID as randomUUID4 } from "node:crypto";
+function escapeMarkdownText(text) {
+  return text.replace(/([\\`*_[\]{}()#+.!|>~-])/gu, "\\$1");
+}
+__name(escapeMarkdownText, "escapeMarkdownText");
+function formatSenderPrefixes(sender) {
+  const senderName = sanitizeSenderName(sender.senderName);
+  return {
+    senderPrefix: `@${escapeMarkdownText(senderName)}`,
+    senderRawPrefix: `@${senderName}`
+  };
+}
+__name(formatSenderPrefixes, "formatSenderPrefixes");
 var DingtalkInteractionPresenter = class {
   static {
     __name(this, "DingtalkInteractionPresenter");
@@ -5804,14 +5907,40 @@ var DingtalkInteractionPresenter = class {
   constructor(options) {
     this.options = options;
   }
-  registerRun(runId, ownerId, target) {
+  registerRun(runId, ownerId, target, sessionId = "", sender) {
     this.runs.set(runId, {
+      runId,
       ownerId,
       target,
+      baseContext: {
+        channelName: "dingtalk",
+        sessionId,
+        runId,
+        segmentId: runId,
+        owner: { kind: "channel_user", id: ownerId },
+        target: {
+          channelName: "dingtalk",
+          chatId: target.chatId,
+          senderId: ownerId,
+          isGroup: target.isGroup
+        }
+      },
       projectionChain: Promise.resolve(),
+      ...target.isGroup && sender ? formatSenderPrefixes(sender) : {},
       terminal: false
     });
   }
+  startStatusCard(runId) {
+    const run = this.runs.get(runId);
+    if (!run || run.terminal)
+      return;
+    const statusContext = this.ensureStatusContext(run);
+    void this.enqueue(run, () => {
+      const statusCards = this.options.statusCards;
+      const target = this.cardTarget(statusContext.target);
+      statusCards?.ensure(statusContext, target);
+    });
+  }
   appendOutput(segment, chunk) {
     const run = this.runs.get(segment.runId);
     if (!run || run.terminal || run.ownerId !== segment.owner.id || run.target.chatId !== segment.target.chatId || run.target.isGroup !== segment.target.isGroup || !chunk || this.terminalSegmentIds.has(segment.segmentId)) {
@@ -5828,10 +5957,9 @@ var DingtalkInteractionPresenter = class {
     presentation.content = this.boundContent(presentation.content + chunk);
     this.segments.set(segment.segmentId, presentation);
     run.activeSegmentId = segment.segmentId;
-    if (!this.options.statusCards)
-      return;
+    const statusContext = this.ensureStatusContext(run, segment);
     void this.enqueue(run, () => {
-      this.options.statusCards?.append(segment, this.cardTarget(segment.target), chunk);
+      this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), presentation.content);
     });
   }
   closeOutput(segmentId, text, reason, segment) {
@@ -5852,17 +5980,48 @@ var DingtalkInteractionPresenter = class {
     }
     return this.enqueue(run, async () => {
       const statusCards = this.options.statusCards;
+      const statusContext = this.ensureStatusContext(run, presentation.context);
       if (reason === "failed") {
-        statusCards?.fail(segmentId, text);
+        statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
+        statusCards?.fail(statusContext.segmentId, this.withSenderPrefix(run, "\u672C\u6B21\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002"));
+        await this.redeliverCardDeliveredContent(run);
         return statusCards !== void 0;
       }
       if (reason === "cancelled") {
         return statusCards !== void 0;
       }
-      const completed = statusCards !== void 0 && await statusCards.complete(segmentId, text);
+      if (reason === "response_boundary") {
+        const deliveredViaCard = statusCards !== void 0 && await statusCards.isCardLive(statusContext.segmentId) && await statusCards.flushPending(statusContext.segmentId);
+        if (deliveredViaCard) {
+          run.cardDelivered = {
+            text: stripPartialImageMarker(text || presentation.content),
+            chatId: presentation.context.target.chatId,
+            sessionId: presentation.context.sessionId
+          };
+          return true;
+        }
+        const fallbackText2 = stripPartialImageMarker(text || presentation.content);
+        if (!fallbackText2 || !this.options.sendFallback)
+          return false;
+        await this.options.sendFallback(presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
+        return true;
+      }
+      if (reason === "input_requested") {
+        const completed2 = statusCards !== void 0 && await statusCards.complete(statusContext.segmentId, this.withSenderPrefix(run, text || presentation.content));
+        run.statusContext = void 0;
+        if (completed2)
+          return true;
+        const fallbackText2 = stripPartialImageMarker(text || presentation.content);
+        if (!fallbackText2 || !this.options.sendFallback)
+          return false;
+        await this.options.sendFallback(presentation.context.target.chatId, fallbackText2, presentation.context.sessionId);
+        return true;
+      }
+      statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
+      const completed = statusCards !== void 0 && await statusCards.complete(statusContext.segmentId, this.withSenderPrefix(run, text || presentation.content));
       if (completed)
         return true;
-      const fallbackText = text || presentation.content;
+      const fallbackText = stripPartialImageMarker(text || presentation.content);
       if (!fallbackText || !this.options.sendFallback)
         return false;
       await this.options.sendFallback(presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
@@ -5892,12 +6051,23 @@ var DingtalkInteractionPresenter = class {
       this.addTerminalSegment(activeSegmentId);
     }
     const finalization = this.enqueue(run, async () => {
-      if (terminal === "failed" && activeSegmentId) {
-        this.options.statusCards?.fail(activeSegmentId, detail);
+      if (terminal === "failed") {
+        const statusContext = this.ensureStatusContext(run);
+        this.options.statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
+        this.options.statusCards?.fail(statusContext.segmentId, this.withSenderPrefix(run, "\u672C\u6B21\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002"));
+        await this.redeliverCardDeliveredContent(run);
       } else if (terminal === "cancelled") {
+        const statusContext = run.statusContext;
+        if (statusContext) {
+          this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSenderPrefix(run, detail === "cancel_command" ? "\u4EFB\u52A1\u5DF2\u505C\u6B62" : "\u4EFB\u52A1\u5DF2\u53D6\u6D88"));
+        }
         this.options.statusCards?.cancelRun(runId, detail === "cancel_command" ? "cancel_command" : "dropped");
-      } else if (activeSegmentId) {
-        await this.options.statusCards?.complete(activeSegmentId, detail);
+        await this.redeliverCardDeliveredContent(run);
+      } else {
+        const statusContext = run.statusContext;
+        if (statusContext) {
+          await this.options.statusCards?.complete(statusContext.segmentId, "", (retained) => retained ? this.withSenderPrefix(run, retained) : retained);
+        }
       }
     });
     void finalization.then(() => {
@@ -5929,17 +6099,71 @@ var DingtalkInteractionPresenter = class {
       return result;
     };
   }
+  /**
+   * A failed or cancelled terminal overwrites the single continuity card,
+   * erasing content a boundary already declared delivered there. Send it as
+   * a text message so it survives the overwrite.
+   */
+  async redeliverCardDeliveredContent(run) {
+    const delivered = run.cardDelivered;
+    if (!delivered || !this.options.sendFallback)
+      return;
+    run.cardDelivered = void 0;
+    await this.options.sendFallback(delivered.chatId, delivered.text, delivered.sessionId);
+  }
   enqueue(run, operation) {
     const result = run.projectionChain.then(operation);
     run.projectionChain = result.then(() => void 0, () => void 0);
     return result;
   }
-  boundContent(content) {
-    const limit = 2e4;
-    const marker = "[Earlier output truncated]\n";
+  boundContent(content, limit = CONTENT_LIMIT) {
     if (content.length <= limit)
       return content;
-    return `${marker}${content.slice(content.length - (limit - marker.length))}`;
+    if (limit === 0)
+      return "";
+    if (limit <= TRUNCATION_MARKER.length)
+      return content.slice(-limit);
+    return `${TRUNCATION_MARKER}${content.slice(content.length - (limit - TRUNCATION_MARKER.length))}`;
+  }
+  withSenderPrefix(run, content) {
+    if (!run.senderPrefix)
+      return this.boundContent(content);
+    const body = this.withoutExistingSenderPrefix(run, content);
+    if (!body)
+      return run.senderPrefix;
+    const separator = "\n\n";
+    const bodyLimit = Math.max(0, CONTENT_LIMIT - run.senderPrefix.length - separator.length);
+    return `${run.senderPrefix}${separator}${this.boundContent(body, bodyLimit)}`;
+  }
+  withoutExistingSenderPrefix(run, content) {
+    const prefixes = /* @__PURE__ */ new Set([run.senderPrefix, run.senderRawPrefix]);
+    let body = content;
+    while (body) {
+      let removed = false;
+      for (const prefix of prefixes) {
+        if (!prefix)
+          continue;
+        if (body === prefix)
+          return "";
+        if (!body.startsWith(prefix))
+          continue;
+        const remainder = body.slice(prefix.length);
+        if (/^\s/u.test(remainder)) {
+          body = remainder.replace(/^\s{1,2}/u, "");
+          removed = true;
+          break;
+        }
+      }
+      if (!removed)
+        break;
+    }
+    return body;
+  }
+  ensureStatusContext(run, segment) {
+    if (run.statusContext)
+      return run.statusContext;
+    run.statusContext = segment ? { ...segment } : { ...run.baseContext, segmentId: `${run.runId}:${randomUUID4()}` };
+    return run.statusContext;
   }
   cardTarget(target) {
     const isGroup = target.isGroup === true;
@@ -5972,7 +6196,6 @@ var DIRECT_MSG_API = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend"
 var PROACTIVE_MSG_KEY = "sampleMarkdown";
 var TOKEN_API = "https://oapi.dingtalk.com/gettoken";
 var PROACTIVE_FETCH_TIMEOUT_MS = 15e3;
-var TEXT_MESSAGE_LIMIT = 3800;
 var mentionTarget = Symbol("mentionTarget");
 var IMAGE_INSTRUCTIONS = [
   "",
@@ -6007,20 +6230,6 @@ function withNonBotMentionContext(data, text) {
 ${text}` : context;
 }
 __name(withNonBotMentionContext, "withNonBotMentionContext");
-function splitTextChunks(text, firstChunkLimit) {
-  if (!text)
-    return [text];
-  const chunks = [];
-  let offset = 0;
-  let chunkLimit = firstChunkLimit;
-  while (offset < text.length) {
-    chunks.push(text.slice(offset, offset + chunkLimit));
-    offset += chunkLimit;
-    chunkLimit = TEXT_MESSAGE_LIMIT;
-  }
-  return chunks;
-}
-__name(splitTextChunks, "splitTextChunks");
 var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static {
     __name(this, "DingtalkChannel");
@@ -6031,7 +6240,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   seenMessages = /* @__PURE__ */ new Map();
   mentionTargets = /* @__PURE__ */ new Map();
   sessionMentionTargets = /* @__PURE__ */ new Map();
-  textReplySessions = /* @__PURE__ */ new Set();
   bufferedMentionTargets = /* @__PURE__ */ new Set();
   bufferedMentionTargetsBySession = /* @__PURE__ */ new Map();
   dedupTimer;
@@ -6115,7 +6323,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           statusCards: this.statusCardController,
           questionCards: this.questionCardController,
           ...config.blockStreaming !== "on" ? {
-            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId) => this.sendResponseMessage(chatId, text, sessionId), "sendFallback")
+            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId) => this.sendFallbackReply(chatId, text, sessionId), "sendFallback")
           } : {}
         });
       }
@@ -6370,34 +6578,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
       });
-      if (!resp.ok) {
-        const detail = await resp.text().catch(() => "");
-        process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: HTTP ${resp.status} ${detail}
-`);
-      }
-    }
-  }
-  async sendTextReply(chatId, text, atUserId) {
-    const webhook = this.webhooks.get(chatId);
-    if (!webhook)
-      return;
-    const mentionPrefix = atUserId ? `@${atUserId}
-
-` : "";
-    const chunks = splitTextChunks(text, TEXT_MESSAGE_LIMIT - mentionPrefix.length);
-    for (let i = 0; i < chunks.length; i++) {
-      const isMention = i === 0 && atUserId !== void 0;
-      const resp = await fetch(webhook, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          msgtype: "text",
-          text: {
-            content: isMention ? `${mentionPrefix}${chunks[i]}` : chunks[i]
-          },
-          ...isMention ? { at: { atUserIds: [atUserId] } } : {}
-        })
-      });
       if (isMention && process.env["QWEN_CHANNEL_DEBUG_MENTIONS"] === "1") {
         const payload = await resp.clone().json().catch(() => void 0);
         const response = payload && typeof payload === "object" ? payload : {};
@@ -6408,7 +6588,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
       if (!resp.ok) {
         const detail = await resp.text().catch(() => "");
-        process.stderr.write(`[DingTalk:${this.name}] sendTextReply failed: HTTP ${resp.status} ${detail}
+        process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: HTTP ${resp.status} ${detail}
 `);
       }
     }
@@ -6697,7 +6877,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
     }
     this.sessionMentionTargets.delete(sessionId);
-    this.textReplySessions.delete(sessionId);
     const cardRunId = this.cardRunBySession.get(sessionId);
     if (cardRunId) {
       this.cardRunBySession.delete(sessionId);
@@ -6726,7 +6905,8 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       if (event.runId && event.owner && inboundOwner?.ownerId === event.owner.id) {
         this.cardRuns.set(event.runId, inboundOwner);
         this.cardRunBySession.set(event.sessionId, event.runId);
-        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target);
+        this.interactionPresenter?.registerRun(event.runId, event.owner.id, inboundOwner.target, event.sessionId, inboundOwner.sender);
+        this.interactionPresenter?.startStatusCard(event.runId);
       }
       return;
     }
@@ -6784,7 +6964,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.mentionTargets.delete(messageId);
       if (this.atSender && atUserId) {
         this.sessionMentionTargets.set(sessionId, atUserId);
-        this.textReplySessions.add(sessionId);
       }
     }
     this.startReaction(chatId, messageId, sessionId);
@@ -6800,7 +6979,12 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         target: {
           chatId: envelope.chatId,
           isGroup: envelope.isGroup
-        }
+        },
+        ...this.atSender && envelope.isGroup ? {
+          sender: {
+            senderName: envelope.senderName
+          }
+        } : {}
       });
       if (this.inboundCardOwners.size > 1e3) {
         const oldest = this.inboundCardOwners.keys().next().value;
@@ -6834,22 +7018,17 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   onPromptEnd(chatId, sessionId, messageId) {
     this.sessionMentionTargets.delete(sessionId);
-    this.textReplySessions.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
   async sendResponseMessage(chatId, text, sessionId) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    if (this.textReplySessions.has(sessionId)) {
-      if (findImageMarkers(text).length > 0) {
-        await this.sendReply(chatId, text, atUserId);
-        return;
-      }
-      await this.sendTextReply(chatId, text, atUserId);
-      return;
-    }
-    await this.sendReply(chatId, text);
+    await this.sendReply(chatId, text, atUserId);
+  }
+  async sendFallbackReply(chatId, text, sessionId) {
+    const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+    await this.sendReply(chatId, text, atUserId);
   }
   async onResponseComplete(chatId, text, sessionId, segment) {
     if (segment && this.interactionPresenter) {
@@ -7035,7 +7214,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         }
       ];
     } else {
-      const dir = join(tmpdir2(), "channel-files", randomUUID4());
+      const dir = join(tmpdir2(), "channel-files", randomUUID5());
       mkdirSync(dir, { recursive: true });
       const safeName = basename2(fileName || "") || `dingtalk_${mediaType}_${Date.now()}`;
       const filePath = join(dir, safeName);