@sunnoy/wecom 1.4.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sunnoy/wecom",
-    "version": "1.4.1",
+    "version": "1.5.0",
     "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
     "type": "module",
     "main": "index.js",

package/wecom/channel-plugin.js

@@ -8,11 +8,18 @@ import { listAccountIds, resolveAccount, detectAccountConflicts } from "./accoun
 import { DEFAULT_ACCOUNT_ID, THINKING_PLACEHOLDER } from "./constants.js";
 import { parseResponseUrlResult } from "./response-url.js";
 import { messageBuffers, resolveAgentConfig, resolveWebhookUrl, responseUrls, streamContext } from "./state.js";
-import { resolveActiveStream } from "./stream-utils.js";
+import { resolveRecoverableStream, unregisterActiveStream } from "./stream-utils.js";
 import { resolveWecomTarget } from "./target.js";
 import { webhookSendImage, webhookSendText, webhookUploadFile, webhookSendFile } from "./webhook-bot.js";
 import { registerWebhookTarget } from "./webhook-targets.js";
 
+const AGENT_IMAGE_EXTS = new Set(["jpg", "jpeg", "png", "gif", "bmp"]);
+
+export function resolveAgentMediaTypeFromFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() || "";
+  return AGENT_IMAGE_EXTS.has(ext) ? "image" : "file";
+}
+
 export const wecomChannelPlugin = {
   id: "wecom",
   meta: {
@@ -259,7 +266,7 @@ export const wecomChannelPlugin = {
 
       // Prefer stream from async context (correct for concurrent processing).
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveActiveStream(userId);
+      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
 
       // Layer 1: Active stream (normal path)
       if (streamId && streamManager.hasStream(streamId) && !streamManager.getStream(streamId)?.finished) {
@@ -377,7 +384,7 @@ export const wecomChannelPlugin = {
 
       // Prefer stream from async context (correct for concurrent processing).
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveActiveStream(userId);
+      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
 
       if (streamId && streamManager.hasStream(streamId)) {
         // Check if mediaUrl is a local path (sandbox: prefix or absolute path)
@@ -575,6 +582,7 @@ export const wecomChannelPlugin = {
       if (agentConfig) {
         try {
           const agentTarget = (target && !target.webhook) ? target : resolveWecomTarget(to) || { toUser: userId };
+          let deliveredFilename = "file";
 
           // Determine if mediaUrl is a local file path.
           let absolutePath = mediaUrl;
@@ -587,9 +595,11 @@ export const wecomChannelPlugin = {
             // Upload local file then send via Agent API.
             const buffer = await readFile(absolutePath);
             const filename = basename(absolutePath);
+            deliveredFilename = filename;
+            const uploadType = resolveAgentMediaTypeFromFilename(filename);
             const mediaId = await agentUploadMedia({
               agent: agentConfig,
-              type: "image",
+              type: uploadType,
               buffer,
               filename,
             });
@@ -597,16 +607,25 @@ export const wecomChannelPlugin = {
               agent: agentConfig,
               ...agentTarget,
               mediaId,
-              mediaType: "image",
+              mediaType: uploadType,
             });
           } else {
             // For external URLs, download first then upload.
             const res = await fetch(mediaUrl);
+            if (!res.ok) {
+              throw new Error(`download media failed: ${res.status}`);
+            }
             const buffer = Buffer.from(await res.arrayBuffer());
-            const filename = basename(new URL(mediaUrl).pathname) || "image.png";
+            const filename = basename(new URL(mediaUrl).pathname) || "file";
+            deliveredFilename = filename;
+            let uploadType = resolveAgentMediaTypeFromFilename(filename);
+            const contentType = res.headers.get("content-type") || "";
+            if (uploadType === "file" && contentType.toLowerCase().startsWith("image/")) {
+              uploadType = "image";
+            }
             const mediaId = await agentUploadMedia({
               agent: agentConfig,
-              type: "image",
+              type: uploadType,
               buffer,
               filename,
             });
@@ -614,7 +633,7 @@ export const wecomChannelPlugin = {
               agent: agentConfig,
               ...agentTarget,
               mediaId,
-              mediaType: "image",
+              mediaType: uploadType,
             });
           }
 
@@ -623,6 +642,30 @@ export const wecomChannelPlugin = {
             await agentSendText({ agent: agentConfig, ...agentTarget, text });
           }
 
+          // Best-effort stream recovery: when async context is missing and the
+          // active stream mapping was already cleaned, still clear "thinking..."
+          // in the most recent stream for this user.
+          const recoverStreamId = resolveRecoverableStream(userId);
+          if (recoverStreamId && streamManager.hasStream(recoverStreamId)) {
+            const recoverStream = streamManager.getStream(recoverStreamId);
+            if (recoverStream && !recoverStream.finished) {
+              const deliveryHint = text
+                ? `${text}\n\n📎 文件已通过私信发送给您：${deliveredFilename}`
+                : `📎 文件已通过私信发送给您：${deliveredFilename}`;
+              streamManager.replaceIfPlaceholder(
+                recoverStreamId,
+                deliveryHint,
+                THINKING_PLACEHOLDER,
+              );
+              await streamManager.finishStream(recoverStreamId);
+              unregisterActiveStream(userId, recoverStreamId);
+              logger.info("WeCom: recovered and finished stream after media fallback", {
+                userId,
+                streamId: recoverStreamId,
+              });
+            }
+          }
+
           logger.info("WeCom: sent media via Agent API fallback (sendMedia)", {
             userId,
             to,

package/wecom/state.js

@@ -14,6 +14,7 @@ export const messageBuffers = new Map();
 export const webhookTargets = new Map();
 export const activeStreams = new Map();
 export const activeStreamHistory = new Map();
+export const lastStreamByKey = new Map();
 export const streamMeta = new Map();
 export const responseUrls = new Map();
 export const streamContext = new AsyncLocalStorage();

package/wecom/stream-utils.js

@@ -1,7 +1,7 @@
 import { logger } from "../logger.js";
 import { streamManager } from "../stream-manager.js";
 import { THINKING_PLACEHOLDER } from "./constants.js";
-import { activeStreamHistory, activeStreams, messageBuffers } from "./state.js";
+import { activeStreamHistory, activeStreams, lastStreamByKey, messageBuffers } from "./state.js";
 
 export function getMessageStreamKey(message) {
   if (!message || typeof message !== "object") {
@@ -25,6 +25,7 @@ export function registerActiveStream(streamKey, streamId) {
   deduped.push(streamId);
   activeStreamHistory.set(streamKey, deduped);
   activeStreams.set(streamKey, streamId);
+  lastStreamByKey.set(streamKey, streamId);
 }
 
 export function unregisterActiveStream(streamKey, streamId) {
@@ -72,9 +73,33 @@ export function resolveActiveStream(streamKey) {
   activeStreamHistory.set(streamKey, remaining);
   const latest = remaining[remaining.length - 1];
   activeStreams.set(streamKey, latest);
+  lastStreamByKey.set(streamKey, latest);
   return latest;
 }
 
+/**
+ * Resolve a usable stream id for a sender/group.
+ * Prefer active history; if that is temporarily empty, fall back to the latest
+ * known stream id for the same key (when it still exists).
+ */
+export function resolveRecoverableStream(streamKey) {
+  const activeId = resolveActiveStream(streamKey);
+  if (activeId) {
+    return activeId;
+  }
+  if (!streamKey) {
+    return null;
+  }
+  const recentId = lastStreamByKey.get(streamKey);
+  if (!recentId) {
+    return null;
+  }
+  if (!streamManager.hasStream(recentId)) {
+    return null;
+  }
+  return recentId;
+}
+
 export function clearBufferedMessagesForStream(streamKey, reason) {
   const buffer = messageBuffers.get(streamKey);
   if (!buffer) {