@sunnoy/wecom 2.2.0 → 2.3.0

package/wecom/workspace-template.js

@@ -220,7 +220,7 @@ export function seedAgentWorkspace(agentId, config, overrideTemplateDir) {
   }
 }
 
-export function upsertAgentIdOnlyEntry(cfg, agentId) {
+export function upsertAgentIdOnlyEntry(cfg, agentId, baseAgentId) {
   const normalizedId = String(agentId || "")
     .trim()
     .toLowerCase();
@@ -252,8 +252,44 @@ export function upsertAgentIdOnlyEntry(cfg, agentId) {
   }
 
   if (!existingIds.has(normalizedId)) {
-    nextList.push({ id: normalizedId, heartbeat: {} });
+    const entry = { id: normalizedId, heartbeat: {} };
+
+    // Inherit inheritable properties from the base agent so the dynamic
+    // agent retains model, subagents (spawn permissions), and tool config.
+    if (baseAgentId) {
+      const baseEntry = currentList.find(
+        (e) => e && typeof e.id === "string" && e.id === baseAgentId,
+      );
+      if (baseEntry) {
+        for (const key of ["model", "subagents", "tools"]) {
+          if (baseEntry[key] != null) {
+            entry[key] = JSON.parse(JSON.stringify(baseEntry[key]));
+          }
+        }
+      }
+    }
+
+    nextList.push(entry);
     changed = true;
+  } else if (baseAgentId) {
+    // Backfill missing inheritable properties on existing entries that were
+    // persisted before the inheritance logic was added.
+    const existingEntry = nextList.find(
+      (e) => e && typeof e.id === "string" && e.id.trim().toLowerCase() === normalizedId,
+    );
+    if (existingEntry) {
+      const baseEntry = currentList.find(
+        (e) => e && typeof e.id === "string" && e.id === baseAgentId,
+      );
+      if (baseEntry) {
+        for (const key of ["model", "subagents", "tools"]) {
+          if (existingEntry[key] == null && baseEntry[key] != null) {
+            existingEntry[key] = JSON.parse(JSON.stringify(baseEntry[key]));
+            changed = true;
+          }
+        }
+      }
+    }
   }
 
   if (changed) {
@@ -263,7 +299,7 @@ export function upsertAgentIdOnlyEntry(cfg, agentId) {
   return changed;
 }
 
-export async function ensureDynamicAgentListed(agentId, templateDir) {
+export async function ensureDynamicAgentListed(agentId, templateDir, baseAgentId) {
   const normalizedId = String(agentId || "")
     .trim()
     .toLowerCase();
@@ -285,7 +321,7 @@ export async function ensureDynamicAgentListed(agentId, templateDir) {
       }
 
       // Upsert into in-memory config so the running gateway sees it immediately.
-      const changed = upsertAgentIdOnlyEntry(openclawConfig, normalizedId);
+      const changed = upsertAgentIdOnlyEntry(openclawConfig, normalizedId, baseAgentId);
       if (changed) {
         logger.info("WeCom: dynamic agent added to in-memory agents.list", { agentId: normalizedId });
 

package/wecom/ws-monitor.js

@@ -30,6 +30,7 @@ import {
   MEDIA_IMAGE_PLACEHOLDER,
   MESSAGE_PROCESS_TIMEOUT_MS,
   REPLY_SEND_TIMEOUT_MS,
+  STREAM_MAX_LIFETIME_MS,
   THINKING_MESSAGE,
   WS_HEARTBEAT_INTERVAL_MS,
   WS_MAX_RECONNECT_ATTEMPTS,
@@ -62,6 +63,8 @@ import {
   startMessageStateCleanup,
 } from "./ws-state.js";
 import { ensureDynamicAgentListed } from "./workspace-template.js";
+import { listAccountIds, resolveAccount } from "./accounts.js";
+import { loadWelcomeMessagesFromFile } from "./welcome-messages-file.js";
 
 const DEFAULT_AGENT_ID = "main";
 const DEFAULT_STATE_DIRNAME = ".openclaw";
@@ -72,8 +75,9 @@ const VISIBLE_STREAM_THROTTLE_MS = 800;
 // Reserve headroom below the SDK's per-reqId queue limit (100) so the final
 // reply always has room.
 const MAX_INTERMEDIATE_STREAM_MESSAGES = 85;
-// WeCom stream messages expire if not updated within 6 minutes. Send a
-// keepalive update every 4 minutes to keep the stream alive during long runs.
+// WeCom stream messages have a hard 6-minute absolute lifetime from creation.
+// Keepalive updates every 4 minutes maintain visible progress but do NOT extend
+// the lifetime.  Stream rotation (see rotateStream) is the actual fix.
 const STREAM_KEEPALIVE_INTERVAL_MS = 4 * 60 * 1000;
 // Match MEDIA:/FILE: directives at line start, optionally preceded by markdown list markers.
 const REPLY_MEDIA_DIRECTIVE_PATTERN = /^\s*(?:[-*•]\s+|\d+\.\s+)?(?:MEDIA|FILE)\s*:/im;
@@ -136,6 +140,11 @@ function buildWaitingModelContent(seconds) {
   return `<think>${lines.join("\n")}`;
 }
 
+function buildWaitingModelReasoningText(seconds) {
+  const normalizedSeconds = Math.max(1, Number.parseInt(String(seconds ?? 1), 10) || 1);
+  return `等待模型响应 ${normalizedSeconds}s`;
+}
+
 function buildWsStreamContent({ reasoningText = "", visibleText = "", finish = false }) {
   const normalizedReasoning = String(reasoningText ?? "").trim();
   const normalizedVisible = String(visibleText ?? "").trim();
@@ -357,10 +366,31 @@ function resolveAgentWorkspaceDir(config, agentId) {
   return path.join(stateDir, `workspace-${normalizedAgentId}`);
 }
 
+function resolveConfiguredReplyMediaLocalRoots(config) {
+  const topLevel = Array.isArray(config?.channels?.[CHANNEL_ID]?.mediaLocalRoots)
+    ? config.channels[CHANNEL_ID].mediaLocalRoots
+    : [];
+
+  // Also collect mediaLocalRoots from each account entry (multi-account mode).
+  // In single-account mode the account config IS the top-level config, so
+  // listAccountIds returns ["default"] and the roots are already in topLevel.
+  const accountRoots = [];
+  for (const accountId of listAccountIds(config)) {
+    const accountConfig = resolveAccount(config, accountId)?.config;
+    if (Array.isArray(accountConfig?.mediaLocalRoots)) {
+      accountRoots.push(...accountConfig.mediaLocalRoots);
+    }
+  }
+
+  const merged = [...new Set([...topLevel, ...accountRoots])];
+  return merged.map((entry) => resolveUserPath(entry)).filter(Boolean);
+}
+
 function resolveReplyMediaLocalRoots(config, agentId) {
   const workspaceDir = resolveAgentWorkspaceDir(config, agentId || resolveDefaultAgentId(config));
   const browserMediaDir = path.join(resolveStateDir(), "media", "browser");
-  return [...new Set([workspaceDir, browserMediaDir].map((entry) => path.resolve(entry)))];
+  const configuredRoots = resolveConfiguredReplyMediaLocalRoots(config);
+  return [...new Set([workspaceDir, browserMediaDir, ...configuredRoots].map((entry) => path.resolve(entry)))];
 }
 
 function mergeReplyMediaUrls(...lists) {
@@ -387,12 +417,13 @@ function mergeReplyMediaUrls(...lists) {
 function buildReplyMediaGuidance(config, agentId) {
   const workspaceDir = resolveAgentWorkspaceDir(config, agentId || resolveDefaultAgentId(config));
   const browserMediaDir = path.join(resolveStateDir(), "media", "browser");
-  return [
+  const configuredRoots = resolveConfiguredReplyMediaLocalRoots(config);
+  const qwenImageToolsConfig = config?.plugins?.entries?.wecom?.config?.qwenImageTools;
+  const guidance = [
     WECOM_REPLY_MEDIA_GUIDANCE_HEADER,
     `Local reply files are allowed only under the current workspace: ${workspaceDir}`,
     "Inside the agent sandbox, that same workspace is visible as /workspace.",
     `Browser-generated files are also allowed only under: ${browserMediaDir}`,
-    "Never reference any other host path.",
     "Do NOT call message.send or message.sendAttachment to deliver files back to the current WeCom chat/user; use MEDIA: or FILE: directives instead.",
     "For images: put each image path on its own line as MEDIA:/abs/path.",
     "If a local file is in the current sandbox workspace, use its /workspace/... path directly.",
@@ -402,7 +433,27 @@ function buildReplyMediaGuidance(config, agentId) {
     "CRITICAL: If a tool already returned a path prefixed with FILE: (e.g. FILE:/abs/path.pdf), keep the FILE: prefix exactly as-is. Do NOT change it to MEDIA:.",
     "Each directive MUST be on its own line with no other text on that line.",
     "The plugin will automatically send the media to the user.",
-  ].join("\n");
+  ];
+
+  if (configuredRoots.length > 0) {
+    guidance.push(`Additional configured host roots are also allowed: ${configuredRoots.join(", ")}`);
+  }
+
+  if (qwenImageToolsConfig?.enabled === true) {
+    guidance.push(
+      "[WeCom image_studio rule]",
+      "When the user asks to generate an image, use image_studio with action=\"generate\".",
+      "When the user asks to edit an existing image, use image_studio with action=\"edit\" and pass images.",
+      "Use aspect=\"landscape\" for architecture diagrams, flowcharts, and banners unless the user asks otherwise.",
+      "Prefer model_preference=\"qwen\" for text-heavy diagrams or label-rich images, and model_preference=\"wan\" for photorealistic scenes.",
+      "For workspace-local images, always use /workspace/... paths when calling image_studio.",
+      "Prefer n=1 unless the user explicitly asks for multiple images.",
+      "If image_studio returns MEDIA: URLs, treat the image task as completed successfully.",
+    );
+  }
+
+  guidance.push("Never reference any other host path.");
+  return guidance.join("\n");
 }
 
 function normalizeReplyMediaUrlForLoad(mediaUrl, config, agentId) {
@@ -546,6 +597,11 @@ async function sendMediaBatch({ wsClient, frame, state, account, runtime, config
 
     if (result.ok) {
       state.hasMedia = true;
+      if (result.finalType === "image") {
+        state.hasImageMedia = true;
+      } else {
+        state.hasFileMedia = true;
+      }
       if (result.downgraded) {
         logger.info(`[WS] Media downgraded: ${result.downgradeNote}`);
       }
@@ -575,8 +631,28 @@ async function finishThinkingStream({ wsClient, frame, state, accountId }) {
       visibleText: finalVisibleText,
       finish: true,
     });
+  } else if (state.reasoningText) {
+    // If the model only emitted reasoning tokens, close the thinking stream
+    // instead of replacing it with a generic completion stub.
+    finishText = buildWsStreamContent({
+      reasoningText: state.reasoningText,
+      visibleText: "",
+      finish: true,
+    });
   } else if (state.hasMedia) {
-    finishText = "文件已发送，请查收。";
+    const mediaVisibleText = state.hasImageMedia && !state.hasFileMedia
+      ? "图片已生成，请查收。"
+      : "文件已发送，请查收。";
+    const fallbackReasoningText = state.waitingModelSeconds > 0
+      ? buildWaitingModelReasoningText(state.waitingModelSeconds)
+      : state.hasImageMedia && !state.hasFileMedia
+        ? "正在生成图片"
+        : "正在整理并发送文件";
+    finishText = buildWsStreamContent({
+      reasoningText: fallbackReasoningText,
+      visibleText: mediaVisibleText,
+      finish: true,
+    });
   } else if (state.hasMediaFailed && state.mediaErrorSummary) {
     finishText = state.mediaErrorSummary;
   } else {
@@ -599,6 +675,12 @@ function resolveWelcomeMessage(account) {
     return configured;
   }
 
+  const fromFile = loadWelcomeMessagesFromFile(account?.config);
+  if (fromFile?.length) {
+    const pick = Math.floor(Math.random() * fromFile.length);
+    return fromFile[pick];
+  }
+
   const index = Math.floor(Math.random() * DEFAULT_WELCOME_MESSAGES.length);
   return DEFAULT_WELCOME_MESSAGES[index] || DEFAULT_WELCOME_MESSAGE;
 }
@@ -1072,6 +1154,14 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
       return;
     }
     text = extractGroupMessageContent(originalText, account.config);
+    if (!text.trim() && imageUrls.length === 0 && fileUrls.length === 0) {
+      logger.debug("[WS] Group message mention stripped to empty content; skipping reply", {
+        accountId: account.accountId,
+        chatId,
+        senderId,
+      });
+      return;
+    }
   }
 
   const senderIsAdmin = isWecomAdmin(senderId, account.config);
@@ -1123,12 +1213,16 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
     accumulatedText: "",
     reasoningText: "",
     streamId,
+    streamCreatedAt: Date.now(),
     replyMediaUrls: [],
     pendingMediaUrls: [],
     hasMedia: false,
+    hasImageMedia: false,
+    hasFileMedia: false,
     hasMediaFailed: false,
     mediaErrorSummary: "",
     deliverCalled: false,
+    waitingModelSeconds: 0,
   };
   setMessageState(messageId, state);
 
@@ -1143,6 +1237,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
   let lastNonEmptyStreamText = "";
   let lastForwardedVisibleText = "";
   let keepaliveTimer = null;
+  let rotationTimer = null;
   let waitingModelTimer = null;
   let waitingModelSeconds = 0;
   let waitingModelActive = false;
@@ -1159,6 +1254,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
 
   const sendWaitingModelUpdate = async (seconds) => {
     const waitingText = buildWaitingModelContent(seconds);
+    state.waitingModelSeconds = seconds;
     lastStreamSentAt = Date.now();
     lastNonEmptyStreamText = waitingText;
     try {
@@ -1391,6 +1487,75 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
     }, STREAM_KEEPALIVE_INTERVAL_MS);
   };
 
+  // --- Stream rotation: finish the current stream before the 6-minute hard
+  //     limit and seamlessly continue on a new streamId. ----
+
+  const rotateStream = async () => {
+    // Flush any pending throttled updates to the current stream first.
+    await flushPendingStreamUpdates();
+
+    const oldStreamId = state.streamId;
+    const hasVisibleText = Boolean(stripThinkTags(state.accumulatedText));
+
+    // Build finish content.  When still in the thinking phase (no visible
+    // text yet), append a small marker so the finished message is not empty.
+    const finishText = buildWsStreamContent({
+      reasoningText: state.reasoningText,
+      visibleText: hasVisibleText ? state.accumulatedText : "⏳ 处理中…",
+      finish: true,
+    });
+
+    try {
+      streamMessagesSent++;
+      await sendWsReply({
+        wsClient,
+        frame,
+        streamId: oldStreamId,
+        text: finishText,
+        finish: true,
+        accountId: account.accountId,
+      });
+    } catch (err) {
+      logger.warn(`[WS] Stream rotation: failed to finish old stream: ${err.message}`);
+    }
+
+    // Switch to new stream.
+    const newStreamId = generateReqId("stream");
+    state.streamId = newStreamId;
+    state.streamCreatedAt = Date.now();
+    state.accumulatedText = "";
+    state.reasoningText = "";
+
+    // Reset per-stream counters.
+    streamMessagesSent = 0;
+    lastStreamSentAt = Date.now();
+    lastReasoningSendAt = 0;
+    lastVisibleSendAt = 0;
+    lastNonEmptyStreamText = "";
+    lastForwardedVisibleText = "";
+
+    if (reqIdStore) reqIdStore.set(chatId, newStreamId);
+
+    logPerf("stream_rotated", { oldStreamId, newStreamId });
+
+    // Re-arm timers for the new stream.
+    scheduleRotation();
+    scheduleKeepalive();
+  };
+
+  const scheduleRotation = () => {
+    if (rotationTimer) clearTimeout(rotationTimer);
+    const remaining = STREAM_MAX_LIFETIME_MS - (Date.now() - state.streamCreatedAt);
+    if (remaining <= 0) {
+      void rotateStream();
+      return;
+    }
+    rotationTimer = setTimeout(() => {
+      rotationTimer = null;
+      void rotateStream();
+    }, remaining);
+  };
+
   const cancelPendingTimers = () => {
     if (pendingReasoningTimer) {
       clearTimeout(pendingReasoningTimer);
@@ -1404,6 +1569,10 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
       clearTimeout(keepaliveTimer);
       keepaliveTimer = null;
     }
+    if (rotationTimer) {
+      clearTimeout(rotationTimer);
+      rotationTimer = null;
+    }
     stopWaitingModelUpdates();
   };
 
@@ -1415,6 +1584,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
   if (account.sendThinkingMessage !== false) {
     waitingModelActive = true;
     waitingModelSeconds = 1;
+    state.waitingModelSeconds = waitingModelSeconds;
     await sendThinkingReply({
       wsClient,
       frame,
@@ -1428,6 +1598,7 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
   }
   lastStreamSentAt = Date.now();
   scheduleKeepalive();
+  scheduleRotation();
 
   const peerKind = isGroupChat ? "group" : "dm";
   const peerId = isGroupChat ? chatId : senderId;
@@ -1438,10 +1609,6 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
       ? generateAgentId(peerKind, peerId, account.accountId)
       : null;
 
-  if (dynamicAgentId) {
-    await ensureDynamicAgentListed(dynamicAgentId, account.config.workspaceTemplate);
-  }
-
   const route = core.routing.resolveAgentRoute({
     cfg: config,
     channel: CHANNEL_ID,
@@ -1456,8 +1623,15 @@ async function processWsMessage({ frame, account, config, runtime, wsClient, req
     );
 
   if (dynamicAgentId && !hasExplicitBinding) {
+    const routeAgentId = route.agentId;
+    // Use the account's configured agentId as the base for property inheritance
+    // (model, subagents, tools). route.agentId may resolve to "main" when
+    // there is no explicit binding, but the account's agentId points to the
+    // actual parent agent whose properties the dynamic agent should inherit.
+    const baseAgentId = account.config.agentId || routeAgentId;
+    await ensureDynamicAgentListed(dynamicAgentId, account.config.workspaceTemplate, baseAgentId);
+    route.sessionKey = route.sessionKey.replace(`agent:${routeAgentId}:`, `agent:${dynamicAgentId}:`);
     route.agentId = dynamicAgentId;
-    route.sessionKey = `agent:${dynamicAgentId}:${peerKind}:${peerId}`;
   }
 
   const { ctxPayload, storePath } = buildInboundContext({