@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.5.4

package/dist/src/reply-dispatcher.js

@@ -0,0 +1,440 @@
+import { interactiveReplyToPresentation, renderMessagePresentationFallbackText, } from "openclaw/plugin-sdk/interactive-runtime";
+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 { sendStreamingFailure } from "./streaming.js";
+function normalizeReplyErrorText(error) {
+    const raw = String(error);
+    const retryWrapped = raw.match(/^Error: Retry failed for delivery [^:]+:\s*(.+)$/s);
+    if (retryWrapped?.[1]?.trim())
+        return retryWrapped[1].trim();
+    const retryWrappedBare = raw.match(/^Retry failed for delivery [^:]+:\s*(.+)$/s);
+    if (retryWrappedBare?.[1]?.trim())
+        return retryWrappedBare[1].trim();
+    return raw;
+}
+function isMessagePresentation(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        Array.isArray(value.blocks));
+}
+function resolvePresentation(payload) {
+    if (isMessagePresentation(payload.presentation))
+        return payload.presentation;
+    if (payload.interactive)
+        return interactiveReplyToPresentation(payload.interactive);
+    return undefined;
+}
+function normalizeActionId(value, label, index) {
+    const raw = value?.trim() || label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    return raw.replace(/^-+|-+$/g, "") || `action-${index + 1}`;
+}
+function collectPresentationActions(blocks) {
+    const actions = [];
+    for (const block of blocks) {
+        if (block.type === "buttons") {
+            for (const button of block.buttons) {
+                const value = button.value?.trim();
+                const url = button.url?.trim();
+                const action = {
+                    id: normalizeActionId(value ?? url, button.label, actions.length),
+                    label: button.label,
+                    ...(button.style ? { style: button.style } : {}),
+                    ...(value || url ? { payload: { ...(value ? { value } : {}), ...(url ? { url } : {}) } } : {}),
+                };
+                actions.push(action);
+            }
+        }
+        if (block.type === "select") {
+            for (const option of block.options) {
+                actions.push({
+                    id: normalizeActionId(option.value, option.label, actions.length),
+                    label: option.label,
+                    style: "secondary",
+                    payload: { value: option.value },
+                });
+            }
+        }
+    }
+    return actions;
+}
+function looksLikeApproval(actions, presentation) {
+    if (presentation.tone === "warning" || presentation.tone === "danger")
+        return true;
+    const ids = new Set(actions.map((action) => action.id.toLowerCase()));
+    return ids.has("approve") || ids.has("deny") || ids.has("reject");
+}
+function buildRichInteractionFragment(payload) {
+    const presentation = resolvePresentation(payload);
+    if (!presentation)
+        return null;
+    const actions = collectPresentationActions(presentation.blocks);
+    if (actions.length === 0)
+        return null;
+    const fallbackText = renderMessagePresentationFallbackText({
+        presentation,
+        text: payload.text ?? null,
+    }).trim();
+    if (!fallbackText)
+        return null;
+    return {
+        kind: looksLikeApproval(actions, presentation) ? "approval_request" : "action_card",
+        ...(presentation.title?.trim() ? { title: presentation.title.trim() } : {}),
+        fallback_text: fallbackText,
+        state: "pending",
+        actions,
+    };
+}
+function resolvePayloadText(payload) {
+    const presentation = resolvePresentation(payload);
+    if (!presentation)
+        return payload.text ?? "";
+    return renderMessagePresentationFallbackText({ presentation, text: payload.text ?? null });
+}
+/**
+ * Reply dispatcher for openclaw-clawchat.
+ *
+ * Streaming mode (`account.replyMode === "stream"`, no replyCtx):
+ *   1. `onReplyStart` just resets accumulators. It does NOT open the session
+ *      yet — that would leave a ghost `message.created + done` bubble if the
+ *      run produces nothing (e.g., agent not configured, send-policy denied).
+ *   2. On first real content (deliver block/tool or partial/reasoning
+ *      snapshot), `queueStreamSnapshot` lazily opens the session, which emits
+ *      `message.created` plus the first `message.add`.
+ *   3. Subsequent snapshots/deltas emit `message.add` frames (chunked by
+ *      `stream.flushIntervalMs` + `stream.minChunkChars`).
+ *   4. On run end (`onIdle`), the session flushes pending buffer, emits
+ *      `message.done`, then the merged full text plus any accumulated
+ *      media is emitted as a separate `message.send` / `message.reply` —
+ *      mirroring the clawling-channel v1 pattern where streaming `agent`
+ *      events are followed by a consolidated `chat` final. Empty runs emit
+ *      nothing at all (no created/done/reply) — they only log a skip line.
+ *
+ * Static mode or replyCtx: bypass streaming and emit one `message.send` /
+ * `message.reply` per deliver with text + media.
+ */
+export function createOpenclawClawlingReplyDispatcher(options) {
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, inboundForFinalReply, 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;
+    const buildApiClient = () => {
+        if (!account.baseUrl || !account.token)
+            return null;
+        return createOpenclawClawlingApiClient({
+            baseUrl: account.baseUrl,
+            token: account.token,
+            userId: account.userId,
+        });
+    };
+    async function uploadMediaUrls(urls) {
+        if (urls.length === 0)
+            return [];
+        const apiClient = buildApiClient();
+        if (!apiClient) {
+            log?.info?.(`[${account.accountId}] openclaw-clawchat outbound media skipped: baseUrl not configured`);
+            return [];
+        }
+        return await uploadOutboundMedia(urls, { apiClient, runtime, log });
+    }
+    // ----- Streaming session state -----------------------------------------
+    let streamingSession = null;
+    let streamingMessageId = "";
+    let streamText = "";
+    let reasoningText = "";
+    const accumulatedMediaUrls = [];
+    const finalRichFragments = [];
+    let finalEmitted = false;
+    let streamingClosed = false;
+    let runFailed = false;
+    let runDone = 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 mintStreamingMessageId = () => `${account.userId}-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const openSessionIfNeeded = () => {
+        if (!streamingEnabled || streamingSession || streamCreatedEmitted)
+            return;
+        streamCreatedEmitted = 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
+        // id is retired — the next inbound turn spawns a new dispatcher instance
+        // which mints its own id. The inbound user message_id lives on
+        // `replyTo.msgId`; keeping the two distinct avoids the agent's reply
+        // frames shadowing the user turn they answer.
+        streamingMessageId = mintStreamingMessageId();
+        streamingSession = openBufferedStreamingSession({
+            client,
+            routing,
+            sender: {
+                id: account.userId,
+                type: target.chatType,
+                nick_name: account.userId,
+            },
+            messageId: streamingMessageId,
+            flushIntervalMs: account.stream.flushIntervalMs,
+            minChunkChars: account.stream.minChunkChars,
+            maxBufferChars: account.stream.maxBufferChars,
+        });
+        log?.info?.(`[${account.accountId}] openclaw-clawchat streaming opened msg=${streamingMessageId}`);
+    };
+    const buildCombinedStreamSnapshot = () => {
+        if (!reasoningText && !streamText)
+            return "";
+        if (!reasoningText)
+            return streamText;
+        if (!streamText)
+            return reasoningText;
+        return `${reasoningText}\n\n${streamText}`;
+    };
+    const queueStreamSnapshot = async () => {
+        openSessionIfNeeded();
+        if (!streamingSession)
+            return;
+        const combined = buildCombinedStreamSnapshot();
+        if (!combined)
+            return;
+        await streamingSession.queueSnapshot(combined);
+    };
+    const closeStreamingSession = async (reason, failReason) => {
+        if (!streamingSession || streamingClosed)
+            return;
+        streamingClosed = true;
+        if (reason === "fail") {
+            await streamingSession.fail(failReason);
+        }
+        else {
+            await streamingSession.done();
+        }
+        log?.info?.(`[${account.accountId}] openclaw-clawchat streaming closed msg=${streamingMessageId} reason=${reason ?? "done"}`);
+    };
+    // ----- Static send ------------------------------------------------------
+    const sendStatic = async (text, mediaFragments = [], richFragments = []) => {
+        if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0)
+            return;
+        log?.info?.(`[${account.accountId}] openclaw-clawchat sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
+        await sendOpenclawClawlingText({
+            client,
+            account,
+            to: target,
+            text,
+            ...(replyCtx ? { replyCtx } : {}),
+            ...(richFragments.length > 0 ? { richFragments } : {}),
+            ...(mediaFragments.length > 0 ? { mediaFragments } : {}),
+            log,
+        });
+        log?.info?.(`[${account.accountId}] openclaw-clawchat send complete to=${target.chatId}`);
+    };
+    const emitFinalConsolidatedMessage = async () => {
+        if (finalEmitted)
+            return;
+        finalEmitted = true;
+        const mergedMedia = await uploadMediaUrls(accumulatedMediaUrls.slice());
+        const mergedText = streamText.trim();
+        if (!mergedText && finalRichFragments.length === 0 && mergedMedia.length === 0) {
+            log?.info?.(`[${account.accountId}] openclaw-clawchat no merged final content; skip consolidated reply`);
+            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,
+        ];
+        // Streaming message_id must match the created/add/done frames so the
+        // backend can correlate the consolidated reply with the stream.
+        emitFinalStreamReply(client, {
+            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 },
+        });
+    };
+    const ingestFinalPayload = (payload, text, richFragment) => {
+        if (richFragment && account.richInteractions) {
+            finalRichFragments.push(richFragment);
+        }
+        if (text)
+            streamText = mergeStreamingText(streamText, text);
+        const urls = [
+            ...(payload.mediaUrl ? [payload.mediaUrl] : []),
+            ...(payload.mediaUrls ?? []),
+        ].filter((u) => Boolean(u));
+        for (const url of urls) {
+            if (!accumulatedMediaUrls.includes(url))
+                accumulatedMediaUrls.push(url);
+        }
+    };
+    const ingestBlockText = async (text) => {
+        if (!text)
+            return;
+        streamText = `${streamText}${text}`;
+        await queueStreamSnapshot();
+    };
+    // ----- Dispatcher -------------------------------------------------------
+    const base = runtime.channel.reply.createReplyDispatcherWithTyping({
+        humanDelay,
+        onReplyStart: async () => {
+            // Only clear transient accumulators the first time the run starts.
+            // If `onReplyStart` fires again during the same dispatcher instance
+            // (e.g. typing controller re-entry), we must NOT tear down the stream
+            // session — that would cause a second `message.created`.
+            //
+            // We deliberately do NOT open the streaming session here. Opening it
+            // eagerly would emit `message.created` even for runs that ultimately
+            // produce nothing (unknown agent, send-policy denied, etc.), leaving a
+            // ghost empty bubble. The session opens lazily via queueStreamSnapshot
+            // on the first real content.
+            if (!streamCreatedEmitted) {
+                streamText = "";
+                reasoningText = "";
+                accumulatedMediaUrls.length = 0;
+                finalRichFragments.length = 0;
+                finalEmitted = false;
+                streamingClosed = false;
+                runDone = false;
+            }
+        },
+        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));
+            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)
+                    return;
+                if (streamingEnabled) {
+                    reasoningText = mergeStreamingText(reasoningText, text);
+                    await queueStreamSnapshot();
+                }
+                else {
+                    await sendStatic(text);
+                }
+                return;
+            }
+            if (info?.kind === "tool" && !account.forwardToolCalls)
+                return;
+            if (info?.kind === "final") {
+                ingestFinalPayload(payload, text, richFragment && account.richInteractions ? richFragment : null);
+                // For streaming: consolidated final is emitted in onIdle after done.
+                // For static: emit immediately.
+                if (!streamingEnabled) {
+                    const mediaFragments = await uploadMediaUrls(urls);
+                    await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : []);
+                }
+                return;
+            }
+            // kind === "block" or "tool" — text during the run
+            if (streamingEnabled) {
+                if (text)
+                    await ingestBlockText(text);
+                if (urls.length > 0) {
+                    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,
+                        });
+                    }
+                }
+            }
+            else {
+                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);
+                }
+            }
+        },
+        onError: (error, info) => {
+            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);
+                return;
+            }
+            if (streamingClosed)
+                return;
+            streamingClosed = true;
+            if (!streamingMessageId)
+                streamingMessageId = mintStreamingMessageId();
+            void sendStreamingFailure({
+                client,
+                routing,
+                messageId: streamingMessageId,
+                currentSequence: 0,
+                reason: errorText,
+            });
+        },
+        onIdle: async () => {
+            if (runDone)
+                return;
+            runDone = true;
+            if (!streamingEnabled)
+                return;
+            if (runFailed)
+                return;
+            await closeStreamingSession("done");
+            await emitFinalConsolidatedMessage();
+        },
+    });
+    const streamingHooks = streamingEnabled
+        ? {
+            onPartialReply: async (payload) => {
+                if (!payload.text || payload.isReasoning)
+                    return;
+                // onPartialReply gives progressive snapshots of the current assistant
+                // message text (not deltas). Use mergeStreamingText so overlapping
+                // prefixes collapse into a single growing snapshot.
+                streamText = mergeStreamingText(streamText, payload.text);
+                await queueStreamSnapshot();
+            },
+            ...(account.forwardThinking
+                ? {
+                    onReasoningStream: async (payload) => {
+                        if (!payload.text)
+                            return;
+                        reasoningText = mergeStreamingText(reasoningText, payload.text);
+                        await queueStreamSnapshot();
+                    },
+                }
+                : {}),
+        }
+        : {};
+    return {
+        dispatcher: base.dispatcher,
+        replyOptions: {
+            ...base.replyOptions,
+            ...streamingHooks,
+        },
+        markDispatchIdle: base.markDispatchIdle,
+    };
+}