@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{dist-AIKFMUKK.js → dist-SL2LUMML.js}

@@ -4,14 +4,15 @@ import {
   require_follow_redirects,
   require_form_data,
   require_proxy_from_env
-} from "./chunk-S3TWXGKA.js";
-import "./chunk-T2NCM2ET.js";
+} from "./chunk-JE7KQ2UP.js";
+import "./chunk-K6KS3LTN.js";
+import "./chunk-T3CHYWJZ.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType,
   sanitizeLogText,
   sanitizeSenderName
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-JCJ7LKNA.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-CR3C7WXL.js";
@@ -36,9 +37,9 @@ init_esbuild_shims();
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 init_esbuild_shims();
 import { mkdirSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { basename, join } from "node:path";
-import { tmpdir } from "node:os";
+import { randomUUID as randomUUID4 } 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";
 
 // node_modules/dingtalk-stream-sdk-nodejs/dist/index.mjs
@@ -47,6 +48,7 @@ init_esbuild_shims();
 // node_modules/dingtalk-stream-sdk-nodejs/dist/constants.mjs
 init_esbuild_shims();
 var TOPIC_ROBOT = "/v1.0/im/bot/messages/get";
+var TOPIC_CARD = "/v1.0/card/instances/callback";
 
 // node_modules/dingtalk-stream-sdk-nodejs/dist/client.mjs
 init_esbuild_shims();
@@ -4460,6 +4462,210 @@ async function downloadMedia(downloadCode, robotCode, accessToken) {
 }
 __name(downloadMedia, "downloadMedia");
 
+// packages/channels/dingtalk/dist/outbound-image.js
+init_esbuild_shims();
+import { closeSync, fstatSync, openSync, readFileSync, readSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, extname, isAbsolute, relative } from "node:path";
+var MEDIA_UPLOAD_API = "https://oapi.dingtalk.com/media/upload";
+var MEDIA_UPLOAD_TIMEOUT_MS = 3e4;
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".bmp"]);
+var AUTH_ERROR_CODES = /* @__PURE__ */ new Set([40014, 42001]);
+var DingTalkMediaUploadError = class extends Error {
+  static {
+    __name(this, "DingTalkMediaUploadError");
+  }
+  authFailure;
+  constructor(message, authFailure) {
+    super(message);
+    this.authFailure = authFailure;
+    this.name = "DingTalkMediaUploadError";
+  }
+};
+function maskCode(text) {
+  const masked = text.split("");
+  const blank = /* @__PURE__ */ __name((start, end) => {
+    for (let i = start; i < end; i++) {
+      if (masked[i] !== "\n")
+        masked[i] = " ";
+    }
+  }, "blank");
+  let offset = 0;
+  while (offset < text.length) {
+    if (text[offset] === "`") {
+      let runLength = 1;
+      while (text[offset + runLength] === "`")
+        runLength++;
+      const delimiter = "`".repeat(runLength);
+      const closing = text.indexOf(delimiter, offset + runLength);
+      const newline = runLength >= 3 ? -1 : text.indexOf("\n", offset + runLength);
+      const closesBeforeNewline = closing !== -1 && (newline === -1 || closing < newline);
+      const end = closesBeforeNewline ? closing + runLength : newline === -1 ? text.length : newline;
+      blank(offset, end);
+      offset = end;
+      continue;
+    }
+    offset++;
+  }
+  return masked.join("");
+}
+__name(maskCode, "maskCode");
+function findImageMarkers(text) {
+  const visibleText = maskCode(text);
+  const markerPattern = /\[IMAGE:\s*([^\]\r\n]+)\]/gi;
+  const markers = [];
+  for (const match of visibleText.matchAll(markerPattern)) {
+    const path = match[1]?.trim();
+    if (!path || match.index === void 0)
+      continue;
+    markers.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      path
+    });
+  }
+  return markers;
+}
+__name(findImageMarkers, "findImageMarkers");
+function replaceImageMarkers(text, markers, replacements) {
+  if (markers.length !== replacements.length) {
+    throw new Error("Image marker replacement count mismatch");
+  }
+  let result = text;
+  for (let i = markers.length - 1; i >= 0; i--) {
+    const marker = markers[i];
+    result = result.slice(0, marker.start) + replacements[i] + result.slice(marker.end);
+  }
+  return result;
+}
+__name(replaceImageMarkers, "replaceImageMarkers");
+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;
+}
+__name(sanitizeStreamingImageMarkers, "sanitizeStreamingImageMarkers");
+function isInside(realPath, directory) {
+  const pathFromDirectory = relative(directory, realPath);
+  return pathFromDirectory === "" || !pathFromDirectory.startsWith("..") && !isAbsolute(pathFromDirectory);
+}
+__name(isInside, "isInside");
+function detectImageMime(data) {
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) {
+    return "image/png";
+  }
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255) {
+    return "image/jpeg";
+  }
+  if (data[0] === 71 && data[1] === 73 && data[2] === 70) {
+    return "image/gif";
+  }
+  if (data[0] === 66 && data[1] === 77) {
+    return "image/bmp";
+  }
+  throw new Error("Unrecognized image format");
+}
+__name(detectImageMime, "detectImageMime");
+function readValidatedImage(imagePath, options) {
+  if (!isAbsolute(imagePath)) {
+    throw new Error(`Image path must be absolute: ${imagePath}`);
+  }
+  const extension = extname(imagePath).toLowerCase();
+  if (!IMAGE_EXTENSIONS.has(extension)) {
+    throw new Error(`Image extension not allowed: ${extension}`);
+  }
+  let realPath;
+  try {
+    realPath = realpathSync(imagePath);
+  } catch {
+    throw new Error(`Image file not found: ${imagePath}`);
+  }
+  const allowedDirectories = [
+    realpathSync(options.workspaceDir),
+    realpathSync(options.temporaryDir ?? tmpdir())
+  ];
+  if (!allowedDirectories.some((directory) => isInside(realPath, directory))) {
+    throw new Error(`Image path outside allowed directories: ${realPath}`);
+  }
+  const descriptor = openSync(realPath, "r");
+  try {
+    const stats = fstatSync(descriptor);
+    if (!stats.isFile()) {
+      throw new Error(`Not a regular file: ${realPath}`);
+    }
+    if (stats.size > MAX_IMAGE_BYTES) {
+      throw new Error(`Image too large: ${stats.size} bytes (max ${MAX_IMAGE_BYTES})`);
+    }
+    const header = Buffer.alloc(16);
+    const bytesRead = readSync(descriptor, header, 0, header.length, 0);
+    const mimeType = detectImageMime(header.subarray(0, bytesRead));
+    const expectedMime = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".bmp": "image/bmp"
+    };
+    if (mimeType !== expectedMime[extension]) {
+      throw new Error(`Image type mismatch: ${extension} expects ${expectedMime[extension]} but got ${mimeType}`);
+    }
+    return {
+      data: readFileSync(descriptor),
+      fileName: basename(realPath),
+      mimeType
+    };
+  } finally {
+    closeSync(descriptor);
+  }
+}
+__name(readValidatedImage, "readValidatedImage");
+function sanitizeApiMessage(message, accessToken) {
+  const value = String(message ?? "");
+  return (accessToken ? value.replaceAll(accessToken, "[redacted]") : value).replace(/[\r\n\t]+/g, " ").slice(0, 200);
+}
+__name(sanitizeApiMessage, "sanitizeApiMessage");
+async function uploadDingTalkImage(image, accessToken) {
+  const form = new FormData();
+  form.append("media", new Blob([image.data], { type: image.mimeType }), image.fileName);
+  let response;
+  try {
+    const url2 = new URL(MEDIA_UPLOAD_API);
+    url2.searchParams.set("access_token", accessToken);
+    url2.searchParams.set("type", "image");
+    response = await fetch(url2, {
+      method: "POST",
+      body: form,
+      signal: AbortSignal.timeout(MEDIA_UPLOAD_TIMEOUT_MS)
+    });
+  } catch {
+    throw new DingTalkMediaUploadError("DingTalk media upload failed: network request failed", false);
+  }
+  let payload;
+  try {
+    const parsed = await response.json();
+    payload = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    throw new DingTalkMediaUploadError(`DingTalk media upload failed: HTTP ${response.status} invalid JSON response`, response.status === 401);
+  }
+  const errcode = typeof payload["errcode"] === "number" ? payload["errcode"] : void 0;
+  if (!response.ok || errcode !== void 0 && errcode !== 0) {
+    const detail = sanitizeApiMessage(payload["errmsg"], accessToken);
+    throw new DingTalkMediaUploadError(`DingTalk media upload failed: HTTP ${response.status}${errcode === void 0 ? "" : ` errcode=${errcode}`}${detail ? ` ${detail}` : ""}`, response.status === 401 || errcode !== void 0 && AUTH_ERROR_CODES.has(errcode));
+  }
+  const mediaId = typeof payload["media_id"] === "string" ? payload["media_id"] : typeof payload["mediaId"] === "string" ? payload["mediaId"] : void 0;
+  if (!mediaId) {
+    throw new DingTalkMediaUploadError("DingTalk media upload failed: response did not include a MediaID", false);
+  }
+  return mediaId;
+}
+__name(uploadDingTalkImage, "uploadDingTalkImage");
+
 // packages/channels/dingtalk/dist/DingtalkConnectionManager.js
 init_esbuild_shims();
 var SOCKET_OPEN = 1;
