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

package/dist/src/config.js

@@ -82,6 +82,7 @@ export const openclawClawlingAccountConfigSchema = {
         forwardThinking: { type: "boolean" },
         forwardToolCalls: { type: "boolean" },
         richInteractions: { type: "boolean" },
+        streamReplies: { type: "boolean" },
         awarenessNote: { type: "boolean" },
         friendGreeting: { type: "boolean" },
         livewareSample: { type: "boolean" },
@@ -448,6 +449,7 @@ export function resolveOpenclawClawlingAccount(cfg, accountId, env = process.env
     const forwardThinking = typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
     const forwardToolCalls = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
     const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
+    const streamReplies = typeof channel.streamReplies === "boolean" ? channel.streamReplies : false;
     const awarenessNote = typeof channel.awarenessNote === "boolean" ? channel.awarenessNote : false;
     const friendGreeting = typeof channel.friendGreeting === "boolean" ? channel.friendGreeting : true;
     const livewareSample = typeof channel.livewareSample === "boolean" ? channel.livewareSample : true;
@@ -476,6 +478,7 @@ export function resolveOpenclawClawlingAccount(cfg, accountId, env = process.env
         forwardThinking,
         forwardToolCalls,
         richInteractions,
+        streamReplies,
         awarenessNote,
         friendGreeting,
         livewareSample,

package/dist/src/framework-error-copy.js

@@ -0,0 +1,172 @@
+/**
+ * Owner-language copy for OpenClaw framework errors that reach a ClawChat
+ * conversation as a final reply.
+ *
+ * The host hands the channel its own English failure text (rate limit, expired
+ * provider login, context overflow, billing, timeouts — see
+ * `docs/clawchat-plugin-openclaw.md` "Framework error replies"). Posting that
+ * raw leaves a non-English owner with a message they cannot act on. Instead we
+ * lead with one sentence in the owner's language saying what happened and what
+ * to do, then keep the original text at the end so it can still be reported.
+ */
+import { resolveOwnerLanguage } from "./owner-language.js";
+const WARNING_PREFIX = "⚠️";
+/**
+ * Host lifecycle notices that look like errors but are not. The host itself
+ * emits "Gateway restarting…" without `isError`; it is listed here too so a
+ * future `⚠️`/`isError` variant still passes through untouched.
+ */
+const PASS_THROUGH = [/^(?:⚠️\s*)?gateway restarting\b/i];
+/**
+ * Ordered: the first entry whose patterns match wins. Context overflow sits
+ * before timeout because the host's compaction failure reads "Context is too
+ * large and auto-compaction timed out"; the weak billing words (quota, credit,
+ * billing) sit after rate limit because the host's bare-429 copy names them as
+ * possible causes of what is reported as a 429.
+ */
+const CATEGORY_PATTERNS = [
+    [
+        "context_overflow",
+        [
+            /context[\s_-]*(?:length|window|overflow|limit)/i,
+            /maximum context/i,
+            /context[\s_-]*length[\s_-]*exceeded/i,
+            /\bcontext is too (?:large|long)\b/i,
+            /\b(?:prompt|input|conversation|request|message)s? (?:is |was )?too (?:long|large)\b/i,
+            /\btoo many (?:input )?tokens\b/i,
+        ],
+    ],
+    [
+        // Unambiguous billing wording first: provider quota errors often ride an
+        // HTTP 429 ("429 You exceeded your current quota"), which would otherwise
+        // read as a rate limit.
+        "billing",
+        [
+            /insufficient[\s_-]*(?:quota|balance|credits?|funds)/i,
+            /exceeded your current quota/i,
+            /out of credits?\b/i,
+            /billing error/i,
+            /\b402\b/,
+            /payment required/i,
+        ],
+    ],
+    [
+        "rate_limit",
+        [
+            /rate[\s_-]*limit/i,
+            /\b429\b/,
+            /overloaded/i,
+            /too many requests/i,
+            /needs a short break/i,
+            /\bat capacity\b/i,
+            /asking us to slow down/i,
+            /resource[\s_-]*exhausted/i,
+        ],
+    ],
+    [
+        "auth",
+        [
+            /\b401\b/,
+            /unauthori[sz]ed/i,
+            /authenticat(?:e|ion)/i,
+            /\bre-?auth\b/i,
+            /(?:invalid|incorrect|missing|wrong|expired) (?:x-)?api[\s_-]*key/i,
+            /api[\s_-]*key (?:is |was )?(?:invalid|incorrect|missing|expired|not valid)/i,
+            /log(?:in|-in)? (?:has )?(?:expired|failed)/i,
+            /\bsaved logins?\b/i,
+            /couldn't sign in|could not sign in|sign[\s-]*in (?:has )?expired/i,
+            /\bauth profile\b/i,
+            /(?:oauth|access|provider) token (?:has |may have )?expired/i,
+        ],
+    ],
+    [
+        "billing",
+        [/billing/i, /\bquota\b/i, /\bcredits?\b/i, /\bbalance\b/i],
+    ],
+    ["timeout", [/timed?[\s_-]*out\b/i, /\btimeout\b/i, /\bwatchdog\b/i]],
+];
+export function classifyFrameworkError(text) {
+    for (const [category, patterns] of CATEGORY_PATTERNS) {
+        if (patterns.some((p) => p.test(text)))
+            return category;
+    }
+    return "unknown";
+}
+/**
+ * Whether a final reply is a framework error to be rewritten. `isError` is the
+ * authority; a leading "⚠️" is only a fallback for host copy that does not set
+ * it. Host lifecycle notices pass through.
+ */
+export function isFrameworkErrorReply(payload, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    if (PASS_THROUGH.some((p) => p.test(trimmed)))
+        return false;
+    return payload.isError === true || trimmed.startsWith(WARNING_PREFIX);
+}
+const COPY = {
+    rate_limit: {
+        zh: "模型服务这会儿太忙，暂时不接新请求。过几分钟再发一次。",
+        zh_Hant: "模型服務這會兒太忙，暫時不接新請求。過幾分鐘再傳一次。",
+        en: "The model service is busy right now and isn't taking new requests. Try again in a few minutes.",
+        ja: "モデルサービスが混み合っていて、いまは新しいリクエストを受け付けていません。数分後にもう一度送ってください。",
+        es: "El servicio del modelo está saturado y ahora no acepta nuevas solicitudes. Vuelve a enviarlo en unos minutos.",
+        ko: "모델 서비스가 지금 너무 바빠서 새 요청을 받지 않고 있어요. 몇 분 뒤에 다시 보내 주세요.",
+    },
+    auth: {
+        zh: "模型服务的登录失效了，或者 API Key 不对。请在运行 OpenClaw 的那台机器上重新登录模型服务（或更新 API Key），再发一次。",
+        zh_Hant: "模型服務的登入失效了，或者 API Key 不對。請在執行 OpenClaw 的那台機器上重新登入模型服務（或更新 API Key），再傳一次。",
+        en: "The model service sign-in has expired, or the API key is wrong. On the machine running OpenClaw, sign in to the model service again (or update the API key), then try again.",
+        ja: "モデルサービスのログインが切れているか、API キーが正しくありません。OpenClaw を動かしているマシンでモデルサービスにログインし直して（または API キーを更新して）から、もう一度送ってください。",
+        es: "La sesión del servicio del modelo ha caducado o la clave de API no es correcta. En el equipo donde se ejecuta OpenClaw, vuelve a iniciar sesión en el servicio del modelo (o actualiza la clave de API) y envíalo de nuevo.",
+        ko: "모델 서비스 로그인이 만료됐거나 API 키가 올바르지 않아요. OpenClaw를 실행 중인 기기에서 모델 서비스에 다시 로그인(또는 API 키를 업데이트)한 뒤 다시 보내 주세요.",
+    },
+    context_overflow: {
+        zh: "这段对话太长，模型装不下了。发送 /new 开始新对话，再接着说。",
+        zh_Hant: "這段對話太長，模型裝不下了。傳送 /new 開始新對話，再接著說。",
+        en: "This conversation is too long for the model. Send /new to start a new conversation, then carry on.",
+        ja: "この会話が長すぎて、モデルが処理しきれません。/new を送って新しい会話を始めてから続けてください。",
+        es: "Esta conversación es demasiado larga para el modelo. Envía /new para empezar una conversación nueva y sigue desde ahí.",
+        ko: "이 대화가 너무 길어서 모델이 처리할 수 없어요. /new를 보내 새 대화를 시작한 뒤 이어서 말해 주세요.",
+    },
+    billing: {
+        zh: "模型服务的账户余额不足。请到模型服务商那里充值或查看账单，再发一次。",
+        zh_Hant: "模型服務的帳戶餘額不足。請到模型服務商那裡儲值或查看帳單，再傳一次。",
+        en: "The model service account is out of credit. Top up or check billing with your model provider, then try again.",
+        ja: "モデルサービスのアカウント残高が不足しています。モデルの提供元でチャージするか請求状況を確認してから、もう一度送ってください。",
+        es: "La cuenta del servicio del modelo no tiene saldo suficiente. Recarga o revisa la facturación con tu proveedor del modelo y vuelve a enviarlo.",
+        ko: "모델 서비스 계정 잔액이 부족해요. 모델 제공업체에서 충전하거나 결제 내역을 확인한 뒤 다시 보내 주세요.",
+    },
+    timeout: {
+        zh: "这次处理超时，没有做完。再发一次试试；总是超时的话，把任务拆小一点。",
+        zh_Hant: "這次處理逾時，沒有做完。再傳一次試試；總是逾時的話，把任務拆小一點。",
+        en: "This took too long and didn't finish. Try again; if it keeps timing out, break the task into smaller steps.",
+        ja: "処理がタイムアウトして、最後まで終わりませんでした。もう一度送ってみてください。何度もタイムアウトする場合は、タスクを小さく分けてください。",
+        es: "Esto tardó demasiado y no terminó. Vuelve a intentarlo; si sigue pasando, divide la tarea en partes más pequeñas.",
+        ko: "처리 시간이 초과되어 끝까지 마치지 못했어요. 다시 보내 보세요. 계속 시간이 초과되면 작업을 더 작게 나눠 주세요.",
+    },
+    unknown: {
+        zh: "这次出错了，没有做完。再发一次试试；还不行的话，可以把下面的原文发给 ClawChat 客服。",
+        zh_Hant: "這次出錯了，沒有做完。再傳一次試試；還不行的話，可以把下面的原文傳給 ClawChat 客服。",
+        en: "Something went wrong and this didn't finish. Try again; if it still fails, send the original message below to ClawChat support.",
+        ja: "エラーが起きて、最後まで終わりませんでした。もう一度送ってみてください。それでもだめなら、下の原文を ClawChat サポートに送ってください。",
+        es: "Algo salió mal y esto no terminó. Vuelve a intentarlo; si sigue fallando, envía el texto original de abajo al soporte de ClawChat.",
+        ko: "오류가 생겨 끝까지 마치지 못했어요. 다시 보내 보세요. 그래도 안 되면 아래 원문을 ClawChat 고객지원에 보내 주세요.",
+    },
+    original_label: {
+        zh: "原文：",
+        zh_Hant: "原文：",
+        en: "Original:",
+        ja: "原文：",
+        es: "Texto original:",
+        ko: "원문:",
+    },
+};
+/** `<owner-language sentence>\n\n<label> <original text>`. */
+export function formatFrameworkErrorForOwner(text, locale) {
+    const language = resolveOwnerLanguage(locale);
+    const original = text.trim();
+    const category = classifyFrameworkError(original);
+    return `${COPY[category][language]}\n\n${COPY.original_label[language]} ${original}`;
+}

package/dist/src/liveware-sample.js

@@ -209,10 +209,20 @@ export async function downloadLivewareSample(opts) {
         throw err;
     }
 }
+/** How long a SIGTERM'd liveware process tree gets before SIGKILL. */
+export const KILL_GRACE_MS = 3_000;
+const KILL_POLL_MS = 50;
 /**
- * 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 —
@@ -220,23 +230,86 @@ export async function downloadLivewareSample(opts) {
  * 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, execFileFn = nodeExecFile) {
+export function killProcessTree(child, execFileFn = nodeExecFile, opts = {}) {
     if (!child)
-        return;
+        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");
+    if (process.platform === "win32") {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch { /* already dead */ }
+        return Promise.resolve();
     }
