@sunnoy/wecom 1.9.0 → 2.0.0

package/image-processor.js

@@ -6,7 +6,7 @@ import { logger } from "./logger.js";
  * Image Processing Module for WeCom
  *
  * Handles loading, validating, and encoding images for WeCom msg_item
- * Supports JPG and PNG formats up to 2MB
+ * Supports JPG and PNG formats up to 10MB
  */
 
 // Image format signatures (magic bytes)
@@ -15,8 +15,27 @@ const IMAGE_SIGNATURES = {
   PNG: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
 };
 
-// 2MB size limit (before base64 encoding)
-const MAX_IMAGE_SIZE = 2 * 1024 * 1024;
+// 10MB size limit (before base64 encoding)
+const MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+
+/**
+ * Process a raw image buffer into a WeCom msg_item payload.
+ * @param {Buffer} buffer
+ * @returns {{ base64: string, md5: string, format: string, size: number }}
+ */
+export function prepareImageBufferForMsgItem(buffer) {
+  validateImageSize(buffer);
+  const format = detectImageFormat(buffer);
+  const base64 = encodeImageToBase64(buffer);
+  const md5 = calculateMD5(buffer);
+
+  return {
+    base64,
+    md5,
+    format,
+    size: buffer.length,
+  };
+}
 
 /**
  * Load image file from filesystem
@@ -65,14 +84,14 @@ export function calculateMD5(buffer) {
 /**
  * Validate image size is within limits
  * @param {Buffer} buffer - Image data buffer
- * @throws {Error} If size exceeds 2MB limit
+ * @throws {Error} If size exceeds 10MB limit
  */
 export function validateImageSize(buffer) {
   const sizeBytes = buffer.length;
   const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
 
   if (sizeBytes > MAX_IMAGE_SIZE) {
-    throw new Error(`Image size ${sizeMB}MB exceeds 2MB limit (actual: ${sizeBytes} bytes)`);
+    throw new Error(`Image size ${sizeMB}MB exceeds 10MB limit (actual: ${sizeBytes} bytes)`);
   }
 
   logger.debug("Image size validated", { sizeBytes, sizeMB });
@@ -135,33 +154,17 @@ export async function prepareImageForMsgItem(filePath) {
   try {
     // Step 1: Load image
     const buffer = await loadImageFromPath(filePath);
-
-    // Step 2: Validate size
-    validateImageSize(buffer);
-
-    // Step 3: Detect format
-    const format = detectImageFormat(buffer);
-
-    // Step 4: Encode to base64
-    const base64 = encodeImageToBase64(buffer);
-
-    // Step 5: Calculate MD5
-    const md5 = calculateMD5(buffer);
+    const result = prepareImageBufferForMsgItem(buffer);
 
     logger.info("Image processed successfully", {
       filePath,
-      format,
-      size: buffer.length,
-      md5,
-      base64Length: base64.length,
+      format: result.format,
+      size: result.size,
+      md5: result.md5,
+      base64Length: result.base64.length,
     });
 
-    return {
-      base64,
-      md5,
-      format,
-      size: buffer.length,
-    };
+    return result;
   } catch (error) {
     logger.error("Image processing failed", {
       filePath,

package/index.js

@@ -1,22 +1,8 @@
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { logger } from "./logger.js";
-import { streamManager } from "./stream-manager.js";
 import { wecomChannelPlugin } from "./wecom/channel-plugin.js";
-import { wecomHttpHandler } from "./wecom/http-handler.js";
-import { responseUrls, setOpenclawConfig, setRuntime, streamMeta } from "./wecom/state.js";
-
-function emptyPluginConfigSchema() {
-  return {
-    safeParse(value) {
-      if (value === undefined) return { success: true, data: undefined };
-      if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return { success: false, error: { message: "expected config object" } };
-      }
-      return { success: true, data: value };
-    },
-  };
-}
-
-let cleanupTimer = null;
+import { setOpenclawConfig, setRuntime } from "./wecom/state.js";
+import { buildReplyMediaGuidance } from "./wecom/ws-monitor.js";
 
 const plugin = {
   id: "wecom",
@@ -24,37 +10,18 @@ const plugin = {
   description: "Enterprise WeChat AI Bot channel plugin for OpenClaw",
   configSchema: emptyPluginConfigSchema(),
   register(api) {
-    logger.info("WeCom plugin registering...");
-
+    logger.info("Registering WeCom WS plugin");
     setRuntime(api.runtime);
     setOpenclawConfig(api.config);
-
-    if (cleanupTimer) clearInterval(cleanupTimer);
-    cleanupTimer = setInterval(() => {
-      const now = Date.now();
-      for (const streamId of streamMeta.keys()) {
-        if (!streamManager.hasStream(streamId)) {
-          streamMeta.delete(streamId);
-        }
-      }
-      for (const [key, entry] of responseUrls.entries()) {
-        if (now > entry.expiresAt) {
-          responseUrls.delete(key);
-        }
-      }
-    }, 60_000);
-    cleanupTimer.unref();
-
     api.registerChannel({ plugin: wecomChannelPlugin });
-    logger.info("WeCom channel registered");
 
-    api.registerHttpRoute({
-      path: "/webhooks",
-      handler: wecomHttpHandler,
-      auth: "plugin",
-      match: "prefix",
+    api.on("before_prompt_build", (_event, ctx) => {
+      if (ctx.channelId !== "wecom") {
+        return;
+      }
+      const guidance = buildReplyMediaGuidance(api.config, ctx.agentId);
+      return { appendSystemContext: guidance };
     });
-    logger.info("WeCom HTTP route registered (auth: plugin, match: prefix)");
   },
 };
 

package/package.json

@@ -1,23 +1,20 @@
 {
     "name": "@sunnoy/wecom",
-    "version": "1.9.0",
+    "version": "2.0.0",
     "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
     "type": "module",
     "main": "index.js",
     "files": [
         "index.js",
         "wecom",
-        "crypto.js",
         "dynamic-agent.js",
         "image-processor.js",
         "logger.js",
         "README.md",
         "LICENSE",
         "CONTRIBUTING.md",
-        "stream-manager.js",
         "think-parser.js",
         "utils.js",
-        "webhook.js",
         "openclaw.plugin.json"
     ],
     "peerDependencies": {
@@ -60,5 +57,8 @@
         "plugin"
     ],
     "author": "",
-    "license": "ISC"
+    "license": "ISC",
+    "dependencies": {
+        "@wecom/aibot-node-sdk": "^1.0.1"
+    }
 }

package/think-parser.js

@@ -1,9 +1,10 @@
 /**
  * Parse <think>...</think> tags from LLM output.
  *
- * Separates content into visible text and thinking process for WeCom's
- * thinking_content stream field. Handles streaming (unclosed tags) and
- * ignores tags inside code blocks.
+ * Handles WeCom thinking tags in streamed LLM output:
+ * - normalize tag variants to <think></think> for outbound WS content
+ * - split visible/thinking text for analysis and tests
+ * - ignore tags inside code blocks
  */
 
 const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought)\b/i;
@@ -43,13 +44,50 @@ function isInsideRegion(pos, regions) {
   return false;
 }
 
+/**
+ * Normalize think tag variants to the canonical <think></think> form that
+ * WeCom clients recognize, while leaving code blocks untouched.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function normalizeThinkingTags(text) {
+  if (!text) {
+    return "";
+  }
+
+  if (!QUICK_TAG_RE.test(text)) {
+    return String(text);
+  }
+
+  const source = String(text);
+  const codeRegions = findCodeRegions(source);
+  const normalized = [];
+  let lastIndex = 0;
+
+  THINK_TAG_RE.lastIndex = 0;
+  for (const match of source.matchAll(THINK_TAG_RE)) {
+    const idx = match.index;
+    if (isInsideRegion(idx, codeRegions)) {
+      continue;
+    }
+
+    normalized.push(source.slice(lastIndex, idx));
+    normalized.push(match[1] === "/" ? "</think>" : "<think>");
+    lastIndex = idx + match[0].length;
+  }
+
+  normalized.push(source.slice(lastIndex));
+  return normalized.join("");
+}
+
 /**
  * Parse thinking content from text that may contain <think>...</think> tags.
  *
  * @param {string} text - Raw accumulated stream text
  * @returns {{ visibleContent: string, thinkingContent: string, isThinking: boolean }}
- *   - visibleContent: text with think blocks removed (for content field)
- *   - thinkingContent: concatenated thinking text (for thinking_content field)
+ *   - visibleContent: text with think blocks removed
+ *   - thinkingContent: concatenated thinking text
  *   - isThinking: true when an unclosed <think> tag is present (streaming)
  */
 export function parseThinkingContent(text) {
@@ -57,12 +95,14 @@ export function parseThinkingContent(text) {
     return { visibleContent: "", thinkingContent: "", isThinking: false };
   }
 
+  const source = String(text);
+
   // Fast path: no think tags at all.
-  if (!QUICK_TAG_RE.test(text)) {
-    return { visibleContent: text, thinkingContent: "", isThinking: false };
+  if (!QUICK_TAG_RE.test(source)) {
+    return { visibleContent: source, thinkingContent: "", isThinking: false };
   }
 
-  const codeRegions = findCodeRegions(text);
+  const codeRegions = findCodeRegions(source);
 
   const visibleParts = [];
   const thinkingParts = [];
@@ -70,7 +110,7 @@ export function parseThinkingContent(text) {
   let inThinking = false;
 
   THINK_TAG_RE.lastIndex = 0;
-  for (const match of text.matchAll(THINK_TAG_RE)) {
+  for (const match of source.matchAll(THINK_TAG_RE)) {
     const idx = match.index;
     const isClose = match[1] === "/";
 
@@ -79,7 +119,7 @@ export function parseThinkingContent(text) {
       continue;
     }
 
-    const segment = text.slice(lastIndex, idx);
+    const segment = source.slice(lastIndex, idx);
 
     if (!inThinking) {
       if (!isClose) {
@@ -103,7 +143,7 @@ export function parseThinkingContent(text) {
   }
 
   // Remaining text after the last tag.
-  const remaining = text.slice(lastIndex);
+  const remaining = source.slice(lastIndex);
   if (inThinking) {
     // Unclosed <think>: remaining text is part of thinking (streaming state).
     thinkingParts.push(remaining);