@newbase-clawchat/openclaw-clawchat 2026.5.4 → 2026.5.12-13

package/dist/src/reply-dispatcher.js

@@ -1,11 +1,11 @@
 import { interactiveReplyToPresentation, renderMessagePresentationFallbackText, } from "openclaw/plugin-sdk/interactive-runtime";
+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) {
     const raw = String(error);
     const retryWrapped = raw.match(/^Error: Retry failed for delivery [^:]+:\s*(.+)$/s);
@@ -117,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;
@@ -151,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
@@ -169,12 +240,20 @@ 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,
             sender: {
                 id: account.userId,
-                type: target.chatType,
+                type: "direct",
                 nick_name: account.userId,
             },
             messageId: streamingMessageId,
@@ -215,26 +294,49 @@ 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)}`);
+    };
+    const settleDetached = (action, promise) => {
+        void promise.catch((error) => logDetachedFailure(action, error));
     };
     const emitFinalConsolidatedMessage = async () => {
         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) {
@@ -242,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?.chatId ?? 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) {
@@ -271,10 +374,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         }
         if (text)
             streamText = mergeStreamingText(streamText, text);
-        const urls = [
-            ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-            ...(payload.mediaUrls ?? []),
-        ].filter((u) => Boolean(u));
+        const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
         for (const url of urls) {
             if (!accumulatedMediaUrls.includes(url))
                 accumulatedMediaUrls.push(url);
@@ -313,10 +413,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         deliver: async (payload, info) => {
             const richFragment = buildRichInteractionFragment(payload);
             const text = richFragment && account.richInteractions ? "" : resolvePayloadText(payload);
-            const urls = [
-                ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-                ...(payload.mediaUrls ?? []),
-            ].filter((u) => Boolean(u));
+            const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
             log?.info?.(`[${account.accountId}] openclaw-clawchat deliver kind=${info?.kind ?? "unknown"} text_len=${text.length} media_urls=${urls.length} reasoning=${payload.isReasoning === true}`);
             if (payload.isReasoning) {
                 if (!account.forwardThinking)
@@ -326,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;
             }
@@ -336,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;
             }
@@ -350,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 });
                     }
                 }
             }
@@ -365,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 });
                 }
             }
         },
@@ -373,12 +476,11 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             const errorText = normalizeReplyErrorText(error);
             log?.error?.(`[${account.accountId}] openclaw-clawchat ${info.kind} reply failed: ${errorText}`);
             if (!streamingEnabled) {
-                void sendStatic(errorText);
                 return;
             }
             runFailed = true;
             if (streamingSession && !streamingClosed) {
-                void closeStreamingSession("fail", errorText);
+                settleDetached("stream failure close", closeStreamingSession("fail", CLIENT_SAFE_REPLY_FAILURE_TEXT));
                 return;
             }
             if (streamingClosed)
@@ -386,13 +488,13 @@ export function createOpenclawClawlingReplyDispatcher(options) {
             streamingClosed = true;
             if (!streamingMessageId)
                 streamingMessageId = mintStreamingMessageId();
-            void sendStreamingFailure({
+            settleDetached("stream failure send", sendStreamingFailure({
                 client,
                 routing,
                 messageId: streamingMessageId,
                 currentSequence: 0,
-                reason: errorText,
-            });
+                reason: CLIENT_SAFE_REPLY_FAILURE_TEXT,
+            }));
         },
         onIdle: async () => {
             if (runDone)
@@ -433,6 +535,7 @@ export function createOpenclawClawlingReplyDispatcher(options) {
         dispatcher: base.dispatcher,
         replyOptions: {
             ...base.replyOptions,
+            sourceReplyDeliveryMode: "automatic",
             ...streamingHooks,
         },
         markDispatchIdle: base.markDispatchIdle,