@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/dist/src/reply-dispatcher.js

@@ -0,0 +1,422 @@
+import { interactiveReplyToPresentation, renderMessagePresentationFallbackText, } from "openclaw/plugin-sdk/interactive-runtime";
+import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
+import { createOpenclawClawlingApiClient } from "./api-client.js";
+import { uploadOutboundMedia } from "./media-runtime.js";
+import { sendOpenclawClawlingText, } from "./outbound.js";
+import { isClawChatNoopResponseText } from "./profile-prompt.js";
+import { consumeTerminalClawChatSend } from "./terminal-send.js";
+import { openclawLlmContextDebug } from "./llm-context-debug.js";
+const GROUP_OWNER_ATTENTION_TITLE = "requires owner attention";
+function ownerAttentionText(groupId, fallbackText) {
+    const body = fallbackText.trim();
+    return `ClawChat group ${groupId} ${GROUP_OWNER_ATTENTION_TITLE}.${body ? `\n\n${body}` : ""}`;
+}
+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 clawchat-plugin-openclaw.
+ *
+ * The plugin intentionally forces complete-message delivery. It sets
+ * `disableBlockStreaming: true` in reply options so OpenClaw does not split
+ * deliver blocks for this channel. If the host still delivers non-final
+ * blocks, the dispatcher buffers or ignores them and only emits materialized
+ * `message.send` / `message.reply` frames for the final reply.
+ */
+export function createOpenclawClawlingReplyDispatcher(options) {
+    const { cfg, runtime, account, client, target, replyCtx, inboundMessageId, store, log, } = options;
+    const isGroupTarget = target.chatType === "group";
+    const ownerDirectTarget = () => {
+        const ownerUserId = account.ownerUserId?.trim();
+        return ownerUserId ? { chatId: ownerUserId, chatType: "direct" } : null;
+    };
+    const humanDelay = runtime.channel.reply.resolveHumanDelayConfig(cfg, account.userId);
+    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}] clawchat-plugin-openclaw outbound media skipped: baseUrl not configured`);
+            return [];
+        }
+        return await uploadOutboundMedia(urls, { apiClient, runtime, log });
+    }
+    // ----- Reply state ------------------------------------------------------
+    let reasoningText = "";
+    let runDone = false;
+    let typingActive = false;
+    let terminalReplySuppressed = false;
+    const outboundEventType = () => (replyCtx ? "message.reply" : "message.send");
+    const outboundRaw = () => ({ target, replyCtx: replyCtx ?? null });
+    const terminalSendScopeId = options.terminalSendScopeId ?? null;
+    const consumeTerminalSend = (reason) => {
+        if (terminalReplySuppressed)
+            return true;
+        if (!terminalSendScopeId)
+            return false;
+        const terminal = consumeTerminalClawChatSend({
+            accountId: account.accountId,
+            chatId: target.chatId,
+            scopeId: terminalSendScopeId,
+        });
+        if (!terminal)
+            return false;
+        terminalReplySuppressed = true;
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw suppressing ${reason} reply after terminal tool send msg=${terminal.messageId} to=${target.chatId}`);
+        return true;
+    };
+    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}] clawchat-plugin-openclaw sqlite outbound claim failed`);
+            return null;
+        }
+    };
+    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}] clawchat-plugin-openclaw sqlite outbound insert failed; continuing`);
+        }
+    };
+    const recordOutboundAck = (kind, messageId, result) => {
+        if (!store || !messageId || !result?.messageId)
+            return;
+        try {
+            store.markMessageAcknowledged?.({
+                accountId: account.accountId,
+                kind,
+                direction: "outbound",
+                messageId,
+                protocolMessageId: result.messageId,
+                ackedAt: result.acceptedAt ?? Date.now(),
+            });
+        }
+        catch {
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw sqlite outbound ack update failed`);
+        }
+    };
+    const recordThinkingIfLinked = (messageId) => {
+        const thinkingText = reasoningText.trim();
+        if (!thinkingText)
+            return;
+        recordOutbound("thinking", messageId, thinkingText);
+        reasoningText = "";
+    };
+    const mintStaticMessageId = () => `${account.userId}-msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const emitTyping = (isTyping) => {
+        if (!isTyping && !typingActive)
+            return;
+        try {
+            client.typing(target.chatId, isTyping);
+            typingActive = isTyping;
+        }
+        catch (error) {
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw typing update failed: ${String(error)}`);
+        }
+    };
+    const sendOwnerAttention = async (fallbackText, richFragment = null) => {
+        const ownerTarget = ownerDirectTarget();
+        if (!ownerTarget) {
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw group owner attention suppressed reason=missing_owner_user_id group=${target.chatId}`);
+            return;
+        }
+        await sendOpenclawClawlingText({
+            client,
+            account,
+            to: ownerTarget,
+            text: ownerAttentionText(target.chatId, fallbackText),
+            messageId: mintStaticMessageId(),
+            ...(richFragment ? { richFragments: [richFragment] } : {}),
+            log,
+        });
+    };
+    // ----- Static send ------------------------------------------------------
+    const sendStatic = async (text, mediaFragments = [], richFragments = [], options = {}) => {
+        if (isClawChatNoopResponseText(text) &&
+            mediaFragments.length === 0 &&
+            richFragments.length === 0) {
+            log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw outbound suppressed: no-reply token`);
+            openclawLlmContextDebug.writeSnapshot({
+                visibility: "host_event",
+                trace: {
+                    messageId: inboundMessageId ?? "unknown",
+                    chatId: target.chatId,
+                    chatType: target.chatType,
+                },
+                input: { injectedPrompt: "", eventText: "" },
+                output: {
+                    rawModelOutput: text,
+                    finalAssistantText: text,
+                    adapterFilteredText: "",
+                    outboundClawChatMessage: null,
+                    suppressed: true,
+                    suppressionReason: "no-reply token",
+                },
+            });
+            return null;
+        }
+        if (!text.trim() && mediaFragments.length === 0 && richFragments.length === 0)
+            return null;
+        if (consumeTerminalSend("static"))
+            return null;
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw sending static text_len=${text.length} media=${mediaFragments.length} rich=${richFragments.length} to=${target.chatId}`);
+        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}] clawchat-plugin-openclaw outbound duplicate skipped msg=${messageId}`);
+            return null;
+        }
+        if (claimed === null) {
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw 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,
+        });
+        recordOutboundAck("message", messageId, result);
+        log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw send complete to=${target.chatId}`);
+        openclawLlmContextDebug.writeSnapshot({
+            visibility: "host_event",
+            trace: {
+                messageId,
+                chatId: target.chatId,
+                chatType: target.chatType,
+            },
+            input: { injectedPrompt: "", eventText: "" },
+            output: {
+                rawModelOutput: text,
+                finalAssistantText: text,
+                adapterFilteredText: text,
+                outboundClawChatMessage: {
+                    messageId: result?.messageId ?? messageId,
+                    chatId: target.chatId,
+                    chatType: target.chatType,
+                },
+                suppressed: false,
+                suppressionReason: null,
+            },
+        });
+        return result;
+    };
+    // ----- Dispatcher -------------------------------------------------------
+    const base = runtime.channel.reply.createReplyDispatcherWithTyping({
+        humanDelay,
+        onReplyStart: async () => {
+            emitTyping(true);
+            reasoningText = "";
+            runDone = false;
+        },
+        deliver: async (payload, info) => {
+            if (consumeTerminalSend(info?.kind ?? "unknown"))
+                return;
+            const richFragment = buildRichInteractionFragment(payload);
+            const text = richFragment && account.richInteractions ? "" : resolvePayloadText(payload);
+            const urls = resolveOutboundMediaUrls(payload).filter(Boolean);
+            log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw deliver kind=${info?.kind ?? "unknown"} text_len=${text.length} media_urls=${urls.length} reasoning=${payload.isReasoning === true}`);
+            if (isGroupTarget && richFragment) {
+                if (info?.kind !== "final")
+                    return;
+                await sendOwnerAttention(resolvePayloadText(payload), richFragment);
+                return;
+            }
+            if (payload.isReasoning) {
+                if (isGroupTarget || !account.forwardThinking)
+                    return;
+                reasoningText = text;
+                return;
+            }
+            if (info?.kind === "tool")
+                return;
+            if (info?.kind === "final") {
+                if (isClawChatNoopResponseText(text) && !richFragment && urls.length === 0) {
+                    log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw final suppressed: no-reply token`);
+                    openclawLlmContextDebug.writeSnapshot({
+                        visibility: "host_event",
+                        trace: {
+                            messageId: inboundMessageId ?? "unknown",
+                            chatId: target.chatId,
+                            chatType: target.chatType,
+                        },
+                        input: { injectedPrompt: "", eventText: "" },
+                        output: {
+                            rawModelOutput: text,
+                            finalAssistantText: text,
+                            adapterFilteredText: "",
+                            outboundClawChatMessage: null,
+                            suppressed: true,
+                            suppressionReason: "no-reply token",
+                        },
+                    });
+                    return;
+                }
+                const mediaFragments = await uploadMediaUrls(urls);
+                const result = await sendStatic(text, mediaFragments, richFragment && account.richInteractions ? [richFragment] : [], { recordMessage: true });
+                if (result?.messageId)
+                    recordThinkingIfLinked(result.messageId);
+                return;
+            }
+            // kind === "block" or unknown: OpenClaw may still call this path while
+            // the model is producing output. ClawChat gets only the final materialized
+            // reply.
+        },
+        onError: (error, info) => {
+            const errorText = normalizeReplyErrorText(error);
+            log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw ${info.kind} reply failed: ${errorText}`);
+            if (isGroupTarget) {
+                log?.error?.(`[${account.accountId}] clawchat-plugin-openclaw group runtime failure suppressed from ClawChat clients group=${target.chatId}`);
+                return;
+            }
+        },
+        onIdle: async () => {
+            emitTyping(false);
+            if (runDone)
+                return;
+            runDone = true;
+        },
+        onCleanup: () => {
+            emitTyping(false);
+        },
+    });
+    return {
+        dispatcher: base.dispatcher,
+        replyOptions: {
+            ...base.replyOptions,
+            sourceReplyDeliveryMode: "automatic",
+            disableBlockStreaming: true,
+        },
+        markDispatchIdle: base.markDispatchIdle,
+    };
+}