@sunnoy/wecom 1.8.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,55 +1,27 @@
+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";
-
-// Periodic cleanup for streamMeta and expired responseUrls to prevent memory leaks.
-setInterval(() => {
-  const now = Date.now();
-  // Clean streamMeta entries whose stream no longer exists in streamManager.
-  for (const streamId of streamMeta.keys()) {
-    if (!streamManager.hasStream(streamId)) {
-      streamMeta.delete(streamId);
-    }
-  }
-  // Clean expired responseUrls (older than 1 hour).
-  for (const [key, entry] of responseUrls.entries()) {
-    if (now > entry.expiresAt) {
-      responseUrls.delete(key);
-    }
-  }
-}, 60 * 1000).unref();
+import { setOpenclawConfig, setRuntime } from "./wecom/state.js";
+import { buildReplyMediaGuidance } from "./wecom/ws-monitor.js";
 
 const plugin = {
-  // Plugin id should match `openclaw.plugin.json` id (and config.plugins.entries key).
   id: "wecom",
   name: "Enterprise WeChat",
   description: "Enterprise WeChat AI Bot channel plugin for OpenClaw",
-  configSchema: { type: "object", additionalProperties: true, properties: {} },
+  configSchema: emptyPluginConfigSchema(),
   register(api) {
-    logger.info("WeCom plugin registering...");
-
-    // Save runtime for message processing
+    logger.info("Registering WeCom WS plugin");
     setRuntime(api.runtime);
     setOpenclawConfig(api.config);
-
-    // Register channel
     api.registerChannel({ plugin: wecomChannelPlugin });
-    logger.info("WeCom channel registered");
 
-    // Register webhook HTTP route with auth: "plugin" so gateway does NOT
-    // enforce Bearer-token auth. WeCom callbacks use msg_signature verification
-    // which the plugin handles internally.
-    // OpenClaw 3.2 removed registerHttpHandler; use registerHttpRoute with
-    // auth: "plugin" + match: "prefix" to handle all /webhooks/* paths.
-    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/openclaw.plugin.json

@@ -2,12 +2,12 @@
   "id": "wecom",
   "name": "OpenClaw WeCom",
   "description": "Enterprise WeChat (WeCom) messaging channel plugin for OpenClaw",
-  "channels": [
-    "wecom"
-  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": true,
     "properties": {}
-  }
+  },
+  "channels": [
+    "wecom"
+  ]
 }

package/package.json

@@ -1,23 +1,20 @@
 {
     "name": "@sunnoy/wecom",
-    "version": "1.8.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": {
@@ -28,9 +25,7 @@
     },
     "scripts": {
         "test": "npm run test:unit",
-        "test:unit": "node --test tests/*.test.js",
-        "test:e2e": "node --test tests/e2e/*.e2e.test.js",
-        "test:e2e:ali-ai": "bash tests/e2e/run-ali-ai.sh"
+        "test:unit": "node --test tests/*.test.js"
     },
     "openclaw": {
         "extensions": [
@@ -62,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);

package/utils.js

@@ -79,6 +79,57 @@ export class MessageDeduplicator {
     this.seen.set(msgId, true);
   }
 }
+// ============================================================================
+// Text chunking for WeCom Agent API (2048-byte limit per message)
+// ============================================================================
+const AGENT_TEXT_BYTE_LIMIT = 2000; // safe margin below 2048
+
+/**
+ * Split a string into chunks that each fit within a byte limit (UTF-8).
+ * Splits at newline boundaries when possible, otherwise at character boundaries.
+ */
+export function splitTextByByteLimit(text, limit = AGENT_TEXT_BYTE_LIMIT) {
+  if (Buffer.byteLength(text, "utf8") <= limit) {
+    return [text];
+  }
+
+  const chunks = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (Buffer.byteLength(remaining, "utf8") <= limit) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // Binary search for the max char index that fits within the byte limit.
+    let lo = 0;
+    let hi = remaining.length;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >>> 1;
+      if (Buffer.byteLength(remaining.slice(0, mid), "utf8") <= limit) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+
+    let splitAt = lo;
+
+    // Prefer splitting at a newline boundary within the last 20% of the chunk.
+    const searchStart = Math.max(0, Math.floor(splitAt * 0.8));
+    const lastNewline = remaining.lastIndexOf("\n", splitAt - 1);
+    if (lastNewline >= searchStart) {
+      splitAt = lastNewline + 1;
+    }
+
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt);
+  }
+
+  return chunks;
+}
+
 // ============================================================================
 // Constants
 // ============================================================================