ylib-openclaw-weixin 2.1.7-beta.13 → 2.1.7-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-openclaw-weixin",
-  "version": "2.1.7-beta.13",
+  "version": "2.1.7-beta.14",
   "description": "OpenClaw Weixin channel",
   "license": "MIT",
   "author": "Tencent",

package/src/messaging/endpoint-dispatch.ts

@@ -368,6 +368,456 @@ function buildEndpointCodeErrorMessage(
   return parts.join(", ") || "unknown";
 }
 
+function parseJsonObjectSafely(raw: string): Record<string, unknown> | null {
+  // 统一 JSON 安全解析：
+  // - 仅保留对象类型（数组/原始值视为无效）；
+  // - 解析失败返回 null，不抛错，避免打断 SSE 消费链路；
+  // - 用于外层 payload 与 eventContent 二次 JSON 解包。
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function parseActionEventContentObject(
+  payload: Record<string, unknown>,
+): Record<string, unknown> | null {
+  // Python 侧 `_serialize_for_sse` 会把 `eventContent` 作为 JSON 字符串输出。
+  // 这里展开后，才能稳定读取 toolName/actionType 等字段识别“确认 action”。
+  // 同时兼容 eventContent 已经是对象的场景。
+  const eventContent = payload.eventContent;
+  if (typeof eventContent === "string") {
+    return parseJsonObjectSafely(eventContent);
+  }
+  if (
+    eventContent &&
+    typeof eventContent === "object" &&
+    !Array.isArray(eventContent)
+  ) {
+    return eventContent as Record<string, unknown>;
+  }
+  return null;
+}
+
+function toReadableActionStatus(rawStatus: unknown): string {
+  // 状态字段中文化，便于在 IM 客户端里快速阅读。
+  // 未知状态保持原始值，避免误判。
+  const status =
+    typeof rawStatus === "string" ? rawStatus.trim().toLowerCase() : "";
+  if (!status) return "未知";
+  if (status === "running") return "进行中";
+  if (status === "pending") return "待确认";
+  if (status === "completed") return "已完成";
+  if (status === "failed") return "失败";
+  if (status === "cancelled") return "已取消";
+  return status;
+}
+
+function toReadableConfirmationType(rawType: unknown): string {
+  const type = typeof rawType === "string" ? rawType.trim().toLowerCase() : "";
+  if (!type) return "未知";
+  if (type === "single_choice" || type === "single-choice" || type === "radio") {
+    return "单选";
+  }
+  if (
+    type === "multiple_choice" ||
+    type === "multi_choice" ||
+    type === "multiple-choice" ||
+    type === "checkbox"
+  ) {
+    return "多选";
+  }
+  return type;
+}
+
+function normalizeConfirmationStatus(rawStatus: unknown): string {
+  return typeof rawStatus === "string" ? rawStatus.trim().toLowerCase() : "";
+}
+
+function isPendingConfirmationStatus(rawStatus: unknown): boolean {
+  return normalizeConfirmationStatus(rawStatus) === "pending";
+}
+
+function resolveSseEventType(
+  currentEventType: string,
+  eventTypeFromPayload: string,
+): string {
+  const current = String(currentEventType || "").trim().toLowerCase();
+  const fromPayload = String(eventTypeFromPayload || "").trim().toLowerCase();
+  if ((!current || current === "message") && fromPayload) return fromPayload;
+  return current || fromPayload;
+}
+
+function getResponseIdFromPayload(payload: Record<string, unknown>): string {
+  const camel = toDisplayText(payload.responseId);
+  if (camel) return camel;
+  return toDisplayText(payload.response_id);
+}
+
+function parseSseEventPayloadWithType(
+  currentEventType: string,
+  rawData: string,
+): { payload: Record<string, unknown>; eventType: string; responseId: string } | null {
+  const payload = parseJsonObjectSafely(rawData);
+  if (!payload) return null;
+  const eventTypeFromPayload =
+    typeof payload.eventType === "string" ? payload.eventType.trim() : "";
+  const eventType = resolveSseEventType(currentEventType, eventTypeFromPayload);
+  const responseId = getResponseIdFromPayload(payload);
+  return { payload, eventType, responseId };
+}
+
+function isLikelyConfirmationPayload(payload: Record<string, unknown>): boolean {
+  // 仅处理“待确认”状态：未标状态或非 pending 一律忽略。
+  if (!isPendingConfirmationStatus(payload.status)) return false;
+  const title = toDisplayText(payload.title);
+  const content = toDisplayText(payload.content);
+  const merged = `${title}\n${content}`.trim();
+  if (!merged) return false;
+  return merged.includes("确认") && merged.includes("选项");
+}
+
+function buildConfirmationSummaryFromLooseText(text: string): string | null {
+  const normalized = String(text || "").replace(/\r/g, "\n").trim();
+  if (!normalized) return null;
+
+  let question = normalized;
+  let optionsPart = "";
+  const optionAnchor =
+    normalized.match(/选项(?:分别)?(?:为|是)\s*[:：]\s*([\s\S]+)/) ||
+    normalized.match(/选项\s*[:：]\s*([\s\S]+)/);
+  if (optionAnchor) {
+    optionsPart = String(optionAnchor[1] || "").trim();
+    question = normalized.slice(0, optionAnchor.index ?? normalized.length).trim();
+  }
+
+  const rawOptions = optionsPart
+    ? optionsPart
+        .split(/[、,，;；\n]+/)
+        .map((item) => item.trim())
+        .filter(Boolean)
+    : [];
+  const uniqueOptions = Array.from(new Set(rawOptions));
+  const choiceType =
+    /多选/.test(normalized) || /multiple/.test(normalized.toLowerCase())
+      ? "多选"
+      : "单选";
+
+  const lines: string[] = ["【用户确认请求】", "状态：待确认", "", "确认请求列表：", ""];
+  lines.push(`问题 1：${question || "确认请求"}`);
+  lines.push(`类型：${choiceType}`);
+  if (question) lines.push(`问题内容：${question}`);
+  if (uniqueOptions.length > 0) {
+    lines.push("选项：");
+    uniqueOptions.forEach((opt, idx) => {
+      lines.push(`${idx + 1}. ${opt}`);
+    });
+  } else {
+    lines.push("选项：无");
+  }
+  lines.push("", "确认问题数：1");
+  return lines.join("\n").trim();
+}
+
+function asObjectRecord(value: unknown): Record<string, unknown> | null {
+  // 运行时类型保护：只允许“非数组对象”按 Record 访问字段。
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return null;
+}
+
+function toDisplayText(value: unknown): string {
+  // 将可能来自后端的字段统一转成可显示文本。
+  // number/boolean 也会转成字符串，降低调用方分支复杂度。
+  if (value == null) return "";
+  if (typeof value === "string") return value.trim();
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+
+function buildReadableResourcePreviewLines(
+  resourcesRaw: unknown,
+): string[] {
+  const lines: string[] = [];
+  if (!Array.isArray(resourcesRaw) || resourcesRaw.length === 0) {
+    return lines;
+  }
+
+  // 最佳实践：资源信息仅保留关键字段，并对长文本做摘要截断。
+  lines.push("    - 关联资源:");
+  resourcesRaw.forEach((resourceItem, idx) => {
+    const resource = asObjectRecord(resourceItem);
+    if (!resource) return;
+
+    const resourceId = toDisplayText(resource.id || resource.resource_id);
+    const resourceType =
+      toDisplayText(resource.type || resource.resource_type) || "unknown";
+    const resourceTitle = toDisplayText(resource.title) || "无标题";
+    const resourceContent = toDisplayText(resource.content);
+    const resourceUrl = toDisplayText(resource.url || resource.full_url);
+
+    const contentPreview =
+      resourceContent.length > 80
+        ? `${resourceContent.slice(0, 80)}...`
+        : resourceContent;
+    const headerBits = [`${idx + 1}. ${resourceTitle}`, `类型=${resourceType}`];
+    if (resourceId) headerBits.push(`ID=${resourceId}`);
+    lines.push(`      ${headerBits.join(" | ")}`);
+    if (resourceUrl) lines.push(`        链接: ${resourceUrl}`);
+    if (contentPreview) lines.push(`        内容摘要: ${contentPreview}`);
+  });
+  return lines;
+}
+
+function buildReadableConfirmationRequests(
+  metadata: Record<string, unknown> | null,
+): string[] {
+  const lines: string[] = [];
+  const requestsRaw = metadata?.requests;
+  if (!Array.isArray(requestsRaw) || requestsRaw.length === 0) {
+    return lines;
+  }
+
+  // 最佳实践：
+  // - 每个确认请求使用稳定编号；
+  // - 明确“问题/可选项”；
+  // - 对每个选项保留 value（供程序化回填）与 label（供人读）。
+  lines.push("确认请求列表：", "");
+  requestsRaw.forEach((requestItem, index) => {
+    const request = asObjectRecord(requestItem);
+    if (!request) return;
+
+    const type = toDisplayText(request.type);
+    const title = toDisplayText(request.title) || `确认请求 ${index + 1}`;
+    const question = toDisplayText(request.question);
+
+    lines.push(`问题 ${index + 1}：${title}`, "");
+    if (type) lines.push(`类型：${toReadableConfirmationType(type)}`, "");
+    if (question) lines.push(`问题内容：${question}`, "");
+
+    const optionsRaw = request.options;
+    if (Array.isArray(optionsRaw) && optionsRaw.length > 0) {
+      lines.push("选项：", "");
+      optionsRaw.forEach((optionItem, optionIndex) => {
+        const option = asObjectRecord(optionItem);
+        const rawLabel = option ? option.label : undefined;
+        const rawValue = option ? option.value : optionItem;
+        const optionLabel = toDisplayText(rawLabel) || toDisplayText(rawValue);
+        const displayLabel = optionLabel || `选项${optionIndex + 1}`;
+
+        lines.push(`${optionIndex + 1}. ${displayLabel}`);
+
+        const resourceLines = buildReadableResourcePreviewLines(option?.resources);
+        lines.push(...resourceLines);
+      });
+    } else {
+      lines.push("选项：无");
+    }
+    lines.push("");
+  });
+  return lines;
+}
+
+function extractConfirmationActionPlainText(
+  currentEventType: string,
+  rawData: string,
+): string | null {
+  // Step 1: 解析 SSE data 的外层 payload（来自 Python `_serialize_for_sse`）。
+  const payload = parseJsonObjectSafely(rawData);
+  if (!payload) return null;
+
+  // 优先使用 SSE event 行；若缺失则回退 data 内 eventType。
+  const eventTypeFromPayload =
+    typeof payload.eventType === "string" ? payload.eventType.trim() : "";
+  const resolvedEventType = resolveSseEventType(
+    currentEventType,
+    eventTypeFromPayload,
+  );
+  if (resolvedEventType !== "action") return null;
+
+  // Step 2: 解包 action 内容（eventContent），读取识别与展示所需字段。
+  const actionPayload = parseActionEventContentObject(payload) ?? payload;
+  const toolName =
+    typeof actionPayload.toolName === "string"
+      ? actionPayload.toolName.trim().toLowerCase()
+      : "";
+  const actionType =
+    typeof actionPayload.actionType === "string"
+      ? actionPayload.actionType.trim().toLowerCase()
+      : "";
+  const normalizedStatus = normalizeConfirmationStatus(actionPayload.status);
+
+  // Python HITL 确认动作是 request_confirmation；仅该类型需要回发会话。
+  // 其他 action 保持静默，避免把工具执行噪音写入用户对话。
+  if (toolName !== "request_confirmation" && actionType !== "request_confirmation") {
+    return null;
+  }
+  // 仅处理“待确认”状态；running/completed/failed/cancelled 全部忽略。
+  if (normalizedStatus !== "pending") return null;
+
+  const title =
+    typeof actionPayload.title === "string" ? actionPayload.title.trim() : "";
+  const description =
+    typeof actionPayload.description === "string"
+      ? actionPayload.description.trim()
+      : "";
+  const toolCallId =
+    typeof actionPayload.toolCallId === "string"
+      ? actionPayload.toolCallId.trim()
+      : "";
+  const responseId =
+    typeof payload.responseId === "string" ? payload.responseId.trim() : "";
+  const requestId =
+    typeof payload.requestId === "string" ? payload.requestId.trim() : "";
+  const metadata = asObjectRecord(actionPayload.metadata);
+
+  const lines: string[] = ["【用户确认请求】", "", `状态：${toReadableActionStatus(actionPayload.status)}`, ""];
+  if (title) lines.push(`标题：${title}`);
+  if (description) lines.push(`说明：${description}`);
+  if (toolCallId || responseId || requestId) lines.push("");
+
+  const requestLines = buildReadableConfirmationRequests(metadata);
+  if (requestLines.length > 0) {
+    lines.push(...requestLines);
+  }
+  return lines.join("\n").trim();
+}
+
+function extractConfirmationRequestPlainText(
+  currentEventType: string,
+  rawData: string,
+): string | null {
+  const parsed = parseSseEventPayloadWithType(currentEventType, rawData);
+  if (!parsed) return null;
+  const { payload, eventType: resolvedEventType } = parsed;
+  if (resolvedEventType !== "confirmation_request") return null;
+
+  const eventContent =
+    // 兼容两种 payload：
+    // 1) 完整包装：{ eventType, requestId, responseId, eventContent: "{...}" }
+    // 2) 网关透传：event=confirmation_request 且 data 直接为 { status, requests, confirmations }
+    parseActionEventContentObject(payload) ??
+    (typeof payload.eventContent === "string"
+      ? parseJsonObjectSafely(payload.eventContent)
+      : asObjectRecord(payload.eventContent)) ??
+    asObjectRecord(payload);
+  if (!eventContent) return null;
+  const normalizedStatus = normalizeConfirmationStatus(eventContent.status);
+  if (normalizedStatus !== "pending") return null;
+  const status = normalizedStatus;
+  const requests = Array.isArray(eventContent.requests)
+    ? eventContent.requests
+    : [];
+  const responseId = getResponseIdFromPayload(payload);
+  const requestId =
+    typeof payload.requestId === "string" ? payload.requestId.trim() : "";
+
+  const lines: string[] = [
+    "【用户确认请求】",
+    `状态：${toReadableActionStatus(status)}`,
+    "",
+  ];
+  if (responseId || requestId) lines.push("");
+  const requestLines = buildReadableConfirmationRequests({ requests });
+  if (requestLines.length > 0) lines.push(...requestLines);
+  lines.push(`确认问题数：${requests.length}`);
+  return lines.join("\n").trim();
+}
+
+function extractGenericSseEventPlainText(
+  currentEventType: string,
+  rawData: string,
+): string | null {
+  const parsed = parseSseEventPayloadWithType(currentEventType, rawData);
+  if (!parsed) return null;
+  const { payload, eventType } = parsed;
+  if (!eventType) return null;
+  if (
+    eventType === "message" ||
+    eventType === "resource" ||
+    eventType === "error" ||
+    eventType === "action" ||
+    eventType === "confirmation_request"
+  ) {
+    return null;
+  }
+
+  const eventContent =
+    typeof payload.eventContent === "string"
+      ? parseJsonObjectSafely(payload.eventContent) ?? payload.eventContent
+      : payload.eventContent;
+  const responseId = getResponseIdFromPayload(payload);
+  const requestId =
+    typeof payload.requestId === "string" ? payload.requestId.trim() : "";
+  if ((eventType === "title" || eventType === "tool_wait") && isLikelyConfirmationPayload(payload)) {
+    const looseText =
+      toDisplayText(payload.content) ||
+      toDisplayText(payload.title) ||
+      (typeof eventContent === "string" ? eventContent : "");
+    const confirmationSummary = buildConfirmationSummaryFromLooseText(looseText);
+    if (confirmationSummary) return confirmationSummary;
+  }
+  const lines: string[] = ["【系统事件】", `类型: ${eventType}`];
+  if (responseId) lines.push(`responseId: ${responseId}`);
+  if (requestId) lines.push(`requestId: ${requestId}`);
+  if (eventContent && typeof eventContent === "object") {
+    const contentObj = eventContent as Record<string, unknown>;
+    const title = toDisplayText(contentObj.title || contentObj.content);
+    const status = toDisplayText(contentObj.status);
+    if (title) lines.push(`标题: ${title}`);
+    if (status) lines.push(`状态: ${toReadableActionStatus(status)}`);
+  } else if (typeof eventContent === "string" && eventContent.trim()) {
+    lines.push(`内容: ${eventContent.trim()}`);
+  }
+  return lines.join("\n");
+}
+
+function extractConfirmationDedupKey(
+  currentEventType: string,
+  rawData: string,
+): string | null {
+  const parsed = parseSseEventPayloadWithType(currentEventType, rawData);
+  if (!parsed) return null;
+  const { payload, eventType, responseId } = parsed;
+  if (!responseId) return null;
+  if (eventType === "confirmation_request") {
+    const eventContent =
+      (typeof payload.eventContent === "string"
+        ? parseJsonObjectSafely(payload.eventContent)
+        : asObjectRecord(payload.eventContent)) ?? asObjectRecord(payload);
+    if (!eventContent || !isPendingConfirmationStatus(eventContent.status)) return null;
+    return `confirmation_request:${responseId}`;
+  }
+  if (eventType === "action") {
+    const actionPayload = parseActionEventContentObject(payload) ?? payload;
+    const toolName =
+      typeof actionPayload.toolName === "string"
+        ? actionPayload.toolName.trim().toLowerCase()
+        : "";
+    const actionType =
+      typeof actionPayload.actionType === "string"
+        ? actionPayload.actionType.trim().toLowerCase()
+        : "";
+    if (!isPendingConfirmationStatus(actionPayload.status)) return null;
+    if (toolName === "request_confirmation" || actionType === "request_confirmation") {
+      return `action_confirmation:${responseId}`;
+    }
+    return null;
+  }
+  if ((eventType === "title" || eventType === "tool_wait") && isLikelyConfirmationPayload(payload)) {
+    return `loose_confirmation:${responseId}`;
+  }
+  return null;
+}
+
 function buildYuceMediaPublicUrl(uploadHost: string, dataPath: string): string {
   const base = uploadHost.replace(/\/+$/, "");
   if (!dataPath) return base;
@@ -537,7 +987,12 @@ async function streamFromEndpoint(params: {
   mediaPath?: string;
   mediaType?: string;
   mediaFileName?: string;
-}): Promise<{ text: string; resources: EndpointResource[] }> {
+  onConfirmationAction?: (text: string) => Promise<void>;
+}): Promise<{
+  text: string;
+  resources: EndpointResource[];
+  confirmationMessages: string[];
+}> {
   const gatewayUrl = `${params.endpointConfig.gatewayBaseUrl.replace(/\/+$/, "")}/v1/im/chat/completions`;
   const messages: Array<{ role: string; content: string }> = [
     {
@@ -631,18 +1086,21 @@ async function streamFromEndpoint(params: {
       return {
         text: String(parsed.choices?.[0]?.message?.content || ""),
         resources: [],
+        confirmationMessages: [],
       };
     } catch {
-      return { text: text.trim(), resources: [] };
+      return { text: text.trim(), resources: [], confirmationMessages: [] };
     }
   }
 
   const resources: EndpointResource[] = [];
+  const confirmationMessages: string[] = [];
   let accumulatedText = "";
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
   let currentEventType = "message";
+  const handledConfirmationKeys = new Set<string>();
   let sseDone = false;
 
   while (!sseDone) {
@@ -668,16 +1126,23 @@ async function streamFromEndpoint(params: {
       logger.info(
         `[weixin][endpoint][sse] event=${currentEventType} data=${data.slice(0, 400)}`,
       );
+      let effectiveEventType = currentEventType;
+      const dataPayload = parseJsonObjectSafely(data);
+      const dataEventType =
+        dataPayload && typeof dataPayload.eventType === "string"
+          ? dataPayload.eventType
+          : "";
+      effectiveEventType = resolveSseEventType(currentEventType, dataEventType);
       if (data === "[DONE]") {
         sseDone = true;
         break;
       }
 
-      if (currentEventType === "error") {
+      if (effectiveEventType === "error") {
         throw new Error(`endpoint error event: ${data}`);
       }
 
-      if (currentEventType === "resource") {
+      if (effectiveEventType === "resource") {
         try {
           const parsed = JSON.parse(data) as { resources?: SseResource[] };
           for (const item of parsed.resources || []) {
@@ -707,6 +1172,99 @@ async function streamFromEndpoint(params: {
         continue;
       }
 
+      if (effectiveEventType === "confirmation_request") {
+        const dedupKey = extractConfirmationDedupKey(effectiveEventType, data);
+        if (dedupKey && handledConfirmationKeys.has(dedupKey)) {
+          logger.info(
+            `[weixin][endpoint][sse][confirmation_request] duplicate skipped: ${dedupKey}`,
+          );
+          // 去重后保持回到默认 message 状态，确保后续正文不会被丢弃。
+          currentEventType = "message";
+          continue;
+        }
+        if (dedupKey) handledConfirmationKeys.add(dedupKey);
+        const confirmationRequestText = extractConfirmationRequestPlainText(
+          effectiveEventType,
+          data,
+        );
+        if (confirmationRequestText) {
+          // 与钉钉行为对齐：确认请求一旦到达就立即独立发送，
+          // 不等待 SSE 全部结束，避免用户侧感知延迟。
+          if (params.onConfirmationAction) {
+            await params.onConfirmationAction(confirmationRequestText);
+          } else {
+            confirmationMessages.push(confirmationRequestText);
+          }
+        }
+        currentEventType = "message";
+        continue;
+      }
+
+      if (effectiveEventType === "action") {
+        // action 处理规则：
+        // - 仅回发 request_confirmation；
+        // - 输出字段顺序和前端确认面板一致，保证跨端认知一致。
+        const dedupKey = extractConfirmationDedupKey(effectiveEventType, data);
+        if (dedupKey && handledConfirmationKeys.has(dedupKey)) {
+          logger.info(
+            `[weixin][endpoint][sse][action] duplicate confirmation skipped: ${dedupKey}`,
+          );
+          // 去重后恢复默认事件类型，继续接收后续 content。
+          currentEventType = "message";
+          continue;
+        }
+        const confirmationActionText = extractConfirmationActionPlainText(
+          effectiveEventType,
+          data,
+        );
+        if (confirmationActionText) {
+          if (dedupKey) handledConfirmationKeys.add(dedupKey);
+          // 与钉钉行为对齐：确认 action 事件同样即时发送。
+          if (params.onConfirmationAction) {
+            await params.onConfirmationAction(confirmationActionText);
+          } else {
+            confirmationMessages.push(confirmationActionText);
+          }
+        }
+        currentEventType = "message";
+        continue;
+      }
+
+      if (effectiveEventType && effectiveEventType !== "message") {
+        // 非确认类透传事件仅记录日志，不回发到会话，避免出现“【系统事件】 类型: title”。
+        const dedupKey = extractConfirmationDedupKey(effectiveEventType, data);
+        if (!dedupKey) {
+          logger.info(
+            `[weixin][endpoint][sse] passthrough ignored for outbound message: event=${effectiveEventType}`,
+          );
+          currentEventType = "message";
+          continue;
+        }
+        const genericEventText = extractGenericSseEventPlainText(
+          effectiveEventType,
+          data,
+        );
+        if (genericEventText) {
+          if (dedupKey && handledConfirmationKeys.has(dedupKey)) {
+            logger.info(
+              `[weixin][endpoint][sse][${effectiveEventType}] duplicate confirmation skipped: ${dedupKey}`,
+            );
+            // 去重后仍需继续累积后续正文 content。
+            currentEventType = "message";
+            continue;
+          }
+          if (dedupKey) handledConfirmationKeys.add(dedupKey);
+          // 仅确认语义的兜底透传事件会进入该分支，也即时发送保持时序一致。
+          if (params.onConfirmationAction) {
+            await params.onConfirmationAction(genericEventText);
+          } else {
+            confirmationMessages.push(genericEventText);
+          }
+        }
+        currentEventType = "message";
+        continue;
+      }
+
       try {
         const parsed = JSON.parse(data) as {
           choices?: Array<{
@@ -745,6 +1303,7 @@ async function streamFromEndpoint(params: {
   return {
     text: accumulatedText,
     resources,
+    confirmationMessages,
   };
 }
 
@@ -1252,8 +1811,40 @@ export async function dispatchWeixinViaEndpoint(params: {
     mediaPath: params.ctx.MediaPath,
     mediaType: params.ctx.MediaType,
     mediaFileName: params.ctx.MediaFileName,
+    onConfirmationAction: async (confirmationText: string) => {
+      const directText = String(confirmationText || "").trim();
+      if (!directText) return;
+      await sendMessageWeixin({
+        to: params.ctx.To,
+        text: directText,
+        opts: {
+          baseUrl: params.baseUrl,
+          token: params.token,
+          contextToken: params.contextToken,
+          accountId: params.accountId,
+        },
+      });
+    },
   });
 
+  // 确认 action 独立发送，不并入主回复文本。
+  if (response.confirmationMessages.length > 0) {
+    for (const confirmationText of response.confirmationMessages) {
+      const directText = String(confirmationText || "").trim();
+      if (!directText) continue;
+      await sendMessageWeixin({
+        to: params.ctx.To,
+        text: directText,
+        opts: {
+          baseUrl: params.baseUrl,
+          token: params.token,
+          contextToken: params.contextToken,
+          accountId: params.accountId,
+        },
+      });
+    }
+  }
+
   const mediaDirectiveParsed = extractMediaDirectives(response.text || "");
   const resourceMediaUrls = collectResourceMediaUrls(response.resources);
   const allMediaUrls = dedupeUrls([
@@ -1284,9 +1875,12 @@ export async function dispatchWeixinViaEndpoint(params: {
     .join("\n\n")
     .trim();
 
-  if (mergedText) {
+  // 与钉钉插件保持一致：当最终正文为空时，始终发送默认提示，
+  // 不区分本轮是否已经发送过确认类独立消息。
+  const outboundText = mergedText || "当前没有可展示的回复内容";
+  if (outboundText) {
     const filter = new StreamingMarkdownFilter();
-    const filtered = filter.feed(mergedText) + filter.flush();
+    const filtered = filter.feed(outboundText) + filter.flush();
     await sendMessageWeixin({
       to: params.ctx.To,
       text: filtered,
@@ -1300,7 +1894,7 @@ export async function dispatchWeixinViaEndpoint(params: {
   }
 
   return {
-    textLength: mergedText.length,
+    textLength: outboundText.length,
     resourceCount: response.resources.length,
   };
 }