@clawling/clawchat-plugin-openclaw 2026.9.26-3 → 2026.10.7-2

package/src/liveware-sample.ts

@@ -252,10 +252,28 @@ export async function downloadLivewareSample(opts: {
 export type SpawnLike = typeof nodeSpawn;
 export type ExecFileLike = typeof nodeExecFile;
 
+/** How long a SIGTERM'd liveware process tree gets before SIGKILL. */
+export const KILL_GRACE_MS = 3_000;
+const KILL_POLL_MS = 50;
+
+export interface KillProcessTreeOptions {
+  /** SIGTERM → SIGKILL grace period (default {@link KILL_GRACE_MS}). */
+  graceMs?: number;
+  /** `process.kill` seam for tests. Negative pids address a process group. */
+  killFn?: (pid: number, signal: NodeJS.Signals | 0) => void;
+}
+
 /**
- * Terminate a child and everything it spawned.
+ * Terminate a child and everything it spawned; resolves once the tree is gone
+ * (POSIX) or the kill has been issued (Windows).
  *
- * POSIX: `SIGTERM` to the child is what we want and what the child expects.
+ * POSIX: the liveware children are spawned `detached` (see
+ * {@link childSpawnOptions}), so each leads its own process group and
+ * `kill(-pid)` reaches every grandchild the liveware agent started. SIGTERM
+ * first; anything still alive after `graceMs` gets SIGKILL — a child that
+ * ignores SIGTERM used to keep the gateway's stop (and systemd's restart)
+ * waiting for the full unit timeout. A child that is not a group leader (no
+ * pid, or spawned without `detached`) is signalled directly instead.
  *
  * Windows: there are no signals. `child.kill()` maps to TerminateProcess on
  * that one process, so any grandchild the liveware agent spawned survives —
@@ -263,21 +281,73 @@ export type ExecFileLike = typeof nodeExecFile;
  * which then fails to bind. `taskkill /T /F` takes the whole tree down.
  * Fire-and-forget: we never wait on it, and a failure (already dead, no such
  * pid) falls through to the ordinary kill().
+ *
+ * The first signal is sent synchronously, before the returned promise is
+ * first awaited, so fire-and-forget callers keep their old behaviour.
  */
 export function killProcessTree(
   child: ChildProcess | null | undefined,
   execFileFn: ExecFileLike = nodeExecFile,
-): void {
-  if (!child) return;
+  opts: KillProcessTreeOptions = {},
+): Promise<void> {
+  if (!child) return Promise.resolve();
   if (process.platform === "win32" && typeof child.pid === "number") {
     try {
       execFileFn("taskkill", ["/pid", String(child.pid), "/T", "/F"], () => {});
-      return;
+      return Promise.resolve();
     } catch {
       // taskkill missing or spawn refused — fall back to the plain kill below.
     }
   }
-  try { child.kill("SIGTERM"); } catch { /* already dead */ }
+  if (process.platform === "win32") {
+    try { child.kill("SIGTERM"); } catch { /* already dead */ }
+    return Promise.resolve();
+  }
+
+  const killFn = opts.killFn ?? ((pid: number, signal: NodeJS.Signals | 0) => { process.kill(pid, signal); });
+  const graceMs = opts.graceMs ?? KILL_GRACE_MS;
+  const pid = typeof child.pid === "number" && child.pid > 0 ? child.pid : null;
+  let exited = child.exitCode != null || child.signalCode != null;
+  const onExit = () => { exited = true; };
+  child.once("exit", onExit);
+
+  const groupAlive = (): boolean => {
+    if (pid === null) return false;
+    try { killFn(-pid, 0); return true; } catch { return false; }
+  };
+  const signalTree = (signal: NodeJS.Signals): void => {
+    let reachedGroup = false;
+    if (pid !== null) {
+      try { killFn(-pid, signal); reachedGroup = true; } catch { /* not a group leader, or gone */ }
+    }
+    if (!reachedGroup && !exited) {
+      try { child.kill(signal); } catch { /* already dead */ }
+    }
+  };
+  const treeAlive = () => !exited || groupAlive();
+
+  signalTree("SIGTERM");
+  return (async () => {
+    try {
+      const deadline = Date.now() + graceMs;
+      while (treeAlive() && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, Math.min(KILL_POLL_MS, Math.max(1, deadline - Date.now()))));
+      }
+      if (treeAlive()) signalTree("SIGKILL");
+    } finally {
+      child.removeListener("exit", onExit);
+    }
+  })();
+}
+
+/**
+ * Spawn options shared by the long-lived liveware children. POSIX: `detached`
+ * makes the child a process-group leader so {@link killProcessTree} can reach
+ * its grandchildren with `kill(-pid)`. Windows keeps the old non-detached
+ * spawn (detached would open a console window there) and relies on taskkill.
+ */
+function childSpawnOptions(): { detached?: boolean } {
+  return process.platform === "win32" ? {} : { detached: true };
 }
 
 const SERVER_START_TIMEOUT_MS = 10_000;
