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

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/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.

package/dist/src/outbound.js

@@ -7,6 +7,7 @@ import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { CHANNEL_ID, resolveOpenclawClawlingAccount } from "./config.js";
 import { applyTextMentionLabels, buildMentionMessageFragments, normalizeMentionTargets, textToFragments, } from "./message-mapper.js";
 import { describeOutboundMediaShortfall, uploadOutboundMedia, } from "./media-runtime.js";
+import { autolinkMentions, hasMentionCandidate, mentionsIn, resolveMentionRoster, } from "./mention-autolink.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { stripNoReplyTokens } from "./no-reply.js";
 import { getOpenclawClawlingClient, getOpenclawClawlingRuntime, waitForOpenclawClawlingClient, } from "./runtime.js";
@@ -423,8 +424,27 @@ export async function sendOpenclawClawlingText(params) {
         params.log?.info?.(`[${params.account.accountId}] clawchat-plugin-openclaw outbound suppressed: empty text and no media`);
         return null;
     }
-    const mentions = params.mentions ?? [];
-    const textFragments = text ? textToFragments(text) : [];
+    const messageMode = 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
@@ -445,7 +465,7 @@ export async function sendOpenclawClawlingText(params) {
         mode = "reply";
         const payload = {
             message_id: messageId,
-            message_mode: "normal",
+            message_mode: messageMode,
             message: {
                 body: { fragments },
                 context: {
@@ -471,7 +491,8 @@ export async function sendOpenclawClawlingText(params) {
         });
     }
     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,
@@ -480,7 +501,7 @@ export async function sendOpenclawClawlingText(params) {
             : null;
         const payload = {
             message_id: messageId,
-            message_mode: "normal",
+            message_mode: messageMode,
             message: {
                 body: { fragments },
                 context: { mentions, reply },
@@ -489,7 +510,7 @@ export async function sendOpenclawClawlingText(params) {
         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 } : {}),
@@ -498,7 +519,7 @@ export async function sendOpenclawClawlingText(params) {
     if (ack.payload.message_id !== messageId) {
         throw new Error(`ack message_id mismatch: expected ${messageId} got ${ack.payload.message_id}`);
     }
-    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.log?.info?.(`[${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,
         acceptedAt: ack.payload.accepted_at,

package/dist/src/reply-dispatcher.js

@@ -6,7 +6,16 @@ import { describeOutboundMediaShortfall, uploadOutboundMedia, } from "./media-ru
 import { mintMessageId, sendOpenclawClawlingText, } from "./outbound.js";
 import { isClawChatNoopResponseText } from "./profile-prompt.js";
 import { consumeTerminalClawChatSend } from "./terminal-send.js";
+import { createReplyStream } from "./reply-stream.js";
 import { openclawLlmContextDebug } from "./llm-context-debug.js";
+/**
+ * Re-send cadence for `typing.update {is_typing:true}` while a reply is in
+ * flight: at most half of the client's typing display window (6 s), so a single
+ * lost frame never lets the indicator lapse.
+ */
+export const TYPING_KEEPALIVE_MS = 3_000;
+/** Safety cap for one reply's typing keepalive (15 min). */
+export const TYPING_KEEPALIVE_MAX_MS = 15 * 60_000;
 const GROUP_OWNER_ATTENTION_TITLE = "requires owner attention";
 const APPROVAL_FALLBACK_COMMAND_RE = /(?:^|\s)\/(?:approve|deny)\b/i;
 function ownerAttentionText(groupId, fallbackText) {
@@ -326,6 +335,40 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
     const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
     const terminalSendScopeId = options.terminalSendScopeId ?? null;
+    // ----- Reply streaming (experimental, `streamReplies`) -----------------
+    //
+    // One open stream previews the assistant text being generated. The next
+    // normal materialized send claims it (`message.done` with the final text,
+    // then the final as `message.reply` reusing the stream's message_id, §8.4);
+    // a final that does not extend the preview, a no-reply, a terminal tool
+    // send, or an idle run with nothing delivered fails it. Host partials are snapshots of
+    // the current assistant message that may be rewritten, so a snapshot that no
+    // longer extends the preview fails the old stream and starts a new one.
+    const streamEnabled = account.streamReplies === true;
+    let replyStream = null;
+    const failStream = (reason) => {
+        replyStream?.fail(reason);
+        replyStream = null;
+    };
+    const claimStreamMessageId = (finalText) => {
+        const id = replyStream?.finish(finalText) ?? null;
+        replyStream = null;
+        return id;
+    };
+    const onStreamPartial = (text) => {
+        if (runDone || terminalReplySuppressed)
+            return;
+        if (replyStream?.diverges(text))
+            failStream("superseded");
+        replyStream ??= createReplyStream({
+            client,
+            chatId: target.chatId,
+            mintMessageId,
+            log,
+            logPrefix: `[${account.accountId}] clawchat-plugin-openclaw`,
+        });
+        replyStream.update(text);
+    };
     const consumeTerminalSend = (reason) => {
         if (terminalReplySuppressed)
             return true;
@@ -339,6 +382,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         if (!terminal)
             return false;
         terminalReplySuppressed = true;
+        failStream("terminal-send");
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw suppressing ${reason} reply after terminal tool send msg=${terminal.messageId} to=${target.chatId}`);
         return true;
     };
@@ -424,7 +468,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 bufferedOutputUrls.push(url);
         }
     };
-    const fullSegmentKey = (text, urls) => JSON.stringify({
+    const fullSegmentKey = (text, urls, mode) => JSON.stringify({
+        mode,
         text: text.replace(/\s+/g, " ").trim(),
         urls: urls.filter(Boolean),
     });
@@ -458,6 +503,39 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw typing update failed: ${String(error)}`);
         }
     };
+    // Plugin-owned typing keepalive. The client lights "typing" for a fixed
+    // window per `is_typing:true` frame, so the sender must re-send at no more
+    // than half that window (TYPING_KEEPALIVE_MS) for as long as the reply is in
+    // flight, and send `false` exactly once at the end. The host's own keepalive
+    // (default 6 s, global config only) equals the client window, so one lost or
+    // late frame makes the indicator flash; we ask the host to turn it off
+    // (`typingKeepalive: false`, honoured by newer hosts) and ignore its repeated
+    // `onReplyStart` ticks on older hosts.
+    let typingTimer = null;
+    let typingCapTimer = null;
+    let typingFinished = false;
+    const stopTyping = () => {
+        if (typingTimer)
+            clearInterval(typingTimer);
+        if (typingCapTimer)
+            clearTimeout(typingCapTimer);
+        typingTimer = null;
+        typingCapTimer = null;
+        typingFinished = true;
+        emitTyping(false);
+    };
+    const startTyping = () => {
+        if (typingFinished || typingTimer)
+            return;
+        emitTyping(true);
+        typingTimer = setInterval(() => emitTyping(true), TYPING_KEEPALIVE_MS);
+        typingTimer.unref?.();
+        typingCapTimer = setTimeout(() => {
+            log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw typing keepalive cap reached; stopping to=${target.chatId}`);
+            stopTyping();
+        }, TYPING_KEEPALIVE_MAX_MS);
+        typingCapTimer.unref?.();
+    };
     const sendOwnerAttention = async (fallbackText, richFragment = null) => {
         const ownerTarget = ownerDirectTarget();
         if (!ownerTarget) {
@@ -479,10 +557,13 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     };
     // ----- Static send ------------------------------------------------------
     const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
+        const messageMode = options.messageMode ?? "normal";
         if (isClawChatNoopResponseText(text) &&
             mediaFragments.length === 0 &&
             richFragments.length === 0) {
             log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw outbound suppressed: no-reply token`);
+            if (messageMode === "normal")
+                failStream("no-reply");
             openclawLlmContextDebug.writeSnapshot({
                 visibility: "host_event",
                 trace: {
@@ -506,11 +587,12 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             return null;
         if (consumeTerminalSend("static"))
             return null;
-        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
-        const messageId = mintStaticMessageId();
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static mode=${messageMode} text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
+        const streamMessageId = messageMode === "normal" ? claimStreamMessageId(text) : null;
+        const messageId = streamMessageId ?? mintStaticMessageId();
         const raw = { target, replyCtx: replyCtx ?? null, mode: "static" };
         const claimed = options.recordMessage
-            ? claimOutbound(outboundEventType(), messageId, text, raw)
+            ? claimOutbound(streamMessageId ? "message.reply" : outboundEventType(), messageId, text, raw)
             : true;
         if (claimed === false) {
             log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw outbound duplicate skipped msg=${messageId}`);
@@ -529,10 +611,14 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             ...(replyCtx ? { replyCtx } : {}),
             ...(richFragments.length > 0 ? { richFragments } : {}),
             ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
+            ...(messageMode !== "normal" ? { messageMode } : {}),
+            ...(streamMessageId ? { finalizesStream: true } : {}),
             log,
         });
         recordOutboundAck("message", messageId, result);
