@dingxiang-me/openclaw-wechat 1.7.1 → 2.0.0

package/src/wecom/thinking-parser.js

@@ -0,0 +1,74 @@
+const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought)\b/i;
+const THINK_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought)\b[^<>]*>/gi;
+
+function isInsideRegion(pos, regions) {
+  for (const [start, end] of regions) {
+    if (pos >= start && pos < end) return true;
+  }
+  return false;
+}
+
+function findCodeRegions(text) {
+  const regions = [];
+  const blockRe = /```[\s\S]*?```/g;
+  for (const match of text.matchAll(blockRe)) {
+    regions.push([match.index, match.index + match[0].length]);
+  }
+  const inlineRe = /`[^`\n]+`/g;
+  for (const match of text.matchAll(inlineRe)) {
+    if (!isInsideRegion(match.index, regions)) {
+      regions.push([match.index, match.index + match[0].length]);
+    }
+  }
+  return regions;
+}
+
+export function parseThinkingContent(text) {
+  if (!text) {
+    return { visibleContent: "", thinkingContent: "", isThinking: false };
+  }
+
+  const input = String(text);
+  if (!QUICK_TAG_RE.test(input)) {
+    return { visibleContent: input, thinkingContent: "", isThinking: false };
+  }
+
+  const codeRegions = findCodeRegions(input);
+  const visibleParts = [];
+  const thinkingParts = [];
+  let lastIndex = 0;
+  let inThinking = false;
+
+  THINK_TAG_RE.lastIndex = 0;
+  for (const match of input.matchAll(THINK_TAG_RE)) {
+    const idx = match.index;
+    const isClose = match[1] === "/";
+    if (isInsideRegion(idx, codeRegions)) continue;
+
+    const segment = input.slice(lastIndex, idx);
+    if (!inThinking) {
+      visibleParts.push(segment);
+      if (!isClose) {
+        inThinking = true;
+      }
+    } else if (isClose) {
+      thinkingParts.push(segment);
+      inThinking = false;
+    }
+
+    lastIndex = idx + match[0].length;
+  }
+
+  const remaining = input.slice(lastIndex);
+  if (inThinking) {
+    thinkingParts.push(remaining);
+  } else {
+    visibleParts.push(remaining);
+  }
+
+  return {
+    visibleContent: visibleParts.join("").replace(/\n{3,}/g, "\n\n").trim(),
+    thinkingContent: thinkingParts.join("\n").replace(/\n{3,}/g, "\n\n").trim(),
+    isThinking: inThinking,
+  };
+}

package/src/wecom/voice-transcription-process.js

@@ -98,7 +98,7 @@ export function createVoiceTranscriptionProcessRuntime({
     return available;
   }
 
-  async function resolveLocalWhisperCommand({ voiceConfig, logger }) {
+  function listLocalWhisperCommandCandidates({ voiceConfig } = {}) {
     const provider = String(voiceConfig?.provider ?? "").trim().toLowerCase();
     const explicitCommand = String(voiceConfig?.command ?? "").trim();
     const fallbackCandidates =
@@ -110,33 +110,105 @@ export function createVoiceTranscriptionProcessRuntime({
     const candidates = explicitCommand ? [explicitCommand, ...fallbackCandidates] : fallbackCandidates;
 
     if (candidates.length === 0) {
-      throw new Error(
-        `unsupported voice transcription provider: ${provider || "unknown"} (supported: local-whisper-cli/local-whisper)`,
-      );
+      return {
+        provider,
+        explicitCommand,
+        candidates: [],
+        error: `unsupported voice transcription provider: ${provider || "unknown"} (supported: local-whisper-cli/local-whisper)`,
+      };
     }
 
-    for (const cmd of candidates) {
+    return {
+      provider,
+      explicitCommand,
+      candidates,
+      error: "",
+    };
+  }
+
+  async function resolveLocalWhisperCommand({ voiceConfig, logger }) {
+    const resolution = listLocalWhisperCommandCandidates({ voiceConfig });
+    if (resolution.error) {
+      throw new Error(resolution.error);
+    }
+
+    for (const cmd of resolution.candidates) {
       // eslint-disable-next-line no-await-in-loop
       if (await checkCommandAvailable(cmd)) {
-        if (explicitCommand && cmd !== explicitCommand) {
-          logger?.warn?.(`wecom: voice command ${explicitCommand} unavailable, fallback to ${cmd}`);
+        if (resolution.explicitCommand && cmd !== resolution.explicitCommand) {
+          logger?.warn?.(`wecom: voice command ${resolution.explicitCommand} unavailable, fallback to ${cmd}`);
         }
         return cmd;
       }
     }
 
-    throw new Error(`local transcription command not found: ${candidates.join(" / ")}`);
+    const checkedList = resolution.candidates.join(" / ");
+    throw new Error(
+      `local transcription command not found: checked ${checkedList}. ` +
+        "Confirm the command is installed and available in PATH for the OpenClaw runtime.",
+    );
+  }
+
+  async function inspectVoiceTranscriptionRuntime({ voiceConfig, logger } = {}) {
+    const resolution = listLocalWhisperCommandCandidates({ voiceConfig });
+    const commandChecks = [];
+    for (const cmd of resolution.candidates) {
+      // eslint-disable-next-line no-await-in-loop
+      const available = await checkCommandAvailable(cmd);
+      commandChecks.push({ command: cmd, available });
+    }
+    const resolvedCommand = commandChecks.find((item) => item.available)?.command || "";
+    const ffmpegEnabled = voiceConfig?.ffmpegEnabled !== false;
+    const ffmpegAvailable = ffmpegEnabled ? await ensureFfmpegAvailable(logger) : false;
+    const provider = String(voiceConfig?.provider ?? "").trim().toLowerCase();
+    const requireModelPath = provider === "local-whisper-cli" && voiceConfig?.requireModelPath !== false;
+    const modelPath = String(voiceConfig?.modelPath ?? "").trim();
+    const issues = [];
+    if (!voiceConfig?.enabled) {
+      issues.push("voice transcription disabled");
+    }
+    if (resolution.error) {
+      issues.push(resolution.error);
+    }
+    if (resolution.candidates.length > 0 && !resolvedCommand) {
+      issues.push(`no available command in PATH: ${resolution.candidates.join(" / ")}`);
+    }
+    if (requireModelPath && !modelPath) {
+      issues.push("voiceTranscription.modelPath is required for local-whisper-cli");
+    }
+    if (ffmpegEnabled && !ffmpegAvailable) {
+      issues.push("ffmpeg not available");
+    }
+
+    return {
+      enabled: voiceConfig?.enabled === true,
+      provider,
+      explicitCommand: resolution.explicitCommand || "",
+      commandCandidates: resolution.candidates,
+      commandChecks,
+      resolvedCommand,
+      ffmpegEnabled,
+      ffmpegAvailable,
+      requireModelPath,
+      modelPathConfigured: Boolean(modelPath),
+      modelPath,
+      issues,
+    };
   }
 
   assertFunction("runProcessWithTimeout", runProcessWithTimeout);
   assertFunction("checkCommandAvailable", checkCommandAvailable);
   assertFunction("ensureFfmpegAvailable", ensureFfmpegAvailable);
+  assertFunction("listLocalWhisperCommandCandidates", listLocalWhisperCommandCandidates);
   assertFunction("resolveLocalWhisperCommand", resolveLocalWhisperCommand);
+  assertFunction("inspectVoiceTranscriptionRuntime", inspectVoiceTranscriptionRuntime);
 
   return {
     runProcessWithTimeout,
     checkCommandAvailable,
     ensureFfmpegAvailable,
+    listLocalWhisperCommandCandidates,
     resolveLocalWhisperCommand,
+    inspectVoiceTranscriptionRuntime,
   };
 }

package/src/wecom/voice-transcription.js

@@ -35,6 +35,7 @@ export function createWecomVoiceTranscriber({
     checkCommandAvailable,
     ensureFfmpegAvailable,
     resolveLocalWhisperCommand,
+    inspectVoiceTranscriptionRuntime,
   } = processRuntime;
 
   function resolveWecomVoiceTranscriptionConfig(api) {
@@ -232,10 +233,20 @@ export function createWecomVoiceTranscriber({
     }
   }
 
+  async function inspectWecomVoiceTranscriptionRuntime({ api, voiceConfig } = {}) {
+    const resolvedConfig = voiceConfig ?? resolveWecomVoiceTranscriptionConfig(api);
+    return inspectVoiceTranscriptionRuntime({
+      voiceConfig: resolvedConfig,
+      logger: api?.logger,
+    });
+  }
+
   return {
     resolveWecomVoiceTranscriptionConfig,
     transcribeInboundVoice,
+    inspectWecomVoiceTranscriptionRuntime,
     __internal: {
+      inspectVoiceTranscriptionRuntime,
       resolveLocalWhisperCommand,
       checkCommandAvailable,
       ensureFfmpegAvailable,