@@ -302,7 +372,7 @@ function waitForOutput(
       child.stderr?.removeListener("data", onData);
       child.removeListener("exit", onExit);
       if (err) {
-        killProcessTree(child);
+        void killProcessTree(child);
         reject(err);
       } else {
         resolve(value as string);
@@ -380,7 +450,7 @@ export async function startSampleServer(opts: {
   const spawnFn = opts.spawnFn ?? nodeSpawn;
   const args = [path.join(opts.appDir, "server.mjs"), "--dir", opts.appDir, "--port", String(opts.port)];
   if (opts.agentUserId) args.push("--agent-id", opts.agentUserId);
-  const child = spawnFn(process.execPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const child = spawnFn(process.execPath, args, { stdio: ["ignore", "pipe", "pipe"], ...childSpawnOptions() });
   const line = await waitForOutput(
     child,
     (acc) => acc.split("\n").find((l) => l.trim().startsWith('{"port"')) ?? null,
@@ -473,7 +543,7 @@ export async function startTunnelAgent(opts: {
   const child = spawnFn(
     opts.livewarePath,
     ["agent"],
-    { stdio: ["ignore", "pipe", "pipe"], ...(opts.env ? { env: opts.env } : {}) },
+    { stdio: ["ignore", "pipe", "pipe"], ...childSpawnOptions(), ...(opts.env ? { env: opts.env } : {}) },
   );
   await waitForOutput(
     child,
@@ -721,6 +791,8 @@ export type LivewareSampleSupervisorDeps = {
   ref?: string;
   spawnFn?: SpawnLike;
   execFileFn?: ExecFileLike;
+  /** SIGTERM → SIGKILL grace on stop (default {@link KILL_GRACE_MS}); a test seam. */
+  killGraceMs?: number;
   /** Private HOME for the liveware CLI (`livewareCliHomeDir(stateDir, accountId)`),
    * so two instances on one host — or two accounts in one gateway — do not
    * share `$HOME/.clawling`. Absent → the CLI inherits the ambient HOME, which
@@ -803,6 +875,8 @@ export class LivewareSampleSupervisor {
   private serverChild: ChildProcess | null = null;
   private tunnelChild: ChildProcess | null = null;
   private stopped = false;
+  /** The one shutdown wait, shared by every stop() caller. */
+  private stopping: Promise<void> | null = null;
   /** True while a startAttempt chain (bootstrap/relaunch) is running; read by
    * isIdle() so adoptDeps never starts a second concurrent flow. */
   private launchInFlight = false;
@@ -874,7 +948,7 @@ export class LivewareSampleSupervisor {
     } catch (err) {
       // A mid-flow failure (e.g. registerApp rejected) may have left children
       // running without a persisted row — never leak orphan processes.
-      this.killChildren();
+      void this.killChildren();
       const delayMs = START_RETRY_DELAYS_MS[attempt];
       if (delayMs === undefined || this.stopped) {
         deps.log?.warn?.(
@@ -891,20 +965,30 @@ export class LivewareSampleSupervisor {
     }
   }
 
-  stop(): void {
+  /**
+   * Stop for good and resolve once both children (and their process groups)
+   * are gone — SIGTERM, then SIGKILL after `killGraceMs`. Idempotent: the abort
+   * listener and the gateway's own shutdown both call it and await one wait.
+   */
+  stop(): Promise<void> {
+    if (this.stopping) return this.stopping;
     this.stopped = true;
     for (const t of this.timers) clearTimeout(t);
     this.timers.clear();
-    this.killChildren();
+    this.stopping = this.killChildren();
+    return this.stopping;
   }
 
-  private killChildren(): void {
+  private killChildren(): Promise<void> {
     this.generation += 1; // invalidate pending exit handlers before killing
-    for (const child of [this.serverChild, this.tunnelChild]) {
-      killProcessTree(child, this.deps.execFileFn);
-    }
+    const kills = [this.serverChild, this.tunnelChild].map((child) =>
+      killProcessTree(child, this.deps.execFileFn, {
+        ...(this.deps.killGraceMs !== undefined ? { graceMs: this.deps.killGraceMs } : {}),
+      }),
+    );
     this.serverChild = null;
     this.tunnelChild = null;
+    return Promise.all(kills).then(() => undefined);
   }
 
   private schedule(fn: () => void, delayMs: number): void {
@@ -919,7 +1003,10 @@ export class LivewareSampleSupervisor {
    * after stop() ran would otherwise never be killed. */
   private bailIfStopped(): boolean {
     if (!this.stopped) return false;
-    this.killChildren();
+    // Fold this late kill into the shared shutdown wait so a stop() caller
+    // that awaits after this point also waits for it.
+    const late = this.killChildren();
+    this.stopping = Promise.all([this.stopping, late]).then(() => undefined);
     return true;
   }
 
@@ -1151,7 +1238,7 @@ export class LivewareSampleSupervisor {
     const gen = ++this.generation;
     const onChildExit = (): void => {
       if (this.stopped || gen !== this.generation) return;
-      this.killChildren();
+      void this.killChildren();
       const now = Date.now();
       this.restartTimes = this.restartTimes.filter((t) => now - t < RESTART_WINDOW_MS);
       if (this.restartTimes.length >= MAX_RESTARTS_PER_WINDOW) {
@@ -1181,7 +1268,7 @@ export class LivewareSampleSupervisor {
           .catch((err) => {
             // A partially-completed relaunch may have spawned children before
             // failing — never leave them running unwatched.
-            this.killChildren();
+            void this.killChildren();
             this.deps.log?.warn?.(`liveware-sample: relaunch failed: ${String(err)}`);
             this.deps.store.updateLivewareSampleStatus({
               platform: this.deps.platform, accountId: this.deps.accountId,

package/src/mention-autolink.ts

@@ -0,0 +1,200 @@
+/**
+ * Text "@name" → structured mention, applied to outbound group messages just
+ * before they are sent.
+ *
+ * A model naturally writes "@Anne please check" in a group reply. Sent as plain
+ * text, that wakes nobody: the mentioned agent's mention-only gate never opens
+ * and clients draw no highlight. This module recognises roster names after `@`
+ * and splits the text into text / mention fragments (protocol §7.1 / §10.2);
+ * the caller sends the fragments in `body.fragments` and the same mentions in
+ * `context.mentions`.
+ *
+ * Rules (shared with the reference ClawChat client so both sides agree):
+ *  - `@` opens a mention unless the character before it belongs to an email
+ *    local part (ASCII alnum, `.`, `_`, `%`, `+`, `-`), so an email address is not a
+ *    mention but "让@大Q看" (CJK glued to the `@`) is.
+ *  - Longest roster name wins; at equal length an exact-case match beats an
+ *    ASCII-case-folded one; a tie between two different users selects nobody.
+ *  - A name ending in an ASCII alnum must not be followed by one ("@Bean" does
+ *    not match inside "@Beanstalk"); CJK names need no right boundary.
+ *  - Self and the `all` sentinel are never produced from text: auto-waking a
+ *    whole room is an echo-storm starter and stays an explicit tool action.
+ *  - Anything not recognised stays plain text. This step must never block the
+ *    message itself.
+ *
+ * Pure functions plus a per-account roster-resolver registry (the runtime
+ * registers one that reads the cached group metadata).
+ */
+import type { Fragment, MentionFragment } from "./protocol-types.ts";
+
+/** The `@everyone` sentinel user id; never auto-linked from text. */
+export const MENTION_ALL_SENTINEL = "all";
+
+export interface MentionRosterMember {
+  userId: string;
+  /** Display name the model sees for this member. */
+  name: string;
+}
+
+const AT = 0x40;
+
+function isAsciiAlnum(c: number): boolean {
+  return (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a);
+}
+
+function isEmailLocal(c: number): boolean {
+  return isAsciiAlnum(c) || c === 0x2e || c === 0x5f || c === 0x25 || c === 0x2b || c === 0x2d;
+}
+
+function openBoundary(text: string, at: number): boolean {
+  if (at === 0) return true;
+  return !isEmailLocal(text.charCodeAt(at - 1));
+}
+
+function lowerAscii(c: number): number {
+  return c >= 0x41 && c <= 0x5a ? c + 0x20 : c;
+}
+
+function matches(text: string, start: number, name: string, fold: boolean): boolean {
+  const end = start + name.length;
+  if (end > text.length) return false;
+  for (let k = 0; k < name.length; k += 1) {
+    let a = text.charCodeAt(start + k);
+    let b = name.charCodeAt(k);
+    if (fold) {
+      a = lowerAscii(a);
+      b = lowerAscii(b);
+    }
+    if (a !== b) return false;
+  }
+  if (end === text.length) return true;
+  return !(isAsciiAlnum(name.charCodeAt(name.length - 1)) && isAsciiAlnum(text.charCodeAt(end)));
+}
+
+function matchAt(text: string, start: number, targets: MentionRosterMember[]): MentionRosterMember | null {
+  let best: MentionRosterMember | null = null;
+  let bestExact = false;
+  let ambiguous = false;
+  for (const t of targets) {
+    const exact = matches(text, start, t.name, false);
+    const hit = exact || matches(text, start, t.name, true);
+    if (!hit) continue;
+    if (
+      !best ||
+      t.name.length > best.name.length ||
+      (t.name.length === best.name.length && exact && !bestExact)
+    ) {
+      best = t;
+      bestExact = exact;
+      ambiguous = false;
+    } else if (t.name.length === best.name.length && exact === bestExact && t.userId !== best.userId) {
+      ambiguous = true;
+    }
+  }
+  return ambiguous ? null : best;
+}
+
+function targetsOf(roster: MentionRosterMember[], ownUserId: string): MentionRosterMember[] {
+  const out: MentionRosterMember[] = [];
+  for (const m of roster) {
+    const name = typeof m.name === "string" ? m.name.trim() : "";
+    const userId = typeof m.userId === "string" ? m.userId.trim() : "";
+    if (!name || !userId) continue;
+    if (userId === ownUserId) continue;
+    if (userId === MENTION_ALL_SENTINEL) continue;
+    out.push({ userId, name });
+  }
+  return out;
+}
+
+/** Whether `text` has an `@` worth fetching the group roster for. */
+export function hasMentionCandidate(text: string): boolean {
+  for (let i = 0; i < text.length - 1; i += 1) {
+    if (text.charCodeAt(i) === AT && openBoundary(text, i)) return true;
+  }
+  return false;
+}
+
+/**
+ * Split `text` into text / mention fragments using `roster`. The `@` is
+ * consumed by the mention fragment (`display` is the bare name; clients
+ * render `@display`). With no hit the result is a single text fragment
+ * (or `[]` for empty text).
+ */
+export function autolinkMentions(
+  text: string,
+  roster: MentionRosterMember[],
+  options: { ownUserId: string },
+): Fragment[] {
+  if (!text) return [];
+  const targets = targetsOf(roster, options.ownUserId);
+  if (targets.length === 0) return [{ kind: "text", text }];
+  const out: Fragment[] = [];
+  let cursor = 0;
+  let i = 0;
+  while (i < text.length) {
+    if (text.charCodeAt(i) !== AT || !openBoundary(text, i)) {
+      i += 1;
+      continue;
+    }
+    const hit = matchAt(text, i + 1, targets);
+    if (!hit) {
+      i += 1;
+      continue;
+    }
+    if (i > cursor) out.push({ kind: "text", text: text.slice(cursor, i) });
+    out.push({ kind: "mention", user_id: hit.userId, display: hit.name });
+    i += 1 + hit.name.length;
+    cursor = i;
+  }
+  if (cursor < text.length) out.push({ kind: "text", text: text.slice(cursor) });
+  return out;
+}
+
+/** The `context.mentions` half: mention fragments de-duplicated by user id. */
+export function mentionsIn(fragments: Fragment[]): MentionFragment[] {
+  const seen = new Set<string>();
+  const out: MentionFragment[] = [];
+  for (const f of fragments) {
+    if (f.kind !== "mention") continue;
+    const id = typeof f.user_id === "string" ? f.user_id : "";
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push({ kind: "mention", user_id: id, ...(f.display ? { display: f.display } : {}) });
+  }
+  return out;
+}
+
+export type MentionRosterResolver = (groupId: string) => Promise<MentionRosterMember[]>;
+
+const rosterResolvers = new Map<string, MentionRosterResolver>();
+
+/** Register the roster source for one account; returns an unregister function. */
+export function registerMentionRosterResolver(
+  accountId: string,
+  resolver: MentionRosterResolver,
+): () => void {
+  rosterResolvers.set(accountId, resolver);
+  return () => {
+    if (rosterResolvers.get(accountId) === resolver) rosterResolvers.delete(accountId);
+  };
+}
+
+/** Best-effort roster lookup: any failure or missing resolver yields `[]`. */
+export async function resolveMentionRoster(
+  accountId: string,
+  groupId: string,
+): Promise<MentionRosterMember[]> {
+  const resolver = rosterResolvers.get(accountId);
+  if (!resolver) return [];
+  try {
+    const roster = await resolver(groupId);
+    return Array.isArray(roster) ? roster : [];
+  } catch {
+    return [];
+  }
+}
+
+export function clearMentionRosterResolversForTest(): void {
+  rosterResolvers.clear();
+}

package/src/no-reply.ts

@@ -9,11 +9,12 @@
  * tolerated for free and must not be written into the pattern itself.
  *
  * RULE B — bare runtime silence markers (`NO_REPLY` / `[SILENT]` / `SILENT` /
- * `NO REPLY`), matched as a WHOLE STRING ONLY. OpenClaw itself has no such
- * convention; these are carried because other agent runtimes define them, so a
- * model may fall back to one instead of the `clawchat:` form. They are ordinary
- * English words — substring-matching them would swallow prose such as "there is
- * no reply from the server".
+ * `NO REPLY` / `HEARTBEAT_OK`), matched as a WHOLE STRING ONLY. These are
+ * carried because agent runtimes define them, so a model may fall back to one
+ * instead of the `clawchat:` form; `HEARTBEAT_OK` is the OpenClaw host's
+ * heartbeat acknowledgement, which some host versions let through as a reply.
+ * They are ordinary words — substring-matching them would swallow prose such as
+ * "there is no reply from the server".
  *
  * This module MUST stay a literal mirror of the Hermes plugin's equivalent
  * module. When one side changes, change the other in the same breath.
@@ -38,7 +39,7 @@ const DECORATION_CLOSE = "[/>\\]}`*_~]*";
 
 const STRIP_RE = new RegExp(DECORATION_OPEN + CORE + DECORATION_CLOSE, "gi");
 
-const HOST_MARKERS = new Set(["[SILENT]", "SILENT", "NO_REPLY", "NO REPLY"]);
+const HOST_MARKERS = new Set(["[SILENT]", "SILENT", "NO_REPLY", "NO REPLY", "HEARTBEAT_OK"]);
 const HOST_MARKER_MAX_LEN = 64;
 
 // General_Category=Punctuation, matching the host's `unicodedata.category()`

package/src/outbound.ts

@@ -21,6 +21,13 @@ import {
   uploadOutboundMedia,
   type ClawlingMediaFragment,
 } from "./media-runtime.ts";
+import {
+  autolinkMentions,
+  hasMentionCandidate,
+  mentionsIn,
+  resolveMentionRoster,
+  type MentionRosterMember,
+} from "./mention-autolink.ts";
 import { isClawChatNoopResponseText } from "./profile-prompt.ts";
 import { stripNoReplyTokens } from "./no-reply.ts";
 import {
@@ -64,9 +71,29 @@ export interface SendParams {
   mediaFragments?: ClawlingMediaFragment[];
   mentions?: MentionFragment[];
   messageId?: string;
+  /**
+   * Protocol §7.5 `payload.message_mode`. `"thinking"` marks process output
+   * (tool progress, runtime notices, reasoning) that agents skip as input and
+   * clients may fold; everything else is `"normal"` (the default).
+   */
+  messageMode?: OutboundMessageMode;
+  /**
+   * Group roster for text "@name" autolinking. When omitted, a group send
+   * whose text contains a candidate `@` looks the roster up via the
+   * per-account resolver the runtime registers (`mention-autolink.ts`).
+   */
+  mentionRoster?: MentionRosterMember[];
+  /**
+   * This send is the final of a reply stream and reuses its message_id. It
+   * goes out as `message.reply` (protocol §8.4 finalize-reply pattern) even
+   * when it quotes nothing; the reply context is unchanged.
+   */
+  finalizesStream?: boolean;
   log?: LogSink;
 }
 
+export type OutboundMessageMode = "normal" | "thinking";
+
 export interface SendResult {
   messageId: string;
   acceptedAt: number;
@@ -591,8 +618,31 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     return null;
   }
 
-  const mentions = params.mentions ?? [];
-  const textFragments = text ? textToFragments(text) : [];
+  const messageMode: OutboundMessageMode = params.messageMode ?? "normal";
+  let mentions = params.mentions ?? [];
+  let textFragments = text ? textToFragments(text) : [];
+  // Text "@name" → structured mention (group, normal messages only). Process
+  // (thinking) output must not wake anyone. Best-effort: an unavailable roster
+  // leaves the text plain and never blocks the send.
+  if (
+    textFragments.length > 0
+    && params.to.chatType === "group"
+    && messageMode === "normal"
+    && hasMentionCandidate(text)
+  ) {
+    const roster = params.mentionRoster
+      ?? await resolveMentionRoster(params.account.accountId, params.to.chatId);
+    const linked = autolinkMentions(text, roster, { ownUserId: params.account.userId ?? "" });
+    const linkedMentions = mentionsIn(linked);
+    if (linkedMentions.length > 0) {
+      textFragments = linked;
+      const seen = new Set(mentions.map((m) => m.user_id).filter(Boolean));
+      mentions = [...mentions, ...linkedMentions.filter((m) => !seen.has(m.user_id))];
+      params.log?.info?.(
+        `[${params.account.accountId}] clawchat-plugin-openclaw outbound text mentions linked count=${linkedMentions.length} to=${params.to.chatId}`,
+      );
+    }
+  }
   // Each MediaItem object is structurally compatible
   // with one of the local narrow Fragment members (ImageFragment / FileFragment /
   // AudioFragment / VideoFragment) based on its runtime `kind`. The wide local
@@ -617,7 +667,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     mode = "reply";
     const payload = {
       message_id: messageId,
-      message_mode: "normal",
+      message_mode: messageMode,
       message: {
         body: { fragments },
         context: {
@@ -642,7 +692,8 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
       ...(params.log ? { log: params.log } : {}),
     });
   } else {
-    mode = "send";
+    // A stream's final is a message.reply (§8.4) whether or not it quotes.
+    mode = params.finalizesStream ? "reply" : "send";
     const reply = params.replyCtx
       ? {
           reply_to_msg_id: params.replyCtx.replyToMessageId,
@@ -651,7 +702,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
       : null;
     const payload = {
       message_id: messageId,
-      message_mode: "normal",
+      message_mode: messageMode,
       message: {
         body: { fragments },
         context: { mentions, reply },
@@ -660,7 +711,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     ack = await sendAlignedAckableEnvelope({
       client: params.client,
       account: params.account,
-      eventName: "message.send",
+      eventName: mode === "reply" ? "message.reply" : "message.send",
       chatId: params.to.chatId,
       payload,
       ...(params.log ? { log: params.log } : {}),
@@ -672,7 +723,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     );
   }
   params.log?.info?.(
-    `[${params.account.accountId}] clawchat-plugin-openclaw outbound mode=${mode} msg=${ack.payload.message_id} text_len=${text.length} media=${mediaFragments.length} trace=${ack.trace_id}`,
+    `[${params.account.accountId}] clawchat-plugin-openclaw outbound mode=${mode} message_mode=${messageMode} msg=${ack.payload.message_id} text_len=${text.length} media=${mediaFragments.length} trace=${ack.trace_id}`,
   );
   return {
     messageId: ack.payload.message_id,