-        if (result)
+        // Process (thinking) messages are not replies: they must not make a
+        // bootstrap greeting look delivered.
+        if (result && messageMode === "normal")
             outboundDeliveredCount += 1;
         log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw send complete to=${target.chatId}`);
         openclawLlmContextDebug.writeSnapshot({
@@ -558,7 +644,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         });
         return result;
     };
-    const emitFullSegment = async (text, urls = []) => {
+    const emitFullSegment = async (text, urls = [], messageMode = "normal") => {
         if (outputVisibility !== "full" && !splitNormalBlockOutput) {
             appendBufferedText(text);
             appendBufferedUrls(urls);
@@ -572,24 +658,26 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         const trimmed = text.trim();
         if (!trimmed && urls.length === 0)
             return;
-        const segmentKey = fullSegmentKey(trimmed, urls);
+        const segmentKey = fullSegmentKey(trimmed, urls, messageMode);
         if (emittedFullSegmentSet.has(segmentKey))
             return;
         emittedFullSegmentSet.add(segmentKey);
         const mediaFragments = await uploadMediaUrls(urls);
-        await sendStatic(trimmed, mediaFragments, [], { recordMessage: true });
+        await sendStatic(trimmed, mediaFragments, [], { recordMessage: true, messageMode });
     };
     const emitFullRuntimeText = async (label, text, urls = []) => {
         const summary = summarizeValue(text);
         if (!summary && urls.length === 0)
             return;
-        await emitFullSegment(summary ? `[${label}] ${summary}` : "", urls);
+        await emitFullSegment(summary ? `[${label}] ${summary}` : "", urls, "thinking");
     };
+    /** Process output (tool / command / patch / compaction / reasoning): `message_mode: "thinking"`. */
+    const emitProcessSegment = (text, urls = []) => emitFullSegment(text, urls, "thinking");
     // ----- Dispatcher -------------------------------------------------------
     const base = runtime.channel.reply.createReplyDispatcherWithTyping({
         humanDelay,
         onReplyStart: async () => {
-            emitTyping(true);
+            startTyping();
         },
         deliver: async (payload, info) => {
             if (consumeTerminalSend(info?.kind ?? "unknown"))
@@ -614,7 +702,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             if (payload.isReasoning) {
                 if (outputVisibility !== "full")
                     return;
-                await emitFullSegment(text, urls);
+                await emitProcessSegment(text, urls);
                 const trimmed = text.trim();
                 if (trimmed)
                     reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
@@ -645,6 +733,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 finalDeliverySeen = true;
                 if (isClawChatNoopResponseText(text) && !richFragment && urls.length === 0) {
                     log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+                    failStream("no-reply");
                     openclawLlmContextDebug.writeSnapshot({
                         visibility: "host_event",
                         trace: {
@@ -670,6 +759,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     !richFragment &&
                     finalUrls.length === 0) {
                     log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+                    failStream("no-reply");
                     return;
                 }
                 const mediaFragments = await uploadMediaUrls(finalUrls);
@@ -687,23 +777,29 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 void emitFullRuntimeText("error", errorText);
         },
         onIdle: async () => {
-            emitTyping(false);
+            stopTyping();
             if (runDone)
                 return;
             runDone = true;
-            if (finalDeliverySeen)
-                return;
-            const fallbackText = bufferedOutputText.trim();
-            const fallbackUrls = bufferedOutputUrls.slice();
-            if (!fallbackText && fallbackUrls.length === 0)
-                return;
-            const mediaFragments = await uploadMediaUrls(fallbackUrls);
-            const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
-            if (result?.messageId)
-                recordThinkingIfLinked(result.messageId);
+            try {
+                if (finalDeliverySeen)
+                    return;
+                const fallbackText = bufferedOutputText.trim();
+                const fallbackUrls = bufferedOutputUrls.slice();
+                if (!fallbackText && fallbackUrls.length === 0)
+                    return;
+                const mediaFragments = await uploadMediaUrls(fallbackUrls);
+                const result = await sendStatic(fallbackText, mediaFragments, [], { recordMessage: true });
+                if (result?.messageId)
+                    recordThinkingIfLinked(result.messageId);
+            }
+            finally {
+                // A preview nothing materialized must not linger as an open stream.
+                failStream("undelivered");
+            }
         },
         onCleanup: () => {
-            emitTyping(false);
+            stopTyping();
         },
     });
     return {
@@ -712,7 +808,15 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         replyOptions: {
             ...base.replyOptions,
             sourceReplyDeliveryMode: "automatic",
-            disableBlockStreaming: !splitNormalBlockOutput,
+            typingKeepalive: false,
+            // Streaming previews the assistant message and the final materializes it,
+            // so host block chunks (which split one message arbitrarily) stay off.
+            disableBlockStreaming: streamEnabled ? true : !splitNormalBlockOutput,
+            onPartialReply: streamEnabled
+                ? (payload) => {
+                    onStreamPartial(typeof payload?.text === "string" ? payload.text : "");
+                }
+                : undefined,
             suppressDefaultToolProgressMessages: true,
             allowProgressCallbacksWhenSourceDeliverySuppressed: splitFullOutput ? true : undefined,
             onReasoningStream: splitFullOutput
@@ -730,7 +834,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ? async (payload) => {
                     if (consumeTerminalSend("tool-start"))
                         return;
-                    await emitFullSegment(formatToolStartSummary(payload));
+                    await emitProcessSegment(formatToolStartSummary(payload));
                 }
                 : undefined,
             onToolResult: splitFullOutput
@@ -763,28 +867,28 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ? async (payload) => {
                     if (consumeTerminalSend("command-output"))
                         return;
-                    await emitFullSegment(formatCommandOutputSummary(payload));
+                    await emitProcessSegment(formatCommandOutputSummary(payload));
                 }
                 : undefined,
             onPatchSummary: splitFullOutput
                 ? async (payload) => {
                     if (consumeTerminalSend("patch-summary"))
                         return;
-                    await emitFullSegment(formatPatchSummary(payload));
+                    await emitProcessSegment(formatPatchSummary(payload));
                 }
                 : undefined,
             onCompactionStart: splitFullOutput
                 ? async () => {
                     if (consumeTerminalSend("compaction-start"))
                         return;
-                    await emitFullSegment("[compaction] started");
+                    await emitProcessSegment("[compaction] started");
                 }
                 : undefined,
             onCompactionEnd: splitFullOutput
                 ? async () => {
                     if (consumeTerminalSend("compaction-end"))
                         return;
-                    await emitFullSegment("[compaction] finished");
+                    await emitProcessSegment("[compaction] finished");
                 }
                 : undefined,
         },