@@ -4765,6 +4971,994 @@ var DingtalkConnectionManager = class {
   }
 };
 
+// packages/channels/dingtalk/dist/interactive-card-client.js
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var STATUS_CARD_TEMPLATE_ID = "675cde2f-f526-40cb-b828-f5b2b57b8b77.schema";
+var QUESTION_CARD_TEMPLATE_ID = "c2a6355b-9724-4f7e-9653-d33fcb3311bb.schema";
+var DINGTALK_API = "https://api.dingtalk.com";
+var CARD_FETCH_TIMEOUT_MS = 1e4;
+function stringifyCardParamMap(cardParamMap) {
+  return Object.fromEntries(Object.entries(cardParamMap).map(([key, value]) => [
+    key,
+    typeof value === "string" ? value : JSON.stringify(value)
+  ]));
+}
+__name(stringifyCardParamMap, "stringifyCardParamMap");
+var DingtalkInteractiveCardClient = class {
+  static {
+    __name(this, "DingtalkInteractiveCardClient");
+  }
+  options;
+  fetch;
+  constructor(options) {
+    this.options = options;
+    this.fetch = options.fetch ?? globalThis.fetch;
+  }
+  async createAndDeliver(input) {
+    const targetModel = input.target.isGroup ? {
+      imGroupOpenDeliverModel: {
+        robotCode: this.options.robotCode,
+        extension: { dynamicSummary: "true" }
+      }
+    } : {
+      imRobotOpenDeliverModel: {
+        spaceType: "IM_ROBOT",
+        robotCode: this.options.robotCode,
+        extension: { dynamicSummary: "true" }
+      }
+    };
+    const data = await this.request("/v1.0/card/instances/createAndDeliver", "POST", {
+      cardTemplateId: input.templateId,
+      outTrackId: input.outTrackId,
+      cardData: {
+        cardParamMap: stringifyCardParamMap(input.cardParamMap)
+      },
+      callbackType: "STREAM",
+      imGroupOpenSpaceModel: { supportForward: true },
+      imRobotOpenSpaceModel: { supportForward: true },
+      openSpaceId: input.target.isGroup ? `dtv1.card//IM_GROUP.${input.target.chatId}` : `dtv1.card//IM_ROBOT.${input.target.chatId}`,
+      userIdType: 1,
+      ...targetModel
+    }, input.templateId);
+    const result = data && typeof data === "object" ? data.result : void 0;
+    const deliveries = result?.deliverResults;
+    if (Array.isArray(deliveries)) {
+      const failure = deliveries.find((entry) => entry !== null && typeof entry === "object" && entry.success === false);
+      if (failure) {
+        throw new Error(`${input.templateId}: ${typeof failure.errorMsg === "string" && failure.errorMsg.trim() ? failure.errorMsg.trim() : "DingTalk card delivery failed"}`);
+      }
+    }
+  }
+  async openOrUpdateStream(input) {
+    await this.request("/v1.0/card/streaming", "PUT", {
+      outTrackId: input.outTrackId,
+      guid: randomUUID(),
+      key: input.key,
+      content: input.content,
+      isFull: true,
+      isFinalize: input.finalize,
+      isError: input.isError ?? false
+    });
+  }
+  async updateInstance(input) {
+    await this.request("/v1.0/card/instances", "PUT", {
+      outTrackId: input.outTrackId,
+      cardData: {
+        cardParamMap: stringifyCardParamMap(input.cardParamMap)
+      },
+      cardUpdateOptions: { updateCardDataByKey: true }
+    });
+  }
+  async request(path, method, body, templateId) {
+    const token = await this.options.getAccessToken();
+    const response = await this.fetch(`${DINGTALK_API}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "x-acs-dingtalk-access-token": token
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(CARD_FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const detail = (await response.text().catch(() => "")).slice(0, 300);
+      throw new Error(`DingTalk Card OpenAPI ${method} ${path} failed${templateId ? ` for ${templateId}` : ""}: HTTP ${response.status}${detail ? ` ${detail}` : ""}`);
+    }
+    return response.json().catch(() => void 0);
+  }
+};
+
+// packages/channels/dingtalk/dist/interactive-card-types.js
+init_esbuild_shims();
+var DEFAULT_QUESTION_TIMEOUT_MS = 27e4;
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+__name(asRecord, "asRecord");
+function parseEmbeddedRecord(value) {
+  if (typeof value !== "string") {
+    return asRecord(value);
+  }
+  try {
+    return asRecord(JSON.parse(value));
+  } catch {
+    return void 0;
+  }
+}
+__name(parseEmbeddedRecord, "parseEmbeddedRecord");
+function parseBooleanLike(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+__name(parseBooleanLike, "parseBooleanLike");
+function optionalBoolean(value, path, fallback) {
+  if (value === void 0)
+    return fallback;
+  if (typeof value !== "boolean") {
+    throw new Error(`DingTalk interactiveCards.${path} must be a boolean.`);
+  }
+  return value;
+}
+__name(optionalBoolean, "optionalBoolean");
+function parseDingtalkInteractiveCardConfig(value) {
+  if (value !== void 0 && !asRecord(value)) {
+    throw new Error("DingTalk interactiveCards must be an object.");
+  }
+  const configured = value !== void 0;
+  const root = asRecord(value) ?? {};
+  const status = asRecord(root["statusCard"]);
+  const question = asRecord(root["questionCard"]);
+  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 <= 0) {
+    throw new Error("DingTalk interactiveCards.questionCard.timeoutMs must be a finite positive number.");
+  }
+  return {
+    enabled: optionalBoolean(root["enabled"], "enabled", configured),
+    statusCard: {
+      enabled: optionalBoolean(status?.["enabled"], "statusCard.enabled", true)
+    },
+    questionCard: {
+      enabled: optionalBoolean(question?.["enabled"], "questionCard.enabled", true),
+      timeoutMs
+    }
+  };
+}
+__name(parseDingtalkInteractiveCardConfig, "parseDingtalkInteractiveCardConfig");
+function parseDingtalkCardCallback(value) {
+  const root = parseEmbeddedRecord(value);
+  if (!root)
+    return void 0;
+  const embeddedValue = parseEmbeddedRecord(root["value"]);
+  const embeddedContent = parseEmbeddedRecord(root["content"]);
+  const privateSources = [embeddedValue, embeddedContent, root].map((source) => parseEmbeddedRecord(source?.["cardPrivateData"])).filter((source) => source !== void 0);
+  const sources = [
+    embeddedValue,
+    embeddedContent,
+    ...privateSources,
+    root
+  ].filter((source) => source !== void 0);
+  const pickString = /* @__PURE__ */ __name((...keys) => {
+    for (const source of sources) {
+      for (const key of keys) {
+        const candidate = source[key];
+        if (typeof candidate === "string" && candidate.trim()) {
+          return candidate.trim();
+        }
+      }
+    }
+    return void 0;
+  }, "pickString");
+  const privateData = privateSources[0];
+  const actionIds = privateData?.["actionIds"];
+  const actionId = (Array.isArray(actionIds) && typeof actionIds[0] === "string" && actionIds[0].trim() ? actionIds[0].trim() : void 0) ?? pickString("actionValue", "eventKey", "actionId");
+  const outTrackId = pickString("outTrackId");
+  const actorId = parseDingtalkCardActorId(root);
+  if (!outTrackId || !actionId || !actorId)
+    return void 0;
+  const params = sources.map((source) => parseEmbeddedRecord(source["params"])).find((source) => source !== void 0);
+  const formData = sources.flatMap((source) => [
+    parseEmbeddedRecord(source["formData"]),
+    parseEmbeddedRecord(parseEmbeddedRecord(source["params"])?.["form"])
+  ]).find((source) => source !== void 0);
+  const hasCancelField = params !== void 0 && Object.prototype.hasOwnProperty.call(params, "user_cancel");
+  return {
+    outTrackId,
+    actionId,
+    actorId,
+    formData: formData ?? {},
+    hasBusinessPayload: formData !== void 0 || hasCancelField,
+    isCancel: hasCancelField && parseBooleanLike(params["user_cancel"])
+  };
+}
+__name(parseDingtalkCardCallback, "parseDingtalkCardCallback");
+function parseDingtalkCardActorId(value) {
+  const root = parseEmbeddedRecord(value);
+  if (!root)
+    return void 0;
+  return ["userId", "senderStaffId", "senderId"].map((key) => root[key]).find((candidate) => typeof candidate === "string" && candidate.trim().length > 0)?.trim();
+}
+__name(parseDingtalkCardActorId, "parseDingtalkCardActorId");
+
+// packages/channels/dingtalk/dist/status-card-controller.js
+init_esbuild_shims();
+import { randomUUID as randomUUID2 } from "node:crypto";
+var FLUSH_INTERVAL_MS = 500;
+var CONTENT_LIMIT = 2e4;
+var TRUNCATION_MARKER = "[Earlier output truncated]\n";
+function boundContent(content) {
+  if (content.length <= CONTENT_LIMIT)
+    return content;
+  return `${TRUNCATION_MARKER}${content.slice(content.length - (CONTENT_LIMIT - TRUNCATION_MARKER.length))}`;
+}
+__name(boundContent, "boundContent");
+var StatusCardController = class {
+  static {
+    __name(this, "StatusCardController");
+  }
+  options;
+  recordsBySegment = /* @__PURE__ */ new Map();
+  recordsByOutTrack = /* @__PURE__ */ new Map();
+  segmentIdsByRun = /* @__PURE__ */ new Map();
+  terminalSegmentIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = options;
+  }
+  append(segment, target, chunk) {
+    if (!chunk || this.terminalSegmentIds.has(segment.segmentId))
+      return;
+    let record = this.recordsBySegment.get(segment.segmentId);
+    if (!record) {
+      record = this.createRecord(segment, target);
+    }
+    if (record.terminal)
+      return;
+    record.content = boundContent(record.content + chunk);
+    if (record.streamFailed)
+      return;
+    record.pendingSnapshot = sanitizeStreamingImageMarkers(record.content);
+    this.scheduleFlush(record);
+  }
+  createRecord(segment, target) {
+    const outTrackId = `qwen-status-${randomUUID2()}`;
+    const record = {
+      segmentId: segment.segmentId,
+      runId: segment.runId,
+      sessionId: segment.sessionId,
+      ownerId: segment.owner.id,
+      target,
+      outTrackId,
+      content: "",
+      startedAt: Date.now(),
+      lastStatusSecond: 0,
+      ready: Promise.resolve(false),
+      terminal: false,
+      streamFailed: false,
+      stopClaimed: false,
+      forbiddenActors: /* @__PURE__ */ new Set(),
+      lastWriteAt: Date.now(),
+      writeChain: Promise.resolve()
+    };
+    this.recordsBySegment.set(record.segmentId, record);
+    this.recordsByOutTrack.set(outTrackId, record);
+    const segmentIds = this.segmentIdsByRun.get(record.runId) ?? /* @__PURE__ */ new Set();
+    segmentIds.add(record.segmentId);
+    this.segmentIdsByRun.set(record.runId, segmentIds);
+    record.ready = this.create(record, target);
+    return record;
+  }
+  complete(segmentId, text) {
+    return this.finalize(segmentId, boundContent(text), "Completed", false);
+  }
+  fail(segmentId, error) {
+    void this.finalize(segmentId, boundContent(error), "Failed", true);
+  }
+  cancelRun(runId, reason) {
+    for (const segmentId of [...this.segmentIdsByRun.get(runId) ?? []]) {
+      const record = this.recordsBySegment.get(segmentId);
+      if (!record)
+        continue;
+      void this.finalize(segmentId, sanitizeStreamingImageMarkers(record.content), reason === "cancel_command" ? "Stopped" : "Cancelled", false);
+    }
+  }
+  claimStop(outTrackId, actorId) {
+    const record = this.recordsByOutTrack.get(outTrackId);
+    if (!record || record.terminal || record.stopClaimed) {
+      return { kind: "ignored", actorId };
+    }
+    if (record.ownerId !== actorId) {
+      if (record.forbiddenActors.has(actorId)) {
+        return { kind: "ignored" };
+      }
+      record.forbiddenActors.add(actorId);
+      return { kind: "forbidden", actorId, target: record.target };
+    }
+    record.stopClaimed = true;
+    return {
+      kind: "accepted",
+      execute: /* @__PURE__ */ __name(async () => {
+        const cancelled = await this.options.cancelRun(record.sessionId, record.runId);
+        if (this.recordsByOutTrack.get(outTrackId) !== record || record.terminal) {
+          return;
+        }
+        if (!cancelled) {
+          record.stopClaimed = false;
+          return;
+        }
+        this.cancelRun(record.runId, "cancel_command");
+      }, "execute")
+    };
+  }
+  async create(record, target) {
+    try {
+      await this.options.client.createAndDeliver({
+        templateId: STATUS_CARD_TEMPLATE_ID,
+        outTrackId: record.outTrackId,
+        target,
+        cardParamMap: {
+          content: "",
+          flowStatus: 2,
+          statusLine: this.statusLine(record, "Running").text,
+          hasAction: "true",
+          stop_action: "true"
+        }
+      });
+      await this.options.client.openOrUpdateStream({
+        outTrackId: record.outTrackId,
+        key: "content",
+        content: "",
+        finalize: false
+      });
+      return true;
+    } catch (error) {
+      this.options.onError?.("status card creation", error);
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: {
+          flowStatus: 3,
+          statusLine: "Unavailable",
+          hasAction: "false",
+          stop_action: "false"
+        }
+      }).catch(() => {
+      });
+      return false;
+    }
+  }
+  scheduleFlush(record) {
+    if (record.flushTimer || record.inFlight || record.terminal)
+      return;
+    const delay = Math.max(0, FLUSH_INTERVAL_MS - (Date.now() - record.lastWriteAt));
+    record.flushTimer = setTimeout(() => {
+      record.flushTimer = void 0;
+      this.flush(record);
+    }, delay);
+  }
+  flush(record) {
+    if (record.terminal || record.inFlight || record.pendingSnapshot === void 0)
+      return;
+    const content = record.pendingSnapshot;
+    record.pendingSnapshot = void 0;
+    const write = record.writeChain.then(async () => {
+      const ready = await record.ready;
+      if (!ready || record.terminal)
+        return;
+      await this.options.client.openOrUpdateStream({
+        outTrackId: record.outTrackId,
+        key: "content",
+        content,
+        finalize: false
+      });
+      await this.updateRunningStatus(record);
+    }).catch((error) => {
+      record.streamFailed = true;
+      record.pendingSnapshot = void 0;
+      this.options.onError?.("status card streaming", error);
+    });
+    const tracked = write.finally(() => {
+      if (record.inFlight === tracked) {
+        record.inFlight = void 0;
+      }
+      record.lastWriteAt = Date.now();
+      if (record.pendingSnapshot !== void 0)
+        this.scheduleFlush(record);
+    });
+    record.inFlight = tracked;
+    record.writeChain = tracked;
+  }
+  async finalize(segmentId, content, state, isError) {
+    const record = this.recordsBySegment.get(segmentId);
+    if (!record || record.terminal)
+      return false;
+    record.terminal = true;
+    this.terminalSegmentIds.add(segmentId);
+    while (this.terminalSegmentIds.size > 1e3) {
+      const oldest = this.terminalSegmentIds.values().next().value;
+      if (oldest === void 0)
+        break;
+      this.terminalSegmentIds.delete(oldest);
+    }
+    if (record.flushTimer)
+      clearTimeout(record.flushTimer);
+    record.flushTimer = void 0;
+    record.pendingSnapshot = void 0;
+    try {
+      if (!await record.ready)
+        return false;
+      await record.writeChain;
+      const finalContent = boundContent(sanitizeStreamingImageMarkers(content || record.content));
+      await this.options.client.openOrUpdateStream({
+        outTrackId: record.outTrackId,
+        key: "content",
+        content: "",
+        finalize: true,
+        isError
+      });
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: {
+          blockList: JSON.stringify([
+            {
+              type: 0,
+              markdown: finalContent
+            }
+          ]),
+          content: finalContent,
+          copy_content: finalContent,
+          flowStatus: 3,
+          statusLine: this.statusLine(record, state).text,
+          hasAction: "false",
+          stop_action: "false"
+        }
+      });
+      record.content = "";
+      return true;
+    } catch (error) {
+      this.options.onError?.("status card finalization", error);
+      return false;
+    } finally {
+      if (this.recordsBySegment.get(segmentId) === record) {
+        this.recordsBySegment.delete(segmentId);
+      }
+      if (this.recordsByOutTrack.get(record.outTrackId) === record) {
+        this.recordsByOutTrack.delete(record.outTrackId);
+      }
+      const segmentIds = this.segmentIdsByRun.get(record.runId);
+      segmentIds?.delete(segmentId);
+      if (segmentIds?.size === 0) {
+        this.segmentIdsByRun.delete(record.runId);
+      }
+    }
+  }
+  statusLine(record, state) {
+    const second = Math.max(0, Math.floor((Date.now() - record.startedAt) / 1e3));
+    const model = this.options.model?.trim();
+    return {
+      text: [state, model, `${second}s`].filter(Boolean).join(" \xB7 "),
+      second
+    };
+  }
+  async updateRunningStatus(record) {
+    if (record.terminal)
+      return;
+    const status = this.statusLine(record, "Running");
+    if (status.second === record.lastStatusSecond)
+      return;
+    try {
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: { statusLine: status.text }
+      });
+      record.lastStatusSecond = status.second;
+    } catch (error) {
+      this.options.onError?.("status card metadata", error);
+    }
+  }
+};
+
+// packages/channels/dingtalk/dist/question-card-controller.js
+init_esbuild_shims();
+import { randomUUID as randomUUID3 } from "node:crypto";
+var OTHER_OPTION_VALUE = "__qwen_other__";
+var QuestionCardController = class {
+  static {
+    __name(this, "QuestionCardController");
+  }
+  options;
+  byRequest = /* @__PURE__ */ new Map();
+  byOutTrack = /* @__PURE__ */ new Map();
+  activeByScope = /* @__PURE__ */ new Map();
+  pendingByRun = /* @__PURE__ */ new Map();
+  nextSequence = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  async present(context, target) {
+    const scopeKey = this.scopeKey(context);
+    const active = this.activeByScope.get(scopeKey);
+    if (active?.state === "reserved" || active?.state === "pending") {
+      if (active.context.runId === context.runId) {
+        return { kind: "unsupported" };
+      }
+      if (active.state === "pending")
+        this.reserveTerminalProjection(active);
+      void this.finalize(active, "expired", "A newer question is available. Answer the latest card.");
+    }
+    const record = {
+      context,
+      target,
+      outTrackId: `qwen-question-${randomUUID3()}`,
+      scopeKey,
+      sequence: this.nextSequence++,
+      state: "reserved",
+      delivered: false,
+      forbiddenActors: /* @__PURE__ */ new Set()
+    };
+    this.byRequest.set(context.requestId, record);
+    this.byOutTrack.set(record.outTrackId, record);
+    this.activeByScope.set(record.scopeKey, 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" ? "resolved_outside_presenter" : "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?.("question card creation", error);
+      if (record.state === "terminal") {
+        return { kind: "presented" };
+      }
+      await this.finalize(record, "cancelled");
+      try {
+        await this.options.sendFallback(context.target.chatId, this.fallbackText(context));
+      } catch (fallbackError) {
+        this.options.onError?.("question fallback delivery", fallbackError);
+      }
+      await context.respond({ outcome: { outcome: "cancelled" } });
+      return { kind: "handled" };
+    }
+    if (record.state !== "reserved") {
+      await this.projectTerminal(record);
+      return { kind: "presented" };
+    }
+    const latest = this.activeByScope.get(record.scopeKey);
+    if (latest && latest.sequence > record.sequence) {
+      await this.finalize(record, "expired", "A newer question is available. Answer the latest card.");
+      return { kind: "presented" };
+    }
+    record.state = "pending";
+    this.activeByScope.set(record.scopeKey, record);
+    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) {
+      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, "cancelled"), "execute")
+      };
+    }
+    if (callback.actionId !== "submit" && callback.actionId !== record.context.requestId) {
+      return { kind: "ignored", actorId: callback.actorId };
+    }
+    const answers = this.parseAnswers(record, callback.formData);
+    if (!answers)
+      return { kind: "ignored", actorId: callback.actorId };
+    this.reserveTerminalProjection(record);
+    record.state = "claimed";
+    return {
+      kind: "accepted",
+      execute: /* @__PURE__ */ __name(() => this.respond(record, "submitted", answers), "execute")
+    };
+  }
+  cancelRun(runId, terminalState = "cancelled") {
+    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, terminalState, terminalState === "expired" ? "This question is no longer available." : void 0);
+      }
+    }
+  }
+  async respond(record, terminalState, answers) {
+    try {
+      const accepted = await record.context.respond(terminalState === "submitted" ? {
+        outcome: {
+          outcome: "selected",
+          optionId: record.context.submitOptionId
+        },
+        answers
+      } : { outcome: { outcome: "cancelled" } });
+      await this.finalize(record, accepted ? terminalState : "expired", accepted ? void 0 : "This question is no longer available.");
+    } catch (error) {
+      this.options.onError?.("question response", error);
+      await this.finalize(record, "expired", "This question is no longer available.");
+    }
+  }
+  async expire(record) {
+    if (record.state !== "pending")
+      return;
+    this.reserveTerminalProjection(record);
+    await this.finalize(record, "expired");
+    try {
+      await record.context.respond({ outcome: { outcome: "cancelled" } });
+    } catch (error) {
+      this.options.onError?.("expired question cancellation", error);
+    }
+  }
+  async finalize(record, state, description) {
+    if (record.state === "terminal")
+      return;
+    record.state = "terminal";
+    record.terminalState = state;
+    record.terminalDescription = description;
+    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);
+    if (this.activeByScope.get(record.scopeKey) === record) {
+      this.activeByScope.delete(record.scopeKey);
+    }
+    const pending = this.pendingByRun.get(record.context.runId);
+    pending?.delete(record.context.requestId);
+    if (pending?.size === 0)
+      this.pendingByRun.delete(record.context.runId);
+    if (record.delivered) {
+      const finishTerminalProjection = record.finishTerminalProjection;
+      record.finishTerminalProjection = void 0;
+      if (finishTerminalProjection) {
+        await finishTerminalProjection(() => this.projectTerminal(record));
+      } else {
+        await this.projectTerminal(record);
+      }
+    }
+  }
+  reserveTerminalProjection(record) {
+    record.finishTerminalProjection ??= this.options.reserveRunProjection?.(record.context.runId);
+  }
+  async projectTerminal(record) {
+    if (!record.terminalState)
+      return;
+    const cardParamMap = {
+      submitted: {
+        card_status: "submitted",
+        question_desc: "Submitted.",
+        form_btn_text: "Submitted"
+      },
+      expired: {
+        card_status: "expired",
+        question_desc: "This question expired. Please retry.",
+        form_btn_text: "Expired"
+      },
+      resolved_outside_presenter: {
+        card_status: "expired",
+        question_desc: "Resolved outside this card.",
+        form_btn_text: "Expired"
+      },
+      cancelled: {
+        card_status: "cancelled",
+        question_desc: "Cancelled.",
+        form_btn_text: "Cancelled"
+      }
+    };
+    try {
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: {
+          ...cardParamMap[record.terminalState],
+          ...record.terminalDescription ? { question_desc: record.terminalDescription } : {}
+        }
+      });
+    } catch (error) {
+      this.options.onError?.("question card finalization", error);
+    }
+  }
+  parseAnswers(record, formData) {
+    const allowed = new Set(record.context.questions.flatMap((question) => [
+      question.answerKey,
+      this.otherAnswerKey(question.answerKey)
+    ]));
+    if (Object.keys(formData).some((key) => !allowed.has(key))) {
+      return void 0;
+    }
+    const answers = {};
+    for (const question of record.context.questions) {
+      const values = this.readAnswerValues(formData[question.answerKey]);
+      if (values.length === 0 || !question.multiSelect && values.length !== 1)
+        return void 0;
+      const optionLabels = new Set(question.options.map((option) => option.label));
+      const customValue = this.readAnswerValues(formData[this.otherAnswerKey(question.answerKey)])[0]?.trim();
+      const normalized = [];
+      for (const value of values) {
+        if (value === OTHER_OPTION_VALUE) {
+          if (!customValue)
+            return void 0;
+          normalized.push(customValue);
+        } else if (optionLabels.has(value)) {
+          normalized.push(value);
+        } else {
+          return void 0;
+        }
+      }
+      answers[question.answerKey] = normalized.join(", ");
+    }
+    return answers;
+  }
+  readAnswerValues(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.readAnswerValues(value["value"]);
+    }
+    return [];
+  }
+  otherAnswerKey(answerKey) {
+    return `${answerKey}_other`;
+  }
+  scopeKey(context) {
+    return `${context.sessionId}\0${context.owner.id}`;
+  }
+  cardData(context) {
+    const first = context.questions[0];
+    return {
+      question_id: context.requestId,
+      question_title: first.header,
+      question_desc: first.question,
+      card_status: "pending",
+      form_btn_text: "Submit",
+      selected_text: "",
+      selected_values: "[]",
+      form: {
+        fields: context.questions.flatMap((question) => [
+          {
+            name: question.answerKey,
+            label: question.question,
+            type: question.multiSelect ? "MULTI_CHECKBOX_GROUP" : "CHECKBOX_GROUP",
+            required: true,
+            options: [
+              ...question.options.map((option) => ({
+                value: option.label,
+                text: option.label
+              })),
+              { value: OTHER_OPTION_VALUE, text: "Other" }
+            ]
+          },
+          {
+            name: this.otherAnswerKey(question.answerKey),
+            label: `${question.header}: Other`,
+            type: "TEXT",
+            required: false,
+            placeholder: "Enter a custom answer when Other is selected"
+          }
+        ])
+      }
+    };
+  }
+  fallbackText(context) {
+    const questions = context.questions.map((question) => `- ${question.question}: ${question.options.map((option) => option.label).join(", ")}`).join("\n");
+    return `The interactive question could not be delivered, so this request was cancelled. Please retry.
+${questions}`;
+  }
+};
+
+// packages/channels/dingtalk/dist/interaction-presenter.js
+init_esbuild_shims();
+var DingtalkInteractionPresenter = class {
+  static {
+    __name(this, "DingtalkInteractionPresenter");
+  }
+  options;
+  runs = /* @__PURE__ */ new Map();
+  segments = /* @__PURE__ */ new Map();
+  terminalSegmentIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = options;
+  }
+  registerRun(runId, ownerId, target) {
+    this.runs.set(runId, {
+      ownerId,
+      target,
+      projectionChain: Promise.resolve(),
+      terminal: false
+    });
+  }
+  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)) {
+      return;
+    }
+    const existing = this.segments.get(segment.segmentId);
+    if (existing && existing.run !== run)
+      return;
+    const presentation = existing ?? {
+      run,
+      context: segment,
+      content: ""
+    };
+    presentation.content = this.boundContent(presentation.content + chunk);
+    this.segments.set(segment.segmentId, presentation);
+    run.activeSegmentId = segment.segmentId;
+    if (!this.options.statusCards)
+      return;
+    void this.enqueue(run, () => {
+      this.options.statusCards?.append(segment, this.cardTarget(segment.target), chunk);
+    });
+  }
+  closeOutput(segmentId, text, reason, segment) {
+    let presentation = this.segments.get(segmentId);
+    if (!presentation && segment && text) {
+      this.appendOutput(segment, text);
+      presentation = this.segments.get(segmentId);
+    }
+    if (!presentation)
+      return Promise.resolve(false);
+    const run = presentation.run;
+    if (run.terminal)
+      return Promise.resolve(false);
+    this.segments.delete(segmentId);
+    this.addTerminalSegment(segmentId);
+    if (run.activeSegmentId === segmentId) {
+      run.activeSegmentId = void 0;
+    }
+    return this.enqueue(run, async () => {
+      const statusCards = this.options.statusCards;
+      if (reason === "failed") {
+        statusCards?.fail(segmentId, text);
+        return statusCards !== void 0;
+      }
+      if (reason === "cancelled") {
+        return statusCards !== void 0;
+      }
+      const completed = statusCards !== void 0 && await statusCards.complete(segmentId, text);
+      if (completed)
+        return true;
+      const fallbackText = text || presentation.content;
+      if (!fallbackText || !this.options.sendFallback)
+        return false;
+      await this.options.sendFallback(presentation.context.target.chatId, fallbackText, presentation.context.sessionId);
+      return true;
+    });
+  }
+  presentInput(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 questionCards = this.options.questionCards;
+    if (!questionCards)
+      return Promise.resolve({ kind: "unsupported" });
+    return questionCards.present(context, this.cardTarget(context.target));
+  }
+  terminalizeRun(runId, terminal, detail = "") {
+    const run = this.runs.get(runId);
+    if (!run || run.terminal)
+      return;
+    this.options.questionCards?.cancelRun(runId, terminal === "cancelled" && (detail === "cancel_command" || detail === "clear") ? "cancelled" : "expired");
+    run.terminal = true;
+    const activeSegmentId = run.activeSegmentId;
+    run.activeSegmentId = void 0;
+    if (activeSegmentId) {
+      this.segments.delete(activeSegmentId);
+      this.addTerminalSegment(activeSegmentId);
+    }
+    const finalization = this.enqueue(run, async () => {
+      if (terminal === "failed" && activeSegmentId) {
+        this.options.statusCards?.fail(activeSegmentId, detail);
+      } else if (terminal === "cancelled") {
+        this.options.statusCards?.cancelRun(runId, detail === "cancel_command" ? "cancel_command" : "dropped");
+      } else if (activeSegmentId) {
+        await this.options.statusCards?.complete(activeSegmentId, detail);
+      }
+    });
+    void finalization.then(() => {
+      if (this.runs.get(runId) === run)
+        this.runs.delete(runId);
+    }, () => {
+      if (this.runs.get(runId) === run)
+        this.runs.delete(runId);
+    });
+  }
+  reserveProjection(runId) {
+    const run = this.runs.get(runId);
+    if (!run || run.terminal)
+      return void 0;
+    let supplyOperation;
+    const operation = new Promise((resolve) => {
+      supplyOperation = resolve;
+    });
+    const result = this.enqueue(run, async () => {
+      const execute = await operation;
+      await execute();
+    });
+    let supplied = false;
+    return (execute) => {
+      if (!supplied) {
+        supplied = true;
+        supplyOperation(execute);
+      }
+      return result;
+    };
+  }
+  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";
+    if (content.length <= limit)
+      return content;
+    return `${marker}${content.slice(content.length - (limit - marker.length))}`;
+  }
+  cardTarget(target) {
+    const isGroup = target.isGroup === true;
+    return {
+      chatId: isGroup ? target.chatId : target.senderId,
+      isGroup
+    };
+  }
+  addTerminalSegment(segmentId) {
+    this.terminalSegmentIds.add(segmentId);
+    while (this.terminalSegmentIds.size > 1e3) {
+      const oldest = this.terminalSegmentIds.values().next().value;
+      if (oldest === void 0)
+        break;
+      this.terminalSegmentIds.delete(oldest);
+    }
+  }
+};
+
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
 var ACK_REACTION_NAME = "\u{1F440}";
@@ -4780,6 +5974,15 @@ 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 = [
+  "",
+  "If you created an image file (screenshot, chart, etc.), you can send it to the user by writing:",
+  "`[IMAGE: /absolute/path/to/file.png]` (without the backticks)",
+  "",
+  "The marker is stripped from text and the image is uploaded automatically.",
+  "",
+  "Only use a real image file inside the workspace or system temporary directory."
+].join("\n");
 function withNonBotMentionContext(data, text) {
   if (!Array.isArray(data.atUsers) || typeof data.chatbotUserId !== "string") {
     return text;
@@ -4848,9 +6051,28 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    * on (re)connect, so a long-lived socket serves a stale one after ~2h.
    */
   proactiveToken;
+  interactiveCardConfig;
+  interactiveCardClient;
+  statusCardController;
+  questionCardController;
+  interactionPresenter;
+  inboundCardOwners = /* @__PURE__ */ new Map();
+  cardRunBySession = /* @__PURE__ */ new Map();
+  cardRuns = /* @__PURE__ */ new Map();
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
+    if (!this.config.instructions) {
+      this.config.instructions = [
+        "## DingTalk Channel",
+        "",
+        "You are responding through DingTalk.",
+        IMAGE_INSTRUCTIONS
+      ].join("\n");
+    } else if (!this.config.instructions.includes("[IMAGE:")) {
+      this.config.instructions += IMAGE_INSTRUCTIONS;
+    }
+    this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
     }
@@ -4860,6 +6082,44 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     const useConnectionManager = rawUseConnectionManager ?? true;
     this.client = this.createClient(useConnectionManager);
+    if (this.interactiveCardConfig.enabled) {
+      this.interactiveCardClient = new DingtalkInteractiveCardClient({
+        robotCode: config.clientId,
+        getAccessToken: /* @__PURE__ */ __name(() => this.getProactiveToken(), "getAccessToken")
+      });
+      if (this.interactiveCardConfig.statusCard.enabled && config.blockStreaming !== "on") {
+        this.statusCardController = new StatusCardController({
+          client: this.interactiveCardClient,
+          cancelRun: /* @__PURE__ */ __name((sessionId, runId) => this.requestPromptRunCancellation(sessionId, runId), "cancelRun"),
+          ...config.model ? { model: config.model } : {},
+          onError: /* @__PURE__ */ __name((operation, error) => {
+            process.stderr.write(`[DingTalk:${this.name}] ${operation} failed: ${sanitizeLogText(String(error), 300)}
+`);
+          }, "onError")
+        });
+      }
+      if (this.interactiveCardConfig.questionCard.enabled) {
+        this.questionCardController = new QuestionCardController({
+          client: this.interactiveCardClient,
+          timeoutMs: this.interactiveCardConfig.questionCard.timeoutMs,
+          sendFallback: /* @__PURE__ */ __name((chatId, text) => this.sendMessage(chatId, text), "sendFallback"),
+          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.interactionPresenter = new DingtalkInteractionPresenter({
+          statusCards: this.statusCardController,
+          questionCards: this.questionCardController,
+          ...config.blockStreaming !== "on" ? {
+            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId) => this.sendResponseMessage(chatId, text, sessionId), "sendFallback")
+          } : {}
+        });
+      }
+    }
     if (useConnectionManager) {
       this.connectionManager = new DingtalkConnectionManager({
         initialClient: this.client,
@@ -4901,6 +6161,47 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       });
       this.onMessage(msg);
     });
+    if (this.interactiveCardConfig.enabled) {
+      client.registerCallbackListener(TOPIC_CARD, (msg) => {
+        this.onCardCallback(client, msg);
+      });
+    }
+  }
+  onCardCallback(client, msg) {
+    const callback = parseDingtalkCardCallback(msg.data);
+    const actorId = callback?.actorId ?? parseDingtalkCardActorId(msg.data);
+    let result;
+    try {
+      result = callback ? this.routeCardCallback(callback) : { kind: "ignored", ...actorId ? { actorId } : {} };
+    } catch (err) {
+      process.stderr.write(`[DingTalk:${this.name}] card callback routing failed: ${sanitizeLogText(String(err), 200)}
+`);
+      result = { kind: "ignored", ...actorId ? { actorId } : {} };
+    }
+    client.send(msg.headers.messageId, {
+      status: EventAck.SUCCESS,
+      message: "ok"
+    });
+    if (result.kind === "accepted") {
+      void result.execute().catch((err) => {
+        process.stderr.write(`[DingTalk:${this.name}] card callback action failed: ${sanitizeLogText(String(err), 200)}
+`);
+      });
+    } else if (result.kind === "forbidden") {
+      void this.sendCardInteractionFeedback(result.actorId, result.target).catch((err) => {
+        process.stderr.write(`[DingTalk:${this.name}] card interaction feedback failed: ${sanitizeLogText(String(err), 200)}
+`);
+      });
+    }
+  }
+  routeCardCallback(callback) {
+    if (callback.actionId === "btn_stop") {
+      return this.statusCardController?.claimStop(callback.outTrackId, callback.actorId) ?? { kind: "ignored", actorId: callback.actorId };
+    }
+    return this.questionCardController?.claim(callback) ?? {
+      kind: "ignored",
+      actorId: callback.actorId
+    };
   }
   onDownStream(raw, client) {
     this.connectionManager?.noteActivity(client);
@@ -5003,23 +6304,66 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static isUnroutableGroupMessage(isGroup, conversationId) {
     return isGroup && !conversationId;
   }
-  async sendReply(chatId, text) {
+  async prepareOutgoingText(text) {
+    const markers = findImageMarkers(text);
+    if (markers.length === 0)
+      return text;
+    const replacements = [];
+    for (const marker of markers) {
+      const fileName = basename2(marker.path).replace(/[\r\n[\]]+/g, "_").slice(0, 100) || "image";
+      try {
+        const image = readValidatedImage(marker.path, {
+          workspaceDir: this.config.cwd
+        });
+        let mediaId;
+        for (let attempt = 0; attempt < 2; attempt++) {
+          const token = await this.getProactiveToken();
+          try {
+            mediaId = await uploadDingTalkImage(image, token);
+            break;
+          } catch (error) {
+            if (error instanceof DingTalkMediaUploadError && error.authFailure && attempt === 0) {
+              this.proactiveToken = void 0;
+              continue;
+            }
+            throw error;
+          }
+        }
+        if (!mediaId) {
+          throw new Error("DingTalk media upload returned no MediaID");
+        }
+        replacements.push(`![image](${mediaId})`);
+      } catch (error) {
+        process.stderr.write(`[DingTalk:${this.name}] outbound image upload failed (${sanitizeLogText(fileName, 100)}): ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+        replacements.push(`[Image delivery failed: ${fileName}]`);
+      }
+    }
+    return replaceImageMarkers(text, markers, replacements);
+  }
+  async sendReply(chatId, text, atUserId) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
 `);
       return;
     }
-    const chunks = normalizeDingTalkMarkdown(text);
-    const title = extractTitle(text);
+    const outgoingText = await this.prepareOutgoingText(text);
+    const mentionPrefix = atUserId ? `@${atUserId}
+
+` : "";
+    const chunks = normalizeDingTalkMarkdown(mentionPrefix + outgoingText);
+    const title = extractTitle(outgoingText);
     for (let i = 0; i < chunks.length; i++) {
       const chunk = chunks[i];
+      const isMention = i === 0 && atUserId !== void 0;
       const body = {
         msgtype: "markdown",
         markdown: {
           title: i === 0 ? title : `${title} (cont.)`,
           text: chunk
-        }
+        },
+        ...isMention ? { at: { atUserIds: [atUserId] } } : {}
       };
       const resp = await fetch(webhook, {
         method: "POST",
@@ -5093,8 +6437,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async pushProactive(target, text) {
     if (!text.trim())
       return;
-    const chunks = normalizeDingTalkMarkdown(text);
-    const title = extractTitle(text);
+    const outgoingText = await this.prepareOutgoingText(text);
+    const chunks = normalizeDingTalkMarkdown(outgoingText);
+    const title = extractTitle(outgoingText);
     for (let i = 0; i < chunks.length; i++) {
       await this.sendProactiveChunk(target, i === 0 ? title : `${title} (cont.)`, chunks[i], `chunk ${i + 1}/${chunks.length}`);
     }
@@ -5128,6 +6473,22 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     };
     return data.access_token;
   }
+  sendCardInteractionFeedback(actorId, target) {
+    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");
+    }
+    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");
+  }
   async sendProactiveChunk(target, title, text, chunkLabel) {
     const targetKind = target.isGroup === true ? "group" : "dm";
     for (let attempt = 0; ; attempt++) {
@@ -5337,6 +6698,12 @@ 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);
+      this.interactionPresenter?.terminalizeRun(cardRunId, "cancelled");
+      this.cardRuns.delete(cardRunId);
+    }
     const keys = this.sessionReactionKeys.get(sessionId);
     if (keys) {
       this.sessionReactionKeys.delete(sessionId);
@@ -5353,12 +6720,33 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
+      const inboundOwner = event.messageId ? this.inboundCardOwners.get(event.messageId) : void 0;
+      if (event.messageId)
+        this.inboundCardOwners.delete(event.messageId);
+      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);
+      }
       return;
     }
     if (isTerminalTaskLifecycleType(event.type)) {
       if (event.messageId)
         this.mentionTargets.delete(event.messageId);
       this.stopReaction(event.chatId, event.messageId, event.sessionId);
+      if (event.runId) {
+        if (event.type === "failed") {
+          this.interactionPresenter?.terminalizeRun(event.runId, "failed", event.error);
+        } else if (event.type === "cancelled") {
+          this.interactionPresenter?.terminalizeRun(event.runId, "cancelled", event.reason);
+        } else {
+          this.interactionPresenter?.terminalizeRun(event.runId, "completed");
+        }
+        this.cardRuns.delete(event.runId);
+        if (this.cardRunBySession.get(event.sessionId) === event.runId) {
+          this.cardRunBySession.delete(event.sessionId);
+        }
+      }
     }
   }
   onPromptBufferDropped(_chatId, sessionId, messageIds) {
@@ -5405,6 +6793,21 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (!await this.preflightInbound(envelope))
       return;
     const messageId = envelope.messageId;
+    if (messageId && envelope.senderId) {
+      this.inboundCardOwners.delete(messageId);
+      this.inboundCardOwners.set(messageId, {
+        ownerId: envelope.senderId,
+        target: {
+          chatId: envelope.chatId,
+          isGroup: envelope.isGroup
+        }
+      });
+      if (this.inboundCardOwners.size > 1e3) {
+        const oldest = this.inboundCardOwners.keys().next().value;
+        if (oldest !== void 0)
+          this.inboundCardOwners.delete(oldest);
+      }
+    }
     const atUserId = envelope[mentionTarget];
     if (this.atSender && messageId && atUserId) {
       this.mentionTargets.set(messageId, atUserId);
@@ -5439,11 +6842,43 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     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);
   }
+  async onResponseComplete(chatId, text, sessionId, segment) {
+    if (segment && this.interactionPresenter) {
+      const outgoingText = await this.prepareOutgoingText(text);
+      if (await this.interactionPresenter.closeOutput(segment.segmentId, outgoingText, "completed", segment)) {
+        return;
+      }
+    }
+    await this.sendResponseMessage(chatId, text, sessionId);
+  }
+  onOutputSegmentEnd(_chatId, _sessionId, segment, reason) {
+    if (!this.interactionPresenter)
+      return;
+    return this.interactionPresenter.closeOutput(segment.segmentId, "", reason, segment).then(() => void 0);
+  }
+  onResponseChunk(_chatId, chunk, _sessionId, segment) {
+    if (segment)
+      this.interactionPresenter?.appendOutput(segment, chunk);
+  }
+  async presentUserInputRequest(context) {
+    const run = this.cardRuns.get(context.runId);
+    if (!run || run.ownerId !== context.owner.id) {
+      return { kind: "unsupported" };
+    }
+    if (!this.questionCardController || !this.interactionPresenter) {
+      return { kind: "unsupported" };
+    }
+    return this.interactionPresenter.presentInput(context);
+  }
   /**
    * Extract quoted/referenced message context from a reply.
    * DingTalk provides this via text.repliedMsg (newer) or quoteMessage (legacy).
@@ -5600,9 +7035,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         }
       ];
     } else {
-      const dir = join(tmpdir(), "channel-files", randomUUID());
+      const dir = join(tmpdir2(), "channel-files", randomUUID4());
       mkdirSync(dir, { recursive: true });
-      const safeName = basename(fileName || "") || `dingtalk_${mediaType}_${Date.now()}`;
+      const safeName = basename2(fileName || "") || `dingtalk_${mediaType}_${Date.now()}`;
       const filePath = join(dir, safeName);
       writeFileSync(filePath, media.buffer);
       if (envelope.text === `(file: ${fileName || "file"})` || envelope.text === "(audio)" || envelope.text === "(video)") {