@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/reply-dispatcher.ts

@@ -0,0 +1,555 @@
+import type { Fragment } from "./protocol-types.ts";
+import type { ClawlingChatClient } from "./ws-client.ts";
+import {
+  interactiveReplyToPresentation,
+  renderMessagePresentationFallbackText,
+  type MessagePresentation,
+  type MessagePresentationBlock,
+  type MessagePresentationButtonStyle,
+} 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 type { ChatType } from "./client.ts";
+import type { ResolvedOpenclawClawlingAccount } from "./config.ts";
+import { uploadOutboundMedia, type ClawlingMediaFragment } from "./media-runtime.ts";
+import {
+  sendOpenclawClawlingText,
+  type OutboundReplyCtx,
+  type SendResult,
+} from "./outbound.ts";
+import { isClawChatNoopResponseText } from "./profile-prompt.ts";
+import type { ClawChatStore } from "./storage.ts";
+import { consumeTerminalClawChatSend } from "./terminal-send.ts";
+import { openclawLlmContextDebug } from "./llm-context-debug.ts";
+
+export interface ReplyDispatcherOptions {
+  cfg: OpenClawConfig;
+  runtime: PluginRuntime;
+  account: ResolvedOpenclawClawlingAccount;
+  client: ClawlingChatClient;
+  /**
+   * New-protocol routing: `chatId` is the subject id, `chatType` is `"direct"`
+   * or `"group"`. Every outbound frame carries these as `chat_id` + `chat_type`.
+   */
+  target: { chatId: string; chatType: ChatType };
+  replyCtx?: OutboundReplyCtx;
+  /**
+   * The `message_id` from the inbound `message.send` envelope that triggered
+   * this reply run. Preserved for reply context compatibility.
+   */
+  inboundMessageId?: string;
+  terminalSendScopeId?: string;
+  /**
+   * Describes the inbound user message for reply preview compatibility.
+   */
+  inboundForFinalReply?: {
+    chatId?: string;
+    senderId: string;
+    senderNickName: string;
+    bodyText: string;
+  };
+  store?: Pick<
+    ClawChatStore,
+    "insertMessage" | "claimMessageOnce" | "markMessageAcknowledged" | "updateMessageByIdentity"
+  > | null;
+  log?: { info?: (m: string) => void; error?: (m: string) => void };
+}
+
+type TypedReplyDispatcherResult = ReturnType<
+  PluginRuntime["channel"]["reply"]["createReplyDispatcherWithTyping"]
+>;
+
+type ClawChatReplyOptions = TypedReplyDispatcherResult["replyOptions"] &
+  {
+    sourceReplyDeliveryMode: "automatic";
+    disableBlockStreaming: true;
+  };
+
+type RichAction = {
+  id: string;
+  label: string;
+  style?: MessagePresentationButtonStyle;
+  disabled?: boolean;
+  payload?: Record<string, unknown>;
+};
+
+type RichInteractionFragment = {
+  kind: "approval_request" | "action_card";
+  title?: string;
+  fallback_text: string;
+  state: "pending";
+  actions: RichAction[];
+};
+
+const GROUP_OWNER_ATTENTION_TITLE = "requires owner attention";
+
+function ownerAttentionText(groupId: string, fallbackText: string): string {
+  const body = fallbackText.trim();
+  return `ClawChat group ${groupId} ${GROUP_OWNER_ATTENTION_TITLE}.${body ? `\n\n${body}` : ""}`;
+}
+
+function normalizeReplyErrorText(error: unknown): string {
+  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: unknown): value is MessagePresentation {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      Array.isArray((value as { blocks?: unknown }).blocks),
+  );
+}
+
+function resolvePresentation(payload: ReplyPayload): MessagePresentation | undefined {
+  if (isMessagePresentation(payload.presentation)) return payload.presentation;
+  if (payload.interactive) return interactiveReplyToPresentation(payload.interactive);
+  return undefined;
+}
+
+function normalizeActionId(value: string | undefined, label: string, index: number): string {
+  const raw = value?.trim() || label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return raw.replace(/^-+|-+$/g, "") || `action-${index + 1}`;
+}
+
+function collectPresentationActions(blocks: MessagePresentationBlock[]): RichAction[] {
+  const actions: RichAction[] = [];
+  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: RichAction = {
+          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: RichAction[], presentation: MessagePresentation): boolean {
+  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: ReplyPayload): RichInteractionFragment | null {
+  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: ReplyPayload): string {
+  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: ReplyDispatcherOptions): {
+  dispatcher: TypedReplyDispatcherResult["dispatcher"];
+  replyOptions: ClawChatReplyOptions;
+  markDispatchIdle: TypedReplyDispatcherResult["markDispatchIdle"];
+} {
+  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" as const } : 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: string[]): Promise<ClawlingMediaFragment[]> {
+    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: string): boolean => {
+    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: "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}] clawchat-plugin-openclaw sqlite outbound claim failed`);
+      return null;
+    }
+  };
+  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}] clawchat-plugin-openclaw sqlite outbound insert failed; continuing`);
+    }
+  };
+  const recordOutboundAck = (kind: "message", messageId: string, result: SendResult | null) => {
+    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: string) => {
+    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: boolean) => {
+    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: string,
+    richFragment: Fragment | null = null,
+  ): Promise<void> => {
+    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: string,
+    mediaFragments: ClawlingMediaFragment[] = [],
+    richFragments: Fragment[] = [],
+    options: { recordMessage?: boolean } = {},
+  ): Promise<SendResult | null> => {
+    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: ReplyPayload, info?: { kind: "tool" | "block" | "final" }) => {
+      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 as unknown as Fragment,
+        );
+        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] as unknown as Fragment[]) : [],
+          { 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: unknown, info: { kind: string }) => {
+      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,
+  };
+}