-    catch { /* already dead */ }
+    const killFn = opts.killFn ?? ((pid, signal) => { 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 = () => {
+        if (pid === null)
+            return false;
+        try {
+            killFn(-pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const signalTree = (signal) => {
+        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() {
+    return process.platform === "win32" ? {} : { detached: true };
 }
 const SERVER_START_TIMEOUT_MS = 10_000;
 const TUNNEL_START_TIMEOUT_MS = 30_000;
@@ -255,7 +328,7 @@ function waitForOutput(child, match, timeoutMs, label) {
             child.stderr?.removeListener("data", onData);
             child.removeListener("exit", onExit);
             if (err) {
-                killProcessTree(child);
+                void killProcessTree(child);
                 reject(err);
             }
             else {
@@ -319,7 +392,7 @@ export async function startSampleServer(opts) {
     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, opts.timeoutMs ?? SERVER_START_TIMEOUT_MS, "liveware-sample server start");
     return { child, port: JSON.parse(line).port };
 }
@@ -387,7 +460,7 @@ export function parseAgentReady(output) {
  */
 export async function startTunnelAgent(opts) {
     const spawnFn = opts.spawnFn ?? nodeSpawn;
-    const child = spawnFn(opts.livewarePath, ["agent"], { stdio: ["ignore", "pipe", "pipe"], ...(opts.env ? { env: opts.env } : {}) });
+    const child = spawnFn(opts.livewarePath, ["agent"], { stdio: ["ignore", "pipe", "pipe"], ...childSpawnOptions(), ...(opts.env ? { env: opts.env } : {}) });
     await waitForOutput(child, (acc) => parseAgentReady(acc), opts.timeoutMs ?? TUNNEL_START_TIMEOUT_MS, "liveware agent start");
     return { child };
 }
@@ -629,6 +702,8 @@ export class LivewareSampleSupervisor {
     serverChild = null;
     tunnelChild = null;
     stopped = false;
+    /** The one shutdown wait, shared by every stop() caller. */
+    stopping = null;
     /** True while a startAttempt chain (bootstrap/relaunch) is running; read by
      * isIdle() so adoptDeps never starts a second concurrent flow. */
     launchInFlight = false;
@@ -702,7 +777,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?.(`clawchat-plugin-openclaw liveware-sample start failed (attempt ${attempt + 1}, giving up): ${String(err)}`);
@@ -715,20 +790,29 @@ export class LivewareSampleSupervisor {
             this.launchInFlight = false;
         }
     }
+    /**
+     * 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() {
+        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;
     }
     killChildren() {
         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);
     }
     schedule(fn, delayMs) {
         if (this.stopped)
@@ -743,7 +827,10 @@ export class LivewareSampleSupervisor {
     bailIfStopped() {
         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;
     }
     /**
@@ -989,7 +1076,7 @@ export class LivewareSampleSupervisor {
         const onChildExit = () => {
             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) {
@@ -1020,7 +1107,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/dist/src/mention-autolink.js

@@ -0,0 +1,155 @@
+/** The `@everyone` sentinel user id; never auto-linked from text. */
+export const MENTION_ALL_SENTINEL = "all";
+const AT = 0x40;
+function isAsciiAlnum(c) {
+    return (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a);
+}
+function isEmailLocal(c) {
+    return isAsciiAlnum(c) || c === 0x2e || c === 0x5f || c === 0x25 || c === 0x2b || c === 0x2d;
+}
+function openBoundary(text, at) {
+    if (at === 0)
+        return true;
+    return !isEmailLocal(text.charCodeAt(at - 1));
+}
+function lowerAscii(c) {
+    return c >= 0x41 && c <= 0x5a ? c + 0x20 : c;
+}
+function matches(text, start, name, fold) {
+    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, start, targets) {
+    let best = 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, ownUserId) {
+    const out = [];
+    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) {
+    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, roster, options) {
+    if (!text)
+        return [];
+    const targets = targetsOf(roster, options.ownUserId);
+    if (targets.length === 0)
+        return [{ kind: "text", text }];
+    const out = [];
+    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) {
+    const seen = new Set();
+    const out = [];
+    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;
+}
+const rosterResolvers = new Map();
+/** Register the roster source for one account; returns an unregister function. */
+export function registerMentionRosterResolver(accountId, resolver) {
+    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, groupId) {
+    const resolver = rosterResolvers.get(accountId);
+    if (!resolver)
+        return [];
+    try {
+        const roster = await resolver(groupId);
+        return Array.isArray(roster) ? roster : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function clearMentionRosterResolversForTest() {
+    rosterResolvers.clear();
+}

package/dist/src/no-reply.js

@@ -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.
@@ -33,7 +34,7 @@ const CONTAINS_RE = new RegExp(CORE, "i");
 const DECORATION_OPEN = "[<\\[{`*_~]*";
 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()`
 // check. Note `*` is Po (stripped) while `~` is Sm (kept) — same as the host.