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

package/src/reply-dispatcher.ts

@@ -1,4 +1,5 @@
-import type { ClawlingChatClient, Fragment } from "@newbase-clawchat/sdk";
+import type { Fragment } from "./protocol-types.ts";
+import type { ClawlingChatClient } from "./ws-client.ts";
 import {
   interactiveReplyToPresentation,
   renderMessagePresentationFallbackText,
@@ -8,6 +9,7 @@ import {
 } from "openclaw/plugin-sdk/interactive-runtime";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
 import type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import {
@@ -15,12 +17,16 @@ import {
   mergeStreamingText,
   type BufferedStreamSession,
 } from "./buffered-stream.ts";
-import { emitFinalStreamReply, type ChatType, type EnvelopeRouting } from "./client.ts";
+import type { ChatType, EnvelopeRouting } from "./client.ts";
 import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
-import { textToFragments } from "./message-mapper.ts";
 import { uploadOutboundMedia, type ClawlingMediaFragment } from "./media-runtime.ts";
-import { sendOpenclawClawlingText, type OutboundReplyCtx } from "./outbound.ts";
+import {
+  sendOpenclawClawlingText,
+  type OutboundReplyCtx,
+  type SendResult,
+} from "./outbound.ts";
 import { sendStreamingFailure } from "./streaming.ts";
+import type { ClawChatStore } from "./storage.ts";
 
 export interface ReplyDispatcherOptions {
   cfg: OpenClawConfig;
@@ -51,6 +57,7 @@ export interface ReplyDispatcherOptions {
     senderNickName: string;
     bodyText: string;
   };
+  store?: Pick<ClawChatStore, "insertMessage" | "claimMessageOnce" | "updateMessageByIdentity"> | null;
   log?: { info?: (m: string) => void; error?: (m: string) => void };
 }
 
@@ -63,6 +70,11 @@ type StreamingReplyHooks = {
   onReasoningStream?: (payload: ReplyPayload) => Promise<void>;
 };
 
+type ClawChatReplyOptions = TypedReplyDispatcherResult["replyOptions"] &
+  StreamingReplyHooks & {
+    sourceReplyDeliveryMode: "automatic";
+  };
+
 type RichAction = {
   id: string;
   label: string;
@@ -79,6 +91,8 @@ type RichInteractionFragment = {
   actions: RichAction[];
 };
 
+const CLIENT_SAFE_REPLY_FAILURE_TEXT = "OpenClaw could not complete this reply.";
+
 function normalizeReplyErrorText(error: unknown): string {
   const raw = String(error);
   const retryWrapped = raw.match(/^Error: Retry failed for delivery [^:]+:\s*(.+)$/s);
@@ -192,7 +206,7 @@ function resolvePayloadText(payload: ReplyPayload): string {
  */
 export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOptions): {
   dispatcher: TypedReplyDispatcherResult["dispatcher"];
-  replyOptions: TypedReplyDispatcherResult["replyOptions"] & StreamingReplyHooks;
+  replyOptions: ClawChatReplyOptions;
   markDispatchIdle: TypedReplyDispatcherResult["markDispatchIdle"];
 } {
   const {
@@ -204,6 +218,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     replyCtx,
     inboundMessageId,
     inboundForFinalReply,
+    store,
     log,
   } = options;
   const routing: EnvelopeRouting = { chatId: target.chatId, chatType: target.chatType };
@@ -243,18 +258,94 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   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: "message.created" | "message.send" | "message.reply",
+    messageId: string,
+    text: string,
+    raw: unknown,
+  ): true | false | null => {
+    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: "message.reply",
+    messageId: string,
+    text: string,
+    raw: unknown,
+  ) => {
+    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: "message" | "thinking", messageId: string, text: string) => {
+    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: string) => {
+    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) return;
-    streamCreatedEmitted = true;
+    if (!streamingEnabled || streamingSession || streamCreatedEmitted || streamClaimAttempted) return;
+    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
@@ -263,12 +354,27 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     // `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,
@@ -315,16 +421,31 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     text: string,
     mediaFragments: ClawlingMediaFragment[] = [],
     richFragments: Fragment[] = [],
-  ) => {
-    if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0) return;
+    options: { recordMessage?: boolean } = {},
+  ): Promise<SendResult | null> => {
+    if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0) 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 } : {}),
@@ -333,11 +454,23 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat send complete to=${target.chatId}`,
     );
+    return result;
+  };
+
+  const logDetachedFailure = (action: string, error: unknown) => {
+    log?.error?.(
+      `[${account.accountId}] openclaw-clawchat ${action} failed: ${String(error)}`,
+    );
+  };
+
+  const settleDetached = (action: string, promise: Promise<unknown>) => {
+    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) {
@@ -349,29 +482,35 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat emitting consolidated final (message.reply) msg=${streamingMessageId} text_len=${mergedText.length} media=${mergedMedia.length}`,
     );
