@dingxiang-me/openclaw-wechat 2.1.0 → 2.3.0

package/src/wecom/outbound-delivery.js

@@ -18,6 +18,14 @@ import {
   webhookSendText,
 } from "./webhook-bot.js";
 import { stat } from "node:fs/promises";
+import { inferWecomDeliveryStatus } from "./reliable-delivery.js";
+import { applyWecomReasoningPolicy } from "./reasoning-visibility.js";
+import {
+  extractWecomReplyDirectives,
+  mergeWecomReplyMediaItems,
+  resolveWecomReplyDirectiveMediaItems,
+} from "./reply-output-policy.js";
+import { parseThinkingContent } from "./thinking-parser.js";
 
 function assertFunction(name, fn) {
   if (typeof fn !== "function") {
@@ -30,6 +38,16 @@ export function createWecomBotReplyDeliverer({
   resolveWecomDeliveryFallbackPolicy,
   resolveWecomWebhookBotDeliveryPolicy,
   resolveWecomObservabilityPolicy,
+  resolveWecomReasoningPolicy = () => ({
+    mode: "separate",
+    sendThinkingMessage: true,
+    includeInFinalAnswer: false,
+    title: "思考过程",
+    maxChars: 1200,
+  }),
+  resolveWecomReplyFormatPolicy = () => ({
+    mode: "auto",
+  }),
   resolveWecomBotProxyConfig,
   resolveWecomBotConfig,
   resolveWecomBotLongConnectionReplyContext,
@@ -53,6 +71,8 @@ export function createWecomBotReplyDeliverer({
   extractWorkspacePathsFromText = () => [],
   resolveWorkspacePathToHost = () => "",
   recordDeliveryMetric = () => {},
+  recordReliableDeliveryOutcome = () => {},
+  enqueuePendingReply = () => null,
   statImpl = stat,
   fetchImpl = fetch,
 } = {}) {
@@ -60,6 +80,8 @@ export function createWecomBotReplyDeliverer({
   assertFunction("resolveWecomDeliveryFallbackPolicy", resolveWecomDeliveryFallbackPolicy);
   assertFunction("resolveWecomWebhookBotDeliveryPolicy", resolveWecomWebhookBotDeliveryPolicy);
   assertFunction("resolveWecomObservabilityPolicy", resolveWecomObservabilityPolicy);
+  assertFunction("resolveWecomReasoningPolicy", resolveWecomReasoningPolicy);
+  assertFunction("resolveWecomReplyFormatPolicy", resolveWecomReplyFormatPolicy);
   assertFunction("resolveWecomBotProxyConfig", resolveWecomBotProxyConfig);
   assertFunction("resolveWecomBotConfig", resolveWecomBotConfig);
   assertFunction("resolveWecomBotLongConnectionReplyContext", resolveWecomBotLongConnectionReplyContext);
@@ -83,6 +105,8 @@ export function createWecomBotReplyDeliverer({
   assertFunction("extractWorkspacePathsFromText", extractWorkspacePathsFromText);
   assertFunction("resolveWorkspacePathToHost", resolveWorkspacePathToHost);
   assertFunction("recordDeliveryMetric", recordDeliveryMetric);
+  assertFunction("recordReliableDeliveryOutcome", recordReliableDeliveryOutcome);
+  assertFunction("enqueuePendingReply", enqueuePendingReply);
   assertFunction("statImpl", statImpl);
 
   const inlineImageExts = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".heic", ".heif"]);
@@ -167,38 +191,92 @@ export function createWecomBotReplyDeliverer({
     streamId,
     responseUrl,
     text,
+    rawText = "",
     thinkingContent = "",
+    rawThinkingContent = "",
     routeAgentId = "",
     mediaUrl,
     mediaUrls,
+    mediaItems,
     mediaType,
     reason = "reply",
+    allowPendingEnqueue = true,
   } = {}) {
     const normalizedAccountId = String(accountId ?? "default").trim().toLowerCase() || "default";
     const fallbackPolicy = resolveWecomDeliveryFallbackPolicy(api);
     const webhookBotPolicy = resolveWecomWebhookBotDeliveryPolicy(api);
     const observabilityPolicy = resolveWecomObservabilityPolicy(api);
+    const reasoningPolicy = resolveWecomReasoningPolicy(api);
+    const replyFormatPolicy = resolveWecomReplyFormatPolicy(api);
     const botProxyUrl = resolveWecomBotProxyConfig(api, normalizedAccountId);
     const botModeConfig = resolveWecomBotConfig(api, normalizedAccountId);
     const normalizedText = String(text ?? "").trim();
+    const normalizedRawText = String(rawText ?? normalizedText).trim();
+    const parsedText =
+      String(thinkingContent ?? "").trim().length > 0
+        ? {
+            visibleContent: normalizedText,
+            thinkingContent: String(thinkingContent ?? "").trim(),
+          }
+        : parseThinkingContent(normalizedText);
+    const parsedRawText =
+      String(rawThinkingContent ?? "").trim().length > 0
+        ? {
+            visibleContent: normalizedRawText,
+            thinkingContent: String(rawThinkingContent ?? "").trim(),
+          }
+        : parseThinkingContent(normalizedRawText);
+    const reasoningPayload = applyWecomReasoningPolicy({
+      text: parsedText.visibleContent,
+      thinkingContent: parsedText.thinkingContent,
+      policy: reasoningPolicy,
+      transport: "bot",
+      phase: "final",
+    });
+    const richReasoningPayload = applyWecomReasoningPolicy({
+      text: parsedRawText.visibleContent,
+      thinkingContent: parsedRawText.thinkingContent,
+      policy: reasoningPolicy,
+      transport: "bot",
+      phase: "final",
+    });
+    const plainDirectivePayload = extractWecomReplyDirectives(reasoningPayload.text);
+    const richDirectivePayload = extractWecomReplyDirectives(richReasoningPayload.text);
+    const effectiveText = String(plainDirectivePayload.text ?? "").trim();
+    const richEffectiveText = String(richDirectivePayload.text ?? "").trim();
+    const effectiveThinkingContent = String(reasoningPayload.thinkingContent ?? "").trim();
+    const directiveMediaItems = resolveWecomReplyDirectiveMediaItems({
+      mediaItems: richDirectivePayload.mediaItems,
+      routeAgentId,
+      resolveWorkspacePathToHost,
+    });
     const inlineWorkspaceMediaUrls = await collectInlineWorkspaceImageMediaUrls({
-      text: normalizedText,
+      text: richEffectiveText || effectiveText,
       routeAgentId,
     });
-    const normalizedMediaUrls = normalizeWecomBotOutboundMediaUrls({
+    const normalizedMediaItems = mergeWecomReplyMediaItems({
       mediaUrl,
       mediaUrls: [...(Array.isArray(mediaUrls) ? mediaUrls : []), ...inlineWorkspaceMediaUrls],
+      mediaItems,
+      mediaType,
+      extraMediaItems: directiveMediaItems,
+    });
+    const normalizedMediaUrls = normalizeWecomBotOutboundMediaUrls({
+      mediaUrls: normalizedMediaItems.map((item) => item.url),
     });
     const mixedPayload =
       normalizedMediaUrls.length > 0
         ? buildWecomBotMixedPayload({
-            text: normalizedText,
+            text: effectiveText,
             mediaUrls: normalizedMediaUrls,
           })
         : null;
-    const fallbackText = normalizedText || "已收到模型返回的媒体结果，请查看以下链接。";
+    const fallbackText = effectiveText || "已收到模型返回的媒体结果，请查看以下链接。";
     const cardPayload = buildWecomBotCardPayload({
-      text: normalizedText || fallbackText,
+      text:
+        String(replyFormatPolicy?.mode ?? "").trim().toLowerCase() === "markdown" && richEffectiveText
+          ? richEffectiveText
+          : effectiveText || fallbackText,
       cardPolicy: botModeConfig?.card,
       hasMedia: normalizedMediaUrls.length > 0,
     });
@@ -231,6 +309,7 @@ export function createWecomBotReplyDeliverer({
           if (normalizedMediaUrls.length > 0) {
             const processed = await buildActiveStreamMsgItems({
               mediaUrls: normalizedMediaUrls,
+              mediaItems: normalizedMediaItems,
               mediaType,
               fetchMediaFromUrl,
               proxyUrl: botProxyUrl,
@@ -246,7 +325,7 @@ export function createWecomBotReplyDeliverer({
           if (fallbackMediaUrls.length > 0) {
             streamContent = `${streamContent}\n\n媒体链接：\n${fallbackMediaUrls.join("\n")}`.trim();
           }
-          if (!streamContent && !streamMsgItem.length && !String(thinkingContent ?? "").trim()) {
+          if (!streamContent && !streamMsgItem.length && !effectiveThinkingContent) {
             streamContent = fallbackText;
           }
           return pushWecomBotLongConnectionStreamUpdate({
@@ -256,7 +335,7 @@ export function createWecomBotReplyDeliverer({
             content: streamContent,
             finish: true,
             msgItem: streamMsgItem,
-            thinkingContent,
+            thinkingContent: effectiveThinkingContent,
           });
         },
         active_stream: async ({ text: content }) => {
@@ -264,10 +343,10 @@ export function createWecomBotReplyDeliverer({
             streamId,
             sessionId: normalizedSessionId,
             content,
-            thinkingContent,
+            thinkingContent: effectiveThinkingContent,
             normalizedMediaUrls,
             mediaType,
-            normalizedText,
+            normalizedText: effectiveText,
             fallbackText,
             botProxyUrl,
             logger: api.logger,
@@ -296,9 +375,13 @@ export function createWecomBotReplyDeliverer({
             webhookBotPolicy,
             botProxyUrl,
             content,
+            richContent:
+              String(replyFormatPolicy?.mode ?? "").trim().toLowerCase() === "markdown" ? richEffectiveText : "",
+            replyFormatMode: replyFormatPolicy?.mode || "auto",
             fallbackText,
-            normalizedText,
+            normalizedText: effectiveText,
             normalizedMediaUrls,
+            normalizedMediaItems,
             mediaType,
             cardPayload,
             cardPolicy: botModeConfig?.card ?? {},
@@ -318,7 +401,7 @@ export function createWecomBotReplyDeliverer({
     });
 
     const deliveryResult = await router.deliverText({
-      text: normalizedText || fallbackText,
+      text: effectiveText || fallbackText,
       traceId,
       meta: {
         reason,
@@ -328,7 +411,7 @@ export function createWecomBotReplyDeliverer({
         streamId: streamId || "",
         hasResponseUrl: Boolean(inlineResponseUrl || cachedResponseUrl?.url),
         mediaCount: normalizedMediaUrls.length,
-        hasThinkingContent: Boolean(String(thinkingContent ?? "").trim()),
+        hasThinkingContent: Boolean(effectiveThinkingContent),
         botCardMode: botModeConfig?.card?.enabled ? botModeConfig.card.mode : "off",
       },
     });
@@ -336,9 +419,43 @@ export function createWecomBotReplyDeliverer({
       layer: deliveryResult?.layer || "",
       ok: deliveryResult?.ok === true,
       finalStatus: deliveryResult?.finalStatus || "",
+      deliveryStatus: deliveryResult?.deliveryStatus || "",
       accountId: normalizedAccountId,
       attempts: deliveryResult?.attempts,
     });
+    recordReliableDeliveryOutcome({
+      mode: "bot",
+      accountId: normalizedAccountId,
+      sessionId: normalizedSessionId,
+      fromUser,
+      deliveryStatus:
+        deliveryResult?.deliveryStatus ||
+        (deliveryResult?.ok === true
+          ? "delivered"
+          : inferWecomDeliveryStatus({
+              reason: deliveryResult?.error || deliveryResult?.attempts?.slice?.(-1)?.[0]?.reason || "delivery-failed",
+              layer: deliveryResult?.layer || deliveryResult?.attempts?.slice?.(-1)?.[0]?.layer || "",
+            })),
+      layer: deliveryResult?.layer || deliveryResult?.attempts?.slice?.(-1)?.[0]?.layer || "",
+      reason: deliveryResult?.error || deliveryResult?.attempts?.slice?.(-1)?.[0]?.reason || reason,
+    });
+    if (deliveryResult?.ok !== true && allowPendingEnqueue) {
+      enqueuePendingReply(api, {
+        mode: "bot",
+        accountId: normalizedAccountId,
+          sessionId: normalizedSessionId,
+          fromUser,
+          payload: {
+            text: effectiveText || fallbackText,
+            thinkingContent: effectiveThinkingContent,
+            mediaUrls: normalizedMediaUrls,
+            mediaItems: normalizedMediaItems,
+            mediaType,
+          },
+        reason: deliveryResult?.error || deliveryResult?.attempts?.slice?.(-1)?.[0]?.reason || reason,
+        deliveryStatus: deliveryResult?.deliveryStatus || "rejected_unknown",
+      });
+    }
     return deliveryResult;
   }
 

package/src/wecom/outbound-stream-msg-item.js

@@ -16,6 +16,7 @@ function isSupportedActiveStreamMsgItemImage(buffer) {
 
 export async function buildActiveStreamMsgItems({
   mediaUrls,
+  mediaItems,
   mediaType,
   fetchMediaFromUrl,
   proxyUrl,
@@ -23,13 +24,35 @@ export async function buildActiveStreamMsgItems({
 }) {
   const msgItem = [];
   const fallbackUrls = [];
+  const rawItems = [
+    ...(Array.isArray(mediaUrls) ? mediaUrls : []).map((url) => ({
+      url,
+      mediaType,
+    })),
+    ...(Array.isArray(mediaItems) ? mediaItems : []),
+  ];
+  const dedupe = new Set();
+  const candidates = [];
+  for (const item of rawItems) {
+    const normalizedUrl = String(item?.url ?? "").trim();
+    const normalizedType = String(item?.mediaType ?? "").trim().toLowerCase() || undefined;
+    if (!normalizedUrl) continue;
+    const dedupeKey = `${normalizedType || ""}:${normalizedUrl}`;
+    if (dedupe.has(dedupeKey)) continue;
+    dedupe.add(dedupeKey);
+    candidates.push({
+      url: normalizedUrl,
+      mediaType: normalizedType,
+    });
+  }
 
-  for (const mediaUrl of mediaUrls) {
+  for (const mediaItem of candidates) {
+    const mediaUrl = mediaItem.url;
     if (msgItem.length >= ACTIVE_STREAM_MSG_ITEM_LIMIT) {
       fallbackUrls.push(mediaUrl);
       continue;
     }
-    const target = resolveWecomOutboundMediaTarget({ mediaUrl, mediaType });
+    const target = resolveWecomOutboundMediaTarget({ mediaUrl, mediaType: mediaItem.mediaType ?? mediaType });
     if (target.type !== "image") {
       fallbackUrls.push(mediaUrl);
       continue;

package/src/wecom/outbound-webhook-delivery.js

@@ -26,9 +26,12 @@ export function createWecomWebhookBotDeliverer({
     webhookBotPolicy,
     botProxyUrl = "",
     content = "",
+    richContent = "",
+    replyFormatMode = "auto",
     fallbackText = "",
     normalizedText = "",
     normalizedMediaUrls = [],
+    normalizedMediaItems = [],
     mediaType,
     cardPayload = null,
     cardPolicy = {},
@@ -46,6 +49,7 @@ export function createWecomWebhookBotDeliverer({
 
     const dispatcher = attachWecomProxyDispatcher(sendUrl, {}, { proxyUrl: botProxyUrl, logger: api?.logger })?.dispatcher;
     const textPayload = `${content || fallbackText}`.trim();
+    const markdownPayload = String(richContent || content || fallbackText).trim();
     let sentAny = false;
     let usedCardMode = "";
 
@@ -82,6 +86,20 @@ export function createWecomWebhookBotDeliverer({
       }
     }
 
+    const preferMarkdown = String(replyFormatMode ?? "").trim().toLowerCase() === "markdown";
+    if (!sentAny && preferMarkdown && markdownPayload && normalizedMediaUrls.length === 0) {
+      await webhookSendMarkdown({
+        url: webhookBotPolicy?.url,
+        key: webhookBotPolicy?.key,
+        content: markdownPayload,
+        timeoutMs: webhookBotPolicy?.timeoutMs,
+        dispatcher,
+        fetchImpl,
+      });
+      sentAny = true;
+      usedCardMode = "markdown";
+    }
+
     if (!sentAny && textPayload && (normalizedText || normalizedMediaUrls.length === 0)) {
       await webhookSendText({
         url: webhookBotPolicy?.url,
@@ -101,6 +119,7 @@ export function createWecomWebhookBotDeliverer({
         webhookBotPolicy,
         proxyUrl: botProxyUrl,
         mediaUrls: normalizedMediaUrls,
+        mediaItems: normalizedMediaItems,
         mediaType,
       });
       sentAny = sentAny || mediaMeta.sentCount > 0;

package/src/wecom/outbound-webhook-media.js

@@ -32,6 +32,7 @@ export function createWecomWebhookBotMediaSender({
     webhookBotPolicy,
     proxyUrl,
     mediaUrls,
+    mediaItems,
     mediaType,
   }) {
     const sendUrl = resolveWebhookBotSendUrl({
@@ -51,12 +52,35 @@ export function createWecomWebhookBotMediaSender({
     const dispatcher = resolveWebhookDispatcher(attachWecomProxyDispatcher, sendUrl, proxyUrl, logger);
     let sentCount = 0;
     const failedUrls = [];
-    const candidateMediaUrls = Array.isArray(mediaUrls) ? mediaUrls : [];
+    const rawItems = [
+      ...(Array.isArray(mediaUrls) ? mediaUrls : []).map((url) => ({
+        url,
+        mediaType,
+      })),
+      ...(Array.isArray(mediaItems) ? mediaItems : []),
+    ];
+    const dedupe = new Set();
+    const candidateMediaItems = [];
+    for (const item of rawItems) {
+      const normalizedUrl = String(item?.url ?? "").trim();
+      const normalizedType = String(item?.mediaType ?? "").trim().toLowerCase() || undefined;
+      if (!normalizedUrl) continue;
+      const dedupeKey = `${normalizedType || ""}:${normalizedUrl}`;
+      if (dedupe.has(dedupeKey)) continue;
+      dedupe.add(dedupeKey);
+      candidateMediaItems.push({
+        url: normalizedUrl,
+        mediaType: normalizedType,
+      });
+    }
 
-    for (const mediaUrl of candidateMediaUrls) {
-      const target = resolveWecomOutboundMediaTarget({ mediaUrl, mediaType });
+    for (const mediaItem of candidateMediaItems) {
+      const target = resolveWecomOutboundMediaTarget({
+        mediaUrl: mediaItem.url,
+        mediaType: mediaItem.mediaType ?? mediaType,
+      });
       try {
-        const { buffer } = await fetchMediaFromUrl(mediaUrl, {
+        const { buffer } = await fetchMediaFromUrl(mediaItem.url, {
           proxyUrl,
           logger,
           forceProxy: Boolean(proxyUrl),
@@ -91,9 +115,9 @@ export function createWecomWebhookBotMediaSender({
         }
         sentCount += 1;
       } catch (err) {
-        failedUrls.push(mediaUrl);
+        failedUrls.push(mediaItem.url);
         logger?.warn?.(
-          `wecom(bot): webhook media send failed target=${mediaUrl} type=${target.type} reason=${String(err?.message || err)}`,
+          `wecom(bot): webhook media send failed target=${mediaItem.url} type=${target.type} reason=${String(err?.message || err)}`,
         );
       }
     }

package/src/wecom/pending-reply-manager.js

@@ -0,0 +1,143 @@
+function assertFunction(name, value) {
+  if (typeof value !== "function") {
+    throw new Error(`createWecomPendingReplyManager: ${name} is required`);
+  }
+}
+
+export function createWecomPendingReplyManager({
+  reliableDeliveryStore,
+  resolveWecomPendingReplyPolicy,
+  deliverPendingReply,
+  ensurePersistenceLoaded = async () => true,
+  schedulePersistenceFlush = () => {},
+  logger,
+  now = () => Date.now(),
+  sweepIntervalMs = 15000,
+} = {}) {
+  if (!reliableDeliveryStore || typeof reliableDeliveryStore !== "object") {
+    throw new Error("createWecomPendingReplyManager: reliableDeliveryStore is required");
+  }
+  assertFunction("resolveWecomPendingReplyPolicy", resolveWecomPendingReplyPolicy);
+  assertFunction("deliverPendingReply", deliverPendingReply);
+  assertFunction("ensurePersistenceLoaded", ensurePersistenceLoaded);
+  assertFunction("schedulePersistenceFlush", schedulePersistenceFlush);
+  assertFunction("now", now);
+
+  let sweepTimer = null;
+  let sweepPromise = Promise.resolve();
+
+  function ensureSweepTimer() {
+    if (sweepTimer) return;
+    sweepTimer = setInterval(() => {
+      void flushDuePendingReplies("timer");
+    }, Math.max(5000, Number(sweepIntervalMs) || 15000));
+    sweepTimer.unref?.();
+  }
+
+  async function initialize(api) {
+    await ensurePersistenceLoaded(api);
+    if (reliableDeliveryStore.countPendingReplies() > 0) {
+      ensureSweepTimer();
+    }
+    return true;
+  }
+
+  function enqueuePendingReply(api, payload = {}) {
+    const policy = resolveWecomPendingReplyPolicy(api);
+    if (policy?.enabled !== true) return null;
+    const entry = reliableDeliveryStore.enqueuePendingReply({
+      ...payload,
+      maxRetries: policy.maxRetries,
+      retryBackoffMs: policy.retryBackoffMs,
+      expireMs: policy.expireMs,
+    });
+    if (entry) {
+      ensureSweepTimer();
+      schedulePersistenceFlush("pending-enqueue", api);
+    }
+    return entry;
+  }
+
+  async function attemptPendingEntry(entry, trigger = "timer") {
+    try {
+      const result = await deliverPendingReply(entry, trigger);
+      if (result?.ok === true) {
+        reliableDeliveryStore.markPendingDelivered({ id: entry.id, at: now() });
+        schedulePersistenceFlush("pending-delivered");
+        return { delivered: true, result };
+      }
+      const reason = String(result?.deliveryStatus || result?.finalStatus || result?.error || "pending-retry-failed");
+      return {
+        delivered: false,
+        result,
+        rescheduled: reliableDeliveryStore.reschedulePendingReply({
+          id: entry.id,
+          reason,
+          at: now(),
+        }),
+      };
+    } catch (err) {
+      const reason = String(err?.message || err || "pending-retry-failed");
+      logger?.warn?.(`wecom: pending reply retry failed id=${entry.id} trigger=${trigger} reason=${reason}`);
+      return {
+        delivered: false,
+        error: reason,
+        rescheduled: reliableDeliveryStore.reschedulePendingReply({
+          id: entry.id,
+          reason,
+          at: now(),
+        }),
+      };
+    }
+  }
+
+  async function flushEntries(entries = [], trigger = "timer") {
+    const list = Array.isArray(entries) ? entries : [];
+    for (const entry of list) {
+      // Keep retries ordered and deterministic.
+      // eslint-disable-next-line no-await-in-loop
+      await attemptPendingEntry(entry, trigger);
+    }
+  }
+
+  function flushDuePendingReplies(trigger = "timer") {
+    sweepPromise = sweepPromise
+      .then(async () => {
+        await initialize();
+        reliableDeliveryStore.dropExpiredPendingReplies({ at: now() });
+        const entries = reliableDeliveryStore.listDuePendingReplies({ at: now(), limit: 20 });
+        await flushEntries(entries, trigger);
+        schedulePersistenceFlush(`pending-flush:${trigger}`);
+      })
+      .catch((err) => {
+        logger?.warn?.(`wecom: pending reply sweep failed: ${String(err?.message || err)}`);
+      });
+    return sweepPromise;
+  }
+
+  function flushSessionPendingReplies({ mode = "agent", accountId = "default", sessionId = "" } = {}) {
+    return ensurePersistenceLoaded()
+      .then(() =>
+        reliableDeliveryStore.listPendingRepliesForSession({
+          mode,
+          accountId,
+          sessionId,
+        }),
+      )
+      .then((entries) => {
+        if (entries.length === 0) return null;
+        return flushEntries(entries, "session-inbound");
+      })
+      .then(() => {
+        schedulePersistenceFlush("pending-session-flush");
+      });
+  }
+
+  return {
+    initialize,
+    enqueuePendingReply,
+    flushDuePendingReplies,
+    flushSessionPendingReplies,
+    ensureSweepTimer,
+  };
+}

package/src/wecom/plugin-account-policy-services.js

@@ -6,6 +6,7 @@ import { createWecomCommandHandlers } from "./command-handlers.js";
 import { createWecomPolicyResolvers } from "./policy-resolvers.js";
 import { createWecomVoiceTranscriber } from "./voice-transcription.js";
 import {
+  buildWecomSessionId,
   isLocalVoiceInputTypeDirectlySupported,
   normalizeAudioContentType,
   normalizeWecomWebhookTargetMap,
@@ -19,6 +20,10 @@ import {
   resolveWecomDmPolicyConfig,
   resolveWecomEventPolicyConfig,
   resolveWecomDeliveryFallbackConfig,
+  resolveWecomPendingReplyConfig,
+  resolveWecomQuotaTrackingConfig,
+  resolveWecomReasoningConfig,
+  resolveWecomReplyFormatConfig,
   resolveWecomDynamicAgentConfig,
   resolveWecomGroupChatConfig,
   resolveWecomObservabilityConfig,
@@ -27,11 +32,13 @@ import {
   resolveWecomStreamingConfig,
   resolveWecomWebhookBotDeliveryConfig,
 } from "../core.js";
+import { buildWecomBotSessionId } from "./runtime-utils.js";
 
 export function createWecomPluginAccountPolicyServices({
   processEnv = process.env,
   getGatewayRuntime,
   getWecomObservabilityMetrics = () => ({}),
+  getWecomReliableDeliverySnapshot = () => null,
   normalizeWecomResolvedTarget,
   formatWecomTargetForLog,
   sendWecomWebhookText,
@@ -82,6 +89,10 @@ export function createWecomPluginAccountPolicyServices({
     resolveWecomTextDebouncePolicy,
     resolveWecomReplyStreamingPolicy,
     resolveWecomDeliveryFallbackPolicy,
+    resolveWecomPendingReplyPolicy,
+    resolveWecomQuotaTrackingPolicy,
+    resolveWecomReasoningPolicy,
+    resolveWecomReplyFormatPolicy,
     resolveWecomWebhookBotDeliveryPolicy,
     resolveWecomStreamManagerPolicy,
     resolveWecomObservabilityPolicy,
@@ -100,6 +111,10 @@ export function createWecomPluginAccountPolicyServices({
     resolveWecomDebounceConfig,
     resolveWecomStreamingConfig,
     resolveWecomDeliveryFallbackConfig,
+    resolveWecomPendingReplyConfig,
+    resolveWecomQuotaTrackingConfig,
+    resolveWecomReasoningConfig,
+    resolveWecomReplyFormatConfig,
     resolveWecomWebhookBotDeliveryConfig,
     resolveWecomStreamManagerConfig,
     resolveWecomObservabilityConfig,
@@ -134,10 +149,17 @@ export function createWecomPluginAccountPolicyServices({
     resolveWecomTextDebouncePolicy,
     resolveWecomReplyStreamingPolicy,
     resolveWecomDeliveryFallbackPolicy,
+    resolveWecomPendingReplyPolicy,
+    resolveWecomQuotaTrackingPolicy,
+    resolveWecomReasoningPolicy,
+    resolveWecomReplyFormatPolicy,
     resolveWecomStreamManagerPolicy,
     resolveWecomWebhookBotDeliveryPolicy,
     resolveWecomDynamicAgentPolicy,
     resolveWecomBotConfig,
+    buildWecomSessionId,
+    buildWecomBotSessionId,
+    getWecomReliableDeliverySnapshot,
     getWecomObservabilityMetrics,
     pluginVersion: PLUGIN_VERSION,
   });
@@ -162,6 +184,10 @@ export function createWecomPluginAccountPolicyServices({
     resolveWecomTextDebouncePolicy,
     resolveWecomReplyStreamingPolicy,
     resolveWecomDeliveryFallbackPolicy,
+    resolveWecomPendingReplyPolicy,
+    resolveWecomQuotaTrackingPolicy,
+    resolveWecomReasoningPolicy,
+    resolveWecomReplyFormatPolicy,
     resolveWecomWebhookBotDeliveryPolicy,
     resolveWecomStreamManagerPolicy,
     resolveWecomObservabilityPolicy,