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

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,
@@ -16,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;
@@ -52,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 };
 }
 
@@ -64,6 +70,12 @@ type StreamingReplyHooks = {
   onReasoningStream?: (payload: ReplyPayload) => Promise<void>;
 };
 
+type ClawChatReplyOptions = TypedReplyDispatcherResult["replyOptions"] &
+  StreamingReplyHooks & {
+    sourceReplyDeliveryMode: "automatic";
+    disableBlockStreaming?: boolean;
+  };
+
 type RichAction = {
   id: string;
   label: string;
@@ -195,7 +207,7 @@ function resolvePayloadText(payload: ReplyPayload): string {
  */
 export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOptions): {
   dispatcher: TypedReplyDispatcherResult["dispatcher"];
-  replyOptions: TypedReplyDispatcherResult["replyOptions"] & StreamingReplyHooks;
+  replyOptions: ClawChatReplyOptions;
   markDispatchIdle: TypedReplyDispatcherResult["markDispatchIdle"];
 } {
   const {
@@ -207,6 +219,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     replyCtx,
     inboundMessageId,
     inboundForFinalReply,
+    store,
     log,
   } = options;
   const routing: EnvelopeRouting = { chatId: target.chatId, chatType: target.chatType };
@@ -246,18 +259,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
@@ -266,6 +355,21 @@ 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,
@@ -318,16 +422,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 } : {}),
@@ -336,6 +455,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat send complete to=${target.chatId}`,
     );
+    return result;
   };
 
   const logDetachedFailure = (action: string, error: unknown) => {
@@ -351,6 +471,7 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
   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) {
@@ -362,29 +483,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?.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: ReplyPayload, text: string, richFragment: Fragment | null) => {
@@ -443,7 +570,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;
       }
@@ -458,13 +587,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;
       }
@@ -478,14 +615,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 {
@@ -493,7 +623,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 });
         }
       }
     },
@@ -563,6 +693,8 @@ export function createOpenclawClawlingReplyDispatcher(options: ReplyDispatcherOp
     dispatcher: base.dispatcher,
     replyOptions: {
       ...base.replyOptions,
+      sourceReplyDeliveryMode: "automatic",
+      ...(streamingEnabled ? { disableBlockStreaming: false } : {}),
       ...streamingHooks,
     },
     markDispatchIdle: base.markDispatchIdle,