@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.2

package/chunks/{dist-STAGIFNB.js → dist-6YDUH3BB.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-XVTCSVBK.js";
+} from "./chunk-WDVV3LRM.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -38,7 +38,7 @@ init_esbuild_shims();
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 init_esbuild_shims();
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { basename as basename3, join } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -6279,11 +6279,6 @@ function projectFileText(text) {
   return projector.result(safe);
 }
 __name(projectFileText, "projectFileText");
-function withFileUnavailableNotice(text) {
-  const safe = text.trimEnd();
-  return `${safe}${safe ? "\n" : ""}${FILE_UNAVAILABLE_NOTICE}`;
-}
-__name(withFileUnavailableNotice, "withFileUnavailableNotice");
 function safeFileName(filePath) {
   return basename2(filePath).replace(/[\p{Cc}\p{Cf}[\]]+/gu, "_").slice(0, 200) || "file";
 }
@@ -6853,16 +6848,24 @@ function parseDingtalkInteractiveCardConfig(value) {
   const root = asRecord(value) ?? {};
   const status = asRecord(root["statusCard"]);
   const question = asRecord(root["questionCard"]);
+  const permission = asRecord(root["permissionCard"]);
   if (root["statusCard"] !== void 0 && !status) {
     throw new Error("DingTalk interactiveCards.statusCard must be an object.");
   }
   if (root["questionCard"] !== void 0 && !question) {
     throw new Error("DingTalk interactiveCards.questionCard must be an object.");
   }
-  const timeoutMs = question?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : question["timeoutMs"];
-  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
+  if (root["permissionCard"] !== void 0 && !permission) {
+    throw new Error("DingTalk interactiveCards.permissionCard must be an object.");
+  }
+  const questionTimeoutMs = question?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : question["timeoutMs"];
+  if (typeof questionTimeoutMs !== "number" || !Number.isFinite(questionTimeoutMs) || questionTimeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
     throw new Error("DingTalk interactiveCards.questionCard.timeoutMs must be a finite positive number.");
   }
+  const permissionTimeoutMs = permission?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : permission["timeoutMs"];
+  if (typeof permissionTimeoutMs !== "number" || !Number.isFinite(permissionTimeoutMs) || permissionTimeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
+    throw new Error("DingTalk interactiveCards.permissionCard.timeoutMs must be a finite positive number.");
+  }
   return {
     enabled: optionalBoolean(root["enabled"], "enabled", configured),
     statusCard: {
@@ -6870,7 +6873,11 @@ function parseDingtalkInteractiveCardConfig(value) {
     },
     questionCard: {
       enabled: optionalBoolean(question?.["enabled"], "questionCard.enabled", true),
-      timeoutMs: Math.min(timeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
+      timeoutMs: Math.min(questionTimeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
+    },
+    permissionCard: {
+      enabled: optionalBoolean(permission?.["enabled"], "permissionCard.enabled", true),
+      timeoutMs: Math.min(permissionTimeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
     }
   };
 }
@@ -7981,9 +7988,294 @@ ${text}`;
   }
 };
 
-// packages/channels/dingtalk/dist/interaction-presenter.js
+// packages/channels/dingtalk/dist/permission-card-controller.js
 init_esbuild_shims();
 import { randomUUID as randomUUID4 } from "node:crypto";
+var DECISION_FIELD = "permission_decision";
+var PERMISSION_CARD_COPY = {
+  en: {
+    title: "Permission required",
+    submit: "Submit",
+    choose: "Choose how to continue",
+    approved: { description: "Permission approved.", button: "Approved" },
+    denied: { description: "Permission denied.", button: "Denied" },
+    expired: {
+      description: "This permission request is no longer available.",
+      button: "Expired"
+    },
+    cancelled: {
+      description: "Permission request cancelled.",
+      button: "Cancelled"
+    }
+  },
+  zh: {
+    title: "\u9700\u8981\u6388\u6743",
+    submit: "\u63D0\u4EA4",
+    choose: "\u8BF7\u9009\u62E9\u540E\u7EED\u64CD\u4F5C",
+    approved: { description: "\u5DF2\u6388\u6743\u3002", button: "\u5DF2\u6388\u6743" },
+    denied: { description: "\u5DF2\u62D2\u7EDD\u6388\u6743\u3002", button: "\u5DF2\u62D2\u7EDD" },
+    expired: { description: "\u6B64\u6388\u6743\u8BF7\u6C42\u5DF2\u5931\u6548\u3002", button: "\u5DF2\u5931\u6548" },
+    cancelled: { description: "\u6388\u6743\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002", button: "\u5DF2\u53D6\u6D88" }
+  }
+};
+var PermissionCardController = class {
+  static {
+    __name(this, "PermissionCardController");
+  }
+  options;
+  byRequest = /* @__PURE__ */ new Map();
+  byOutTrack = /* @__PURE__ */ new Map();
+  pendingByRun = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  async present(context, target) {
+    const previous = this.byRequest.get(context.requestId);
+    if (previous) {
+      this.reserveTerminalProjection(previous);
+      await this.finalize(previous, "expired");
+    }
+    const record = {
+      context,
+      target,
+      outTrackId: `qwen-permission-${randomUUID4()}`,
+      state: "reserved",
+      delivered: false,
+      forbiddenActors: /* @__PURE__ */ new Set()
+    };
+    this.byRequest.set(context.requestId, record);
+    this.byOutTrack.set(record.outTrackId, record);
+    const unsubscribe = context.onSettled((reason) => {
+      if (record.state === "claimed")
+        return;
+      if (record.state === "pending")
+        this.reserveTerminalProjection(record);
+      void this.finalize(record, reason === "resolved_outside_presenter" ? "expired" : "cancelled");
+    });
+    record.unsubscribe = unsubscribe;
+    if (record.state === "terminal")
+      unsubscribe();
+    try {
+      await this.options.client.createAndDeliver({
+        templateId: QUESTION_CARD_TEMPLATE_ID,
+        outTrackId: record.outTrackId,
+        target,
+        cardParamMap: this.cardData(context)
+      });
+      record.delivered = true;
+    } catch (error) {
+      this.options.onError?.("permission card creation", error);
+      if (record.state === "terminal")
+        return { kind: "presented" };
+      this.discard(record);
+      return { kind: "unsupported" };
+    }
+    if (record.state !== "reserved") {
+      await this.projectTerminal(record);
+      return { kind: "presented" };
+    }
+    record.state = "pending";
+    const pending = this.pendingByRun.get(context.runId) ?? /* @__PURE__ */ new Set();
+    pending.add(context.requestId);
+    this.pendingByRun.set(context.runId, pending);
+    record.timer = setTimeout(() => {
+      void this.expire(record);
+    }, this.options.timeoutMs);
+    record.timer.unref?.();
+    return { kind: "presented" };
+  }
+  claim(callback) {
+    const record = this.byOutTrack.get(callback.outTrackId);
+    if (!record || record.state !== "pending") {
+      return { kind: "ignored", actorId: callback.actorId };
+    }
+    if (record.context.owner.id !== callback.actorId) {
+      if (record.forbiddenActors.has(callback.actorId)) {
+        return { kind: "ignored" };
+      }
+      record.forbiddenActors.add(callback.actorId);
+      return {
+        kind: "forbidden",
+        actorId: callback.actorId,
+        target: record.target
+      };
+    }
+    if (callback.hasBusinessPayload === false || !callback.isCancel && callback.actionId !== "cancel" && callback.actionId !== "submit" && callback.actionId !== record.context.requestId) {
+      return { kind: "ignored", actorId: callback.actorId };
+    }
+    if (callback.isCancel || callback.actionId === "cancel") {
+      this.reserveTerminalProjection(record);
+      record.state = "claimed";
+      return {
+        kind: "accepted",
+        execute: /* @__PURE__ */ __name(() => this.respond(record, "deny", "cancelled"), "execute")
+      };
+    }
+    const decision = this.parseDecision(record, callback.formData);
+    if (!decision)
+      return { kind: "ignored", actorId: callback.actorId };
+    this.reserveTerminalProjection(record);
+    record.state = "claimed";
+    return {
+      kind: "accepted",
+      execute: /* @__PURE__ */ __name(() => this.respond(record, decision), "execute")
+    };
+  }
+  cancelRun(runId) {
+    const requestIds = [...this.pendingByRun.get(runId) ?? []];
+    for (const requestId of requestIds) {
+      const record = this.byRequest.get(requestId);
+      if (record) {
+        this.reserveTerminalProjection(record);
+        void this.finalize(record, "cancelled");
+      }
+    }
+  }
+  async respond(record, decision, terminalState) {
+    try {
+      const accepted = await record.context.respond(decision);
+      await this.finalize(record, accepted ? terminalState ?? (decision === "deny" ? "denied" : "approved") : "expired");
+    } catch (error) {
+      this.options.onError?.("permission response", error);
+      await this.finalize(record, "expired");
+    }
+  }
+  async expire(record) {
+    if (record.state !== "pending")
+      return;
+    this.reserveTerminalProjection(record);
+    record.state = "claimed";
+    const response = record.context.respond("deny").catch((error) => {
+      this.options.onError?.("expired permission cancellation", error);
+    });
+    await this.finalize(record, "expired");
+    await response;
+  }
+  async finalize(record, terminalState) {
+    if (record.state === "terminal")
+      return;
+    record.state = "terminal";
+    record.terminalState = terminalState;
+    this.removeRecord(record);
+    if (!record.delivered)
+      return;
+    const finishTerminalProjection = record.finishTerminalProjection;
+    record.finishTerminalProjection = void 0;
+    if (finishTerminalProjection) {
+      await finishTerminalProjection(() => this.projectTerminal(record));
+    } else {
+      await this.projectTerminal(record);
+    }
+  }
+  discard(record) {
+    if (record.state === "terminal")
+      return;
+    record.state = "terminal";
+    this.removeRecord(record);
+  }
+  removeRecord(record) {
+    if (record.timer)
+      clearTimeout(record.timer);
+    record.timer = void 0;
+    record.unsubscribe?.();
+    record.unsubscribe = void 0;
+    this.byRequest.delete(record.context.requestId);
+    this.byOutTrack.delete(record.outTrackId);
+    const pending = this.pendingByRun.get(record.context.runId);
+    pending?.delete(record.context.requestId);
+    if (pending?.size === 0)
+      this.pendingByRun.delete(record.context.runId);
+  }
+  reserveTerminalProjection(record) {
+    record.finishTerminalProjection ??= this.options.reserveRunProjection?.(record.context.runId);
+  }
+  async projectTerminal(record) {
+    if (!record.terminalState)
+      return;
+    const copy = PERMISSION_CARD_COPY[this.options.locale ?? "en"];
+    const cardParamMap = {
+      approved: {
+        card_status: "approved",
+        question_desc: copy.approved.description,
+        form_btn_text: copy.approved.button
+      },
+      denied: {
+        card_status: "denied",
+        question_desc: copy.denied.description,
+        form_btn_text: copy.denied.button
+      },
+      expired: {
+        card_status: "expired",
+        question_desc: copy.expired.description,
+        form_btn_text: copy.expired.button
+      },
+      cancelled: {
+        card_status: "cancelled",
+        question_desc: copy.cancelled.description,
+        form_btn_text: copy.cancelled.button
+      }
+    };
+    try {
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: cardParamMap[record.terminalState]
+      });
+    } catch (error) {
+      this.options.onError?.("permission card finalization", error);
+    }
+  }
+  parseDecision(record, formData) {
+    if (Object.keys(formData).length !== 1 || !Object.prototype.hasOwnProperty.call(formData, DECISION_FIELD)) {
+      return void 0;
+    }
+    const values = this.readValues(formData[DECISION_FIELD]);
+    if (values.length !== 1)
+      return void 0;
+    const decision = values[0];
+    return record.context.decisions.some((candidate) => candidate.kind === decision) ? decision : void 0;
+  }
+  readValues(value) {
+    if (typeof value === "string")
+      return value.trim() ? [value.trim()] : [];
+    if (Array.isArray(value)) {
+      return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+    }
+    if (value !== null && typeof value === "object") {
+      return this.readValues(value["value"]);
+    }
+    return [];
+  }
+  cardData(context) {
+    const copy = PERMISSION_CARD_COPY[this.options.locale ?? "en"];
+    return {
+      question_id: context.requestId,
+      question_title: copy.title,
+      question_desc: context.title,
+      card_status: "pending",
+      form_btn_text: copy.submit,
+      selected_text: "",
+      selected_values: "[]",
+      form: {
+        fields: [
+          {
+            name: DECISION_FIELD,
+            label: copy.choose,
+            type: "CHECKBOX_GROUP",
+            required: true,
+            options: context.decisions.map((decision) => ({
+              value: decision.kind,
+              text: decision.label
+            }))
+          }
+        ]
+      }
+    };
+  }
+};
+
+// packages/channels/dingtalk/dist/interaction-presenter.js
+init_esbuild_shims();
+import { randomUUID as randomUUID5 } from "node:crypto";
 function escapeSenderMarkdownText(text) {
   return text.replace(/([\\`*_[\]{}()#+.!|>~-])/gu, "\\$1");
 }
@@ -8149,6 +8441,16 @@ var DingtalkInteractionPresenter = class {
       return Promise.resolve({ kind: "unsupported" });
     return questionCards.present(context, this.cardTarget(context.target));
   }
+  presentPermission(context) {
+    const run = this.runs.get(context.runId);
+    if (!run || run.terminal || run.ownerId !== context.owner.id || run.target.chatId !== context.target.chatId || run.target.isGroup !== context.target.isGroup) {
+      return Promise.resolve({ kind: "unsupported" });
+    }
+    const permissionCards = this.options.permissionCards;
+    if (!permissionCards)
+      return Promise.resolve({ kind: "unsupported" });
+    return permissionCards.present(context, this.cardTarget(context.target));
+  }
   terminalCopy() {
     if (this.options.language !== void 0 && !isChinesePresentationLanguage(this.options.language)) {
       return {
@@ -8168,6 +8470,7 @@ var DingtalkInteractionPresenter = class {
     if (!run || run.terminal)
       return;
     this.options.questionCards?.cancelRun(runId, terminal === "cancelled" && (detail === "cancel_command" || detail === "clear") ? "cancelled" : "expired");
+    this.options.permissionCards?.cancelRun(runId);
     run.terminal = true;
     const activeSegmentId = run.activeSegmentId;
     run.activeSegmentId = void 0;
@@ -8323,7 +8626,7 @@ ${this.boundContent(content, Math.max(0, CONTENT_LIMIT - sourceLabel.length - 2)
   ensureStatusContext(run, segment) {
     if (run.statusContext)
       return run.statusContext;
-    run.statusContext = segment ? { ...segment } : { ...run.baseContext, segmentId: `${run.runId}:${randomUUID4()}` };
+    run.statusContext = segment ? { ...segment } : { ...run.baseContext, segmentId: `${run.runId}:${randomUUID5()}` };
     return run.statusContext;
   }
   cardTarget(target) {
@@ -8802,6 +9105,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   interactiveCardClient;
   statusCardController;
   questionCardController;
+  permissionCardController;
   interactionPresenter;
   inboundCardOwners = /* @__PURE__ */ new Map();
   cardRunBySession = /* @__PURE__ */ new Map();
@@ -8810,14 +9114,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   // boundary, input requested) mints a fresh segment UUID but the projection
   // state must survive it, or a marker split across the reset leaks.
   fileProjectors = /* @__PURE__ */ new Map();
-  blockFileProjectors = /* @__PURE__ */ new Map();
-  // Sessions armed for block projection by onPromptStart and disarmed when
-  // the turn settles (or the session dies). A block send that finds NO
-  // projector state is only legitimate as a turn's FIRST block, which always
-  // lands while armed: late sends from an evicted (/clear) or dead session
-  // must be dropped, because recreating state would post the tail of a
-  // force-split [FILE: ...] marker verbatim.
-  blockProjectionArmed = /* @__PURE__ */ new Set();
   backgroundResponseAggregations = /* @__PURE__ */ new Map();
   detachedBackgroundResponseAggregations = /* @__PURE__ */ new Set();
   pendingBackgroundResponseTerminals = /* @__PURE__ */ new Map();
@@ -8836,7 +9132,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     } else if (!this.config.instructions.includes("[IMAGE:")) {
       this.config.instructions += IMAGE_INSTRUCTIONS;
     }
-    if (config.blockStreaming !== "on" && !this.config.instructions.includes("[FILE:")) {
+    if (!this.config.instructions.includes("[FILE:")) {
       this.config.instructions += FILE_INSTRUCTIONS;
     }
     this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
@@ -8864,7 +9160,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           }
         }, "invalidateAccessToken")
       });
-      if (this.interactiveCardConfig.statusCard.enabled && config.blockStreaming !== "on") {
+      if (this.interactiveCardConfig.statusCard.enabled) {
         this.statusCardController = new StatusCardController({
           client: this.interactiveCardClient,
           cancelRun: /* @__PURE__ */ __name((sessionId, runId) => this.requestPromptRunCancellation(sessionId, runId), "cancelRun"),
@@ -8888,14 +9184,25 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           }, "onError")
         });
       }
-      if (this.statusCardController || this.questionCardController) {
+      if (this.interactiveCardConfig.permissionCard.enabled) {
+        this.permissionCardController = new PermissionCardController({
+          client: this.interactiveCardClient,
+          timeoutMs: this.interactiveCardConfig.permissionCard.timeoutMs,
+          locale: this.locale,
+          reserveRunProjection: /* @__PURE__ */ __name((runId) => this.interactionPresenter?.reserveProjection(runId), "reserveRunProjection"),
+          onError: /* @__PURE__ */ __name((operation, error) => {
+            process.stderr.write(`[DingTalk:${this.name}] ${operation} failed: ${sanitizeLogText(String(error), 300)}
+`);
+          }, "onError")
+        });
+      }
+      if (this.statusCardController || this.questionCardController || this.permissionCardController) {
         this.interactionPresenter = new DingtalkInteractionPresenter({
           statusCards: this.statusCardController,
           questionCards: this.questionCardController,
+          permissionCards: this.permissionCardController,
           ...options?.displayLanguage ? { language: options.displayLanguage } : {},
-          ...config.blockStreaming !== "on" ? {
-            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
-          } : {}
+          sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
         });
       }
     }
@@ -8979,7 +9286,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (callback.actionId === "btn_stop") {
       return this.statusCardController?.claimStop(callback.outTrackId, callback.actorId) ?? { kind: "ignored", actorId: callback.actorId };
     }
-    return this.questionCardController?.claim(callback) ?? {
+    const permissionResult = this.permissionCardController?.claim(callback);
+    if (permissionResult && permissionResult.kind !== "ignored") {
+      return permissionResult;
+    }
+    return this.questionCardController?.claim(callback) ?? permissionResult ?? {
       kind: "ignored",
       actorId: callback.actorId
     };
@@ -9191,9 +9502,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       process.stderr.write(`[DingTalk:${this.name}] file markers projected (final=${projection.markerCount}, streamed=${streamedMarkers})
 `);
     }
-    if (this.config.blockStreaming === "on" && (projection.markerCount > 0 || streamedMarkers > 0)) {
-      return this.prepareOutgoingText(withFileUnavailableNotice(projection.text));
-    }
     const notices = [];
     if (projection.invalidMarkers > 0) {
       notices.push("[File delivery failed: invalid marker]");
@@ -9432,20 +9740,29 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     return data.access_token;
   }
   sendCardInteractionFeedback(actorId, target) {
+    const copy = this.locale === "zh" ? {
+      title: "\u5361\u7247\u64CD\u4F5C",
+      group: "\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u672C\u6B21\u64CD\u4F5C\u672A\u751F\u6548\u3002",
+      direct: "\u4F60\u65E0\u6743\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u63D0\u4EA4\u6216\u505C\u6B62\u3002"
+    } : {
+      title: "Card interaction",
+      group: "Only the task initiator can operate this card. This action had no effect.",
+      direct: "You cannot operate this card. Only the task initiator can submit or stop it."
+    };
     if (target?.isGroup) {
       return this.sendProactiveChunk({
         channelName: this.name,
         senderId: actorId,
         chatId: target.chatId,
         isGroup: true
-      }, "\u5361\u7247\u64CD\u4F5C", "\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u672C\u6B21\u64CD\u4F5C\u672A\u751F\u6548\u3002", "card interaction feedback");
+      }, copy.title, copy.group, "card interaction feedback");
     }
     return this.sendProactiveChunk({
       channelName: this.name,
       senderId: actorId,
       chatId: actorId,
       isGroup: false
-    }, "\u5361\u7247\u64CD\u4F5C", "\u4F60\u65E0\u6743\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u63D0\u4EA4\u6216\u505C\u6B62\u3002", "card interaction feedback");
+    }, copy.title, copy.direct, "card interaction feedback");
   }
   async sendProactiveChunk(target, title, text, chunkLabel) {
     return this.sendProactivePayload(target, PROACTIVE_MSG_KEY, { title, text }, chunkLabel);
@@ -9841,8 +10158,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /** Recall reactions left behind when a session dies without terminal lifecycle events. */
   onSessionDied(sessionId) {
-    this.blockProjectionArmed.delete(sessionId);
-    this.blockFileProjectors.delete(sessionId);
     for (const [runId, state] of this.fileProjectors) {
       if (state.sessionId === sessionId)
         this.fileProjectors.delete(runId);
@@ -9966,7 +10281,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
   }
   onPromptStart(chatId, sessionId, messageId) {
-    this.blockProjectionArmed.add(sessionId);
     if (messageId) {
       this.bufferedMentionTargets.delete(messageId);
       this.untrackBufferedMentionTarget(sessionId, messageId);
@@ -10029,35 +10343,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.bufferedMentionTargetsBySession.delete(sessionId);
   }
   onPromptEnd(chatId, sessionId, messageId) {
-    this.settleBlockFileProjector(chatId, sessionId);
     this.sessionMentionTargets.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
-  /**
-   * Turn end is the only point where the block projector's held state can be
-   * settled: ChannelBase drains the turn's queued block sends before calling
-   * onPromptEnd, so everything already appended belongs to this turn. Flush
-   * the held candidate bytes (a trailing `[FILE:` prefix the stream never
-   * completed) before deleting the entry — a later delete-without-settle
-   * would silently drop them from the delivered answer. Also disarm the
-   * session: /clear eviction and session death settle WITHOUT draining the
-   * turn's send chain, and any block that lands afterwards must be dropped
-   * rather than recreating projector state.
-   */
-  settleBlockFileProjector(chatId, sessionId) {
-    this.blockProjectionArmed.delete(sessionId);
-    const state = this.blockFileProjectors.get(sessionId);
-    if (!state)
-      return;
-    this.blockFileProjectors.delete(sessionId);
-    const tail = state.projector.complete();
-    if (!tail.trim())
-      return;
-    void this.sendReply(chatId, tail, void 0, this.getResponseSourceLabel(sessionId)).catch((err) => {
-      process.stderr.write(`[DingTalk:${this.name}] projector tail delivery failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}
-`);
-    });
-  }
   /** Deliver every Agent segment immediately unless aggregation is enabled. */
   async dispatchBackgroundResponse(sessionId, text, context) {
     const target = this.router.getTarget(sessionId);
@@ -10610,51 +10898,21 @@ ${text}`;
     return escapeDingTalkMarkdown(normalized || "\u540E\u53F0\u4EFB\u52A1");
   }
   /**
-   * Out-of-turn one-shot sends (background responses) must not flow through
-   * the session's block-streaming projector: a second sender interleaving with
-   * mid-projection state can swallow the send or split a held marker.
+   * Body-identical to the base implementation — this override exists only to
+   * widen the signature, which the base seam does not declare. The background
+   * aggregation flush passes `prepared` so the body it already projected isn't
+   * projected a second time (that would re-upload its files), and
+   * `failOnHttpError` so a failed send throws instead of being swallowed,
+   * letting the flush capture the delivery plan for the next retry.
    */
   async deliverBackgroundReply(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
-    if (this.config.blockStreaming !== "on") {
-      return this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
-    }
-    await this.sendReply(chatId, text, void 0, sourceLabel, prepared, failOnHttpError);
+    await this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
   }
   async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
-    let outgoingText = text;
-    let consumesMention = true;
-    if (this.config.blockStreaming === "on") {
-      const projected = this.projectBlockStreamChunk(text, sessionId);
-      if (!projected.text.trim())
-        return;
-      outgoingText = projected.text;
-      consumesMention = projected.hasContent;
-    }
-    const atUserId = consumesMention && this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+    const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared, failOnHttpError);
-  }
-  projectBlockStreamChunk(text, sessionId) {
-    let state = this.blockFileProjectors.get(sessionId);
-    if (!state) {
-      if (!this.blockProjectionArmed.has(sessionId)) {
-        return { text: "", hasContent: false };
-      }
-      state = { projector: new OutboundFileProjector(), reportedMarkers: 0 };
-      this.blockFileProjectors.set(sessionId, state);
-    }
-    const safe = state.projector.append(text);
-    const hasContent = safe.trim().length > 0;
-    const result = state.projector.result(safe);
-    let outgoingText = safe;
-    if (result.markerCount > state.reportedMarkers) {
-      outgoingText = withFileUnavailableNotice(safe);
-      state.reportedMarkers = result.markerCount;
-      process.stderr.write(`[DingTalk:${this.name}] file markers redacted in block stream (session ${sessionId}, markers=${result.markerCount})
-`);
-    }
-    return { text: outgoingText, hasContent };
+    await this.sendReply(chatId, text, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared, failOnHttpError);
   }
   async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
@@ -10708,6 +10966,16 @@ ${text}`;
     }
     return this.interactionPresenter.presentInput(context);
   }
+  async presentPermissionRequest(context) {
+    const run = this.cardRuns.get(context.runId);
+    if (!run || run.ownerId !== context.owner.id) {
+      return { kind: "unsupported" };
+    }
+    if (!this.permissionCardController || !this.interactionPresenter) {
+      return { kind: "unsupported" };
+    }
+    return this.interactionPresenter.presentPermission(context);
+  }
   /**
    * Extract quoted/referenced message context from a reply.
    * DingTalk provides this via text.repliedMsg (newer) or quoteMessage (legacy).
@@ -10946,7 +11214,7 @@ ${text}`;
       let filePath;
       let safeName;
       try {
-        dir = join(tmpdir3(), "channel-files", randomUUID5());
+        dir = join(tmpdir3(), "channel-files", randomUUID6());
         mkdirSync(dir, { recursive: true });
         safeName = basename3(typeof fileName === "string" ? fileName : "") || `dingtalk_${mediaType}_${Date.now()}.${GENERATED_MEDIA_EXT[media.mimeType] ?? "bin"}`;
         filePath = join(dir, safeName);
@@ -11053,7 +11321,7 @@ ${text}`;
         }
       }) : this.handleInbound(envelope);
       processMessage.catch((err) => {
-        const reference = randomUUID5().slice(0, 8);
+        const reference = randomUUID6().slice(0, 8);
         let errorSummary = "Unknown error";
         try {
           errorSummary = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
@@ -11140,6 +11408,24 @@ var plugin = {
                 exclusiveMinimum: DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM
               }
             ]
+          },
+          {
+            key: "permissionCard",
+            label: "Permission Card",
+            kind: "object",
+            properties: [
+              {
+                key: "enabled",
+                label: "Enabled",
+                kind: "boolean"
+              },
+              {
+                key: "timeoutMs",
+                label: "Timeout (ms)",
+                kind: "number",
+                exclusiveMinimum: DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM
+              }
+            ]
           }
         ]
       }