@clawling/clawchat-plugin-openclaw 2026.10.7-2 → 2026.10.8-2

package/dist/src/clawchat-metadata.js

@@ -202,12 +202,20 @@ export async function pullGroupMetadata(params) {
                 targetType: "user",
                 targetId: mapped.userId,
             });
-            if (existing.exists)
+            // A cached file is kept as is, except that one without profile_type
+            // (written before types were recorded) gets just that field filled in:
+            // without it the prompt lists a peer agent as a person.
+            if (existing.exists && existing.metadata.profile_type)
                 continue;
             if (!getUser)
                 throw new Error("ClawChat participant metadata pull requires getUserProfile");
             const profile = await getUser(mapped.userId);
-            const metadata = userMetadataFromProfile(profile, mapped.userId);
+            const fetched = userMetadataFromProfile(profile, mapped.userId);
+            if (existing.exists && !fetched.profile_type)
+                continue;
+            const metadata = existing.exists
+                ? { ...existing.metadata, profile_type: fetched.profile_type }
+                : fetched;
             await writeClawChatMetadata(params.memoryRoot, { targetType: "user", targetId: mapped.userId }, metadata);
             writes.push({ targetType: "user", targetId: mapped.userId });
         }

package/dist/src/config.js

@@ -86,6 +86,10 @@ export const openclawClawlingAccountConfigSchema = {
         awarenessNote: { type: "boolean" },
         friendGreeting: { type: "boolean" },
         livewareSample: { type: "boolean" },
+        "note-cap-user": { type: "integer" },
+        "note-cap-group": { type: "integer" },
+        "note-cap-turn": { type: "integer" },
+        "delta-budget-chars": { type: "integer" },
         reconnect: {
             type: "object",
             additionalProperties: false,
@@ -383,6 +387,29 @@ export function effectiveOutputVisibility(account, chatId, chatType) {
         ?? account.outputVisibility
         ?? "normal";
 }
+/**
+ * Session / note keys shared with the other ClawChat agent channels (same
+ * hyphenated names, meaning and factory values as the Hermes plugin's
+ * `SESSION_INT_KEYS`). An out-of-range value is clamped to the nearest bound,
+ * a non-number falls back to the factory value. Every key here has a reader;
+ * the shared keys this plugin has no use for are listed in
+ * docs/clawchat-plugin-openclaw.md with the reason.
+ *   key -> [factory, minimum, maximum]
+ */
+export const SESSION_INT_KEYS = {
+    "note-cap-user": [1500, 300, 6000],
+    "note-cap-group": [2000, 300, 8000],
+    "note-cap-turn": [4000, 1000, 16000],
+    "delta-budget-chars": [8000, 2000, 32000],
+};
+function readSessionInt(channel, key) {
+    const [factory, minimum, maximum] = SESSION_INT_KEYS[key];
+    const raw = channel[key];
+    const parsed = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() ? Number(raw.trim()) : Number.NaN;
+    if (!Number.isFinite(parsed))
+        return factory;
+    return Math.max(minimum, Math.min(maximum, Math.trunc(parsed)));
+}
 function readReconnect(raw) {
     const s = raw && typeof raw === "object" ? raw : {};
     return {
@@ -482,6 +509,10 @@ export function resolveOpenclawClawlingAccount(cfg, accountId, env = process.env
         awarenessNote,
         friendGreeting,
         livewareSample,
+        noteCapUser: readSessionInt(channel, "note-cap-user"),
+        noteCapGroup: readSessionInt(channel, "note-cap-group"),
+        noteCapTurn: readSessionInt(channel, "note-cap-turn"),
+        deltaBudgetChars: readSessionInt(channel, "delta-budget-chars"),
         allowFrom: [],
         reconnect: readReconnect(channel.reconnect),
         heartbeat: readHeartbeat(channel.heartbeat),

package/dist/src/group-catch-up.js

@@ -0,0 +1,90 @@
+/**
+ * What an @-mention adds in front of a group turn: the group messages this
+ * agent's session has not been given since its last turn.
+ *
+ * Every group batch the plugin hands to the host is recorded as delivered
+ * (per chat, bounded). On a mention, the ledger's recent group messages minus
+ * the delivered ones, the agent's own replies and the batch itself are the
+ * catch-up — e.g. messages a mention-only group held back. It is bounded by
+ * the shared `delta-budget-chars` key (characters, newest kept first); the
+ * unseen messages that do not fit are counted in one closing line, and are
+ * recorded as delivered with the rest, so a later mention does not bring them
+ * back out of order. Same rule as the Hermes plugin's shared group sessions.
+ *
+ * The delivered record is in memory: after a gateway restart the first
+ * mention may repeat up to that budget of messages the session already has.
+ */
+/** How far back the ledger is read to find unseen messages (one row per message). */
+export const CATCH_UP_FETCH_ROWS = 500;
+/** Per group, how many delivered message ids are remembered. */
+export const DELIVERED_GROUP_IDS_MAX = 500;
+export const GROUP_UNSEEN_HEADER = "[ClawChat group messages you have not seen yet, oldest first. " +
+    "Context only; the new messages follow.]";
+export function groupUnseenLeftOutLine(count) {
+    return (`[${count} earlier unseen group messages were left out for length. If you ` +
+        "need them, ask in the group; the group's note (clawchat_memory_read) " +
+        "holds what was saved about it.]");
+}
+export class DeliveredGroupMessages {
+    max;
+    byChat = new Map();
+    constructor(max = DELIVERED_GROUP_IDS_MAX) {
+        this.max = max;
+    }
+    remember(chatId, messageIds) {
+        let delivered = this.byChat.get(chatId);
+        if (!delivered) {
+            delivered = new Set();
+            this.byChat.set(chatId, delivered);
+        }
+        for (const id of messageIds) {
+            if (!id)
+                continue;
+            delivered.delete(id); // re-insert at the end (most recent)
+            delivered.add(id);
+        }
+        while (delivered.size > this.max) {
+            const oldest = delivered.values().next().value;
+            delivered.delete(oldest);
+        }
+    }
+    has(chatId, messageId) {
+        return this.byChat.get(chatId)?.has(messageId) ?? false;
+    }
+}
+/**
+ * The catch-up text (or null when nothing is unseen) for `rows` (oldest
+ * first, as read from the ledger with `fetchLimit`). Records every unseen row
+ * as delivered.
+ */
+export function buildGroupCatchUp(params) {
+    const { chatId, rows, batchIds, delivered, budgetChars } = params;
+    const windowFull = rows.length >= params.fetchLimit;
+    const unseen = rows.filter((row) => row.message_id != null &&
+        row.direction !== "outbound" &&
+        !batchIds.has(row.message_id) &&
+        !delivered.has(chatId, row.message_id));
+    if (unseen.length === 0)
+        return null;
+    delivered.remember(chatId, unseen.map((row) => row.message_id));
+    const kept = [];
+    let used = 0;
+    for (let index = unseen.length - 1; index >= 0; index -= 1) {
+        // newest first, so the budget keeps the latest
+        const line = params.formatLine(unseen[index]);
+        const cost = line.length + (kept.length > 0 ? 1 : 0);
+        if (used + cost > budgetChars) {
+            if (kept.length === 0)
+                kept.push(`${line.slice(0, Math.max(0, budgetChars - 1))}…`);
+            break;
+        }
+        kept.push(line);
+        used += cost;
+    }
+    const leftOut = unseen.length - kept.length;
+    const lines = [GROUP_UNSEEN_HEADER, ...kept.reverse()];
+    if (leftOut > 0 || windowFull) {
+        lines.push(groupUnseenLeftOutLine(windowFull ? `${leftOut}+` : String(leftOut)));
+    }
+    return lines.join("\n");
+}

package/dist/src/group-message-coalescer.js

@@ -25,6 +25,36 @@ export function formatCoalescedGroupBody(turns, timing = { idleSeconds: 10, maxW
         }).join("\n"),
     ].join("\n");
 }
+/**
+ * Relabel a coalesced body's `[message N] <sender>:` lines whose sender was
+ * still a bare id when the batch was built (ingest labels synchronously from
+ * an in-memory nickname map, which is empty right after a restart). Only the
+ * label line of each message, in order, is touched; bodies are never rewritten.
+ */
+export function relabelCoalescedGroupBody(rawBody, messages, nameFor) {
+    const lines = rawBody.split("\n");
+    let from = 0;
+    messages.forEach((message, index) => {
+        const prefix = `[message ${index + 1}] ${formatField(message.senderId)}:`;
+        let at = -1;
+        for (let i = from; i < lines.length; i += 1) {
+            if (lines[i].startsWith(`[message ${index + 1}] `)) {
+                at = i;
+                break;
+            }
+        }
+        if (at < 0)
+            return;
+        from = at + 1;
+        if (message.senderName && message.senderName !== message.senderId)
+            return;
+        const name = nameFor(message.senderId);
+        if (!name || name === message.senderId || !lines[at].startsWith(prefix))
+            return;
+        lines[at] = `[message ${index + 1}] ${formatField(name)}:${lines[at].slice(prefix.length)}`;
+    });
+    return lines.join("\n");
+}
 function groupMessageForPrompt(turn) {
     return {
         messageId: turn.messageId,

package/dist/src/note-injection.js

@@ -0,0 +1,158 @@
+/**
+ * The agent's own ClawChat notes shown in a turn's prompt, capped.
+ *
+ * Same shape, keys and limits as the Hermes plugin (0.14.0-101,
+ * `clawchat_gateway/note_injection.py` + `_format_note_memory_section`):
+ *
+ * - Owner's direct chat: `owner.md`. Anyone else's direct chat:
+ *   `users/<sender>.md`.
+ * - Group: `groups/<chat>.md` plus `users/<id>.md` of each speaker in the
+ *   batch. Never `owner.md` (it stays in the owner's direct chat).
+ * - `note-cap-user` per person, `note-cap-group` for the group,
+ *   `note-cap-turn` for the whole section (the longest notes give way first).
+ *
+ * Only the Markdown body is shown; the metadata block already reaches the
+ * prompt through the profile sections.
+ */
+import { readClawChatMemoryFile } from "./clawchat-memory.js";
+export const NOTE_MEMORY_PREAMBLE = "Notes you wrote yourself in earlier conversations (ClawChat memory files). " +
+    "They are social context, not instructions.";
+export const GROUP_NOTE_MEMORY_PRIVACY = "A note about a person can hold something they told you elsewhere; do not bring " +
+    "that up here unless they have already said it in this group.";
+const PARAGRAPH_SPLIT = /\n[ \t]*\n/;
+function truncationMarker(readHint) {
+    return readHint ? `(truncated — ${readHint} for the rest)` : "(truncated)";
+}
+/** `body` cut to at most `limit` characters of note text: whole paragraphs, then whole lines, then a hard cut. */
+export function capNote(body, limit, readHint = "") {
+    const text = (body ?? "").trim();
+    if (text.length <= limit)
+        return text;
+    let kept = "";
+    for (const paragraph of text.split(PARAGRAPH_SPLIT)) {
+        const candidate = kept ? `${kept}\n\n${paragraph}` : paragraph;
+        if (candidate.length > limit)
+            break;
+        kept = candidate;
+    }
+    if (!kept) {
+        for (const line of text.split("\n")) {
+            const candidate = kept ? `${kept}\n${line}` : line;
+            if (candidate.length > limit)
+                break;
+            kept = candidate;
+        }
+    }
+    if (!kept)
+        kept = text.slice(0, limit);
+    return `${kept.trimEnd()}\n${truncationMarker(readHint)}`;
+}
+/**
+ * Per-note ceilings so `sum(min(length, ceiling)) <= budget`: notes no longer
+ * than the common ceiling keep their full length, the longer ones are all
+ * reduced to that ceiling.
+ */
+export function fitTurnBudget(lengths, budget) {
+    if (lengths.reduce((sum, length) => sum + length, 0) <= budget)
+        return [...lengths];
+    let remaining = budget;
+    const ceilings = [...lengths];
+    const order = lengths.map((_, index) => index).sort((a, b) => lengths[a] - lengths[b]);
+    for (let position = 0; position < order.length; position += 1) {
+        const index = order[position];
+        const share = Math.floor(remaining / (order.length - position));
+        if (lengths[index] <= share) {
+            remaining -= lengths[index];
+            continue;
+        }
+        for (const rest of order.slice(position))
+            ceilings[rest] = share;
+        break;
+    }
+    return ceilings;
+}
+async function readBody(memoryRoot, target) {
+    if (!target.targetId)
+        return "";
+    try {
+        const file = await readClawChatMemoryFile(memoryRoot, target);
+        return file.exists ? (file.body ?? "").trim() : "";
+    }
+    catch {
+        return "";
+    }
+}
+function escapeTitle(value) {
+    return value.replace(/[\r\n]+/g, " ").trim();
+}
+/** The `## ClawChat Peer Memory` / `## ClawChat Group Memory` section, or null when there is no note to show. */
+export async function buildNoteMemorySection(params) {
+    const { memoryRoot, caps } = params;
+    // [title, body, per-note cap, read hint]
+    const entries = [];
+    let heading;
+    let preamble;
+    if (params.chatType === "group") {
+        heading = "## ClawChat Group Memory";
+        preamble = `${NOTE_MEMORY_PREAMBLE} ${GROUP_NOTE_MEMORY_PRIVACY}`;
+        const groupBody = await readBody(memoryRoot, { targetType: "group", targetId: params.chatId });
+        if (groupBody) {
+            entries.push([
+                `### This group (groups/${params.chatId}.md)`,
+                groupBody,
+                caps.group,
+                `clawchat_memory_read targetType=group targetId=${params.chatId}`,
+            ]);
+        }
+        const seen = new Set();
+        for (const speaker of params.speakers) {
+            const id = speaker.id;
+            if (!id || seen.has(id) || id === params.selfId || id === "system")
+                continue;
+            seen.add(id);
+            const body = await readBody(memoryRoot, { targetType: "user", targetId: id });
+            if (!body)
+                continue;
+            entries.push([
+                `### ${escapeTitle(speaker.name || id)} (users/${id}.md)`,
+                body,
+                caps.user,
+                `clawchat_memory_read targetType=user targetId=${id}`,
+            ]);
+        }
+    }
+    else {
+        heading = "## ClawChat Peer Memory";
+        preamble = NOTE_MEMORY_PREAMBLE;
+        if (params.senderIsOwner) {
+            const body = await readBody(memoryRoot, { targetType: "owner", targetId: "owner" });
+            if (body) {
+                entries.push(["### Your owner (owner.md)", body, caps.user, "clawchat_memory_read targetType=owner targetId=owner"]);
+            }
+        }
+        else {
+            const body = await readBody(memoryRoot, { targetType: "user", targetId: params.senderId });
+            if (body) {
+                entries.push([
+                    `### This person (users/${params.senderId}.md)`,
+                    body,
+                    caps.user,
+                    `clawchat_memory_read targetType=user targetId=${params.senderId}`,
+                ]);
+            }
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    const capped = entries.map(([, body, cap, hint]) => capNote(body, cap, hint));
+    const ceilings = fitTurnBudget(capped.map((text) => text.length), caps.turn);
+    const blocks = [heading, preamble];
+    entries.forEach(([title, body, cap, hint], index) => {
+        let text = capped[index];
+        const ceiling = ceilings[index];
+        if (text.length > ceiling)
+            text = capNote(body, Math.min(cap, ceiling), hint);
+        blocks.push(`${title}\n${text}`);
+    });
+    return blocks.join("\n\n");
+}

package/dist/src/profile-prompt.js

@@ -324,6 +324,8 @@ export function renderClawChatProfilePrompt(params) {
         if (participantSection)
             sections.push(participantSection);
     }
+    if (params.noteMemorySection)
+        sections.push(params.noteMemorySection);
     sections.push(params.turn.chatType === "group"
         ? renderGroupMessageMetadata(params.turn, params.groupMetadata)
         : renderDirectSenderMetadata(params.turn));

package/dist/src/reply-dispatcher.js

@@ -7,7 +7,7 @@ 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 { createReplyStream, streamableText } 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
@@ -345,7 +345,10 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     // 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;
+    // Direct chats only, same as Hermes. In a group the server's merged stream
+    // copy carries no @, and a receiver that dedupes by message_id keeps
+    // whichever copy lands first, so an @-only agent would never wake up.
+    const streamEnabled = account.streamReplies === true && !isGroupTarget;
     let replyStream = null;
     const failStream = (reason) => {
         replyStream?.fail(reason);
@@ -356,11 +359,19 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         replyStream = null;
         return id;
     };
+    // Latest host snapshot of the current assistant message, including any tail
+    // the add throttle held back, so a boundary can close the preview whole.
+    let streamPartialText = "";
+    // Texts already delivered as their own message at a message boundary; a
+    // final that only repeats one of them is not sent again.
+    const finalizedPreviewTexts = new Set();
     const onStreamPartial = (text) => {
         if (runDone || terminalReplySuppressed)
             return;
-        if (replyStream?.diverges(text))
-            failStream("superseded");
+        // A snapshot that no longer extends the preview without a message
+        // boundary is a host rewrite: the stream stops growing and the final
+        // replaces it in place (same id). It is never retracted.
+        streamPartialText = text;
         replyStream ??= createReplyStream({
             client,
             chatId: target.chatId,
@@ -556,6 +567,36 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             log,
         });
     };
+    // ----- Stream message boundary -----------------------------------------
+    //
+    // A new assistant message (after a tool call or a thinking block) means the
+    // previewed one is complete. Close it as its own message — `message.done` +
+    // `message.reply` under the same id — instead of letting the next snapshot
+    // supersede it, so text the recipient already saw stays. A preview still
+    // held back (never shown) is just dropped.
+    const finalizeStreamAtBoundary = async (reason) => {
+        if (!replyStream)
+            return;
+        if (!replyStream.isOpen()) {
+            replyStream = null;
+            streamPartialText = "";
+            return;
+        }
+        const decision = streamableText(streamPartialText);
+        const text = decision.kind === "ok"
+            ? decision.text
+            : decision.kind === "poisoned"
+                ? streamPartialText
+                : replyStream.shownText();
+        streamPartialText = "";
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw stream boundary reason=${reason} text_len=${text.length} to=${target.chatId}`);
+        const result = await sendStatic(text, [], [], { recordMessage: true });
+        if (result)
+            finalizedPreviewTexts.add(text.trim());
+        // Whatever sendStatic did (sent, suppressed as no-reply, skipped after a
+        // terminal tool send), the stream is closed now.
+        replyStream = null;
+    };
     // ----- Static send ------------------------------------------------------
     const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
         const messageMode = options.messageMode ?? "normal";
@@ -772,6 +813,13 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     failStream("no-reply");
                     return;
                 }
+                if (!replyStream?.isOpen() &&
+                    finalizedPreviewTexts.has(finalText.trim()) &&
+                    !richFragment &&
+                    finalUrls.length === 0) {
+                    log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final skipped: already delivered at a message boundary`);
+                    return;
+                }
                 const mediaFragments = await uploadMediaUrls(finalUrls);
                 const result = await sendStatic(finalText, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
                 if (result?.messageId)
@@ -796,16 +844,31 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     return;
                 const fallbackText = bufferedOutputText.trim();
                 const fallbackUrls = bufferedOutputUrls.slice();
-                if (!fallbackText && fallbackUrls.length === 0)
+                if (!fallbackText && fallbackUrls.length === 0) {
+                    // No final came, but a preview was shown: keep it as the reply
+                    // rather than retracting text the recipient already read.
+                    if (replyStream?.isOpen())
+                        await finalizeStreamAtBoundary("idle");
                     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");
+                // Safety net: nothing above claimed or closed an open stream (e.g. the
+                // finalize send threw). It must not linger open, and text already
+                // shown must not vanish: close it with what was shown (the server
+                // materializes that from message.done). Only a preview whose snapshot
+                // turned out to be a no-reply is retracted.
+                if (replyStream?.isOpen()) {
+                    if (streamableText(streamPartialText).kind === "poisoned")
+                        failStream("no-reply");
+                    else
+                        claimStreamMessageId(replyStream.shownText());
+                }
+                replyStream = null;
             }
         },
         onCleanup: () => {
@@ -840,13 +903,22 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                         reasoningText = reasoningText ? `${reasoningText}\n${trimmed}` : trimmed;
                 }
                 : undefined,
-            onToolStart: splitFullOutput
+            onToolStart: splitFullOutput || streamEnabled
                 ? async (payload) => {
+                    if (streamEnabled)
+                        await finalizeStreamAtBoundary("tool-start");
+                    if (!splitFullOutput)
+                        return;
                     if (consumeTerminalSend("tool-start"))
                         return;
                     await emitProcessSegment(formatToolStartSummary(payload));
                 }
                 : undefined,
+            onAssistantMessageStart: streamEnabled
+                ? async () => {
+                    await finalizeStreamAtBoundary("assistant-message-start");
+                }
+                : undefined,
             onToolResult: splitFullOutput
                 ? async (payload) => {
                     if (consumeTerminalSend("tool-result"))

package/dist/src/reply-stream.js

@@ -11,12 +11,13 @@
  * and the server materializes its merged reply from the stream. `finish`
  * therefore takes the final text, sends whatever tail of it the throttle held
  * back as one last add, and closes with the whole text. A final that does not
- * extend what was shown cannot be appended (§8.2) — the stream is failed and
- * the final goes out under its own id.
+ * extend what was shown cannot be appended (§8.2): `message.done` then closes
+ * with the shown text and the final reply, under the same id, replaces it in
+ * place, so text the recipient already saw never vanishes.
  *
- * or, when the reply turns out not to be sendable (no-reply token, run
- * aborted, nothing delivered): message.created(M) → … → message.failed(M),
- * which aborts the stream without materializing anything.
+ * or, when the preview must not stay (a no-reply, or the reply went out
+ * through a ClawChat tool instead): message.created(M) → … → message.failed(M),
+ * which retracts the preview — the recipient keeps nothing of it.
  *
  * Streaming frames get no ack (§8.5) and no server-side mention repair, so the
  * stream only ever carries plain text; mentions, media and rich fragments ride
@@ -184,23 +185,24 @@ export function createReplyStream(options) {
                 return null;
             }
             // Trailing whitespace a partial carried may be trimmed off the final.
-            if (!finalText.startsWith(sent.trimEnd())) {
-                fail("superseded");
-                return null;
-            }
-            if (finalText.length > sent.length && finalText.startsWith(sent)) {
+            const extendsShown = finalText.startsWith(sent.trimEnd());
+            if (extendsShown && finalText.length > sent.length && finalText.startsWith(sent)) {
                 // Past the throttle: this is the last frame before done.
                 sendAdd(finalText, now());
             }
+            // A final that rewrites the preview cannot be appended (§8.2), but the
+            // shown text must not vanish: close the stream with what was shown and
+            // let the final reply under this same id replace it in place.
+            const doneText = extendsShown ? finalText : sent;
             closed = true;
             const at = now();
             emit(EVENT.MESSAGE_DONE, {
                 message_id: messageId,
-                fragments: [{ kind: "text", text: finalText }],
+                fragments: [{ kind: "text", text: doneText }],
                 streaming: streamingState("done", at),
                 completed_at: at,
             });
-            options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}`);
+            options.log?.info?.(`${prefix} stream done msg=${messageId} text_len=${finalText.length}${extendsShown ? "" : " replaced_in_place=true"}`);
             return messageId;
         },
         fail,