@dingxiang-me/openclaw-wechat 2.0.1 → 2.3.0

package/src/wecom/network-config.js

@@ -0,0 +1,91 @@
+export const DEFAULT_WECOM_API_BASE_URL = "https://qyapi.weixin.qq.com";
+
+function pickFirstNonEmptyString(...values) {
+  for (const value of values) {
+    const trimmed = String(value ?? "").trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+
+function normalizeAccountId(accountId) {
+  const normalized = String(accountId ?? "default").trim().toLowerCase();
+  return normalized || "default";
+}
+
+function normalizeHttpBaseUrl(value, fallback = DEFAULT_WECOM_API_BASE_URL) {
+  const raw = String(value ?? "").trim() || String(fallback ?? "").trim() || DEFAULT_WECOM_API_BASE_URL;
+  const withProtocol = /^https?:\/\//i.test(raw) ? raw : `https://${raw}`;
+  const parsed = new URL(withProtocol);
+  parsed.search = "";
+  parsed.hash = "";
+  if (!parsed.pathname || parsed.pathname === "/") {
+    parsed.pathname = "/";
+  } else if (parsed.pathname.endsWith("/")) {
+    parsed.pathname = parsed.pathname.replace(/\/+$/g, "/");
+  }
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function readScopedEnvValue({ envVars = {}, processEnv = process.env, accountId = "default", suffix = "" } = {}) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const scopedKey = normalizedAccountId === "default" ? null : `WECOM_${normalizedAccountId.toUpperCase()}_${suffix}`;
+  return pickFirstNonEmptyString(
+    scopedKey ? envVars?.[scopedKey] : undefined,
+    scopedKey ? processEnv?.[scopedKey] : undefined,
+    envVars?.[`WECOM_${suffix}`],
+    processEnv?.[`WECOM_${suffix}`],
+  );
+}
+
+export function normalizeWecomApiBaseUrl(value, fallback = DEFAULT_WECOM_API_BASE_URL) {
+  return normalizeHttpBaseUrl(value, fallback);
+}
+
+export function buildWecomApiUrl(path, { apiBaseUrl = DEFAULT_WECOM_API_BASE_URL } = {}) {
+  const normalizedBaseUrl = normalizeWecomApiBaseUrl(apiBaseUrl);
+  const normalizedPath = String(path ?? "").trim();
+  if (!normalizedPath) return normalizedBaseUrl;
+  return new URL(normalizedPath.replace(/^\/+/, ""), `${normalizedBaseUrl}/`).toString();
+}
+
+export function isWecomApiUrl(url, { apiBaseUrl = DEFAULT_WECOM_API_BASE_URL } = {}) {
+  const raw = String(url ?? "").trim();
+  if (!raw) return false;
+  const candidates = [DEFAULT_WECOM_API_BASE_URL, apiBaseUrl]
+    .map((value) => {
+      try {
+        return new URL(`${normalizeWecomApiBaseUrl(value)}/`);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+
+  try {
+    const parsed = new URL(raw);
+    return candidates.some(
+      (baseUrl) => parsed.origin === baseUrl.origin && parsed.pathname.startsWith(baseUrl.pathname),
+    );
+  } catch {
+    return candidates.some((baseUrl) => raw.includes(baseUrl.origin));
+  }
+}
+
+export function resolveWecomApiBaseUrl({
+  channelConfig = {},
+  accountConfig = {},
+  envVars = {},
+  processEnv = process.env,
+  accountId = "default",
+} = {}) {
+  const fromAccount = pickFirstNonEmptyString(accountConfig?.apiBaseUrl, accountConfig?.network?.apiBaseUrl);
+  const fromChannel = pickFirstNonEmptyString(channelConfig?.apiBaseUrl, channelConfig?.network?.apiBaseUrl);
+  const fromEnv = readScopedEnvValue({
+    envVars,
+    processEnv,
+    accountId,
+    suffix: "API_BASE_URL",
+  });
+  return normalizeWecomApiBaseUrl(pickFirstNonEmptyString(fromAccount, fromChannel, fromEnv));
+}

package/src/wecom/observability-metrics.js

@@ -62,11 +62,15 @@ export function createWecomObservabilityMetricsStore({
     layer = "",
     ok = false,
     finalStatus = "",
+    deliveryStatus = "",
     accountId = "default",
     attempts = [],
   } = {}) {
     const normalizedLayer = String(layer ?? "").trim().toLowerCase() || "unknown";
-    const normalizedStatus = String(finalStatus ?? "").trim().toLowerCase() || (ok ? "ok" : "failed");
+    const normalizedStatus =
+      String(deliveryStatus ?? "").trim().toLowerCase() ||
+      String(finalStatus ?? "").trim().toLowerCase() ||
+      (ok ? "ok" : "failed");
     const normalizedAccountId = String(accountId ?? "default").trim().toLowerCase() || "default";
     state.deliveryTotal += 1;
     if (ok) state.deliverySuccess += 1;
@@ -77,10 +81,12 @@ export function createWecomObservabilityMetricsStore({
 
     const normalizedAttempts = Array.isArray(attempts) ? attempts : [];
     for (const attempt of normalizedAttempts) {
-      if (attempt?.status === "error") {
+      if (attempt?.status === "error" || attempt?.status === "miss") {
         pushRecentFailure({
           scope: "delivery",
-          reason: String(attempt?.reason ?? "unknown"),
+          reason: `${String(attempt?.deliveryStatus ?? attempt?.status ?? "unknown")} ${String(
+            attempt?.reason ?? "unknown",
+          )}`.trim(),
           accountId: normalizedAccountId,
           layer: String(attempt?.layer ?? ""),
         });

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

@@ -0,0 +1,313 @@
+import { inferWecomDeliveryStatus } from "./reliable-delivery.js";
+import { applyWecomReasoningPolicy } from "./reasoning-visibility.js";
+import {
+  extractWecomReplyDirectives,
+  mergeWecomReplyMediaItems,
+  resolveWecomReplyDirectiveMediaItems,
+  selectWecomReplyTextVariant,
+} from "./reply-output-policy.js";
+import { parseThinkingContent } from "./thinking-parser.js";
+
+function assertFunction(name, value) {
+  if (typeof value !== "function") {
+    throw new Error(`createWecomAgentReplyDeliverer: ${name} is required`);
+  }
+}
+
+export function createWecomAgentReplyDeliverer({
+  getWecomConfig,
+  sendWecomText,
+  sendWecomMarkdown = null,
+  sendWecomOutboundMediaBatch,
+  resolveWecomReasoningPolicy = () => ({
+    mode: "separate",
+    sendThinkingMessage: true,
+    includeInFinalAnswer: false,
+    title: "思考过程",
+    maxChars: 1200,
+  }),
+  resolveWecomReplyFormatPolicy = () => ({
+    mode: "auto",
+  }),
+  resolveWorkspacePathToHost = () => "",
+  createDeliveryTraceId,
+  recordDeliveryMetric = () => {},
+  recordReliableDeliveryOutcome = () => {},
+  enqueuePendingReply = () => null,
+} = {}) {
+  assertFunction("getWecomConfig", getWecomConfig);
+  assertFunction("sendWecomText", sendWecomText);
+  assertFunction("sendWecomOutboundMediaBatch", sendWecomOutboundMediaBatch);
+  assertFunction("resolveWecomReasoningPolicy", resolveWecomReasoningPolicy);
+  assertFunction("resolveWecomReplyFormatPolicy", resolveWecomReplyFormatPolicy);
+  assertFunction("resolveWorkspacePathToHost", resolveWorkspacePathToHost);
+  assertFunction("createDeliveryTraceId", createDeliveryTraceId);
+  assertFunction("recordDeliveryMetric", recordDeliveryMetric);
+  assertFunction("recordReliableDeliveryOutcome", recordReliableDeliveryOutcome);
+  assertFunction("enqueuePendingReply", enqueuePendingReply);
+
+  return async function deliverAgentReply({
+    api,
+    fromUser,
+    accountId = "default",
+    sessionId = "",
+    text = "",
+    rawText = "",
+    thinkingContent = "",
+    rawThinkingContent = "",
+    routeAgentId = "",
+    mediaUrl,
+    mediaUrls,
+    mediaItems,
+    mediaType,
+    reason = "reply",
+    allowPendingEnqueue = true,
+  } = {}) {
+    const normalizedText = String(text ?? "").trim();
+    const normalizedRawText = String(rawText ?? normalizedText).trim();
+    const normalizedAccountId = String(accountId ?? "default").trim().toLowerCase() || "default";
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    const traceId = createDeliveryTraceId("wecom-agent");
+    const attempts = [];
+
+    const parsedPlainReply =
+      String(thinkingContent ?? "").trim().length > 0
+        ? {
+            visibleContent: normalizedText,
+            thinkingContent: String(thinkingContent ?? "").trim(),
+          }
+        : parseThinkingContent(normalizedText);
+    const parsedRawReply =
+      String(rawThinkingContent ?? "").trim().length > 0
+        ? {
+            visibleContent: normalizedRawText,
+            thinkingContent: String(rawThinkingContent ?? "").trim(),
+          }
+        : parseThinkingContent(normalizedRawText);
+
+    const reasoningPolicy = resolveWecomReasoningPolicy(api);
+    const plainReasoningPayload = applyWecomReasoningPolicy({
+      text: parsedPlainReply.visibleContent,
+      thinkingContent: parsedPlainReply.thinkingContent,
+      policy: reasoningPolicy,
+      transport: "agent",
+      phase: "final",
+    });
+    const richReasoningPayload = applyWecomReasoningPolicy({
+      text: parsedRawReply.visibleContent,
+      thinkingContent: parsedRawReply.thinkingContent,
+      policy: reasoningPolicy,
+      transport: "agent",
+      phase: "final",
+    });
+
+    const plainDirectivePayload = extractWecomReplyDirectives(plainReasoningPayload.text);
+    const richDirectivePayload = extractWecomReplyDirectives(richReasoningPayload.text);
+    const directiveMediaItems = resolveWecomReplyDirectiveMediaItems({
+      mediaItems: richDirectivePayload.mediaItems,
+      routeAgentId,
+      resolveWorkspacePathToHost,
+    });
+    const normalizedMediaItems = mergeWecomReplyMediaItems({
+      mediaUrl,
+      mediaUrls,
+      mediaItems,
+      mediaType,
+      extraMediaItems: directiveMediaItems,
+    });
+    const pendingMediaUrls = normalizedMediaItems.map((item) => item.url);
+    const selectedReplyText = selectWecomReplyTextVariant({
+      plainText: plainDirectivePayload.text,
+      richText: richDirectivePayload.text,
+      policy: resolveWecomReplyFormatPolicy(api),
+      supportsMarkdown: typeof sendWecomMarkdown === "function",
+    });
+    const effectiveText = String(plainDirectivePayload.text ?? "").trim();
+
+    const account = getWecomConfig(api, normalizedAccountId) ?? getWecomConfig(api, "default") ?? getWecomConfig(api);
+    if (!account?.corpId || !account?.corpSecret || !account?.agentId) {
+      const failed = {
+        ok: false,
+        layer: "agent_push",
+        finalStatus: "failed",
+        deliveryStatus: "rejected_target",
+        attempts: [
+          {
+            layer: "agent_push",
+            ok: false,
+            status: "miss",
+            deliveryStatus: "rejected_target",
+            reason: "agent-config-missing",
+          },
+        ],
+        error: "agent-config-missing",
+      };
+      recordDeliveryMetric({
+        layer: failed.layer,
+        ok: false,
+        finalStatus: failed.finalStatus,
+        deliveryStatus: failed.deliveryStatus,
+        accountId: normalizedAccountId,
+        attempts: failed.attempts,
+      });
+      recordReliableDeliveryOutcome({
+        mode: "agent",
+        accountId: normalizedAccountId,
+        sessionId: normalizedSessionId,
+        fromUser,
+        deliveryStatus: failed.deliveryStatus,
+        layer: failed.layer,
+        reason: failed.error,
+      });
+      if (allowPendingEnqueue) {
+        enqueuePendingReply(api, {
+          mode: "agent",
+          accountId: normalizedAccountId,
+          sessionId: normalizedSessionId,
+          fromUser,
+          payload: {
+            text: effectiveText,
+            mediaUrls: pendingMediaUrls,
+            mediaType,
+          },
+          reason,
+          deliveryStatus: failed.deliveryStatus,
+        });
+      }
+      return failed;
+    }
+
+    try {
+      const sendTarget = {
+        corpId: account.corpId,
+        corpSecret: account.corpSecret,
+        agentId: account.agentId,
+        toUser: fromUser,
+        logger: api?.logger,
+        proxyUrl: account.outboundProxy,
+        apiBaseUrl: account.apiBaseUrl,
+      };
+      if (selectedReplyText.text) {
+        if (selectedReplyText.format === "markdown" && typeof sendWecomMarkdown === "function") {
+          await sendWecomMarkdown({
+            ...sendTarget,
+            content: selectedReplyText.text,
+          });
+        } else {
+          await sendWecomText({
+            ...sendTarget,
+            text: selectedReplyText.text,
+          });
+        }
+      }
+
+      let mediaResult = { sentCount: 0, failed: [] };
+      if (normalizedMediaItems.length > 0) {
+        mediaResult = await sendWecomOutboundMediaBatch({
+          corpId: account.corpId,
+          corpSecret: account.corpSecret,
+          agentId: account.agentId,
+          toUser: fromUser,
+          mediaItems: normalizedMediaItems,
+          logger: api?.logger,
+          proxyUrl: account.outboundProxy,
+          apiBaseUrl: account.apiBaseUrl,
+        });
+      }
+
+      attempts.push({
+        layer: "agent_push",
+        ok: true,
+        status: "ok",
+        deliveryStatus: "delivered",
+        reason: "",
+      });
+      const success = {
+        ok: true,
+        layer: "agent_push",
+        finalStatus: "ok",
+        deliveryStatus: "delivered",
+        attempts,
+        traceId,
+        meta: {
+          accountId: account.accountId || normalizedAccountId,
+          mediaSent: Number(mediaResult.sentCount || 0),
+          mediaFailed: Array.isArray(mediaResult.failed) ? mediaResult.failed.length : 0,
+          replyFormat: selectedReplyText.format,
+        },
+      };
+      recordDeliveryMetric({
+        layer: success.layer,
+        ok: true,
+        finalStatus: success.finalStatus,
+        deliveryStatus: success.deliveryStatus,
+        accountId: normalizedAccountId,
+        attempts: success.attempts,
+      });
+      recordReliableDeliveryOutcome({
+        mode: "agent",
+        accountId: normalizedAccountId,
+        sessionId: normalizedSessionId,
+        fromUser,
+        deliveryStatus: success.deliveryStatus,
+        layer: success.layer,
+        reason,
+      });
+      return success;
+    } catch (err) {
+      const deliveryStatus = inferWecomDeliveryStatus({
+        reason: String(err?.message || err),
+        layer: "agent_push",
+      });
+      attempts.push({
+        layer: "agent_push",
+        ok: false,
+        status: "error",
+        deliveryStatus,
+        reason: String(err?.message || err),
+      });
+      const failed = {
+        ok: false,
+        layer: "agent_push",
+        finalStatus: "failed",
+        deliveryStatus,
+        attempts,
+        error: String(err?.message || err),
+        traceId,
+      };
+      recordDeliveryMetric({
+        layer: failed.layer,
+        ok: false,
+        finalStatus: failed.finalStatus,
+        deliveryStatus: failed.deliveryStatus,
+        accountId: normalizedAccountId,
+        attempts: failed.attempts,
+      });
+      recordReliableDeliveryOutcome({
+        mode: "agent",
+        accountId: normalizedAccountId,
+        sessionId: normalizedSessionId,
+        fromUser,
+        deliveryStatus: failed.deliveryStatus,
+        layer: failed.layer,
+        reason: failed.error,
+      });
+      if (allowPendingEnqueue) {
+        enqueuePendingReply(api, {
+          mode: "agent",
+          accountId: normalizedAccountId,
+          sessionId: normalizedSessionId,
+          fromUser,
+          payload: {
+            text: effectiveText,
+            mediaUrls: pendingMediaUrls,
+            mediaType,
+          },
+          reason: failed.error,
+          deliveryStatus: failed.deliveryStatus,
+        });
+      }
+      return failed;
+    }
+  };
+}

package/src/wecom/outbound-agent-media-sender.js

@@ -38,12 +38,36 @@ export function createWecomAgentMediaSender({
     chatId,
     mediaUrl,
     mediaUrls,
+    mediaItems,
     mediaType,
     logger,
     proxyUrl,
+    apiBaseUrl,
     maxBytes = 20 * 1024 * 1024,
   } = {}) {
-    const candidates = normalizeOutboundMediaUrls({ mediaUrl, mediaUrls });
+    const rawItems = [
+      ...[mediaUrl, ...(Array.isArray(mediaUrls) ? mediaUrls : [])]
+        .map((url) => ({
+          url,
+          mediaType,
+        }))
+        .filter((item) => String(item?.url ?? "").trim()),
+      ...(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,
+      });
+    }
     if (candidates.length === 0) {
       return { total: 0, sentCount: 0, failed: [] };
     }
@@ -54,10 +78,10 @@ export function createWecomAgentMediaSender({
     for (const candidate of candidates) {
       try {
         const target = resolveWecomOutboundMediaTarget({
-          mediaUrl: candidate,
-          mediaType: candidates.length === 1 ? mediaType : undefined,
+          mediaUrl: candidate.url,
+          mediaType: candidate.mediaType ?? (candidates.length === 1 ? mediaType : undefined),
         });
-        const { buffer } = await fetchMediaFromUrl(candidate, {
+        const { buffer } = await fetchMediaFromUrl(candidate.url, {
           proxyUrl,
           logger,
           forceProxy: Boolean(proxyUrl),
@@ -79,9 +103,10 @@ export function createWecomAgentMediaSender({
             text: fallbackText,
             logger,
             proxyUrl,
+            apiBaseUrl,
           });
           logger?.info?.(
-            `wecom: tiny file fallback as text (${buffer.length} bytes) target=${candidate.slice(0, 120)}`,
+            `wecom: tiny file fallback as text (${buffer.length} bytes) target=${candidate.url.slice(0, 120)}`,
           );
           sentCount += 1;
           continue;
@@ -94,6 +119,7 @@ export function createWecomAgentMediaSender({
           filename: target.filename,
           logger,
           proxyUrl,
+          apiBaseUrl,
         });
         if (target.type === "image") {
           await sendWecomImage({
@@ -107,6 +133,7 @@ export function createWecomAgentMediaSender({
             mediaId,
             logger,
             proxyUrl,
+            apiBaseUrl,
           });
         } else if (target.type === "video") {
           await sendWecomVideo({
@@ -120,6 +147,7 @@ export function createWecomAgentMediaSender({
             mediaId,
             logger,
             proxyUrl,
+            apiBaseUrl,
           });
         } else if (target.type === "voice") {
           await sendWecomVoice({
@@ -133,6 +161,7 @@ export function createWecomAgentMediaSender({
             mediaId,
             logger,
             proxyUrl,
+            apiBaseUrl,
           });
         } else {
           await sendWecomFile({
@@ -146,15 +175,16 @@ export function createWecomAgentMediaSender({
             mediaId,
             logger,
             proxyUrl,
+            apiBaseUrl,
           });
         }
         sentCount += 1;
       } catch (err) {
         failed.push({
-          url: candidate,
+          url: candidate.url,
           reason: String(err?.message || err),
         });
-        logger?.warn?.(`wecom: failed to send outbound media ${candidate}: ${String(err?.message || err)}`);
+        logger?.warn?.(`wecom: failed to send outbound media ${candidate.url}: ${String(err?.message || err)}`);
       }
     }
 

package/src/wecom/outbound-agent-push.js

@@ -31,6 +31,7 @@ export function createWecomAgentPushDeliverer({
       text: `${content || fallbackText}${mediaFallbackSuffix}`.trim(),
       logger: api?.logger,
       proxyUrl: account.outboundProxy,
+      apiBaseUrl: account.apiBaseUrl,
     });
     return {
       ok: true,