-    const bodyFragments: Fragment[] = [
-      ...(mergedText ? textToFragments(mergedText) : []),
-      ...finalRichFragments,
-      // mediaFragments is the local wide shape; cast at SDK boundary as
-      // we do in outbound.ts.
-      ...(mergedMedia as Fragment[]),
-    ];
+    const finalReplyCtx: OutboundReplyCtx = {
+      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: ReplyPayload, text: string, richFragment: Fragment | null) => {
@@ -379,10 +518,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
       finalRichFragments.push(richFragment);
     }
     if (text) streamText = mergeStreamingText(streamText, text);
-    const urls = [
-      ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-      ...(payload.mediaUrls ?? []),
-    ].filter((u): u is string => Boolean(u));
+    const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
     for (const url of urls) {
       if (!accumulatedMediaUrls.includes(url)) accumulatedMediaUrls.push(url);
     }
@@ -422,10 +558,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     deliver: async (payload: ReplyPayload, info?: { kind: "tool" | "block" | "final" }) => {
       const richFragment = buildRichInteractionFragment(payload);
       const text = richFragment && account.richInteractions ? "" : resolvePayloadText(payload);
-      const urls = [
-        ...(payload.mediaUrl ? [payload.mediaUrl] : []),
-        ...(payload.mediaUrls ?? []),
-      ].filter((u): u is string => 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}`,
       );
@@ -436,7 +569,9 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
           reasoningText = mergeStreamingText(reasoningText, text);
           await queueStreamSnapshot();
         } else {
-          await sendStatic(text);
+          reasoningText = mergeStreamingText(reasoningText, text);
+          const result = await sendStatic(text, [], [], { recordMessage: true });
+          if (result?.messageId) recordThinkingIfLinked(result.messageId);
         }
         return;
       }
@@ -451,13 +586,21 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         );
         // 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(
+          const result = await sendStatic(
             text,
             mediaFragments,
             richFragment && account.richInteractions ? ([richFragment] as unknown as Fragment[]) : [],
+            { recordMessage: true },
           );
+          if (result?.messageId) recordThinkingIfLinked(result.messageId);
         }
         return;
       }
@@ -471,14 +614,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
             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 });
           }
         }
       } else {
@@ -486,7 +622,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         const richFragments =
           richFragment && account.richInteractions ? ([richFragment] as unknown as Fragment[]) : [];
         if (text.trim() || mediaFragments.length > 0 || richFragments.length > 0) {
-          await sendStatic(text, mediaFragments, richFragments);
+          await sendStatic(text, mediaFragments, richFragments, { recordMessage: true });
         }
       }
     },
@@ -496,24 +632,29 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
         `[${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) return;
       streamingClosed = true;
       if (!streamingMessageId) streamingMessageId = mintStreamingMessageId();
-      void sendStreamingFailure({
-        client,
-        routing,
-        messageId: streamingMessageId,
-        currentSequence: 0,
-        reason: errorText,
-      });
+      settleDetached(
+        "stream failure send",
+        sendStreamingFailure({
+          client,
+          routing,
+          messageId: streamingMessageId,
+          currentSequence: 0,
+          reason: CLIENT_SAFE_REPLY_FAILURE_TEXT,
+        }),
+      );
     },
     onIdle: async () => {
       if (runDone) return;
@@ -551,6 +692,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     dispatcher: base.dispatcher,
     replyOptions: {
       ...base.replyOptions,
+      sourceReplyDeliveryMode: "automatic",
       ...streamingHooks,
     },
     markDispatchIdle: base.markDispatchIdle,