@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/dist/src/reply-dispatcher.js

@@ -2,10 +2,8 @@ import { interactiveReplyToPresentation, renderMessagePresentationFallbackText,
 import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { openBufferedStreamingSession, mergeStreamingText, } from "./buffered-stream.js";
-import { emitFinalStreamReply } from "./client.js";
-import { textToFragments } from "./message-mapper.js";
 import { uploadOutboundMedia } from "./media-runtime.js";
-import { sendOpenclawClawlingText } from "./outbound.js";
+import { sendOpenclawClawlingText, } from "./outbound.js";
 import { sendStreamingFailure } from "./streaming.js";
 const CLIENT_SAFE_REPLY_FAILURE_TEXT = "OpenClaw could not complete this reply.";
 function normalizeReplyErrorText(error) {
@@ -119,7 +117,7 @@ function resolvePayloadText(payload) {
  * `message.reply` per deliver with text + media.
  */
 export function createOpenclawClawlingReplyDispatcher(options) {
-    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, inboundForFinalReply, log, } = options;
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, inboundForFinalReply, store, log, } = options;
     const routing = { chatId: target.chatId, chatType: target.chatType };
     const humanDelay = runtime.channel.reply.resolveHumanDelayConfig(cfg, account.userId);
     const streamingEnabled = account.replyMode === "stream" && !replyCtx;
@@ -153,16 +151,87 @@ export function createOpenclawClawlingReplyDispatcher(options) {
     let streamingClosed = false;
     let runFailed = false;
     let runDone = false;
+    let streamClaimAttempted = false;
     // `streamCreatedEmitted` is the authoritative guard: once a `message.created`
     // has been emitted for this dispatcher instance, never emit another — even
     // if `onReplyStart` fires again or a pre-onReplyStart `onPartialReply`
     // raced the lazy open path.
     let streamCreatedEmitted = false;
+    const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
+    const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
+    const claimOutbound = (eventType, messageId, text, raw) => {
+        if (!store || !messageId)
+            return null;
+        try {
+            return store.claimMessageOnce({
+                platform: "openclaw",
+                accountId: account.accountId,
+                kind: "message",
+                direction: "outbound",
+                eventType,
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw,
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound claim failed`);
+            return null;
+        }
+    };
+    const updateOutbound = (eventType, messageId, text, raw) => {
+        if (!store || !messageId)
+            return;
+        try {
+            store.updateMessageByIdentity({
+                accountId: account.accountId,
+                kind: "message",
+                direction: "outbound",
+                eventType,
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw,
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound update failed; continuing`);
+        }
+    };
+    const recordOutbound = (kind, messageId, text) => {
+        if (!store || !messageId)
+            return;
+        try {
+            store.insertMessage({
+                platform: "openclaw",
+                accountId: account.accountId,
+                kind,
+                direction: "outbound",
+                eventType: outboundEventType(),
+                chatId: target.chatId,
+                messageId,
+                text,
+                raw: outboundRaw(),
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat sqlite outbound insert failed; continuing`);
+        }
+    };
+    const recordThinkingIfLinked = (messageId) => {
+        const thinkingText = reasoningText.trim();
+        if (!thinkingText)
+            return;
+        recordOutbound("thinking", messageId, thinkingText);
+        reasoningText = "";
+    };
     const mintStreamingMessageId = () => `${account.userId}-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const mintStaticMessageId = () => `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const openSessionIfNeeded = () => {
-        if (!streamingEnabled || streamingSession || streamCreatedEmitted)
+        if (!streamingEnabled || streamingSession || streamCreatedEmitted || streamClaimAttempted)
             return;
-        streamCreatedEmitted = true;
+        streamClaimAttempted = true;
         // Mint a fresh agent-side message_id at `message.created` time. All
         // subsequent `message.add` / `message.done` / `message.reply` frames for
         // this stream reuse it. Once the stream finalizes (done or reply), this
@@ -171,6 +240,14 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         // `replyTo.msgId`; keeping the two distinct avoids the agent's reply
         // frames shadowing the user turn they answer.
         streamingMessageId = mintStreamingMessageId();
+        const claimed = claimOutbound("message.created", streamingMessageId, "", { target, replyCtx: replyCtx ?? null, mode: "stream" });
+        if (claimed !== true) {
+            streamCreatedEmitted = false;
+            streamingMessageId = "";
+            log?.[claimed === false ? "info" : "error"]?.(`[${account.accountId}] openclaw-clawchat stream outbound skipped reason=${claimed === false ? "duplicate" : "claim_unavailable"}`);
+            return;
+        }
+        streamCreatedEmitted = true;
         streamingSession = openBufferedStreamingSession({
             client,
             routing,
@@ -217,21 +294,36 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         log?.info?.(`[${account.accountId}] openclaw-clawchat streaming closed msg=${streamingMessageId} reason=${reason ?? "done"}`);
     };
     // ----- Static send ------------------------------------------------------
-    const sendStatic = async (text, mediaFragments = [], richFragments = []) => {
+    const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
         if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0)
-            return;
+            return null;
         log?.info?.(`[${account.accountId}] openclaw-clawchat sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
-        await sendOpenclawClawlingText({
+        const messageId = mintStaticMessageId();
+        const raw = { target, replyCtx: replyCtx ?? null, mode: "static" };
+        const claimed = options.recordMessage
+            ? claimOutbound(outboundEventType(), messageId, text, raw)
+            : true;
+        if (claimed === false) {
+            log?.info?.(`[${account.accountId}] openclaw-clawchat outbound duplicate skipped msg=${messageId}`);
+            return null;
+        }
+        if (claimed === null) {
+            log?.error?.(`[${account.accountId}] openclaw-clawchat outbound skipped msg=${messageId} reason=claim_unavailable`);
+            return null;
+        }
+        const result = await sendOpenclawClawlingText({
             client,
             account,
             to: target,
             text,
+            messageId,
             ...(replyCtx ? { replyCtx } : {}),
             ...(richFragments.length > 0 ? { richFragments } : {}),
             ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
             log,
         });
         log?.info?.(`[${account.accountId}] openclaw-clawchat send complete to=${target.chatId}`);
+        return result;
     };
     const logDetachedFailure = (action, error) => {
         log?.error?.(`[${account.accountId}] openclaw-clawchat ${action} failed: ${String(error)}`);
@@ -243,6 +335,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         if (finalEmitted)
             return;
         finalEmitted = true;
+        if (!streamingMessageId)
+            return;
         const mergedMedia = await uploadMediaUrls(accumulatedMediaUrls.slice());
         const mergedText = streamText.trim();
         if (!mergedText && finalRichFragments.length === 0 && mergedMedia.length === 0) {
@@ -250,28 +344,29 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             return;
         }
         log?.info?.(`[${account.accountId}] openclaw-clawchat emitting consolidated final (message.reply) msg=${streamingMessageId} text_len=${mergedText.length} media=${mergedMedia.length}`);
-        const bodyFragments = [
-            ...(mergedText ? textToFragments(mergedText) : []),
-            ...finalRichFragments,
-            // mediaFragments is the local wide shape; cast at SDK boundary as
-            // we do in outbound.ts.
-            ...mergedMedia,
-        ];
+        const finalReplyCtx = {
+            replyToMessageId: inboundMessageId ?? streamingMessageId,
+            replyPreviewChatId: inboundForFinalReply?.chatId ?? target.chatId,
+            replyPreviewSenderId: inboundForFinalReply?.senderId ?? target.chatId,
+            replyPreviewNickName: inboundForFinalReply?.senderNickName ?? inboundForFinalReply?.senderId ?? target.chatId,
+            replyPreviewText: inboundForFinalReply?.bodyText ?? "",
+        };
         // Streaming message_id must match the created/add/done frames so the
-        // backend can correlate the consolidated reply with the stream.
-        emitFinalStreamReply(client, {
+        // backend can correlate the consolidated reply with the stream. Use the
+        // ackable send path so disconnects queue the final user-visible answer.
+        await sendOpenclawClawlingText({
+            client,
+            account,
+            to: target,
+            text: mergedText,
             messageId: streamingMessageId,
-            routing,
-            replyTo: {
-                msgId: inboundMessageId ?? streamingMessageId,
-                previewId: inboundForFinalReply?.senderId ?? target.chatId,
-                nickName: inboundForFinalReply?.senderNickName ?? inboundForFinalReply?.senderId ?? target.chatId,
-                fragments: inboundForFinalReply?.bodyText
-                    ? [{ kind: "text", text: inboundForFinalReply.bodyText }]
-                    : [],
-            },
-            body: { fragments: bodyFragments },
+            replyCtx: finalReplyCtx,
+            ...(finalRichFragments.length > 0 ? { richFragments: finalRichFragments } : {}),
+            ...(mergedMedia.length > 0 ? { mediaFragments: mergedMedia } : {}),
+            log,
         });
+        updateOutbound("message.reply", streamingMessageId, mergedText, { target, replyCtx: replyCtx ?? null, mode: "stream-final" });
+        recordThinkingIfLinked(streamingMessageId);
     };
     const ingestFinalPayload = (payload, text, richFragment) => {
         if (richFragment && account.richInteractions) {
@@ -328,7 +423,10 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     await queueStreamSnapshot();
                 }
                 else {
-                    await sendStatic(text);
+                    reasoningText = mergeStreamingText(reasoningText, text);
+                    const result = await sendStatic(text, [], [], { recordMessage: true });
+                    if (result?.messageId)
+                        recordThinkingIfLinked(result.messageId);
                 }
                 return;
             }
@@ -338,9 +436,19 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 ingestFinalPayload(payload, text, richFragment && account.richInteractions ? richFragment : null);
                 // For streaming: consolidated final is emitted in onIdle after done.
                 // For static: emit immediately.
-                if (!streamingEnabled) {
+                if (streamingEnabled) {
+                    if (text.trim()) {
+                        await queueStreamSnapshot();
+                    }
+                    else if (richFragment || urls.length > 0) {
+                        openSessionIfNeeded();
+                    }
+                }
+                else {
                     const mediaFragments = await uploadMediaUrls(urls);
-                    await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : []);
+                    const result = await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
+                    if (result?.messageId)
+                        recordThinkingIfLinked(result.messageId);
                 }
                 return;
             }
@@ -352,14 +460,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                     const mediaFragments = await uploadMediaUrls(urls);
                     if (mediaFragments.length > 0) {
                         log?.info?.(`[${account.accountId}] openclaw-clawchat mid-stream media emitted as separate message (count=${mediaFragments.length})`);
-                        await sendOpenclawClawlingText({
-                            client,
-                            account,
-                            to: target,
-                            text: "",
-                            mediaFragments,
-                            log,
-                        });
+                        await sendStatic("", mediaFragments, [], { recordMessage: true });
                     }
                 }
             }
@@ -367,7 +468,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
                 const mediaFragments = await uploadMediaUrls(urls);
                 const richFragments = richFragment && account.richInteractions ? [richFragment] : [];
                 if (text.trim() || mediaFragments.length > 0 || richFragments.length > 0) {
-                    await sendStatic(text, mediaFragments, richFragments);
+                    await sendStatic(text, mediaFragments, richFragments, { recordMessage: true });
                 }
             }
         },
@@ -434,6 +535,8 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         dispatcher: base.dispatcher,
         replyOptions: {
             ...base.replyOptions,
+            sourceReplyDeliveryMode: "automatic",
+            ...(streamingEnabled ? { disableBlockStreaming: false } : {}),
             ...streamingHooks,
         },
         markDispatchIdle: base.markDispatchIdle,